ptx_parser/parser/instruction/
max.rs

1//! Original PTX specification:
2//!
3//! max.atype         d, a, b;
4//! max{.relu}.btype  d, a, b;
5//! .atype = { .u16, .u32, .u64,
6//! .u16x2, .s16, .s64 };
7//! .btype = { .s16x2, .s32 };
8//! 
9//! max{.ftz}{.NaN}{.xorsign.abs}.f32  d, a, b;
10//! max{.ftz}{.NaN}{.abs}.f32          d, a, b, c;
11//! max.f64                            d, a, b;
12//! 
13//! max{.ftz}{.NaN}{.xorsign.abs}.f16      d, a, b;
14//! max{.ftz}{.NaN}{.xorsign.abs}.f16x2    d, a, b;
15//! max{.NaN}{.xorsign.abs}.bf16           d, a, b;
16//! max{.NaN}{.xorsign.abs}.bf16x2         d, a, b;
17
18#![allow(unused)]
19
20use crate::lexer::PtxToken;
21use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
22use crate::r#type::common::*;
23
24pub mod section_0 {
25    use super::*;
26    use crate::r#type::instruction::max::section_0::*;
27
28    // ============================================================================
29    // Generated enum parsers
30    // ============================================================================
31
32    impl PtxParser for Atype {
33        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
34            // Try U16x2
35            {
36                let saved_pos = stream.position();
37                if stream.expect_string(".u16x2").is_ok() {
38                    return Ok(Atype::U16x2);
39                }
40                stream.set_position(saved_pos);
41            }
42            let saved_pos = stream.position();
43            // Try U16
44            {
45                let saved_pos = stream.position();
46                if stream.expect_string(".u16").is_ok() {
47                    return Ok(Atype::U16);
48                }
49                stream.set_position(saved_pos);
50            }
51            stream.set_position(saved_pos);
52            let saved_pos = stream.position();
53            // Try U32
54            {
55                let saved_pos = stream.position();
56                if stream.expect_string(".u32").is_ok() {
57                    return Ok(Atype::U32);
58                }
59                stream.set_position(saved_pos);
60            }
61            stream.set_position(saved_pos);
62            let saved_pos = stream.position();
63            // Try U64
64            {
65                let saved_pos = stream.position();
66                if stream.expect_string(".u64").is_ok() {
67                    return Ok(Atype::U64);
68                }
69                stream.set_position(saved_pos);
70            }
71            stream.set_position(saved_pos);
72            let saved_pos = stream.position();
73            // Try S16
74            {
75                let saved_pos = stream.position();
76                if stream.expect_string(".s16").is_ok() {
77                    return Ok(Atype::S16);
78                }
79                stream.set_position(saved_pos);
80            }
81            stream.set_position(saved_pos);
82            let saved_pos = stream.position();
83            // Try S64
84            {
85                let saved_pos = stream.position();
86                if stream.expect_string(".s64").is_ok() {
87                    return Ok(Atype::S64);
88                }
89                stream.set_position(saved_pos);
90            }
91            stream.set_position(saved_pos);
92            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
93            let expected = &[".u16x2", ".u16", ".u32", ".u64", ".s16", ".s64"];
94            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
95            Err(crate::parser::unexpected_value(span, expected, found))
96        }
97    }
98
99    impl PtxParser for Btype {
100        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
101            // Try S16x2
102            {
103                let saved_pos = stream.position();
104                if stream.expect_string(".s16x2").is_ok() {
105                    return Ok(Btype::S16x2);
106                }
107                stream.set_position(saved_pos);
108            }
109            let saved_pos = stream.position();
110            // Try S32
111            {
112                let saved_pos = stream.position();
113                if stream.expect_string(".s32").is_ok() {
114                    return Ok(Btype::S32);
115                }
116                stream.set_position(saved_pos);
117            }
118            stream.set_position(saved_pos);
119            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
120            let expected = &[".s16x2", ".s32"];
121            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
122            Err(crate::parser::unexpected_value(span, expected, found))
123        }
124    }
125
126    impl PtxParser for MaxAtype {
127        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
128            stream.expect_string("max")?;
129            let atype = Atype::parse(stream)?;
130            stream.expect_complete()?;
131            let d = GeneralOperand::parse(stream)?;
132            stream.expect_complete()?;
133            stream.expect(&PtxToken::Comma)?;
134            let a = GeneralOperand::parse(stream)?;
135            stream.expect_complete()?;
136            stream.expect(&PtxToken::Comma)?;
137            let b = GeneralOperand::parse(stream)?;
138            stream.expect_complete()?;
139            stream.expect_complete()?;
140            stream.expect(&PtxToken::Semicolon)?;
141            Ok(MaxAtype {
142                atype,
143                d,
144                a,
145                b,
146            })
147        }
148    }
149
150
151    impl PtxParser for MaxReluBtype {
152        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
153            stream.expect_string("max")?;
154            let saved_pos = stream.position();
155            let relu = stream.expect_string(".relu").is_ok();
156            if !relu {
157                stream.set_position(saved_pos);
158            }
159            stream.expect_complete()?;
160            let btype = Btype::parse(stream)?;
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(MaxReluBtype {
173                relu,
174                btype,
175                d,
176                a,
177                b,
178            })
179        }
180    }
181
182
183    impl PtxParser for MaxFtzNanXorsignAbsF32 {
184        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
185            stream.expect_string("max")?;
186            let saved_pos = stream.position();
187            let ftz = stream.expect_string(".ftz").is_ok();
188            if !ftz {
189                stream.set_position(saved_pos);
190            }
191            stream.expect_complete()?;
192            let saved_pos = stream.position();
193            let nan = stream.expect_string(".NaN").is_ok();
194            if !nan {
195                stream.set_position(saved_pos);
196            }
197            stream.expect_complete()?;
198            let saved_pos = stream.position();
199            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
200            if !xorsign_abs {
201                stream.set_position(saved_pos);
202            }
203            stream.expect_complete()?;
204            stream.expect_string(".f32")?;
205            let f32 = ();
206            stream.expect_complete()?;
207            let d = GeneralOperand::parse(stream)?;
208            stream.expect_complete()?;
209            stream.expect(&PtxToken::Comma)?;
210            let a = GeneralOperand::parse(stream)?;
211            stream.expect_complete()?;
212            stream.expect(&PtxToken::Comma)?;
213            let b = GeneralOperand::parse(stream)?;
214            stream.expect_complete()?;
215            stream.expect_complete()?;
216            stream.expect(&PtxToken::Semicolon)?;
217            Ok(MaxFtzNanXorsignAbsF32 {
218                ftz,
219                nan,
220                xorsign_abs,
221                f32,
222                d,
223                a,
224                b,
225            })
226        }
227    }
228
229
230    impl PtxParser for MaxFtzNanAbsF32 {
231        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
232            stream.expect_string("max")?;
233            let saved_pos = stream.position();
234            let ftz = stream.expect_string(".ftz").is_ok();
235            if !ftz {
236                stream.set_position(saved_pos);
237            }
238            stream.expect_complete()?;
239            let saved_pos = stream.position();
240            let nan = stream.expect_string(".NaN").is_ok();
241            if !nan {
242                stream.set_position(saved_pos);
243            }
244            stream.expect_complete()?;
245            let saved_pos = stream.position();
246            let abs = stream.expect_string(".abs").is_ok();
247            if !abs {
248                stream.set_position(saved_pos);
249            }
250            stream.expect_complete()?;
251            stream.expect_string(".f32")?;
252            let f32 = ();
253            stream.expect_complete()?;
254            let d = GeneralOperand::parse(stream)?;
255            stream.expect_complete()?;
256            stream.expect(&PtxToken::Comma)?;
257            let a = GeneralOperand::parse(stream)?;
258            stream.expect_complete()?;
259            stream.expect(&PtxToken::Comma)?;
260            let b = GeneralOperand::parse(stream)?;
261            stream.expect_complete()?;
262            stream.expect(&PtxToken::Comma)?;
263            let c = GeneralOperand::parse(stream)?;
264            stream.expect_complete()?;
265            stream.expect_complete()?;
266            stream.expect(&PtxToken::Semicolon)?;
267            Ok(MaxFtzNanAbsF32 {
268                ftz,
269                nan,
270                abs,
271                f32,
272                d,
273                a,
274                b,
275                c,
276            })
277        }
278    }
279
280
281    impl PtxParser for MaxF64 {
282        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
283            stream.expect_string("max")?;
284            stream.expect_string(".f64")?;
285            let f64 = ();
286            stream.expect_complete()?;
287            let d = GeneralOperand::parse(stream)?;
288            stream.expect_complete()?;
289            stream.expect(&PtxToken::Comma)?;
290            let a = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect(&PtxToken::Comma)?;
293            let b = GeneralOperand::parse(stream)?;
294            stream.expect_complete()?;
295            stream.expect_complete()?;
296            stream.expect(&PtxToken::Semicolon)?;
297            Ok(MaxF64 {
298                f64,
299                d,
300                a,
301                b,
302            })
303        }
304    }
305
306
307    impl PtxParser for MaxFtzNanXorsignAbsF16 {
308        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
309            stream.expect_string("max")?;
310            let saved_pos = stream.position();
311            let ftz = stream.expect_string(".ftz").is_ok();
312            if !ftz {
313                stream.set_position(saved_pos);
314            }
315            stream.expect_complete()?;
316            let saved_pos = stream.position();
317            let nan = stream.expect_string(".NaN").is_ok();
318            if !nan {
319                stream.set_position(saved_pos);
320            }
321            stream.expect_complete()?;
322            let saved_pos = stream.position();
323            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
324            if !xorsign_abs {
325                stream.set_position(saved_pos);
326            }
327            stream.expect_complete()?;
328            stream.expect_string(".f16")?;
329            let f16 = ();
330            stream.expect_complete()?;
331            let d = GeneralOperand::parse(stream)?;
332            stream.expect_complete()?;
333            stream.expect(&PtxToken::Comma)?;
334            let a = GeneralOperand::parse(stream)?;
335            stream.expect_complete()?;
336            stream.expect(&PtxToken::Comma)?;
337            let b = GeneralOperand::parse(stream)?;
338            stream.expect_complete()?;
339            stream.expect_complete()?;
340            stream.expect(&PtxToken::Semicolon)?;
341            Ok(MaxFtzNanXorsignAbsF16 {
342                ftz,
343                nan,
344                xorsign_abs,
345                f16,
346                d,
347                a,
348                b,
349            })
350        }
351    }
352
353
354    impl PtxParser for MaxFtzNanXorsignAbsF16x2 {
355        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
356            stream.expect_string("max")?;
357            let saved_pos = stream.position();
358            let ftz = stream.expect_string(".ftz").is_ok();
359            if !ftz {
360                stream.set_position(saved_pos);
361            }
362            stream.expect_complete()?;
363            let saved_pos = stream.position();
364            let nan = stream.expect_string(".NaN").is_ok();
365            if !nan {
366                stream.set_position(saved_pos);
367            }
368            stream.expect_complete()?;
369            let saved_pos = stream.position();
370            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
371            if !xorsign_abs {
372                stream.set_position(saved_pos);
373            }
374            stream.expect_complete()?;
375            stream.expect_string(".f16x2")?;
376            let f16x2 = ();
377            stream.expect_complete()?;
378            let d = GeneralOperand::parse(stream)?;
379            stream.expect_complete()?;
380            stream.expect(&PtxToken::Comma)?;
381            let a = GeneralOperand::parse(stream)?;
382            stream.expect_complete()?;
383            stream.expect(&PtxToken::Comma)?;
384            let b = GeneralOperand::parse(stream)?;
385            stream.expect_complete()?;
386            stream.expect_complete()?;
387            stream.expect(&PtxToken::Semicolon)?;
388            Ok(MaxFtzNanXorsignAbsF16x2 {
389                ftz,
390                nan,
391                xorsign_abs,
392                f16x2,
393                d,
394                a,
395                b,
396            })
397        }
398    }
399
400
401    impl PtxParser for MaxNanXorsignAbsBf16 {
402        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
403            stream.expect_string("max")?;
404            let saved_pos = stream.position();
405            let nan = stream.expect_string(".NaN").is_ok();
406            if !nan {
407                stream.set_position(saved_pos);
408            }
409            stream.expect_complete()?;
410            let saved_pos = stream.position();
411            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
412            if !xorsign_abs {
413                stream.set_position(saved_pos);
414            }
415            stream.expect_complete()?;
416            stream.expect_string(".bf16")?;
417            let bf16 = ();
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(MaxNanXorsignAbsBf16 {
430                nan,
431                xorsign_abs,
432                bf16,
433                d,
434                a,
435                b,
436            })
437        }
438    }
439
440
441    impl PtxParser for MaxNanXorsignAbsBf16x2 {
442        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
443            stream.expect_string("max")?;
444            let saved_pos = stream.position();
445            let nan = stream.expect_string(".NaN").is_ok();
446            if !nan {
447                stream.set_position(saved_pos);
448            }
449            stream.expect_complete()?;
450            let saved_pos = stream.position();
451            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
452            if !xorsign_abs {
453                stream.set_position(saved_pos);
454            }
455            stream.expect_complete()?;
456            stream.expect_string(".bf16x2")?;
457            let bf16x2 = ();
458            stream.expect_complete()?;
459            let d = GeneralOperand::parse(stream)?;
460            stream.expect_complete()?;
461            stream.expect(&PtxToken::Comma)?;
462            let a = GeneralOperand::parse(stream)?;
463            stream.expect_complete()?;
464            stream.expect(&PtxToken::Comma)?;
465            let b = GeneralOperand::parse(stream)?;
466            stream.expect_complete()?;
467            stream.expect_complete()?;
468            stream.expect(&PtxToken::Semicolon)?;
469            Ok(MaxNanXorsignAbsBf16x2 {
470                nan,
471                xorsign_abs,
472                bf16x2,
473                d,
474                a,
475                b,
476            })
477        }
478    }
479
480
481}
482
ptx_parser/parser/instruction/max.rs

ptx_parser/parser/instruction/
max.rs
