ptx_parser/unparser/instruction/
st.rs

1//! Original PTX specification:
2//!
3//! st{.weak}{.ss}{.cop}{.level::cache_hint}{.vec}.type   [a], b{, cache-policy};
4//! st{.weak}{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.vec}.type [a], b{, cache-policy};
5//! st.volatile{.ss}{.vec}.type                           [a], b;
6//! st.relaxed.scope{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.vec}.type [a], b{, cache-policy};
7//! st.release.scope{.ss}{.level1::eviction_priority}{.level2::eviction_priority}{.level::cache_hint}{.vec}.type [a], b{, cache-policy};
8//! st.mmio.relaxed.sys{.global}.type         [a], b;
9//! .ss =                       { .global, .local, .param, .param::func, .shared, .shared::cta, .shared::cluster};
10//! .level1::eviction_priority = { .L1::evict_normal, .L1::evict_unchanged,
11//! .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//! .cop =                      { .wb, .cg, .cs, .wt };
15//! .sem =                      { .relaxed, .release };
16//! .scope =                    { .cta, .cluster, .gpu, .sys };
17//! .vec =                      { .v2, .v4, .v8 };
18//! .type =                     { .b8, .b16, .b32, .b64, .b128,
19//! .u8, .u16, .u32, .u64,
20//! .s8, .s16, .s32, .s64,
21//! .f32, .f64 };
22
23#![allow(unused)]
24
25use crate::lexer::PtxToken;
26use crate::unparser::{PtxUnparser, common::*};
27
28pub mod section_0 {
29    use super::*;
30    use crate::r#type::instruction::st::section_0::*;
31
32    impl PtxUnparser for StWeakSsCopLevelCacheHintVecType {
33        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
34            self.unparse_tokens_mode(tokens, false);
35        }
36        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
37            push_opcode(tokens, "st");
38            if self.weak {
39                push_directive(tokens, "weak");
40            }
41            if let Some(ss_0) = self.ss.as_ref() {
42                match ss_0 {
43                    Ss::SharedCluster => {
44                        push_directive(tokens, "shared::cluster");
45                    }
46                    Ss::ParamFunc => {
47                        push_directive(tokens, "param::func");
48                    }
49                    Ss::SharedCta => {
50                        push_directive(tokens, "shared::cta");
51                    }
52                    Ss::Global => {
53                        push_directive(tokens, "global");
54                    }
55                    Ss::Shared => {
56                        push_directive(tokens, "shared");
57                    }
58                    Ss::Local => {
59                        push_directive(tokens, "local");
60                    }
61                    Ss::Param => {
62                        push_directive(tokens, "param");
63                    }
64                }
65            }
66            if let Some(cop_1) = self.cop.as_ref() {
67                match cop_1 {
68                    Cop::Wb => {
69                        push_directive(tokens, "wb");
70                    }
71                    Cop::Cg => {
72                        push_directive(tokens, "cg");
73                    }
74                    Cop::Cs => {
75                        push_directive(tokens, "cs");
76                    }
77                    Cop::Wt => {
78                        push_directive(tokens, "wt");
79                    }
80                }
81            }
82            if let Some(level_cache_hint_2) = self.level_cache_hint.as_ref() {
83                match level_cache_hint_2 {
84                    LevelCacheHint::L2CacheHint => {
85                        push_directive(tokens, "L2::cache_hint");
86                    }
87                }
88            }
89            if let Some(vec_3) = self.vec.as_ref() {
90                match vec_3 {
91                    Vec::V2 => {
92                        push_directive(tokens, "v2");
93                    }
94                    Vec::V4 => {
95                        push_directive(tokens, "v4");
96                    }
97                    Vec::V8 => {
98                        push_directive(tokens, "v8");
99                    }
100                }
101            }
102            match &self.type_ {
103                Type::B128 => {
104                    push_directive(tokens, "b128");
105                }
106                Type::B16 => {
107                    push_directive(tokens, "b16");
108                }
109                Type::B32 => {
110                    push_directive(tokens, "b32");
111                }
112                Type::B64 => {
113                    push_directive(tokens, "b64");
114                }
115                Type::U16 => {
116                    push_directive(tokens, "u16");
117                }
118                Type::U32 => {
119                    push_directive(tokens, "u32");
120                }
121                Type::U64 => {
122                    push_directive(tokens, "u64");
123                }
124                Type::S16 => {
125                    push_directive(tokens, "s16");
126                }
127                Type::S32 => {
128                    push_directive(tokens, "s32");
129                }
130                Type::S64 => {
131                    push_directive(tokens, "s64");
132                }
133                Type::F32 => {
134                    push_directive(tokens, "f32");
135                }
136                Type::F64 => {
137                    push_directive(tokens, "f64");
138                }
139                Type::B8 => {
140                    push_directive(tokens, "b8");
141                }
142                Type::U8 => {
143                    push_directive(tokens, "u8");
144                }
145                Type::S8 => {
146                    push_directive(tokens, "s8");
147                }
148            }
149            if spaced {
150                tokens.push(PtxToken::Space);
151            }
152            self.a.unparse_tokens_mode(tokens, spaced);
153            tokens.push(PtxToken::Comma);
154            if spaced {
155                tokens.push(PtxToken::Space);
156            }
157            self.b.unparse_tokens_mode(tokens, spaced);
158            if self.cache_policy.is_some() {
159                tokens.push(PtxToken::Comma);
160            }
161            if let Some(opt_4) = self.cache_policy.as_ref() {
162                if spaced {
163                    tokens.push(PtxToken::Space);
164                }
165                opt_4.unparse_tokens_mode(tokens, spaced);
166            }
167            tokens.push(PtxToken::Semicolon);
168            if spaced {
169                tokens.push(PtxToken::Newline);
170            }
171        }
172    }
173
174    impl PtxUnparser for StWeakSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType {
175        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
176            self.unparse_tokens_mode(tokens, false);
177        }
178        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
179            push_opcode(tokens, "st");
180            if self.weak {
181                push_directive(tokens, "weak");
182            }
183            if let Some(ss_5) = self.ss.as_ref() {
184                match ss_5 {
185                    Ss::SharedCluster => {
186                        push_directive(tokens, "shared::cluster");
187                    }
188                    Ss::ParamFunc => {
189                        push_directive(tokens, "param::func");
190                    }
191                    Ss::SharedCta => {
192                        push_directive(tokens, "shared::cta");
193                    }
194                    Ss::Global => {
195                        push_directive(tokens, "global");
196                    }
197                    Ss::Shared => {
198                        push_directive(tokens, "shared");
199                    }
200                    Ss::Local => {
201                        push_directive(tokens, "local");
202                    }
203                    Ss::Param => {
204                        push_directive(tokens, "param");
205                    }
206                }
207            }
208            if let Some(level1_eviction_priority_6) = self.level1_eviction_priority.as_ref() {
209                match level1_eviction_priority_6 {
210                    Level1EvictionPriority::L1EvictUnchanged => {
211                        push_directive(tokens, "L1::evict_unchanged");
212                    }
213                    Level1EvictionPriority::L1EvictNormal => {
214                        push_directive(tokens, "L1::evict_normal");
215                    }
216                    Level1EvictionPriority::L1EvictFirst => {
217                        push_directive(tokens, "L1::evict_first");
218                    }
219                    Level1EvictionPriority::L1NoAllocate => {
220                        push_directive(tokens, "L1::no_allocate");
221                    }
222                    Level1EvictionPriority::L1EvictLast => {
223                        push_directive(tokens, "L1::evict_last");
224                    }
225                }
226            }
227            if let Some(level2_eviction_priority_7) = self.level2_eviction_priority.as_ref() {
228                match level2_eviction_priority_7 {
229                    Level2EvictionPriority::L2EvictNormal => {
230                        push_directive(tokens, "L2::evict_normal");
231                    }
232                    Level2EvictionPriority::L2EvictFirst => {
233                        push_directive(tokens, "L2::evict_first");
234                    }
235                    Level2EvictionPriority::L2EvictLast => {
236                        push_directive(tokens, "L2::evict_last");
237                    }
238                }
239            }
240            if let Some(level_cache_hint_8) = self.level_cache_hint.as_ref() {
241                match level_cache_hint_8 {
242                    LevelCacheHint::L2CacheHint => {
243                        push_directive(tokens, "L2::cache_hint");
244                    }
245                }
246            }
247            if let Some(vec_9) = self.vec.as_ref() {
248                match vec_9 {
249                    Vec::V2 => {
250                        push_directive(tokens, "v2");
251                    }
252                    Vec::V4 => {
253                        push_directive(tokens, "v4");
254                    }
255                    Vec::V8 => {
256                        push_directive(tokens, "v8");
257                    }
258                }
259            }
260            match &self.type_ {
261                Type::B128 => {
262                    push_directive(tokens, "b128");
263                }
264                Type::B16 => {
265                    push_directive(tokens, "b16");
266                }
267                Type::B32 => {
268                    push_directive(tokens, "b32");
269                }
270                Type::B64 => {
271                    push_directive(tokens, "b64");
272                }
273                Type::U16 => {
274                    push_directive(tokens, "u16");
275                }
276                Type::U32 => {
277                    push_directive(tokens, "u32");
278                }
279                Type::U64 => {
280                    push_directive(tokens, "u64");
281                }
282                Type::S16 => {
283                    push_directive(tokens, "s16");
284                }
285                Type::S32 => {
286                    push_directive(tokens, "s32");
287                }
288                Type::S64 => {
289                    push_directive(tokens, "s64");
290                }
291                Type::F32 => {
292                    push_directive(tokens, "f32");
293                }
294                Type::F64 => {
295                    push_directive(tokens, "f64");
296                }
297                Type::B8 => {
298                    push_directive(tokens, "b8");
299                }
300                Type::U8 => {
301                    push_directive(tokens, "u8");
302                }
303                Type::S8 => {
304                    push_directive(tokens, "s8");
305                }
306            }
307            if spaced {
308                tokens.push(PtxToken::Space);
309            }
310            self.a.unparse_tokens_mode(tokens, spaced);
311            tokens.push(PtxToken::Comma);
312            if spaced {
313                tokens.push(PtxToken::Space);
314            }
315            self.b.unparse_tokens_mode(tokens, spaced);
316            if self.cache_policy.is_some() {
317                tokens.push(PtxToken::Comma);
318            }
319            if let Some(opt_10) = self.cache_policy.as_ref() {
320                if spaced {
321                    tokens.push(PtxToken::Space);
322                }
323                opt_10.unparse_tokens_mode(tokens, spaced);
324            }
325            tokens.push(PtxToken::Semicolon);
326            if spaced {
327                tokens.push(PtxToken::Newline);
328            }
329        }
330    }
331
332    impl PtxUnparser for StVolatileSsVecType {
333        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
334            self.unparse_tokens_mode(tokens, false);
335        }
336        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
337            push_opcode(tokens, "st");
338            push_directive(tokens, "volatile");
339            if let Some(ss_11) = self.ss.as_ref() {
340                match ss_11 {
341                    Ss::SharedCluster => {
342                        push_directive(tokens, "shared::cluster");
343                    }
344                    Ss::ParamFunc => {
345                        push_directive(tokens, "param::func");
346                    }
347                    Ss::SharedCta => {
348                        push_directive(tokens, "shared::cta");
349                    }
350                    Ss::Global => {
351                        push_directive(tokens, "global");
352                    }
353                    Ss::Shared => {
354                        push_directive(tokens, "shared");
355                    }
356                    Ss::Local => {
357                        push_directive(tokens, "local");
358                    }
359                    Ss::Param => {
360                        push_directive(tokens, "param");
361                    }
362                }
363            }
364            if let Some(vec_12) = self.vec.as_ref() {
365                match vec_12 {
366                    Vec::V2 => {
367                        push_directive(tokens, "v2");
368                    }
369                    Vec::V4 => {
370                        push_directive(tokens, "v4");
371                    }
372                    Vec::V8 => {
373                        push_directive(tokens, "v8");
374                    }
375                }
376            }
377            match &self.type_ {
378                Type::B128 => {
379                    push_directive(tokens, "b128");
380                }
381                Type::B16 => {
382                    push_directive(tokens, "b16");
383                }
384                Type::B32 => {
385                    push_directive(tokens, "b32");
386                }
387                Type::B64 => {
388                    push_directive(tokens, "b64");
389                }
390                Type::U16 => {
391                    push_directive(tokens, "u16");
392                }
393                Type::U32 => {
394                    push_directive(tokens, "u32");
395                }
396                Type::U64 => {
397                    push_directive(tokens, "u64");
398                }
399                Type::S16 => {
400                    push_directive(tokens, "s16");
401                }
402                Type::S32 => {
403                    push_directive(tokens, "s32");
404                }
405                Type::S64 => {
406                    push_directive(tokens, "s64");
407                }
408                Type::F32 => {
409                    push_directive(tokens, "f32");
410                }
411                Type::F64 => {
412                    push_directive(tokens, "f64");
413                }
414                Type::B8 => {
415                    push_directive(tokens, "b8");
416                }
417                Type::U8 => {
418                    push_directive(tokens, "u8");
419                }
420                Type::S8 => {
421                    push_directive(tokens, "s8");
422                }
423            }
424            if spaced {
425                tokens.push(PtxToken::Space);
426            }
427            self.a.unparse_tokens_mode(tokens, spaced);
428            tokens.push(PtxToken::Comma);
429            if spaced {
430                tokens.push(PtxToken::Space);
431            }
432            self.b.unparse_tokens_mode(tokens, spaced);
433            tokens.push(PtxToken::Semicolon);
434            if spaced {
435                tokens.push(PtxToken::Newline);
436            }
437        }
438    }
439
440    impl PtxUnparser
441        for StRelaxedScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType
442    {
443        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
444            self.unparse_tokens_mode(tokens, false);
445        }
446        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
447            push_opcode(tokens, "st");
448            push_directive(tokens, "relaxed");
449            match &self.scope {
450                Scope::Cluster => {
451                    push_directive(tokens, "cluster");
452                }
453                Scope::Cta => {
454                    push_directive(tokens, "cta");
455                }
456                Scope::Gpu => {
457                    push_directive(tokens, "gpu");
458                }
459                Scope::Sys => {
460                    push_directive(tokens, "sys");
461                }
462            }
463            if let Some(ss_13) = self.ss.as_ref() {
464                match ss_13 {
465                    Ss::SharedCluster => {
466                        push_directive(tokens, "shared::cluster");
467                    }
468                    Ss::ParamFunc => {
469                        push_directive(tokens, "param::func");
470                    }
471                    Ss::SharedCta => {
472                        push_directive(tokens, "shared::cta");
473                    }
474                    Ss::Global => {
475                        push_directive(tokens, "global");
476                    }
477                    Ss::Shared => {
478                        push_directive(tokens, "shared");
479                    }
480                    Ss::Local => {
481                        push_directive(tokens, "local");
482                    }
483                    Ss::Param => {
484                        push_directive(tokens, "param");
485                    }
486                }
487            }
488            if let Some(level1_eviction_priority_14) = self.level1_eviction_priority.as_ref() {
489                match level1_eviction_priority_14 {
490                    Level1EvictionPriority::L1EvictUnchanged => {
491                        push_directive(tokens, "L1::evict_unchanged");
492                    }
493                    Level1EvictionPriority::L1EvictNormal => {
494                        push_directive(tokens, "L1::evict_normal");
495                    }
496                    Level1EvictionPriority::L1EvictFirst => {
497                        push_directive(tokens, "L1::evict_first");
498                    }
499                    Level1EvictionPriority::L1NoAllocate => {
500                        push_directive(tokens, "L1::no_allocate");
501                    }
502                    Level1EvictionPriority::L1EvictLast => {
503                        push_directive(tokens, "L1::evict_last");
504                    }
505                }
506            }
507            if let Some(level2_eviction_priority_15) = self.level2_eviction_priority.as_ref() {
508                match level2_eviction_priority_15 {
509                    Level2EvictionPriority::L2EvictNormal => {
510                        push_directive(tokens, "L2::evict_normal");
511                    }
512                    Level2EvictionPriority::L2EvictFirst => {
513                        push_directive(tokens, "L2::evict_first");
514                    }
515                    Level2EvictionPriority::L2EvictLast => {
516                        push_directive(tokens, "L2::evict_last");
517                    }
518                }
519            }
520            if let Some(level_cache_hint_16) = self.level_cache_hint.as_ref() {
521                match level_cache_hint_16 {
522                    LevelCacheHint::L2CacheHint => {
523                        push_directive(tokens, "L2::cache_hint");
524                    }
525                }
526            }
527            if let Some(vec_17) = self.vec.as_ref() {
528                match vec_17 {
529                    Vec::V2 => {
530                        push_directive(tokens, "v2");
531                    }
532                    Vec::V4 => {
533                        push_directive(tokens, "v4");
534                    }
535                    Vec::V8 => {
536                        push_directive(tokens, "v8");
537                    }
538                }
539            }
540            match &self.type_ {
541                Type::B128 => {
542                    push_directive(tokens, "b128");
543                }
544                Type::B16 => {
545                    push_directive(tokens, "b16");
546                }
547                Type::B32 => {
548                    push_directive(tokens, "b32");
549                }
550                Type::B64 => {
551                    push_directive(tokens, "b64");
552                }
553                Type::U16 => {
554                    push_directive(tokens, "u16");
555                }
556                Type::U32 => {
557                    push_directive(tokens, "u32");
558                }
559                Type::U64 => {
560                    push_directive(tokens, "u64");
561                }
562                Type::S16 => {
563                    push_directive(tokens, "s16");
564                }
565                Type::S32 => {
566                    push_directive(tokens, "s32");
567                }
568                Type::S64 => {
569                    push_directive(tokens, "s64");
570                }
571                Type::F32 => {
572                    push_directive(tokens, "f32");
573                }
574                Type::F64 => {
575                    push_directive(tokens, "f64");
576                }
577                Type::B8 => {
578                    push_directive(tokens, "b8");
579                }
580                Type::U8 => {
581                    push_directive(tokens, "u8");
582                }
583                Type::S8 => {
584                    push_directive(tokens, "s8");
585                }
586            }
587            if spaced {
588                tokens.push(PtxToken::Space);
589            }
590            self.a.unparse_tokens_mode(tokens, spaced);
591            tokens.push(PtxToken::Comma);
592            if spaced {
593                tokens.push(PtxToken::Space);
594            }
595            self.b.unparse_tokens_mode(tokens, spaced);
596            if self.cache_policy.is_some() {
597                tokens.push(PtxToken::Comma);
598            }
599            if let Some(opt_18) = self.cache_policy.as_ref() {
600                if spaced {
601                    tokens.push(PtxToken::Space);
602                }
603                opt_18.unparse_tokens_mode(tokens, spaced);
604            }
605            tokens.push(PtxToken::Semicolon);
606            if spaced {
607                tokens.push(PtxToken::Newline);
608            }
609        }
610    }
611
612    impl PtxUnparser
613        for StReleaseScopeSsLevel1EvictionPriorityLevel2EvictionPriorityLevelCacheHintVecType
614    {
615        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
616            self.unparse_tokens_mode(tokens, false);
617        }
618        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
619            push_opcode(tokens, "st");
620            push_directive(tokens, "release");
621            match &self.scope {
622                Scope::Cluster => {
623                    push_directive(tokens, "cluster");
624                }
625                Scope::Cta => {
626                    push_directive(tokens, "cta");
627                }
628                Scope::Gpu => {
629                    push_directive(tokens, "gpu");
630                }
631                Scope::Sys => {
632                    push_directive(tokens, "sys");
633                }
634            }
635            if let Some(ss_19) = self.ss.as_ref() {
636                match ss_19 {
637                    Ss::SharedCluster => {
638                        push_directive(tokens, "shared::cluster");
639                    }
640                    Ss::ParamFunc => {
641                        push_directive(tokens, "param::func");
642                    }
643                    Ss::SharedCta => {
644                        push_directive(tokens, "shared::cta");
645                    }
646                    Ss::Global => {
647                        push_directive(tokens, "global");
648                    }
649                    Ss::Shared => {
650                        push_directive(tokens, "shared");
651                    }
652                    Ss::Local => {
653                        push_directive(tokens, "local");
654                    }
655                    Ss::Param => {
656                        push_directive(tokens, "param");
657                    }
658                }
659            }
660            if let Some(level1_eviction_priority_20) = self.level1_eviction_priority.as_ref() {
661                match level1_eviction_priority_20 {
662                    Level1EvictionPriority::L1EvictUnchanged => {
663                        push_directive(tokens, "L1::evict_unchanged");
664                    }
665                    Level1EvictionPriority::L1EvictNormal => {
666                        push_directive(tokens, "L1::evict_normal");
667                    }
668                    Level1EvictionPriority::L1EvictFirst => {
669                        push_directive(tokens, "L1::evict_first");
670                    }
671                    Level1EvictionPriority::L1NoAllocate => {
672                        push_directive(tokens, "L1::no_allocate");
673                    }
674                    Level1EvictionPriority::L1EvictLast => {
675                        push_directive(tokens, "L1::evict_last");
676                    }
677                }
678            }
679            if let Some(level2_eviction_priority_21) = self.level2_eviction_priority.as_ref() {
680                match level2_eviction_priority_21 {
681                    Level2EvictionPriority::L2EvictNormal => {
682                        push_directive(tokens, "L2::evict_normal");
683                    }
684                    Level2EvictionPriority::L2EvictFirst => {
685                        push_directive(tokens, "L2::evict_first");
686                    }
687                    Level2EvictionPriority::L2EvictLast => {
688                        push_directive(tokens, "L2::evict_last");
689                    }
690                }
691            }
692            if let Some(level_cache_hint_22) = self.level_cache_hint.as_ref() {
693                match level_cache_hint_22 {
694                    LevelCacheHint::L2CacheHint => {
695                        push_directive(tokens, "L2::cache_hint");
696                    }
697                }
698            }
699            if let Some(vec_23) = self.vec.as_ref() {
700                match vec_23 {
701                    Vec::V2 => {
702                        push_directive(tokens, "v2");
703                    }
704                    Vec::V4 => {
705                        push_directive(tokens, "v4");
706                    }
707                    Vec::V8 => {
708                        push_directive(tokens, "v8");
709                    }
710                }
711            }
712            match &self.type_ {
713                Type::B128 => {
714                    push_directive(tokens, "b128");
715                }
716                Type::B16 => {
717                    push_directive(tokens, "b16");
718                }
719                Type::B32 => {
720                    push_directive(tokens, "b32");
721                }
722                Type::B64 => {
723                    push_directive(tokens, "b64");
724                }
725                Type::U16 => {
726                    push_directive(tokens, "u16");
727                }
728                Type::U32 => {
729                    push_directive(tokens, "u32");
730                }
731                Type::U64 => {
732                    push_directive(tokens, "u64");
733                }
734                Type::S16 => {
735                    push_directive(tokens, "s16");
736                }
737                Type::S32 => {
738                    push_directive(tokens, "s32");
739                }
740                Type::S64 => {
741                    push_directive(tokens, "s64");
742                }
743                Type::F32 => {
744                    push_directive(tokens, "f32");
745                }
746                Type::F64 => {
747                    push_directive(tokens, "f64");
748                }
749                Type::B8 => {
750                    push_directive(tokens, "b8");
751                }
752                Type::U8 => {
753                    push_directive(tokens, "u8");
754                }
755                Type::S8 => {
756                    push_directive(tokens, "s8");
757                }
758            }
759            if spaced {
760                tokens.push(PtxToken::Space);
761            }
762            self.a.unparse_tokens_mode(tokens, spaced);
763            tokens.push(PtxToken::Comma);
764            if spaced {
765                tokens.push(PtxToken::Space);
766            }
767            self.b.unparse_tokens_mode(tokens, spaced);
768            if self.cache_policy.is_some() {
769                tokens.push(PtxToken::Comma);
770            }
771            if let Some(opt_24) = self.cache_policy.as_ref() {
772                if spaced {
773                    tokens.push(PtxToken::Space);
774                }
775                opt_24.unparse_tokens_mode(tokens, spaced);
776            }
777            tokens.push(PtxToken::Semicolon);
778            if spaced {
779                tokens.push(PtxToken::Newline);
780            }
781        }
782    }
783
784    impl PtxUnparser for StMmioRelaxedSysGlobalType {
785        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
786            self.unparse_tokens_mode(tokens, false);
787        }
788        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
789            push_opcode(tokens, "st");
790            push_directive(tokens, "mmio");
791            push_directive(tokens, "relaxed");
792            push_directive(tokens, "sys");
793            if self.global {
794                push_directive(tokens, "global");
795            }
796            match &self.type_ {
797                Type::B128 => {
798                    push_directive(tokens, "b128");
799                }
800                Type::B16 => {
801                    push_directive(tokens, "b16");
802                }
803                Type::B32 => {
804                    push_directive(tokens, "b32");
805                }
806                Type::B64 => {
807                    push_directive(tokens, "b64");
808                }
809                Type::U16 => {
810                    push_directive(tokens, "u16");
811                }
812                Type::U32 => {
813                    push_directive(tokens, "u32");
814                }
815                Type::U64 => {
816                    push_directive(tokens, "u64");
817                }
818                Type::S16 => {
819                    push_directive(tokens, "s16");
820                }
821                Type::S32 => {
822                    push_directive(tokens, "s32");
823                }
824                Type::S64 => {
825                    push_directive(tokens, "s64");
826                }
827                Type::F32 => {
828                    push_directive(tokens, "f32");
829                }
830                Type::F64 => {
831                    push_directive(tokens, "f64");
832                }
833                Type::B8 => {
834                    push_directive(tokens, "b8");
835                }
836                Type::U8 => {
837                    push_directive(tokens, "u8");
838                }
839                Type::S8 => {
840                    push_directive(tokens, "s8");
841                }
842            }
843            if spaced {
844                tokens.push(PtxToken::Space);
845            }
846            self.a.unparse_tokens_mode(tokens, spaced);
847            tokens.push(PtxToken::Comma);
848            if spaced {
849                tokens.push(PtxToken::Space);
850            }
851            self.b.unparse_tokens_mode(tokens, spaced);
852            tokens.push(PtxToken::Semicolon);
853            if spaced {
854                tokens.push(PtxToken::Newline);
855            }
856        }
857    }
858}
ptx_parser/unparser/instruction/st.rs

ptx_parser/unparser/instruction/
st.rs
