ptx_parser/parser/instruction/
sub.rs

1//! Original PTX specification:
2//!
3//! sub.type       d, a, b;
4//! sub{.sat}.s32  d, a, b;     // .sat applies only to .s32
5//! .type = { .u16, .u32, .u64,
6//! .s16, .s32, .s64 };
7//! --------------------------------------------
8//! sub{.rnd}{.ftz}{.sat}.f32  d, a, b;
9//! sub{.rnd}{.ftz}.f32x2      d, a, b;
10//! sub{.rnd}.f64              d, a, b;
11//! .rnd = { .rn, .rz, .rm, .rp };
12//! --------------------------------------------
13//! sub{.rnd}{.ftz}{.sat}.f16   d, a, b;
14//! sub{.rnd}{.ftz}{.sat}.f16x2 d, a, b;
15//! sub{.rnd}.bf16   d, a, b;
16//! sub{.rnd}.bf16x2 d, a, b;
17//! .rnd = { .rn };
18//! --------------------------------------------
19//! sub{.rnd}{.sat}.f32.atype  d, a, c;
20//! .atype = { .f16, .bf16};
21//! .rnd   = { .rn, .rz, .rm, .rp };
22
23#![allow(unused)]
24
25use crate::lexer::PtxToken;
26use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
27use crate::r#type::common::*;
28
29pub mod section_0 {
30    use super::*;
31    use crate::r#type::instruction::sub::section_0::*;
32
33    // ============================================================================
34    // Generated enum parsers
35    // ============================================================================
36
37    impl PtxParser for Type {
38        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
39            // Try U16
40            {
41                let saved_pos = stream.position();
42                if stream.expect_string(".u16").is_ok() {
43                    return Ok(Type::U16);
44                }
45                stream.set_position(saved_pos);
46            }
47            let saved_pos = stream.position();
48            // Try U32
49            {
50                let saved_pos = stream.position();
51                if stream.expect_string(".u32").is_ok() {
52                    return Ok(Type::U32);
53                }
54                stream.set_position(saved_pos);
55            }
56            stream.set_position(saved_pos);
57            let saved_pos = stream.position();
58            // Try U64
59            {
60                let saved_pos = stream.position();
61                if stream.expect_string(".u64").is_ok() {
62                    return Ok(Type::U64);
63                }
64                stream.set_position(saved_pos);
65            }
66            stream.set_position(saved_pos);
67            let saved_pos = stream.position();
68            // Try S16
69            {
70                let saved_pos = stream.position();
71                if stream.expect_string(".s16").is_ok() {
72                    return Ok(Type::S16);
73                }
74                stream.set_position(saved_pos);
75            }
76            stream.set_position(saved_pos);
77            let saved_pos = stream.position();
78            // Try S32
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".s32").is_ok() {
82                    return Ok(Type::S32);
83                }
84                stream.set_position(saved_pos);
85            }
86            stream.set_position(saved_pos);
87            let saved_pos = stream.position();
88            // Try S64
89            {
90                let saved_pos = stream.position();
91                if stream.expect_string(".s64").is_ok() {
92                    return Ok(Type::S64);
93                }
94                stream.set_position(saved_pos);
95            }
96            stream.set_position(saved_pos);
97            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
98            let expected = &[".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
99            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
100            Err(crate::parser::unexpected_value(span, expected, found))
101        }
102    }
103
104    impl PtxParser for SubType {
105        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
106            stream.expect_string("sub")?;
107            let type_ = Type::parse(stream)?;
108            stream.expect_complete()?;
109            let d = GeneralOperand::parse(stream)?;
110            stream.expect_complete()?;
111            stream.expect(&PtxToken::Comma)?;
112            let a = GeneralOperand::parse(stream)?;
113            stream.expect_complete()?;
114            stream.expect(&PtxToken::Comma)?;
115            let b = GeneralOperand::parse(stream)?;
116            stream.expect_complete()?;
117            stream.expect_complete()?;
118            stream.expect(&PtxToken::Semicolon)?;
119            Ok(SubType {
120                type_,
121                d,
122                a,
123                b,
124            })
125        }
126    }
127
128
129    impl PtxParser for SubSatS32 {
130        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
131            stream.expect_string("sub")?;
132            let saved_pos = stream.position();
133            let sat = stream.expect_string(".sat").is_ok();
134            if !sat {
135                stream.set_position(saved_pos);
136            }
137            stream.expect_complete()?;
138            stream.expect_string(".s32")?;
139            let s32 = ();
140            stream.expect_complete()?;
141            let d = GeneralOperand::parse(stream)?;
142            stream.expect_complete()?;
143            stream.expect(&PtxToken::Comma)?;
144            let a = GeneralOperand::parse(stream)?;
145            stream.expect_complete()?;
146            stream.expect(&PtxToken::Comma)?;
147            let b = GeneralOperand::parse(stream)?;
148            stream.expect_complete()?;
149            stream.expect_complete()?;
150            stream.expect(&PtxToken::Semicolon)?;
151            Ok(SubSatS32 {
152                sat,
153                s32,
154                d,
155                a,
156                b,
157            })
158        }
159    }
160
161
162}
163
164pub mod section_1 {
165    use super::*;
166    use crate::r#type::instruction::sub::section_1::*;
167
168    // ============================================================================
169    // Generated enum parsers
170    // ============================================================================
171
172    impl PtxParser for Rnd {
173        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
174            // Try Rn
175            {
176                let saved_pos = stream.position();
177                if stream.expect_string(".rn").is_ok() {
178                    return Ok(Rnd::Rn);
179                }
180                stream.set_position(saved_pos);
181            }
182            let saved_pos = stream.position();
183            // Try Rz
184            {
185                let saved_pos = stream.position();
186                if stream.expect_string(".rz").is_ok() {
187                    return Ok(Rnd::Rz);
188                }
189                stream.set_position(saved_pos);
190            }
191            stream.set_position(saved_pos);
192            let saved_pos = stream.position();
193            // Try Rm
194            {
195                let saved_pos = stream.position();
196                if stream.expect_string(".rm").is_ok() {
197                    return Ok(Rnd::Rm);
198                }
199                stream.set_position(saved_pos);
200            }
201            stream.set_position(saved_pos);
202            let saved_pos = stream.position();
203            // Try Rp
204            {
205                let saved_pos = stream.position();
206                if stream.expect_string(".rp").is_ok() {
207                    return Ok(Rnd::Rp);
208                }
209                stream.set_position(saved_pos);
210            }
211            stream.set_position(saved_pos);
212            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
213            let expected = &[".rn", ".rz", ".rm", ".rp"];
214            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
215            Err(crate::parser::unexpected_value(span, expected, found))
216        }
217    }
218
219    impl PtxParser for SubRndFtzSatF32 {
220        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
221            stream.expect_string("sub")?;
222            let saved_pos = stream.position();
223            let rnd = match Rnd::parse(stream) {
224                Ok(val) => Some(val),
225                Err(_) => {
226                    stream.set_position(saved_pos);
227                    None
228                }
229            };
230            stream.expect_complete()?;
231            let saved_pos = stream.position();
232            let ftz = stream.expect_string(".ftz").is_ok();
233            if !ftz {
234                stream.set_position(saved_pos);
235            }
236            stream.expect_complete()?;
237            let saved_pos = stream.position();
238            let sat = stream.expect_string(".sat").is_ok();
239            if !sat {
240                stream.set_position(saved_pos);
241            }
242            stream.expect_complete()?;
243            stream.expect_string(".f32")?;
244            let f32 = ();
245            stream.expect_complete()?;
246            let d = GeneralOperand::parse(stream)?;
247            stream.expect_complete()?;
248            stream.expect(&PtxToken::Comma)?;
249            let a = GeneralOperand::parse(stream)?;
250            stream.expect_complete()?;
251            stream.expect(&PtxToken::Comma)?;
252            let b = GeneralOperand::parse(stream)?;
253            stream.expect_complete()?;
254            stream.expect_complete()?;
255            stream.expect(&PtxToken::Semicolon)?;
256            Ok(SubRndFtzSatF32 {
257                rnd,
258                ftz,
259                sat,
260                f32,
261                d,
262                a,
263                b,
264            })
265        }
266    }
267
268
269    impl PtxParser for SubRndFtzF32x2 {
270        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
271            stream.expect_string("sub")?;
272            let saved_pos = stream.position();
273            let rnd = match Rnd::parse(stream) {
274                Ok(val) => Some(val),
275                Err(_) => {
276                    stream.set_position(saved_pos);
277                    None
278                }
279            };
280            stream.expect_complete()?;
281            let saved_pos = stream.position();
282            let ftz = stream.expect_string(".ftz").is_ok();
283            if !ftz {
284                stream.set_position(saved_pos);
285            }
286            stream.expect_complete()?;
287            stream.expect_string(".f32x2")?;
288            let f32x2 = ();
289            stream.expect_complete()?;
290            let d = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect(&PtxToken::Comma)?;
293            let a = GeneralOperand::parse(stream)?;
294            stream.expect_complete()?;
295            stream.expect(&PtxToken::Comma)?;
296            let b = GeneralOperand::parse(stream)?;
297            stream.expect_complete()?;
298            stream.expect_complete()?;
299            stream.expect(&PtxToken::Semicolon)?;
300            Ok(SubRndFtzF32x2 {
301                rnd,
302                ftz,
303                f32x2,
304                d,
305                a,
306                b,
307            })
308        }
309    }
310
311
312    impl PtxParser for SubRndF64 {
313        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
314            stream.expect_string("sub")?;
315            let saved_pos = stream.position();
316            let rnd = match Rnd::parse(stream) {
317                Ok(val) => Some(val),
318                Err(_) => {
319                    stream.set_position(saved_pos);
320                    None
321                }
322            };
323            stream.expect_complete()?;
324            stream.expect_string(".f64")?;
325            let f64 = ();
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(SubRndF64 {
338                rnd,
339                f64,
340                d,
341                a,
342                b,
343            })
344        }
345    }
346
347
348}
349
350pub mod section_2 {
351    use super::*;
352    use crate::r#type::instruction::sub::section_2::*;
353
354    // ============================================================================
355    // Generated enum parsers
356    // ============================================================================
357
358    impl PtxParser for Rnd {
359        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
360            // Try Rn
361            {
362                let saved_pos = stream.position();
363                if stream.expect_string(".rn").is_ok() {
364                    return Ok(Rnd::Rn);
365                }
366                stream.set_position(saved_pos);
367            }
368            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
369            let expected = &[".rn"];
370            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
371            Err(crate::parser::unexpected_value(span, expected, found))
372        }
373    }
374
375    impl PtxParser for SubRndFtzSatF16 {
376        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
377            stream.expect_string("sub")?;
378            let saved_pos = stream.position();
379            let rnd = match Rnd::parse(stream) {
380                Ok(val) => Some(val),
381                Err(_) => {
382                    stream.set_position(saved_pos);
383                    None
384                }
385            };
386            stream.expect_complete()?;
387            let saved_pos = stream.position();
388            let ftz = stream.expect_string(".ftz").is_ok();
389            if !ftz {
390                stream.set_position(saved_pos);
391            }
392            stream.expect_complete()?;
393            let saved_pos = stream.position();
394            let sat = stream.expect_string(".sat").is_ok();
395            if !sat {
396                stream.set_position(saved_pos);
397            }
398            stream.expect_complete()?;
399            stream.expect_string(".f16")?;
400            let f16 = ();
401            stream.expect_complete()?;
402            let d = GeneralOperand::parse(stream)?;
403            stream.expect_complete()?;
404            stream.expect(&PtxToken::Comma)?;
405            let a = GeneralOperand::parse(stream)?;
406            stream.expect_complete()?;
407            stream.expect(&PtxToken::Comma)?;
408            let b = GeneralOperand::parse(stream)?;
409            stream.expect_complete()?;
410            stream.expect_complete()?;
411            stream.expect(&PtxToken::Semicolon)?;
412            Ok(SubRndFtzSatF16 {
413                rnd,
414                ftz,
415                sat,
416                f16,
417                d,
418                a,
419                b,
420            })
421        }
422    }
423
424
425    impl PtxParser for SubRndFtzSatF16x2 {
426        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
427            stream.expect_string("sub")?;
428            let saved_pos = stream.position();
429            let rnd = match Rnd::parse(stream) {
430                Ok(val) => Some(val),
431                Err(_) => {
432                    stream.set_position(saved_pos);
433                    None
434                }
435            };
436            stream.expect_complete()?;
437            let saved_pos = stream.position();
438            let ftz = stream.expect_string(".ftz").is_ok();
439            if !ftz {
440                stream.set_position(saved_pos);
441            }
442            stream.expect_complete()?;
443            let saved_pos = stream.position();
444            let sat = stream.expect_string(".sat").is_ok();
445            if !sat {
446                stream.set_position(saved_pos);
447            }
448            stream.expect_complete()?;
449            stream.expect_string(".f16x2")?;
450            let f16x2 = ();
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(SubRndFtzSatF16x2 {
463                rnd,
464                ftz,
465                sat,
466                f16x2,
467                d,
468                a,
469                b,
470            })
471        }
472    }
473
474
475    impl PtxParser for SubRndBf16 {
476        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
477            stream.expect_string("sub")?;
478            let saved_pos = stream.position();
479            let rnd = match Rnd::parse(stream) {
480                Ok(val) => Some(val),
481                Err(_) => {
482                    stream.set_position(saved_pos);
483                    None
484                }
485            };
486            stream.expect_complete()?;
487            stream.expect_string(".bf16")?;
488            let bf16 = ();
489            stream.expect_complete()?;
490            let d = GeneralOperand::parse(stream)?;
491            stream.expect_complete()?;
492            stream.expect(&PtxToken::Comma)?;
493            let a = GeneralOperand::parse(stream)?;
494            stream.expect_complete()?;
495            stream.expect(&PtxToken::Comma)?;
496            let b = GeneralOperand::parse(stream)?;
497            stream.expect_complete()?;
498            stream.expect_complete()?;
499            stream.expect(&PtxToken::Semicolon)?;
500            Ok(SubRndBf16 {
501                rnd,
502                bf16,
503                d,
504                a,
505                b,
506            })
507        }
508    }
509
510
511    impl PtxParser for SubRndBf16x2 {
512        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
513            stream.expect_string("sub")?;
514            let saved_pos = stream.position();
515            let rnd = match Rnd::parse(stream) {
516                Ok(val) => Some(val),
517                Err(_) => {
518                    stream.set_position(saved_pos);
519                    None
520                }
521            };
522            stream.expect_complete()?;
523            stream.expect_string(".bf16x2")?;
524            let bf16x2 = ();
525            stream.expect_complete()?;
526            let d = GeneralOperand::parse(stream)?;
527            stream.expect_complete()?;
528            stream.expect(&PtxToken::Comma)?;
529            let a = GeneralOperand::parse(stream)?;
530            stream.expect_complete()?;
531            stream.expect(&PtxToken::Comma)?;
532            let b = GeneralOperand::parse(stream)?;
533            stream.expect_complete()?;
534            stream.expect_complete()?;
535            stream.expect(&PtxToken::Semicolon)?;
536            Ok(SubRndBf16x2 {
537                rnd,
538                bf16x2,
539                d,
540                a,
541                b,
542            })
543        }
544    }
545
546
547}
548
549pub mod section_3 {
550    use super::*;
551    use crate::r#type::instruction::sub::section_3::*;
552
553    // ============================================================================
554    // Generated enum parsers
555    // ============================================================================
556
557    impl PtxParser for Atype {
558        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
559            // Try Bf16
560            {
561                let saved_pos = stream.position();
562                if stream.expect_string(".bf16").is_ok() {
563                    return Ok(Atype::Bf16);
564                }
565                stream.set_position(saved_pos);
566            }
567            let saved_pos = stream.position();
568            // Try F16
569            {
570                let saved_pos = stream.position();
571                if stream.expect_string(".f16").is_ok() {
572                    return Ok(Atype::F16);
573                }
574                stream.set_position(saved_pos);
575            }
576            stream.set_position(saved_pos);
577            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
578            let expected = &[".bf16", ".f16"];
579            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
580            Err(crate::parser::unexpected_value(span, expected, found))
581        }
582    }
583
584    impl PtxParser for Rnd {
585        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
586            // Try Rn
587            {
588                let saved_pos = stream.position();
589                if stream.expect_string(".rn").is_ok() {
590                    return Ok(Rnd::Rn);
591                }
592                stream.set_position(saved_pos);
593            }
594            let saved_pos = stream.position();
595            // Try Rz
596            {
597                let saved_pos = stream.position();
598                if stream.expect_string(".rz").is_ok() {
599                    return Ok(Rnd::Rz);
600                }
601                stream.set_position(saved_pos);
602            }
603            stream.set_position(saved_pos);
604            let saved_pos = stream.position();
605            // Try Rm
606            {
607                let saved_pos = stream.position();
608                if stream.expect_string(".rm").is_ok() {
609                    return Ok(Rnd::Rm);
610                }
611                stream.set_position(saved_pos);
612            }
613            stream.set_position(saved_pos);
614            let saved_pos = stream.position();
615            // Try Rp
616            {
617                let saved_pos = stream.position();
618                if stream.expect_string(".rp").is_ok() {
619                    return Ok(Rnd::Rp);
620                }
621                stream.set_position(saved_pos);
622            }
623            stream.set_position(saved_pos);
624            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
625            let expected = &[".rn", ".rz", ".rm", ".rp"];
626            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
627            Err(crate::parser::unexpected_value(span, expected, found))
628        }
629    }
630
631    impl PtxParser for SubRndSatF32Atype {
632        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
633            stream.expect_string("sub")?;
634            let saved_pos = stream.position();
635            let rnd = match Rnd::parse(stream) {
636                Ok(val) => Some(val),
637                Err(_) => {
638                    stream.set_position(saved_pos);
639                    None
640                }
641            };
642            stream.expect_complete()?;
643            let saved_pos = stream.position();
644            let sat = stream.expect_string(".sat").is_ok();
645            if !sat {
646                stream.set_position(saved_pos);
647            }
648            stream.expect_complete()?;
649            stream.expect_string(".f32")?;
650            let f32 = ();
651            stream.expect_complete()?;
652            let atype = Atype::parse(stream)?;
653            stream.expect_complete()?;
654            let d = GeneralOperand::parse(stream)?;
655            stream.expect_complete()?;
656            stream.expect(&PtxToken::Comma)?;
657            let a = GeneralOperand::parse(stream)?;
658            stream.expect_complete()?;
659            stream.expect(&PtxToken::Comma)?;
660            let c = GeneralOperand::parse(stream)?;
661            stream.expect_complete()?;
662            stream.expect_complete()?;
663            stream.expect(&PtxToken::Semicolon)?;
664            Ok(SubRndSatF32Atype {
665                rnd,
666                sat,
667                f32,
668                atype,
669                d,
670                a,
671                c,
672            })
673        }
674    }
675
676
677}
678
ptx_parser/parser/instruction/sub.rs

ptx_parser/parser/instruction/
sub.rs
