1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* AttrDef Declarations *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifdef GET_ATTRDEF_CLASSES
10#undef GET_ATTRDEF_CLASSES
11
12#include "mlir/IR/Attributes.h"
13
14
15namespace mlir {
16class AsmParser;
17class AsmPrinter;
18} // namespace mlir
19namespace mlir::NVVM {
20
21/// NVVM FPRoundingMode kind
22class FPRoundingModeAttr;
23/// Describes the saturation mode
24/// A `nvvm.sat_mode` attribute specifies the saturation mode for instructions
25/// involving floating points or integers. It can be one of the following
26/// values:
27/// - `none`: No saturation is applied.
28/// - `satfinite`: If the absolute value of input (ignoring sign) is greater
29/// than the `MAX_NORM` of the specified destination format, then the result
30/// is the sign-preserved `MAX_NORM` of the destination format and a positive
31/// `MAX_NORM` in unsigned datatypes for which the destination sign is not
32/// supported. If the input is `NaN`, then the result can be `NaN` or the
33/// `MAX_NORM` of the destination format, depending on the format.
34/// - `sat`: For integer destination types, this limits the value to `MININT..
35/// MAXINT` and applies to both signed and unsigned integer datatypes. For
36/// floating point destination types (applies to only `F16`, `F32`, and `F64`
37/// types), this limits the value to the range `[0.0, 1.0]` and flushes NaN
38/// results to positive zero.
39///
40/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#data-movement-and-conversion-instructions-cvt)
41class SaturationModeAttr;
42/// NVVM Cache Eviction Priority
43/// Enum cases:
44/// * evict_normal (`EvictNormal`)
45/// * evict_first (`EvictFirst`)
46/// * evict_last (`EvictLast`)
47/// * evict_unchanged (`EvictUnchanged`)
48/// * no_allocate (`NoAllocate`)
49class CacheEvictionPriorityAttr;
50/// NVVM Memory Space
51/// Enum cases:
52/// * generic (`Generic`)
53/// * global (`Global`)
54/// * shared (`Shared`)
55/// * constant (`Constant`)
56/// * local (`Local`)
57/// * tensor (`Tensor`)
58/// * shared_cluster (`SharedCluster`)
59class NVVMMemorySpaceAttr;
60/// NVVM Memory Scope kind
61class MemScopeKindAttr;
62/// Shared memory space
63class SharedSpaceAttr;
64/// NVVM Memory Ordering kind
65class MemOrderKindAttr;
66/// NVVM Reduction Kind attribute
67class ReductionKindAttr;
68/// NVVM barrier reduction operation
69class BarrierReductionAttr;
70/// Proxy kind
71/// ProxyKind attribute represents a memory proxy which is an abstract label
72/// applied to a method of memory access. When two memory operations use distinct
73/// methods of memory access, they are said to be different proxies.
74class ProxyKindAttr;
75/// NVVM set max register action
76class SetMaxRegisterActionAttr;
77/// NVVM shuffle kind
78class ShflKindAttr;
79/// NVVM vote sync kind
80class VoteSyncKindAttr;
81/// NVVM permute mode
82class PermuteModeAttr;
83/// NVVM load cache modifier kind
84/// Enum attribute of the different kinds of cache operators for load instructions.
85///
86/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#id62)
87class LoadCacheModifierKindAttr;
88/// MMA binary operations
89class MMAB1OpAttr;
90/// MMA overflow options
91class MMAIntOverflowAttr;
92/// MMA operation kind
93class MMAKindAttr;
94/// Attribute for MMA operation shape.
95class MMAShapeAttr;
96/// NVVM MMA layout
97class MMALayoutAttr;
98/// NVVM MMA types
99class MMATypesAttr;
100/// NVVM MMA frag type
101class MMAFragAttr;
102/// Matrix shape for ldmatrix and stmatrix
103class LdStMatrixShapeAttr;
104/// Element type for ldmatrix and stmatrix
105class LdStMatrixEltTypeAttr;
106/// MMA Scale Vector Sizes
107class ScaleVecSizeAttr;
108/// MMA Block Scale Format
109class BlockScaleFormatAttr;
110/// Block Scale Kind
111/// The MMABlockScaleKind attribute describes the allowed set of types for matrix A and B in the *.mma.{sp}.block_scale Op. The following are supported types for each kind:
112///
113/// ```
114/// +--------------+-------------------------------------------+
115/// | Matrix Kind | supported types for A / B |
116/// +--------------+-------------------------------------------+
117/// | mxf8f6f4 | e4m3, e5m2, e2m3, e3m2, e2m1 |
118/// | mxf4 | e2m1 |
119/// | mxf4nvf4 | e2m1 |
120/// +--------------+-------------------------------------------+
121/// ```
122class MMABlockScaleKindAttr;
123/// List of Load-Modes supported for TMA Tensor Ops
124/// TMA Tensor Ops support the following modes, when copying data from
125/// global memory to shared memory (i.e. load):
126///
127/// Tile Mode: It's the default mode. The source multi-dimensional tensor
128/// layout is preserved at the destination.
129/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#tensor-tiled-mode)
130///
131/// Im2col Mode: This mode is used when `im2colOffsets` operands are present.
132/// The elements in the Bounding Box of the source tensor are rearranged into
133/// columns at the destination. In this mode, the tensor has to be at least
134/// 3-dimensional. The number of `im2colOffsets` is `dims - 2` where `dims`
135/// is the dimension of the tensor.
136/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#tensor-im2col-mode)
137///
138/// Im2col_W Mode: This mode is similar to Im2Col mode with the restriction that
139/// elements are accessed across the W dimension only. The number of `im2colOffsets`
140/// are always two, referred as `wHalo` and `wOffset`.
141/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#tensor-im2col-w-w128-modes)
142///
143/// Im2col_W_128 Mode: This mode is similar to Im2Col_W mode with the number of
144/// elements accessed across the W dimension is always 128 only.
145/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#tensor-im2col-w-w128-modes)
146///
147/// Tile_Gather4 Mode: This mode is similar to Tile mode but works only on 2D tensor.
148/// In gather4 mode, four rows in the source 2D tensor are combined to form a single
149/// 2D tensor at the destination. This mode requires five co-ordinates. The first one
150/// represents the column-index followed by four row indices.
151/// [For more information, see PTX ISA](https://docs.nvidia.com/cuda/parallel-thread-execution/#tensor-tiled-scatter4-gather4-modes)
152class TMALoadModeAttr;
153/// NVVM TMA Store Mode
154class TMAStoreModeAttr;
155/// NVVM CTA group kind
156class CTAGroupKindAttr;
157/// NVVM Prefetch Cache Level
158/// Enum cases:
159/// * L1 (`L1`)
160/// * L2 (`L2`)
161class PrefetchCacheLevelAttr;
162/// NVVM TMA redux kind
163class TMAReduxKindAttr;
164/// WGMMA overflow options
165class WGMMAScaleInAttr;
166/// WGMMA input predicate
167class WGMMAScaleOutAttr;
168/// NVVM WGMMA types
169class WGMMATypesAttr;
170/// Action kind for grid dependency control
171/// Enum cases:
172/// * wait (`wait`)
173/// * launch_dependents (`launch_dependents`)
174class GridDepActionKindAttr;
175/// NVVM match sync kind
176class MatchSyncKindAttr;
177/// NVVM Tcgen05 fence kind
178class Tcgen05FenceKindAttr;
179/// NVVM Tcgen05 wait kind
180class Tcgen05WaitKindAttr;
181/// tcgen05 cp shapes
182class Tcgen05CpShapeAttr;
183/// tcgen05 cp multicast
184class Tcgen05CpMulticastAttr;
185/// tcgen05 cp source format
186class Tcgen05CpSrcFormatAttr;
187/// allowed 32-bit signless integer cases: 0, 1, 2, 3, 4
188class Tcgen05LdStShapeAttr;
189/// NVVM DotAccumulateType
190class DotAccumulateTypeAttr;
191/// NVVM ClusterLaunchControlQueryType
192/// Enum cases:
193/// * is_canceled (`IS_CANCELED`)
194/// * get_first_cta_id_x (`GET_FIRST_CTA_ID_X`)
195/// * get_first_cta_id_y (`GET_FIRST_CTA_ID_Y`)
196/// * get_first_cta_id_z (`GET_FIRST_CTA_ID_Z`)
197class ClusterLaunchControlQueryTypeAttr;
198/// tcgen05 MMA Supported Types
199/// The Tcgen05MMAKind attribute describes the allowed set of types for matrix A and B in the tcgen05.mma Ops.
200/// The following are supported types for each kind:
201///
202/// ```
203/// +-------------+--------------------------------------------+
204/// | Matrix Kind | supported types for A / B |
205/// +-------------+--------------------------------------------+
206/// | f16 | f16, bf16 |
207/// | tf32 | tf32 |
208/// | f8f6f4 | e4m3, e5m2, e2m3, e3m2, e2m1 |
209/// | i8 | unsigned 8b, signed 8b |
210/// | mxf8f6f4 | e4m3, e5m2, e2m3, e3m2, e2m1 |
211/// | mxf4 | e2m1 |
212/// | mxf4nvf4 | e2m1 |
213/// +-------------+--------------------------------------------+
214/// ```
215class Tcgen05MMAKindAttr;
216/// tcgen05.mma Collector Buffer Operation
217/// Tcgen05MMACollectorOp attribute specifies the collector buffer operations.
218/// The following are the supported operations:
219/// * discard : Release buffer after use (default)
220/// * lastuse : Mark buffer for last use
221/// * fill : Fill buffer
222/// * use : Use buffer without modification
223class Tcgen05MMACollectorOpAttr;
224/// tcgen05.mma block scale attribute
225class Tcgen05MMABlockScaleAttr;
226/// tcgen05 MMA Collector Buffer B Attribute
227class Tcgen05MMACollectorBBufferAttr;
228/// NVVM Tensormap Field Kind
229/// Enum cases:
230/// * global_address (`GLOBAL_ADDRESS`)
231/// * rank (`RANK`)
232/// * box_dim (`BOX_DIM`)
233/// * global_dim (`GLOBAL_DIM`)
234/// * global_stride (`GLOBAL_STRIDE`)
235/// * element_stride (`ELEMENT_STRIDE`)
236/// * elemtype (`ELEMTYPE`)
237/// * interleave_layout (`INTERLEAVE_LAYOUT`)
238/// * swizzle_mode (`SWIZZLE_MODE`)
239/// * swizzle_atomicity (`SWIZZLE_ATOMICITY`)
240/// * fill_mode (`FILL_MODE`)
241class TensormapFieldAttr;
242/// NVVM Tensormap Elemtype
243/// Enum cases:
244/// * u8 (`U8`)
245/// * u16 (`U16`)
246/// * u32 (`U32`)
247/// * s32 (`S32`)
248/// * u64 (`U64`)
249/// * s64 (`S64`)
250/// * f16 (`F16`)
251/// * f32 (`F32`)
252/// * f32.ftz (`F32_FTZ`)
253/// * f64 (`F64`)
254/// * bf16 (`BF16`)
255/// * tf32 (`TF32`)
256/// * tf32.ftz (`TF32_FTZ`)
257/// * b4x16 (`B4x16`)
258/// * b4x16_p64 (`B4x16P64`)
259/// * b6x16_p32 (`B6x16P32`)
260class TensormapElemtypeAttr;
261/// NVVM Tensormap Interleave Layout
262/// Enum cases:
263/// * no_interleave (`NO_INTERLEAVE`)
264/// * b16 (`B16`)
265/// * b32 (`B32`)
266class TensormapInterleaveLayoutAttr;
267/// NVVM Tensormap Swizzle Mode
268/// Enum cases:
269/// * no_swizzling (`NO_SWIZZLING`)
270/// * b32 (`B32`)
271/// * b64 (`B64`)
272/// * b128 (`B128`)
273/// * b96 (`B96`)
274class TensormapSwizzleModeAttr;
275/// NVVM Tensormap Swizzle Atomicity
276/// Enum cases:
277/// * b16 (`B16`)
278/// * b32 (`B32`)
279/// * b32_flip_b8 (`B32_FLIP_8B`)
280/// * b64 (`B64`)
281class TensormapSwizzleAtomicityAttr;
282/// NVVM Tensormap Fill Mode
283/// Enum cases:
284/// * zero (`ZERO`)
285/// * oob_nan (`OOB_NAN`)
286class TensormapFillModeAttr;
287/// GPU target attribute for controlling compilation of NVIDIA targets. All
288/// parameters decay into default values if not present.
289///
290/// Examples:
291///
292/// 1. Target with default values.
293/// ```
294/// gpu.module @mymodule [#nvvm.target] attributes {...} {
295/// ...
296/// }
297/// ```
298///
299/// 2. Target with `sm_90` chip and fast math.
300/// ```
301/// gpu.module @mymodule [#nvvm.target<chip = "sm_90", flags = {fast}>] {
302/// ...
303/// }
304/// ```
305class NVVMTargetAttr;
306namespace detail {
307
308struct FPRoundingModeAttrStorage;
309
310} // namespace detail
311class FPRoundingModeAttr : public ::mlir::Attribute::AttrBase<FPRoundingModeAttr, ::mlir::Attribute, detail::FPRoundingModeAttrStorage> {
312public:
313 using Base::Base;
314 static constexpr ::llvm::StringLiteral name = "nvvm.fp_rnd_mode";
315 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
316 static FPRoundingModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::FPRoundingMode value);
317 static constexpr ::llvm::StringLiteral getMnemonic() {
318 return {"fp_rnd_mode"};
319 }
320
321 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
322 void print(::mlir::AsmPrinter &odsPrinter) const;
323 ::mlir::NVVM::FPRoundingMode getValue() const;
324};
325namespace detail {
326
327struct SaturationModeAttrStorage;
328
329} // namespace detail
330class SaturationModeAttr : public ::mlir::Attribute::AttrBase<SaturationModeAttr, ::mlir::Attribute, detail::SaturationModeAttrStorage> {
331public:
332 using Base::Base;
333 static constexpr ::llvm::StringLiteral name = "nvvm.sat_mode";
334 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
335 static SaturationModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::SaturationMode value);
336 static constexpr ::llvm::StringLiteral getMnemonic() {
337 return {"sat_mode"};
338 }
339
340 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
341 void print(::mlir::AsmPrinter &odsPrinter) const;
342 ::mlir::NVVM::SaturationMode getValue() const;
343};
344namespace detail {
345
346struct CacheEvictionPriorityAttrStorage;
347
348} // namespace detail
349class CacheEvictionPriorityAttr : public ::mlir::Attribute::AttrBase<CacheEvictionPriorityAttr, ::mlir::Attribute, detail::CacheEvictionPriorityAttrStorage> {
350public:
351 using Base::Base;
352 static constexpr ::llvm::StringLiteral name = "nvvm.cache_eviction_priority";
353 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
354 static CacheEvictionPriorityAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::CacheEvictionPriority value);
355 static constexpr ::llvm::StringLiteral getMnemonic() {
356 return {"cache_eviction_priority"};
357 }
358
359 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
360 void print(::mlir::AsmPrinter &odsPrinter) const;
361 ::mlir::NVVM::CacheEvictionPriority getValue() const;
362};
363namespace detail {
364
365struct NVVMMemorySpaceAttrStorage;
366
367} // namespace detail
368class NVVMMemorySpaceAttr : public ::mlir::Attribute::AttrBase<NVVMMemorySpaceAttr, ::mlir::Attribute, detail::NVVMMemorySpaceAttrStorage, ::mlir::LLVM::LLVMAddrSpaceAttrInterface::Trait, ::mlir::ptr::MemorySpaceAttrInterface::Trait> {
369public:
370 using Base::Base;
371 static constexpr ::llvm::StringLiteral name = "nvvm.memory_space";
372 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
373 static NVVMMemorySpaceAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::NVVMMemorySpace value);
374 static constexpr ::llvm::StringLiteral getMnemonic() {
375 return {"memory_space"};
376 }
377
378 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
379 void print(::mlir::AsmPrinter &odsPrinter) const;
380 ::mlir::NVVM::NVVMMemorySpace getValue() const;
381 unsigned getAddressSpace() const;
382 bool isValidLoad(::mlir::Type type, ::mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
383 bool isValidStore(::mlir::Type type, ::mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
384 bool isValidAtomicOp(::mlir::ptr::AtomicBinOp op, ::mlir::Type type, ::mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
385 bool isValidAtomicXchg(::mlir::Type type, ::mlir::ptr::AtomicOrdering successOrdering, ::mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment, const ::mlir::DataLayout *dataLayout, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
386 bool isValidAddrSpaceCast(::mlir::Type tgt, ::mlir::Type src, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
387 bool isValidPtrIntCast(::mlir::Type intLikeTy, ::mlir::Type ptrLikeTy, ::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError) const;
388};
389namespace detail {
390
391struct MemScopeKindAttrStorage;
392
393} // namespace detail
394class MemScopeKindAttr : public ::mlir::Attribute::AttrBase<MemScopeKindAttr, ::mlir::Attribute, detail::MemScopeKindAttrStorage> {
395public:
396 using Base::Base;
397 static constexpr ::llvm::StringLiteral name = "nvvm.mem_scope";
398 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
399 static MemScopeKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MemScopeKind value);
400 static constexpr ::llvm::StringLiteral getMnemonic() {
401 return {"mem_scope"};
402 }
403
404 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
405 void print(::mlir::AsmPrinter &odsPrinter) const;
406 ::mlir::NVVM::MemScopeKind getValue() const;
407};
408namespace detail {
409
410struct SharedSpaceAttrStorage;
411
412} // namespace detail
413class SharedSpaceAttr : public ::mlir::Attribute::AttrBase<SharedSpaceAttr, ::mlir::Attribute, detail::SharedSpaceAttrStorage> {
414public:
415 using Base::Base;
416 static constexpr ::llvm::StringLiteral name = "nvvm.shared_space";
417 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
418 static SharedSpaceAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::SharedSpace value);
419 static constexpr ::llvm::StringLiteral getMnemonic() {
420 return {"shared_space"};
421 }
422
423 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
424 void print(::mlir::AsmPrinter &odsPrinter) const;
425 ::mlir::NVVM::SharedSpace getValue() const;
426};
427namespace detail {
428
429struct MemOrderKindAttrStorage;
430
431} // namespace detail
432class MemOrderKindAttr : public ::mlir::Attribute::AttrBase<MemOrderKindAttr, ::mlir::Attribute, detail::MemOrderKindAttrStorage> {
433public:
434 using Base::Base;
435 static constexpr ::llvm::StringLiteral name = "nvvm.mem_order";
436 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
437 static MemOrderKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MemOrderKind value);
438 static constexpr ::llvm::StringLiteral getMnemonic() {
439 return {"mem_order"};
440 }
441
442 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
443 void print(::mlir::AsmPrinter &odsPrinter) const;
444 ::mlir::NVVM::MemOrderKind getValue() const;
445};
446namespace detail {
447
448struct ReductionKindAttrStorage;
449
450} // namespace detail
451class ReductionKindAttr : public ::mlir::Attribute::AttrBase<ReductionKindAttr, ::mlir::Attribute, detail::ReductionKindAttrStorage> {
452public:
453 using Base::Base;
454 static constexpr ::llvm::StringLiteral name = "nvvm.reduction_kind";
455 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
456 static ReductionKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::ReductionKind value);
457 static constexpr ::llvm::StringLiteral getMnemonic() {
458 return {"reduction_kind"};
459 }
460
461 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
462 void print(::mlir::AsmPrinter &odsPrinter) const;
463 ::mlir::NVVM::ReductionKind getValue() const;
464};
465namespace detail {
466
467struct BarrierReductionAttrStorage;
468
469} // namespace detail
470class BarrierReductionAttr : public ::mlir::Attribute::AttrBase<BarrierReductionAttr, ::mlir::Attribute, detail::BarrierReductionAttrStorage> {
471public:
472 using Base::Base;
473 static constexpr ::llvm::StringLiteral name = "nvvm.reduction";
474 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
475 static BarrierReductionAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::BarrierReduction value);
476 static constexpr ::llvm::StringLiteral getMnemonic() {
477 return {"reduction"};
478 }
479
480 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
481 void print(::mlir::AsmPrinter &odsPrinter) const;
482 ::mlir::NVVM::BarrierReduction getValue() const;
483};
484namespace detail {
485
486struct ProxyKindAttrStorage;
487
488} // namespace detail
489class ProxyKindAttr : public ::mlir::Attribute::AttrBase<ProxyKindAttr, ::mlir::Attribute, detail::ProxyKindAttrStorage> {
490public:
491 using Base::Base;
492 static constexpr ::llvm::StringLiteral name = "nvvm.proxy_kind";
493 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
494 static ProxyKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::ProxyKind value);
495 static constexpr ::llvm::StringLiteral getMnemonic() {
496 return {"proxy_kind"};
497 }
498
499 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
500 void print(::mlir::AsmPrinter &odsPrinter) const;
501 ::mlir::NVVM::ProxyKind getValue() const;
502};
503namespace detail {
504
505struct SetMaxRegisterActionAttrStorage;
506
507} // namespace detail
508class SetMaxRegisterActionAttr : public ::mlir::Attribute::AttrBase<SetMaxRegisterActionAttr, ::mlir::Attribute, detail::SetMaxRegisterActionAttrStorage> {
509public:
510 using Base::Base;
511 static constexpr ::llvm::StringLiteral name = "nvvm.action";
512 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
513 static SetMaxRegisterActionAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::SetMaxRegisterAction value);
514 static constexpr ::llvm::StringLiteral getMnemonic() {
515 return {"action"};
516 }
517
518 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
519 void print(::mlir::AsmPrinter &odsPrinter) const;
520 ::mlir::NVVM::SetMaxRegisterAction getValue() const;
521};
522namespace detail {
523
524struct ShflKindAttrStorage;
525
526} // namespace detail
527class ShflKindAttr : public ::mlir::Attribute::AttrBase<ShflKindAttr, ::mlir::Attribute, detail::ShflKindAttrStorage> {
528public:
529 using Base::Base;
530 static constexpr ::llvm::StringLiteral name = "nvvm.shfl_kind";
531 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
532 static ShflKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::ShflKind value);
533 static constexpr ::llvm::StringLiteral getMnemonic() {
534 return {"shfl_kind"};
535 }
536
537 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
538 void print(::mlir::AsmPrinter &odsPrinter) const;
539 ::mlir::NVVM::ShflKind getValue() const;
540};
541namespace detail {
542
543struct VoteSyncKindAttrStorage;
544
545} // namespace detail
546class VoteSyncKindAttr : public ::mlir::Attribute::AttrBase<VoteSyncKindAttr, ::mlir::Attribute, detail::VoteSyncKindAttrStorage> {
547public:
548 using Base::Base;
549 static constexpr ::llvm::StringLiteral name = "nvvm.vote_sync_kind";
550 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
551 static VoteSyncKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::VoteSyncKind value);
552 static constexpr ::llvm::StringLiteral getMnemonic() {
553 return {"vote_sync_kind"};
554 }
555
556 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
557 void print(::mlir::AsmPrinter &odsPrinter) const;
558 ::mlir::NVVM::VoteSyncKind getValue() const;
559};
560namespace detail {
561
562struct PermuteModeAttrStorage;
563
564} // namespace detail
565class PermuteModeAttr : public ::mlir::Attribute::AttrBase<PermuteModeAttr, ::mlir::Attribute, detail::PermuteModeAttrStorage> {
566public:
567 using Base::Base;
568 static constexpr ::llvm::StringLiteral name = "nvvm.permute_mode";
569 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
570 static PermuteModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::PermuteMode value);
571 static constexpr ::llvm::StringLiteral getMnemonic() {
572 return {"permute_mode"};
573 }
574
575 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
576 void print(::mlir::AsmPrinter &odsPrinter) const;
577 ::mlir::NVVM::PermuteMode getValue() const;
578};
579namespace detail {
580
581struct LoadCacheModifierKindAttrStorage;
582
583} // namespace detail
584class LoadCacheModifierKindAttr : public ::mlir::Attribute::AttrBase<LoadCacheModifierKindAttr, ::mlir::Attribute, detail::LoadCacheModifierKindAttrStorage> {
585public:
586 using Base::Base;
587 static constexpr ::llvm::StringLiteral name = "nvvm.load_cache_modifier";
588 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
589 static LoadCacheModifierKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::LoadCacheModifierKind value);
590 static constexpr ::llvm::StringLiteral getMnemonic() {
591 return {"load_cache_modifier"};
592 }
593
594 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
595 void print(::mlir::AsmPrinter &odsPrinter) const;
596 ::mlir::NVVM::LoadCacheModifierKind getValue() const;
597};
598namespace detail {
599
600struct MMAB1OpAttrStorage;
601
602} // namespace detail
603class MMAB1OpAttr : public ::mlir::Attribute::AttrBase<MMAB1OpAttr, ::mlir::Attribute, detail::MMAB1OpAttrStorage> {
604public:
605 using Base::Base;
606 static constexpr ::llvm::StringLiteral name = "nvvm.mma_b1op";
607 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
608 static MMAB1OpAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMAB1Op value);
609 static constexpr ::llvm::StringLiteral getMnemonic() {
610 return {"mma_b1op"};
611 }
612
613 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
614 void print(::mlir::AsmPrinter &odsPrinter) const;
615 ::mlir::NVVM::MMAB1Op getValue() const;
616};
617namespace detail {
618
619struct MMAIntOverflowAttrStorage;
620
621} // namespace detail
622class MMAIntOverflowAttr : public ::mlir::Attribute::AttrBase<MMAIntOverflowAttr, ::mlir::Attribute, detail::MMAIntOverflowAttrStorage> {
623public:
624 using Base::Base;
625 static constexpr ::llvm::StringLiteral name = "nvvm.mma_int_overflow";
626 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
627 static MMAIntOverflowAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMAIntOverflow value);
628 static constexpr ::llvm::StringLiteral getMnemonic() {
629 return {"mma_int_overflow"};
630 }
631
632 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
633 void print(::mlir::AsmPrinter &odsPrinter) const;
634 ::mlir::NVVM::MMAIntOverflow getValue() const;
635};
636namespace detail {
637
638struct MMAKindAttrStorage;
639
640} // namespace detail
641class MMAKindAttr : public ::mlir::Attribute::AttrBase<MMAKindAttr, ::mlir::Attribute, detail::MMAKindAttrStorage> {
642public:
643 using Base::Base;
644 static constexpr ::llvm::StringLiteral name = "nvvm.mma_kind";
645 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
646 static MMAKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMAKind value);
647 static constexpr ::llvm::StringLiteral getMnemonic() {
648 return {"mma_kind"};
649 }
650
651 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
652 void print(::mlir::AsmPrinter &odsPrinter) const;
653 ::mlir::NVVM::MMAKind getValue() const;
654};
655namespace detail {
656
657struct MMAShapeAttrStorage;
658
659} // namespace detail
660class MMAShapeAttr : public ::mlir::Attribute::AttrBase<MMAShapeAttr, ::mlir::Attribute, detail::MMAShapeAttrStorage> {
661public:
662 using Base::Base;
663 static constexpr ::llvm::StringLiteral name = "nvvm.shape";
664 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
665 static MMAShapeAttr get(::mlir::MLIRContext *context, int m, int n, int k);
666 static constexpr ::llvm::StringLiteral getMnemonic() {
667 return {"shape"};
668 }
669
670 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
671 void print(::mlir::AsmPrinter &odsPrinter) const;
672 int getM() const;
673 int getN() const;
674 int getK() const;
675};
676namespace detail {
677
678struct MMALayoutAttrStorage;
679
680} // namespace detail
681class MMALayoutAttr : public ::mlir::Attribute::AttrBase<MMALayoutAttr, ::mlir::Attribute, detail::MMALayoutAttrStorage> {
682public:
683 using Base::Base;
684 static constexpr ::llvm::StringLiteral name = "nvvm.mma_layout";
685 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
686 static MMALayoutAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMALayout value);
687 static constexpr ::llvm::StringLiteral getMnemonic() {
688 return {"mma_layout"};
689 }
690
691 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
692 void print(::mlir::AsmPrinter &odsPrinter) const;
693 ::mlir::NVVM::MMALayout getValue() const;
694};
695namespace detail {
696
697struct MMATypesAttrStorage;
698
699} // namespace detail
700class MMATypesAttr : public ::mlir::Attribute::AttrBase<MMATypesAttr, ::mlir::Attribute, detail::MMATypesAttrStorage> {
701public:
702 using Base::Base;
703 static constexpr ::llvm::StringLiteral name = "nvvm.mma_type";
704 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
705 static MMATypesAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMATypes value);
706 static constexpr ::llvm::StringLiteral getMnemonic() {
707 return {"mma_type"};
708 }
709
710 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
711 void print(::mlir::AsmPrinter &odsPrinter) const;
712 ::mlir::NVVM::MMATypes getValue() const;
713};
714namespace detail {
715
716struct MMAFragAttrStorage;
717
718} // namespace detail
719class MMAFragAttr : public ::mlir::Attribute::AttrBase<MMAFragAttr, ::mlir::Attribute, detail::MMAFragAttrStorage> {
720public:
721 using Base::Base;
722 static constexpr ::llvm::StringLiteral name = "nvvm.mma_frag";
723 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
724 static MMAFragAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMAFrag value);
725 static constexpr ::llvm::StringLiteral getMnemonic() {
726 return {"mma_frag"};
727 }
728
729 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
730 void print(::mlir::AsmPrinter &odsPrinter) const;
731 ::mlir::NVVM::MMAFrag getValue() const;
732};
733namespace detail {
734
735struct LdStMatrixShapeAttrStorage;
736
737} // namespace detail
738class LdStMatrixShapeAttr : public ::mlir::Attribute::AttrBase<LdStMatrixShapeAttr, ::mlir::Attribute, detail::LdStMatrixShapeAttrStorage> {
739public:
740 using Base::Base;
741 static constexpr ::llvm::StringLiteral name = "nvvm.ld_st_matrix_shape";
742 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
743 static LdStMatrixShapeAttr get(::mlir::MLIRContext *context, int m, int n);
744 static constexpr ::llvm::StringLiteral getMnemonic() {
745 return {"ld_st_matrix_shape"};
746 }
747
748 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
749 void print(::mlir::AsmPrinter &odsPrinter) const;
750 int getM() const;
751 int getN() const;
752};
753namespace detail {
754
755struct LdStMatrixEltTypeAttrStorage;
756
757} // namespace detail
758class LdStMatrixEltTypeAttr : public ::mlir::Attribute::AttrBase<LdStMatrixEltTypeAttr, ::mlir::Attribute, detail::LdStMatrixEltTypeAttrStorage> {
759public:
760 using Base::Base;
761 static constexpr ::llvm::StringLiteral name = "nvvm.ld_st_matrix_elt_type";
762 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
763 static LdStMatrixEltTypeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::LdStMatrixEltType value);
764 static constexpr ::llvm::StringLiteral getMnemonic() {
765 return {"ld_st_matrix_elt_type"};
766 }
767
768 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
769 void print(::mlir::AsmPrinter &odsPrinter) const;
770 ::mlir::NVVM::LdStMatrixEltType getValue() const;
771};
772namespace detail {
773
774struct ScaleVecSizeAttrStorage;
775
776} // namespace detail
777class ScaleVecSizeAttr : public ::mlir::Attribute::AttrBase<ScaleVecSizeAttr, ::mlir::Attribute, detail::ScaleVecSizeAttrStorage> {
778public:
779 using Base::Base;
780 static constexpr ::llvm::StringLiteral name = "nvvm.scale_vec_size";
781 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
782 static ScaleVecSizeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::ScaleVecSize value);
783 static constexpr ::llvm::StringLiteral getMnemonic() {
784 return {"scale_vec_size"};
785 }
786
787 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
788 void print(::mlir::AsmPrinter &odsPrinter) const;
789 ::mlir::NVVM::ScaleVecSize getValue() const;
790};
791namespace detail {
792
793struct BlockScaleFormatAttrStorage;
794
795} // namespace detail
796class BlockScaleFormatAttr : public ::mlir::Attribute::AttrBase<BlockScaleFormatAttr, ::mlir::Attribute, detail::BlockScaleFormatAttrStorage> {
797public:
798 using Base::Base;
799 static constexpr ::llvm::StringLiteral name = "nvvm.block_scale_format";
800 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
801 static BlockScaleFormatAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::BlockScaleFormat value);
802 static constexpr ::llvm::StringLiteral getMnemonic() {
803 return {"block_scale_format"};
804 }
805
806 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
807 void print(::mlir::AsmPrinter &odsPrinter) const;
808 ::mlir::NVVM::BlockScaleFormat getValue() const;
809};
810namespace detail {
811
812struct MMABlockScaleKindAttrStorage;
813
814} // namespace detail
815class MMABlockScaleKindAttr : public ::mlir::Attribute::AttrBase<MMABlockScaleKindAttr, ::mlir::Attribute, detail::MMABlockScaleKindAttrStorage> {
816public:
817 using Base::Base;
818 static constexpr ::llvm::StringLiteral name = "nvvm.block_scale_kind";
819 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
820 static MMABlockScaleKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MMABlockScaleKind value);
821 static constexpr ::llvm::StringLiteral getMnemonic() {
822 return {"block_scale_kind"};
823 }
824
825 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
826 void print(::mlir::AsmPrinter &odsPrinter) const;
827 ::mlir::NVVM::MMABlockScaleKind getValue() const;
828};
829namespace detail {
830
831struct TMALoadModeAttrStorage;
832
833} // namespace detail
834class TMALoadModeAttr : public ::mlir::Attribute::AttrBase<TMALoadModeAttr, ::mlir::Attribute, detail::TMALoadModeAttrStorage> {
835public:
836 using Base::Base;
837 static constexpr ::llvm::StringLiteral name = "nvvm.tma_load_mode";
838 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
839 static TMALoadModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TMALoadMode value);
840 static constexpr ::llvm::StringLiteral getMnemonic() {
841 return {"tma_load_mode"};
842 }
843
844 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
845 void print(::mlir::AsmPrinter &odsPrinter) const;
846 ::mlir::NVVM::TMALoadMode getValue() const;
847};
848namespace detail {
849
850struct TMAStoreModeAttrStorage;
851
852} // namespace detail
853class TMAStoreModeAttr : public ::mlir::Attribute::AttrBase<TMAStoreModeAttr, ::mlir::Attribute, detail::TMAStoreModeAttrStorage> {
854public:
855 using Base::Base;
856 static constexpr ::llvm::StringLiteral name = "nvvm.tma_store_mode";
857 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
858 static TMAStoreModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TMAStoreMode value);
859 static constexpr ::llvm::StringLiteral getMnemonic() {
860 return {"tma_store_mode"};
861 }
862
863 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
864 void print(::mlir::AsmPrinter &odsPrinter) const;
865 ::mlir::NVVM::TMAStoreMode getValue() const;
866};
867namespace detail {
868
869struct CTAGroupKindAttrStorage;
870
871} // namespace detail
872class CTAGroupKindAttr : public ::mlir::Attribute::AttrBase<CTAGroupKindAttr, ::mlir::Attribute, detail::CTAGroupKindAttrStorage> {
873public:
874 using Base::Base;
875 static constexpr ::llvm::StringLiteral name = "nvvm.cta_group";
876 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
877 static CTAGroupKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::CTAGroupKind value);
878 static constexpr ::llvm::StringLiteral getMnemonic() {
879 return {"cta_group"};
880 }
881
882 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
883 void print(::mlir::AsmPrinter &odsPrinter) const;
884 ::mlir::NVVM::CTAGroupKind getValue() const;
885};
886namespace detail {
887
888struct PrefetchCacheLevelAttrStorage;
889
890} // namespace detail
891class PrefetchCacheLevelAttr : public ::mlir::Attribute::AttrBase<PrefetchCacheLevelAttr, ::mlir::Attribute, detail::PrefetchCacheLevelAttrStorage> {
892public:
893 using Base::Base;
894 static constexpr ::llvm::StringLiteral name = "nvvm.prefetch_cache_level";
895 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
896 static PrefetchCacheLevelAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::PrefetchCacheLevel value);
897 static constexpr ::llvm::StringLiteral getMnemonic() {
898 return {"prefetch_cache_level"};
899 }
900
901 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
902 void print(::mlir::AsmPrinter &odsPrinter) const;
903 ::mlir::NVVM::PrefetchCacheLevel getValue() const;
904};
905namespace detail {
906
907struct TMAReduxKindAttrStorage;
908
909} // namespace detail
910class TMAReduxKindAttr : public ::mlir::Attribute::AttrBase<TMAReduxKindAttr, ::mlir::Attribute, detail::TMAReduxKindAttrStorage> {
911public:
912 using Base::Base;
913 static constexpr ::llvm::StringLiteral name = "nvvm.tma_redux_kind";
914 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
915 static TMAReduxKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TMAReduxKind value);
916 static constexpr ::llvm::StringLiteral getMnemonic() {
917 return {"tma_redux_kind"};
918 }
919
920 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
921 void print(::mlir::AsmPrinter &odsPrinter) const;
922 ::mlir::NVVM::TMAReduxKind getValue() const;
923};
924namespace detail {
925
926struct WGMMAScaleInAttrStorage;
927
928} // namespace detail
929class WGMMAScaleInAttr : public ::mlir::Attribute::AttrBase<WGMMAScaleInAttr, ::mlir::Attribute, detail::WGMMAScaleInAttrStorage> {
930public:
931 using Base::Base;
932 static constexpr ::llvm::StringLiteral name = "nvvm.wgmma_scale_in";
933 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
934 static WGMMAScaleInAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::WGMMAScaleIn value);
935 static constexpr ::llvm::StringLiteral getMnemonic() {
936 return {"wgmma_scale_in"};
937 }
938
939 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
940 void print(::mlir::AsmPrinter &odsPrinter) const;
941 ::mlir::NVVM::WGMMAScaleIn getValue() const;
942};
943namespace detail {
944
945struct WGMMAScaleOutAttrStorage;
946
947} // namespace detail
948class WGMMAScaleOutAttr : public ::mlir::Attribute::AttrBase<WGMMAScaleOutAttr, ::mlir::Attribute, detail::WGMMAScaleOutAttrStorage> {
949public:
950 using Base::Base;
951 static constexpr ::llvm::StringLiteral name = "nvvm.wgmma_scale_out";
952 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
953 static WGMMAScaleOutAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::WGMMAScaleOut value);
954 static constexpr ::llvm::StringLiteral getMnemonic() {
955 return {"wgmma_scale_out"};
956 }
957
958 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
959 void print(::mlir::AsmPrinter &odsPrinter) const;
960 ::mlir::NVVM::WGMMAScaleOut getValue() const;
961};
962namespace detail {
963
964struct WGMMATypesAttrStorage;
965
966} // namespace detail
967class WGMMATypesAttr : public ::mlir::Attribute::AttrBase<WGMMATypesAttr, ::mlir::Attribute, detail::WGMMATypesAttrStorage> {
968public:
969 using Base::Base;
970 static constexpr ::llvm::StringLiteral name = "nvvm.wgmma_type";
971 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
972 static WGMMATypesAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::WGMMATypes value);
973 static constexpr ::llvm::StringLiteral getMnemonic() {
974 return {"wgmma_type"};
975 }
976
977 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
978 void print(::mlir::AsmPrinter &odsPrinter) const;
979 ::mlir::NVVM::WGMMATypes getValue() const;
980};
981namespace detail {
982
983struct GridDepActionKindAttrStorage;
984
985} // namespace detail
986class GridDepActionKindAttr : public ::mlir::Attribute::AttrBase<GridDepActionKindAttr, ::mlir::Attribute, detail::GridDepActionKindAttrStorage> {
987public:
988 using Base::Base;
989 static constexpr ::llvm::StringLiteral name = "nvvm.grid_dep_action";
990 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
991 static GridDepActionKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::GridDepActionKind value);
992 static constexpr ::llvm::StringLiteral getMnemonic() {
993 return {"grid_dep_action"};
994 }
995
996 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
997 void print(::mlir::AsmPrinter &odsPrinter) const;
998 ::mlir::NVVM::GridDepActionKind getValue() const;
999};
1000namespace detail {
1001
1002struct MatchSyncKindAttrStorage;
1003
1004} // namespace detail
1005class MatchSyncKindAttr : public ::mlir::Attribute::AttrBase<MatchSyncKindAttr, ::mlir::Attribute, detail::MatchSyncKindAttrStorage> {
1006public:
1007 using Base::Base;
1008 static constexpr ::llvm::StringLiteral name = "nvvm.match_sync_kind";
1009 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1010 static MatchSyncKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::MatchSyncKind value);
1011 static constexpr ::llvm::StringLiteral getMnemonic() {
1012 return {"match_sync_kind"};
1013 }
1014
1015 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1016 void print(::mlir::AsmPrinter &odsPrinter) const;
1017 ::mlir::NVVM::MatchSyncKind getValue() const;
1018};
1019namespace detail {
1020
1021struct Tcgen05FenceKindAttrStorage;
1022
1023} // namespace detail
1024class Tcgen05FenceKindAttr : public ::mlir::Attribute::AttrBase<Tcgen05FenceKindAttr, ::mlir::Attribute, detail::Tcgen05FenceKindAttrStorage> {
1025public:
1026 using Base::Base;
1027 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_fence";
1028 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1029 static Tcgen05FenceKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05FenceKind value);
1030 static constexpr ::llvm::StringLiteral getMnemonic() {
1031 return {"tcgen05_fence"};
1032 }
1033
1034 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1035 void print(::mlir::AsmPrinter &odsPrinter) const;
1036 ::mlir::NVVM::Tcgen05FenceKind getValue() const;
1037};
1038namespace detail {
1039
1040struct Tcgen05WaitKindAttrStorage;
1041
1042} // namespace detail
1043class Tcgen05WaitKindAttr : public ::mlir::Attribute::AttrBase<Tcgen05WaitKindAttr, ::mlir::Attribute, detail::Tcgen05WaitKindAttrStorage> {
1044public:
1045 using Base::Base;
1046 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_wait";
1047 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1048 static Tcgen05WaitKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05WaitKind value);
1049 static constexpr ::llvm::StringLiteral getMnemonic() {
1050 return {"tcgen05_wait"};
1051 }
1052
1053 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1054 void print(::mlir::AsmPrinter &odsPrinter) const;
1055 ::mlir::NVVM::Tcgen05WaitKind getValue() const;
1056};
1057namespace detail {
1058
1059struct Tcgen05CpShapeAttrStorage;
1060
1061} // namespace detail
1062class Tcgen05CpShapeAttr : public ::mlir::Attribute::AttrBase<Tcgen05CpShapeAttr, ::mlir::Attribute, detail::Tcgen05CpShapeAttrStorage> {
1063public:
1064 using Base::Base;
1065 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_cp_shape";
1066 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1067 static Tcgen05CpShapeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05CpShape value);
1068 static constexpr ::llvm::StringLiteral getMnemonic() {
1069 return {"tcgen05_cp_shape"};
1070 }
1071
1072 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1073 void print(::mlir::AsmPrinter &odsPrinter) const;
1074 ::mlir::NVVM::Tcgen05CpShape getValue() const;
1075};
1076namespace detail {
1077
1078struct Tcgen05CpMulticastAttrStorage;
1079
1080} // namespace detail
1081class Tcgen05CpMulticastAttr : public ::mlir::Attribute::AttrBase<Tcgen05CpMulticastAttr, ::mlir::Attribute, detail::Tcgen05CpMulticastAttrStorage> {
1082public:
1083 using Base::Base;
1084 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_cp_multicast";
1085 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1086 static Tcgen05CpMulticastAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05CpMulticast value);
1087 static constexpr ::llvm::StringLiteral getMnemonic() {
1088 return {"tcgen05_cp_multicast"};
1089 }
1090
1091 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1092 void print(::mlir::AsmPrinter &odsPrinter) const;
1093 ::mlir::NVVM::Tcgen05CpMulticast getValue() const;
1094};
1095namespace detail {
1096
1097struct Tcgen05CpSrcFormatAttrStorage;
1098
1099} // namespace detail
1100class Tcgen05CpSrcFormatAttr : public ::mlir::Attribute::AttrBase<Tcgen05CpSrcFormatAttr, ::mlir::Attribute, detail::Tcgen05CpSrcFormatAttrStorage> {
1101public:
1102 using Base::Base;
1103 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_cp_src_fmt";
1104 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1105 static Tcgen05CpSrcFormatAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05CpSrcFormat value);
1106 static constexpr ::llvm::StringLiteral getMnemonic() {
1107 return {"tcgen05_cp_src_fmt"};
1108 }
1109
1110 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1111 void print(::mlir::AsmPrinter &odsPrinter) const;
1112 ::mlir::NVVM::Tcgen05CpSrcFormat getValue() const;
1113};
1114namespace detail {
1115
1116struct Tcgen05LdStShapeAttrStorage;
1117
1118} // namespace detail
1119class Tcgen05LdStShapeAttr : public ::mlir::Attribute::AttrBase<Tcgen05LdStShapeAttr, ::mlir::Attribute, detail::Tcgen05LdStShapeAttrStorage> {
1120public:
1121 using Base::Base;
1122 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_ldst_shape";
1123 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1124 static Tcgen05LdStShapeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05LdStShape value);
1125 static constexpr ::llvm::StringLiteral getMnemonic() {
1126 return {"tcgen05_ldst_shape"};
1127 }
1128
1129 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1130 void print(::mlir::AsmPrinter &odsPrinter) const;
1131 ::mlir::NVVM::Tcgen05LdStShape getValue() const;
1132};
1133namespace detail {
1134
1135struct DotAccumulateTypeAttrStorage;
1136
1137} // namespace detail
1138class DotAccumulateTypeAttr : public ::mlir::Attribute::AttrBase<DotAccumulateTypeAttr, ::mlir::Attribute, detail::DotAccumulateTypeAttrStorage> {
1139public:
1140 using Base::Base;
1141 static constexpr ::llvm::StringLiteral name = "nvvm.dot_accumulate_type";
1142 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1143 static DotAccumulateTypeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::DotAccumulateType value);
1144 static constexpr ::llvm::StringLiteral getMnemonic() {
1145 return {"dot_accumulate_type"};
1146 }
1147
1148 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1149 void print(::mlir::AsmPrinter &odsPrinter) const;
1150 ::mlir::NVVM::DotAccumulateType getValue() const;
1151};
1152namespace detail {
1153
1154struct ClusterLaunchControlQueryTypeAttrStorage;
1155
1156} // namespace detail
1157class ClusterLaunchControlQueryTypeAttr : public ::mlir::Attribute::AttrBase<ClusterLaunchControlQueryTypeAttr, ::mlir::Attribute, detail::ClusterLaunchControlQueryTypeAttrStorage> {
1158public:
1159 using Base::Base;
1160 static constexpr ::llvm::StringLiteral name = "nvvm.cluster_launch_control_query_type";
1161 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1162 static ClusterLaunchControlQueryTypeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::ClusterLaunchControlQueryType value);
1163 static constexpr ::llvm::StringLiteral getMnemonic() {
1164 return {"cluster_launch_control_query_type"};
1165 }
1166
1167 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1168 void print(::mlir::AsmPrinter &odsPrinter) const;
1169 ::mlir::NVVM::ClusterLaunchControlQueryType getValue() const;
1170};
1171namespace detail {
1172
1173struct Tcgen05MMAKindAttrStorage;
1174
1175} // namespace detail
1176class Tcgen05MMAKindAttr : public ::mlir::Attribute::AttrBase<Tcgen05MMAKindAttr, ::mlir::Attribute, detail::Tcgen05MMAKindAttrStorage> {
1177public:
1178 using Base::Base;
1179 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_mma_kind";
1180 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1181 static Tcgen05MMAKindAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05MMAKind value);
1182 static constexpr ::llvm::StringLiteral getMnemonic() {
1183 return {"tcgen05_mma_kind"};
1184 }
1185
1186 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1187 void print(::mlir::AsmPrinter &odsPrinter) const;
1188 ::mlir::NVVM::Tcgen05MMAKind getValue() const;
1189};
1190namespace detail {
1191
1192struct Tcgen05MMACollectorOpAttrStorage;
1193
1194} // namespace detail
1195class Tcgen05MMACollectorOpAttr : public ::mlir::Attribute::AttrBase<Tcgen05MMACollectorOpAttr, ::mlir::Attribute, detail::Tcgen05MMACollectorOpAttrStorage> {
1196public:
1197 using Base::Base;
1198 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_mma_collectorop";
1199 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1200 static Tcgen05MMACollectorOpAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05MMACollectorOp value);
1201 static constexpr ::llvm::StringLiteral getMnemonic() {
1202 return {"tcgen05_mma_collectorop"};
1203 }
1204
1205 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1206 void print(::mlir::AsmPrinter &odsPrinter) const;
1207 ::mlir::NVVM::Tcgen05MMACollectorOp getValue() const;
1208};
1209namespace detail {
1210
1211struct Tcgen05MMABlockScaleAttrStorage;
1212
1213} // namespace detail
1214class Tcgen05MMABlockScaleAttr : public ::mlir::Attribute::AttrBase<Tcgen05MMABlockScaleAttr, ::mlir::Attribute, detail::Tcgen05MMABlockScaleAttrStorage> {
1215public:
1216 using Base::Base;
1217 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_mma_block_scale";
1218 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1219 static Tcgen05MMABlockScaleAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05MMABlockScale value);
1220 static constexpr ::llvm::StringLiteral getMnemonic() {
1221 return {"tcgen05_mma_block_scale"};
1222 }
1223
1224 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1225 void print(::mlir::AsmPrinter &odsPrinter) const;
1226 ::mlir::NVVM::Tcgen05MMABlockScale getValue() const;
1227};
1228namespace detail {
1229
1230struct Tcgen05MMACollectorBBufferAttrStorage;
1231
1232} // namespace detail
1233class Tcgen05MMACollectorBBufferAttr : public ::mlir::Attribute::AttrBase<Tcgen05MMACollectorBBufferAttr, ::mlir::Attribute, detail::Tcgen05MMACollectorBBufferAttrStorage> {
1234public:
1235 using Base::Base;
1236 static constexpr ::llvm::StringLiteral name = "nvvm.tcgen05_mma_collectorb";
1237 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1238 static Tcgen05MMACollectorBBufferAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::Tcgen05MMACollectorBBuffer value);
1239 static constexpr ::llvm::StringLiteral getMnemonic() {
1240 return {"tcgen05_mma_collectorb"};
1241 }
1242
1243 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1244 void print(::mlir::AsmPrinter &odsPrinter) const;
1245 ::mlir::NVVM::Tcgen05MMACollectorBBuffer getValue() const;
1246};
1247namespace detail {
1248
1249struct TensormapFieldAttrStorage;
1250
1251} // namespace detail
1252class TensormapFieldAttr : public ::mlir::Attribute::AttrBase<TensormapFieldAttr, ::mlir::Attribute, detail::TensormapFieldAttrStorage> {
1253public:
1254 using Base::Base;
1255 static constexpr ::llvm::StringLiteral name = "nvvm.tensormap_field";
1256 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1257 static TensormapFieldAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TensormapField value);
1258 static constexpr ::llvm::StringLiteral getMnemonic() {
1259 return {"tensormap_field"};
1260 }
1261
1262 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1263 void print(::mlir::AsmPrinter &odsPrinter) const;
1264 ::mlir::NVVM::TensormapField getValue() const;
1265};
1266namespace detail {
1267
1268struct TensormapElemtypeAttrStorage;
1269
1270} // namespace detail
1271class TensormapElemtypeAttr : public ::mlir::Attribute::AttrBase<TensormapElemtypeAttr, ::mlir::Attribute, detail::TensormapElemtypeAttrStorage> {
1272public:
1273 using Base::Base;
1274 static constexpr ::llvm::StringLiteral name = "nvvm.tensormap_elemtype";
1275 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1276 static TensormapElemtypeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TensormapElemtype value);
1277 static constexpr ::llvm::StringLiteral getMnemonic() {
1278 return {"tensormap_elemtype"};
1279 }
1280
1281 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1282 void print(::mlir::AsmPrinter &odsPrinter) const;
1283 ::mlir::NVVM::TensormapElemtype getValue() const;
1284};
1285namespace detail {
1286
1287struct TensormapInterleaveLayoutAttrStorage;
1288
1289} // namespace detail
1290class TensormapInterleaveLayoutAttr : public ::mlir::Attribute::AttrBase<TensormapInterleaveLayoutAttr, ::mlir::Attribute, detail::TensormapInterleaveLayoutAttrStorage> {
1291public:
1292 using Base::Base;
1293 static constexpr ::llvm::StringLiteral name = "nvvm.tensormap_interleave_layout";
1294 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1295 static TensormapInterleaveLayoutAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TensormapInterleaveLayout value);
1296 static constexpr ::llvm::StringLiteral getMnemonic() {
1297 return {"tensormap_interleave_layout"};
1298 }
1299
1300 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1301 void print(::mlir::AsmPrinter &odsPrinter) const;
1302 ::mlir::NVVM::TensormapInterleaveLayout getValue() const;
1303};
1304namespace detail {
1305
1306struct TensormapSwizzleModeAttrStorage;
1307
1308} // namespace detail
1309class TensormapSwizzleModeAttr : public ::mlir::Attribute::AttrBase<TensormapSwizzleModeAttr, ::mlir::Attribute, detail::TensormapSwizzleModeAttrStorage> {
1310public:
1311 using Base::Base;
1312 static constexpr ::llvm::StringLiteral name = "nvvm.tensormap_swizzle_mode";
1313 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1314 static TensormapSwizzleModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TensormapSwizzleMode value);
1315 static constexpr ::llvm::StringLiteral getMnemonic() {
1316 return {"tensormap_swizzle_mode"};
1317 }
1318
1319 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1320 void print(::mlir::AsmPrinter &odsPrinter) const;
1321 ::mlir::NVVM::TensormapSwizzleMode getValue() const;
1322};
1323namespace detail {
1324
1325struct TensormapSwizzleAtomicityAttrStorage;
1326
1327} // namespace detail
1328class TensormapSwizzleAtomicityAttr : public ::mlir::Attribute::AttrBase<TensormapSwizzleAtomicityAttr, ::mlir::Attribute, detail::TensormapSwizzleAtomicityAttrStorage> {
1329public:
1330 using Base::Base;
1331 static constexpr ::llvm::StringLiteral name = "nvvm.tensormap_swizzle_atomicity";
1332 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1333 static TensormapSwizzleAtomicityAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TensormapSwizzleAtomicity value);
1334 static constexpr ::llvm::StringLiteral getMnemonic() {
1335 return {"tensormap_swizzle_atomicity"};
1336 }
1337
1338 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1339 void print(::mlir::AsmPrinter &odsPrinter) const;
1340 ::mlir::NVVM::TensormapSwizzleAtomicity getValue() const;
1341};
1342namespace detail {
1343
1344struct TensormapFillModeAttrStorage;
1345
1346} // namespace detail
1347class TensormapFillModeAttr : public ::mlir::Attribute::AttrBase<TensormapFillModeAttr, ::mlir::Attribute, detail::TensormapFillModeAttrStorage> {
1348public:
1349 using Base::Base;
1350 static constexpr ::llvm::StringLiteral name = "nvvm.tensormap_fill_mode";
1351 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1352 static TensormapFillModeAttr get(::mlir::MLIRContext *context, ::mlir::NVVM::TensormapFillMode value);
1353 static constexpr ::llvm::StringLiteral getMnemonic() {
1354 return {"tensormap_fill_mode"};
1355 }
1356
1357 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1358 void print(::mlir::AsmPrinter &odsPrinter) const;
1359 ::mlir::NVVM::TensormapFillMode getValue() const;
1360};
1361namespace detail {
1362
1363struct NVVMTargetAttrStorage;
1364
1365} // namespace detail
1366class NVVMTargetAttr : public ::mlir::Attribute::AttrBase<NVVMTargetAttr, ::mlir::Attribute, detail::NVVMTargetAttrStorage, ::mlir::gpu::TargetAttrVerifyInterface::Trait> {
1367public:
1368 using Base::Base;
1369 bool hasFlag(StringRef flag) const;
1370 bool hasFastMath() const;
1371 bool hasFtz() const;
1372 bool hasCmdOptions() const;
1373 std::optional<mlir::NamedAttribute> getCmdOptions() const;
1374 LogicalResult verifyTarget(Operation *gpuModule);
1375 static constexpr ::llvm::StringLiteral name = "nvvm.target";
1376 static constexpr ::llvm::StringLiteral dialectName = "nvvm";
1377 using Base::getChecked;
1378 static NVVMTargetAttr get(::mlir::MLIRContext *context, int optLevel = 2, StringRef triple = "nvptx64-nvidia-cuda", StringRef chip = "sm_75", StringRef features = "", DictionaryAttr targetFlags = nullptr, ArrayAttr linkFiles = nullptr, bool verifyTarget = true);
1379 static NVVMTargetAttr getChecked(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int optLevel = 2, StringRef triple = "nvptx64-nvidia-cuda", StringRef chip = "sm_75", StringRef features = "", DictionaryAttr targetFlags = nullptr, ArrayAttr linkFiles = nullptr, bool verifyTarget = true);
1380 static ::llvm::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int O, ::llvm::StringRef triple, ::llvm::StringRef chip, ::llvm::StringRef features, DictionaryAttr flags, ArrayAttr link, bool verifyTarget);
1381 static ::llvm::LogicalResult verifyInvariants(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int O, ::llvm::StringRef triple, ::llvm::StringRef chip, ::llvm::StringRef features, DictionaryAttr flags, ArrayAttr link, bool verifyTarget);
1382 static constexpr ::llvm::StringLiteral getMnemonic() {
1383 return {"target"};
1384 }
1385
1386 static ::mlir::Attribute parse(::mlir::AsmParser &odsParser, ::mlir::Type odsType);
1387 void print(::mlir::AsmPrinter &odsPrinter) const;
1388 int getO() const;
1389 ::llvm::StringRef getTriple() const;
1390 ::llvm::StringRef getChip() const;
1391 ::llvm::StringRef getFeatures() const;
1392 DictionaryAttr getFlags() const;
1393 ArrayAttr getLink() const;
1394 bool getVerifyTarget() const;
1395 ::mlir::LogicalResult verifyTarget(::mlir::Operation *module) const;
1396};
1397
1398} // namespace mlir::NVVM
1399MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::FPRoundingModeAttr)
1400MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::SaturationModeAttr)
1401MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::CacheEvictionPriorityAttr)
1402MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::NVVMMemorySpaceAttr)
1403MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MemScopeKindAttr)
1404MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::SharedSpaceAttr)
1405MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MemOrderKindAttr)
1406MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::ReductionKindAttr)
1407MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::BarrierReductionAttr)
1408MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::ProxyKindAttr)
1409MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::SetMaxRegisterActionAttr)
1410MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::ShflKindAttr)
1411MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::VoteSyncKindAttr)
1412MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::PermuteModeAttr)
1413MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::LoadCacheModifierKindAttr)
1414MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMAB1OpAttr)
1415MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMAIntOverflowAttr)
1416MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMAKindAttr)
1417MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMAShapeAttr)
1418MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMALayoutAttr)
1419MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMATypesAttr)
1420MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMAFragAttr)
1421MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::LdStMatrixShapeAttr)
1422MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::LdStMatrixEltTypeAttr)
1423MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::ScaleVecSizeAttr)
1424MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::BlockScaleFormatAttr)
1425MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MMABlockScaleKindAttr)
1426MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TMALoadModeAttr)
1427MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TMAStoreModeAttr)
1428MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::CTAGroupKindAttr)
1429MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::PrefetchCacheLevelAttr)
1430MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TMAReduxKindAttr)
1431MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::WGMMAScaleInAttr)
1432MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::WGMMAScaleOutAttr)
1433MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::WGMMATypesAttr)
1434MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::GridDepActionKindAttr)
1435MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::MatchSyncKindAttr)
1436MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05FenceKindAttr)
1437MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05WaitKindAttr)
1438MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05CpShapeAttr)
1439MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05CpMulticastAttr)
1440MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05CpSrcFormatAttr)
1441MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05LdStShapeAttr)
1442MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::DotAccumulateTypeAttr)
1443MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::ClusterLaunchControlQueryTypeAttr)
1444MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05MMAKindAttr)
1445MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05MMACollectorOpAttr)
1446MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05MMABlockScaleAttr)
1447MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::Tcgen05MMACollectorBBufferAttr)
1448MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TensormapFieldAttr)
1449MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TensormapElemtypeAttr)
1450MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TensormapInterleaveLayoutAttr)
1451MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TensormapSwizzleModeAttr)
1452MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TensormapSwizzleAtomicityAttr)
1453MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::TensormapFillModeAttr)
1454MLIR_DECLARE_EXPLICIT_TYPE_ID(::mlir::NVVM::NVVMTargetAttr)
1455
1456#endif // GET_ATTRDEF_CLASSES
1457
1458