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
93                .peek()
94                .map(|(_, s)| s.clone())
95                .unwrap_or(Span { start: 0, end: 0 });
96            let expected = &[".u16x2", ".u16", ".u32", ".u64", ".s16", ".s64"];
97            let found = stream
98                .peek()
99                .map(|(t, _)| format!("{:?}", t))
100                .unwrap_or_else(|_| "<end of input>".to_string());
101            Err(crate::parser::unexpected_value(span, expected, found))
102        }
103    }
104
105    impl PtxParser for Btype {
106        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
107            // Try S16x2
108            {
109                let saved_pos = stream.position();
110                if stream.expect_string(".s16x2").is_ok() {
111                    return Ok(Btype::S16x2);
112                }
113                stream.set_position(saved_pos);
114            }
115            let saved_pos = stream.position();
116            // Try S32
117            {
118                let saved_pos = stream.position();
119                if stream.expect_string(".s32").is_ok() {
120                    return Ok(Btype::S32);
121                }
122                stream.set_position(saved_pos);
123            }
124            stream.set_position(saved_pos);
125            let span = stream
126                .peek()
127                .map(|(_, s)| s.clone())
128                .unwrap_or(Span { start: 0, end: 0 });
129            let expected = &[".s16x2", ".s32"];
130            let found = stream
131                .peek()
132                .map(|(t, _)| format!("{:?}", t))
133                .unwrap_or_else(|_| "<end of input>".to_string());
134            Err(crate::parser::unexpected_value(span, expected, found))
135        }
136    }
137
138    impl PtxParser for MaxAtype {
139        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
140            stream.expect_string("max")?;
141            let atype = Atype::parse(stream)?;
142            stream.expect_complete()?;
143            let d = GeneralOperand::parse(stream)?;
144            stream.expect_complete()?;
145            stream.expect(&PtxToken::Comma)?;
146            let a = GeneralOperand::parse(stream)?;
147            stream.expect_complete()?;
148            stream.expect(&PtxToken::Comma)?;
149            let b = GeneralOperand::parse(stream)?;
150            stream.expect_complete()?;
151            stream.expect_complete()?;
152            stream.expect(&PtxToken::Semicolon)?;
153            Ok(MaxAtype { atype, d, a, b })
154        }
155    }
156
157    impl PtxParser for MaxReluBtype {
158        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
159            stream.expect_string("max")?;
160            let saved_pos = stream.position();
161            let relu = stream.expect_string(".relu").is_ok();
162            if !relu {
163                stream.set_position(saved_pos);
164            }
165            stream.expect_complete()?;
166            let btype = Btype::parse(stream)?;
167            stream.expect_complete()?;
168            let d = GeneralOperand::parse(stream)?;
169            stream.expect_complete()?;
170            stream.expect(&PtxToken::Comma)?;
171            let a = GeneralOperand::parse(stream)?;
172            stream.expect_complete()?;
173            stream.expect(&PtxToken::Comma)?;
174            let b = GeneralOperand::parse(stream)?;
175            stream.expect_complete()?;
176            stream.expect_complete()?;
177            stream.expect(&PtxToken::Semicolon)?;
178            Ok(MaxReluBtype {
179                relu,
180                btype,
181                d,
182                a,
183                b,
184            })
185        }
186    }
187
188    impl PtxParser for MaxFtzNanXorsignAbsF32 {
189        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
190            stream.expect_string("max")?;
191            let saved_pos = stream.position();
192            let ftz = stream.expect_string(".ftz").is_ok();
193            if !ftz {
194                stream.set_position(saved_pos);
195            }
196            stream.expect_complete()?;
197            let saved_pos = stream.position();
198            let nan = stream.expect_string(".NaN").is_ok();
199            if !nan {
200                stream.set_position(saved_pos);
201            }
202            stream.expect_complete()?;
203            let saved_pos = stream.position();
204            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
205            if !xorsign_abs {
206                stream.set_position(saved_pos);
207            }
208            stream.expect_complete()?;
209            stream.expect_string(".f32")?;
210            let f32 = ();
211            stream.expect_complete()?;
212            let d = GeneralOperand::parse(stream)?;
213            stream.expect_complete()?;
214            stream.expect(&PtxToken::Comma)?;
215            let a = GeneralOperand::parse(stream)?;
216            stream.expect_complete()?;
217            stream.expect(&PtxToken::Comma)?;
218            let b = GeneralOperand::parse(stream)?;
219            stream.expect_complete()?;
220            stream.expect_complete()?;
221            stream.expect(&PtxToken::Semicolon)?;
222            Ok(MaxFtzNanXorsignAbsF32 {
223                ftz,
224                nan,
225                xorsign_abs,
226                f32,
227                d,
228                a,
229                b,
230            })
231        }
232    }
233
234    impl PtxParser for MaxFtzNanAbsF32 {
235        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
236            stream.expect_string("max")?;
237            let saved_pos = stream.position();
238            let ftz = stream.expect_string(".ftz").is_ok();
239            if !ftz {
240                stream.set_position(saved_pos);
241            }
242            stream.expect_complete()?;
243            let saved_pos = stream.position();
244            let nan = stream.expect_string(".NaN").is_ok();
245            if !nan {
246                stream.set_position(saved_pos);
247            }
248            stream.expect_complete()?;
249            let saved_pos = stream.position();
250            let abs = stream.expect_string(".abs").is_ok();
251            if !abs {
252                stream.set_position(saved_pos);
253            }
254            stream.expect_complete()?;
255            stream.expect_string(".f32")?;
256            let f32 = ();
257            stream.expect_complete()?;
258            let d = GeneralOperand::parse(stream)?;
259            stream.expect_complete()?;
260            stream.expect(&PtxToken::Comma)?;
261            let a = GeneralOperand::parse(stream)?;
262            stream.expect_complete()?;
263            stream.expect(&PtxToken::Comma)?;
264            let b = GeneralOperand::parse(stream)?;
265            stream.expect_complete()?;
266            stream.expect(&PtxToken::Comma)?;
267            let c = GeneralOperand::parse(stream)?;
268            stream.expect_complete()?;
269            stream.expect_complete()?;
270            stream.expect(&PtxToken::Semicolon)?;
271            Ok(MaxFtzNanAbsF32 {
272                ftz,
273                nan,
274                abs,
275                f32,
276                d,
277                a,
278                b,
279                c,
280            })
281        }
282    }
283
284    impl PtxParser for MaxF64 {
285        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
286            stream.expect_string("max")?;
287            stream.expect_string(".f64")?;
288            let f64 = ();
289            stream.expect_complete()?;
290            let d = GeneralOperand::parse(stream)?;
291            stream.expect_complete()?;
292            stream.expect(&PtxToken::Comma)?;
293            let a = GeneralOperand::parse(stream)?;
294            stream.expect_complete()?;
295            stream.expect(&PtxToken::Comma)?;
296            let b = GeneralOperand::parse(stream)?;
297            stream.expect_complete()?;
298            stream.expect_complete()?;
299            stream.expect(&PtxToken::Semicolon)?;
300            Ok(MaxF64 { f64, d, a, b })
301        }
302    }
303
304    impl PtxParser for MaxFtzNanXorsignAbsF16 {
305        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
306            stream.expect_string("max")?;
307            let saved_pos = stream.position();
308            let ftz = stream.expect_string(".ftz").is_ok();
309            if !ftz {
310                stream.set_position(saved_pos);
311            }
312            stream.expect_complete()?;
313            let saved_pos = stream.position();
314            let nan = stream.expect_string(".NaN").is_ok();
315            if !nan {
316                stream.set_position(saved_pos);
317            }
318            stream.expect_complete()?;
319            let saved_pos = stream.position();
320            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
321            if !xorsign_abs {
322                stream.set_position(saved_pos);
323            }
324            stream.expect_complete()?;
325            stream.expect_string(".f16")?;
326            let f16 = ();
327            stream.expect_complete()?;
328            let d = GeneralOperand::parse(stream)?;
329            stream.expect_complete()?;
330            stream.expect(&PtxToken::Comma)?;
331            let a = GeneralOperand::parse(stream)?;
332            stream.expect_complete()?;
333            stream.expect(&PtxToken::Comma)?;
334            let b = GeneralOperand::parse(stream)?;
335            stream.expect_complete()?;
336            stream.expect_complete()?;
337            stream.expect(&PtxToken::Semicolon)?;
338            Ok(MaxFtzNanXorsignAbsF16 {
339                ftz,
340                nan,
341                xorsign_abs,
342                f16,
343                d,
344                a,
345                b,
346            })
347        }
348    }
349
350    impl PtxParser for MaxFtzNanXorsignAbsF16x2 {
351        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
352            stream.expect_string("max")?;
353            let saved_pos = stream.position();
354            let ftz = stream.expect_string(".ftz").is_ok();
355            if !ftz {
356                stream.set_position(saved_pos);
357            }
358            stream.expect_complete()?;
359            let saved_pos = stream.position();
360            let nan = stream.expect_string(".NaN").is_ok();
361            if !nan {
362                stream.set_position(saved_pos);
363            }
364            stream.expect_complete()?;
365            let saved_pos = stream.position();
366            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
367            if !xorsign_abs {
368                stream.set_position(saved_pos);
369            }
370            stream.expect_complete()?;
371            stream.expect_string(".f16x2")?;
372            let f16x2 = ();
373            stream.expect_complete()?;
374            let d = GeneralOperand::parse(stream)?;
375            stream.expect_complete()?;
376            stream.expect(&PtxToken::Comma)?;
377            let a = GeneralOperand::parse(stream)?;
378            stream.expect_complete()?;
379            stream.expect(&PtxToken::Comma)?;
380            let b = GeneralOperand::parse(stream)?;
381            stream.expect_complete()?;
382            stream.expect_complete()?;
383            stream.expect(&PtxToken::Semicolon)?;
384            Ok(MaxFtzNanXorsignAbsF16x2 {
385                ftz,
386                nan,
387                xorsign_abs,
388                f16x2,
389                d,
390                a,
391                b,
392            })
393        }
394    }
395
396    impl PtxParser for MaxNanXorsignAbsBf16 {
397        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
398            stream.expect_string("max")?;
399            let saved_pos = stream.position();
400            let nan = stream.expect_string(".NaN").is_ok();
401            if !nan {
402                stream.set_position(saved_pos);
403            }
404            stream.expect_complete()?;
405            let saved_pos = stream.position();
406            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
407            if !xorsign_abs {
408                stream.set_position(saved_pos);
409            }
410            stream.expect_complete()?;
411            stream.expect_string(".bf16")?;
412            let bf16 = ();
413            stream.expect_complete()?;
414            let d = GeneralOperand::parse(stream)?;
415            stream.expect_complete()?;
416            stream.expect(&PtxToken::Comma)?;
417            let a = GeneralOperand::parse(stream)?;
418            stream.expect_complete()?;
419            stream.expect(&PtxToken::Comma)?;
420            let b = GeneralOperand::parse(stream)?;
421            stream.expect_complete()?;
422            stream.expect_complete()?;
423            stream.expect(&PtxToken::Semicolon)?;
424            Ok(MaxNanXorsignAbsBf16 {
425                nan,
426                xorsign_abs,
427                bf16,
428                d,
429                a,
430                b,
431            })
432        }
433    }
434
435    impl PtxParser for MaxNanXorsignAbsBf16x2 {
436        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
437            stream.expect_string("max")?;
438            let saved_pos = stream.position();
439            let nan = stream.expect_string(".NaN").is_ok();
440            if !nan {
441                stream.set_position(saved_pos);
442            }
443            stream.expect_complete()?;
444            let saved_pos = stream.position();
445            let xorsign_abs = stream.expect_string(".xorsign.abs").is_ok();
446            if !xorsign_abs {
447                stream.set_position(saved_pos);
448            }
449            stream.expect_complete()?;
450            stream.expect_string(".bf16x2")?;
451            let bf16x2 = ();
452            stream.expect_complete()?;
453            let d = GeneralOperand::parse(stream)?;
454            stream.expect_complete()?;
455            stream.expect(&PtxToken::Comma)?;
456            let a = GeneralOperand::parse(stream)?;
457            stream.expect_complete()?;
458            stream.expect(&PtxToken::Comma)?;
459            let b = GeneralOperand::parse(stream)?;
460            stream.expect_complete()?;
461            stream.expect_complete()?;
462            stream.expect(&PtxToken::Semicolon)?;
463            Ok(MaxNanXorsignAbsBf16x2 {
464                nan,
465                xorsign_abs,
466                bf16x2,
467                d,
468                a,
469                b,
470            })
471        }
472    }
473}
ptx_parser/parser/instruction/max.rs

ptx_parser/parser/instruction/
max.rs
