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

ptx_parser/parser/instruction/
ld.rs
