ptx_parser/parser/instruction/
min.rs

1//! Original PTX specification:
2//!
3//! min.atype         d, a, b;
4//! min{.relu}.btype  d, a, b;
5//! .atype = { .u16, .u32, .u64, .u16x2, .s16, .s64 };
6//! .btype = { .s16x2, .s32 };
7//!
8//! min{.ftz}{.NaN}{.xorsign.abs}.f32  d, a, b;
9//! min{.ftz}{.NaN}{.abs}.f32          d, a, b, c;
10//! min.f64                            d, a, b;
11//!
12//! min{.ftz}{.NaN}{.xorsign.abs}.f16      d, a, b;
13//! min{.ftz}{.NaN}{.xorsign.abs}.f16x2    d, a, b;
14//! min{.NaN}{.xorsign.abs}.bf16           d, a, b;
15//! min{.NaN}{.xorsign.abs}.bf16x2         d, a, b;
16
17#![allow(unused)]
18
19use crate::lexer::PtxToken;
20use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
21use crate::r#type::common::*;
22
23pub mod section_0 {
24    use super::*;
25    use crate::r#type::instruction::min::section_0::*;
26
27    // ============================================================================
28    // Generated enum parsers
29    // ============================================================================
30
31    impl PtxParser for Atype {
32        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
33            // Try U16x2
34            {
35                let saved_pos = stream.position();
36                if stream.expect_string(".u16x2").is_ok() {
37                    return Ok(Atype::U16x2);
38                }
39                stream.set_position(saved_pos);
40            }
41            let saved_pos = stream.position();
42            // Try U16
43            {
44                let saved_pos = stream.position();
45                if stream.expect_string(".u16").is_ok() {
46                    return Ok(Atype::U16);
47                }
48                stream.set_position(saved_pos);
49            }
50            stream.set_position(saved_pos);
51            let saved_pos = stream.position();
52            // Try U32
53            {
54                let saved_pos = stream.position();
55                if stream.expect_string(".u32").is_ok() {
56                    return Ok(Atype::U32);
57                }
58                stream.set_position(saved_pos);
59            }
60            stream.set_position(saved_pos);
61            let saved_pos = stream.position();
62            // Try U64
63            {
64                let saved_pos = stream.position();
65                if stream.expect_string(".u64").is_ok() {
66                    return Ok(Atype::U64);
67                }
68                stream.set_position(saved_pos);
69            }
70            stream.set_position(saved_pos);
71            let saved_pos = stream.position();
72            // Try S16
73            {
74                let saved_pos = stream.position();
75                if stream.expect_string(".s16").is_ok() {
76                    return Ok(Atype::S16);
77                }
78                stream.set_position(saved_pos);
79            }
80            stream.set_position(saved_pos);
81            let saved_pos = stream.position();
82            // Try S64
83            {
84                let saved_pos = stream.position();
85                if stream.expect_string(".s64").is_ok() {
86                    return Ok(Atype::S64);
87                }
88                stream.set_position(saved_pos);
89            }
90            stream.set_position(saved_pos);
91            let span = stream
92                .peek()
93                .map(|(_, s)| s.clone())
94                .unwrap_or(Span { start: 0, end: 0 });
95            let expected = &[".u16x2", ".u16", ".u32", ".u64", ".s16", ".s64"];
96            let found = stream
97                .peek()
98                .map(|(t, _)| format!("{:?}", t))
99                .unwrap_or_else(|_| "<end of input>".to_string());
100            Err(crate::parser::unexpected_value(span, expected, found))
101        }
102    }
103
104    impl PtxParser for Btype {
105        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
106            // Try S16x2
107            {
108                let saved_pos = stream.position();
109                if stream.expect_string(".s16x2").is_ok() {
110                    return Ok(Btype::S16x2);
111                }
112                stream.set_position(saved_pos);
113            }
114            let saved_pos = stream.position();
115            // Try S32
116            {
117                let saved_pos = stream.position();
118                if stream.expect_string(".s32").is_ok() {
119                    return Ok(Btype::S32);
120                }
121                stream.set_position(saved_pos);
122            }
123            stream.set_position(saved_pos);
124            let span = stream
125                .peek()
126                .map(|(_, s)| s.clone())
127                .unwrap_or(Span { start: 0, end: 0 });
128            let expected = &[".s16x2", ".s32"];
129            let found = stream
130                .peek()
131                .map(|(t, _)| format!("{:?}", t))
132                .unwrap_or_else(|_| "<end of input>".to_string());
133            Err(crate::parser::unexpected_value(span, expected, found))
134        }
135    }
136
137    impl PtxParser for MinAtype {
138        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
139            stream.expect_string("min")?;
140            let atype = Atype::parse(stream)?;
141            stream.expect_complete()?;
142            let d = GeneralOperand::parse(stream)?;
143            stream.expect_complete()?;
144            stream.expect(&PtxToken::Comma)?;
145            let a = GeneralOperand::parse(stream)?;
146            stream.expect_complete()?;
147            stream.expect(&PtxToken::Comma)?;
148            let b = GeneralOperand::parse(stream)?;
149            stream.expect_complete()?;
150            stream.expect_complete()?;
151            stream.expect(&PtxToken::Semicolon)?;
152            Ok(MinAtype { atype, d, a, b })
153        }
154    }
155
156    impl PtxParser for MinReluBtype {
157        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
158            stream.expect_string("min")?;
159            let saved_pos = stream.position();
160            let relu = stream.expect_string(".relu").is_ok();
161            if !relu {
162                stream.set_position(saved_pos);
163            }
164            stream.expect_complete()?;
165            let btype = Btype::parse(stream)?;
166            stream.expect_complete()?;
167            let d = GeneralOperand::parse(stream)?;
168            stream.expect_complete()?;
169            stream.expect(&PtxToken::Comma)?;
170            let a = GeneralOperand::parse(stream)?;
171            stream.expect_complete()?;
172            stream.expect(&PtxToken::Comma)?;
173            let b = GeneralOperand::parse(stream)?;
174            stream.expect_complete()?;
175            stream.expect_complete()?;
176            stream.expect(&PtxToken::Semicolon)?;
177            Ok(MinReluBtype {
178                relu,
179                btype,
180                d,
181                a,
182                b,
183            })
184        }
185    }
186
187    impl PtxParser for MinFtzNanXorsignAbsF32 {
188        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
189            stream.expect_string("min")?;
190            let saved_pos = stream.position();
191            let ftz = stream.expect_string(".ftz").is_ok();
192            if !ftz {
193                stream.set_position(saved_pos);
194            }
195            stream.expect_complete()?;
196            let saved_pos = stream.position();
197            let nan = stream.expect_string(".NaN").is_ok();
198            if !nan {
199                stream.set_position(saved_pos);
200            }
201            stream.expect_complete()?;
202            let saved_pos = stream.position();
203            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
204            if !xorsign_abs {
205                stream.set_position(saved_pos);
206            }
207            stream.expect_complete()?;
208            stream.expect_string(".f32")?;
209            let f32 = ();
210            stream.expect_complete()?;
211            let d = GeneralOperand::parse(stream)?;
212            stream.expect_complete()?;
213            stream.expect(&PtxToken::Comma)?;
214            let a = GeneralOperand::parse(stream)?;
215            stream.expect_complete()?;
216            stream.expect(&PtxToken::Comma)?;
217            let b = GeneralOperand::parse(stream)?;
218            stream.expect_complete()?;
219            stream.expect_complete()?;
220            stream.expect(&PtxToken::Semicolon)?;
221            Ok(MinFtzNanXorsignAbsF32 {
222                ftz,
223                nan,
224                xorsign_abs,
225                f32,
226                d,
227                a,
228                b,
229            })
230        }
231    }
232
233    impl PtxParser for MinFtzNanAbsF32 {
234        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
235            stream.expect_string("min")?;
236            let saved_pos = stream.position();
237            let ftz = stream.expect_string(".ftz").is_ok();
238            if !ftz {
239                stream.set_position(saved_pos);
240            }
241            stream.expect_complete()?;
242            let saved_pos = stream.position();
243            let nan = stream.expect_string(".NaN").is_ok();
244            if !nan {
245                stream.set_position(saved_pos);
246            }
247            stream.expect_complete()?;
248            let saved_pos = stream.position();
249            let abs = stream.expect_string(".abs").is_ok();
250            if !abs {
251                stream.set_position(saved_pos);
252            }
253            stream.expect_complete()?;
254            stream.expect_string(".f32")?;
255            let f32 = ();
256            stream.expect_complete()?;
257            let d = GeneralOperand::parse(stream)?;
258            stream.expect_complete()?;
259            stream.expect(&PtxToken::Comma)?;
260            let a = GeneralOperand::parse(stream)?;
261            stream.expect_complete()?;
262            stream.expect(&PtxToken::Comma)?;
263            let b = GeneralOperand::parse(stream)?;
264            stream.expect_complete()?;
265            stream.expect(&PtxToken::Comma)?;
266            let c = GeneralOperand::parse(stream)?;
267            stream.expect_complete()?;
268            stream.expect_complete()?;
269            stream.expect(&PtxToken::Semicolon)?;
270            Ok(MinFtzNanAbsF32 {
271                ftz,
272                nan,
273                abs,
274                f32,
275                d,
276                a,
277                b,
278                c,
279            })
280        }
281    }
282
283    impl PtxParser for MinF64 {
284        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
285            stream.expect_string("min")?;
286            stream.expect_string(".f64")?;
287            let f64 = ();
288            stream.expect_complete()?;
289            let d = GeneralOperand::parse(stream)?;
290            stream.expect_complete()?;
291            stream.expect(&PtxToken::Comma)?;
292            let a = GeneralOperand::parse(stream)?;
293            stream.expect_complete()?;
294            stream.expect(&PtxToken::Comma)?;
295            let b = GeneralOperand::parse(stream)?;
296            stream.expect_complete()?;
297            stream.expect_complete()?;
298            stream.expect(&PtxToken::Semicolon)?;
299            Ok(MinF64 { f64, d, a, b })
300        }
301    }
302
303    impl PtxParser for MinFtzNanXorsignAbsF16 {
304        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
305            stream.expect_string("min")?;
306            let saved_pos = stream.position();
307            let ftz = stream.expect_string(".ftz").is_ok();
308            if !ftz {
309                stream.set_position(saved_pos);
310            }
311            stream.expect_complete()?;
312            let saved_pos = stream.position();
313            let nan = stream.expect_string(".NaN").is_ok();
314            if !nan {
315                stream.set_position(saved_pos);
316            }
317            stream.expect_complete()?;
318            let saved_pos = stream.position();
319            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
320            if !xorsign_abs {
321                stream.set_position(saved_pos);
322            }
323            stream.expect_complete()?;
324            stream.expect_string(".f16")?;
325            let f16 = ();
326            stream.expect_complete()?;
327            let d = GeneralOperand::parse(stream)?;
328            stream.expect_complete()?;
329            stream.expect(&PtxToken::Comma)?;
330            let a = GeneralOperand::parse(stream)?;
331            stream.expect_complete()?;
332            stream.expect(&PtxToken::Comma)?;
333            let b = GeneralOperand::parse(stream)?;
334            stream.expect_complete()?;
335            stream.expect_complete()?;
336            stream.expect(&PtxToken::Semicolon)?;
337            Ok(MinFtzNanXorsignAbsF16 {
338                ftz,
339                nan,
340                xorsign_abs,
341                f16,
342                d,
343                a,
344                b,
345            })
346        }
347    }
348
349    impl PtxParser for MinFtzNanXorsignAbsF16x2 {
350        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
351            stream.expect_string("min")?;
352            let saved_pos = stream.position();
353            let ftz = stream.expect_string(".ftz").is_ok();
354            if !ftz {
355                stream.set_position(saved_pos);
356            }
357            stream.expect_complete()?;
358            let saved_pos = stream.position();
359            let nan = stream.expect_string(".NaN").is_ok();
360            if !nan {
361                stream.set_position(saved_pos);
362            }
363            stream.expect_complete()?;
364            let saved_pos = stream.position();
365            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
366            if !xorsign_abs {
367                stream.set_position(saved_pos);
368            }
369            stream.expect_complete()?;
370            stream.expect_string(".f16x2")?;
371            let f16x2 = ();
372            stream.expect_complete()?;
373            let d = GeneralOperand::parse(stream)?;
374            stream.expect_complete()?;
375            stream.expect(&PtxToken::Comma)?;
376            let a = GeneralOperand::parse(stream)?;
377            stream.expect_complete()?;
378            stream.expect(&PtxToken::Comma)?;
379            let b = GeneralOperand::parse(stream)?;
380            stream.expect_complete()?;
381            stream.expect_complete()?;
382            stream.expect(&PtxToken::Semicolon)?;
383            Ok(MinFtzNanXorsignAbsF16x2 {
384                ftz,
385                nan,
386                xorsign_abs,
387                f16x2,
388                d,
389                a,
390                b,
391            })
392        }
393    }
394
395    impl PtxParser for MinNanXorsignAbsBf16 {
396        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
397            stream.expect_string("min")?;
398            let saved_pos = stream.position();
399            let nan = stream.expect_string(".NaN").is_ok();
400            if !nan {
401                stream.set_position(saved_pos);
402            }
403            stream.expect_complete()?;
404            let saved_pos = stream.position();
405            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
406            if !xorsign_abs {
407                stream.set_position(saved_pos);
408            }
409            stream.expect_complete()?;
410            stream.expect_string(".bf16")?;
411            let bf16 = ();
412            stream.expect_complete()?;
413            let d = GeneralOperand::parse(stream)?;
414            stream.expect_complete()?;
415            stream.expect(&PtxToken::Comma)?;
416            let a = GeneralOperand::parse(stream)?;
417            stream.expect_complete()?;
418            stream.expect(&PtxToken::Comma)?;
419            let b = GeneralOperand::parse(stream)?;
420            stream.expect_complete()?;
421            stream.expect_complete()?;
422            stream.expect(&PtxToken::Semicolon)?;
423            Ok(MinNanXorsignAbsBf16 {
424                nan,
425                xorsign_abs,
426                bf16,
427                d,
428                a,
429                b,
430            })
431        }
432    }
433
434    impl PtxParser for MinNanXorsignAbsBf16x2 {
435        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
436            stream.expect_string("min")?;
437            let saved_pos = stream.position();
438            let nan = stream.expect_string(".NaN").is_ok();
439            if !nan {
440                stream.set_position(saved_pos);
441            }
442            stream.expect_complete()?;
443            let saved_pos = stream.position();
444            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
445            if !xorsign_abs {
446                stream.set_position(saved_pos);
447            }
448            stream.expect_complete()?;
449            stream.expect_string(".bf16x2")?;
450            let bf16x2 = ();
451            stream.expect_complete()?;
452            let d = GeneralOperand::parse(stream)?;
453            stream.expect_complete()?;
454            stream.expect(&PtxToken::Comma)?;
455            let a = GeneralOperand::parse(stream)?;
456            stream.expect_complete()?;
457            stream.expect(&PtxToken::Comma)?;
458            let b = GeneralOperand::parse(stream)?;
459            stream.expect_complete()?;
460            stream.expect_complete()?;
461            stream.expect(&PtxToken::Semicolon)?;
462            Ok(MinNanXorsignAbsBf16x2 {
463                nan,
464                xorsign_abs,
465                bf16x2,
466                d,
467                a,
468                b,
469            })
470        }
471    }
472}
ptx_parser/parser/instruction/min.rs

ptx_parser/parser/instruction/
min.rs
