ptx_parser/parser/instruction/
add.rs

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

ptx_parser/parser/instruction/
add.rs
