ptx_parser/type/instruction/
setp.rs

1//! Original PTX specification:
2//!
3//! setp.CmpOp{.ftz}.type         p{|q}, a, b;
4//! setp.CmpOp.BoolOp{.ftz}.type  p{|q}, a, b, {!}c;
5//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .lo, .ls, .hi, .hs, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
6//! .BoolOp = { .and, .or, .xor };
7//! .type   = { .b16, .b32, .b64, .u16, .u32, .u64, .s16, .s32, .s64, .f32, .f64 };
8//! --------------------------------------------------------------
9//! setp.CmpOp{.ftz}.f16           p, a, b;
10//! setp.CmpOp.BoolOp{.ftz}.f16    p, a, b, {!}c;
11//! setp.CmpOp{.ftz}.f16x2         p|q, a, b;
12//! setp.CmpOp.BoolOp{.ftz}.f16x2  p|q, a, b, {!}c;
13//! setp.CmpOp.bf16                p, a, b;
14//! setp.CmpOp.BoolOp.bf16         p, a, b, {!}c;
15//! setp.CmpOp.bf16x2              p|q, a, b;
16//! setp.CmpOp.BoolOp.bf16x2       p|q, a, b, {!}c;
17//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
18//! .BoolOp = { .and, .or, .xor };
19
20#![allow(unused)]
21use crate::r#type::common::*;
22
23pub mod section_0 {
24    use crate::Spanned;
25    use crate::parser::Span;
26    use crate::r#type::common::*;
27
28    use serde::Serialize;
29
30    #[derive(Debug, Clone, PartialEq, Serialize)]
31    pub enum Cmpop {
32        Equ, // .equ
33        Neu, // .neu
34        Ltu, // .ltu
35        Leu, // .leu
36        Gtu, // .gtu
37        Geu, // .geu
38        Num, // .num
39        Nan, // .nan
40        Eq,  // .eq
41        Ne,  // .ne
42        Lt,  // .lt
43        Le,  // .le
44        Gt,  // .gt
45        Ge,  // .ge
46        Lo,  // .lo
47        Ls,  // .ls
48        Hi,  // .hi
49        Hs,  // .hs
50    }
51
52    #[derive(Debug, Clone, PartialEq, Serialize)]
53    pub enum Type {
54        B16, // .b16
55        B32, // .b32
56        B64, // .b64
57        U16, // .u16
58        U32, // .u32
59        U64, // .u64
60        S16, // .s16
61        S32, // .s32
62        S64, // .s64
63        F32, // .f32
64        F64, // .f64
65    }
66
67    #[derive(Debug, Clone, PartialEq, Serialize)]
68    pub enum Boolop {
69        And, // .and
70        Xor, // .xor
71        Or,  // .or
72    }
73
74    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
75    pub struct SetpCmpopFtzType {
76        pub cmpop: Cmpop,              // .CmpOp
77        pub ftz: bool,                 // {.ftz}
78        pub type_: Type,               // .type
79        pub p: GeneralOperand,         // first operand of p{|q}
80        pub q: Option<GeneralOperand>, // optional second operand of p{|q}
81        pub a: GeneralOperand,         // a
82        pub b: GeneralOperand,         // b
83        pub span: Span,
84    }
85
86    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
87    pub struct SetpCmpopBoolopFtzType {
88        pub cmpop: Cmpop,              // .CmpOp
89        pub boolop: Boolop,            // .BoolOp
90        pub ftz: bool,                 // {.ftz}
91        pub type_: Type,               // .type
92        pub p: GeneralOperand,         // first operand of p{|q}
93        pub q: Option<GeneralOperand>, // optional second operand of p{|q}
94        pub a: GeneralOperand,         // a
95        pub b: GeneralOperand,         // b
96        pub c_op: bool,                // {!} operator
97        pub c: GeneralOperand,         // {!}c
98        pub span: Span,
99    }
100}
101
102pub mod section_1 {
103    use crate::Spanned;
104    use crate::parser::Span;
105    use crate::r#type::common::*;
106
107    use serde::Serialize;
108
109    #[derive(Debug, Clone, PartialEq, Serialize)]
110    pub enum Cmpop {
111        Equ, // .equ
112        Neu, // .neu
113        Ltu, // .ltu
114        Leu, // .leu
115        Gtu, // .gtu
116        Geu, // .geu
117        Num, // .num
118        Nan, // .nan
119        Eq,  // .eq
120        Ne,  // .ne
121        Lt,  // .lt
122        Le,  // .le
123        Gt,  // .gt
124        Ge,  // .ge
125    }
126
127    #[derive(Debug, Clone, PartialEq, Serialize)]
128    pub enum Boolop {
129        And, // .and
130        Xor, // .xor
131        Or,  // .or
132    }
133
134    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
135    pub struct SetpCmpopFtzF16 {
136        pub cmpop: Cmpop,      // .CmpOp
137        pub ftz: bool,         // {.ftz}
138        pub f16: (),           // .f16
139        pub p: GeneralOperand, // p
140        pub a: GeneralOperand, // a
141        pub b: GeneralOperand, // b
142        pub span: Span,
143    }
144
145    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
146    pub struct SetpCmpopBoolopFtzF16 {
147        pub cmpop: Cmpop,      // .CmpOp
148        pub boolop: Boolop,    // .BoolOp
149        pub ftz: bool,         // {.ftz}
150        pub f16: (),           // .f16
151        pub p: GeneralOperand, // p
152        pub a: GeneralOperand, // a
153        pub b: GeneralOperand, // b
154        pub c_op: bool,        // {!} operator
155        pub c: GeneralOperand, // {!}c
156        pub span: Span,
157    }
158
159    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
160    pub struct SetpCmpopFtzF16x2 {
161        pub cmpop: Cmpop,      // .CmpOp
162        pub ftz: bool,         // {.ftz}
163        pub f16x2: (),         // .f16x2
164        pub p: GeneralOperand, // first operand of p|q
165        pub q: GeneralOperand, // second operand of p|q
166        pub a: GeneralOperand, // a
167        pub b: GeneralOperand, // b
168        pub span: Span,
169    }
170
171    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
172    pub struct SetpCmpopBoolopFtzF16x2 {
173        pub cmpop: Cmpop,      // .CmpOp
174        pub boolop: Boolop,    // .BoolOp
175        pub ftz: bool,         // {.ftz}
176        pub f16x2: (),         // .f16x2
177        pub p: GeneralOperand, // first operand of p|q
178        pub q: GeneralOperand, // second operand of p|q
179        pub a: GeneralOperand, // a
180        pub b: GeneralOperand, // b
181        pub c_op: bool,        // {!} operator
182        pub c: GeneralOperand, // {!}c
183        pub span: Span,
184    }
185
186    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
187    pub struct SetpCmpopBf16 {
188        pub cmpop: Cmpop,      // .CmpOp
189        pub bf16: (),          // .bf16
190        pub p: GeneralOperand, // p
191        pub a: GeneralOperand, // a
192        pub b: GeneralOperand, // b
193        pub span: Span,
194    }
195
196    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
197    pub struct SetpCmpopBoolopBf16 {
198        pub cmpop: Cmpop,      // .CmpOp
199        pub boolop: Boolop,    // .BoolOp
200        pub bf16: (),          // .bf16
201        pub p: GeneralOperand, // p
202        pub a: GeneralOperand, // a
203        pub b: GeneralOperand, // b
204        pub c_op: bool,        // {!} operator
205        pub c: GeneralOperand, // {!}c
206        pub span: Span,
207    }
208
209    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
210    pub struct SetpCmpopBf16x2 {
211        pub cmpop: Cmpop,      // .CmpOp
212        pub bf16x2: (),        // .bf16x2
213        pub p: GeneralOperand, // first operand of p|q
214        pub q: GeneralOperand, // second operand of p|q
215        pub a: GeneralOperand, // a
216        pub b: GeneralOperand, // b
217        pub span: Span,
218    }
219
220    #[derive(Debug, Clone, PartialEq, Spanned, Serialize)]
221    pub struct SetpCmpopBoolopBf16x2 {
222        pub cmpop: Cmpop,      // .CmpOp
223        pub boolop: Boolop,    // .BoolOp
224        pub bf16x2: (),        // .bf16x2
225        pub p: GeneralOperand, // first operand of p|q
226        pub q: GeneralOperand, // second operand of p|q
227        pub a: GeneralOperand, // a
228        pub b: GeneralOperand, // b
229        pub c_op: bool,        // {!} operator
230        pub c: GeneralOperand, // {!}c
231        pub span: Span,
232    }
233}
234
235// Re-export types with section suffixes to avoid naming conflicts
236// e.g., Type0 for section_0::Type, Type1 for section_1::Type
237pub use section_0::Boolop as Boolop0;
238pub use section_0::Cmpop as Cmpop0;
239pub use section_0::SetpCmpopBoolopFtzType;
240pub use section_0::SetpCmpopFtzType;
241pub use section_0::Type as Type0;
242pub use section_1::Boolop as Boolop1;
243pub use section_1::Cmpop as Cmpop1;
244pub use section_1::SetpCmpopBf16;
245pub use section_1::SetpCmpopBf16x2;
246pub use section_1::SetpCmpopBoolopBf16;
247pub use section_1::SetpCmpopBoolopBf16x2;
248pub use section_1::SetpCmpopBoolopFtzF16;
249pub use section_1::SetpCmpopBoolopFtzF16x2;
250pub use section_1::SetpCmpopFtzF16;
251pub use section_1::SetpCmpopFtzF16x2;
ptx_parser/type/instruction/setp.rs

ptx_parser/type/instruction/
setp.rs
