ptx_parser/unparser/instruction/
cvta.rs

1//! Original PTX specification:
2//!
3//! // convert const, global, local, or shared address to generic address
4//! cvta.space.size  p, a;        // source address in register a
5//! // cvta.space.size  p, var;      // get generic address of var
6//! // cvta.space.size  p, var+imm;  // generic address of var+offset
7//! // convert generic address to const, global, local, or shared address
8//! cvta.to.space.size  p, a;
9//! .space = { .const, .global, .local, .shared, .shared::cta, .shared::cluster, .param, .param::entry };
10//! .size  = { .u32, .u64 };
11
12#![allow(unused)]
13
14use crate::lexer::PtxToken;
15use crate::unparser::{PtxUnparser, common::*};
16
17pub mod section_0 {
18    use super::*;
19    use crate::r#type::instruction::cvta::section_0::*;
20
21    impl PtxUnparser for CvtaSpaceSize {
22        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
23            push_opcode(tokens, "cvta");
24            match &self.space {
25                Space::SharedCluster => {
26                    push_directive(tokens, "shared::cluster");
27                }
28                Space::ParamEntry => {
29                    push_directive(tokens, "param::entry");
30                }
31                Space::SharedCta => {
32                    push_directive(tokens, "shared::cta");
33                }
34                Space::Global => {
35                    push_directive(tokens, "global");
36                }
37                Space::Shared => {
38                    push_directive(tokens, "shared");
39                }
40                Space::Const => {
41                    push_directive(tokens, "const");
42                }
43                Space::Local => {
44                    push_directive(tokens, "local");
45                }
46                Space::Param => {
47                    push_directive(tokens, "param");
48                }
49            }
50            match &self.size {
51                Size::U32 => {
52                    push_directive(tokens, "u32");
53                }
54                Size::U64 => {
55                    push_directive(tokens, "u64");
56                }
57            }
58            self.p.unparse_tokens(tokens);
59            tokens.push(PtxToken::Comma);
60            self.a.unparse_tokens(tokens);
61            tokens.push(PtxToken::Semicolon);
62        }
63    }
64
65    impl PtxUnparser for CvtaToSpaceSize {
66        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
67            push_opcode(tokens, "cvta");
68            push_directive(tokens, "to");
69            match &self.space {
70                Space::SharedCluster => {
71                    push_directive(tokens, "shared::cluster");
72                }
73                Space::ParamEntry => {
74                    push_directive(tokens, "param::entry");
75                }
76                Space::SharedCta => {
77                    push_directive(tokens, "shared::cta");
78                }
79                Space::Global => {
80                    push_directive(tokens, "global");
81                }
82                Space::Shared => {
83                    push_directive(tokens, "shared");
84                }
85                Space::Const => {
86                    push_directive(tokens, "const");
87                }
88                Space::Local => {
89                    push_directive(tokens, "local");
90                }
91                Space::Param => {
92                    push_directive(tokens, "param");
93                }
94            }
95            match &self.size {
96                Size::U32 => {
97                    push_directive(tokens, "u32");
98                }
99                Size::U64 => {
100                    push_directive(tokens, "u64");
101                }
102            }
103            self.p.unparse_tokens(tokens);
104            tokens.push(PtxToken::Comma);
105            self.a.unparse_tokens(tokens);
106            tokens.push(PtxToken::Semicolon);
107        }
108    }
109}