Debian Codegraph @

check/public-tests/render_t.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 "render_t.h"
21
22 #include <stdio.h>
23 #include <string.h>
24
25 #include <fcml_renderer.h>
26 #include <fcml_intel_dialect.h>
27 #include <fcml_gas_dialect.h>
28
29 #include "instructions_base_t.h"
30
31 fcml_bool fcml_ifn_render_test_disassemble_intel( fcml_st_disassembler_result *dasm_result, fcml_uint8_t *code, fcml_usize code_size ) {
32
33 fcml_st_disassembler_context d_context = {0};
34 d_context.entry_point.op_mode = FCML_OM_32_BIT;
35 d_context.entry_point.ip = 0x00401000;
36 d_context.disassembler = disassembler_intel;
37 d_context.code = code;
38 d_context.code_length = code_size;
39
40 fcml_fn_disassembler_result_prepare( dasm_result );
41
42 fcml_ceh_error error = fcml_fn_disassemble( &d_context, dasm_result );
43 if( error ) {
44 STF_FAIL("Disassembling failed.");
45 return FCML_FALSE;
46 }
47
48 return FCML_TRUE;
49 }
50
51 fcml_bool fcml_ifn_render_test_disassemble_gas( fcml_st_disassembler_result *dasm_result, fcml_uint8_t *code, fcml_usize code_size ) {
52
53 fcml_st_disassembler_context d_context = {0};
54 d_context.entry_point.op_mode = FCML_OM_32_BIT;
55 d_context.entry_point.ip = 0x00401000;
56 d_context.disassembler = disassembler_gas;
57 d_context.code = code;
58 d_context.code_length = code_size;
59
60 fcml_fn_disassembler_result_prepare( dasm_result );
61
62 fcml_ceh_error error = fcml_fn_disassemble( &d_context, dasm_result );
63 if( error ) {
64 STF_FAIL("Disassembling failed.");
65 return FCML_FALSE;
66 }
67
68 return FCML_TRUE;
69 }
70
71 fcml_bool fcml_tf_render_suite_init(void) {
72 return FCML_TRUE;
73 }
74
75 fcml_bool fcml_tf_render_suite_cleanup(void) {
76 return FCML_TRUE;
77 }
78
79 void fcml_fn_render_paddings_leading_zeroes_intel(void) {
80
81 fcml_uint8_t code[] = { 0x80, 0x54, 0x01, 0x02, 0x03 };
82
83 fcml_st_disassembler_result dasm_result;
84
85 if( !fcml_ifn_render_test_disassemble_intel( &dasm_result, code, sizeof( code ) ) ) {
86 return;
87 }
88
89 fcml_st_render_config config = {0};
90 config.render_flags = FCML_REND_FLAG_REMOVE_LEADING_ZEROS | FCML_REND_FLAG_HEX_IMM | FCML_REND_FLAG_HEX_DISPLACEMENT;
91
92 fcml_char buffer[FCML_REND_MAX_BUFF_LEN];
93
94 fcml_ceh_error error = fcml_fn_render( dialect_intel, &config, buffer, sizeof( buffer ), &dasm_result );
95 if( error ) {
96 STF_FAIL("Rendering failed.");
97 return;
98 }
99
100 STF_ASSERT_STRING_EQUAL( buffer, "adc byte ptr [ecx+eax+2h],3h" );
101
102 fcml_fn_disassembler_result_free( &dasm_result );
103 }
104
105 void fcml_fn_render_paddings_leading_zeroes_intel_2(void) {
106
107 fcml_uint8_t code[] = { 0x83, 0x15, 0x00, 0x00, 0x00, 0x00, 0x03 };
108
109 fcml_st_disassembler_result dasm_result;
110
111 if( !fcml_ifn_render_test_disassemble_intel( &dasm_result, code, sizeof( code ) ) ) {
112 return;
113 }
114
115 fcml_st_render_config config = {0};
116 config.render_flags = FCML_REND_FLAG_REMOVE_LEADING_ZEROS | FCML_REND_FLAG_HEX_IMM | FCML_REND_FLAG_HEX_DISPLACEMENT;
117
118 fcml_char buffer[FCML_REND_MAX_BUFF_LEN];
119
120 fcml_ceh_error error = fcml_fn_render( dialect_intel, &config, buffer, sizeof( buffer ), &dasm_result );
121 if( error ) {
122 STF_FAIL("Rendering failed.");
123 return;
124 }
125
126 STF_ASSERT_STRING_EQUAL( buffer, "adc dword ptr [0h],3h" );
127
128 fcml_fn_disassembler_result_free( &dasm_result );
129 }
130
131 void fcml_fn_render_paddings_leading_zeroes_gas(void) {
132
133 fcml_uint8_t code[] = { 0x80, 0x54, 0x01, 0x02, 0x03 };
134
135 fcml_st_disassembler_result dasm_result;
136
137 if( !fcml_ifn_render_test_disassemble_gas( &dasm_result, code, sizeof( code ) ) ) {
138 return;
139 }
140
141 fcml_st_render_config config = {0};
142 config.render_flags = FCML_REND_FLAG_REMOVE_LEADING_ZEROS | FCML_REND_FLAG_HEX_IMM | FCML_REND_FLAG_HEX_DISPLACEMENT;
143
144 fcml_char buffer[FCML_REND_MAX_BUFF_LEN];
145
146 fcml_ceh_error error = fcml_fn_render( dialect_gas, &config, buffer, sizeof( buffer ), &dasm_result );
147 if( error ) {
148 STF_FAIL("Rendering failed.");
149 return;
150 }
151
152 STF_ASSERT_STRING_EQUAL( buffer, "adcb $0x3,0x2(%ecx,%eax)" );
153
154 fcml_fn_disassembler_result_free( &dasm_result );
155 }
156
157 void fcml_fn_render_paddings_intel(void) {
158
159 fcml_uint8_t code[] = { 0x66, 0x81, 0xd0, 0x42, 0x80 };
160
161 fcml_st_disassembler_result dasm_result;
162
163 if( !fcml_ifn_render_test_disassemble_intel( &dasm_result, code, sizeof( code ) ) ) {
164 return;
165 }
166
167 fcml_st_render_config config = {0};
168 config.render_flags = FCML_REND_FLAG_CODE_PADDING | FCML_REND_FLAG_MNEMONIC_PADDING | FCML_REND_FLAG_RENDER_CODE;
169 config.prefered_code_padding = 10;
170 config.prefered_mnemonic_padding = 8;
171
172 fcml_char buffer[FCML_REND_MAX_BUFF_LEN];
173
174 fcml_ceh_error error = fcml_fn_render( dialect_intel, &config, buffer, sizeof( buffer ), &dasm_result );
175 if( error ) {
176 STF_FAIL("Rendering failed.");
177 return;
178 }
179
180 STF_ASSERT_STRING_EQUAL( buffer, "6681d04280 adc ax,-32702" );
181
182 // Padding length equal to code and mnemonic.
183
184 config.prefered_code_padding = 5;
185 config.prefered_mnemonic_padding = 3;
186
187 error = fcml_fn_render( dialect_intel, &config, buffer, sizeof( buffer ), &dasm_result );
188 if( error ) {
189 STF_FAIL("Rendering failed.");
190 return;
191 }
192
193 STF_ASSERT_STRING_EQUAL( buffer, "6681d04280 adc ax,-32702" );
194
195 // Paddings less than rendered mnemonic and code.
196
197 config.prefered_code_padding = 1;
198 config.prefered_mnemonic_padding = 1;
199
200 error = fcml_fn_render( dialect_intel, &config, buffer, sizeof( buffer ), &dasm_result );
201 if( error ) {
202 STF_FAIL("Rendering failed.");
203 return;
204 }
205
206 STF_ASSERT_STRING_EQUAL( buffer, "6681d04280 adc ax,-32702" );
207
208 fcml_fn_disassembler_result_free( &dasm_result );
209 }
210
211 void fcml_fn_render_paddings_intel_lock(void) {
212
213 fcml_uint8_t code[] = { 0xF0, 0x80, 0x15, 0x01, 0x02, 0x03, 0x04, 0xff };
214
215 fcml_st_disassembler_result dasm_result;
216
217 if( !fcml_ifn_render_test_disassemble_intel( &dasm_result, code, sizeof( code ) ) ) {
218 return;
219 }
220
221 fcml_st_render_config config = {0};
222 config.render_flags = FCML_REND_FLAG_CODE_PADDING | FCML_REND_FLAG_MNEMONIC_PADDING | FCML_REND_FLAG_RENDER_CODE;
223 config.prefered_code_padding = 10;
224 config.prefered_mnemonic_padding = 8;
225
226 fcml_char buffer[FCML_REND_MAX_BUFF_LEN];
227
228 fcml_ceh_error error = fcml_fn_render( dialect_intel, &config, buffer, sizeof( buffer ), &dasm_result );
229 if( error ) {
230 STF_FAIL("Rendering failed.");
231 return;
232 }
233
234 STF_ASSERT_STRING_EQUAL( buffer, "f0801501020304ff lock adc byte ptr [04030201h],-1" );
235
236 fcml_fn_disassembler_result_free( &dasm_result );
237 }
238
239 void fcml_fn_render_paddings_gas(void) {
240
241 fcml_uint8_t code[] = { 0x66, 0x81, 0xd0, 0x42, 0x80 };
242
243 fcml_st_disassembler_result dasm_result;
244
245 if( !fcml_ifn_render_test_disassemble_gas( &dasm_result, code, sizeof( code ) ) ) {
246 return;
247 }
248
249 fcml_st_render_config config = {0};
250 config.render_flags = FCML_REND_FLAG_CODE_PADDING | FCML_REND_FLAG_MNEMONIC_PADDING | FCML_REND_FLAG_RENDER_CODE;
251 config.prefered_code_padding = 10;
252 config.prefered_mnemonic_padding = 8;
253
254 fcml_char buffer[FCML_REND_MAX_BUFF_LEN];
255
256 fcml_ceh_error error = fcml_fn_render( dialect_gas, &config, buffer, sizeof( buffer ), &dasm_result );
257 if( error ) {
258 STF_FAIL("Rendering failed.");
259 return;
260 }
261
262 STF_ASSERT_STRING_EQUAL( buffer, "6681d04280 adc $-32702,%ax" );
263
264 // Padding length equal to code and mnemonic.
265
266 config.prefered_code_padding = 5;
267 config.prefered_mnemonic_padding = 3;
268
269 error = fcml_fn_render( dialect_gas, &config, buffer, sizeof( buffer ), &dasm_result );
270 if( error ) {
271 STF_FAIL("Rendering failed.");
272 return;
273 }
274
275 STF_ASSERT_STRING_EQUAL( buffer, "6681d04280 adc $-32702,%ax" );
276
277 // Paddings less than rendered mnemonic and code.
278
279 config.prefered_code_padding = 1;
280 config.prefered_mnemonic_padding = 1;
281
282 error = fcml_fn_render( dialect_gas, &config, buffer, sizeof( buffer ), &dasm_result );
283 if( error ) {
284 STF_FAIL("Rendering failed.");
285 return;
286 }
287
288 STF_ASSERT_STRING_EQUAL( buffer, "6681d04280 adc $-32702,%ax" );
289
290 fcml_fn_disassembler_result_free( &dasm_result );
291 }
292
293 fcml_stf_test_case fcml_ti_render[] = {
294 { "fcml_fn_render_paddings_leading_zeroes_intel", fcml_fn_render_paddings_leading_zeroes_intel },
295 { "fcml_fn_render_paddings_leading_zeroes_intel_2", fcml_fn_render_paddings_leading_zeroes_intel_2 },
296 { "fcml_fn_render_paddings_leading_zeroes_gas", fcml_fn_render_paddings_leading_zeroes_gas },
297 { "fcml_fn_render_paddings_intel", fcml_fn_render_paddings_intel },
298 { "fcml_fn_render_paddings_intel_lock", fcml_fn_render_paddings_intel_lock },
299 { "fcml_fn_render_paddings_gas", fcml_fn_render_paddings_gas },
300 FCML_STF_NULL_TEST
301 };
302
303 fcml_stf_test_suite fcml_si_render = {
304 "suite-fcml-render", fcml_tf_render_suite_init, fcml_tf_render_suite_cleanup, fcml_ti_render
305 };