Debian Codegraph @

src/fcml_gas_rend.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 /* There is a bit of code duplication between GAS and Intel instruction renderers.
21 * It evaluated up to this point due to historical reasons and it will be probably fixed in
22 * the near future by providing one generic customizable rendering template as a base for
23 * instruction renderers.
24 */
25
26 #include "fcml_gas_rend.h"
27
28 #include <fcml_types.h>
29 #include <fcml_common.h>
30 #include <fcml_dialect.h>
31 #include <fcml_renderer.h>
32 #include <fcml_disassembler.h>
33
34 #include "fcml_common_dialect.h"
35 #include "fcml_ceh.h"
36 #include "fcml_common_utils.h"
37 #include "fcml_dialect_int.h"
38 #include "fcml_env_int.h"
39 #include "fcml_rend_utils.h"
40 #include "fcml_stream.h"
41 #include "fcml_utils.h"
42
43 #define FCML_REND_LOCAL_BUFFER_SIZE 512
44
45 static fcml_string integer_formats_gas[6][4] = {
46 /* Signed integer values.*/
47 {
48 FCML_PRI_INT8_DEC, FCML_PRI_INT16_DEC, FCML_PRI_INT32_DEC,
49 FCML_PRI_INT64_DEC
50 },
51 /* Unsigned integer values.*/
52 {
53 FCML_PRI_UINT8_DEC, FCML_PRI_UINT16_DEC, FCML_PRI_UINT32_DEC,
54 FCML_PRI_UINT64_DEC
55 },
56 /* Signed hex values.*/
57 {
58 FCML_TEXT("0x") FCML_PRI_INT8_HEX, FCML_TEXT("0x") FCML_PRI_INT16_HEX,
59 FCML_TEXT("0x") FCML_PRI_INT32_HEX, FCML_TEXT("0x") FCML_PRI_INT64_HEX
60 },
61 /* Unsigned hex values.*/
62 {
63 FCML_TEXT("0x") FCML_PRI_INT8_HEX, FCML_TEXT("0x") FCML_PRI_INT16_HEX,
64 FCML_TEXT("0x") FCML_PRI_INT32_HEX,FCML_TEXT("0x") FCML_PRI_INT64_HEX
65 },
66 /* Signed hex values without leading zeros. */
67 {
68 FCML_TEXT("0x") FCML_PRI_INT8_HEX_NO_ZEROS,
69 FCML_TEXT("0x") FCML_PRI_INT16_HEX_NO_ZEROS,
70 FCML_TEXT("0x") FCML_PRI_INT32_HEX_NO_ZEROS,
71 FCML_TEXT("0x") FCML_PRI_INT64_HEX_NO_ZEROS
72 },
73 /* Unsigned hex values without leading zeros. */
74 {
75 FCML_TEXT("0x") FCML_PRI_INT8_HEX_NO_ZEROS,
76 FCML_TEXT("0x") FCML_PRI_INT16_HEX_NO_ZEROS,
77 FCML_TEXT("0x") FCML_PRI_INT32_HEX_NO_ZEROS,
78 FCML_TEXT("0x") FCML_PRI_INT64_HEX_NO_ZEROS
79 }
80 };
81
82 static fcml_ceh_error operand_renderer_imm(
83 const fcml_st_render_config *config,
84 fcml_st_memory_stream *output_stream,
85 const fcml_st_operand *operand) {
86
87 const fcml_st_integer *immediate = &(operand->immediate);
88
89 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT("$"));
90
91 return fcml_fn_rend_utils_format_append_integer(
92 integer_formats_gas, output_stream, immediate,
93 config->render_flags & FCML_REND_FLAG_HEX_IMM,
94 config->render_flags & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
95 }
96
97 static inline fcml_ceh_error operand_renderer_reg(
98 const fcml_st_dialect_context_int *dialect_context,
99 fcml_st_memory_stream *output_stream,
100 const fcml_st_disassembler_result *result,
101 const fcml_st_operand *operand) {
102 fcml_fn_rend_utils_format_append_reg(dialect_context, output_stream,
103 &(operand->reg),
104 result->instruction_details.prefixes_details.is_rex);
105 return FCML_CEH_GEC_NO_ERROR;
106 }
107
108 static fcml_ceh_error operand_renderer_address(
109 const fcml_st_render_config *config,
110 const fcml_st_dialect_context_int *dialect_context,
111 fcml_st_memory_stream *output_stream,
112 const fcml_st_disassembler_result *result,
113 const fcml_st_operand *operand) {
114
115 fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;
116 const fcml_st_address *address = &(operand->address);
117 const fcml_st_prefixes_details *prefixes =
118 &(result->instruction_details.prefixes_details);
119 fcml_hints hints = operand->hints;
120
121 if (hints & FCML_OP_HINT_DISPLACEMENT_RELATIVE_ADDRESS) {
122
123 fcml_st_integer integer;
124 fcml_ceh_error error = fcml_fn_utils_offset_to_integer(
125 &(address->offset), &integer);
126 if (error) {
127 return error;
128 }
129
130 error = fcml_fn_rend_utils_format_append_integer(
131 integer_formats_gas, output_stream,
132 &integer, FCML_TRUE,
133 config->render_flags & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
134
135 return error;
136 }
137
138 if (!address->segment_selector.is_default_reg
139 || (config->render_flags & FCML_REND_FLAG_RENDER_DEFAULT_SEG)) {
140 fcml_fn_rend_utils_format_append_reg(dialect_context, output_stream,
141 &(address->segment_selector.segment_selector),
142 prefixes->is_rex);
143 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT(":"));
144 }
145
146 const fcml_st_effective_address *effective_address =
147 &(address->effective_address);
148
149 if (result->instruction.hints & FCML_HINT_INDIRECT_POINTER) {
150 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT("*"));
151 }
152
153 if (address->address_form == FCML_AF_COMBINED) {
154
155 /* Displacement.*/
156 if (effective_address->displacement.size > 0) {
157
158 error = fcml_fn_rend_utils_format_append_integer(
159 integer_formats_gas, output_stream,
160 &(effective_address->displacement),
161 config->render_flags & FCML_REND_FLAG_HEX_DISPLACEMENT,
162 config->render_flags & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
163 if (error) {
164 return error;
165 }
166 }
167
168 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT("("));
169
170 /* Append base register.*/
171 if (!is_reg_undef(&(effective_address->base))) {
172 fcml_fn_rend_utils_format_append_reg(dialect_context, output_stream,
173 &(effective_address->base), prefixes->is_rex);
174 }
175
176 /* Append index register.*/
177 if (!is_reg_undef(&(effective_address->index))) {
178 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT(","));
179 fcml_fn_rend_utils_format_append_reg(dialect_context, output_stream,
180 &(effective_address->index), prefixes->is_rex);
181 }
182
183 /* Append scale.*/
184 if (effective_address->scale_factor > 0) {
185
186 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT(","));
187
188 fcml_st_integer scale_value = { 0 };
189 scale_value.is_signed = FCML_FALSE;
190 scale_value.size = 8;
191 scale_value.int8 = (fcml_int8_t) effective_address->scale_factor;
192
193 fcml_fn_rend_utils_format_append_integer(
194 integer_formats_gas, output_stream,
195 &scale_value, FCML_FALSE, FCML_FALSE);
196 }
197
198 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT(")"));
199
200 } else {
201
202 /* Absolute offset or RIP.*/
203 if (!error) {
204
205 /* For RIP base register is set to IP. */
206 fcml_st_integer integer;
207 if (address->effective_address.base.type == FCML_REG_IP) {
208 /* IP relative addressing.*/
209 error = fcml_fn_rend_utils_format_append_integer(
210 integer_formats_gas, output_stream,
211 &(address->effective_address.displacement), FCML_TRUE,
212 config->render_flags
213 & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
214 if (!error) {
215 fcml_fn_rend_utils_format_append_str(output_stream,
216 FCML_TEXT("("));
217 fcml_fn_rend_utils_format_append_reg(dialect_context,
218 output_stream, &(fcml_reg_RIP), FCML_FALSE);
219 fcml_fn_rend_utils_format_append_str(output_stream,
220 FCML_TEXT(")"));
221 }
222 } else {
223 /* Absolute offset.*/
224 fcml_ceh_error error = fcml_fn_utils_offset_to_integer(
225 &(address->offset), &integer);
226 if (error) {
227 return error;
228 }
229 error = fcml_fn_rend_utils_format_append_integer(
230 integer_formats_gas, output_stream,
231 &integer, FCML_TRUE,
232 config->render_flags
233 & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
234 }
235 }
236 }
237
238 return error;
239 }
240
241 static fcml_ceh_error operand_renderer_far_pointer(
242 const fcml_st_render_config *config,
243 fcml_st_memory_stream *output_stream,
244 const fcml_st_operand *operand) {
245
246 fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;
247 fcml_st_integer integer = { 0 };
248
249 integer.is_signed = FCML_TRUE;
250 integer.size = 16;
251 integer.int16 = operand->far_pointer.segment;
252
253 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT("$"));
254 fcml_fn_rend_utils_format_append_integer(integer_formats_gas, output_stream,
255 &integer, FCML_TRUE,
256 config->render_flags & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
257
258 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT(","));
259
260 integer.size = operand->far_pointer.offset_size;
261 switch (integer.size) {
262 case FCML_DS_16:
263 integer.int16 = operand->far_pointer.offset16;
264 break;
265 case FCML_DS_32:
266 integer.int32 = operand->far_pointer.offset32;
267 break;
268 }
269
270 fcml_fn_rend_utils_format_append_str(output_stream, FCML_TEXT("$"));
271 fcml_fn_rend_utils_format_append_integer(integer_formats_gas, output_stream,
272 &integer, FCML_TRUE,
273 config->render_flags & FCML_REND_FLAG_REMOVE_LEADING_ZEROS);
274
275 return error;
276 }
277
278 static fcml_ceh_error print_operand(const fcml_st_render_config *config,
279 const fcml_st_dialect_context_int *dialect_context,
280 fcml_st_memory_stream *output_stream,
281 const fcml_st_disassembler_result *result, fcml_int operand_index) {
282
283 fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;
284 const fcml_st_operand *operand =
285 &(result->instruction.operands[operand_index]);
286
287 switch (operand->type) {
288 case FCML_OT_IMMEDIATE:
289 error = operand_renderer_imm(config, output_stream, operand);
290 break;
291 case FCML_OT_FAR_POINTER:
292 error = operand_renderer_far_pointer(config, output_stream, operand);
293 break;
294 case FCML_OT_ADDRESS:
295 error = operand_renderer_address(config, dialect_context,
296 output_stream, result, operand);
297 break;
298 case FCML_OT_REGISTER:
299 error = operand_renderer_reg(dialect_context, output_stream,
300 result, operand);
301 break;
302 case FCML_OT_VIRTUAL:
303 break;
304 case FCML_OT_NONE:
305 break;
306 default:
307 error = FCML_CEH_GEC_INVALID_INPUT;
308 }
309
310 /* Print operand attributes just after the operand. */
311 if (!error) {
312 fcml_fn_rend_utils_format_append_operand_decorators(dialect_context,
313 output_stream, &(operand->decorators));
314 }
315
316 return error;
317 }
318
319 fcml_ceh_error fcml_fn_rend_render_instruction_gas(
320 const fcml_st_dialect *dialect_context,
321 const fcml_st_render_config *config,
322 fcml_st_memory_stream *output_stream,
323 const fcml_st_disassembler_result *result) {
324
325 fcml_st_dialect_context_int *dialect_context_int =
326 (fcml_st_dialect_context_int*) dialect_context;
327 fcml_char local_buffer[FCML_REND_LOCAL_BUFFER_SIZE] = { 0 };
328 fcml_ceh_error error = FCML_CEH_GEC_NO_ERROR;
329 fcml_uint32_t render_flags = config->render_flags;
330
331 /* Local stream.*/
332 fcml_st_memory_stream local_stream;
333 local_stream.base_address = local_buffer;
334 local_stream.size = sizeof(local_buffer);
335 local_stream.offset = 0;
336
337 /* Instruction code. */
338 if (render_flags & FCML_REND_FLAG_RENDER_CODE) {
339 fcml_fn_rend_utils_format_append_code(config, output_stream,
340 result->instruction_details.instruction_code,
341 result->instruction_details.instruction_size);
342 }
343
344 fcml_int len = 0;
345
346 /* Instruction prefixes like LOCK. */
347 len += fcml_ifn_rend_utils_print_prefixes(output_stream,
348 &(result->instruction_details.prefixes_details), render_flags);
349
350 /* Mnemonic. */
351 len += fcml_fn_rend_utils_format_append_str(output_stream,
352 result->instruction.mnemonic);
353
354 /* Short form, so operands should be ignored. */
355 if (result->instruction_details.is_shortcut) {
356 return error;
357 }
358
359 /* Add all operands. */
360 fcml_bool first_render = FCML_TRUE;
361 fcml_int i;
362 for (i = 0; i < FCML_OPERANDS_COUNT; i++) {
363 if (result->instruction.operands[i].type != FCML_OT_NONE) {
364 error = print_operand(config, dialect_context_int,
365 &local_stream, result, i);
366 if (!error) {
367 first_render = fcml_fn_rend_utils_render_operand_separator(
368 config, output_stream, len, first_render);
369 fcml_fn_rend_utils_format_append_stream(output_stream,
370 &local_stream);
371 fcml_fn_stream_clean(&local_stream);
372 } else {
373 break;
374 }
375 } else {
376 break;
377 }
378 }
379
380 fcml_fn_rend_utils_format_finish_str(output_stream);
381
382 return error;
383 }