clang/AST/AttrNodeTraverse.inc

0001 /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
0002 |*                                                                            *|
0003 |* Attribute text node traverser                                              *|
0004 |*                                                                            *|
0005 |* Automatically generated file, do not edit!                                 *|
0006 |* From: Attr.td                                                              *|
0007 |*                                                                            *|
0008 \*===----------------------------------------------------------------------===*/
0009
0010   void VisitAMDGPUFlatWorkGroupSizeAttr(const AMDGPUFlatWorkGroupSizeAttr *A) {
0011     const auto *SA = cast<AMDGPUFlatWorkGroupSizeAttr>(A); (void)SA;
0012     Visit(SA->getMin());
0013     Visit(SA->getMax());
0014   }
0015   void VisitAMDGPUMaxNumWorkGroupsAttr(const AMDGPUMaxNumWorkGroupsAttr *A) {
0016     const auto *SA = cast<AMDGPUMaxNumWorkGroupsAttr>(A); (void)SA;
0017     Visit(SA->getMaxNumWorkGroupsX());
0018     Visit(SA->getMaxNumWorkGroupsY());
0019     Visit(SA->getMaxNumWorkGroupsZ());
0020   }
0021   void VisitAMDGPUWavesPerEUAttr(const AMDGPUWavesPerEUAttr *A) {
0022     const auto *SA = cast<AMDGPUWavesPerEUAttr>(A); (void)SA;
0023     Visit(SA->getMin());
0024     Visit(SA->getMax());
0025   }
0026   void VisitAcquireCapabilityAttr(const AcquireCapabilityAttr *A) {
0027     const auto *SA = cast<AcquireCapabilityAttr>(A); (void)SA;
0028     for (AcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0029       Visit(*I);
0030   }
0031   void VisitAcquiredAfterAttr(const AcquiredAfterAttr *A) {
0032     const auto *SA = cast<AcquiredAfterAttr>(A); (void)SA;
0033     for (AcquiredAfterAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0034       Visit(*I);
0035   }
0036   void VisitAcquiredBeforeAttr(const AcquiredBeforeAttr *A) {
0037     const auto *SA = cast<AcquiredBeforeAttr>(A); (void)SA;
0038     for (AcquiredBeforeAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0039       Visit(*I);
0040   }
0041   void VisitAlignValueAttr(const AlignValueAttr *A) {
0042     const auto *SA = cast<AlignValueAttr>(A); (void)SA;
0043     Visit(SA->getAlignment());
0044   }
0045   void VisitAlignedAttr(const AlignedAttr *A) {
0046     const auto *SA = cast<AlignedAttr>(A); (void)SA;
0047     if (SA->isAlignmentExpr())
0048       Visit(SA->getAlignmentExpr());
0049   }
0050   void VisitAnnotateAttr(const AnnotateAttr *A) {
0051     const auto *SA = cast<AnnotateAttr>(A); (void)SA;
0052     for (AnnotateAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0053       Visit(*I);
0054     for (AnnotateAttr::delayedArgs_iterator I = SA->delayedArgs_begin(), E = SA->delayedArgs_end(); I != E; ++I)
0055       Visit(*I);
0056   }
0057   void VisitAnnotateTypeAttr(const AnnotateTypeAttr *A) {
0058     const auto *SA = cast<AnnotateTypeAttr>(A); (void)SA;
0059     for (AnnotateTypeAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0060       Visit(*I);
0061     for (AnnotateTypeAttr::delayedArgs_iterator I = SA->delayedArgs_begin(), E = SA->delayedArgs_end(); I != E; ++I)
0062       Visit(*I);
0063   }
0064   void VisitAssertCapabilityAttr(const AssertCapabilityAttr *A) {
0065     const auto *SA = cast<AssertCapabilityAttr>(A); (void)SA;
0066     for (AssertCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0067       Visit(*I);
0068   }
0069   void VisitAssertExclusiveLockAttr(const AssertExclusiveLockAttr *A) {
0070     const auto *SA = cast<AssertExclusiveLockAttr>(A); (void)SA;
0071     for (AssertExclusiveLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0072       Visit(*I);
0073   }
0074   void VisitAssertSharedLockAttr(const AssertSharedLockAttr *A) {
0075     const auto *SA = cast<AssertSharedLockAttr>(A); (void)SA;
0076     for (AssertSharedLockAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0077       Visit(*I);
0078   }
0079   void VisitAssumeAlignedAttr(const AssumeAlignedAttr *A) {
0080     const auto *SA = cast<AssumeAlignedAttr>(A); (void)SA;
0081     Visit(SA->getAlignment());
0082     Visit(SA->getOffset());
0083   }
0084   void VisitCUDALaunchBoundsAttr(const CUDALaunchBoundsAttr *A) {
0085     const auto *SA = cast<CUDALaunchBoundsAttr>(A); (void)SA;
0086     Visit(SA->getMaxThreads());
0087     Visit(SA->getMinBlocks());
0088     Visit(SA->getMaxBlocks());
0089   }
0090   void VisitCXXAssumeAttr(const CXXAssumeAttr *A) {
0091     const auto *SA = cast<CXXAssumeAttr>(A); (void)SA;
0092     Visit(SA->getAssumption());
0093   }
0094   void VisitCodeAlignAttr(const CodeAlignAttr *A) {
0095     const auto *SA = cast<CodeAlignAttr>(A); (void)SA;
0096     Visit(SA->getAlignment());
0097   }
0098   void VisitCountedByAttr(const CountedByAttr *A) {
0099     const auto *SA = cast<CountedByAttr>(A); (void)SA;
0100     Visit(SA->getCount());
0101   }
0102   void VisitCountedByOrNullAttr(const CountedByOrNullAttr *A) {
0103     const auto *SA = cast<CountedByOrNullAttr>(A); (void)SA;
0104     Visit(SA->getCount());
0105   }
0106   void VisitDiagnoseIfAttr(const DiagnoseIfAttr *A) {
0107     const auto *SA = cast<DiagnoseIfAttr>(A); (void)SA;
0108     Visit(SA->getCond());
0109   }
0110   void VisitEnableIfAttr(const EnableIfAttr *A) {
0111     const auto *SA = cast<EnableIfAttr>(A); (void)SA;
0112     Visit(SA->getCond());
0113   }
0114   void VisitExclusiveTrylockFunctionAttr(const ExclusiveTrylockFunctionAttr *A) {
0115     const auto *SA = cast<ExclusiveTrylockFunctionAttr>(A); (void)SA;
0116     Visit(SA->getSuccessValue());
0117     for (ExclusiveTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0118       Visit(*I);
0119   }
0120   void VisitGuardedByAttr(const GuardedByAttr *A) {
0121     const auto *SA = cast<GuardedByAttr>(A); (void)SA;
0122     Visit(SA->getArg());
0123   }
0124   void VisitLockReturnedAttr(const LockReturnedAttr *A) {
0125     const auto *SA = cast<LockReturnedAttr>(A); (void)SA;
0126     Visit(SA->getArg());
0127   }
0128   void VisitLocksExcludedAttr(const LocksExcludedAttr *A) {
0129     const auto *SA = cast<LocksExcludedAttr>(A); (void)SA;
0130     for (LocksExcludedAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0131       Visit(*I);
0132   }
0133   void VisitLoopHintAttr(const LoopHintAttr *A) {
0134     const auto *SA = cast<LoopHintAttr>(A); (void)SA;
0135     Visit(SA->getValue());
0136   }
0137   void VisitNonAllocatingAttr(const NonAllocatingAttr *A) {
0138     const auto *SA = cast<NonAllocatingAttr>(A); (void)SA;
0139     Visit(SA->getCond());
0140   }
0141   void VisitNonBlockingAttr(const NonBlockingAttr *A) {
0142     const auto *SA = cast<NonBlockingAttr>(A); (void)SA;
0143     Visit(SA->getCond());
0144   }
0145   void VisitOMPAllocateDeclAttr(const OMPAllocateDeclAttr *A) {
0146     const auto *SA = cast<OMPAllocateDeclAttr>(A); (void)SA;
0147     Visit(SA->getAllocator());
0148     Visit(SA->getAlignment());
0149   }
0150   void VisitOMPDeclareSimdDeclAttr(const OMPDeclareSimdDeclAttr *A) {
0151     const auto *SA = cast<OMPDeclareSimdDeclAttr>(A); (void)SA;
0152     Visit(SA->getSimdlen());
0153     for (OMPDeclareSimdDeclAttr::uniforms_iterator I = SA->uniforms_begin(), E = SA->uniforms_end(); I != E; ++I)
0154       Visit(*I);
0155     for (OMPDeclareSimdDeclAttr::aligneds_iterator I = SA->aligneds_begin(), E = SA->aligneds_end(); I != E; ++I)
0156       Visit(*I);
0157     for (OMPDeclareSimdDeclAttr::alignments_iterator I = SA->alignments_begin(), E = SA->alignments_end(); I != E; ++I)
0158       Visit(*I);
0159     for (OMPDeclareSimdDeclAttr::linears_iterator I = SA->linears_begin(), E = SA->linears_end(); I != E; ++I)
0160       Visit(*I);
0161     for (OMPDeclareSimdDeclAttr::steps_iterator I = SA->steps_begin(), E = SA->steps_end(); I != E; ++I)
0162       Visit(*I);
0163   }
0164   void VisitOMPDeclareTargetDeclAttr(const OMPDeclareTargetDeclAttr *A) {
0165     const auto *SA = cast<OMPDeclareTargetDeclAttr>(A); (void)SA;
0166     Visit(SA->getIndirectExpr());
0167   }
0168   void VisitOMPDeclareVariantAttr(const OMPDeclareVariantAttr *A) {
0169     const auto *SA = cast<OMPDeclareVariantAttr>(A); (void)SA;
0170     Visit(SA->getVariantFuncRef());
0171     for (OMPDeclareVariantAttr::adjustArgsNothing_iterator I = SA->adjustArgsNothing_begin(), E = SA->adjustArgsNothing_end(); I != E; ++I)
0172       Visit(*I);
0173     for (OMPDeclareVariantAttr::adjustArgsNeedDevicePtr_iterator I = SA->adjustArgsNeedDevicePtr_begin(), E = SA->adjustArgsNeedDevicePtr_end(); I != E; ++I)
0174       Visit(*I);
0175   }
0176   void VisitOMPReferencedVarAttr(const OMPReferencedVarAttr *A) {
0177     const auto *SA = cast<OMPReferencedVarAttr>(A); (void)SA;
0178     Visit(SA->getRef());
0179   }
0180   void VisitPtGuardedByAttr(const PtGuardedByAttr *A) {
0181     const auto *SA = cast<PtGuardedByAttr>(A); (void)SA;
0182     Visit(SA->getArg());
0183   }
0184   void VisitReleaseCapabilityAttr(const ReleaseCapabilityAttr *A) {
0185     const auto *SA = cast<ReleaseCapabilityAttr>(A); (void)SA;
0186     for (ReleaseCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0187       Visit(*I);
0188   }
0189   void VisitRequiresCapabilityAttr(const RequiresCapabilityAttr *A) {
0190     const auto *SA = cast<RequiresCapabilityAttr>(A); (void)SA;
0191     for (RequiresCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0192       Visit(*I);
0193   }
0194   void VisitSharedTrylockFunctionAttr(const SharedTrylockFunctionAttr *A) {
0195     const auto *SA = cast<SharedTrylockFunctionAttr>(A); (void)SA;
0196     Visit(SA->getSuccessValue());
0197     for (SharedTrylockFunctionAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0198       Visit(*I);
0199   }
0200   void VisitSizedByAttr(const SizedByAttr *A) {
0201     const auto *SA = cast<SizedByAttr>(A); (void)SA;
0202     Visit(SA->getSize());
0203   }
0204   void VisitSizedByOrNullAttr(const SizedByOrNullAttr *A) {
0205     const auto *SA = cast<SizedByOrNullAttr>(A); (void)SA;
0206     Visit(SA->getSize());
0207   }
0208   void VisitSwiftVersionedAdditionAttr(const SwiftVersionedAdditionAttr *A) {
0209     const auto *SA = cast<SwiftVersionedAdditionAttr>(A); (void)SA;
0210     Visit(SA->getAdditionalAttr());
0211   }
0212   void VisitTryAcquireCapabilityAttr(const TryAcquireCapabilityAttr *A) {
0213     const auto *SA = cast<TryAcquireCapabilityAttr>(A); (void)SA;
0214     Visit(SA->getSuccessValue());
0215     for (TryAcquireCapabilityAttr::args_iterator I = SA->args_begin(), E = SA->args_end(); I != E; ++I)
0216       Visit(*I);
0217   }