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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
92            let expected = &[".u16x2", ".u16", ".u32", ".u64", ".s16", ".s64"];
93            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
94            Err(crate::parser::unexpected_value(span, expected, found))
95        }
96    }
97
98    impl PtxParser for Btype {
99        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
100            // Try S16x2
101            {
102                let saved_pos = stream.position();
103                if stream.expect_string(".s16x2").is_ok() {
104                    return Ok(Btype::S16x2);
105                }
106                stream.set_position(saved_pos);
107            }
108            let saved_pos = stream.position();
109            // Try S32
110            {
111                let saved_pos = stream.position();
112                if stream.expect_string(".s32").is_ok() {
113                    return Ok(Btype::S32);
114                }
115                stream.set_position(saved_pos);
116            }
117            stream.set_position(saved_pos);
118            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
119            let expected = &[".s16x2", ".s32"];
120            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
121            Err(crate::parser::unexpected_value(span, expected, found))
122        }
123    }
124
125    impl PtxParser for MinAtype {
126        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
127            stream.expect_string("min")?;
128            let atype = Atype::parse(stream)?;
129            stream.expect_complete()?;
130            let d = GeneralOperand::parse(stream)?;
131            stream.expect_complete()?;
132            stream.expect(&PtxToken::Comma)?;
133            let a = GeneralOperand::parse(stream)?;
134            stream.expect_complete()?;
135            stream.expect(&PtxToken::Comma)?;
136            let b = GeneralOperand::parse(stream)?;
137            stream.expect_complete()?;
138            stream.expect_complete()?;
139            stream.expect(&PtxToken::Semicolon)?;
140            Ok(MinAtype {
141                atype,
142                d,
143                a,
144                b,
145            })
146        }
147    }
148
149
150    impl PtxParser for MinReluBtype {
151        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
152            stream.expect_string("min")?;
153            let saved_pos = stream.position();
154            let relu = stream.expect_string(".relu").is_ok();
155            if !relu {
156                stream.set_position(saved_pos);
157            }
158            stream.expect_complete()?;
159            let btype = Btype::parse(stream)?;
160            stream.expect_complete()?;
161            let d = GeneralOperand::parse(stream)?;
162            stream.expect_complete()?;
163            stream.expect(&PtxToken::Comma)?;
164            let a = GeneralOperand::parse(stream)?;
165            stream.expect_complete()?;
166            stream.expect(&PtxToken::Comma)?;
167            let b = GeneralOperand::parse(stream)?;
168            stream.expect_complete()?;
169            stream.expect_complete()?;
170            stream.expect(&PtxToken::Semicolon)?;
171            Ok(MinReluBtype {
172                relu,
173                btype,
174                d,
175                a,
176                b,
177            })
178        }
179    }
180
181
182    impl PtxParser for MinFtzNanXorsignAbsF32 {
183        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
184            stream.expect_string("min")?;
185            let saved_pos = stream.position();
186            let ftz = stream.expect_string(".ftz").is_ok();
187            if !ftz {
188                stream.set_position(saved_pos);
189            }
190            stream.expect_complete()?;
191            let saved_pos = stream.position();
192            let nan = stream.expect_string(".NaN").is_ok();
193            if !nan {
194                stream.set_position(saved_pos);
195            }
196            stream.expect_complete()?;
197            let saved_pos = stream.position();
198            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
199            if !xorsign_abs {
200                stream.set_position(saved_pos);
201            }
202            stream.expect_complete()?;
203            stream.expect_string(".f32")?;
204            let f32 = ();
205            stream.expect_complete()?;
206            let d = GeneralOperand::parse(stream)?;
207            stream.expect_complete()?;
208            stream.expect(&PtxToken::Comma)?;
209            let a = GeneralOperand::parse(stream)?;
210            stream.expect_complete()?;
211            stream.expect(&PtxToken::Comma)?;
212            let b = GeneralOperand::parse(stream)?;
213            stream.expect_complete()?;
214            stream.expect_complete()?;
215            stream.expect(&PtxToken::Semicolon)?;
216            Ok(MinFtzNanXorsignAbsF32 {
217                ftz,
218                nan,
219                xorsign_abs,
220                f32,
221                d,
222                a,
223                b,
224            })
225        }
226    }
227
228
229    impl PtxParser for MinFtzNanAbsF32 {
230        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
231            stream.expect_string("min")?;
232            let saved_pos = stream.position();
233            let ftz = stream.expect_string(".ftz").is_ok();
234            if !ftz {
235                stream.set_position(saved_pos);
236            }
237            stream.expect_complete()?;
238            let saved_pos = stream.position();
239            let nan = stream.expect_string(".NaN").is_ok();
240            if !nan {
241                stream.set_position(saved_pos);
242            }
243            stream.expect_complete()?;
244            let saved_pos = stream.position();
245            let abs = stream.expect_string(".abs").is_ok();
246            if !abs {
247                stream.set_position(saved_pos);
248            }
249            stream.expect_complete()?;
250            stream.expect_string(".f32")?;
251            let f32 = ();
252            stream.expect_complete()?;
253            let d = GeneralOperand::parse(stream)?;
254            stream.expect_complete()?;
255            stream.expect(&PtxToken::Comma)?;
256            let a = GeneralOperand::parse(stream)?;
257            stream.expect_complete()?;
258            stream.expect(&PtxToken::Comma)?;
259            let b = GeneralOperand::parse(stream)?;
260            stream.expect_complete()?;
261            stream.expect(&PtxToken::Comma)?;
262            let c = GeneralOperand::parse(stream)?;
263            stream.expect_complete()?;
264            stream.expect_complete()?;
265            stream.expect(&PtxToken::Semicolon)?;
266            Ok(MinFtzNanAbsF32 {
267                ftz,
268                nan,
269                abs,
270                f32,
271                d,
272                a,
273                b,
274                c,
275            })
276        }
277    }
278
279
280    impl PtxParser for MinF64 {
281        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
282            stream.expect_string("min")?;
283            stream.expect_string(".f64")?;
284            let f64 = ();
285            stream.expect_complete()?;
286            let d = GeneralOperand::parse(stream)?;
287            stream.expect_complete()?;
288            stream.expect(&PtxToken::Comma)?;
289            let a = GeneralOperand::parse(stream)?;
290            stream.expect_complete()?;
291            stream.expect(&PtxToken::Comma)?;
292            let b = GeneralOperand::parse(stream)?;
293            stream.expect_complete()?;
294            stream.expect_complete()?;
295            stream.expect(&PtxToken::Semicolon)?;
296            Ok(MinF64 {
297                f64,
298                d,
299                a,
300                b,
301            })
302        }
303    }
304
305
306    impl PtxParser for MinFtzNanXorsignAbsF16 {
307        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
308            stream.expect_string("min")?;
309            let saved_pos = stream.position();
310            let ftz = stream.expect_string(".ftz").is_ok();
311            if !ftz {
312                stream.set_position(saved_pos);
313            }
314            stream.expect_complete()?;
315            let saved_pos = stream.position();
316            let nan = stream.expect_string(".NaN").is_ok();
317            if !nan {
318                stream.set_position(saved_pos);
319            }
320            stream.expect_complete()?;
321            let saved_pos = stream.position();
322            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
323            if !xorsign_abs {
324                stream.set_position(saved_pos);
325            }
326            stream.expect_complete()?;
327            stream.expect_string(".f16")?;
328            let f16 = ();
329            stream.expect_complete()?;
330            let d = GeneralOperand::parse(stream)?;
331            stream.expect_complete()?;
332            stream.expect(&PtxToken::Comma)?;
333            let a = GeneralOperand::parse(stream)?;
334            stream.expect_complete()?;
335            stream.expect(&PtxToken::Comma)?;
336            let b = GeneralOperand::parse(stream)?;
337            stream.expect_complete()?;
338            stream.expect_complete()?;
339            stream.expect(&PtxToken::Semicolon)?;
340            Ok(MinFtzNanXorsignAbsF16 {
341                ftz,
342                nan,
343                xorsign_abs,
344                f16,
345                d,
346                a,
347                b,
348            })
349        }
350    }
351
352
353    impl PtxParser for MinFtzNanXorsignAbsF16x2 {
354        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
355            stream.expect_string("min")?;
356            let saved_pos = stream.position();
357            let ftz = stream.expect_string(".ftz").is_ok();
358            if !ftz {
359                stream.set_position(saved_pos);
360            }
361            stream.expect_complete()?;
362            let saved_pos = stream.position();
363            let nan = stream.expect_string(".NaN").is_ok();
364            if !nan {
365                stream.set_position(saved_pos);
366            }
367            stream.expect_complete()?;
368            let saved_pos = stream.position();
369            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
370            if !xorsign_abs {
371                stream.set_position(saved_pos);
372            }
373            stream.expect_complete()?;
374            stream.expect_string(".f16x2")?;
375            let f16x2 = ();
376            stream.expect_complete()?;
377            let d = GeneralOperand::parse(stream)?;
378            stream.expect_complete()?;
379            stream.expect(&PtxToken::Comma)?;
380            let a = GeneralOperand::parse(stream)?;
381            stream.expect_complete()?;
382            stream.expect(&PtxToken::Comma)?;
383            let b = GeneralOperand::parse(stream)?;
384            stream.expect_complete()?;
385            stream.expect_complete()?;
386            stream.expect(&PtxToken::Semicolon)?;
387            Ok(MinFtzNanXorsignAbsF16x2 {
388                ftz,
389                nan,
390                xorsign_abs,
391                f16x2,
392                d,
393                a,
394                b,
395            })
396        }
397    }
398
399
400    impl PtxParser for MinNanXorsignAbsBf16 {
401        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
402            stream.expect_string("min")?;
403            let saved_pos = stream.position();
404            let nan = stream.expect_string(".NaN").is_ok();
405            if !nan {
406                stream.set_position(saved_pos);
407            }
408            stream.expect_complete()?;
409            let saved_pos = stream.position();
410            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
411            if !xorsign_abs {
412                stream.set_position(saved_pos);
413            }
414            stream.expect_complete()?;
415            stream.expect_string(".bf16")?;
416            let bf16 = ();
417            stream.expect_complete()?;
418            let d = GeneralOperand::parse(stream)?;
419            stream.expect_complete()?;
420            stream.expect(&PtxToken::Comma)?;
421            let a = GeneralOperand::parse(stream)?;
422            stream.expect_complete()?;
423            stream.expect(&PtxToken::Comma)?;
424            let b = GeneralOperand::parse(stream)?;
425            stream.expect_complete()?;
426            stream.expect_complete()?;
427            stream.expect(&PtxToken::Semicolon)?;
428            Ok(MinNanXorsignAbsBf16 {
429                nan,
430                xorsign_abs,
431                bf16,
432                d,
433                a,
434                b,
435            })
436        }
437    }
438
439
440    impl PtxParser for MinNanXorsignAbsBf16x2 {
441        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
442            stream.expect_string("min")?;
443            let saved_pos = stream.position();
444            let nan = stream.expect_string(".NaN").is_ok();
445            if !nan {
446                stream.set_position(saved_pos);
447            }
448            stream.expect_complete()?;
449            let saved_pos = stream.position();
450            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
451            if !xorsign_abs {
452                stream.set_position(saved_pos);
453            }
454            stream.expect_complete()?;
455            stream.expect_string(".bf16x2")?;
456            let bf16x2 = ();
457            stream.expect_complete()?;
458            let d = GeneralOperand::parse(stream)?;
459            stream.expect_complete()?;
460            stream.expect(&PtxToken::Comma)?;
461            let a = GeneralOperand::parse(stream)?;
462            stream.expect_complete()?;
463            stream.expect(&PtxToken::Comma)?;
464            let b = GeneralOperand::parse(stream)?;
465            stream.expect_complete()?;
466            stream.expect_complete()?;
467            stream.expect(&PtxToken::Semicolon)?;
468            Ok(MinNanXorsignAbsBf16x2 {
469                nan,
470                xorsign_abs,
471                bf16x2,
472                d,
473                a,
474                b,
475            })
476        }
477    }
478
479
480}
481
ptx_parser/parser/instruction/min.rs

ptx_parser/parser/instruction/
min.rs
