Debian Codegraph @

src/fcml_def_enc.c

raw
1 /*
2 * FCML - Free Code Manipulation Library.
3 * Copyright (C) 2010-2020 Slawomir Wojtasiak
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20 #include "fcml_def.h"
21 #include "fcml_env_int.h"
22
23 static fcml_ptr args_decoder_is(fcml_operand_desc encoded_addr_mode) {
24 FCML_ENV_ALLOC_CLEAR(is_args, fcml_st_def_tma_is);
25 if (is_args) {
26 is_args->flags = ( encoded_addr_mode & 0x000000FF );
27 }
28 return is_args;
29 }
30
31 static fcml_ptr args_decoder_imm(fcml_operand_desc encoded_addr_mode) {
32 FCML_ENV_ALLOC_CLEAR(imm_args, fcml_st_def_tma_imm);
33 if (imm_args) {
34 imm_args->encoded_size = (encoded_addr_mode & 0x0000FF00) >> 8;
35 imm_args->encoded_ex_size = encoded_addr_mode & 0x000000FF;
36 imm_args->is_64bit_imm_allowed =
37 encoded_addr_mode & FCML_OP_IMM_64_ALLOWED;
38 }
39 return imm_args;
40 }
41
42 static fcml_ptr args_decoder_explicit_reg(fcml_operand_desc addr_mode) {
43 FCML_ENV_ALLOC_CLEAR(explicit_reg_args, fcml_st_def_tma_explicit_reg);
44 if (explicit_reg_args) {
45 explicit_reg_args->reg_type = (addr_mode & 0x0000F000 ) >> 12;
46 explicit_reg_args->reg_num = (addr_mode & 0x00000F00 ) >> 8;
47 explicit_reg_args->encoded_reg_size = addr_mode & 0x000000FF;
48 }
49 return explicit_reg_args;
50 }
51
52 static fcml_ptr args_decoder_opcode_reg(fcml_operand_desc encoded_addr_mode) {
53 FCML_ENV_ALLOC_CLEAR(opcode_reg_args, fcml_st_def_tma_opcode_reg);
54 if (opcode_reg_args) {
55 opcode_reg_args->reg_type = (encoded_addr_mode & 0x0000FF00) >> 8;
56 opcode_reg_args->encoded_reg_size = encoded_addr_mode & 0x000000FF;
57 }
58 return opcode_reg_args;
59 }
60
61 static fcml_ptr args_decoder_immediate_dis_relative(
62 fcml_operand_desc addr_mode) {
63 FCML_ENV_ALLOC_CLEAR(immediate_dis_relative_args,
64 fcml_sf_def_tma_immediate_dis_relative);
65 if (immediate_dis_relative_args) {
66 immediate_dis_relative_args->encoded_size = addr_mode & 0x000000FF;
67 }
68 return immediate_dis_relative_args;
69 }
70
71 static fcml_ptr args_decoder_explicit_gps_reg_addressing(
72 fcml_operand_desc addr_mode) {
73 FCML_ENV_ALLOC_CLEAR(args, fcml_st_def_tma_explicit_gps_reg_addressing);
74 if (args) {
75 args->reg_num = (fcml_uint8_t)((addr_mode & 0x00FF0000) >> 16);
76 args->encoded_operand_size = (addr_mode & 0x0000FF00) >> 8;
77 args->encoded_segment_register = addr_mode & 0x000000FF;
78 }
79 return args;
80 }
81
82 static fcml_ptr args_decoder_explicit_ib(fcml_operand_desc addr_mode) {
83 FCML_ENV_ALLOC_CLEAR(explicit_ib_args, fcml_st_def_tma_explicit_ib);
84 if (explicit_ib_args) {
85 explicit_ib_args->ib = addr_mode & 0x000000FF;
86 }
87 return explicit_ib_args;
88 }
89
90 static fcml_ptr args_decoder_segment_relative_offset(
91 fcml_operand_desc addr_mode) {
92 FCML_ENV_ALLOC_CLEAR(segment_relative_offset_args,
93 fcml_st_def_tma_segment_relative_offset);
94 if (segment_relative_offset_args) {
95 segment_relative_offset_args->encoded_operand_size =
96 (addr_mode & 0x0000FF00) >> 8;
97 segment_relative_offset_args->encoded_segment_register =
98 addr_mode & 0x000000FF;
99 }
100 return segment_relative_offset_args;
101 }
102
103 static fcml_ptr args_decoder_rm(fcml_operand_desc addr_mode) {
104 FCML_ENV_ALLOC_CLEAR(rm_args, fcml_st_def_tma_rm);
105 if (rm_args) {
106 fcml_operand_decorators decorators = FCML_DECORATORS(addr_mode);
107 rm_args->reg_type = (addr_mode & 0x000000F0) >> 4;
108 rm_args->encoded_register_operand_size =
109 (addr_mode & 0x0000FF00) >> 8;
110 rm_args->encoded_memory_operand_size =
111 (fcml_uint8_t)((addr_mode & 0x00FF0000) >> 16);
112 rm_args->flags = addr_mode & 0x0000000F;
113 rm_args->is_vsib = FCML_FALSE;
114 rm_args->vector_index_register = 0;
115 rm_args->is_bcast = FCML_IS_DECOR_BCAST(decorators);
116 }
117 return rm_args;
118 }
119
120 static fcml_ptr args_decoder_r(fcml_operand_desc addr_mode) {
121 FCML_ENV_ALLOC_CLEAR(r_args, fcml_st_def_tma_r);
122 if (r_args) {
123 r_args->reg_type = (fcml_en_register)(addr_mode & 0x0000000F);
124 r_args->encoded_register_operand_size =
125 (fcml_uint8_t)((addr_mode & 0x00000FF0) >> 4);
126 /* TODO: Decode decorators here. Hide the encoding format here! */
127 r_args->decorators = FCML_DECORATORS(addr_mode);
128 }
129 return r_args;
130 }
131
132 static fcml_ptr args_decoder_vex_vvvv(fcml_operand_desc addr_mode) {
133 FCML_ENV_ALLOC_CLEAR(vex_vvvv_args, fcml_st_def_tma_vex_vvvv_reg);
134 if (vex_vvvv_args) {
135 vex_vvvv_args->reg_type = addr_mode & 0x0000000F;
136 vex_vvvv_args->encoded_register_size =
137 (fcml_uint8_t)((addr_mode & 0x00000FF0) >> 4);
138 }
139 return vex_vvvv_args;
140 }
141
142 static fcml_ptr args_decoder_vsib(fcml_operand_desc addr_mode) {
143 FCML_ENV_ALLOC_CLEAR(vsib_args, fcml_st_def_tma_rm);
144 if (vsib_args) {
145 vsib_args->vector_index_register = (fcml_uint8_t)(addr_mode >> 8);
146 vsib_args->encoded_memory_operand_size = addr_mode & 0x000000FF;
147 vsib_args->encoded_register_operand_size = 0;
148 vsib_args->flags = FCML_RMF_M;
149 vsib_args->reg_type = FCML_REG_UNDEFINED;
150 vsib_args->is_vsib = FCML_TRUE;
151 }
152 return vsib_args;
153 }
154
155 static fcml_ptr args_decoder_pseudo_op(fcml_operand_desc addr_mode) {
156 FCML_ENV_ALLOC_CLEAR(pseudo_op_args, fcml_st_def_tma_pseudo_op);
157 if (pseudo_op_args) {
158 pseudo_op_args->mask = (fcml_uint8_t)(addr_mode & 0x000000FF);
159 }
160 return pseudo_op_args;
161 }
162
163 static fcml_ptr args_decoder_virtual_op(fcml_operand_desc encoded_addr_mode) {
164 FCML_ENV_ALLOC_CLEAR(virtual_op_args, fcml_st_def_tma_virtual_op);
165 if (virtual_op_args) {
166 virtual_op_args->decorators = FCML_DECORATORS(encoded_addr_mode);
167 }
168 return virtual_op_args;
169 }
170
171 typedef fcml_ptr (*addr_mode_args_decoder)(fcml_operand_desc);
172
173 #define FCML_DEF_DECODERS_COUNT (sizeof(args_decoders) \
174 / sizeof(addr_mode_args_decoder))
175
176 /**
177 * Ordering is really important here because every decoder corresponds
178 * to one addressing mode from "fcml_def.h".
179 */
180 static addr_mode_args_decoder args_decoders[] = {
181 NULL,
182 args_decoder_imm,
183 args_decoder_explicit_reg,
184 args_decoder_opcode_reg,
185 args_decoder_immediate_dis_relative,
186 NULL,
187 args_decoder_explicit_gps_reg_addressing,
188 args_decoder_explicit_ib,
189 args_decoder_segment_relative_offset,
190 args_decoder_rm,
191 args_decoder_r,
192 args_decoder_vex_vvvv,
193 args_decoder_is,
194 args_decoder_vsib,
195 args_decoder_pseudo_op,
196 args_decoder_virtual_op
197 };
198
199 static fcml_en_access_mode decode_access_mode(
200 const fcml_operand_desc operand_desc) {
201 fcml_en_access_mode access_mode = FCML_AM_ACCESS_MODE_UNDEFINED;
202 if (operand_desc & FCML_OA_W) {
203 /* Destination operands for some instructions can be
204 * also a source operands. In such a case "READ" flag
205 * has to be set for such operands. */
206 access_mode = (fcml_en_access_mode)(access_mode | FCML_AM_WRITE);
207 if (operand_desc & FCML_OA_R) {
208 access_mode = (fcml_en_access_mode)(access_mode | FCML_AM_READ);
209 }
210 } else {
211 /* All operands but destination ones have the access mode
212 * automatically set to "READ". */
213 access_mode = FCML_AM_READ;
214 }
215 return access_mode;
216 }
217
218 fcml_ceh_error fcml_fn_def_decode_addr_mode_args(
219 const fcml_operand_desc operand_desc,
220 fcml_st_def_decoded_addr_mode **decoded_addr_mode) {
221
222 fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;
223 *decoded_addr_mode = NULL;
224
225 FCML_ENV_ALLOC_CLEAR(addr_mode, fcml_st_def_decoded_addr_mode);
226 if (addr_mode) {
227 addr_mode->addr_mode = FCML_GET_ADDR_MODE(operand_desc);
228 addr_mode->access_mode = decode_access_mode(operand_desc);
229 if (addr_mode->addr_mode > FCML_DEF_DECODERS_COUNT) {
230 /* Corrupted instruction model. */
231 fcml_fn_env_memory_free(addr_mode);
232 return FCML_CEH_GEC_INTERNAL_ERROR;
233 }
234
235 addr_mode->addr_mode_args = NULL;
236 addr_mode_args_decoder decoder = args_decoders[addr_mode->addr_mode];
237 if (decoder) {
238 /* Send addressing mode together with decorators, because they
239 * are used by decoders/encoders too. */
240 addr_mode->addr_mode_args = decoder(operand_desc);
241 if (!addr_mode->addr_mode_args) {
242 fcml_fn_env_memory_free(addr_mode);
243 return FCML_CEH_GEC_OUT_OF_MEMORY;
244 }
245 }
246
247 *decoded_addr_mode = addr_mode;
248 } else {
249 error = FCML_CEH_GEC_OUT_OF_MEMORY;
250 }
251
252 return error;
253 }
254
255 void fcml_fnp_def_free_addr_mode(
256 fcml_st_def_decoded_addr_mode *decoded_addr_mode) {
257 if (decoded_addr_mode) {
258 if (decoded_addr_mode->addr_mode_args) {
259 fcml_fn_env_memory_free(decoded_addr_mode->addr_mode_args);
260 }
261 fcml_fn_env_memory_free(decoded_addr_mode);
262 }
263 }
264
265 /**
266 * Converts VSIB register type to corresponding data size.
267 */
268 fcml_usize fcml_fn_def_vsib_reg_to_ds(fcml_uint8_t vsib_reg) {
269 switch (vsib_reg) {
270 case FCML_VSIB_XMM:
271 return FCML_DS_128;
272 case FCML_VSIB_YMM:
273 return FCML_DS_256;
274 case FCML_VSIB_ZMM:
275 return FCML_DS_512;
276 case FCML_VSIB_UNDEF:
277 return FCML_DS_UNDEF;
278 }
279 return FCML_DS_UNDEF;
280 }