Lines Matching defs:S
41 void VisitStmt(const Stmt *S);
43 void VisitStmtNoChildren(const Stmt *S) {
44 HandleStmtClass(S->getStmtClass());
49 #define STMT(Node, Base) void Visit##Node(const Node *S);
238 void StmtProfiler::VisitStmt(const Stmt *S) {
239 assert(S && "Requires non-null Stmt pointer");
241 VisitStmtNoChildren(S);
243 for (const Stmt *SubStmt : S->children()) {
251 void StmtProfiler::VisitDeclStmt(const DeclStmt *S) {
252 VisitStmt(S);
253 for (const auto *D : S->decls())
257 void StmtProfiler::VisitNullStmt(const NullStmt *S) {
258 VisitStmt(S);
261 void StmtProfiler::VisitCompoundStmt(const CompoundStmt *S) {
262 VisitStmt(S);
265 void StmtProfiler::VisitCaseStmt(const CaseStmt *S) {
266 VisitStmt(S);
269 void StmtProfiler::VisitDefaultStmt(const DefaultStmt *S) {
270 VisitStmt(S);
273 void StmtProfiler::VisitLabelStmt(const LabelStmt *S) {
274 VisitStmt(S);
275 VisitDecl(S->getDecl());
278 void StmtProfiler::VisitAttributedStmt(const AttributedStmt *S) {
279 VisitStmt(S);
283 void StmtProfiler::VisitIfStmt(const IfStmt *S) {
284 VisitStmt(S);
285 VisitDecl(S->getConditionVariable());
288 void StmtProfiler::VisitSwitchStmt(const SwitchStmt *S) {
289 VisitStmt(S);
290 VisitDecl(S->getConditionVariable());
293 void StmtProfiler::VisitWhileStmt(const WhileStmt *S) {
294 VisitStmt(S);
295 VisitDecl(S->getConditionVariable());
298 void StmtProfiler::VisitDoStmt(const DoStmt *S) {
299 VisitStmt(S);
302 void StmtProfiler::VisitForStmt(const ForStmt *S) {
303 VisitStmt(S);
306 void StmtProfiler::VisitGotoStmt(const GotoStmt *S) {
307 VisitStmt(S);
308 VisitDecl(S->getLabel());
311 void StmtProfiler::VisitIndirectGotoStmt(const IndirectGotoStmt *S) {
312 VisitStmt(S);
315 void StmtProfiler::VisitContinueStmt(const ContinueStmt *S) {
316 VisitStmt(S);
319 void StmtProfiler::VisitBreakStmt(const BreakStmt *S) {
320 VisitStmt(S);
323 void StmtProfiler::VisitReturnStmt(const ReturnStmt *S) {
324 VisitStmt(S);
327 void StmtProfiler::VisitGCCAsmStmt(const GCCAsmStmt *S) {
328 VisitStmt(S);
329 ID.AddBoolean(S->isVolatile());
330 ID.AddBoolean(S->isSimple());
331 VisitStringLiteral(S->getAsmString());
332 ID.AddInteger(S->getNumOutputs());
333 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
334 ID.AddString(S->getOutputName(I));
335 VisitStringLiteral(S->getOutputConstraintLiteral(I));
337 ID.AddInteger(S->getNumInputs());
338 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
339 ID.AddString(S->getInputName(I));
340 VisitStringLiteral(S->getInputConstraintLiteral(I));
342 ID.AddInteger(S->getNumClobbers());
343 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
344 VisitStringLiteral(S->getClobberStringLiteral(I));
345 ID.AddInteger(S->getNumLabels());
346 for (auto *L : S->labels())
350 void StmtProfiler::VisitMSAsmStmt(const MSAsmStmt *S) {
352 VisitStmt(S);
355 void StmtProfiler::VisitCXXCatchStmt(const CXXCatchStmt *S) {
356 VisitStmt(S);
357 VisitType(S->getCaughtType());
360 void StmtProfiler::VisitCXXTryStmt(const CXXTryStmt *S) {
361 VisitStmt(S);
364 void StmtProfiler::VisitCXXForRangeStmt(const CXXForRangeStmt *S) {
365 VisitStmt(S);
368 void StmtProfiler::VisitMSDependentExistsStmt(const MSDependentExistsStmt *S) {
369 VisitStmt(S);
370 ID.AddBoolean(S->isIfExists());
371 VisitNestedNameSpecifier(S->getQualifierLoc().getNestedNameSpecifier());
372 VisitName(S->getNameInfo().getName());
375 void StmtProfiler::VisitSEHTryStmt(const SEHTryStmt *S) {
376 VisitStmt(S);
379 void StmtProfiler::VisitSEHFinallyStmt(const SEHFinallyStmt *S) {
380 VisitStmt(S);
383 void StmtProfiler::VisitSEHExceptStmt(const SEHExceptStmt *S) {
384 VisitStmt(S);
387 void StmtProfiler::VisitSEHLeaveStmt(const SEHLeaveStmt *S) {
388 VisitStmt(S);
391 void StmtProfiler::VisitCapturedStmt(const CapturedStmt *S) {
392 VisitStmt(S);
395 void StmtProfiler::VisitSYCLKernelCallStmt(const SYCLKernelCallStmt *S) {
396 VisitStmt(S);
399 void StmtProfiler::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
400 VisitStmt(S);
403 void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) {
404 VisitStmt(S);
405 ID.AddBoolean(S->hasEllipsis());
406 if (S->getCatchParamDecl())
407 VisitType(S->getCatchParamDecl()->getType());
410 void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) {
411 VisitStmt(S);
414 void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) {
415 VisitStmt(S);
419 StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) {
420 VisitStmt(S);
423 void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) {
424 VisitStmt(S);
428 StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) {
429 VisitStmt(S);
450 if (auto *S = C->getPreInitStmt())
451 Profiler->VisitStmt(S);
571 if (auto *S = C->getChunkSize())
572 Profiler->VisitStmt(S);
964 StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
965 VisitStmt(S);
967 ArrayRef<OMPClause *> Clauses = S->clauses();
978 void StmtProfiler::VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *S) {
979 VisitOMPExecutableDirective(S);
982 void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) {
983 VisitOMPLoopBasedDirective(S);
986 void StmtProfiler::VisitOMPMetaDirective(const OMPMetaDirective *S) {
987 VisitOMPExecutableDirective(S);
990 void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
991 VisitOMPExecutableDirective(S);
994 void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) {
995 VisitOMPLoopDirective(S);
999 const OMPLoopTransformationDirective *S) {
1000 VisitOMPLoopBasedDirective(S);
1003 void StmtProfiler::VisitOMPTileDirective(const OMPTileDirective *S) {
1004 VisitOMPLoopTransformationDirective(S);
1007 void StmtProfiler::VisitOMPUnrollDirective(const OMPUnrollDirective *S) {
1008 VisitOMPLoopTransformationDirective(S);
1011 void StmtProfiler::VisitOMPReverseDirective(const OMPReverseDirective *S) {
1012 VisitOMPLoopTransformationDirective(S);
1016 const OMPInterchangeDirective *S) {
1017 VisitOMPLoopTransformationDirective(S);
1020 void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) {
1021 VisitOMPLoopDirective(S);
1024 void StmtProfiler::VisitOMPForSimdDirective(const OMPForSimdDirective *S) {
1025 VisitOMPLoopDirective(S);
1028 void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) {
1029 VisitOMPExecutableDirective(S);
1032 void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
1033 VisitOMPExecutableDirective(S);
1036 void StmtProfiler::VisitOMPScopeDirective(const OMPScopeDirective *S) {
1037 VisitOMPExecutableDirective(S);
1040 void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) {
1041 VisitOMPExecutableDirective(S);
1044 void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) {
1045 VisitOMPExecutableDirective(S);
1048 void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) {
1049 VisitOMPExecutableDirective(S);
1050 VisitName(S->getDirectiveName().getName());
1054 StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) {
1055 VisitOMPLoopDirective(S);
1059 const OMPParallelForSimdDirective *S) {
1060 VisitOMPLoopDirective(S);
1064 const OMPParallelMasterDirective *S) {
1065 VisitOMPExecutableDirective(S);
1069 const OMPParallelMaskedDirective *S) {
1070 VisitOMPExecutableDirective(S);
1074 const OMPParallelSectionsDirective *S) {
1075 VisitOMPExecutableDirective(S);
1078 void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) {
1079 VisitOMPExecutableDirective(S);
1082 void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) {
1083 VisitOMPExecutableDirective(S);
1086 void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) {
1087 VisitOMPExecutableDirective(S);
1090 void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) {
1091 VisitOMPExecutableDirective(S);
1094 void StmtProfiler::VisitOMPAssumeDirective(const OMPAssumeDirective *S) {
1095 VisitOMPExecutableDirective(S);
1098 void StmtProfiler::VisitOMPErrorDirective(const OMPErrorDirective *S) {
1099 VisitOMPExecutableDirective(S);
1101 void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) {
1102 VisitOMPExecutableDirective(S);
1103 if (const Expr *E = S->getReductionRef())
1107 void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) {
1108 VisitOMPExecutableDirective(S);
1111 void StmtProfiler::VisitOMPDepobjDirective(const OMPDepobjDirective *S) {
1112 VisitOMPExecutableDirective(S);
1115 void StmtProfiler::VisitOMPScanDirective(const OMPScanDirective *S) {
1116 VisitOMPExecutableDirective(S);
1119 void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) {
1120 VisitOMPExecutableDirective(S);
1123 void StmtProfiler::VisitOMPAtomicDirective(const OMPAtomicDirective *S) {
1124 VisitOMPExecutableDirective(S);
1127 void StmtProfiler::VisitOMPTargetDirective(const OMPTargetDirective *S) {
1128 VisitOMPExecutableDirective(S);
1131 void StmtProfiler::VisitOMPTargetDataDirective(const OMPTargetDataDirective *S) {
1132 VisitOMPExecutableDirective(S);
1136 const OMPTargetEnterDataDirective *S) {
1137 VisitOMPExecutableDirective(S);
1141 const OMPTargetExitDataDirective *S) {
1142 VisitOMPExecutableDirective(S);
1146 const OMPTargetParallelDirective *S) {
1147 VisitOMPExecutableDirective(S);
1151 const OMPTargetParallelForDirective *S) {
1152 VisitOMPExecutableDirective(S);
1155 void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) {
1156 VisitOMPExecutableDirective(S);
1160 const OMPCancellationPointDirective *S) {
1161 VisitOMPExecutableDirective(S);
1164 void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) {
1165 VisitOMPExecutableDirective(S);
1168 void StmtProfiler::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *S) {
1169 VisitOMPLoopDirective(S);
1173 const OMPTaskLoopSimdDirective *S) {
1174 VisitOMPLoopDirective(S);
1178 const OMPMasterTaskLoopDirective *S) {
1179 VisitOMPLoopDirective(S);
1183 const OMPMaskedTaskLoopDirective *S) {
1184 VisitOMPLoopDirective(S);
1188 const OMPMasterTaskLoopSimdDirective *S) {
1189 VisitOMPLoopDirective(S);
1193 const OMPMaskedTaskLoopSimdDirective *S) {
1194 VisitOMPLoopDirective(S);
1198 const OMPParallelMasterTaskLoopDirective *S) {
1199 VisitOMPLoopDirective(S);
1203 const OMPParallelMaskedTaskLoopDirective *S) {
1204 VisitOMPLoopDirective(S);
1208 const OMPParallelMasterTaskLoopSimdDirective *S) {
1209 VisitOMPLoopDirective(S);
1213 const OMPParallelMaskedTaskLoopSimdDirective *S) {
1214 VisitOMPLoopDirective(S);
1218 const OMPDistributeDirective *S) {
1219 VisitOMPLoopDirective(S);
1225 if (auto *S = C->getChunkSize())
1226 Profiler->VisitStmt(S);
1232 const OMPTargetUpdateDirective *S) {
1233 VisitOMPExecutableDirective(S);
1237 const OMPDistributeParallelForDirective *S) {
1238 VisitOMPLoopDirective(S);
1242 const OMPDistributeParallelForSimdDirective *S) {
1243 VisitOMPLoopDirective(S);
1247 const OMPDistributeSimdDirective *S) {
1248 VisitOMPLoopDirective(S);
1252 const OMPTargetParallelForSimdDirective *S) {
1253 VisitOMPLoopDirective(S);
1257 const OMPTargetSimdDirective *S) {
1258 VisitOMPLoopDirective(S);
1262 const OMPTeamsDistributeDirective *S) {
1263 VisitOMPLoopDirective(S);
1267 const OMPTeamsDistributeSimdDirective *S) {
1268 VisitOMPLoopDirective(S);
1272 const OMPTeamsDistributeParallelForSimdDirective *S) {
1273 VisitOMPLoopDirective(S);
1277 const OMPTeamsDistributeParallelForDirective *S) {
1278 VisitOMPLoopDirective(S);
1282 const OMPTargetTeamsDirective *S) {
1283 VisitOMPExecutableDirective(S);
1287 const OMPTargetTeamsDistributeDirective *S) {
1288 VisitOMPLoopDirective(S);
1292 const OMPTargetTeamsDistributeParallelForDirective *S) {
1293 VisitOMPLoopDirective(S);
1297 const OMPTargetTeamsDistributeParallelForSimdDirective *S) {
1298 VisitOMPLoopDirective(S);
1302 const OMPTargetTeamsDistributeSimdDirective *S) {
1303 VisitOMPLoopDirective(S);
1306 void StmtProfiler::VisitOMPInteropDirective(const OMPInteropDirective *S) {
1307 VisitOMPExecutableDirective(S);
1310 void StmtProfiler::VisitOMPDispatchDirective(const OMPDispatchDirective *S) {
1311 VisitOMPExecutableDirective(S);
1314 void StmtProfiler::VisitOMPMaskedDirective(const OMPMaskedDirective *S) {
1315 VisitOMPExecutableDirective(S);
1319 const OMPGenericLoopDirective *S) {
1320 VisitOMPLoopDirective(S);
1324 const OMPTeamsGenericLoopDirective *S) {
1325 VisitOMPLoopDirective(S);
1329 const OMPTargetTeamsGenericLoopDirective *S) {
1330 VisitOMPLoopDirective(S);
1334 const OMPParallelGenericLoopDirective *S) {
1335 VisitOMPLoopDirective(S);
1339 const OMPTargetParallelGenericLoopDirective *S) {
1340 VisitOMPLoopDirective(S);
1343 void StmtProfiler::VisitExpr(const Expr *S) {
1344 VisitStmt(S);
1347 void StmtProfiler::VisitConstantExpr(const ConstantExpr *S) {
1348 VisitExpr(S);
1351 void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) {
1352 VisitExpr(S);
1354 VisitNestedNameSpecifier(S->getQualifier());
1355 VisitDecl(S->getDecl());
1357 ID.AddBoolean(S->hasExplicitTemplateArgs());
1358 if (S->hasExplicitTemplateArgs())
1359 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1364 const SYCLUniqueStableNameExpr *S) {
1365 VisitExpr(S);
1366 VisitType(S->getTypeSourceInfo()->getType());
1369 void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) {
1370 VisitExpr(S);
1371 ID.AddInteger(llvm::to_underlying(S->getIdentKind()));
1375 const OpenACCAsteriskSizeExpr *S) {
1376 VisitExpr(S);
1379 void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) {
1380 VisitExpr(S);
1381 S->getValue().Profile(ID);
1383 QualType T = S->getType();
1393 void StmtProfiler::VisitFixedPointLiteral(const FixedPointLiteral *S) {
1394 VisitExpr(S);
1395 S->getValue().Profile(ID);
1396 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1399 void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) {
1400 VisitExpr(S);
1401 ID.AddInteger(llvm::to_underlying(S->getKind()));
1402 ID.AddInteger(S->getValue());
1405 void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) {
1406 VisitExpr(S);
1407 S->getValue().Profile(ID);
1408 ID.AddBoolean(S->isExact());
1409 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1412 void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) {
1413 VisitExpr(S);
1416 void StmtProfiler::VisitStringLiteral(const StringLiteral *S) {
1417 VisitExpr(S);
1418 ID.AddString(S->getBytes());
1419 ID.AddInteger(llvm::to_underlying(S->getKind()));
1422 void StmtProfiler::VisitParenExpr(const ParenExpr *S) {
1423 VisitExpr(S);
1426 void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) {
1427 VisitExpr(S);
1430 void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) {
1431 VisitExpr(S);
1432 ID.AddInteger(S->getOpcode());
1435 void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
1436 VisitType(S->getTypeSourceInfo()->getType());
1437 unsigned n = S->getNumComponents();
1439 const OffsetOfNode &ON = S->getComponent(i);
1460 VisitExpr(S);
1464 StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) {
1465 VisitExpr(S);
1466 ID.AddInteger(S->getKind());
1467 if (S->isArgumentType())
1468 VisitType(S->getArgumentType());
1471 void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) {
1472 VisitExpr(S);
1475 void StmtProfiler::VisitMatrixSubscriptExpr(const MatrixSubscriptExpr *S) {
1476 VisitExpr(S);
1479 void StmtProfiler::VisitArraySectionExpr(const ArraySectionExpr *S) {
1480 VisitExpr(S);
1483 void StmtProfiler::VisitOMPArrayShapingExpr(const OMPArrayShapingExpr *S) {
1484 VisitExpr(S);
1487 void StmtProfiler::VisitOMPIteratorExpr(const OMPIteratorExpr *S) {
1488 VisitExpr(S);
1489 for (unsigned I = 0, E = S->numOfIterators(); I < E; ++I)
1490 VisitDecl(S->getIteratorDecl(I));
1493 void StmtProfiler::VisitCallExpr(const CallExpr *S) {
1494 VisitExpr(S);
1497 void StmtProfiler::VisitMemberExpr(const MemberExpr *S) {
1498 VisitExpr(S);
1499 VisitDecl(S->getMemberDecl());
1501 VisitNestedNameSpecifier(S->getQualifier());
1502 ID.AddBoolean(S->isArrow());
1505 void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) {
1506 VisitExpr(S);
1507 ID.AddBoolean(S->isFileScope());
1510 void StmtProfiler::VisitCastExpr(const CastExpr *S) {
1511 VisitExpr(S);
1514 void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) {
1515 VisitCastExpr(S);
1516 ID.AddInteger(S->getValueKind());
1519 void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) {
1520 VisitCastExpr(S);
1521 VisitType(S->getTypeAsWritten());
1524 void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) {
1525 VisitExplicitCastExpr(S);
1528 void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) {
1529 VisitExpr(S);
1530 ID.AddInteger(S->getOpcode());
1534 StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) {
1535 VisitBinaryOperator(S);
1538 void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) {
1539 VisitExpr(S);
1543 const BinaryConditionalOperator *S) {
1544 VisitExpr(S);
1547 void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) {
1548 VisitExpr(S);
1549 VisitDecl(S->getLabel());
1552 void StmtProfiler::VisitStmtExpr(const StmtExpr *S) {
1553 VisitExpr(S);
1556 void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) {
1557 VisitExpr(S);
1560 void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) {
1561 VisitExpr(S);
1564 void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) {
1565 VisitExpr(S);
1568 void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
1569 VisitExpr(S);
1572 void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
1573 VisitExpr(S);
1576 void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
1577 if (S->getSyntacticForm()) {
1578 VisitInitListExpr(S->getSyntacticForm());
1582 VisitExpr(S);
1585 void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
1586 VisitExpr(S);
1587 ID.AddBoolean(S->usesGNUSyntax());
1588 for (const DesignatedInitExpr::Designator &D : S->designators()) {
1608 const DesignatedInitUpdateExpr *S) {
1613 void StmtProfiler::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *S) {
1614 VisitExpr(S);
1617 void StmtProfiler::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *S) {
1618 VisitExpr(S);
1621 void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) {
1625 void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) {
1626 VisitExpr(S);
1629 void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) {
1630 VisitExpr(S);
1631 VisitName(&S->getAccessor());
1634 void StmtProfiler::VisitBlockExpr(const BlockExpr *S) {
1635 VisitExpr(S);
1636 VisitDecl(S->getBlockDecl());
1639 void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) {
1640 VisitExpr(S);
1642 S->associations()) {
1652 void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) {
1653 VisitExpr(S);
1655 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1661 void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) {
1662 VisitExpr(S);
1663 ID.AddInteger(S->getOp());
1667 const ConceptSpecializationExpr *S) {
1668 VisitExpr(S);
1669 VisitDecl(S->getNamedConcept());
1670 for (const TemplateArgument &Arg : S->getTemplateArguments())
1674 void StmtProfiler::VisitRequiresExpr(const RequiresExpr *S) {
1675 VisitExpr(S);
1676 ID.AddInteger(S->getLocalParameters().size());
1677 for (ParmVarDecl *LocalParam : S->getLocalParameters())
1679 ID.AddInteger(S->getRequirements().size());
1680 for (concepts::Requirement *Req : S->getRequirements()) {
1717 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
1721 switch (S->getOperator()) {
1921 void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
1922 if (S->isTypeDependent()) {
1928 if (S->getOperator() == OO_Arrow)
1929 return Visit(S->getArg(0));
1933 unsigned NumArgs = S->getNumArgs();
1934 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp, NumArgs);
1938 Visit(S->getArg(I));
1950 VisitCallExpr(S);
1951 ID.AddInteger(S->getOperator());
1955 const CXXRewrittenBinaryOperator *S) {
1958 assert(!S->isTypeDependent() &&
1960 ID.AddBoolean(S->isReversed());
1961 VisitExpr(S->getSemanticForm());
1970 void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) {
1971 VisitCallExpr(S);
1974 void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) {
1975 VisitCallExpr(S);
1978 void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) {
1979 VisitExpr(S);
1982 void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) {
1983 VisitExplicitCastExpr(S);
1986 void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) {
1987 VisitCXXNamedCastExpr(S);
1990 void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) {
1991 VisitCXXNamedCastExpr(S);
1995 StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) {
1996 VisitCXXNamedCastExpr(S);
1999 void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) {
2000 VisitCXXNamedCastExpr(S);
2003 void StmtProfiler::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *S) {
2004 VisitExpr(S);
2005 VisitType(S->getTypeInfoAsWritten()->getType());
2008 void StmtProfiler::VisitCXXAddrspaceCastExpr(const CXXAddrspaceCastExpr *S) {
2009 VisitCXXNamedCastExpr(S);
2012 void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) {
2013 VisitCallExpr(S);
2016 void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
2017 VisitExpr(S);
2018 ID.AddBoolean(S->getValue());
2021 void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) {
2022 VisitExpr(S);
2026 const CXXStdInitializerListExpr *S) {
2027 VisitExpr(S);
2030 void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) {
2031 VisitExpr(S);
2032 if (S->isTypeOperand())
2033 VisitType(S->getTypeOperandSourceInfo()->getType());
2036 void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) {
2037 VisitExpr(S);
2038 if (S->isTypeOperand())
2039 VisitType(S->getTypeOperandSourceInfo()->getType());
2042 void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) {
2043 VisitExpr(S);
2044 VisitDecl(S->getPropertyDecl());
2048 const MSPropertySubscriptExpr *S) {
2049 VisitExpr(S);
2052 void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) {
2053 VisitExpr(S);
2054 ID.AddBoolean(S->isImplicit());
2055 ID.AddBoolean(S->isCapturedByCopyInLambdaWithExplicitObjectParameter());
2058 void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) {
2059 VisitExpr(S);
2062 void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) {
2063 VisitExpr(S);
2064 VisitDecl(S->getParam());
2067 void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) {
2068 VisitExpr(S);
2069 VisitDecl(S->getField());
2072 void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) {
2073 VisitExpr(S);
2075 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor()));
2078 void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) {
2079 VisitExpr(S);
2080 VisitDecl(S->getConstructor());
2081 ID.AddBoolean(S->isElidable());
2085 const CXXInheritedCtorInitExpr *S) {
2086 VisitExpr(S);
2087 VisitDecl(S->getConstructor());
2090 void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) {
2091 VisitExplicitCastExpr(S);
2095 StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) {
2096 VisitCXXConstructExpr(S);
2100 StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
2105 VisitStmtNoChildren(S);
2109 VisitDecl(S->getLambdaClass());
2114 CXXRecordDecl *Lambda = S->getLambdaClass();
2143 StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) {
2144 VisitExpr(S);
2147 void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
2148 VisitExpr(S);
2149 ID.AddBoolean(S->isGlobalDelete());
2150 ID.AddBoolean(S->isArrayForm());
2151 VisitDecl(S->getOperatorDelete());
2154 void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) {
2155 VisitExpr(S);
2156 VisitType(S->getAllocatedType());
2157 VisitDecl(S->getOperatorNew());
2158 VisitDecl(S->getOperatorDelete());
2159 ID.AddBoolean(S->isArray());
2160 ID.AddInteger(S->getNumPlacementArgs());
2161 ID.AddBoolean(S->isGlobalNew());
2162 ID.AddBoolean(S->isParenTypeId());
2163 ID.AddInteger(llvm::to_underlying(S->getInitializationStyle()));
2167 StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
2168 VisitExpr(S);
2169 ID.AddBoolean(S->isArrow());
2170 VisitNestedNameSpecifier(S->getQualifier());
2171 ID.AddBoolean(S->getScopeTypeInfo() != nullptr);
2172 if (S->getScopeTypeInfo())
2173 VisitType(S->getScopeTypeInfo()->getType());
2174 ID.AddBoolean(S->getDestroyedTypeInfo() != nullptr);
2175 if (S->getDestroyedTypeInfo())
2176 VisitType(S->getDestroyedType());
2178 VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
2181 void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) {
2182 VisitExpr(S);
2183 VisitNestedNameSpecifier(S->getQualifier());
2184 VisitName(S->getName(), /*TreatAsDecl*/ true);
2185 ID.AddBoolean(S->hasExplicitTemplateArgs());
2186 if (S->hasExplicitTemplateArgs())
2187 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2191 StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) {
2192 VisitOverloadExpr(S);
2195 void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) {
2196 VisitExpr(S);
2197 ID.AddInteger(S->getTrait());
2198 ID.AddInteger(S->getNumArgs());
2199 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2200 VisitType(S->getArg(I)->getType());
2203 void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) {
2204 VisitExpr(S);
2205 ID.AddInteger(S->getTrait());
2206 VisitType(S->getQueriedType());
2209 void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) {
2210 VisitExpr(S);
2211 ID.AddInteger(S->getTrait());
2212 VisitExpr(S->getQueriedExpression());
2216 const DependentScopeDeclRefExpr *S) {
2217 VisitExpr(S);
2218 VisitName(S->getDeclName());
2219 VisitNestedNameSpecifier(S->getQualifier());
2220 ID.AddBoolean(S->hasExplicitTemplateArgs());
2221 if (S->hasExplicitTemplateArgs())
2222 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2225 void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) {
2226 VisitExpr(S);
2230 const CXXUnresolvedConstructExpr *S) {
2231 VisitExpr(S);
2232 VisitType(S->getTypeAsWritten());
2233 ID.AddInteger(S->isListInitialization());
2237 const CXXDependentScopeMemberExpr *S) {
2238 ID.AddBoolean(S->isImplicitAccess());
2239 if (!S->isImplicitAccess()) {
2240 VisitExpr(S);
2241 ID.AddBoolean(S->isArrow());
2243 VisitNestedNameSpecifier(S->getQualifier());
2244 VisitName(S->getMember());
2245 ID.AddBoolean(S->hasExplicitTemplateArgs());
2246 if (S->hasExplicitTemplateArgs())
2247 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2250 void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) {
2251 ID.AddBoolean(S->isImplicitAccess());
2252 if (!S->isImplicitAccess()) {
2253 VisitExpr(S);
2254 ID.AddBoolean(S->isArrow());
2256 VisitNestedNameSpecifier(S->getQualifier());
2257 VisitName(S->getMemberName());
2258 ID.AddBoolean(S->hasExplicitTemplateArgs());
2259 if (S->hasExplicitTemplateArgs())
2260 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2263 void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) {
2264 VisitExpr(S);
2267 void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) {
2268 VisitExpr(S);
2271 void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) {
2272 VisitExpr(S);
2273 if (S->isPartiallySubstituted()) {
2274 auto Args = S->getPartialArguments();
2279 VisitDecl(S->getPack());
2284 const ResolvedUnexpandedPackExpr *S) {
2285 VisitExpr(S);
2295 const SubstNonTypeTemplateParmPackExpr *S) {
2296 VisitExpr(S);
2297 VisitDecl(S->getParameterPack());
2298 VisitTemplateArgument(S->getArgumentPack());
2307 void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) {
2308 VisitExpr(S);
2309 VisitDecl(S->getParameterPack());
2310 ID.AddInteger(S->getNumExpansions());
2311 for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I)
2316 const MaterializeTemporaryExpr *S) {
2317 VisitExpr(S);
2320 void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) {
2321 VisitExpr(S);
2322 ID.AddInteger(S->getOperator());
2325 void StmtProfiler::VisitCXXParenListInitExpr(const CXXParenListInitExpr *S) {
2326 VisitExpr(S);
2329 void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) {
2330 VisitStmt(S);
2333 void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
2334 VisitStmt(S);
2337 void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) {
2338 VisitExpr(S);
2341 void StmtProfiler::VisitDependentCoawaitExpr(const DependentCoawaitExpr *S) {
2342 VisitExpr(S);
2345 void StmtProfiler::VisitCoyieldExpr(const CoyieldExpr *S) {
2346 VisitExpr(S);
2365 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
2366 VisitExpr(S);
2381 void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) {
2382 VisitExpr(S);
2383 VisitType(S->getEncodedType());
2386 void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) {
2387 VisitExpr(S);
2388 VisitName(S->getSelector());
2391 void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) {
2392 VisitExpr(S);
2393 VisitDecl(S->getProtocol());
2396 void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) {
2397 VisitExpr(S);
2398 VisitDecl(S->getDecl());
2399 ID.AddBoolean(S->isArrow());
2400 ID.AddBoolean(S->isFreeIvar());
2403 void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) {
2404 VisitExpr(S);
2405 if (S->isImplicitProperty()) {
2406 VisitDecl(S->getImplicitPropertyGetter());
2407 VisitDecl(S->getImplicitPropertySetter());
2409 VisitDecl(S->getExplicitProperty());
2411 if (S->isSuperReceiver()) {
2412 ID.AddBoolean(S->isSuperReceiver());
2413 VisitType(S->getSuperReceiverType());
2417 void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) {
2418 VisitExpr(S);
2419 VisitDecl(S->getAtIndexMethodDecl());
2420 VisitDecl(S->setAtIndexMethodDecl());
2423 void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) {
2424 VisitExpr(S);
2425 VisitName(S->getSelector());
2426 VisitDecl(S->getMethodDecl());
2429 void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) {
2430 VisitExpr(S);
2431 ID.AddBoolean(S->isArrow());
2434 void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) {
2435 VisitExpr(S);
2436 ID.AddBoolean(S->getValue());
2440 const ObjCIndirectCopyRestoreExpr *S) {
2441 VisitExpr(S);
2442 ID.AddBoolean(S->shouldCopy());
2445 void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) {
2446 VisitExplicitCastExpr(S);
2447 ID.AddBoolean(S->getBridgeKind());
2451 const ObjCAvailabilityCheckExpr *S) {
2452 VisitExpr(S);
2722 const OpenACCComputeConstruct *S) {
2724 VisitStmt(S);
2727 P.VisitOpenACCClauseList(S->clauses());
2730 void StmtProfiler::VisitOpenACCLoopConstruct(const OpenACCLoopConstruct *S) {
2732 VisitStmt(S);
2735 P.VisitOpenACCClauseList(S->clauses());
2739 const OpenACCCombinedConstruct *S) {
2741 VisitStmt(S);
2744 P.VisitOpenACCClauseList(S->clauses());
2747 void StmtProfiler::VisitOpenACCDataConstruct(const OpenACCDataConstruct *S) {
2748 VisitStmt(S);
2751 P.VisitOpenACCClauseList(S->clauses());
2755 const OpenACCEnterDataConstruct *S) {
2756 VisitStmt(S);
2759 P.VisitOpenACCClauseList(S->clauses());
2763 const OpenACCExitDataConstruct *S) {
2764 VisitStmt(S);
2767 P.VisitOpenACCClauseList(S->clauses());
2771 const OpenACCHostDataConstruct *S) {
2772 VisitStmt(S);
2775 P.VisitOpenACCClauseList(S->clauses());
2778 void StmtProfiler::VisitOpenACCWaitConstruct(const OpenACCWaitConstruct *S) {
2780 VisitStmt(S);
2783 P.VisitOpenACCClauseList(S->clauses());
2786 void StmtProfiler::VisitOpenACCInitConstruct(const OpenACCInitConstruct *S) {
2787 VisitStmt(S);
2789 P.VisitOpenACCClauseList(S->clauses());
2793 const OpenACCShutdownConstruct *S) {
2794 VisitStmt(S);
2796 P.VisitOpenACCClauseList(S->clauses());
2799 void StmtProfiler::VisitOpenACCSetConstruct(const OpenACCSetConstruct *S) {
2800 VisitStmt(S);
2802 P.VisitOpenACCClauseList(S->clauses());
2806 const OpenACCUpdateConstruct *S) {
2807 VisitStmt(S);
2809 P.VisitOpenACCClauseList(S->clauses());
2812 void StmtProfiler::VisitHLSLOutArgExpr(const HLSLOutArgExpr *S) {
2813 VisitStmt(S);