ptx_parser/parser/instruction/
mul.rs

1//! Original PTX specification:
2//!
3//! mul.mode.type  d, a, b;
4//! .mode = { .hi, .lo, .wide };
5//! .type = { .u16, .u32, .u64,
6//! .s16, .s32, .s64 };
7//! --------------------------------------------
8//! mul{.rnd}{.ftz}{.sat}.f32  d, a, b;
9//! mul{.rnd}{.ftz}.f32x2      d, a, b;
10//! mul{.rnd}.f64              d, a, b;
11//! .rnd = { .rn, .rz, .rm, .rp };
12//! --------------------------------------------
13//! mul{.rnd}{.ftz}{.sat}.f16   d, a, b;
14//! mul{.rnd}{.ftz}{.sat}.f16x2 d, a, b;
15//! mul{.rnd}.bf16   d, a, b;
16//! mul{.rnd}.bf16x2 d, a, b;
17//! .rnd = { .rn };
18
19#![allow(unused)]
20
21use crate::lexer::PtxToken;
22use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
23use crate::r#type::common::*;
24
25pub mod section_0 {
26    use super::*;
27    use crate::r#type::instruction::mul::section_0::*;
28
29    // ============================================================================
30    // Generated enum parsers
31    // ============================================================================
32
33    impl PtxParser for Mode {
34        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
35            // Try Wide
36            {
37                let saved_pos = stream.position();
38                if stream.expect_string(".wide").is_ok() {
39                    return Ok(Mode::Wide);
40                }
41                stream.set_position(saved_pos);
42            }
43            let saved_pos = stream.position();
44            // Try Hi
45            {
46                let saved_pos = stream.position();
47                if stream.expect_string(".hi").is_ok() {
48                    return Ok(Mode::Hi);
49                }
50                stream.set_position(saved_pos);
51            }
52            stream.set_position(saved_pos);
53            let saved_pos = stream.position();
54            // Try Lo
55            {
56                let saved_pos = stream.position();
57                if stream.expect_string(".lo").is_ok() {
58                    return Ok(Mode::Lo);
59                }
60                stream.set_position(saved_pos);
61            }
62            stream.set_position(saved_pos);
63            let span = stream
64                .peek()
65                .map(|(_, s)| s.clone())
66                .unwrap_or(Span { start: 0, end: 0 });
67            let expected = &[".wide", ".hi", ".lo"];
68            let found = stream
69                .peek()
70                .map(|(t, _)| format!("{:?}", t))
71                .unwrap_or_else(|_| "<end of input>".to_string());
72            Err(crate::parser::unexpected_value(span, expected, found))
73        }
74    }
75
76    impl PtxParser for Type {
77        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
78            // Try U16
79            {
80                let saved_pos = stream.position();
81                if stream.expect_string(".u16").is_ok() {
82                    return Ok(Type::U16);
83                }
84                stream.set_position(saved_pos);
85            }
86            let saved_pos = stream.position();
87            // Try U32
88            {
89                let saved_pos = stream.position();
90                if stream.expect_string(".u32").is_ok() {
91                    return Ok(Type::U32);
92                }
93                stream.set_position(saved_pos);
94            }
95            stream.set_position(saved_pos);
96            let saved_pos = stream.position();
97            // Try U64
98            {
99                let saved_pos = stream.position();
100                if stream.expect_string(".u64").is_ok() {
101                    return Ok(Type::U64);
102                }
103                stream.set_position(saved_pos);
104            }
105            stream.set_position(saved_pos);
106            let saved_pos = stream.position();
107            // Try S16
108            {
109                let saved_pos = stream.position();
110                if stream.expect_string(".s16").is_ok() {
111                    return Ok(Type::S16);
112                }
113                stream.set_position(saved_pos);
114            }
115            stream.set_position(saved_pos);
116            let saved_pos = stream.position();
117            // Try S32
118            {
119                let saved_pos = stream.position();
120                if stream.expect_string(".s32").is_ok() {
121                    return Ok(Type::S32);
122                }
123                stream.set_position(saved_pos);
124            }
125            stream.set_position(saved_pos);
126            let saved_pos = stream.position();
127            // Try S64
128            {
129                let saved_pos = stream.position();
130                if stream.expect_string(".s64").is_ok() {
131                    return Ok(Type::S64);
132                }
133                stream.set_position(saved_pos);
134            }
135            stream.set_position(saved_pos);
136            let span = stream
137                .peek()
138                .map(|(_, s)| s.clone())
139                .unwrap_or(Span { start: 0, end: 0 });
140            let expected = &[".u16", ".u32", ".u64", ".s16", ".s32", ".s64"];
141            let found = stream
142                .peek()
143                .map(|(t, _)| format!("{:?}", t))
144                .unwrap_or_else(|_| "<end of input>".to_string());
145            Err(crate::parser::unexpected_value(span, expected, found))
146        }
147    }
148
149    impl PtxParser for MulModeType {
150        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
151            stream.expect_string("mul")?;
152            let mode = Mode::parse(stream)?;
153            stream.expect_complete()?;
154            let type_ = Type::parse(stream)?;
155            stream.expect_complete()?;
156            let d = GeneralOperand::parse(stream)?;
157            stream.expect_complete()?;
158            stream.expect(&PtxToken::Comma)?;
159            let a = GeneralOperand::parse(stream)?;
160            stream.expect_complete()?;
161            stream.expect(&PtxToken::Comma)?;
162            let b = GeneralOperand::parse(stream)?;
163            stream.expect_complete()?;
164            stream.expect_complete()?;
165            stream.expect(&PtxToken::Semicolon)?;
166            Ok(MulModeType {
167                mode,
168                type_,
169                d,
170                a,
171                b,
172            })
173        }
174    }
175}
176
177pub mod section_1 {
178    use super::*;
179    use crate::r#type::instruction::mul::section_1::*;
180
181    // ============================================================================
182    // Generated enum parsers
183    // ============================================================================
184
185    impl PtxParser for Rnd {
186        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
187            // Try Rn
188            {
189                let saved_pos = stream.position();
190                if stream.expect_string(".rn").is_ok() {
191                    return Ok(Rnd::Rn);
192                }
193                stream.set_position(saved_pos);
194            }
195            let saved_pos = stream.position();
196            // Try Rz
197            {
198                let saved_pos = stream.position();
199                if stream.expect_string(".rz").is_ok() {
200                    return Ok(Rnd::Rz);
201                }
202                stream.set_position(saved_pos);
203            }
204            stream.set_position(saved_pos);
205            let saved_pos = stream.position();
206            // Try Rm
207            {
208                let saved_pos = stream.position();
209                if stream.expect_string(".rm").is_ok() {
210                    return Ok(Rnd::Rm);
211                }
212                stream.set_position(saved_pos);
213            }
214            stream.set_position(saved_pos);
215            let saved_pos = stream.position();
216            // Try Rp
217            {
218                let saved_pos = stream.position();
219                if stream.expect_string(".rp").is_ok() {
220                    return Ok(Rnd::Rp);
221                }
222                stream.set_position(saved_pos);
223            }
224            stream.set_position(saved_pos);
225            let span = stream
226                .peek()
227                .map(|(_, s)| s.clone())
228                .unwrap_or(Span { start: 0, end: 0 });
229            let expected = &[".rn", ".rz", ".rm", ".rp"];
230            let found = stream
231                .peek()
232                .map(|(t, _)| format!("{:?}", t))
233                .unwrap_or_else(|_| "<end of input>".to_string());
234            Err(crate::parser::unexpected_value(span, expected, found))
235        }
236    }
237
238    impl PtxParser for MulRndFtzSatF32 {
239        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
240            stream.expect_string("mul")?;
241            let saved_pos = stream.position();
242            let rnd = match Rnd::parse(stream) {
243                Ok(val) => Some(val),
244                Err(_) => {
245                    stream.set_position(saved_pos);
246                    None
247                }
248            };
249            stream.expect_complete()?;
250            let saved_pos = stream.position();
251            let ftz = stream.expect_string(".ftz").is_ok();
252            if !ftz {
253                stream.set_position(saved_pos);
254            }
255            stream.expect_complete()?;
256            let saved_pos = stream.position();
257            let sat = stream.expect_string(".sat").is_ok();
258            if !sat {
259                stream.set_position(saved_pos);
260            }
261            stream.expect_complete()?;
262            stream.expect_string(".f32")?;
263            let f32 = ();
264            stream.expect_complete()?;
265            let d = GeneralOperand::parse(stream)?;
266            stream.expect_complete()?;
267            stream.expect(&PtxToken::Comma)?;
268            let a = GeneralOperand::parse(stream)?;
269            stream.expect_complete()?;
270            stream.expect(&PtxToken::Comma)?;
271            let b = GeneralOperand::parse(stream)?;
272            stream.expect_complete()?;
273            stream.expect_complete()?;
274            stream.expect(&PtxToken::Semicolon)?;
275            Ok(MulRndFtzSatF32 {
276                rnd,
277                ftz,
278                sat,
279                f32,
280                d,
281                a,
282                b,
283            })
284        }
285    }
286
287    impl PtxParser for MulRndFtzF32x2 {
288        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
289            stream.expect_string("mul")?;
290            let saved_pos = stream.position();
291            let rnd = match Rnd::parse(stream) {
292                Ok(val) => Some(val),
293                Err(_) => {
294                    stream.set_position(saved_pos);
295                    None
296                }
297            };
298            stream.expect_complete()?;
299            let saved_pos = stream.position();
300            let ftz = stream.expect_string(".ftz").is_ok();
301            if !ftz {
302                stream.set_position(saved_pos);
303            }
304            stream.expect_complete()?;
305            stream.expect_string(".f32x2")?;
306            let f32x2 = ();
307            stream.expect_complete()?;
308            let d = GeneralOperand::parse(stream)?;
309            stream.expect_complete()?;
310            stream.expect(&PtxToken::Comma)?;
311            let a = GeneralOperand::parse(stream)?;
312            stream.expect_complete()?;
313            stream.expect(&PtxToken::Comma)?;
314            let b = GeneralOperand::parse(stream)?;
315            stream.expect_complete()?;
316            stream.expect_complete()?;
317            stream.expect(&PtxToken::Semicolon)?;
318            Ok(MulRndFtzF32x2 {
319                rnd,
320                ftz,
321                f32x2,
322                d,
323                a,
324                b,
325            })
326        }
327    }
328
329    impl PtxParser for MulRndF64 {
330        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
331            stream.expect_string("mul")?;
332            let saved_pos = stream.position();
333            let rnd = match Rnd::parse(stream) {
334                Ok(val) => Some(val),
335                Err(_) => {
336                    stream.set_position(saved_pos);
337                    None
338                }
339            };
340            stream.expect_complete()?;
341            stream.expect_string(".f64")?;
342            let f64 = ();
343            stream.expect_complete()?;
344            let d = GeneralOperand::parse(stream)?;
345            stream.expect_complete()?;
346            stream.expect(&PtxToken::Comma)?;
347            let a = GeneralOperand::parse(stream)?;
348            stream.expect_complete()?;
349            stream.expect(&PtxToken::Comma)?;
350            let b = GeneralOperand::parse(stream)?;
351            stream.expect_complete()?;
352            stream.expect_complete()?;
353            stream.expect(&PtxToken::Semicolon)?;
354            Ok(MulRndF64 { rnd, f64, d, a, b })
355        }
356    }
357}
358
359pub mod section_2 {
360    use super::*;
361    use crate::r#type::instruction::mul::section_2::*;
362
363    // ============================================================================
364    // Generated enum parsers
365    // ============================================================================
366
367    impl PtxParser for Rnd {
368        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
369            // Try Rn
370            {
371                let saved_pos = stream.position();
372                if stream.expect_string(".rn").is_ok() {
373                    return Ok(Rnd::Rn);
374                }
375                stream.set_position(saved_pos);
376            }
377            let span = stream
378                .peek()
379                .map(|(_, s)| s.clone())
380                .unwrap_or(Span { start: 0, end: 0 });
381            let expected = &[".rn"];
382            let found = stream
383                .peek()
384                .map(|(t, _)| format!("{:?}", t))
385                .unwrap_or_else(|_| "<end of input>".to_string());
386            Err(crate::parser::unexpected_value(span, expected, found))
387        }
388    }
389
390    impl PtxParser for MulRndFtzSatF16 {
391        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
392            stream.expect_string("mul")?;
393            let saved_pos = stream.position();
394            let rnd = match Rnd::parse(stream) {
395                Ok(val) => Some(val),
396                Err(_) => {
397                    stream.set_position(saved_pos);
398                    None
399                }
400            };
401            stream.expect_complete()?;
402            let saved_pos = stream.position();
403            let ftz = stream.expect_string(".ftz").is_ok();
404            if !ftz {
405                stream.set_position(saved_pos);
406            }
407            stream.expect_complete()?;
408            let saved_pos = stream.position();
409            let sat = stream.expect_string(".sat").is_ok();
410            if !sat {
411                stream.set_position(saved_pos);
412            }
413            stream.expect_complete()?;
414            stream.expect_string(".f16")?;
415            let f16 = ();
416            stream.expect_complete()?;
417            let d = GeneralOperand::parse(stream)?;
418            stream.expect_complete()?;
419            stream.expect(&PtxToken::Comma)?;
420            let a = GeneralOperand::parse(stream)?;
421            stream.expect_complete()?;
422            stream.expect(&PtxToken::Comma)?;
423            let b = GeneralOperand::parse(stream)?;
424            stream.expect_complete()?;
425            stream.expect_complete()?;
426            stream.expect(&PtxToken::Semicolon)?;
427            Ok(MulRndFtzSatF16 {
428                rnd,
429                ftz,
430                sat,
431                f16,
432                d,
433                a,
434                b,
435            })
436        }
437    }
438
439    impl PtxParser for MulRndFtzSatF16x2 {
440        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
441            stream.expect_string("mul")?;
442            let saved_pos = stream.position();
443            let rnd = match Rnd::parse(stream) {
444                Ok(val) => Some(val),
445                Err(_) => {
446                    stream.set_position(saved_pos);
447                    None
448                }
449            };
450            stream.expect_complete()?;
451            let saved_pos = stream.position();
452            let ftz = stream.expect_string(".ftz").is_ok();
453            if !ftz {
454                stream.set_position(saved_pos);
455            }
456            stream.expect_complete()?;
457            let saved_pos = stream.position();
458            let sat = stream.expect_string(".sat").is_ok();
459            if !sat {
460                stream.set_position(saved_pos);
461            }
462            stream.expect_complete()?;
463            stream.expect_string(".f16x2")?;
464            let f16x2 = ();
465            stream.expect_complete()?;
466            let d = GeneralOperand::parse(stream)?;
467            stream.expect_complete()?;
468            stream.expect(&PtxToken::Comma)?;
469            let a = GeneralOperand::parse(stream)?;
470            stream.expect_complete()?;
471            stream.expect(&PtxToken::Comma)?;
472            let b = GeneralOperand::parse(stream)?;
473            stream.expect_complete()?;
474            stream.expect_complete()?;
475            stream.expect(&PtxToken::Semicolon)?;
476            Ok(MulRndFtzSatF16x2 {
477                rnd,
478                ftz,
479                sat,
480                f16x2,
481                d,
482                a,
483                b,
484            })
485        }
486    }
487
488    impl PtxParser for MulRndBf16 {
489        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
490            stream.expect_string("mul")?;
491            let saved_pos = stream.position();
492            let rnd = match Rnd::parse(stream) {
493                Ok(val) => Some(val),
494                Err(_) => {
495                    stream.set_position(saved_pos);
496                    None
497                }
498            };
499            stream.expect_complete()?;
500            stream.expect_string(".bf16")?;
501            let bf16 = ();
502            stream.expect_complete()?;
503            let d = GeneralOperand::parse(stream)?;
504            stream.expect_complete()?;
505            stream.expect(&PtxToken::Comma)?;
506            let a = GeneralOperand::parse(stream)?;
507            stream.expect_complete()?;
508            stream.expect(&PtxToken::Comma)?;
509            let b = GeneralOperand::parse(stream)?;
510            stream.expect_complete()?;
511            stream.expect_complete()?;
512            stream.expect(&PtxToken::Semicolon)?;
513            Ok(MulRndBf16 { rnd, bf16, d, a, b })
514        }
515    }
516
517    impl PtxParser for MulRndBf16x2 {
518        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
519            stream.expect_string("mul")?;
520            let saved_pos = stream.position();
521            let rnd = match Rnd::parse(stream) {
522                Ok(val) => Some(val),
523                Err(_) => {
524                    stream.set_position(saved_pos);
525                    None
526                }
527            };
528            stream.expect_complete()?;
529            stream.expect_string(".bf16x2")?;
530            let bf16x2 = ();
531            stream.expect_complete()?;
532            let d = GeneralOperand::parse(stream)?;
533            stream.expect_complete()?;
534            stream.expect(&PtxToken::Comma)?;
535            let a = GeneralOperand::parse(stream)?;
536            stream.expect_complete()?;
537            stream.expect(&PtxToken::Comma)?;
538            let b = GeneralOperand::parse(stream)?;
539            stream.expect_complete()?;
540            stream.expect_complete()?;
541            stream.expect(&PtxToken::Semicolon)?;
542            Ok(MulRndBf16x2 {
543                rnd,
544                bf16x2,
545                d,
546                a,
547                b,
548            })
549        }
550    }
551}
ptx_parser/parser/instruction/mul.rs

ptx_parser/parser/instruction/
mul.rs
