1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
//! Original PTX specification:
//!
//! fma.rnd{.ftz}{.sat}.f32 d, a, b, c;
//! fma.rnd{.ftz}.f32x2 d, a, b, c;
//! fma.rnd.f64 d, a, b, c;
//! .rnd = { .rn, .rz, .rm, .rp };
//! ---------------------------------------------
//! fma.rnd{.ftz}{.sat}.f16 d, a, b, c;
//! fma.rnd{.ftz}{.sat}.f16x2 d, a, b, c;
//! fma.rnd{.ftz}.relu.f16 d, a, b, c;
//! fma.rnd{.ftz}.relu.f16x2 d, a, b, c;
//! fma.rnd{.relu}.bf16 d, a, b, c;
//! fma.rnd{.relu}.bf16x2 d, a, b, c;
//! fma.rnd.oob{.relu}.type d, a, b, c;
//! .rnd = { .rn };
//! ---------------------------------------------
//! fma.rnd{.sat}.f32.abtype d, a, b, c;
//! .abtype = { .f16, .bf16};
//! .rnd = { .rn, .rz, .rm, .rp };
#![allow(unused)]
use crate::r#type::common::*;
pub mod section_0 {
use crate::r#type::common::*;
#[derive(Debug, Clone, PartialEq)]
pub enum Rnd {
Rn, // .rn
Rz, // .rz
Rm, // .rm
Rp, // .rp
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndFtzSatF32 {
pub rnd: Rnd, // .rnd
pub ftz: bool, // {.ftz}
pub sat: bool, // {.sat}
pub f32: (), // .f32
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndFtzF32x2 {
pub rnd: Rnd, // .rnd
pub ftz: bool, // {.ftz}
pub f32x2: (), // .f32x2
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndF64 {
pub rnd: Rnd, // .rnd
pub f64: (), // .f64
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
}
pub mod section_1 {
use crate::r#type::common::*;
#[derive(Debug, Clone, PartialEq)]
pub enum Rnd {
Rn, // .rn
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndFtzSatF16 {
pub rnd: Rnd, // .rnd
pub ftz: bool, // {.ftz}
pub sat: bool, // {.sat}
pub f16: (), // .f16
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndFtzSatF16x2 {
pub rnd: Rnd, // .rnd
pub ftz: bool, // {.ftz}
pub sat: bool, // {.sat}
pub f16x2: (), // .f16x2
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndFtzReluF16 {
pub rnd: Rnd, // .rnd
pub ftz: bool, // {.ftz}
pub relu: (), // .relu
pub f16: (), // .f16
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndFtzReluF16x2 {
pub rnd: Rnd, // .rnd
pub ftz: bool, // {.ftz}
pub relu: (), // .relu
pub f16x2: (), // .f16x2
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndReluBf16 {
pub rnd: Rnd, // .rnd
pub relu: bool, // {.relu}
pub bf16: (), // .bf16
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndReluBf16x2 {
pub rnd: Rnd, // .rnd
pub relu: bool, // {.relu}
pub bf16x2: (), // .bf16x2
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndOobReluType {
pub rnd: Rnd, // .rnd
pub oob: (), // .oob
pub relu: bool, // {.relu}
pub type_: (), // .type
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
}
pub mod section_2 {
use crate::r#type::common::*;
#[derive(Debug, Clone, PartialEq)]
pub enum Rnd {
Rn, // .rn
Rz, // .rz
Rm, // .rm
Rp, // .rp
}
#[derive(Debug, Clone, PartialEq)]
pub enum Abtype {
Bf16, // .bf16
F16, // .f16
}
#[derive(Debug, Clone, PartialEq)]
pub struct FmaRndSatF32Abtype {
pub rnd: Rnd, // .rnd
pub sat: bool, // {.sat}
pub f32: (), // .f32
pub abtype: Abtype, // .abtype
pub d: GeneralOperand, // d
pub a: GeneralOperand, // a
pub b: GeneralOperand, // b
pub c: GeneralOperand, // c
}
}