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

ptx_parser/parser/instruction/
mul.rs
