ptx_parser/unparser/instruction/
mov.rs

1//! Original PTX specification:
2//!
3//! mov.type  d, a; 
4//! // mov.type  d, sreg;
5//! // mov.type  d, avar;       // get address of variable
6//! // mov.type  d, avar+imm;   // get address of variable with offset
7//! mov.u32   d, fname;      // get address of device function
8//! mov.u64   d, fname;      // get address of device function
9//! mov.u32   d, kernel;     // get address of entry function
10//! mov.u64   d, kernel;     // get address of entry function
11//! .type = { .pred,
12//! .b16, .b32, .b64,
13//! .u16, .u32, .u64,
14//! .s16, .s32, .s64,
15//! .f32, .f64 };
16//! ----------------------------------------------
17//! mov.type  d, a;
18//! .type = { .b16, .b32, .b64, .b128 };
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::mov::section_0::*;
28
29    impl PtxUnparser for MovType {
30        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
31            push_opcode(tokens, "mov");
32                    match &self.type_ {
33                            Type::Pred => {
34                                    push_directive(tokens, "pred");
35                            }
36                            Type::B16 => {
37                                    push_directive(tokens, "b16");
38                            }
39                            Type::B32 => {
40                                    push_directive(tokens, "b32");
41                            }
42                            Type::B64 => {
43                                    push_directive(tokens, "b64");
44                            }
45                            Type::U16 => {
46                                    push_directive(tokens, "u16");
47                            }
48                            Type::U32 => {
49                                    push_directive(tokens, "u32");
50                            }
51                            Type::U64 => {
52                                    push_directive(tokens, "u64");
53                            }
54                            Type::S16 => {
55                                    push_directive(tokens, "s16");
56                            }
57                            Type::S32 => {
58                                    push_directive(tokens, "s32");
59                            }
60                            Type::S64 => {
61                                    push_directive(tokens, "s64");
62                            }
63                            Type::F32 => {
64                                    push_directive(tokens, "f32");
65                            }
66                            Type::F64 => {
67                                    push_directive(tokens, "f64");
68                            }
69                    }
70                    self.d.unparse_tokens(tokens);
71            tokens.push(PtxToken::Comma);
72                    self.a.unparse_tokens(tokens);
73            tokens.push(PtxToken::Semicolon);
74        }
75    }
76
77    impl PtxUnparser for MovU32 {
78        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
79            push_opcode(tokens, "mov");
80                    push_directive(tokens, "u32");
81                    self.d.unparse_tokens(tokens);
82            tokens.push(PtxToken::Comma);
83                    self.fname.unparse_tokens(tokens);
84            tokens.push(PtxToken::Semicolon);
85        }
86    }
87
88    impl PtxUnparser for MovU64 {
89        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
90            push_opcode(tokens, "mov");
91                    push_directive(tokens, "u64");
92                    self.d.unparse_tokens(tokens);
93            tokens.push(PtxToken::Comma);
94                    self.fname.unparse_tokens(tokens);
95            tokens.push(PtxToken::Semicolon);
96        }
97    }
98
99    impl PtxUnparser for MovU321 {
100        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
101            push_opcode(tokens, "mov");
102                    push_directive(tokens, "u32");
103                    self.d.unparse_tokens(tokens);
104            tokens.push(PtxToken::Comma);
105                    self.kernel.unparse_tokens(tokens);
106            tokens.push(PtxToken::Semicolon);
107        }
108    }
109
110    impl PtxUnparser for MovU641 {
111        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
112            push_opcode(tokens, "mov");
113                    push_directive(tokens, "u64");
114                    self.d.unparse_tokens(tokens);
115            tokens.push(PtxToken::Comma);
116                    self.kernel.unparse_tokens(tokens);
117            tokens.push(PtxToken::Semicolon);
118        }
119    }
120
121}
122
123pub mod section_1 {
124    use super::*;
125    use crate::r#type::instruction::mov::section_1::*;
126
127    impl PtxUnparser for MovType1 {
128        fn unparse_tokens(&self, tokens: &mut ::std::vec::Vec<PtxToken>) {
129            push_opcode(tokens, "mov");
130                    match &self.type_ {
131                            Type::B128 => {
132                                    push_directive(tokens, "b128");
133                            }
134                            Type::B16 => {
135                                    push_directive(tokens, "b16");
136                            }
137                            Type::B32 => {
138                                    push_directive(tokens, "b32");
139                            }
140                            Type::B64 => {
141                                    push_directive(tokens, "b64");
142                            }
143                    }
144                    self.d.unparse_tokens(tokens);
145            tokens.push(PtxToken::Comma);
146                    self.a.unparse_tokens(tokens);
147            tokens.push(PtxToken::Semicolon);
148        }
149    }
150
151}
152
ptx_parser/unparser/instruction/mov.rs

ptx_parser/unparser/instruction/
mov.rs
