ptx_parser/unparser/instruction/
setp.rs

1//! Original PTX specification:
2//!
3//! setp.CmpOp{.ftz}.type         p{|q}, a, b;
4//! setp.CmpOp.BoolOp{.ftz}.type  p{|q}, a, b, {!}c;
5//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .lo, .ls, .hi, .hs, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
6//! .BoolOp = { .and, .or, .xor };
7//! .type   = { .b16, .b32, .b64, .u16, .u32, .u64, .s16, .s32, .s64, .f32, .f64 };
8//! --------------------------------------------------------------
9//! setp.CmpOp{.ftz}.f16           p, a, b;
10//! setp.CmpOp.BoolOp{.ftz}.f16    p, a, b, {!}c;
11//! setp.CmpOp{.ftz}.f16x2         p|q, a, b;
12//! setp.CmpOp.BoolOp{.ftz}.f16x2  p|q, a, b, {!}c;
13//! setp.CmpOp.bf16                p, a, b;
14//! setp.CmpOp.BoolOp.bf16         p, a, b, {!}c;
15//! setp.CmpOp.bf16x2              p|q, a, b;
16//! setp.CmpOp.BoolOp.bf16x2       p|q, a, b, {!}c;
17//! .CmpOp  = { .eq, .ne, .lt, .le, .gt, .ge, .equ, .neu, .ltu, .leu, .gtu, .geu, .num, .nan };
18//! .BoolOp = { .and, .or, .xor };
19
20#![allow(unused)]
21
22use crate::lexer::PtxToken;
23use crate::unparser::{PtxUnparser, common::*};
24
25pub mod section_0 {
26    use super::*;
27    use crate::r#type::instruction::setp::section_0::*;
28
29    impl PtxUnparser for SetpCmpopFtzType {
30        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
31            self.unparse_tokens_mode(tokens, false);
32        }
33        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
34            push_opcode(tokens, "setp");
35            match &self.cmpop {
36                Cmpop::Equ => {
37                    push_directive(tokens, "equ");
38                }
39                Cmpop::Neu => {
40                    push_directive(tokens, "neu");
41                }
42                Cmpop::Ltu => {
43                    push_directive(tokens, "ltu");
44                }
45                Cmpop::Leu => {
46                    push_directive(tokens, "leu");
47                }
48                Cmpop::Gtu => {
49                    push_directive(tokens, "gtu");
50                }
51                Cmpop::Geu => {
52                    push_directive(tokens, "geu");
53                }
54                Cmpop::Num => {
55                    push_directive(tokens, "num");
56                }
57                Cmpop::Nan => {
58                    push_directive(tokens, "nan");
59                }
60                Cmpop::Eq => {
61                    push_directive(tokens, "eq");
62                }
63                Cmpop::Ne => {
64                    push_directive(tokens, "ne");
65                }
66                Cmpop::Lt => {
67                    push_directive(tokens, "lt");
68                }
69                Cmpop::Le => {
70                    push_directive(tokens, "le");
71                }
72                Cmpop::Gt => {
73                    push_directive(tokens, "gt");
74                }
75                Cmpop::Ge => {
76                    push_directive(tokens, "ge");
77                }
78                Cmpop::Lo => {
79                    push_directive(tokens, "lo");
80                }
81                Cmpop::Ls => {
82                    push_directive(tokens, "ls");
83                }
84                Cmpop::Hi => {
85                    push_directive(tokens, "hi");
86                }
87                Cmpop::Hs => {
88                    push_directive(tokens, "hs");
89                }
90            }
91            if self.ftz {
92                push_directive(tokens, "ftz");
93            }
94            match &self.type_ {
95                Type::B16 => {
96                    push_directive(tokens, "b16");
97                }
98                Type::B32 => {
99                    push_directive(tokens, "b32");
100                }
101                Type::B64 => {
102                    push_directive(tokens, "b64");
103                }
104                Type::U16 => {
105                    push_directive(tokens, "u16");
106                }
107                Type::U32 => {
108                    push_directive(tokens, "u32");
109                }
110                Type::U64 => {
111                    push_directive(tokens, "u64");
112                }
113                Type::S16 => {
114                    push_directive(tokens, "s16");
115                }
116                Type::S32 => {
117                    push_directive(tokens, "s32");
118                }
119                Type::S64 => {
120                    push_directive(tokens, "s64");
121                }
122                Type::F32 => {
123                    push_directive(tokens, "f32");
124                }
125                Type::F64 => {
126                    push_directive(tokens, "f64");
127                }
128            }
129            if spaced {
130                tokens.push(PtxToken::Space);
131            }
132            self.p.unparse_tokens_mode(tokens, spaced);
133            if let Some(q_0) = self.q.as_ref() {
134                tokens.push(PtxToken::Pipe);
135                q_0.unparse_tokens_mode(tokens, spaced);
136            }
137            tokens.push(PtxToken::Comma);
138            if spaced {
139                tokens.push(PtxToken::Space);
140            }
141            self.a.unparse_tokens_mode(tokens, spaced);
142            tokens.push(PtxToken::Comma);
143            if spaced {
144                tokens.push(PtxToken::Space);
145            }
146            self.b.unparse_tokens_mode(tokens, spaced);
147            tokens.push(PtxToken::Semicolon);
148            if spaced {
149                tokens.push(PtxToken::Newline);
150            }
151        }
152    }
153
154    impl PtxUnparser for SetpCmpopBoolopFtzType {
155        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
156            self.unparse_tokens_mode(tokens, false);
157        }
158        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
159            push_opcode(tokens, "setp");
160            match &self.cmpop {
161                Cmpop::Equ => {
162                    push_directive(tokens, "equ");
163                }
164                Cmpop::Neu => {
165                    push_directive(tokens, "neu");
166                }
167                Cmpop::Ltu => {
168                    push_directive(tokens, "ltu");
169                }
170                Cmpop::Leu => {
171                    push_directive(tokens, "leu");
172                }
173                Cmpop::Gtu => {
174                    push_directive(tokens, "gtu");
175                }
176                Cmpop::Geu => {
177                    push_directive(tokens, "geu");
178                }
179                Cmpop::Num => {
180                    push_directive(tokens, "num");
181                }
182                Cmpop::Nan => {
183                    push_directive(tokens, "nan");
184                }
185                Cmpop::Eq => {
186                    push_directive(tokens, "eq");
187                }
188                Cmpop::Ne => {
189                    push_directive(tokens, "ne");
190                }
191                Cmpop::Lt => {
192                    push_directive(tokens, "lt");
193                }
194                Cmpop::Le => {
195                    push_directive(tokens, "le");
196                }
197                Cmpop::Gt => {
198                    push_directive(tokens, "gt");
199                }
200                Cmpop::Ge => {
201                    push_directive(tokens, "ge");
202                }
203                Cmpop::Lo => {
204                    push_directive(tokens, "lo");
205                }
206                Cmpop::Ls => {
207                    push_directive(tokens, "ls");
208                }
209                Cmpop::Hi => {
210                    push_directive(tokens, "hi");
211                }
212                Cmpop::Hs => {
213                    push_directive(tokens, "hs");
214                }
215            }
216            match &self.boolop {
217                Boolop::And => {
218                    push_directive(tokens, "and");
219                }
220                Boolop::Xor => {
221                    push_directive(tokens, "xor");
222                }
223                Boolop::Or => {
224                    push_directive(tokens, "or");
225                }
226            }
227            if self.ftz {
228                push_directive(tokens, "ftz");
229            }
230            match &self.type_ {
231                Type::B16 => {
232                    push_directive(tokens, "b16");
233                }
234                Type::B32 => {
235                    push_directive(tokens, "b32");
236                }
237                Type::B64 => {
238                    push_directive(tokens, "b64");
239                }
240                Type::U16 => {
241                    push_directive(tokens, "u16");
242                }
243                Type::U32 => {
244                    push_directive(tokens, "u32");
245                }
246                Type::U64 => {
247                    push_directive(tokens, "u64");
248                }
249                Type::S16 => {
250                    push_directive(tokens, "s16");
251                }
252                Type::S32 => {
253                    push_directive(tokens, "s32");
254                }
255                Type::S64 => {
256                    push_directive(tokens, "s64");
257                }
258                Type::F32 => {
259                    push_directive(tokens, "f32");
260                }
261                Type::F64 => {
262                    push_directive(tokens, "f64");
263                }
264            }
265            if spaced {
266                tokens.push(PtxToken::Space);
267            }
268            self.p.unparse_tokens_mode(tokens, spaced);
269            if let Some(q_1) = self.q.as_ref() {
270                tokens.push(PtxToken::Pipe);
271                q_1.unparse_tokens_mode(tokens, spaced);
272            }
273            tokens.push(PtxToken::Comma);
274            if spaced {
275                tokens.push(PtxToken::Space);
276            }
277            self.a.unparse_tokens_mode(tokens, spaced);
278            tokens.push(PtxToken::Comma);
279            if spaced {
280                tokens.push(PtxToken::Space);
281            }
282            self.b.unparse_tokens_mode(tokens, spaced);
283            tokens.push(PtxToken::Comma);
284            if self.c_op {
285                tokens.push(PtxToken::Exclaim);
286            }
287            if spaced {
288                tokens.push(PtxToken::Space);
289            }
290            self.c.unparse_tokens_mode(tokens, spaced);
291            tokens.push(PtxToken::Semicolon);
292            if spaced {
293                tokens.push(PtxToken::Newline);
294            }
295        }
296    }
297}
298
299pub mod section_1 {
300    use super::*;
301    use crate::r#type::instruction::setp::section_1::*;
302
303    impl PtxUnparser for SetpCmpopFtzF16 {
304        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
305            self.unparse_tokens_mode(tokens, false);
306        }
307        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
308            push_opcode(tokens, "setp");
309            match &self.cmpop {
310                Cmpop::Equ => {
311                    push_directive(tokens, "equ");
312                }
313                Cmpop::Neu => {
314                    push_directive(tokens, "neu");
315                }
316                Cmpop::Ltu => {
317                    push_directive(tokens, "ltu");
318                }
319                Cmpop::Leu => {
320                    push_directive(tokens, "leu");
321                }
322                Cmpop::Gtu => {
323                    push_directive(tokens, "gtu");
324                }
325                Cmpop::Geu => {
326                    push_directive(tokens, "geu");
327                }
328                Cmpop::Num => {
329                    push_directive(tokens, "num");
330                }
331                Cmpop::Nan => {
332                    push_directive(tokens, "nan");
333                }
334                Cmpop::Eq => {
335                    push_directive(tokens, "eq");
336                }
337                Cmpop::Ne => {
338                    push_directive(tokens, "ne");
339                }
340                Cmpop::Lt => {
341                    push_directive(tokens, "lt");
342                }
343                Cmpop::Le => {
344                    push_directive(tokens, "le");
345                }
346                Cmpop::Gt => {
347                    push_directive(tokens, "gt");
348                }
349                Cmpop::Ge => {
350                    push_directive(tokens, "ge");
351                }
352            }
353            if self.ftz {
354                push_directive(tokens, "ftz");
355            }
356            push_directive(tokens, "f16");
357            if spaced {
358                tokens.push(PtxToken::Space);
359            }
360            self.p.unparse_tokens_mode(tokens, spaced);
361            tokens.push(PtxToken::Comma);
362            if spaced {
363                tokens.push(PtxToken::Space);
364            }
365            self.a.unparse_tokens_mode(tokens, spaced);
366            tokens.push(PtxToken::Comma);
367            if spaced {
368                tokens.push(PtxToken::Space);
369            }
370            self.b.unparse_tokens_mode(tokens, spaced);
371            tokens.push(PtxToken::Semicolon);
372            if spaced {
373                tokens.push(PtxToken::Newline);
374            }
375        }
376    }
377
378    impl PtxUnparser for SetpCmpopBoolopFtzF16 {
379        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
380            self.unparse_tokens_mode(tokens, false);
381        }
382        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
383            push_opcode(tokens, "setp");
384            match &self.cmpop {
385                Cmpop::Equ => {
386                    push_directive(tokens, "equ");
387                }
388                Cmpop::Neu => {
389                    push_directive(tokens, "neu");
390                }
391                Cmpop::Ltu => {
392                    push_directive(tokens, "ltu");
393                }
394                Cmpop::Leu => {
395                    push_directive(tokens, "leu");
396                }
397                Cmpop::Gtu => {
398                    push_directive(tokens, "gtu");
399                }
400                Cmpop::Geu => {
401                    push_directive(tokens, "geu");
402                }
403                Cmpop::Num => {
404                    push_directive(tokens, "num");
405                }
406                Cmpop::Nan => {
407                    push_directive(tokens, "nan");
408                }
409                Cmpop::Eq => {
410                    push_directive(tokens, "eq");
411                }
412                Cmpop::Ne => {
413                    push_directive(tokens, "ne");
414                }
415                Cmpop::Lt => {
416                    push_directive(tokens, "lt");
417                }
418                Cmpop::Le => {
419                    push_directive(tokens, "le");
420                }
421                Cmpop::Gt => {
422                    push_directive(tokens, "gt");
423                }
424                Cmpop::Ge => {
425                    push_directive(tokens, "ge");
426                }
427            }
428            match &self.boolop {
429                Boolop::And => {
430                    push_directive(tokens, "and");
431                }
432                Boolop::Xor => {
433                    push_directive(tokens, "xor");
434                }
435                Boolop::Or => {
436                    push_directive(tokens, "or");
437                }
438            }
439            if self.ftz {
440                push_directive(tokens, "ftz");
441            }
442            push_directive(tokens, "f16");
443            if spaced {
444                tokens.push(PtxToken::Space);
445            }
446            self.p.unparse_tokens_mode(tokens, spaced);
447            tokens.push(PtxToken::Comma);
448            if spaced {
449                tokens.push(PtxToken::Space);
450            }
451            self.a.unparse_tokens_mode(tokens, spaced);
452            tokens.push(PtxToken::Comma);
453            if spaced {
454                tokens.push(PtxToken::Space);
455            }
456            self.b.unparse_tokens_mode(tokens, spaced);
457            tokens.push(PtxToken::Comma);
458            if self.c_op {
459                tokens.push(PtxToken::Exclaim);
460            }
461            if spaced {
462                tokens.push(PtxToken::Space);
463            }
464            self.c.unparse_tokens_mode(tokens, spaced);
465            tokens.push(PtxToken::Semicolon);
466            if spaced {
467                tokens.push(PtxToken::Newline);
468            }
469        }
470    }
471
472    impl PtxUnparser for SetpCmpopFtzF16x2 {
473        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
474            self.unparse_tokens_mode(tokens, false);
475        }
476        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
477            push_opcode(tokens, "setp");
478            match &self.cmpop {
479                Cmpop::Equ => {
480                    push_directive(tokens, "equ");
481                }
482                Cmpop::Neu => {
483                    push_directive(tokens, "neu");
484                }
485                Cmpop::Ltu => {
486                    push_directive(tokens, "ltu");
487                }
488                Cmpop::Leu => {
489                    push_directive(tokens, "leu");
490                }
491                Cmpop::Gtu => {
492                    push_directive(tokens, "gtu");
493                }
494                Cmpop::Geu => {
495                    push_directive(tokens, "geu");
496                }
497                Cmpop::Num => {
498                    push_directive(tokens, "num");
499                }
500                Cmpop::Nan => {
501                    push_directive(tokens, "nan");
502                }
503                Cmpop::Eq => {
504                    push_directive(tokens, "eq");
505                }
506                Cmpop::Ne => {
507                    push_directive(tokens, "ne");
508                }
509                Cmpop::Lt => {
510                    push_directive(tokens, "lt");
511                }
512                Cmpop::Le => {
513                    push_directive(tokens, "le");
514                }
515                Cmpop::Gt => {
516                    push_directive(tokens, "gt");
517                }
518                Cmpop::Ge => {
519                    push_directive(tokens, "ge");
520                }
521            }
522            if self.ftz {
523                push_directive(tokens, "ftz");
524            }
525            push_directive(tokens, "f16x2");
526            if spaced {
527                tokens.push(PtxToken::Space);
528            }
529            self.p.unparse_tokens_mode(tokens, spaced);
530            tokens.push(PtxToken::Pipe);
531            self.q.unparse_tokens_mode(tokens, spaced);
532            tokens.push(PtxToken::Comma);
533            if spaced {
534                tokens.push(PtxToken::Space);
535            }
536            self.a.unparse_tokens_mode(tokens, spaced);
537            tokens.push(PtxToken::Comma);
538            if spaced {
539                tokens.push(PtxToken::Space);
540            }
541            self.b.unparse_tokens_mode(tokens, spaced);
542            tokens.push(PtxToken::Semicolon);
543            if spaced {
544                tokens.push(PtxToken::Newline);
545            }
546        }
547    }
548
549    impl PtxUnparser for SetpCmpopBoolopFtzF16x2 {
550        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
551            self.unparse_tokens_mode(tokens, false);
552        }
553        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
554            push_opcode(tokens, "setp");
555            match &self.cmpop {
556                Cmpop::Equ => {
557                    push_directive(tokens, "equ");
558                }
559                Cmpop::Neu => {
560                    push_directive(tokens, "neu");
561                }
562                Cmpop::Ltu => {
563                    push_directive(tokens, "ltu");
564                }
565                Cmpop::Leu => {
566                    push_directive(tokens, "leu");
567                }
568                Cmpop::Gtu => {
569                    push_directive(tokens, "gtu");
570                }
571                Cmpop::Geu => {
572                    push_directive(tokens, "geu");
573                }
574                Cmpop::Num => {
575                    push_directive(tokens, "num");
576                }
577                Cmpop::Nan => {
578                    push_directive(tokens, "nan");
579                }
580                Cmpop::Eq => {
581                    push_directive(tokens, "eq");
582                }
583                Cmpop::Ne => {
584                    push_directive(tokens, "ne");
585                }
586                Cmpop::Lt => {
587                    push_directive(tokens, "lt");
588                }
589                Cmpop::Le => {
590                    push_directive(tokens, "le");
591                }
592                Cmpop::Gt => {
593                    push_directive(tokens, "gt");
594                }
595                Cmpop::Ge => {
596                    push_directive(tokens, "ge");
597                }
598            }
599            match &self.boolop {
600                Boolop::And => {
601                    push_directive(tokens, "and");
602                }
603                Boolop::Xor => {
604                    push_directive(tokens, "xor");
605                }
606                Boolop::Or => {
607                    push_directive(tokens, "or");
608                }
609            }
610            if self.ftz {
611                push_directive(tokens, "ftz");
612            }
613            push_directive(tokens, "f16x2");
614            if spaced {
615                tokens.push(PtxToken::Space);
616            }
617            self.p.unparse_tokens_mode(tokens, spaced);
618            tokens.push(PtxToken::Pipe);
619            self.q.unparse_tokens_mode(tokens, spaced);
620            tokens.push(PtxToken::Comma);
621            if spaced {
622                tokens.push(PtxToken::Space);
623            }
624            self.a.unparse_tokens_mode(tokens, spaced);
625            tokens.push(PtxToken::Comma);
626            if spaced {
627                tokens.push(PtxToken::Space);
628            }
629            self.b.unparse_tokens_mode(tokens, spaced);
630            tokens.push(PtxToken::Comma);
631            if self.c_op {
632                tokens.push(PtxToken::Exclaim);
633            }
634            if spaced {
635                tokens.push(PtxToken::Space);
636            }
637            self.c.unparse_tokens_mode(tokens, spaced);
638            tokens.push(PtxToken::Semicolon);
639            if spaced {
640                tokens.push(PtxToken::Newline);
641            }
642        }
643    }
644
645    impl PtxUnparser for SetpCmpopBf16 {
646        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
647            self.unparse_tokens_mode(tokens, false);
648        }
649        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
650            push_opcode(tokens, "setp");
651            match &self.cmpop {
652                Cmpop::Equ => {
653                    push_directive(tokens, "equ");
654                }
655                Cmpop::Neu => {
656                    push_directive(tokens, "neu");
657                }
658                Cmpop::Ltu => {
659                    push_directive(tokens, "ltu");
660                }
661                Cmpop::Leu => {
662                    push_directive(tokens, "leu");
663                }
664                Cmpop::Gtu => {
665                    push_directive(tokens, "gtu");
666                }
667                Cmpop::Geu => {
668                    push_directive(tokens, "geu");
669                }
670                Cmpop::Num => {
671                    push_directive(tokens, "num");
672                }
673                Cmpop::Nan => {
674                    push_directive(tokens, "nan");
675                }
676                Cmpop::Eq => {
677                    push_directive(tokens, "eq");
678                }
679                Cmpop::Ne => {
680                    push_directive(tokens, "ne");
681                }
682                Cmpop::Lt => {
683                    push_directive(tokens, "lt");
684                }
685                Cmpop::Le => {
686                    push_directive(tokens, "le");
687                }
688                Cmpop::Gt => {
689                    push_directive(tokens, "gt");
690                }
691                Cmpop::Ge => {
692                    push_directive(tokens, "ge");
693                }
694            }
695            push_directive(tokens, "bf16");
696            if spaced {
697                tokens.push(PtxToken::Space);
698            }
699            self.p.unparse_tokens_mode(tokens, spaced);
700            tokens.push(PtxToken::Comma);
701            if spaced {
702                tokens.push(PtxToken::Space);
703            }
704            self.a.unparse_tokens_mode(tokens, spaced);
705            tokens.push(PtxToken::Comma);
706            if spaced {
707                tokens.push(PtxToken::Space);
708            }
709            self.b.unparse_tokens_mode(tokens, spaced);
710            tokens.push(PtxToken::Semicolon);
711            if spaced {
712                tokens.push(PtxToken::Newline);
713            }
714        }
715    }
716
717    impl PtxUnparser for SetpCmpopBoolopBf16 {
718        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
719            self.unparse_tokens_mode(tokens, false);
720        }
721        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
722            push_opcode(tokens, "setp");
723            match &self.cmpop {
724                Cmpop::Equ => {
725                    push_directive(tokens, "equ");
726                }
727                Cmpop::Neu => {
728                    push_directive(tokens, "neu");
729                }
730                Cmpop::Ltu => {
731                    push_directive(tokens, "ltu");
732                }
733                Cmpop::Leu => {
734                    push_directive(tokens, "leu");
735                }
736                Cmpop::Gtu => {
737                    push_directive(tokens, "gtu");
738                }
739                Cmpop::Geu => {
740                    push_directive(tokens, "geu");
741                }
742                Cmpop::Num => {
743                    push_directive(tokens, "num");
744                }
745                Cmpop::Nan => {
746                    push_directive(tokens, "nan");
747                }
748                Cmpop::Eq => {
749                    push_directive(tokens, "eq");
750                }
751                Cmpop::Ne => {
752                    push_directive(tokens, "ne");
753                }
754                Cmpop::Lt => {
755                    push_directive(tokens, "lt");
756                }
757                Cmpop::Le => {
758                    push_directive(tokens, "le");
759                }
760                Cmpop::Gt => {
761                    push_directive(tokens, "gt");
762                }
763                Cmpop::Ge => {
764                    push_directive(tokens, "ge");
765                }
766            }
767            match &self.boolop {
768                Boolop::And => {
769                    push_directive(tokens, "and");
770                }
771                Boolop::Xor => {
772                    push_directive(tokens, "xor");
773                }
774                Boolop::Or => {
775                    push_directive(tokens, "or");
776                }
777            }
778            push_directive(tokens, "bf16");
779            if spaced {
780                tokens.push(PtxToken::Space);
781            }
782            self.p.unparse_tokens_mode(tokens, spaced);
783            tokens.push(PtxToken::Comma);
784            if spaced {
785                tokens.push(PtxToken::Space);
786            }
787            self.a.unparse_tokens_mode(tokens, spaced);
788            tokens.push(PtxToken::Comma);
789            if spaced {
790                tokens.push(PtxToken::Space);
791            }
792            self.b.unparse_tokens_mode(tokens, spaced);
793            tokens.push(PtxToken::Comma);
794            if self.c_op {
795                tokens.push(PtxToken::Exclaim);
796            }
797            if spaced {
798                tokens.push(PtxToken::Space);
799            }
800            self.c.unparse_tokens_mode(tokens, spaced);
801            tokens.push(PtxToken::Semicolon);
802            if spaced {
803                tokens.push(PtxToken::Newline);
804            }
805        }
806    }
807
808    impl PtxUnparser for SetpCmpopBf16x2 {
809        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
810            self.unparse_tokens_mode(tokens, false);
811        }
812        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
813            push_opcode(tokens, "setp");
814            match &self.cmpop {
815                Cmpop::Equ => {
816                    push_directive(tokens, "equ");
817                }
818                Cmpop::Neu => {
819                    push_directive(tokens, "neu");
820                }
821                Cmpop::Ltu => {
822                    push_directive(tokens, "ltu");
823                }
824                Cmpop::Leu => {
825                    push_directive(tokens, "leu");
826                }
827                Cmpop::Gtu => {
828                    push_directive(tokens, "gtu");
829                }
830                Cmpop::Geu => {
831                    push_directive(tokens, "geu");
832                }
833                Cmpop::Num => {
834                    push_directive(tokens, "num");
835                }
836                Cmpop::Nan => {
837                    push_directive(tokens, "nan");
838                }
839                Cmpop::Eq => {
840                    push_directive(tokens, "eq");
841                }
842                Cmpop::Ne => {
843                    push_directive(tokens, "ne");
844                }
845                Cmpop::Lt => {
846                    push_directive(tokens, "lt");
847                }
848                Cmpop::Le => {
849                    push_directive(tokens, "le");
850                }
851                Cmpop::Gt => {
852                    push_directive(tokens, "gt");
853                }
854                Cmpop::Ge => {
855                    push_directive(tokens, "ge");
856                }
857            }
858            push_directive(tokens, "bf16x2");
859            if spaced {
860                tokens.push(PtxToken::Space);
861            }
862            self.p.unparse_tokens_mode(tokens, spaced);
863            tokens.push(PtxToken::Pipe);
864            self.q.unparse_tokens_mode(tokens, spaced);
865            tokens.push(PtxToken::Comma);
866            if spaced {
867                tokens.push(PtxToken::Space);
868            }
869            self.a.unparse_tokens_mode(tokens, spaced);
870            tokens.push(PtxToken::Comma);
871            if spaced {
872                tokens.push(PtxToken::Space);
873            }
874            self.b.unparse_tokens_mode(tokens, spaced);
875            tokens.push(PtxToken::Semicolon);
876            if spaced {
877                tokens.push(PtxToken::Newline);
878            }
879        }
880    }
881
882    impl PtxUnparser for SetpCmpopBoolopBf16x2 {
883        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
884            self.unparse_tokens_mode(tokens, false);
885        }
886        fn unparse_tokens_mode(&self, tokens: &mut ::std::vec::Vec<PtxToken>, spaced: bool) {
887            push_opcode(tokens, "setp");
888            match &self.cmpop {
889                Cmpop::Equ => {
890                    push_directive(tokens, "equ");
891                }
892                Cmpop::Neu => {
893                    push_directive(tokens, "neu");
894                }
895                Cmpop::Ltu => {
896                    push_directive(tokens, "ltu");
897                }
898                Cmpop::Leu => {
899                    push_directive(tokens, "leu");
900                }
901                Cmpop::Gtu => {
902                    push_directive(tokens, "gtu");
903                }
904                Cmpop::Geu => {
905                    push_directive(tokens, "geu");
906                }
907                Cmpop::Num => {
908                    push_directive(tokens, "num");
909                }
910                Cmpop::Nan => {
911                    push_directive(tokens, "nan");
912                }
913                Cmpop::Eq => {
914                    push_directive(tokens, "eq");
915                }
916                Cmpop::Ne => {
917                    push_directive(tokens, "ne");
918                }
919                Cmpop::Lt => {
920                    push_directive(tokens, "lt");
921                }
922                Cmpop::Le => {
923                    push_directive(tokens, "le");
924                }
925                Cmpop::Gt => {
926                    push_directive(tokens, "gt");
927                }
928                Cmpop::Ge => {
929                    push_directive(tokens, "ge");
930                }
931            }
932            match &self.boolop {
933                Boolop::And => {
934                    push_directive(tokens, "and");
935                }
936                Boolop::Xor => {
937                    push_directive(tokens, "xor");
938                }
939                Boolop::Or => {
940                    push_directive(tokens, "or");
941                }
942            }
943            push_directive(tokens, "bf16x2");
944            if spaced {
945                tokens.push(PtxToken::Space);
946            }
947            self.p.unparse_tokens_mode(tokens, spaced);
948            tokens.push(PtxToken::Pipe);
949            self.q.unparse_tokens_mode(tokens, spaced);
950            tokens.push(PtxToken::Comma);
951            if spaced {
952                tokens.push(PtxToken::Space);
953            }
954            self.a.unparse_tokens_mode(tokens, spaced);
955            tokens.push(PtxToken::Comma);
956            if spaced {
957                tokens.push(PtxToken::Space);
958            }
959            self.b.unparse_tokens_mode(tokens, spaced);
960            tokens.push(PtxToken::Comma);
961            if self.c_op {
962                tokens.push(PtxToken::Exclaim);
963            }
964            if spaced {
965                tokens.push(PtxToken::Space);
966            }
967            self.c.unparse_tokens_mode(tokens, spaced);
968            tokens.push(PtxToken::Semicolon);
969            if spaced {
970                tokens.push(PtxToken::Newline);
971            }
972        }
973    }
974}
ptx_parser/unparser/instruction/setp.rs

ptx_parser/unparser/instruction/
setp.rs
