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
98                .peek()
99                .map(|(_, s)| s.clone())
100                .unwrap_or(Span { start: 0, end: 0 });
101            let expected = &[".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
102            let found = stream
103                .peek()
104                .map(|(t, _)| format!("{:?}", t))
105                .unwrap_or_else(|_| "<end of input>".to_string());
106            Err(crate::parser::unexpected_value(span, expected, found))
107        }
108    }
109
110    impl PtxParser for SubType {
111        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
112            stream.expect_string("sub")?;
113            let type_ = Type::parse(stream)?;
114            stream.expect_complete()?;
115            let d = GeneralOperand::parse(stream)?;
116            stream.expect_complete()?;
117            stream.expect(&PtxToken::Comma)?;
118            let a = GeneralOperand::parse(stream)?;
119            stream.expect_complete()?;
120            stream.expect(&PtxToken::Comma)?;
121            let b = GeneralOperand::parse(stream)?;
122            stream.expect_complete()?;
123            stream.expect_complete()?;
124            stream.expect(&PtxToken::Semicolon)?;
125            Ok(SubType { type_, d, a, b })
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 { sat, s32, d, a, b })
152        }
153    }
154}
155
156pub mod section_1 {
157    use super::*;
158    use crate::r#type::instruction::sub::section_1::*;
159
160    // ============================================================================
161    // Generated enum parsers
162    // ============================================================================
163
164    impl PtxParser for Rnd {
165        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
166            // Try Rn
167            {
168                let saved_pos = stream.position();
169                if stream.expect_string(".rn").is_ok() {
170                    return Ok(Rnd::Rn);
171                }
172                stream.set_position(saved_pos);
173            }
174            let saved_pos = stream.position();
175            // Try Rz
176            {
177                let saved_pos = stream.position();
178                if stream.expect_string(".rz").is_ok() {
179                    return Ok(Rnd::Rz);
180                }
181                stream.set_position(saved_pos);
182            }
183            stream.set_position(saved_pos);
184            let saved_pos = stream.position();
185            // Try Rm
186            {
187                let saved_pos = stream.position();
188                if stream.expect_string(".rm").is_ok() {
189                    return Ok(Rnd::Rm);
190                }
191                stream.set_position(saved_pos);
192            }
193            stream.set_position(saved_pos);
194            let saved_pos = stream.position();
195            // Try Rp
196            {
197                let saved_pos = stream.position();
198                if stream.expect_string(".rp").is_ok() {
199                    return Ok(Rnd::Rp);
200                }
201                stream.set_position(saved_pos);
202            }
203            stream.set_position(saved_pos);
204            let span = stream
205                .peek()
206                .map(|(_, s)| s.clone())
207                .unwrap_or(Span { start: 0, end: 0 });
208            let expected = &[".rn", ".rz", ".rm", ".rp"];
209            let found = stream
210                .peek()
211                .map(|(t, _)| format!("{:?}", t))
212                .unwrap_or_else(|_| "<end of input>".to_string());
213            Err(crate::parser::unexpected_value(span, expected, found))
214        }
215    }
216
217    impl PtxParser for SubRndFtzSatF32 {
218        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
219            stream.expect_string("sub")?;
220            let saved_pos = stream.position();
221            let rnd = match Rnd::parse(stream) {
222                Ok(val) => Some(val),
223                Err(_) => {
224                    stream.set_position(saved_pos);
225                    None
226                }
227            };
228            stream.expect_complete()?;
229            let saved_pos = stream.position();
230            let ftz = stream.expect_string(".ftz").is_ok();
231            if !ftz {
232                stream.set_position(saved_pos);
233            }
234            stream.expect_complete()?;
235            let saved_pos = stream.position();
236            let sat = stream.expect_string(".sat").is_ok();
237            if !sat {
238                stream.set_position(saved_pos);
239            }
240            stream.expect_complete()?;
241            stream.expect_string(".f32")?;
242            let f32 = ();
243            stream.expect_complete()?;
244            let d = GeneralOperand::parse(stream)?;
245            stream.expect_complete()?;
246            stream.expect(&PtxToken::Comma)?;
247            let a = GeneralOperand::parse(stream)?;
248            stream.expect_complete()?;
249            stream.expect(&PtxToken::Comma)?;
250            let b = GeneralOperand::parse(stream)?;
251            stream.expect_complete()?;
252            stream.expect_complete()?;
253            stream.expect(&PtxToken::Semicolon)?;
254            Ok(SubRndFtzSatF32 {
255                rnd,
256                ftz,
257                sat,
258                f32,
259                d,
260                a,
261                b,
262            })
263        }
264    }
265
266    impl PtxParser for SubRndFtzF32x2 {
267        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
268            stream.expect_string("sub")?;
269            let saved_pos = stream.position();
270            let rnd = match Rnd::parse(stream) {
271                Ok(val) => Some(val),
272                Err(_) => {
273                    stream.set_position(saved_pos);
274                    None
275                }
276            };
277            stream.expect_complete()?;
278            let saved_pos = stream.position();
279            let ftz = stream.expect_string(".ftz").is_ok();
280            if !ftz {
281                stream.set_position(saved_pos);
282            }
283            stream.expect_complete()?;
284            stream.expect_string(".f32x2")?;
285            let f32x2 = ();
286            stream.expect_complete()?;
287            let d = GeneralOperand::parse(stream)?;
288            stream.expect_complete()?;
289            stream.expect(&PtxToken::Comma)?;
290            let a = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect(&PtxToken::Comma)?;
293            let b = GeneralOperand::parse(stream)?;
294            stream.expect_complete()?;
295            stream.expect_complete()?;
296            stream.expect(&PtxToken::Semicolon)?;
297            Ok(SubRndFtzF32x2 {
298                rnd,
299                ftz,
300                f32x2,
301                d,
302                a,
303                b,
304            })
305        }
306    }
307
308    impl PtxParser for SubRndF64 {
309        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
310            stream.expect_string("sub")?;
311            let saved_pos = stream.position();
312            let rnd = match Rnd::parse(stream) {
313                Ok(val) => Some(val),
314                Err(_) => {
315                    stream.set_position(saved_pos);
316                    None
317                }
318            };
319            stream.expect_complete()?;
320            stream.expect_string(".f64")?;
321            let f64 = ();
322            stream.expect_complete()?;
323            let d = GeneralOperand::parse(stream)?;
324            stream.expect_complete()?;
325            stream.expect(&PtxToken::Comma)?;
326            let a = GeneralOperand::parse(stream)?;
327            stream.expect_complete()?;
328            stream.expect(&PtxToken::Comma)?;
329            let b = GeneralOperand::parse(stream)?;
330            stream.expect_complete()?;
331            stream.expect_complete()?;
332            stream.expect(&PtxToken::Semicolon)?;
333            Ok(SubRndF64 { rnd, f64, d, a, b })
334        }
335    }
336}
337
338pub mod section_2 {
339    use super::*;
340    use crate::r#type::instruction::sub::section_2::*;
341
342    // ============================================================================
343    // Generated enum parsers
344    // ============================================================================
345
346    impl PtxParser for Rnd {
347        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
348            // Try Rn
349            {
350                let saved_pos = stream.position();
351                if stream.expect_string(".rn").is_ok() {
352                    return Ok(Rnd::Rn);
353                }
354                stream.set_position(saved_pos);
355            }
356            let span = stream
357                .peek()
358                .map(|(_, s)| s.clone())
359                .unwrap_or(Span { start: 0, end: 0 });
360            let expected = &[".rn"];
361            let found = stream
362                .peek()
363                .map(|(t, _)| format!("{:?}", t))
364                .unwrap_or_else(|_| "<end of input>".to_string());
365            Err(crate::parser::unexpected_value(span, expected, found))
366        }
367    }
368
369    impl PtxParser for SubRndFtzSatF16 {
370        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
371            stream.expect_string("sub")?;
372            let saved_pos = stream.position();
373            let rnd = match Rnd::parse(stream) {
374                Ok(val) => Some(val),
375                Err(_) => {
376                    stream.set_position(saved_pos);
377                    None
378                }
379            };
380            stream.expect_complete()?;
381            let saved_pos = stream.position();
382            let ftz = stream.expect_string(".ftz").is_ok();
383            if !ftz {
384                stream.set_position(saved_pos);
385            }
386            stream.expect_complete()?;
387            let saved_pos = stream.position();
388            let sat = stream.expect_string(".sat").is_ok();
389            if !sat {
390                stream.set_position(saved_pos);
391            }
392            stream.expect_complete()?;
393            stream.expect_string(".f16")?;
394            let f16 = ();
395            stream.expect_complete()?;
396            let d = GeneralOperand::parse(stream)?;
397            stream.expect_complete()?;
398            stream.expect(&PtxToken::Comma)?;
399            let a = GeneralOperand::parse(stream)?;
400            stream.expect_complete()?;
401            stream.expect(&PtxToken::Comma)?;
402            let b = GeneralOperand::parse(stream)?;
403            stream.expect_complete()?;
404            stream.expect_complete()?;
405            stream.expect(&PtxToken::Semicolon)?;
406            Ok(SubRndFtzSatF16 {
407                rnd,
408                ftz,
409                sat,
410                f16,
411                d,
412                a,
413                b,
414            })
415        }
416    }
417
418    impl PtxParser for SubRndFtzSatF16x2 {
419        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
420            stream.expect_string("sub")?;
421            let saved_pos = stream.position();
422            let rnd = match Rnd::parse(stream) {
423                Ok(val) => Some(val),
424                Err(_) => {
425                    stream.set_position(saved_pos);
426                    None
427                }
428            };
429            stream.expect_complete()?;
430            let saved_pos = stream.position();
431            let ftz = stream.expect_string(".ftz").is_ok();
432            if !ftz {
433                stream.set_position(saved_pos);
434            }
435            stream.expect_complete()?;
436            let saved_pos = stream.position();
437            let sat = stream.expect_string(".sat").is_ok();
438            if !sat {
439                stream.set_position(saved_pos);
440            }
441            stream.expect_complete()?;
442            stream.expect_string(".f16x2")?;
443            let f16x2 = ();
444            stream.expect_complete()?;
445            let d = GeneralOperand::parse(stream)?;
446            stream.expect_complete()?;
447            stream.expect(&PtxToken::Comma)?;
448            let a = GeneralOperand::parse(stream)?;
449            stream.expect_complete()?;
450            stream.expect(&PtxToken::Comma)?;
451            let b = GeneralOperand::parse(stream)?;
452            stream.expect_complete()?;
453            stream.expect_complete()?;
454            stream.expect(&PtxToken::Semicolon)?;
455            Ok(SubRndFtzSatF16x2 {
456                rnd,
457                ftz,
458                sat,
459                f16x2,
460                d,
461                a,
462                b,
463            })
464        }
465    }
466
467    impl PtxParser for SubRndBf16 {
468        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
469            stream.expect_string("sub")?;
470            let saved_pos = stream.position();
471            let rnd = match Rnd::parse(stream) {
472                Ok(val) => Some(val),
473                Err(_) => {
474                    stream.set_position(saved_pos);
475                    None
476                }
477            };
478            stream.expect_complete()?;
479            stream.expect_string(".bf16")?;
480            let bf16 = ();
481            stream.expect_complete()?;
482            let d = GeneralOperand::parse(stream)?;
483            stream.expect_complete()?;
484            stream.expect(&PtxToken::Comma)?;
485            let a = GeneralOperand::parse(stream)?;
486            stream.expect_complete()?;
487            stream.expect(&PtxToken::Comma)?;
488            let b = GeneralOperand::parse(stream)?;
489            stream.expect_complete()?;
490            stream.expect_complete()?;
491            stream.expect(&PtxToken::Semicolon)?;
492            Ok(SubRndBf16 { rnd, bf16, d, a, b })
493        }
494    }
495
496    impl PtxParser for SubRndBf16x2 {
497        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
498            stream.expect_string("sub")?;
499            let saved_pos = stream.position();
500            let rnd = match Rnd::parse(stream) {
501                Ok(val) => Some(val),
502                Err(_) => {
503                    stream.set_position(saved_pos);
504                    None
505                }
506            };
507            stream.expect_complete()?;
508            stream.expect_string(".bf16x2")?;
509            let bf16x2 = ();
510            stream.expect_complete()?;
511            let d = GeneralOperand::parse(stream)?;
512            stream.expect_complete()?;
513            stream.expect(&PtxToken::Comma)?;
514            let a = GeneralOperand::parse(stream)?;
515            stream.expect_complete()?;
516            stream.expect(&PtxToken::Comma)?;
517            let b = GeneralOperand::parse(stream)?;
518            stream.expect_complete()?;
519            stream.expect_complete()?;
520            stream.expect(&PtxToken::Semicolon)?;
521            Ok(SubRndBf16x2 {
522                rnd,
523                bf16x2,
524                d,
525                a,
526                b,
527            })
528        }
529    }
530}
531
532pub mod section_3 {
533    use super::*;
534    use crate::r#type::instruction::sub::section_3::*;
535
536    // ============================================================================
537    // Generated enum parsers
538    // ============================================================================
539
540    impl PtxParser for Atype {
541        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
542            // Try Bf16
543            {
544                let saved_pos = stream.position();
545                if stream.expect_string(".bf16").is_ok() {
546                    return Ok(Atype::Bf16);
547                }
548                stream.set_position(saved_pos);
549            }
550            let saved_pos = stream.position();
551            // Try F16
552            {
553                let saved_pos = stream.position();
554                if stream.expect_string(".f16").is_ok() {
555                    return Ok(Atype::F16);
556                }
557                stream.set_position(saved_pos);
558            }
559            stream.set_position(saved_pos);
560            let span = stream
561                .peek()
562                .map(|(_, s)| s.clone())
563                .unwrap_or(Span { start: 0, end: 0 });
564            let expected = &[".bf16", ".f16"];
565            let found = stream
566                .peek()
567                .map(|(t, _)| format!("{:?}", t))
568                .unwrap_or_else(|_| "<end of input>".to_string());
569            Err(crate::parser::unexpected_value(span, expected, found))
570        }
571    }
572
573    impl PtxParser for Rnd {
574        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
575            // Try Rn
576            {
577                let saved_pos = stream.position();
578                if stream.expect_string(".rn").is_ok() {
579                    return Ok(Rnd::Rn);
580                }
581                stream.set_position(saved_pos);
582            }
583            let saved_pos = stream.position();
584            // Try Rz
585            {
586                let saved_pos = stream.position();
587                if stream.expect_string(".rz").is_ok() {
588                    return Ok(Rnd::Rz);
589                }
590                stream.set_position(saved_pos);
591            }
592            stream.set_position(saved_pos);
593            let saved_pos = stream.position();
594            // Try Rm
595            {
596                let saved_pos = stream.position();
597                if stream.expect_string(".rm").is_ok() {
598                    return Ok(Rnd::Rm);
599                }
600                stream.set_position(saved_pos);
601            }
602            stream.set_position(saved_pos);
603            let saved_pos = stream.position();
604            // Try Rp
605            {
606                let saved_pos = stream.position();
607                if stream.expect_string(".rp").is_ok() {
608                    return Ok(Rnd::Rp);
609                }
610                stream.set_position(saved_pos);
611            }
612            stream.set_position(saved_pos);
613            let span = stream
614                .peek()
615                .map(|(_, s)| s.clone())
616                .unwrap_or(Span { start: 0, end: 0 });
617            let expected = &[".rn", ".rz", ".rm", ".rp"];
618            let found = stream
619                .peek()
620                .map(|(t, _)| format!("{:?}", t))
621                .unwrap_or_else(|_| "<end of input>".to_string());
622            Err(crate::parser::unexpected_value(span, expected, found))
623        }
624    }
625
626    impl PtxParser for SubRndSatF32Atype {
627        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
628            stream.expect_string("sub")?;
629            let saved_pos = stream.position();
630            let rnd = match Rnd::parse(stream) {
631                Ok(val) => Some(val),
632                Err(_) => {
633                    stream.set_position(saved_pos);
634                    None
635                }
636            };
637            stream.expect_complete()?;
638            let saved_pos = stream.position();
639            let sat = stream.expect_string(".sat").is_ok();
640            if !sat {
641                stream.set_position(saved_pos);
642            }
643            stream.expect_complete()?;
644            stream.expect_string(".f32")?;
645            let f32 = ();
646            stream.expect_complete()?;
647            let atype = Atype::parse(stream)?;
648            stream.expect_complete()?;
649            let d = GeneralOperand::parse(stream)?;
650            stream.expect_complete()?;
651            stream.expect(&PtxToken::Comma)?;
652            let a = GeneralOperand::parse(stream)?;
653            stream.expect_complete()?;
654            stream.expect(&PtxToken::Comma)?;
655            let c = GeneralOperand::parse(stream)?;
656            stream.expect_complete()?;
657            stream.expect_complete()?;
658            stream.expect(&PtxToken::Semicolon)?;
659            Ok(SubRndSatF32Atype {
660                rnd,
661                sat,
662                f32,
663                atype,
664                d,
665                a,
666                c,
667            })
668        }
669    }
670}
ptx_parser/parser/instruction/sub.rs

ptx_parser/parser/instruction/
sub.rs
