112 | 136M | } clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONDumper, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 2.48k | 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.48k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 151 | 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 | 2 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 58 | 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 | 151 | } | 85 | 2.33k | } 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 | 46 | } | 102 | 46 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 2.28k | 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.28k | } | 112 | 2.28k | } |
clang::StmtVisitorBase<llvm::make_const_ptr, clang::ASTDumper, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 33.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 | 33.3k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 1.83k | 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 | 326 | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 172 | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 2 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 2 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 870 | 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 | 50 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 12 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 1 | 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 | 5 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 174 | 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 | 76 | 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 | 1.83k | } | 85 | 31.5k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 1.13k | switch (UnOp->getOpcode()) { | 87 | 731 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 3 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 139 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 8 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 84 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 69 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 15 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 65 | 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 | 1.13k | } | 102 | 1.13k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 30.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 | 30.4k | } | 112 | 30.4k | } |
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 | 0 | } | 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 | 5 | } | 102 | 5 | } | 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 | 24.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 | 24.7k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 4.66k | 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 | 581 | 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 | 8 | 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.71k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 28 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 0 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 0 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 2.32k | 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 | 8 | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 12 | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 0 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 4.66k | } | 85 | 20.1k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 662 | switch (UnOp->getOpcode()) { | 87 | 326 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 0 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 218 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 0 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 0 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 118 | 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 | 662 | } | 102 | 662 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 19.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 | 19.4k | } | 112 | 19.4k | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 10.9M | 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.9M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 980k | switch (BinOp->getOpcode()) { | 49 | 295 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 208 | 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 | 914k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 5.38k | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 1.01k | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 152 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 37.1k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 2.83k | case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator); | 78 | 345 | case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator); | 79 | 127 | case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator); | 80 | 681 | case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator); | 81 | 9.48k | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 1.48k | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 6.72k | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 980k | } | 85 | 10.0M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 172k | switch (UnOp->getOpcode()) { | 87 | 0 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 0 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 53.6k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 7.04k | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 0 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 111k | 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 | 132 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 111 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 264 | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 172k | } | 102 | 172k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 9.83M | 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.83M | } | 112 | 9.83M | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::PointerExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 2.08M | 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.08M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 67.6k | 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 | 52.1k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 10.2k | 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 | 5.00k | 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 | 99 | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 20 | 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 | 97 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 67.6k | } | 85 | 2.01M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 55.6k | switch (UnOp->getOpcode()) { | 87 | 3.38k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 26 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 32 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 23 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 52.1k | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 0 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 19 | 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 | 55.6k | } | 102 | 55.6k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 1.96M | 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.96M | } | 112 | 1.96M | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::MemberPointerExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 3.79k | 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.79k | 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 | 0 | } | 85 | 3.79k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 1.65k | 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.65k | 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.65k | } | 102 | 1.65k | } | 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 | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IntExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 27.0M | 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.0M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 3.21M | switch (BinOp->getOpcode()) { | 49 | 2 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 78.2k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 97.9k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 9.79k | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 736k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 601k | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 236k | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 6.88k | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 306k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 350k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 24.0k | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 48.4k | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 202k | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 81.2k | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 0 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 47.1k | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 6.41k | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 56.7k | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 174k | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 44.4k | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 95.0k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 306 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 201 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 160 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 1.00k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 474 | case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator); | 78 | 143 | case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator); | 79 | 136 | case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator); | 80 | 614 | case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator); | 81 | 549 | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 201 | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 2.29k | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 3.21M | } | 85 | 23.8M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 1.11M | switch (UnOp->getOpcode()) { | 87 | 2.22k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 135 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 311 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 1.89k | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 0 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 0 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 123 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 901k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 16.8k | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 189k | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 6 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 9 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 287 | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 1.11M | } | 102 | 1.11M | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 22.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 | 22.6M | } | 112 | 22.6M | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ComplexExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 5.46k | 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.46k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 1.74k | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 338 | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 220 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 0 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 669 | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 248 | 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 | 253 | 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 | 7 | 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 | 1.74k | } | 85 | 3.71k | } 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 | 64 | } | 102 | 64 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 3.65k | 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.65k | } | 112 | 3.65k | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::FloatExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 302k | 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 | 302k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 58.0k | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 5.28k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 7.35k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 0 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 12.9k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 5.23k | 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 | 22.9k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 1.06k | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 1.04k | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 0 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 1.11k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 1.06k | 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 | 18 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 58.0k | } | 85 | 244k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 3.18k | switch (UnOp->getOpcode()) { | 87 | 61 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 12 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 8 | 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 | 27 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 2.65k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 0 | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 0 | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 43 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 29 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 349 | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 3.18k | } | 102 | 3.18k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 241k | 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 | 241k | } | 112 | 241k | } |
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 | 1.27k | } | 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 | 282 | } | 102 | 282 | } | 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 | 120k | 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 | 120k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 714 | 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 | 664 | 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 | 26 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 714 | } | 85 | 120k | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 120k | 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 | 120k | } | 112 | 120k | } |
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 | 0 | } | 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 | 0 | } | 102 | 0 | } | 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 | 12.4k | 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 | 12.4k | 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 | 0 | } | 85 | 12.4k | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 12.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 | 12.4k | } | 112 | 12.4k | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AtomicExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 433 | 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 | 433 | 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 | 0 | } | 85 | 433 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 433 | 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 | 433 | } | 112 | 433 | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VectorExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 1.85M | 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.85M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 527k | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 20.9k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 3.18k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 173 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 26.3k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 22.3k | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 362 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 164 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 3.78k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 6.89k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 3.75k | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 3.75k | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 7.73k | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 229 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 0 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 19.9k | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 9.09k | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 13.0k | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 55 | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 43 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 384k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 86 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 85 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 60 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 104 | 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 | 527k | } | 85 | 1.32M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 22.4k | switch (UnOp->getOpcode()) { | 87 | 0 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 0 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 1 | 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 | 3.36k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 15.6k | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 21 | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 0 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 0 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 3.41k | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 22.4k | } | 102 | 22.4k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 1.30M | 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.30M | } | 112 | 1.30M | } |
ExprConstant.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 6.16k | 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.16k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 90 | 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 | 90 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 90 | } | 85 | 6.07k | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 6.07k | 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.07k | } | 112 | 6.07k | } |
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::ByteCodeEmitter>, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 12 | 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 | 12 | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 4 | 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 | 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 | 4 | } | 85 | 8 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 8 | 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 | 8 | } | 112 | 8 | } |
clang::StmtVisitorBase<llvm::make_const_ptr, clang::interp::ByteCodeExprGen<clang::interp::EvalEmitter>, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 31 | 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 | 31 | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 11 | 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 | 6 | 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 | } | 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 | 0 | } | 102 | 0 | } | 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 | } |
clang::StmtVisitorBase<llvm::make_const_ptr, clang::JSONNodeDumper, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 2.48k | 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.48k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 151 | 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 | 2 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 58 | 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 | 151 | } | 85 | 2.33k | } 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 | 46 | } | 102 | 46 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 2.28k | 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.28k | } | 112 | 2.28k | } |
StmtPrinter.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::StmtPrinter, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 338k | 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 | 338k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 16.6k | switch (BinOp->getOpcode()) { | 49 | 8 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 66 | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 8 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 5 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 1.83k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 684 | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 44 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 0 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 7.22k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 1.20k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 8 | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 12 | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 355 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 299 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 0 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 1 | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 20 | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 8 | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 220 | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 625 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 3.40k | 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 | 460 | 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 | 85 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 16.6k | } | 85 | 321k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 39.4k | switch (UnOp->getOpcode()) { | 87 | 2.10k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 4 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 7.32k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 18 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 1.18k | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 660 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 11 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 132 | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 0 | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 28.0k | 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 | 39.4k | } | 102 | 39.4k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 282k | 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 | 282k | } | 112 | 282k | } |
StmtProfile.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::StmtProfiler, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 18.8M | 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.8M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 1.68M | switch (BinOp->getOpcode()) { | 49 | 28.6k | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 34 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 17.8k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 63.8k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 17.4k | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 40.4k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 31.1k | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 14.3k | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 2.73k | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 4.52k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 3.84k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 16.9k | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 59.8k | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 97.8k | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 35.8k | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 6 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 6.98k | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 583 | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 7.54k | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 980k | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 195k | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 41.6k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 214 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 264 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 114 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 4.05k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 1.42k | case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator); | 78 | 100 | case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator); | 79 | 110 | case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator); | 80 | 332 | case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator); | 81 | 1.50k | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 49 | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 7.31k | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 1.68M | } | 85 | 17.1M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 761k | switch (UnOp->getOpcode()) { | 87 | 1.23k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 25 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 12.7k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 3.01k | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 5.33k | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 32.1k | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 125 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 32.1k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 2.89k | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 670k | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 0 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 2 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 1.53k | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 5 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 761k | } | 102 | 761k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 16.4M | 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.4M | } | 112 | 16.4M | } |
clang::StmtVisitorBase<llvm::make_const_ptr, clang::TextNodeDumper, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 33.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 | 33.3k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 1.83k | 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 | 326 | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 172 | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 2 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 2 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 870 | 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 | 50 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 12 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 1 | 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 | 5 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 174 | 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 | 76 | 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 | 1.83k | } | 85 | 31.5k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 1.13k | switch (UnOp->getOpcode()) { | 87 | 731 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 3 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 139 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 8 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 84 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 69 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 15 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 65 | 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 | 1.13k | } | 102 | 1.13k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 30.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 | 30.4k | } | 112 | 30.4k | } |
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtReader, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 12.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 | 12.2M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 815k | 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 | 42.9k | 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 | 772k | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 815k | } | 85 | 11.3M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 342k | 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 | 342k | 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 | 342k | } | 102 | 342k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 11.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 | 11.0M | } | 112 | 11.0M | } |
clang::StmtVisitorBase<std::__1::add_pointer, clang::ASTStmtWriter, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 4.95M | 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.95M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 358k | switch (BinOp->getOpcode()) { | 49 | 232 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 34 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 20.2k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 15.7k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 1.84k | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 53.6k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 37.1k | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 14.6k | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 2.63k | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 17.9k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 10.6k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 8.25k | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 2.54k | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 10.1k | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 3.64k | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 3 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 6.38k | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 706 | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 7.00k | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 26.6k | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 6.09k | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 94.5k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 431 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 426 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 114 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 9.87k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 1.80k | case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator); | 78 | 100 | case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator); | 79 | 110 | case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator); | 80 | 351 | case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator); | 81 | 1.51k | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 176 | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 3.34k | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 358k | } | 85 | 4.59M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 116k | switch (UnOp->getOpcode()) { | 87 | 4.30k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 97 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 19.6k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 3.25k | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 5.20k | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 20.1k | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 47 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 30.8k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 3.07k | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 28.5k | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 0 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 2 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 1.56k | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 5 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 116k | } | 102 | 116k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 4.47M | 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.47M | } | 112 | 4.47M | } |
AnalysisBasedWarnings.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::ContainsReference, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 451 | 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 | 451 | 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 | 32 | } | 85 | 419 | } 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 | 8 | } | 102 | 8 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 411 | 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 | 411 | } | 112 | 411 | } |
Sema.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeferredDiagnosticsEmitter, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 833k | 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 | 833k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 56.3k | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 1.19k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 271 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 0 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 5.66k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 230 | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 10 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 38 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 11.0k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 252 | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 228 | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 400 | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 179 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 9 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 0 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 80 | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 38 | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 10 | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 198 | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 108 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 17.3k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 66 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 28 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 0 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 18.4k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 364 | 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 | 14 | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 10 | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 100 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 56.3k | } | 85 | 777k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 32.2k | switch (UnOp->getOpcode()) { | 87 | 5.37k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 152 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 9.44k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 24 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 216 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 16.1k | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 16 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 658 | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 46 | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 78 | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 32 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 32 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 9 | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 32.2k | } | 102 | 32.2k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 745k | 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 | 745k | } | 112 | 745k | } |
SemaChecking.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::SequenceChecker, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 55.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 | 55.6M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 5.30M | switch (BinOp->getOpcode()) { | 49 | 386 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 298 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 194k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 458k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 9.36k | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 1.12M | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 1.07M | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 48.2k | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 16.1k | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 204k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 181k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 21.1k | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 27.5k | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 108k | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 35.5k | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 337 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 57.8k | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 15.5k | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 41.0k | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 146k | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 44.8k | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 1.41M | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 2.60k | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 2.30k | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 371 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 36.6k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 4.47k | case BO_SubAssign: DISPATCH(BinSubAssign, CompoundAssignOperator); | 78 | 634 | case BO_ShlAssign: DISPATCH(BinShlAssign, CompoundAssignOperator); | 79 | 308 | case BO_ShrAssign: DISPATCH(BinShrAssign, CompoundAssignOperator); | 80 | 1.37k | case BO_AndAssign: DISPATCH(BinAndAssign, CompoundAssignOperator); | 81 | 10.0k | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 1.73k | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 9.63k | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 5.30M | } | 85 | 50.3M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 854k | switch (UnOp->getOpcode()) { | 87 | 54.9k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 820 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 169k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 10.7k | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 81.7k | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 134k | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 381 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 181k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 28.2k | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 155k | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 167 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 160 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 35.9k | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 854k | } | 102 | 854k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 49.5M | 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 | 49.5M | } | 112 | 49.5M | } |
SemaChecking.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindCaptureVisitor, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 148 | 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 | 148 | 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 | 2 | } | 85 | 146 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 146 | 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 | 146 | } | 112 | 146 | } |
SemaDecl.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::SelfReferenceChecker, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 1.29M | 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.29M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 139k | switch (BinOp->getOpcode()) { | 49 | 29 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 5 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 30.4k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 33.9k | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 80 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 15.6k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 12.0k | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 9.96k | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 43 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 13.2k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 54 | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 6.41k | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 575 | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 7.64k | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 38 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 85 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 507 | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 1.73k | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 1.02k | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 5.81k | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 111 | 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 | 226 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 139k | } | 85 | 1.15M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 45.2k | switch (UnOp->getOpcode()) { | 87 | 45 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 2 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 43 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 7 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 11.3k | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 7.84k | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 11 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 19.0k | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 3.65k | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 3.20k | case UO_LNot: DISPATCH(UnaryLNot, UnaryOperator); | 97 | 9 | case UO_Real: DISPATCH(UnaryReal, UnaryOperator); | 98 | 9 | case UO_Imag: DISPATCH(UnaryImag, UnaryOperator); | 99 | 0 | case UO_Extension: DISPATCH(UnaryExtension, UnaryOperator); | 100 | 0 | case UO_Coawait: DISPATCH(UnaryCoawait, UnaryOperator); | 101 | 45.2k | } | 102 | 45.2k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 1.11M | 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.11M | } | 112 | 1.11M | } |
SemaDeclCXX.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::UninitializedFieldVisitor, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 61.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 | 61.3k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 1.88k | 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 | 9 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 0 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 1.77k | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 6 | 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 | 18 | 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 | 1.88k | } | 85 | 59.4k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 189 | switch (UnOp->getOpcode()) { | 87 | 19 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 0 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 18 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 0 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 118 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 22 | 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 | 189 | } | 102 | 189 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 59.2k | 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 | 59.2k | } | 112 | 59.2k | } |
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 | 818 | 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 | 751 | 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 | 818 | } | 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 | 15 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 0 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 0 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 50 | 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 | 65 | } | 102 | 65 | } | 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)::EvaluatedExprMarker, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 167k | 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 | 167k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 1.57k | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 24 | 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 | 2 | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 100 | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 0 | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 1.41k | 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 | 1.57k | } | 85 | 166k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 49 | 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 | 20 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 12 | 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 | 2 | 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 | 49 | } | 102 | 49 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 165k | 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 | 165k | } | 112 | 165k | } |
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 | 0 | } | 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 | 0 | } | 102 | 0 | } | 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)::RebuildUnknownAnyExpr, clang::ActionResult<clang::Expr*, true> >::Visit(clang::Stmt*) Line | Count | Source | 43 | 789 | 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 | 789 | 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 | 0 | } | 85 | 789 | } 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 | 4 | } | 102 | 4 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 785 | 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 | 785 | } | 112 | 785 | } |
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 | 3 | } | 85 | 1.77k | } 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 | 4 | } | 102 | 4 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 1.77k | 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.77k | } | 112 | 1.77k | } |
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::AllocatorChecker, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 340 | 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 | 340 | 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 | 0 | } | 85 | 340 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 340 | 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 | 340 | } | 112 | 340 | } |
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::(anonymous namespace)::LoopCounterRefChecker, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 352k | 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 | 352k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 829 | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 99 | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 92 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 0 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 474 | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 157 | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 0 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 0 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 7 | 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 | 829 | } | 85 | 351k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 503 | 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 | 337 | 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 | 503 | } | 102 | 503 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 351k | 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 | 351k | } | 112 | 351k | } |
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSARefChecker, bool>::Visit(clang::Stmt*) Line | Count | Source | 43 | 15.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 | 15.0k | 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 | 0 | } | 85 | 15.0k | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 15.0k | 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.0k | } | 112 | 15.0k | } |
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::MapBaseChecker, bool>::Visit(clang::Stmt*) Line | Count | Source | 43 | 74.1k | 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 | 74.1k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 569 | 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 | 566 | 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 | 569 | } | 85 | 73.5k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 747 | 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 | 747 | 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 | 747 | } | 102 | 747 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 72.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 | 72.8k | } | 112 | 72.8k | } |
SemaOpenMP.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LocalVarRefChecker, bool>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 2.19k | 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.19k | 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 | 0 | } | 85 | 2.19k | } 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 | 0 | } | 102 | 0 | } | 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 | } |
SemaOpenMP.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DSAAttrChecker, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 2.27M | 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.27M | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 213k | switch (BinOp->getOpcode()) { | 49 | 0 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 1.47k | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 158 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 0 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 8.05k | 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 | 108k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 1.72k | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 396 | 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.9k | case BO_Assign: DISPATCH(BinAssign, BinaryOperator); | 73 | 105 | case BO_MulAssign: DISPATCH(BinMulAssign, CompoundAssignOperator); | 74 | 138 | case BO_DivAssign: DISPATCH(BinDivAssign, CompoundAssignOperator); | 75 | 16 | case BO_RemAssign: DISPATCH(BinRemAssign, CompoundAssignOperator); | 76 | 16.1k | case BO_AddAssign: DISPATCH(BinAddAssign, CompoundAssignOperator); | 77 | 821 | 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 | 14 | case BO_OrAssign: DISPATCH(BinOrAssign, CompoundAssignOperator); | 82 | 10 | case BO_XorAssign: DISPATCH(BinXorAssign, CompoundAssignOperator); | 83 | 404 | case BO_Comma: DISPATCH(BinComma, BinaryOperator); | 84 | 213k | } | 85 | 2.06M | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 123k | switch (UnOp->getOpcode()) { | 87 | 31.0k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 380 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 90.2k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 185 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 120 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 678 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 0 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 724 | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 0 | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 300 | 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 | 123k | } | 102 | 123k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 1.93M | 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.93M | } | 112 | 1.93M | } |
SemaStmt.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BreakContinueFinder, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 56.1k | 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 | 56.1k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 9.12k | 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 | 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 | 4 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 0 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 8.39k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 75 | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 79 | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 23 | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 107 | 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 | 26 | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 23 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 57 | 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 | 23 | 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 | 9.12k | } | 85 | 47.0k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 8.69k | switch (UnOp->getOpcode()) { | 87 | 1.01k | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 43 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 7.47k | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 38 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 24 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 72 | 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 | 8.69k | } | 102 | 8.69k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 38.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 | 38.3k | } | 112 | 38.3k | } |
SemaStmt.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::DeclExtractor, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 649 | 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 | 649 | 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 | 141 | } | 85 | 508 | } 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 | 4 | } | 102 | 4 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 504 | 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 | 504 | } | 112 | 504 | } |
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 | 157 | } | 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 | 32 | } | 102 | 32 | } | 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 | 180 | } | 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 | 0 | } | 102 | 0 | } | 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 | 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 | 13 | 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 | 10 | 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 | 13 | } | 85 | 127 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 127 | 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 | 127 | } | 112 | 127 | } |
AnalysisDeclContext.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::FindBlockDeclRefExprsVals, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 2.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 | 2.45k | 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 | 165 | } | 85 | 2.29k | } 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 | 80 | } | 102 | 80 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 2.21k | 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.21k | } | 112 | 2.21k | } |
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DeclRefFinder, clang::DeclRefExpr const*>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 873 | 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 | 873 | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 11 | 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 | 6 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 3 | 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 | 11 | } | 85 | 862 | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 27 | 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 | 25 | 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 | 27 | } | 102 | 27 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 835 | 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 | 835 | } | 112 | 835 | } |
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::CalledOnceChecker, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 1.16k | 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.16k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 28 | 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 | 6 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 3 | 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 | 10 | 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 | 28 | } | 85 | 1.13k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 26 | 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 | 19 | 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 | 26 | } | 102 | 26 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 1.11k | 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.11k | } | 112 | 1.11k | } |
CalledOnceCheck.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::NotCalledClarifier, llvm::Optional<(anonymous namespace)::Clarification> >::Visit(clang::Stmt const*) Line | Count | Source | 43 | 45 | 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 | 45 | 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 | 2 | } | 85 | 43 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 43 | 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 | 43 | } | 112 | 43 | } |
CFG.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::CFGBlockTerminatorPrint, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 556 | 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 | 556 | 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 | 37 | } | 85 | 519 | } 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 | 0 | } | 102 | 0 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 519 | 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 | 519 | } | 112 | 519 | } |
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 | 145 | } | 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 | 23 | } | 102 | 23 | } | 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 | 36.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 | 36.5k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 2.03k | 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 | 42 | 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 | 199 | 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.56k | 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 | 2.03k | } | 85 | 34.4k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 848 | switch (UnOp->getOpcode()) { | 87 | 8 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 4 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 44 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 4 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 410 | 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 | 848 | } | 102 | 848 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 33.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 | 33.6k | } | 112 | 33.6k | } |
ThreadSafety.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::BuildLockset, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 36.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 | 36.3k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 2.03k | 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 | 42 | 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 | 199 | 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.56k | 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 | 2.03k | } | 85 | 34.2k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 840 | switch (UnOp->getOpcode()) { | 87 | 8 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 4 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 44 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 4 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 410 | 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 | 840 | } | 102 | 840 | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 33.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 | 33.4k | } | 112 | 33.4k | } |
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::TransferFunctions, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 44.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 | 44.3k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 4.65k | switch (BinOp->getOpcode()) { | 49 | 2 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 53 | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 8 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 22 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 207 | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 74 | 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.81k | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 134 | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 65 | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 65 | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 176 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 282 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 0 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 124 | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 2 | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 57 | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 9 | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 19 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 1.17k | 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 | 88 | 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 | 4.65k | } | 85 | 39.6k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 1.51k | switch (UnOp->getOpcode()) { | 87 | 46 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 0 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 966 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 0 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 148 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 179 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 0 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 154 | case UO_Minus: DISPATCH(UnaryMinus, UnaryOperator); | 95 | 1 | case UO_Not: DISPATCH(UnaryNot, UnaryOperator); | 96 | 21 | 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.51k | } | 102 | 1.51k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 38.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 | 38.1k | } | 112 | 38.1k | } |
UninitializedValues.cpp:clang::StmtVisitorBase<std::__1::add_pointer, (anonymous namespace)::ClassifyRefs, void>::Visit(clang::Stmt*) Line | Count | Source | 43 | 25.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 | 25.9k | if (PTR(BinaryOperator) BinOp = dyn_cast<BinaryOperator>(S)) { | 48 | 3.03k | switch (BinOp->getOpcode()) { | 49 | 1 | case BO_PtrMemD: DISPATCH(BinPtrMemD, BinaryOperator); | 50 | 0 | case BO_PtrMemI: DISPATCH(BinPtrMemI, BinaryOperator); | 51 | 53 | case BO_Mul: DISPATCH(BinMul, BinaryOperator); | 52 | 6 | case BO_Div: DISPATCH(BinDiv, BinaryOperator); | 53 | 22 | case BO_Rem: DISPATCH(BinRem, BinaryOperator); | 54 | 106 | case BO_Add: DISPATCH(BinAdd, BinaryOperator); | 55 | 72 | case BO_Sub: DISPATCH(BinSub, BinaryOperator); | 56 | 100 | case BO_Shl: DISPATCH(BinShl, BinaryOperator); | 57 | 11 | case BO_Shr: DISPATCH(BinShr, BinaryOperator); | 58 | | | 59 | 968 | case BO_LT: DISPATCH(BinLT, BinaryOperator); | 60 | 134 | case BO_GT: DISPATCH(BinGT, BinaryOperator); | 61 | 63 | case BO_LE: DISPATCH(BinLE, BinaryOperator); | 62 | 65 | case BO_GE: DISPATCH(BinGE, BinaryOperator); | 63 | 163 | case BO_EQ: DISPATCH(BinEQ, BinaryOperator); | 64 | 118 | case BO_NE: DISPATCH(BinNE, BinaryOperator); | 65 | 0 | case BO_Cmp: DISPATCH(BinCmp, BinaryOperator); | 66 | | | 67 | 124 | case BO_And: DISPATCH(BinAnd, BinaryOperator); | 68 | 2 | case BO_Xor: DISPATCH(BinXor, BinaryOperator); | 69 | 57 | case BO_Or : DISPATCH(BinOr, BinaryOperator); | 70 | 7 | case BO_LAnd: DISPATCH(BinLAnd, BinaryOperator); | 71 | 17 | case BO_LOr : DISPATCH(BinLOr, BinaryOperator); | 72 | 724 | 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 | 65 | 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 | 3.03k | } | 85 | 22.9k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 1.31k | switch (UnOp->getOpcode()) { | 87 | 34 | case UO_PostInc: DISPATCH(UnaryPostInc, UnaryOperator); | 88 | 0 | case UO_PostDec: DISPATCH(UnaryPostDec, UnaryOperator); | 89 | 894 | case UO_PreInc: DISPATCH(UnaryPreInc, UnaryOperator); | 90 | 0 | case UO_PreDec: DISPATCH(UnaryPreDec, UnaryOperator); | 91 | 125 | case UO_AddrOf: DISPATCH(UnaryAddrOf, UnaryOperator); | 92 | 93 | case UO_Deref: DISPATCH(UnaryDeref, UnaryOperator); | 93 | 0 | case UO_Plus: DISPATCH(UnaryPlus, UnaryOperator); | 94 | 151 | 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 | 1.31k | } | 102 | 1.31k | } | 103 | | | 104 | | // Top switch stmt: dispatch to VisitFooStmt for each FooStmt. | 105 | 21.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 | 21.5k | } | 112 | 21.5k | } |
CGClass.cpp:clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::DynamicThisUseChecker, void>::Visit(clang::Stmt const*) Line | Count | Source | 43 | 32.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 | 32.9k | 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 | 13 | } | 85 | 32.9k | } else if (PTR(UnaryOperator) UnOp = dyn_cast<UnaryOperator>(S)) { | 86 | 12 | switch (UnOp->getOpcode()) { | 87 | 0 | case U
|
|