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