ptx_parser/parser/instruction/
div.rs

1//! Original PTX specification:
2//!
3//! div.type  d, a, b;
4//! .type = { .u16, .u32, .u64,
5//! .s16, .s32, .s64 };
6//!
7//! div.approx{.ftz}.f32  d, a, b;  // fast, approximate divide
8//! div.full{.ftz}.f32    d, a, b;  // full-range approximate divide
9//! div.rnd{.ftz}.f32     d, a, b;  // IEEE 754 compliant rounding
10//! div.rnd.f64           d, a, b;  // IEEE 754 compliant rounding
11//! .rnd = { .rn, .rz, .rm, .rp };
12
13#![allow(unused)]
14
15use crate::parser::{
16    PtxParseError, PtxParser, PtxTokenStream, Span,
17    util::{
18        between, comma_p, directive_p, exclamation_p, lbracket_p, lparen_p, map, minus_p, optional,
19        pipe_p, rbracket_p, rparen_p, semicolon_p, sep_by, string_p, try_map,
20    },
21};
22use crate::r#type::common::*;
23use crate::{alt, ok, seq_n};
24
25pub mod section_0 {
26    use super::*;
27    use crate::r#type::instruction::div::section_0::*;
28
29    // ============================================================================
30    // Generated enum parsers
31    // ============================================================================
32
33    impl PtxParser for Rnd {
34        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
35            alt!(
36                map(string_p(".rn"), |_, _span| Rnd::Rn),
37                map(string_p(".rz"), |_, _span| Rnd::Rz),
38                map(string_p(".rm"), |_, _span| Rnd::Rm),
39                map(string_p(".rp"), |_, _span| Rnd::Rp)
40            )
41        }
42    }
43
44    impl PtxParser for Type {
45        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
46            alt!(
47                map(string_p(".u16"), |_, _span| Type::U16),
48                map(string_p(".u32"), |_, _span| Type::U32),
49                map(string_p(".u64"), |_, _span| Type::U64),
50                map(string_p(".s16"), |_, _span| Type::S16),
51                map(string_p(".s32"), |_, _span| Type::S32),
52                map(string_p(".s64"), |_, _span| Type::S64)
53            )
54        }
55    }
56
57    impl PtxParser for DivType {
58        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
59            try_map(
60                seq_n!(
61                    string_p("div"),
62                    Type::parse(),
63                    GeneralOperand::parse(),
64                    comma_p(),
65                    GeneralOperand::parse(),
66                    comma_p(),
67                    GeneralOperand::parse(),
68                    semicolon_p()
69                ),
70                |(_, type_, d, _, a, _, b, _), span| {
71                    ok!(DivType {
72                        type_ = type_,
73                        d = d,
74                        a = a,
75                        b = b,
76
77                    })
78                },
79            )
80        }
81    }
82
83    impl PtxParser for DivApproxFtzF32 {
84        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
85            try_map(
86                seq_n!(
87                    string_p("div"),
88                    string_p(".approx"),
89                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
90                    string_p(".f32"),
91                    GeneralOperand::parse(),
92                    comma_p(),
93                    GeneralOperand::parse(),
94                    comma_p(),
95                    GeneralOperand::parse(),
96                    semicolon_p()
97                ),
98                |(_, approx, ftz, f32, d, _, a, _, b, _), span| {
99                    ok!(DivApproxFtzF32 {
100                        approx = approx,
101                        ftz = ftz,
102                        f32 = f32,
103                        d = d,
104                        a = a,
105                        b = b,
106
107                    })
108                },
109            )
110        }
111    }
112
113    impl PtxParser for DivFullFtzF32 {
114        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
115            try_map(
116                seq_n!(
117                    string_p("div"),
118                    string_p(".full"),
119                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
120                    string_p(".f32"),
121                    GeneralOperand::parse(),
122                    comma_p(),
123                    GeneralOperand::parse(),
124                    comma_p(),
125                    GeneralOperand::parse(),
126                    semicolon_p()
127                ),
128                |(_, full, ftz, f32, d, _, a, _, b, _), span| {
129                    ok!(DivFullFtzF32 {
130                        full = full,
131                        ftz = ftz,
132                        f32 = f32,
133                        d = d,
134                        a = a,
135                        b = b,
136
137                    })
138                },
139            )
140        }
141    }
142
143    impl PtxParser for DivRndFtzF32 {
144        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
145            try_map(
146                seq_n!(
147                    string_p("div"),
148                    Rnd::parse(),
149                    map(optional(string_p(".ftz")), |value, _| value.is_some()),
150                    string_p(".f32"),
151                    GeneralOperand::parse(),
152                    comma_p(),
153                    GeneralOperand::parse(),
154                    comma_p(),
155                    GeneralOperand::parse(),
156                    semicolon_p()
157                ),
158                |(_, rnd, ftz, f32, d, _, a, _, b, _), span| {
159                    ok!(DivRndFtzF32 {
160                        rnd = rnd,
161                        ftz = ftz,
162                        f32 = f32,
163                        d = d,
164                        a = a,
165                        b = b,
166
167                    })
168                },
169            )
170        }
171    }
172
173    impl PtxParser for DivRndF64 {
174        fn parse() -> impl Fn(&mut PtxTokenStream) -> Result<(Self, Span), PtxParseError> {
175            try_map(
176                seq_n!(
177                    string_p("div"),
178                    Rnd::parse(),
179                    string_p(".f64"),
180                    GeneralOperand::parse(),
181                    comma_p(),
182                    GeneralOperand::parse(),
183                    comma_p(),
184                    GeneralOperand::parse(),
185                    semicolon_p()
186                ),
187                |(_, rnd, f64, d, _, a, _, b, _), span| {
188                    ok!(DivRndF64 {
189                        rnd = rnd,
190                        f64 = f64,
191                        d = d,
192                        a = a,
193                        b = b,
194
195                    })
196                },
197            )
198        }
199    }
200}
ptx_parser/parser/instruction/div.rs

ptx_parser/parser/instruction/
div.rs
