ptx_parser/parser/instruction/
ld.rs

1//! Original PTX specification:
2//!
3//! ld{.weak}{.ss}{.cop}{.level::cache_hint}{.level::prefetch_size}{.vec}.type  d, [a]{.unified}{, cache-policy};
4//! ld{.weak}{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.level::prefetch_size}{.vec}.type  d, [a]{.unified}{, cache-policy};
5//! ld.volatile{.ss}{.level::prefetch_size}{.vec}.type  d, [a];
6//! ld.relaxed.scope{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.level::prefetch_size}{.vec}.type  d, [a]{, cache-policy};
7//! ld.acquire.scope{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.level::prefetch_size}{.vec}.type  d, [a]{, cache-policy};
8//! ld.mmio.relaxed.sys{.global}.type  d, [a];
9//! .ss =                       { .const, .global, .local, .param::entry, .param::func, .param, .shared, .shared::cta, .shared::cluster};
10//! .cop =                      { .ca, .cg, .cs, .lu, .cv };
11//! .level1::eviction_priority = { .L1::evict_normal, .L1::evict_unchanged, .L1::evict_first, .L1::evict_last, .L1::no_allocate };
12//! .level2::eviction_priority = {.L2::evict_normal, .L2::evict_first, .L2::evict_last};
13//! .level::cache_hint =        { .L2::cache_hint };
14//! .level::prefetch_size =     { .L2::64B, .L2::128B, .L2::256B };
15//! .scope =                    { .cta, .cluster, .gpu, .sys };
16//! .vec =                      { .v2, .v4, .v8 };
17//! .type =                     { .b8, .b16, .b32, .b64, .b128,
18//! .u8, .u16, .u32, .u64,
19//! .s8, .s16, .s32, .s64,
20//! .f32, .f64 };
21
22#![allow(unused)]
23
24use crate::lexer::PtxToken;
25use crate::parser::{PtxParseError, PtxParser, PtxTokenStream, Span};
26use crate::r#type::common::*;
27
28pub mod section_0 {
29    use super::*;
30    use crate::r#type::instruction::ld::section_0::*;
31
32    // ============================================================================
33    // Generated enum parsers
34    // ============================================================================
35
36    impl PtxParser for Cop {
37        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
38            // Try Ca
39            {
40                let saved_pos = stream.position();
41                if stream.expect_string(".ca").is_ok() {
42                    return Ok(Cop::Ca);
43                }
44                stream.set_position(saved_pos);
45            }
46            let saved_pos = stream.position();
47            // Try Cg
48            {
49                let saved_pos = stream.position();
50                if stream.expect_string(".cg").is_ok() {
51                    return Ok(Cop::Cg);
52                }
53                stream.set_position(saved_pos);
54            }
55            stream.set_position(saved_pos);
56            let saved_pos = stream.position();
57            // Try Cs
58            {
59                let saved_pos = stream.position();
60                if stream.expect_string(".cs").is_ok() {
61                    return Ok(Cop::Cs);
62                }
63                stream.set_position(saved_pos);
64            }
65            stream.set_position(saved_pos);
66            let saved_pos = stream.position();
67            // Try Lu
68            {
69                let saved_pos = stream.position();
70                if stream.expect_string(".lu").is_ok() {
71                    return Ok(Cop::Lu);
72                }
73                stream.set_position(saved_pos);
74            }
75            stream.set_position(saved_pos);
76            let saved_pos = stream.position();
77            // Try Cv
78            {
79                let saved_pos = stream.position();
80                if stream.expect_string(".cv").is_ok() {
81                    return Ok(Cop::Cv);
82                }
83                stream.set_position(saved_pos);
84            }
85            stream.set_position(saved_pos);
86            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
87            let expected = &[".ca", ".cg", ".cs", ".lu", ".cv"];
88            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
89            Err(crate::parser::unexpected_value(span, expected, found))
90        }
91    }
92
93    impl PtxParser for Level1EvictionPriority {
94        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
95            // Try L1EvictUnchanged
96            {
97                let saved_pos = stream.position();
98                if stream.expect_string(".L1::evict_unchanged").is_ok() {
99                    return Ok(Level1EvictionPriority::L1EvictUnchanged);
100                }
101                stream.set_position(saved_pos);
102            }
103            let saved_pos = stream.position();
104            // Try L1EvictNormal
105            {
106                let saved_pos = stream.position();
107                if stream.expect_string(".L1::evict_normal").is_ok() {
108                    return Ok(Level1EvictionPriority::L1EvictNormal);
109                }
110                stream.set_position(saved_pos);
111            }
112            stream.set_position(saved_pos);
113            let saved_pos = stream.position();
114            // Try L1EvictFirst
115            {
116                let saved_pos = stream.position();
117                if stream.expect_string(".L1::evict_first").is_ok() {
118                    return Ok(Level1EvictionPriority::L1EvictFirst);
119                }
120                stream.set_position(saved_pos);
121            }
122            stream.set_position(saved_pos);
123            let saved_pos = stream.position();
124            // Try L1NoAllocate
125            {
126                let saved_pos = stream.position();
127                if stream.expect_string(".L1::no_allocate").is_ok() {
128                    return Ok(Level1EvictionPriority::L1NoAllocate);
129                }
130                stream.set_position(saved_pos);
131            }
132            stream.set_position(saved_pos);
133            let saved_pos = stream.position();
134            // Try L1EvictLast
135            {
136                let saved_pos = stream.position();
137                if stream.expect_string(".L1::evict_last").is_ok() {
138                    return Ok(Level1EvictionPriority::L1EvictLast);
139                }
140                stream.set_position(saved_pos);
141            }
142            stream.set_position(saved_pos);
143            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
144            let expected = &[".L1::evict_unchanged", ".L1::evict_normal", ".L1::evict_first", ".L1::no_allocate", ".L1::evict_last"];
145            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
146            Err(crate::parser::unexpected_value(span, expected, found))
147        }
148    }
149
150    impl PtxParser for Level2EvictionPriority {
151        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
152            // Try L2EvictNormal
153            {
154                let saved_pos = stream.position();
155                if stream.expect_string(".L2::evict_normal").is_ok() {
156                    return Ok(Level2EvictionPriority::L2EvictNormal);
157                }
158                stream.set_position(saved_pos);
159            }
160            let saved_pos = stream.position();
161            // Try L2EvictFirst
162            {
163                let saved_pos = stream.position();
164                if stream.expect_string(".L2::evict_first").is_ok() {
165                    return Ok(Level2EvictionPriority::L2EvictFirst);
166                }
167                stream.set_position(saved_pos);
168            }
169            stream.set_position(saved_pos);
170            let saved_pos = stream.position();
171            // Try L2EvictLast
172            {
173                let saved_pos = stream.position();
174                if stream.expect_string(".L2::evict_last").is_ok() {
175                    return Ok(Level2EvictionPriority::L2EvictLast);
176                }
177                stream.set_position(saved_pos);
178            }
179            stream.set_position(saved_pos);
180            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
181            let expected = &[".L2::evict_normal", ".L2::evict_first", ".L2::evict_last"];
182            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
183            Err(crate::parser::unexpected_value(span, expected, found))
184        }
185    }
186
187    impl PtxParser for LevelCacheHint {
188        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
189            // Try L2CacheHint
190            {
191                let saved_pos = stream.position();
192                if stream.expect_string(".L2::cache_hint").is_ok() {
193                    return Ok(LevelCacheHint::L2CacheHint);
194                }
195                stream.set_position(saved_pos);
196            }
197            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
198            let expected = &[".L2::cache_hint"];
199            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
200            Err(crate::parser::unexpected_value(span, expected, found))
201        }
202    }
203
204    impl PtxParser for LevelPrefetchSize {
205        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
206            // Try L2128b
207            {
208                let saved_pos = stream.position();
209                if stream.expect_string(".L2::128B").is_ok() {
210                    return Ok(LevelPrefetchSize::L2128b);
211                }
212                stream.set_position(saved_pos);
213            }
214            let saved_pos = stream.position();
215            // Try L2256b
216            {
217                let saved_pos = stream.position();
218                if stream.expect_string(".L2::256B").is_ok() {
219                    return Ok(LevelPrefetchSize::L2256b);
220                }
221                stream.set_position(saved_pos);
222            }
223            stream.set_position(saved_pos);
224            let saved_pos = stream.position();
225            // Try L264b
226            {
227                let saved_pos = stream.position();
228                if stream.expect_string(".L2::64B").is_ok() {
229                    return Ok(LevelPrefetchSize::L264b);
230                }
231                stream.set_position(saved_pos);
232            }
233            stream.set_position(saved_pos);
234            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
235            let expected = &[".L2::128B", ".L2::256B", ".L2::64B"];
236            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
237            Err(crate::parser::unexpected_value(span, expected, found))
238        }
239    }
240
241    impl PtxParser for Scope {
242        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
243            // Try Cluster
244            {
245                let saved_pos = stream.position();
246                if stream.expect_string(".cluster").is_ok() {
247                    return Ok(Scope::Cluster);
248                }
249                stream.set_position(saved_pos);
250            }
251            let saved_pos = stream.position();
252            // Try Cta
253            {
254                let saved_pos = stream.position();
255                if stream.expect_string(".cta").is_ok() {
256                    return Ok(Scope::Cta);
257                }
258                stream.set_position(saved_pos);
259            }
260            stream.set_position(saved_pos);
261            let saved_pos = stream.position();
262            // Try Gpu
263            {
264                let saved_pos = stream.position();
265                if stream.expect_string(".gpu").is_ok() {
266                    return Ok(Scope::Gpu);
267                }
268                stream.set_position(saved_pos);
269            }
270            stream.set_position(saved_pos);
271            let saved_pos = stream.position();
272            // Try Sys
273            {
274                let saved_pos = stream.position();
275                if stream.expect_string(".sys").is_ok() {
276                    return Ok(Scope::Sys);
277                }
278                stream.set_position(saved_pos);
279            }
280            stream.set_position(saved_pos);
281            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
282            let expected = &[".cluster", ".cta", ".gpu", ".sys"];
283            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
284            Err(crate::parser::unexpected_value(span, expected, found))
285        }
286    }
287
288    impl PtxParser for Ss {
289        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
290            // Try SharedCluster
291            {
292                let saved_pos = stream.position();
293                if stream.expect_string(".shared::cluster").is_ok() {
294                    return Ok(Ss::SharedCluster);
295                }
296                stream.set_position(saved_pos);
297            }
298            let saved_pos = stream.position();
299            // Try ParamEntry
300            {
301                let saved_pos = stream.position();
302                if stream.expect_string(".param::entry").is_ok() {
303                    return Ok(Ss::ParamEntry);
304                }
305                stream.set_position(saved_pos);
306            }
307            stream.set_position(saved_pos);
308            let saved_pos = stream.position();
309            // Try ParamFunc
310            {
311                let saved_pos = stream.position();
312                if stream.expect_string(".param::func").is_ok() {
313                    return Ok(Ss::ParamFunc);
314                }
315                stream.set_position(saved_pos);
316            }
317            stream.set_position(saved_pos);
318            let saved_pos = stream.position();
319            // Try SharedCta
320            {
321                let saved_pos = stream.position();
322                if stream.expect_string(".shared::cta").is_ok() {
323                    return Ok(Ss::SharedCta);
324                }
325                stream.set_position(saved_pos);
326            }
327            stream.set_position(saved_pos);
328            let saved_pos = stream.position();
329            // Try Global
330            {
331                let saved_pos = stream.position();
332                if stream.expect_string(".global").is_ok() {
333                    return Ok(Ss::Global);
334                }
335                stream.set_position(saved_pos);
336            }
337            stream.set_position(saved_pos);
338            let saved_pos = stream.position();
339            // Try Shared
340            {
341                let saved_pos = stream.position();
342                if stream.expect_string(".shared").is_ok() {
343                    return Ok(Ss::Shared);
344                }
345                stream.set_position(saved_pos);
346            }
347            stream.set_position(saved_pos);
348            let saved_pos = stream.position();
349            // Try Const
350            {
351                let saved_pos = stream.position();
352                if stream.expect_string(".const").is_ok() {
353                    return Ok(Ss::Const);
354                }
355                stream.set_position(saved_pos);
356            }
357            stream.set_position(saved_pos);
358            let saved_pos = stream.position();
359            // Try Local
360            {
361                let saved_pos = stream.position();
362                if stream.expect_string(".local").is_ok() {
363                    return Ok(Ss::Local);
364                }
365                stream.set_position(saved_pos);
366            }
367            stream.set_position(saved_pos);
368            let saved_pos = stream.position();
369            // Try Param
370            {
371                let saved_pos = stream.position();
372                if stream.expect_string(".param").is_ok() {
373                    return Ok(Ss::Param);
374                }
375                stream.set_position(saved_pos);
376            }
377            stream.set_position(saved_pos);
378            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
379            let expected = &[".shared::cluster", ".param::entry", ".param::func", ".shared::cta", ".global", ".shared", ".const", ".local", ".param"];
380            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
381            Err(crate::parser::unexpected_value(span, expected, found))
382        }
383    }
384
385    impl PtxParser for Type {
386        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
387            // Try B128
388            {
389                let saved_pos = stream.position();
390                if stream.expect_string(".b128").is_ok() {
391                    return Ok(Type::B128);
392                }
393                stream.set_position(saved_pos);
394            }
395            let saved_pos = stream.position();
396            // Try B16
397            {
398                let saved_pos = stream.position();
399                if stream.expect_string(".b16").is_ok() {
400                    return Ok(Type::B16);
401                }
402                stream.set_position(saved_pos);
403            }
404            stream.set_position(saved_pos);
405            let saved_pos = stream.position();
406            // Try B32
407            {
408                let saved_pos = stream.position();
409                if stream.expect_string(".b32").is_ok() {
410                    return Ok(Type::B32);
411                }
412                stream.set_position(saved_pos);
413            }
414            stream.set_position(saved_pos);
415            let saved_pos = stream.position();
416            // Try B64
417            {
418                let saved_pos = stream.position();
419                if stream.expect_string(".b64").is_ok() {
420                    return Ok(Type::B64);
421                }
422                stream.set_position(saved_pos);
423            }
424            stream.set_position(saved_pos);
425            let saved_pos = stream.position();
426            // Try U16
427            {
428                let saved_pos = stream.position();
429                if stream.expect_string(".u16").is_ok() {
430                    return Ok(Type::U16);
431                }
432                stream.set_position(saved_pos);
433            }
434            stream.set_position(saved_pos);
435            let saved_pos = stream.position();
436            // Try U32
437            {
438                let saved_pos = stream.position();
439                if stream.expect_string(".u32").is_ok() {
440                    return Ok(Type::U32);
441                }
442                stream.set_position(saved_pos);
443            }
444            stream.set_position(saved_pos);
445            let saved_pos = stream.position();
446            // Try U64
447            {
448                let saved_pos = stream.position();
449                if stream.expect_string(".u64").is_ok() {
450                    return Ok(Type::U64);
451                }
452                stream.set_position(saved_pos);
453            }
454            stream.set_position(saved_pos);
455            let saved_pos = stream.position();
456            // Try S16
457            {
458                let saved_pos = stream.position();
459                if stream.expect_string(".s16").is_ok() {
460                    return Ok(Type::S16);
461                }
462                stream.set_position(saved_pos);
463            }
464            stream.set_position(saved_pos);
465            let saved_pos = stream.position();
466            // Try S32
467            {
468                let saved_pos = stream.position();
469                if stream.expect_string(".s32").is_ok() {
470                    return Ok(Type::S32);
471                }
472                stream.set_position(saved_pos);
473            }
474            stream.set_position(saved_pos);
475            let saved_pos = stream.position();
476            // Try S64
477            {
478                let saved_pos = stream.position();
479                if stream.expect_string(".s64").is_ok() {
480                    return Ok(Type::S64);
481                }
482                stream.set_position(saved_pos);
483            }
484            stream.set_position(saved_pos);
485            let saved_pos = stream.position();
486            // Try F32
487            {
488                let saved_pos = stream.position();
489                if stream.expect_string(".f32").is_ok() {
490                    return Ok(Type::F32);
491                }
492                stream.set_position(saved_pos);
493            }
494            stream.set_position(saved_pos);
495            let saved_pos = stream.position();
496            // Try F64
497            {
498                let saved_pos = stream.position();
499                if stream.expect_string(".f64").is_ok() {
500                    return Ok(Type::F64);
501                }
502                stream.set_position(saved_pos);
503            }
504            stream.set_position(saved_pos);
505            let saved_pos = stream.position();
506            // Try B8
507            {
508                let saved_pos = stream.position();
509                if stream.expect_string(".b8").is_ok() {
510                    return Ok(Type::B8);
511                }
512                stream.set_position(saved_pos);
513            }
514            stream.set_position(saved_pos);
515            let saved_pos = stream.position();
516            // Try U8
517            {
518                let saved_pos = stream.position();
519                if stream.expect_string(".u8").is_ok() {
520                    return Ok(Type::U8);
521                }
522                stream.set_position(saved_pos);
523            }
524            stream.set_position(saved_pos);
525            let saved_pos = stream.position();
526            // Try S8
527            {
528                let saved_pos = stream.position();
529                if stream.expect_string(".s8").is_ok() {
530                    return Ok(Type::S8);
531                }
532                stream.set_position(saved_pos);
533            }
534            stream.set_position(saved_pos);
535            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
536            let expected = &[".b128", ".b16", ".b32", ".b64", ".u16", ".u32", ".u64", ".s16", ".s32", ".s64", ".f32", ".f64", ".b8", ".u8", ".s8"];
537            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
538            Err(crate::parser::unexpected_value(span, expected, found))
539        }
540    }
541
542    impl PtxParser for Vec {
543        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
544            // Try V2
545            {
546                let saved_pos = stream.position();
547                if stream.expect_string(".v2").is_ok() {
548                    return Ok(Vec::V2);
549                }
550                stream.set_position(saved_pos);
551            }
552            let saved_pos = stream.position();
553            // Try V4
554            {
555                let saved_pos = stream.position();
556                if stream.expect_string(".v4").is_ok() {
557                    return Ok(Vec::V4);
558                }
559                stream.set_position(saved_pos);
560            }
561            stream.set_position(saved_pos);
562            let saved_pos = stream.position();
563            // Try V8
564            {
565                let saved_pos = stream.position();
566                if stream.expect_string(".v8").is_ok() {
567                    return Ok(Vec::V8);
568                }
569                stream.set_position(saved_pos);
570            }
571            stream.set_position(saved_pos);
572            let span = stream.peek().map(|(_, s)| s.clone()).unwrap_or(Span { start: 0, end: 0 });
573            let expected = &[".v2", ".v4", ".v8"];
574            let found = stream.peek().map(|(t, _)| format!("{:?}", t)).unwrap_or_else(|_| "<end of input>".to_string());
575            Err(crate::parser::unexpected_value(span, expected, found))
576        }
577    }
578
579    impl PtxParser for LdWeakSsCopLevelCacheHintLevelPrefetchSizeVecType {
580        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
581            stream.expect_string("ld")?;
582            let saved_pos = stream.position();
583            let weak = stream.expect_string(".weak").is_ok();
584            if !weak {
585                stream.set_position(saved_pos);
586            }
587            stream.expect_complete()?;
588            let saved_pos = stream.position();
589            let ss = match Ss::parse(stream) {
590                Ok(val) => Some(val),
591                Err(_) => {
592                    stream.set_position(saved_pos);
593                    None
594                }
595            };
596            stream.expect_complete()?;
597            let saved_pos = stream.position();
598            let cop = match Cop::parse(stream) {
599                Ok(val) => Some(val),
600                Err(_) => {
601                    stream.set_position(saved_pos);
602                    None
603                }
604            };
605            stream.expect_complete()?;
606            let saved_pos = stream.position();
607            let level_cache_hint = match LevelCacheHint::parse(stream) {
608                Ok(val) => Some(val),
609                Err(_) => {
610                    stream.set_position(saved_pos);
611                    None
612                }
613            };
614            stream.expect_complete()?;
615            let saved_pos = stream.position();
616            let level_prefetch_size = match LevelPrefetchSize::parse(stream) {
617                Ok(val) => Some(val),
618                Err(_) => {
619                    stream.set_position(saved_pos);
620                    None
621                }
622            };
623            stream.expect_complete()?;
624            let saved_pos = stream.position();
625            let vec = match Vec::parse(stream) {
626                Ok(val) => Some(val),
627                Err(_) => {
628                    stream.set_position(saved_pos);
629                    None
630                }
631            };
632            stream.expect_complete()?;
633            let type_ = Type::parse(stream)?;
634            stream.expect_complete()?;
635            let d = GeneralOperand::parse(stream)?;
636            stream.expect_complete()?;
637            stream.expect(&PtxToken::Comma)?;
638            let a = AddressOperand::parse(stream)?;
639            let saved_pos = stream.position();
640            let unified = stream.expect_string(".unified").is_ok();
641            if !unified {
642                stream.set_position(saved_pos);
643            }
644            stream.expect_complete()?;
645            let saved_pos = stream.position();
646            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
647            if !has_comma {
648                stream.set_position(saved_pos);
649            }
650            let saved_pos = stream.position();
651            let cache_policy = match GeneralOperand::parse(stream) {
652                Ok(val) => Some(val),
653                Err(_) => {
654                    stream.set_position(saved_pos);
655                    None
656                }
657            };
658            stream.expect_complete()?;
659            stream.expect_complete()?;
660            stream.expect(&PtxToken::Semicolon)?;
661            Ok(LdWeakSsCopLevelCacheHintLevelPrefetchSizeVecType {
662                weak,
663                ss,
664                cop,
665                level_cache_hint,
666                level_prefetch_size,
667                vec,
668                type_,
669                d,
670                a,
671                unified,
672                cache_policy,
673            })
674        }
675    }
676
677
678    impl PtxParser for LdWeakSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintLevelPrefetchSizeVecType {
679        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
680            stream.expect_string("ld")?;
681            let saved_pos = stream.position();
682            let weak = stream.expect_string(".weak").is_ok();
683            if !weak {
684                stream.set_position(saved_pos);
685            }
686            stream.expect_complete()?;
687            let saved_pos = stream.position();
688            let ss = match Ss::parse(stream) {
689                Ok(val) => Some(val),
690                Err(_) => {
691                    stream.set_position(saved_pos);
692                    None
693                }
694            };
695            stream.expect_complete()?;
696            let saved_pos = stream.position();
697            let level1_eviction_priority = match Level1EvictionPriority::parse(stream) {
698                Ok(val) => Some(val),
699                Err(_) => {
700                    stream.set_position(saved_pos);
701                    None
702                }
703            };
704            stream.expect_complete()?;
705            let saved_pos = stream.position();
706            let level2_eviction_priority = match Level2EvictionPriority::parse(stream) {
707                Ok(val) => Some(val),
708                Err(_) => {
709                    stream.set_position(saved_pos);
710                    None
711                }
712            };
713            stream.expect_complete()?;
714            let saved_pos = stream.position();
715            let level_cache_hint = match LevelCacheHint::parse(stream) {
716                Ok(val) => Some(val),
717                Err(_) => {
718                    stream.set_position(saved_pos);
719                    None
720                }
721            };
722            stream.expect_complete()?;
723            let saved_pos = stream.position();
724            let level_prefetch_size = match LevelPrefetchSize::parse(stream) {
725                Ok(val) => Some(val),
726                Err(_) => {
727                    stream.set_position(saved_pos);
728                    None
729                }
730            };
731            stream.expect_complete()?;
732            let saved_pos = stream.position();
733            let vec = match Vec::parse(stream) {
734                Ok(val) => Some(val),
735                Err(_) => {
736                    stream.set_position(saved_pos);
737                    None
738                }
739            };
740            stream.expect_complete()?;
741            let type_ = Type::parse(stream)?;
742            stream.expect_complete()?;
743            let d = GeneralOperand::parse(stream)?;
744            stream.expect_complete()?;
745            stream.expect(&PtxToken::Comma)?;
746            let a = AddressOperand::parse(stream)?;
747            let saved_pos = stream.position();
748            let unified = stream.expect_string(".unified").is_ok();
749            if !unified {
750                stream.set_position(saved_pos);
751            }
752            stream.expect_complete()?;
753            let saved_pos = stream.position();
754            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
755            if !has_comma {
756                stream.set_position(saved_pos);
757            }
758            let saved_pos = stream.position();
759            let cache_policy = match GeneralOperand::parse(stream) {
760                Ok(val) => Some(val),
761                Err(_) => {
762                    stream.set_position(saved_pos);
763                    None
764                }
765            };
766            stream.expect_complete()?;
767            stream.expect_complete()?;
768            stream.expect(&PtxToken::Semicolon)?;
769            Ok(LdWeakSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintLevelPrefetchSizeVecType {
770                weak,
771                ss,
772                level1_eviction_priority,
773                level2_eviction_priority,
774                level_cache_hint,
775                level_prefetch_size,
776                vec,
777                type_,
778                d,
779                a,
780                unified,
781                cache_policy,
782            })
783        }
784    }
785
786
787    impl PtxParser for LdVolatileSsLevelPrefetchSizeVecType {
788        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
789            stream.expect_string("ld")?;
790            stream.expect_string(".volatile")?;
791            let volatile = ();
792            stream.expect_complete()?;
793            let saved_pos = stream.position();
794            let ss = match Ss::parse(stream) {
795                Ok(val) => Some(val),
796                Err(_) => {
797                    stream.set_position(saved_pos);
798                    None
799                }
800            };
801            stream.expect_complete()?;
802            let saved_pos = stream.position();
803            let level_prefetch_size = match LevelPrefetchSize::parse(stream) {
804                Ok(val) => Some(val),
805                Err(_) => {
806                    stream.set_position(saved_pos);
807                    None
808                }
809            };
810            stream.expect_complete()?;
811            let saved_pos = stream.position();
812            let vec = match Vec::parse(stream) {
813                Ok(val) => Some(val),
814                Err(_) => {
815                    stream.set_position(saved_pos);
816                    None
817                }
818            };
819            stream.expect_complete()?;
820            let type_ = Type::parse(stream)?;
821            stream.expect_complete()?;
822            let d = GeneralOperand::parse(stream)?;
823            stream.expect_complete()?;
824            stream.expect(&PtxToken::Comma)?;
825            let a = AddressOperand::parse(stream)?;
826            stream.expect_complete()?;
827            stream.expect_complete()?;
828            stream.expect(&PtxToken::Semicolon)?;
829            Ok(LdVolatileSsLevelPrefetchSizeVecType {
830                volatile,
831                ss,
832                level_prefetch_size,
833                vec,
834                type_,
835                d,
836                a,
837            })
838        }
839    }
840
841
842    impl PtxParser for LdRelaxedScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintLevelPrefetchSizeVecType {
843        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
844            stream.expect_string("ld")?;
845            stream.expect_string(".relaxed")?;
846            let relaxed = ();
847            stream.expect_complete()?;
848            let scope = Scope::parse(stream)?;
849            stream.expect_complete()?;
850            let saved_pos = stream.position();
851            let ss = match Ss::parse(stream) {
852                Ok(val) => Some(val),
853                Err(_) => {
854                    stream.set_position(saved_pos);
855                    None
856                }
857            };
858            stream.expect_complete()?;
859            let saved_pos = stream.position();
860            let level1_eviction_priority = match Level1EvictionPriority::parse(stream) {
861                Ok(val) => Some(val),
862                Err(_) => {
863                    stream.set_position(saved_pos);
864                    None
865                }
866            };
867            stream.expect_complete()?;
868            let saved_pos = stream.position();
869            let level2_eviction_priority = match Level2EvictionPriority::parse(stream) {
870                Ok(val) => Some(val),
871                Err(_) => {
872                    stream.set_position(saved_pos);
873                    None
874                }
875            };
876            stream.expect_complete()?;
877            let saved_pos = stream.position();
878            let level_cache_hint = match LevelCacheHint::parse(stream) {
879                Ok(val) => Some(val),
880                Err(_) => {
881                    stream.set_position(saved_pos);
882                    None
883                }
884            };
885            stream.expect_complete()?;
886            let saved_pos = stream.position();
887            let level_prefetch_size = match LevelPrefetchSize::parse(stream) {
888                Ok(val) => Some(val),
889                Err(_) => {
890                    stream.set_position(saved_pos);
891                    None
892                }
893            };
894            stream.expect_complete()?;
895            let saved_pos = stream.position();
896            let vec = match Vec::parse(stream) {
897                Ok(val) => Some(val),
898                Err(_) => {
899                    stream.set_position(saved_pos);
900                    None
901                }
902            };
903            stream.expect_complete()?;
904            let type_ = Type::parse(stream)?;
905            stream.expect_complete()?;
906            let d = GeneralOperand::parse(stream)?;
907            stream.expect_complete()?;
908            stream.expect(&PtxToken::Comma)?;
909            let a = AddressOperand::parse(stream)?;
910            stream.expect_complete()?;
911            let saved_pos = stream.position();
912            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
913            if !has_comma {
914                stream.set_position(saved_pos);
915            }
916            let saved_pos = stream.position();
917            let cache_policy = match GeneralOperand::parse(stream) {
918                Ok(val) => Some(val),
919                Err(_) => {
920                    stream.set_position(saved_pos);
921                    None
922                }
923            };
924            stream.expect_complete()?;
925            stream.expect_complete()?;
926            stream.expect(&PtxToken::Semicolon)?;
927            Ok(LdRelaxedScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintLevelPrefetchSizeVecType {
928                relaxed,
929                scope,
930                ss,
931                level1_eviction_priority,
932                level2_eviction_priority,
933                level_cache_hint,
934                level_prefetch_size,
935                vec,
936                type_,
937                d,
938                a,
939                cache_policy,
940            })
941        }
942    }
943
944
945    impl PtxParser for LdAcquireScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintLevelPrefetchSizeVecType {
946        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
947            stream.expect_string("ld")?;
948            stream.expect_string(".acquire")?;
949            let acquire = ();
950            stream.expect_complete()?;
951            let scope = Scope::parse(stream)?;
952            stream.expect_complete()?;
953            let saved_pos = stream.position();
954            let ss = match Ss::parse(stream) {
955                Ok(val) => Some(val),
956                Err(_) => {
957                    stream.set_position(saved_pos);
958                    None
959                }
960            };
961            stream.expect_complete()?;
962            let saved_pos = stream.position();
963            let level1_eviction_priority = match Level1EvictionPriority::parse(stream) {
964                Ok(val) => Some(val),
965                Err(_) => {
966                    stream.set_position(saved_pos);
967                    None
968                }
969            };
970            stream.expect_complete()?;
971            let saved_pos = stream.position();
972            let level2_eviction_priority = match Level2EvictionPriority::parse(stream) {
973                Ok(val) => Some(val),
974                Err(_) => {
975                    stream.set_position(saved_pos);
976                    None
977                }
978            };
979            stream.expect_complete()?;
980            let saved_pos = stream.position();
981            let level_cache_hint = match LevelCacheHint::parse(stream) {
982                Ok(val) => Some(val),
983                Err(_) => {
984                    stream.set_position(saved_pos);
985                    None
986                }
987            };
988            stream.expect_complete()?;
989            let saved_pos = stream.position();
990            let level_prefetch_size = match LevelPrefetchSize::parse(stream) {
991                Ok(val) => Some(val),
992                Err(_) => {
993                    stream.set_position(saved_pos);
994                    None
995                }
996            };
997            stream.expect_complete()?;
998            let saved_pos = stream.position();
999            let vec = match Vec::parse(stream) {
1000                Ok(val) => Some(val),
1001                Err(_) => {
1002                    stream.set_position(saved_pos);
1003                    None
1004                }
1005            };
1006            stream.expect_complete()?;
1007            let type_ = Type::parse(stream)?;
1008            stream.expect_complete()?;
1009            let d = GeneralOperand::parse(stream)?;
1010            stream.expect_complete()?;
1011            stream.expect(&PtxToken::Comma)?;
1012            let a = AddressOperand::parse(stream)?;
1013            stream.expect_complete()?;
1014            let saved_pos = stream.position();
1015            let has_comma = stream.expect(&PtxToken::Comma).is_ok();
1016            if !has_comma {
1017                stream.set_position(saved_pos);
1018            }
1019            let saved_pos = stream.position();
1020            let cache_policy = match GeneralOperand::parse(stream) {
1021                Ok(val) => Some(val),
1022                Err(_) => {
1023                    stream.set_position(saved_pos);
1024                    None
1025                }
1026            };
1027            stream.expect_complete()?;
1028            stream.expect_complete()?;
1029            stream.expect(&PtxToken::Semicolon)?;
1030            Ok(LdAcquireScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintLevelPrefetchSizeVecType {
1031                acquire,
1032                scope,
1033                ss,
1034                level1_eviction_priority,
1035                level2_eviction_priority,
1036                level_cache_hint,
1037                level_prefetch_size,
1038                vec,
1039                type_,
1040                d,
1041                a,
1042                cache_policy,
1043            })
1044        }
1045    }
1046
1047
1048    impl PtxParser for LdMmioRelaxedSysGlobalType {
1049        fn parse(stream: &mut PtxTokenStream) -> Result<Self, PtxParseError> {
1050            stream.expect_string("ld")?;
1051            stream.expect_string(".mmio")?;
1052            let mmio = ();
1053            stream.expect_complete()?;
1054            stream.expect_string(".relaxed")?;
1055            let relaxed = ();
1056            stream.expect_complete()?;
1057            stream.expect_string(".sys")?;
1058            let sys = ();
1059            stream.expect_complete()?;
1060            let saved_pos = stream.position();
1061            let global = stream.expect_string(".global").is_ok();
1062            if !global {
1063                stream.set_position(saved_pos);
1064            }
1065            stream.expect_complete()?;
1066            let type_ = Type::parse(stream)?;
1067            stream.expect_complete()?;
1068            let d = GeneralOperand::parse(stream)?;
1069            stream.expect_complete()?;
1070            stream.expect(&PtxToken::Comma)?;
1071            let a = AddressOperand::parse(stream)?;
1072            stream.expect_complete()?;
1073            stream.expect_complete()?;
1074            stream.expect(&PtxToken::Semicolon)?;
1075            Ok(LdMmioRelaxedSysGlobalType {
1076                mmio,
1077                relaxed,
1078                sys,
1079                global,
1080                type_,
1081                d,
1082                a,
1083            })
1084        }
1085    }
1086
1087
1088}
1089
ptx_parser/parser/instruction/ld.rs

ptx_parser/parser/instruction/
ld.rs
