Lines Matching full: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);
63 /// Visit identifiers that are not in Decl's or Type's.
112 // TODO: Why do we need to include the type in the profile? It's not
121 // function parameters, so we will use the parameter's type for
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::VisitObjCForCollectionStmt(const ObjCForCollectionStmt *S) {
396 VisitStmt(S);
399 void StmtProfiler::VisitObjCAtCatchStmt(const ObjCAtCatchStmt *S) {
400 VisitStmt(S);
401 ID.AddBoolean(S->hasEllipsis());
402 if (S->getCatchParamDecl())
403 VisitType(S->getCatchParamDecl()->getType());
406 void StmtProfiler::VisitObjCAtFinallyStmt(const ObjCAtFinallyStmt *S) {
407 VisitStmt(S);
410 void StmtProfiler::VisitObjCAtTryStmt(const ObjCAtTryStmt *S) {
411 VisitStmt(S);
415 StmtProfiler::VisitObjCAtSynchronizedStmt(const ObjCAtSynchronizedStmt *S) {
416 VisitStmt(S);
419 void StmtProfiler::VisitObjCAtThrowStmt(const ObjCAtThrowStmt *S) {
420 VisitStmt(S);
424 StmtProfiler::VisitObjCAutoreleasePoolStmt(const ObjCAutoreleasePoolStmt *S) {
425 VisitStmt(S);
446 if (auto *S = C->getPreInitStmt())
447 Profiler->VisitStmt(S);
560 if (auto *S = C->getChunkSize())
561 Profiler->VisitStmt(S);
941 StmtProfiler::VisitOMPExecutableDirective(const OMPExecutableDirective *S) {
942 VisitStmt(S);
944 ArrayRef<OMPClause *> Clauses = S->clauses();
955 void StmtProfiler::VisitOMPLoopBasedDirective(const OMPLoopBasedDirective *S) {
956 VisitOMPExecutableDirective(S);
959 void StmtProfiler::VisitOMPLoopDirective(const OMPLoopDirective *S) {
960 VisitOMPLoopBasedDirective(S);
963 void StmtProfiler::VisitOMPMetaDirective(const OMPMetaDirective *S) {
964 VisitOMPExecutableDirective(S);
967 void StmtProfiler::VisitOMPParallelDirective(const OMPParallelDirective *S) {
968 VisitOMPExecutableDirective(S);
971 void StmtProfiler::VisitOMPSimdDirective(const OMPSimdDirective *S) {
972 VisitOMPLoopDirective(S);
976 const OMPLoopTransformationDirective *S) {
977 VisitOMPLoopBasedDirective(S);
980 void StmtProfiler::VisitOMPTileDirective(const OMPTileDirective *S) {
981 VisitOMPLoopTransformationDirective(S);
984 void StmtProfiler::VisitOMPUnrollDirective(const OMPUnrollDirective *S) {
985 VisitOMPLoopTransformationDirective(S);
988 void StmtProfiler::VisitOMPReverseDirective(const OMPReverseDirective *S) {
989 VisitOMPLoopTransformationDirective(S);
993 const OMPInterchangeDirective *S) {
994 VisitOMPLoopTransformationDirective(S);
997 void StmtProfiler::VisitOMPForDirective(const OMPForDirective *S) {
998 VisitOMPLoopDirective(S);
1001 void StmtProfiler::VisitOMPForSimdDirective(const OMPForSimdDirective *S) {
1002 VisitOMPLoopDirective(S);
1005 void StmtProfiler::VisitOMPSectionsDirective(const OMPSectionsDirective *S) {
1006 VisitOMPExecutableDirective(S);
1009 void StmtProfiler::VisitOMPSectionDirective(const OMPSectionDirective *S) {
1010 VisitOMPExecutableDirective(S);
1013 void StmtProfiler::VisitOMPScopeDirective(const OMPScopeDirective *S) {
1014 VisitOMPExecutableDirective(S);
1017 void StmtProfiler::VisitOMPSingleDirective(const OMPSingleDirective *S) {
1018 VisitOMPExecutableDirective(S);
1021 void StmtProfiler::VisitOMPMasterDirective(const OMPMasterDirective *S) {
1022 VisitOMPExecutableDirective(S);
1025 void StmtProfiler::VisitOMPCriticalDirective(const OMPCriticalDirective *S) {
1026 VisitOMPExecutableDirective(S);
1027 VisitName(S->getDirectiveName().getName());
1031 StmtProfiler::VisitOMPParallelForDirective(const OMPParallelForDirective *S) {
1032 VisitOMPLoopDirective(S);
1036 const OMPParallelForSimdDirective *S) {
1037 VisitOMPLoopDirective(S);
1041 const OMPParallelMasterDirective *S) {
1042 VisitOMPExecutableDirective(S);
1046 const OMPParallelMaskedDirective *S) {
1047 VisitOMPExecutableDirective(S);
1051 const OMPParallelSectionsDirective *S) {
1052 VisitOMPExecutableDirective(S);
1055 void StmtProfiler::VisitOMPTaskDirective(const OMPTaskDirective *S) {
1056 VisitOMPExecutableDirective(S);
1059 void StmtProfiler::VisitOMPTaskyieldDirective(const OMPTaskyieldDirective *S) {
1060 VisitOMPExecutableDirective(S);
1063 void StmtProfiler::VisitOMPBarrierDirective(const OMPBarrierDirective *S) {
1064 VisitOMPExecutableDirective(S);
1067 void StmtProfiler::VisitOMPTaskwaitDirective(const OMPTaskwaitDirective *S) {
1068 VisitOMPExecutableDirective(S);
1071 void StmtProfiler::VisitOMPErrorDirective(const OMPErrorDirective *S) {
1072 VisitOMPExecutableDirective(S);
1074 void StmtProfiler::VisitOMPTaskgroupDirective(const OMPTaskgroupDirective *S) {
1075 VisitOMPExecutableDirective(S);
1076 if (const Expr *E = S->getReductionRef())
1080 void StmtProfiler::VisitOMPFlushDirective(const OMPFlushDirective *S) {
1081 VisitOMPExecutableDirective(S);
1084 void StmtProfiler::VisitOMPDepobjDirective(const OMPDepobjDirective *S) {
1085 VisitOMPExecutableDirective(S);
1088 void StmtProfiler::VisitOMPScanDirective(const OMPScanDirective *S) {
1089 VisitOMPExecutableDirective(S);
1092 void StmtProfiler::VisitOMPOrderedDirective(const OMPOrderedDirective *S) {
1093 VisitOMPExecutableDirective(S);
1096 void StmtProfiler::VisitOMPAtomicDirective(const OMPAtomicDirective *S) {
1097 VisitOMPExecutableDirective(S);
1100 void StmtProfiler::VisitOMPTargetDirective(const OMPTargetDirective *S) {
1101 VisitOMPExecutableDirective(S);
1104 void StmtProfiler::VisitOMPTargetDataDirective(const OMPTargetDataDirective *S) {
1105 VisitOMPExecutableDirective(S);
1109 const OMPTargetEnterDataDirective *S) {
1110 VisitOMPExecutableDirective(S);
1114 const OMPTargetExitDataDirective *S) {
1115 VisitOMPExecutableDirective(S);
1119 const OMPTargetParallelDirective *S) {
1120 VisitOMPExecutableDirective(S);
1124 const OMPTargetParallelForDirective *S) {
1125 VisitOMPExecutableDirective(S);
1128 void StmtProfiler::VisitOMPTeamsDirective(const OMPTeamsDirective *S) {
1129 VisitOMPExecutableDirective(S);
1133 const OMPCancellationPointDirective *S) {
1134 VisitOMPExecutableDirective(S);
1137 void StmtProfiler::VisitOMPCancelDirective(const OMPCancelDirective *S) {
1138 VisitOMPExecutableDirective(S);
1141 void StmtProfiler::VisitOMPTaskLoopDirective(const OMPTaskLoopDirective *S) {
1142 VisitOMPLoopDirective(S);
1146 const OMPTaskLoopSimdDirective *S) {
1147 VisitOMPLoopDirective(S);
1151 const OMPMasterTaskLoopDirective *S) {
1152 VisitOMPLoopDirective(S);
1156 const OMPMaskedTaskLoopDirective *S) {
1157 VisitOMPLoopDirective(S);
1161 const OMPMasterTaskLoopSimdDirective *S) {
1162 VisitOMPLoopDirective(S);
1166 const OMPMaskedTaskLoopSimdDirective *S) {
1167 VisitOMPLoopDirective(S);
1171 const OMPParallelMasterTaskLoopDirective *S) {
1172 VisitOMPLoopDirective(S);
1176 const OMPParallelMaskedTaskLoopDirective *S) {
1177 VisitOMPLoopDirective(S);
1181 const OMPParallelMasterTaskLoopSimdDirective *S) {
1182 VisitOMPLoopDirective(S);
1186 const OMPParallelMaskedTaskLoopSimdDirective *S) {
1187 VisitOMPLoopDirective(S);
1191 const OMPDistributeDirective *S) {
1192 VisitOMPLoopDirective(S);
1198 if (auto *S = C->getChunkSize())
1199 Profiler->VisitStmt(S);
1205 const OMPTargetUpdateDirective *S) {
1206 VisitOMPExecutableDirective(S);
1210 const OMPDistributeParallelForDirective *S) {
1211 VisitOMPLoopDirective(S);
1215 const OMPDistributeParallelForSimdDirective *S) {
1216 VisitOMPLoopDirective(S);
1220 const OMPDistributeSimdDirective *S) {
1221 VisitOMPLoopDirective(S);
1225 const OMPTargetParallelForSimdDirective *S) {
1226 VisitOMPLoopDirective(S);
1230 const OMPTargetSimdDirective *S) {
1231 VisitOMPLoopDirective(S);
1235 const OMPTeamsDistributeDirective *S) {
1236 VisitOMPLoopDirective(S);
1240 const OMPTeamsDistributeSimdDirective *S) {
1241 VisitOMPLoopDirective(S);
1245 const OMPTeamsDistributeParallelForSimdDirective *S) {
1246 VisitOMPLoopDirective(S);
1250 const OMPTeamsDistributeParallelForDirective *S) {
1251 VisitOMPLoopDirective(S);
1255 const OMPTargetTeamsDirective *S) {
1256 VisitOMPExecutableDirective(S);
1260 const OMPTargetTeamsDistributeDirective *S) {
1261 VisitOMPLoopDirective(S);
1265 const OMPTargetTeamsDistributeParallelForDirective *S) {
1266 VisitOMPLoopDirective(S);
1270 const OMPTargetTeamsDistributeParallelForSimdDirective *S) {
1271 VisitOMPLoopDirective(S);
1275 const OMPTargetTeamsDistributeSimdDirective *S) {
1276 VisitOMPLoopDirective(S);
1279 void StmtProfiler::VisitOMPInteropDirective(const OMPInteropDirective *S) {
1280 VisitOMPExecutableDirective(S);
1283 void StmtProfiler::VisitOMPDispatchDirective(const OMPDispatchDirective *S) {
1284 VisitOMPExecutableDirective(S);
1287 void StmtProfiler::VisitOMPMaskedDirective(const OMPMaskedDirective *S) {
1288 VisitOMPExecutableDirective(S);
1292 const OMPGenericLoopDirective *S) {
1293 VisitOMPLoopDirective(S);
1297 const OMPTeamsGenericLoopDirective *S) {
1298 VisitOMPLoopDirective(S);
1302 const OMPTargetTeamsGenericLoopDirective *S) {
1303 VisitOMPLoopDirective(S);
1307 const OMPParallelGenericLoopDirective *S) {
1308 VisitOMPLoopDirective(S);
1312 const OMPTargetParallelGenericLoopDirective *S) {
1313 VisitOMPLoopDirective(S);
1316 void StmtProfiler::VisitExpr(const Expr *S) {
1317 VisitStmt(S);
1320 void StmtProfiler::VisitConstantExpr(const ConstantExpr *S) {
1321 VisitExpr(S);
1324 void StmtProfiler::VisitDeclRefExpr(const DeclRefExpr *S) {
1325 VisitExpr(S);
1327 VisitNestedNameSpecifier(S->getQualifier());
1328 VisitDecl(S->getDecl());
1330 ID.AddBoolean(S->hasExplicitTemplateArgs());
1331 if (S->hasExplicitTemplateArgs())
1332 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
1337 const SYCLUniqueStableNameExpr *S) {
1338 VisitExpr(S);
1339 VisitType(S->getTypeSourceInfo()->getType());
1342 void StmtProfiler::VisitPredefinedExpr(const PredefinedExpr *S) {
1343 VisitExpr(S);
1344 ID.AddInteger(llvm::to_underlying(S->getIdentKind()));
1347 void StmtProfiler::VisitIntegerLiteral(const IntegerLiteral *S) {
1348 VisitExpr(S);
1349 S->getValue().Profile(ID);
1351 QualType T = S->getType();
1361 void StmtProfiler::VisitFixedPointLiteral(const FixedPointLiteral *S) {
1362 VisitExpr(S);
1363 S->getValue().Profile(ID);
1364 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1367 void StmtProfiler::VisitCharacterLiteral(const CharacterLiteral *S) {
1368 VisitExpr(S);
1369 ID.AddInteger(llvm::to_underlying(S->getKind()));
1370 ID.AddInteger(S->getValue());
1373 void StmtProfiler::VisitFloatingLiteral(const FloatingLiteral *S) {
1374 VisitExpr(S);
1375 S->getValue().Profile(ID);
1376 ID.AddBoolean(S->isExact());
1377 ID.AddInteger(S->getType()->castAs<BuiltinType>()->getKind());
1380 void StmtProfiler::VisitImaginaryLiteral(const ImaginaryLiteral *S) {
1381 VisitExpr(S);
1384 void StmtProfiler::VisitStringLiteral(const StringLiteral *S) {
1385 VisitExpr(S);
1386 ID.AddString(S->getBytes());
1387 ID.AddInteger(llvm::to_underlying(S->getKind()));
1390 void StmtProfiler::VisitParenExpr(const ParenExpr *S) {
1391 VisitExpr(S);
1394 void StmtProfiler::VisitParenListExpr(const ParenListExpr *S) {
1395 VisitExpr(S);
1398 void StmtProfiler::VisitUnaryOperator(const UnaryOperator *S) {
1399 VisitExpr(S);
1400 ID.AddInteger(S->getOpcode());
1403 void StmtProfiler::VisitOffsetOfExpr(const OffsetOfExpr *S) {
1404 VisitType(S->getTypeSourceInfo()->getType());
1405 unsigned n = S->getNumComponents();
1407 const OffsetOfNode &ON = S->getComponent(i);
1428 VisitExpr(S);
1432 StmtProfiler::VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *S) {
1433 VisitExpr(S);
1434 ID.AddInteger(S->getKind());
1435 if (S->isArgumentType())
1436 VisitType(S->getArgumentType());
1439 void StmtProfiler::VisitArraySubscriptExpr(const ArraySubscriptExpr *S) {
1440 VisitExpr(S);
1443 void StmtProfiler::VisitMatrixSubscriptExpr(const MatrixSubscriptExpr *S) {
1444 VisitExpr(S);
1447 void StmtProfiler::VisitArraySectionExpr(const ArraySectionExpr *S) {
1448 VisitExpr(S);
1451 void StmtProfiler::VisitOMPArrayShapingExpr(const OMPArrayShapingExpr *S) {
1452 VisitExpr(S);
1455 void StmtProfiler::VisitOMPIteratorExpr(const OMPIteratorExpr *S) {
1456 VisitExpr(S);
1457 for (unsigned I = 0, E = S->numOfIterators(); I < E; ++I)
1458 VisitDecl(S->getIteratorDecl(I));
1461 void StmtProfiler::VisitCallExpr(const CallExpr *S) {
1462 VisitExpr(S);
1465 void StmtProfiler::VisitMemberExpr(const MemberExpr *S) {
1466 VisitExpr(S);
1467 VisitDecl(S->getMemberDecl());
1469 VisitNestedNameSpecifier(S->getQualifier());
1470 ID.AddBoolean(S->isArrow());
1473 void StmtProfiler::VisitCompoundLiteralExpr(const CompoundLiteralExpr *S) {
1474 VisitExpr(S);
1475 ID.AddBoolean(S->isFileScope());
1478 void StmtProfiler::VisitCastExpr(const CastExpr *S) {
1479 VisitExpr(S);
1482 void StmtProfiler::VisitImplicitCastExpr(const ImplicitCastExpr *S) {
1483 VisitCastExpr(S);
1484 ID.AddInteger(S->getValueKind());
1487 void StmtProfiler::VisitExplicitCastExpr(const ExplicitCastExpr *S) {
1488 VisitCastExpr(S);
1489 VisitType(S->getTypeAsWritten());
1492 void StmtProfiler::VisitCStyleCastExpr(const CStyleCastExpr *S) {
1493 VisitExplicitCastExpr(S);
1496 void StmtProfiler::VisitBinaryOperator(const BinaryOperator *S) {
1497 VisitExpr(S);
1498 ID.AddInteger(S->getOpcode());
1502 StmtProfiler::VisitCompoundAssignOperator(const CompoundAssignOperator *S) {
1503 VisitBinaryOperator(S);
1506 void StmtProfiler::VisitConditionalOperator(const ConditionalOperator *S) {
1507 VisitExpr(S);
1511 const BinaryConditionalOperator *S) {
1512 VisitExpr(S);
1515 void StmtProfiler::VisitAddrLabelExpr(const AddrLabelExpr *S) {
1516 VisitExpr(S);
1517 VisitDecl(S->getLabel());
1520 void StmtProfiler::VisitStmtExpr(const StmtExpr *S) {
1521 VisitExpr(S);
1524 void StmtProfiler::VisitShuffleVectorExpr(const ShuffleVectorExpr *S) {
1525 VisitExpr(S);
1528 void StmtProfiler::VisitConvertVectorExpr(const ConvertVectorExpr *S) {
1529 VisitExpr(S);
1532 void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) {
1533 VisitExpr(S);
1536 void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
1537 VisitExpr(S);
1540 void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
1541 VisitExpr(S);
1544 void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
1545 if (S->getSyntacticForm()) {
1546 VisitInitListExpr(S->getSyntacticForm());
1550 VisitExpr(S);
1553 void StmtProfiler::VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
1554 VisitExpr(S);
1555 ID.AddBoolean(S->usesGNUSyntax());
1556 for (const DesignatedInitExpr::Designator &D : S->designators()) {
1576 const DesignatedInitUpdateExpr *S) {
1581 void StmtProfiler::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *S) {
1582 VisitExpr(S);
1585 void StmtProfiler::VisitArrayInitIndexExpr(const ArrayInitIndexExpr *S) {
1586 VisitExpr(S);
1589 void StmtProfiler::VisitNoInitExpr(const NoInitExpr *S) {
1593 void StmtProfiler::VisitImplicitValueInitExpr(const ImplicitValueInitExpr *S) {
1594 VisitExpr(S);
1597 void StmtProfiler::VisitExtVectorElementExpr(const ExtVectorElementExpr *S) {
1598 VisitExpr(S);
1599 VisitName(&S->getAccessor());
1602 void StmtProfiler::VisitBlockExpr(const BlockExpr *S) {
1603 VisitExpr(S);
1604 VisitDecl(S->getBlockDecl());
1607 void StmtProfiler::VisitGenericSelectionExpr(const GenericSelectionExpr *S) {
1608 VisitExpr(S);
1610 S->associations()) {
1620 void StmtProfiler::VisitPseudoObjectExpr(const PseudoObjectExpr *S) {
1621 VisitExpr(S);
1623 i = S->semantics_begin(), e = S->semantics_end(); i != e; ++i)
1629 void StmtProfiler::VisitAtomicExpr(const AtomicExpr *S) {
1630 VisitExpr(S);
1631 ID.AddInteger(S->getOp());
1635 const ConceptSpecializationExpr *S) {
1636 VisitExpr(S);
1637 VisitDecl(S->getNamedConcept());
1638 for (const TemplateArgument &Arg : S->getTemplateArguments())
1642 void StmtProfiler::VisitRequiresExpr(const RequiresExpr *S) {
1643 VisitExpr(S);
1644 ID.AddInteger(S->getLocalParameters().size());
1645 for (ParmVarDecl *LocalParam : S->getLocalParameters())
1647 ID.AddInteger(S->getRequirements().size());
1648 for (concepts::Requirement *Req : S->getRequirements()) {
1685 static Stmt::StmtClass DecodeOperatorCall(const CXXOperatorCallExpr *S,
1689 switch (S->getOperator()) {
1889 void StmtProfiler::VisitCXXOperatorCallExpr(const CXXOperatorCallExpr *S) {
1890 if (S->isTypeDependent()) {
1896 if (S->getOperator() == OO_Arrow)
1897 return Visit(S->getArg(0));
1901 unsigned NumArgs = S->getNumArgs();
1902 Stmt::StmtClass SC = DecodeOperatorCall(S, UnaryOp, BinaryOp, NumArgs);
1906 Visit(S->getArg(I));
1918 VisitCallExpr(S);
1919 ID.AddInteger(S->getOperator());
1923 const CXXRewrittenBinaryOperator *S) {
1926 assert(!S->isTypeDependent() &&
1928 ID.AddBoolean(S->isReversed());
1929 VisitExpr(S->getSemanticForm());
1938 void StmtProfiler::VisitCXXMemberCallExpr(const CXXMemberCallExpr *S) {
1939 VisitCallExpr(S);
1942 void StmtProfiler::VisitCUDAKernelCallExpr(const CUDAKernelCallExpr *S) {
1943 VisitCallExpr(S);
1946 void StmtProfiler::VisitAsTypeExpr(const AsTypeExpr *S) {
1947 VisitExpr(S);
1950 void StmtProfiler::VisitCXXNamedCastExpr(const CXXNamedCastExpr *S) {
1951 VisitExplicitCastExpr(S);
1954 void StmtProfiler::VisitCXXStaticCastExpr(const CXXStaticCastExpr *S) {
1955 VisitCXXNamedCastExpr(S);
1958 void StmtProfiler::VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *S) {
1959 VisitCXXNamedCastExpr(S);
1963 StmtProfiler::VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *S) {
1964 VisitCXXNamedCastExpr(S);
1967 void StmtProfiler::VisitCXXConstCastExpr(const CXXConstCastExpr *S) {
1968 VisitCXXNamedCastExpr(S);
1971 void StmtProfiler::VisitBuiltinBitCastExpr(const BuiltinBitCastExpr *S) {
1972 VisitExpr(S);
1973 VisitType(S->getTypeInfoAsWritten()->getType());
1976 void StmtProfiler::VisitCXXAddrspaceCastExpr(const CXXAddrspaceCastExpr *S) {
1977 VisitCXXNamedCastExpr(S);
1980 void StmtProfiler::VisitUserDefinedLiteral(const UserDefinedLiteral *S) {
1981 VisitCallExpr(S);
1984 void StmtProfiler::VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *S) {
1985 VisitExpr(S);
1986 ID.AddBoolean(S->getValue());
1989 void StmtProfiler::VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *S) {
1990 VisitExpr(S);
1994 const CXXStdInitializerListExpr *S) {
1995 VisitExpr(S);
1998 void StmtProfiler::VisitCXXTypeidExpr(const CXXTypeidExpr *S) {
1999 VisitExpr(S);
2000 if (S->isTypeOperand())
2001 VisitType(S->getTypeOperandSourceInfo()->getType());
2004 void StmtProfiler::VisitCXXUuidofExpr(const CXXUuidofExpr *S) {
2005 VisitExpr(S);
2006 if (S->isTypeOperand())
2007 VisitType(S->getTypeOperandSourceInfo()->getType());
2010 void StmtProfiler::VisitMSPropertyRefExpr(const MSPropertyRefExpr *S) {
2011 VisitExpr(S);
2012 VisitDecl(S->getPropertyDecl());
2016 const MSPropertySubscriptExpr *S) {
2017 VisitExpr(S);
2020 void StmtProfiler::VisitCXXThisExpr(const CXXThisExpr *S) {
2021 VisitExpr(S);
2022 ID.AddBoolean(S->isImplicit());
2023 ID.AddBoolean(S->isCapturedByCopyInLambdaWithExplicitObjectParameter());
2026 void StmtProfiler::VisitCXXThrowExpr(const CXXThrowExpr *S) {
2027 VisitExpr(S);
2030 void StmtProfiler::VisitCXXDefaultArgExpr(const CXXDefaultArgExpr *S) {
2031 VisitExpr(S);
2032 VisitDecl(S->getParam());
2035 void StmtProfiler::VisitCXXDefaultInitExpr(const CXXDefaultInitExpr *S) {
2036 VisitExpr(S);
2037 VisitDecl(S->getField());
2040 void StmtProfiler::VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *S) {
2041 VisitExpr(S);
2043 const_cast<CXXDestructorDecl *>(S->getTemporary()->getDestructor()));
2046 void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) {
2047 VisitExpr(S);
2048 VisitDecl(S->getConstructor());
2049 ID.AddBoolean(S->isElidable());
2053 const CXXInheritedCtorInitExpr *S) {
2054 VisitExpr(S);
2055 VisitDecl(S->getConstructor());
2058 void StmtProfiler::VisitCXXFunctionalCastExpr(const CXXFunctionalCastExpr *S) {
2059 VisitExplicitCastExpr(S);
2063 StmtProfiler::VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *S) {
2064 VisitCXXConstructExpr(S);
2068 StmtProfiler::VisitLambdaExpr(const LambdaExpr *S) {
2073 VisitStmtNoChildren(S);
2077 VisitDecl(S->getLambdaClass());
2082 CXXRecordDecl *Lambda = S->getLambdaClass();
2111 StmtProfiler::VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *S) {
2112 VisitExpr(S);
2115 void StmtProfiler::VisitCXXDeleteExpr(const CXXDeleteExpr *S) {
2116 VisitExpr(S);
2117 ID.AddBoolean(S->isGlobalDelete());
2118 ID.AddBoolean(S->isArrayForm());
2119 VisitDecl(S->getOperatorDelete());
2122 void StmtProfiler::VisitCXXNewExpr(const CXXNewExpr *S) {
2123 VisitExpr(S);
2124 VisitType(S->getAllocatedType());
2125 VisitDecl(S->getOperatorNew());
2126 VisitDecl(S->getOperatorDelete());
2127 ID.AddBoolean(S->isArray());
2128 ID.AddInteger(S->getNumPlacementArgs());
2129 ID.AddBoolean(S->isGlobalNew());
2130 ID.AddBoolean(S->isParenTypeId());
2131 ID.AddInteger(llvm::to_underlying(S->getInitializationStyle()));
2135 StmtProfiler::VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
2136 VisitExpr(S);
2137 ID.AddBoolean(S->isArrow());
2138 VisitNestedNameSpecifier(S->getQualifier());
2139 ID.AddBoolean(S->getScopeTypeInfo() != nullptr);
2140 if (S->getScopeTypeInfo())
2141 VisitType(S->getScopeTypeInfo()->getType());
2142 ID.AddBoolean(S->getDestroyedTypeInfo() != nullptr);
2143 if (S->getDestroyedTypeInfo())
2144 VisitType(S->getDestroyedType());
2146 VisitIdentifierInfo(S->getDestroyedTypeIdentifier());
2149 void StmtProfiler::VisitOverloadExpr(const OverloadExpr *S) {
2150 VisitExpr(S);
2151 VisitNestedNameSpecifier(S->getQualifier());
2152 VisitName(S->getName(), /*TreatAsDecl*/ true);
2153 ID.AddBoolean(S->hasExplicitTemplateArgs());
2154 if (S->hasExplicitTemplateArgs())
2155 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2159 StmtProfiler::VisitUnresolvedLookupExpr(const UnresolvedLookupExpr *S) {
2160 VisitOverloadExpr(S);
2163 void StmtProfiler::VisitTypeTraitExpr(const TypeTraitExpr *S) {
2164 VisitExpr(S);
2165 ID.AddInteger(S->getTrait());
2166 ID.AddInteger(S->getNumArgs());
2167 for (unsigned I = 0, N = S->getNumArgs(); I != N; ++I)
2168 VisitType(S->getArg(I)->getType());
2171 void StmtProfiler::VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *S) {
2172 VisitExpr(S);
2173 ID.AddInteger(S->getTrait());
2174 VisitType(S->getQueriedType());
2177 void StmtProfiler::VisitExpressionTraitExpr(const ExpressionTraitExpr *S) {
2178 VisitExpr(S);
2179 ID.AddInteger(S->getTrait());
2180 VisitExpr(S->getQueriedExpression());
2184 const DependentScopeDeclRefExpr *S) {
2185 VisitExpr(S);
2186 VisitName(S->getDeclName());
2187 VisitNestedNameSpecifier(S->getQualifier());
2188 ID.AddBoolean(S->hasExplicitTemplateArgs());
2189 if (S->hasExplicitTemplateArgs())
2190 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2193 void StmtProfiler::VisitExprWithCleanups(const ExprWithCleanups *S) {
2194 VisitExpr(S);
2198 const CXXUnresolvedConstructExpr *S) {
2199 VisitExpr(S);
2200 VisitType(S->getTypeAsWritten());
2201 ID.AddInteger(S->isListInitialization());
2205 const CXXDependentScopeMemberExpr *S) {
2206 ID.AddBoolean(S->isImplicitAccess());
2207 if (!S->isImplicitAccess()) {
2208 VisitExpr(S);
2209 ID.AddBoolean(S->isArrow());
2211 VisitNestedNameSpecifier(S->getQualifier());
2212 VisitName(S->getMember());
2213 ID.AddBoolean(S->hasExplicitTemplateArgs());
2214 if (S->hasExplicitTemplateArgs())
2215 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2218 void StmtProfiler::VisitUnresolvedMemberExpr(const UnresolvedMemberExpr *S) {
2219 ID.AddBoolean(S->isImplicitAccess());
2220 if (!S->isImplicitAccess()) {
2221 VisitExpr(S);
2222 ID.AddBoolean(S->isArrow());
2224 VisitNestedNameSpecifier(S->getQualifier());
2225 VisitName(S->getMemberName());
2226 ID.AddBoolean(S->hasExplicitTemplateArgs());
2227 if (S->hasExplicitTemplateArgs())
2228 VisitTemplateArguments(S->getTemplateArgs(), S->getNumTemplateArgs());
2231 void StmtProfiler::VisitCXXNoexceptExpr(const CXXNoexceptExpr *S) {
2232 VisitExpr(S);
2235 void StmtProfiler::VisitPackExpansionExpr(const PackExpansionExpr *S) {
2236 VisitExpr(S);
2239 void StmtProfiler::VisitSizeOfPackExpr(const SizeOfPackExpr *S) {
2240 VisitExpr(S);
2241 VisitDecl(S->getPack());
2242 if (S->isPartiallySubstituted()) {
2243 auto Args = S->getPartialArguments();
2259 const SubstNonTypeTemplateParmPackExpr *S) {
2260 VisitExpr(S);
2261 VisitDecl(S->getParameterPack());
2262 VisitTemplateArgument(S->getArgumentPack());
2271 void StmtProfiler::VisitFunctionParmPackExpr(const FunctionParmPackExpr *S) {
2272 VisitExpr(S);
2273 VisitDecl(S->getParameterPack());
2274 ID.AddInteger(S->getNumExpansions());
2275 for (FunctionParmPackExpr::iterator I = S->begin(), E = S->end(); I != E; ++I)
2280 const MaterializeTemporaryExpr *S) {
2281 VisitExpr(S);
2284 void StmtProfiler::VisitCXXFoldExpr(const CXXFoldExpr *S) {
2285 VisitExpr(S);
2286 ID.AddInteger(S->getOperator());
2289 void StmtProfiler::VisitCXXParenListInitExpr(const CXXParenListInitExpr *S) {
2290 VisitExpr(S);
2293 void StmtProfiler::VisitCoroutineBodyStmt(const CoroutineBodyStmt *S) {
2294 VisitStmt(S);
2297 void StmtProfiler::VisitCoreturnStmt(const CoreturnStmt *S) {
2298 VisitStmt(S);
2301 void StmtProfiler::VisitCoawaitExpr(const CoawaitExpr *S) {
2302 VisitExpr(S);
2305 void StmtProfiler::VisitDependentCoawaitExpr(const DependentCoawaitExpr *S) {
2306 VisitExpr(S);
2309 void StmtProfiler::VisitCoyieldExpr(const CoyieldExpr *S) {
2310 VisitExpr(S);
2329 void StmtProfiler::VisitObjCStringLiteral(const ObjCStringLiteral *S) {
2330 VisitExpr(S);
2345 void StmtProfiler::VisitObjCEncodeExpr(const ObjCEncodeExpr *S) {
2346 VisitExpr(S);
2347 VisitType(S->getEncodedType());
2350 void StmtProfiler::VisitObjCSelectorExpr(const ObjCSelectorExpr *S) {
2351 VisitExpr(S);
2352 VisitName(S->getSelector());
2355 void StmtProfiler::VisitObjCProtocolExpr(const ObjCProtocolExpr *S) {
2356 VisitExpr(S);
2357 VisitDecl(S->getProtocol());
2360 void StmtProfiler::VisitObjCIvarRefExpr(const ObjCIvarRefExpr *S) {
2361 VisitExpr(S);
2362 VisitDecl(S->getDecl());
2363 ID.AddBoolean(S->isArrow());
2364 ID.AddBoolean(S->isFreeIvar());
2367 void StmtProfiler::VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *S) {
2368 VisitExpr(S);
2369 if (S->isImplicitProperty()) {
2370 VisitDecl(S->getImplicitPropertyGetter());
2371 VisitDecl(S->getImplicitPropertySetter());
2373 VisitDecl(S->getExplicitProperty());
2375 if (S->isSuperReceiver()) {
2376 ID.AddBoolean(S->isSuperReceiver());
2377 VisitType(S->getSuperReceiverType());
2381 void StmtProfiler::VisitObjCSubscriptRefExpr(const ObjCSubscriptRefExpr *S) {
2382 VisitExpr(S);
2383 VisitDecl(S->getAtIndexMethodDecl());
2384 VisitDecl(S->setAtIndexMethodDecl());
2387 void StmtProfiler::VisitObjCMessageExpr(const ObjCMessageExpr *S) {
2388 VisitExpr(S);
2389 VisitName(S->getSelector());
2390 VisitDecl(S->getMethodDecl());
2393 void StmtProfiler::VisitObjCIsaExpr(const ObjCIsaExpr *S) {
2394 VisitExpr(S);
2395 ID.AddBoolean(S->isArrow());
2398 void StmtProfiler::VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *S) {
2399 VisitExpr(S);
2400 ID.AddBoolean(S->getValue());
2404 const ObjCIndirectCopyRestoreExpr *S) {
2405 VisitExpr(S);
2406 ID.AddBoolean(S->shouldCopy());
2409 void StmtProfiler::VisitObjCBridgedCastExpr(const ObjCBridgedCastExpr *S) {
2410 VisitExplicitCastExpr(S);
2411 ID.AddBoolean(S->getBridgeKind());
2415 const ObjCAvailabilityCheckExpr *S) {
2416 VisitExpr(S);
2618 const OpenACCComputeConstruct *S) {
2620 VisitStmt(S);
2623 P.VisitOpenACCClauseList(S->clauses());
2626 void StmtProfiler::VisitOpenACCLoopConstruct(const OpenACCLoopConstruct *S) {
2628 VisitStmt(S);
2631 P.VisitOpenACCClauseList(S->clauses());