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.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
119            let expected = &[".u16x2", ".s16x2", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
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 AddType {
126        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
127            stream.expect_string("add")?;
128            let type_ = Type::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(AddType {
141                type_,
142                d,
143                a,
144                b,
145            })
146        }
147    }
148
149
150    impl PtxParser for AddSatS32 {
151        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
152            stream.expect_string("add")?;
153            let saved_pos = stream.position();
154            let sat = stream.expect_string(".sat").is_ok();
155            if !sat {
156                stream.set_position(saved_pos);
157            }
158            stream.expect_complete()?;
159            stream.expect_string(".s32")?;
160            let s32 = ();
161            stream.expect_complete()?;
162            let d = GeneralOperand::parse(stream)?;
163            stream.expect_complete()?;
164            stream.expect(&PtxToken::Comma)?;
165            let a = GeneralOperand::parse(stream)?;
166            stream.expect_complete()?;
167            stream.expect(&PtxToken::Comma)?;
168            let b = GeneralOperand::parse(stream)?;
169            stream.expect_complete()?;
170            stream.expect_complete()?;
171            stream.expect(&PtxToken::Semicolon)?;
172            Ok(AddSatS32 {
173                sat,
174                s32,
175                d,
176                a,
177                b,
178            })
179        }
180    }
181
182
183}
184
185pub mod section_1 {
186    use super::*;
187    use crate::r#type::instruction::add::section_1::*;
188
189    // ============================================================================
190    // Generated enum parsers
191    // ============================================================================
192
193    impl PtxParser for Rnd {
194        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
195            // Try Rn
196            {
197                let saved_pos = stream.position();
198                if stream.expect_string(".rn").is_ok() {
199                    return Ok(Rnd::Rn);
200                }
201                stream.set_position(saved_pos);
202            }
203            let saved_pos = stream.position();
204            // Try Rz
205            {
206                let saved_pos = stream.position();
207                if stream.expect_string(".rz").is_ok() {
208                    return Ok(Rnd::Rz);
209                }
210                stream.set_position(saved_pos);
211            }
212            stream.set_position(saved_pos);
213            let saved_pos = stream.position();
214            // Try Rm
215            {
216                let saved_pos = stream.position();
217                if stream.expect_string(".rm").is_ok() {
218                    return Ok(Rnd::Rm);
219                }
220                stream.set_position(saved_pos);
221            }
222            stream.set_position(saved_pos);
223            let saved_pos = stream.position();
224            // Try Rp
225            {
226                let saved_pos = stream.position();
227                if stream.expect_string(".rp").is_ok() {
228                    return Ok(Rnd::Rp);
229                }
230                stream.set_position(saved_pos);
231            }
232            stream.set_position(saved_pos);
233            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
234            let expected = &[".rn", ".rz", ".rm", ".rp"];
235            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).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
290    impl PtxParser for AddRndFtzF32x2 {
291        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
292            stream.expect_string("add")?;
293            let saved_pos = stream.position();
294            let rnd = match Rnd::parse(stream) {
295                Ok(val) => Some(val),
296                Err(_) => {
297                    stream.set_position(saved_pos);
298                    None
299                }
300            };
301            stream.expect_complete()?;
302            let saved_pos = stream.position();
303            let ftz = stream.expect_string(".ftz").is_ok();
304            if !ftz {
305                stream.set_position(saved_pos);
306            }
307            stream.expect_complete()?;
308            stream.expect_string(".f32x2")?;
309            let f32x2 = ();
310            stream.expect_complete()?;
311            let d = GeneralOperand::parse(stream)?;
312            stream.expect_complete()?;
313            stream.expect(&PtxToken::Comma)?;
314            let a = GeneralOperand::parse(stream)?;
315            stream.expect_complete()?;
316            stream.expect(&PtxToken::Comma)?;
317            let b = GeneralOperand::parse(stream)?;
318            stream.expect_complete()?;
319            stream.expect_complete()?;
320            stream.expect(&PtxToken::Semicolon)?;
321            Ok(AddRndFtzF32x2 {
322                rnd,
323                ftz,
324                f32x2,
325                d,
326                a,
327                b,
328            })
329        }
330    }
331
332
333    impl PtxParser for AddRndF64 {
334        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
335            stream.expect_string("add")?;
336            let saved_pos = stream.position();
337            let rnd = match Rnd::parse(stream) {
338                Ok(val) => Some(val),
339                Err(_) => {
340                    stream.set_position(saved_pos);
341                    None
342                }
343            };
344            stream.expect_complete()?;
345            stream.expect_string(".f64")?;
346            let f64 = ();
347            stream.expect_complete()?;
348            let d = GeneralOperand::parse(stream)?;
349            stream.expect_complete()?;
350            stream.expect(&PtxToken::Comma)?;
351            let a = GeneralOperand::parse(stream)?;
352            stream.expect_complete()?;
353            stream.expect(&PtxToken::Comma)?;
354            let b = GeneralOperand::parse(stream)?;
355            stream.expect_complete()?;
356            stream.expect_complete()?;
357            stream.expect(&PtxToken::Semicolon)?;
358            Ok(AddRndF64 {
359                rnd,
360                f64,
361                d,
362                a,
363                b,
364            })
365        }
366    }
367
368
369}
370
371pub mod section_2 {
372    use super::*;
373    use crate::r#type::instruction::add::section_2::*;
374
375    // ============================================================================
376    // Generated enum parsers
377    // ============================================================================
378
379    impl PtxParser for Rnd {
380        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
381            // Try Rn
382            {
383                let saved_pos = stream.position();
384                if stream.expect_string(".rn").is_ok() {
385                    return Ok(Rnd::Rn);
386                }
387                stream.set_position(saved_pos);
388            }
389            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
390            let expected = &[".rn"];
391            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
392            Err(crate::parser::unexpected_value(span, expected, found))
393        }
394    }
395
396    impl PtxParser for AddRndFtzSatF16 {
397        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
398            stream.expect_string("add")?;
399            let saved_pos = stream.position();
400            let rnd = match Rnd::parse(stream) {
401                Ok(val) => Some(val),
402                Err(_) => {
403                    stream.set_position(saved_pos);
404                    None
405                }
406            };
407            stream.expect_complete()?;
408            let saved_pos = stream.position();
409            let ftz = stream.expect_string(".ftz").is_ok();
410            if !ftz {
411                stream.set_position(saved_pos);
412            }
413            stream.expect_complete()?;
414            let saved_pos = stream.position();
415            let sat = stream.expect_string(".sat").is_ok();
416            if !sat {
417                stream.set_position(saved_pos);
418            }
419            stream.expect_complete()?;
420            stream.expect_string(".f16")?;
421            let f16 = ();
422            stream.expect_complete()?;
423            let d = GeneralOperand::parse(stream)?;
424            stream.expect_complete()?;
425            stream.expect(&PtxToken::Comma)?;
426            let a = GeneralOperand::parse(stream)?;
427            stream.expect_complete()?;
428            stream.expect(&PtxToken::Comma)?;
429            let b = GeneralOperand::parse(stream)?;
430            stream.expect_complete()?;
431            stream.expect_complete()?;
432            stream.expect(&PtxToken::Semicolon)?;
433            Ok(AddRndFtzSatF16 {
434                rnd,
435                ftz,
436                sat,
437                f16,
438                d,
439                a,
440                b,
441            })
442        }
443    }
444
445
446    impl PtxParser for AddRndFtzSatF16x2 {
447        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
448            stream.expect_string("add")?;
449            let saved_pos = stream.position();
450            let rnd = match Rnd::parse(stream) {
451                Ok(val) => Some(val),
452                Err(_) => {
453                    stream.set_position(saved_pos);
454                    None
455                }
456            };
457            stream.expect_complete()?;
458            let saved_pos = stream.position();
459            let ftz = stream.expect_string(".ftz").is_ok();
460            if !ftz {
461                stream.set_position(saved_pos);
462            }
463            stream.expect_complete()?;
464            let saved_pos = stream.position();
465            let sat = stream.expect_string(".sat").is_ok();
466            if !sat {
467                stream.set_position(saved_pos);
468            }
469            stream.expect_complete()?;
470            stream.expect_string(".f16x2")?;
471            let f16x2 = ();
472            stream.expect_complete()?;
473            let d = GeneralOperand::parse(stream)?;
474            stream.expect_complete()?;
475            stream.expect(&PtxToken::Comma)?;
476            let a = GeneralOperand::parse(stream)?;
477            stream.expect_complete()?;
478            stream.expect(&PtxToken::Comma)?;
479            let b = GeneralOperand::parse(stream)?;
480            stream.expect_complete()?;
481            stream.expect_complete()?;
482            stream.expect(&PtxToken::Semicolon)?;
483            Ok(AddRndFtzSatF16x2 {
484                rnd,
485                ftz,
486                sat,
487                f16x2,
488                d,
489                a,
490                b,
491            })
492        }
493    }
494
495
496    impl PtxParser for AddRndBf16 {
497        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
498            stream.expect_string("add")?;
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(".bf16")?;
509            let bf16 = ();
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(AddRndBf16 {
522                rnd,
523                bf16,
524                d,
525                a,
526                b,
527            })
528        }
529    }
530
531
532    impl PtxParser for AddRndBf16x2 {
533        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
534            stream.expect_string("add")?;
535            let saved_pos = stream.position();
536            let rnd = match Rnd::parse(stream) {
537                Ok(val) => Some(val),
538                Err(_) => {
539                    stream.set_position(saved_pos);
540                    None
541                }
542            };
543            stream.expect_complete()?;
544            stream.expect_string(".bf16x2")?;
545            let bf16x2 = ();
546            stream.expect_complete()?;
547            let d = GeneralOperand::parse(stream)?;
548            stream.expect_complete()?;
549            stream.expect(&PtxToken::Comma)?;
550            let a = GeneralOperand::parse(stream)?;
551            stream.expect_complete()?;
552            stream.expect(&PtxToken::Comma)?;
553            let b = GeneralOperand::parse(stream)?;
554            stream.expect_complete()?;
555            stream.expect_complete()?;
556            stream.expect(&PtxToken::Semicolon)?;
557            Ok(AddRndBf16x2 {
558                rnd,
559                bf16x2,
560                d,
561                a,
562                b,
563            })
564        }
565    }
566
567
568}
569
570pub mod section_3 {
571    use super::*;
572    use crate::r#type::instruction::add::section_3::*;
573
574    // ============================================================================
575    // Generated enum parsers
576    // ============================================================================
577
578    impl PtxParser for Atype {
579        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
580            // Try Bf16
581            {
582                let saved_pos = stream.position();
583                if stream.expect_string(".bf16").is_ok() {
584                    return Ok(Atype::Bf16);
585                }
586                stream.set_position(saved_pos);
587            }
588            let saved_pos = stream.position();
589            // Try F16
590            {
591                let saved_pos = stream.position();
592                if stream.expect_string(".f16").is_ok() {
593                    return Ok(Atype::F16);
594                }
595                stream.set_position(saved_pos);
596            }
597            stream.set_position(saved_pos);
598            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
599            let expected = &[".bf16", ".f16"];
600            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
601            Err(crate::parser::unexpected_value(span, expected, found))
602        }
603    }
604
605    impl PtxParser for Rnd {
606        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
607            // Try Rn
608            {
609                let saved_pos = stream.position();
610                if stream.expect_string(".rn").is_ok() {
611                    return Ok(Rnd::Rn);
612                }
613                stream.set_position(saved_pos);
614            }
615            let saved_pos = stream.position();
616            // Try Rz
617            {
618                let saved_pos = stream.position();
619                if stream.expect_string(".rz").is_ok() {
620                    return Ok(Rnd::Rz);
621                }
622                stream.set_position(saved_pos);
623            }
624            stream.set_position(saved_pos);
625            let saved_pos = stream.position();
626            // Try Rm
627            {
628                let saved_pos = stream.position();
629                if stream.expect_string(".rm").is_ok() {
630                    return Ok(Rnd::Rm);
631                }
632                stream.set_position(saved_pos);
633            }
634            stream.set_position(saved_pos);
635            let saved_pos = stream.position();
636            // Try Rp
637            {
638                let saved_pos = stream.position();
639                if stream.expect_string(".rp").is_ok() {
640                    return Ok(Rnd::Rp);
641                }
642                stream.set_position(saved_pos);
643            }
644            stream.set_position(saved_pos);
645            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
646            let expected = &[".rn", ".rz", ".rm", ".rp"];
647            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
648            Err(crate::parser::unexpected_value(span, expected, found))
649        }
650    }
651
652    impl PtxParser for AddRndSatF32Atype {
653        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
654            stream.expect_string("add")?;
655            let saved_pos = stream.position();
656            let rnd = match Rnd::parse(stream) {
657                Ok(val) => Some(val),
658                Err(_) => {
659                    stream.set_position(saved_pos);
660                    None
661                }
662            };
663            stream.expect_complete()?;
664            let saved_pos = stream.position();
665            let sat = stream.expect_string(".sat").is_ok();
666            if !sat {
667                stream.set_position(saved_pos);
668            }
669            stream.expect_complete()?;
670            stream.expect_string(".f32")?;
671            let f32 = ();
672            stream.expect_complete()?;
673            let atype = Atype::parse(stream)?;
674            stream.expect_complete()?;
675            let d = GeneralOperand::parse(stream)?;
676            stream.expect_complete()?;
677            stream.expect(&PtxToken::Comma)?;
678            let a = GeneralOperand::parse(stream)?;
679            stream.expect_complete()?;
680            stream.expect(&PtxToken::Comma)?;
681            let c = GeneralOperand::parse(stream)?;
682            stream.expect_complete()?;
683            stream.expect_complete()?;
684            stream.expect(&PtxToken::Semicolon)?;
685            Ok(AddRndSatF32Atype {
686                rnd,
687                sat,
688                f32,
689                atype,
690                d,
691                a,
692                c,
693            })
694        }
695    }
696
697
698}
699
ptx_parser/parser/instruction/add.rs

ptx_parser/parser/instruction/
add.rs
