Debian Codegraph @

check/internal-tests/modrm_decoder_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 "modrm_decoder_t.h"
21
22 #include <fcml_modrm_decoder.h>
23 #include <fcml_env_int.h>
24 #include <fcml_errors.h>
25
26 fcml_st_modrm_decoder_context fcml_ifn_modrm_decoder_alloc_ctx() {
27 fcml_st_modrm_decoder_context context;
28 fcml_fn_env_memory_clear( &context, sizeof( context ) );
29 return context;
30 }
31
32 fcml_bool fcml_tf_modrm_decoder_suite_init(void) {
33 return FCML_TRUE;
34 }
35
36 fcml_bool fcml_tf_modrm_decoder_suite_cleanup(void) {
37 return FCML_TRUE;
38 }
39
40 void fcml_tf_modrm_decoder_test_1(void) {
41
42 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
43
44 context.op_mode = FCML_OM_32_BIT;
45 context.effective_address_size = FCML_DS_16;
46
47 fcml_uint8_t buffer[] = {23};
48
49 fcml_st_memory_stream stream;
50 stream.base_address = &buffer;
51 stream.size = sizeof( buffer );
52 stream.offset = 0;
53
54 fcml_st_modrm_source modrm_source = {0};
55 modrm_source.ext_B = 0;
56 modrm_source.ext_R = 0;
57 modrm_source.ext_X = 0;
58 modrm_source.stream = &stream;
59 fcml_st_modrm decoded_modrm;
60
61 fcml_st_modrm_details details;
62
63 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
64
65 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
66 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
67 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_BX );
68 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_16 );
69 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
70 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
71 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
72 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_DX );
73 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
74 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
75 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
76
77 }
78
79 void fcml_tf_modrm_decoder_test_2(void) {
80
81 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
82
83 context.op_mode = FCML_OM_32_BIT;
84 context.effective_address_size = FCML_DS_16;
85
86 fcml_uint8_t buffer[] = {0x1E, 0x01, 0x02};
87
88 fcml_st_memory_stream stream;
89 stream.base_address = &buffer;
90 stream.size = sizeof( buffer );
91 stream.offset = 0;
92
93 fcml_st_modrm_source modrm_source = {0};
94 modrm_source.ext_B = 0;
95 modrm_source.ext_R = 0;
96 modrm_source.ext_X = 0;
97 modrm_source.stream = &stream;
98 fcml_st_modrm decoded_modrm;
99
100 fcml_st_modrm_details details;
101 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
102
103 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
104 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_UNDEFINED );
105 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
106 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, 0 );
107 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
108 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
109 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
110 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_BX );
111 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_16 );
112 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int16, 0x0201 );
113 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
114 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
115
116 }
117
118 void fcml_tf_modrm_decoder_test_3(void) {
119
120 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
121
122 context.op_mode = FCML_OM_32_BIT;
123 context.effective_address_size = FCML_DS_16;
124
125 fcml_uint8_t buffer[] = {0x0B};
126
127 fcml_st_memory_stream stream;
128 stream.base_address = &buffer;
129 stream.size = sizeof( buffer );
130 stream.offset = 0;
131
132 fcml_st_modrm_source modrm_source = {0};
133 modrm_source.ext_B = 0;
134 modrm_source.ext_R = 0;
135 modrm_source.ext_X = 0;
136 modrm_source.stream = &stream;
137 fcml_st_modrm decoded_modrm;
138
139 fcml_st_modrm_details details;
140 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
141
142 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
143 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
144 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_BP );
145 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_16 );
146 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
147 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_DI );
148 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_16 );
149 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
150 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_CX );
151 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
152 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
153
154 }
155
156 void fcml_tf_modrm_decoder_test_4(void) {
157
158 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
159
160 context.op_mode = FCML_OM_32_BIT;
161 context.effective_address_size = FCML_DS_16;
162
163 fcml_uint8_t buffer[] = {0x14};
164
165 fcml_st_memory_stream stream;
166 stream.base_address = &buffer;
167 stream.size = sizeof( buffer );
168 stream.offset = 0;
169
170 fcml_st_modrm_source modrm_source = {0};
171 modrm_source.ext_B = 0;
172 modrm_source.ext_R = 0;
173 modrm_source.ext_X = 0;
174 modrm_source.stream = &stream;
175 fcml_st_modrm decoded_modrm;
176
177 fcml_st_modrm_details details;
178
179 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
180
181 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
182 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
183 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_SI );
184 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_16 );
185 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
186 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
187 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
188 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_DX );
189 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
190 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
191 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
192
193 }
194
195 void fcml_tf_modrm_decoder_test_5(void) {
196
197 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
198
199 context.op_mode = FCML_OM_64_BIT;
200 context.effective_address_size = FCML_DS_16;
201
202 fcml_uint8_t buffer[] = {0x14};
203
204 fcml_st_memory_stream stream;
205 stream.base_address = &buffer;
206 stream.size = sizeof( buffer );
207 stream.offset = 0;
208
209 fcml_st_modrm_source modrm_source = {0};
210 modrm_source.ext_B = 0;
211 modrm_source.ext_R = 0;
212 modrm_source.ext_X = 0;
213 modrm_source.stream = &stream;
214 fcml_st_modrm decoded_modrm;
215
216 fcml_st_modrm_details details;
217
218 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
219
220 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
221 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_UNDEFINED );
222 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
223 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, 0 );
224 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
225 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
226 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
227 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, 0 );
228 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
229 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
230 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
231
232 }
233
234 void fcml_tf_modrm_decoder_test_6(void) {
235
236 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
237
238 context.op_mode = FCML_OM_32_BIT;
239 context.effective_address_size = FCML_DS_16;
240
241 fcml_uint8_t buffer[] = {0x73, 0x01};
242
243 fcml_st_memory_stream stream;
244 stream.base_address = &buffer;
245 stream.size = sizeof( buffer );
246 stream.offset = 0;
247
248 fcml_st_modrm_source modrm_source = {0};
249 modrm_source.ext_B = 0;
250 modrm_source.ext_R = 0;
251 modrm_source.ext_X = 0;
252 modrm_source.stream = &stream;
253 fcml_st_modrm decoded_modrm;
254 fcml_st_modrm_details details;
255
256 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
257
258 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
259 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
260 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_BP );
261 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_16 );
262 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
263 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_DI );
264 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_16 );
265 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_SI );
266 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_8 );
267 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int8, 0x01 );
268 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
269 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
270
271 }
272
273 void fcml_tf_modrm_decoder_test_7(void) {
274
275 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
276
277 context.op_mode = FCML_OM_32_BIT;
278 context.effective_address_size = FCML_DS_16;
279
280 fcml_uint8_t buffer[] = {0x73};
281
282 fcml_st_memory_stream stream;
283 stream.base_address = &buffer;
284 stream.size = sizeof( buffer );
285 stream.offset = 0;
286
287 fcml_st_modrm_source modrm_source = {0};
288 modrm_source.ext_B = 0;
289 modrm_source.ext_R = 0;
290 modrm_source.ext_X = 0;
291 modrm_source.stream = &stream;
292 fcml_st_modrm decoded_modrm;
293 fcml_st_modrm_details details;
294
295 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
296
297 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_EOF );
298
299 }
300
301 /* [EBX], EBX*/
302 void fcml_tf_modrm_3264_decoder_test_1(void) {
303
304 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
305
306 context.op_mode = FCML_OM_32_BIT;
307 context.effective_address_size = FCML_DS_32;
308
309 fcml_uint8_t buffer[] = {0x1B};
310
311 fcml_st_memory_stream stream;
312 stream.base_address = &buffer;
313 stream.size = sizeof( buffer );
314 stream.offset = 0;
315
316 fcml_st_modrm_source modrm_source = {0};
317 modrm_source.ext_B = 0;
318 modrm_source.ext_R = 0;
319 modrm_source.ext_X = 0;
320 modrm_source.stream = &stream;
321 fcml_st_modrm decoded_modrm;
322 fcml_st_modrm_details details;
323
324 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
325
326 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
327 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
328 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_EBX );
329 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_32 );
330 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
331 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
332 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
333 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EBX );
334 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
335 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int8, 0 );
336 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
337 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
338
339 }
340
341 /* [04030201], EDX*/
342 void fcml_tf_modrm_3264_decoder_test_2(void) {
343
344 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
345
346 context.op_mode = FCML_OM_32_BIT;
347 context.effective_address_size = FCML_DS_32;
348
349 fcml_uint8_t buffer[] = {0x15, 0x01, 0x02, 0x03, 0x04};
350
351 fcml_st_memory_stream stream;
352 stream.base_address = &buffer;
353 stream.size = sizeof( buffer );
354 stream.offset = 0;
355
356 fcml_st_modrm_source modrm_source = {0};
357 modrm_source.ext_B = 0;
358 modrm_source.ext_R = 0;
359 modrm_source.ext_X = 0;
360 modrm_source.stream = &stream;
361 fcml_st_modrm decoded_modrm;
362 fcml_st_modrm_details details;
363
364 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
365
366 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
367 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_UNDEFINED );
368 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
369 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, 0 );
370 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
371 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
372 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
373 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EDX );
374 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, FCML_DS_32 );
375 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0x04030201 );
376 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_TRUE );
377 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
378 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
379 }
380
381 /* RIP-addressing.*/
382 /* RIP: 401000h*/
383 /* disp32: 0f1efbf00h*/
384 /* [FFFFFFFFFF887766], EDX*/
385 void fcml_tf_modrm_3264_decoder_test_3(void) {
386
387 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
388
389 context.op_mode = FCML_OM_64_BIT;
390 context.effective_address_size = FCML_DS_64;
391
392 fcml_uint8_t buffer[] = {0x15, 0xfa, 0xf1, 0xbf, 0xff};
393
394 fcml_st_memory_stream stream;
395 stream.base_address = &buffer;
396 stream.size = sizeof( buffer );
397 stream.offset = 0;
398
399 fcml_st_modrm_source modrm_source = {0};
400 modrm_source.ext_B = 0;
401 modrm_source.ext_R = 0;
402 modrm_source.ext_X = 0;
403 modrm_source.stream = &stream;
404 fcml_st_modrm decoded_modrm;
405 fcml_st_modrm_details details;
406
407 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
408
409 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
410 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_IP );
411 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
412 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
413 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
414 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
415 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
416 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EDX );
417 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, FCML_DS_32 );
418 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0xFFBFF1FA );
419 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_TRUE );
420 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
421 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
422 STF_ASSERT_EQUAL( decoded_modrm.is_rip, FCML_TRUE );
423
424 fcml_st_offset address = {0};
425 error = fcml_fn_modrm_decode_rip( 0x401000, FCML_DS_64, &(decoded_modrm.address.offset), &address );
426
427 STF_ASSERT_EQUAL( address.size, FCML_DS_64 );
428 STF_ASSERT_EQUAL( address.off64, 0x1faUL );
429
430 }
431
432 /* [ECX]+0x66, EAX*/
433 void fcml_tf_modrm_3264_decoder_test_4(void) {
434
435 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
436
437 context.op_mode = FCML_OM_64_BIT;
438 context.effective_address_size = FCML_DS_32;
439
440 fcml_uint8_t buffer[] = {0x41, 0x66};
441
442 fcml_st_memory_stream stream;
443 stream.base_address = &buffer;
444 stream.size = sizeof( buffer );
445 stream.offset = 0;
446
447 fcml_st_modrm_source modrm_source = {0};
448 modrm_source.ext_B = 0;
449 modrm_source.ext_R = 0;
450 modrm_source.ext_X = 0;
451 modrm_source.stream = &stream;
452 fcml_st_modrm decoded_modrm;
453 fcml_st_modrm_details details;
454
455 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
456
457 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
458 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
459 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_ECX );
460 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_32 );
461 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
462 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
463 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
464 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EAX );
465 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_8 );
466 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int8, 0x66 );
467 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
468 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
469 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
470 }
471
472
473 /* [ECX]+0x01020304, EAX*/
474 void fcml_tf_modrm_3264_decoder_test_5(void) {
475
476 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
477
478 context.op_mode = FCML_OM_64_BIT;
479 context.effective_address_size = FCML_DS_32;
480
481 fcml_uint8_t buffer[] = {0x81, 0x04, 0x03, 0x02, 0x01};
482
483 fcml_st_memory_stream stream;
484 stream.base_address = &buffer;
485 stream.size = sizeof( buffer );
486 stream.offset = 0;
487
488 fcml_st_modrm_source modrm_source = {0};
489 modrm_source.ext_B = 0;
490 modrm_source.ext_R = 0;
491 modrm_source.ext_X = 0;
492 modrm_source.stream = &stream;
493 fcml_st_modrm decoded_modrm;
494 fcml_st_modrm_details details;
495
496 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
497
498 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
499 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
500 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_ECX );
501 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_32 );
502 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
503 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
504 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
505 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EAX );
506 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_32 );
507 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
508 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
509 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
510 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
511 }
512
513 /* [R9]+0x01020304, R8*/
514 void fcml_tf_modrm_3264_decoder_test_6(void) {
515
516 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
517
518 context.op_mode = FCML_OM_64_BIT;
519 context.effective_address_size = FCML_DS_64;
520
521 fcml_uint8_t buffer[] = {0x81, 0x04, 0x03, 0x02, 0x01};
522
523 fcml_st_memory_stream stream;
524 stream.base_address = &buffer;
525 stream.size = sizeof( buffer );
526 stream.offset = 0;
527
528 fcml_st_modrm_source modrm_source = {0};
529 modrm_source.ext_B = 1;
530 modrm_source.ext_R = 1;
531 modrm_source.ext_X = 0;
532 modrm_source.stream = &stream;
533 fcml_st_modrm decoded_modrm;
534 fcml_st_modrm_details details;
535
536 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
537
538 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
539 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
540 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
541 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
542 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
543 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
544 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
545 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
546 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_32 );
547 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
548 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
549 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
550 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
551 }
552
553 /* Illegal EASA size.*/
554 void fcml_tf_modrm_3264_decoder_test_7(void) {
555
556 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
557
558 context.op_mode = FCML_OM_64_BIT;
559 context.effective_address_size = FCML_DS_16;
560
561 fcml_uint8_t buffer[] = {0x81, 0x04, 0x03, 0x02, 0x01};
562
563 fcml_st_memory_stream stream;
564 stream.base_address = &buffer;
565 stream.size = sizeof( buffer );
566 stream.offset = 0;
567
568 fcml_st_modrm_source modrm_source = {0};
569 modrm_source.ext_B = 1;
570 modrm_source.ext_R = 1;
571 modrm_source.ext_X = 0;
572 modrm_source.stream = &stream;
573 fcml_st_modrm decoded_modrm;
574 fcml_st_modrm_details details;
575
576 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
577
578 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
579 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_UNDEFINED );
580 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
581 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, 0 );
582 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
583 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
584 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
585 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, 0 );
586 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
587 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
588 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
589 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
590 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0 );
591 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
592 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
593 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
594 }
595
596 /* RAX, EBX*/
597 void fcml_tf_modrm_3264_decoder_test_8(void) {
598
599 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
600
601 context.op_mode = FCML_OM_64_BIT;
602 context.effective_address_size = FCML_DS_64;
603
604 fcml_uint8_t buffer[] = {0xD8};
605
606 fcml_st_memory_stream stream;
607 stream.base_address = &buffer;
608 stream.size = sizeof( buffer );
609 stream.offset = 0;
610
611 fcml_st_modrm_source modrm_source = {0};
612 modrm_source.ext_B = 0;
613 modrm_source.ext_R = 0;
614 modrm_source.ext_X = 0;
615 modrm_source.stream = &stream;
616 fcml_st_modrm decoded_modrm;
617 fcml_st_modrm_details details;
618
619 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
620
621 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
622 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_RAX );
623 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_TRUE );
624 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
625 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
626 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
627 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_RBX );
628 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
629 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
630 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
631 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, 0 );
632 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0 );
633 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
634 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
635 }
636
637 /* R8, R11*/
638 void fcml_tf_modrm_3264_decoder_test_9(void) {
639
640 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
641
642 context.op_mode = FCML_OM_64_BIT;
643 context.effective_address_size = FCML_DS_64;
644
645 fcml_uint8_t buffer[] = {0xD8};
646
647 fcml_st_memory_stream stream;
648 stream.base_address = &buffer;
649 stream.size = sizeof( buffer );
650 stream.offset = 0;
651
652 fcml_st_modrm_source modrm_source = {0};
653 modrm_source.ext_B = 1;
654 modrm_source.ext_R = 1;
655 modrm_source.ext_X = 0;
656 modrm_source.stream = &stream;
657 fcml_st_modrm decoded_modrm;
658 fcml_st_modrm_details details;
659
660 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
661
662 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
663 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_R8 );
664 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_TRUE );
665 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
666 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
667 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
668 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R11 );
669 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
670 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
671 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
672 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, 0 );
673 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off64, 0 );
674 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
675 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
676 }
677
678
679 /* RIP-addressing.*/
680 void fcml_tf_modrm_3264_decoder_test_10(void) {
681
682 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
683
684 context.op_mode = FCML_OM_64_BIT;
685 context.effective_address_size = FCML_DS_64;
686
687 fcml_uint8_t buffer[] = {0x15, 0xff, 0xff, 0xff, 0xff};
688
689 fcml_st_memory_stream stream;
690 stream.base_address = &buffer;
691 stream.size = sizeof( buffer );
692 stream.offset = 0;
693
694 fcml_st_modrm_source modrm_source = {0};
695 modrm_source.ext_B = 0;
696 modrm_source.ext_R = 0;
697 modrm_source.ext_X = 0;
698 modrm_source.stream = &stream;
699 fcml_st_modrm decoded_modrm;
700 fcml_st_modrm_details details;
701
702 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
703
704 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
705 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_IP );
706 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
707 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
708 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
709 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
710 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
711 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EDX );
712 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, FCML_DS_32 );
713 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0xFFFFFFFF );
714 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_TRUE );
715 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
716 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
717 STF_ASSERT_EQUAL( decoded_modrm.is_rip, FCML_TRUE );
718
719 fcml_st_offset address = {0};
720 error = fcml_fn_modrm_decode_rip( 0x401000, FCML_DS_64, &(decoded_modrm.address.offset), &address );
721
722 STF_ASSERT_EQUAL( address.size, FCML_DS_64 );
723 STF_ASSERT_EQUAL( address.off64, 0x400fffUL );
724
725 }
726
727 /* RIP-addressing.*/
728 void fcml_tf_modrm_3264_decoder_test_11(void) {
729
730 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
731
732 context.op_mode = FCML_OM_64_BIT;
733 context.effective_address_size = FCML_DS_64;
734
735 fcml_uint8_t buffer[] = {0x15, 0x00, 0xE0, 0x7F, 0xFF};
736
737 fcml_st_memory_stream stream;
738 stream.base_address = &buffer;
739 stream.size = sizeof( buffer );
740 stream.offset = 0;
741
742 fcml_st_modrm_source modrm_source = {0};
743 modrm_source.ext_B = 0;
744 modrm_source.ext_R = 0;
745 modrm_source.ext_X = 0;
746 modrm_source.stream = &stream;
747 fcml_st_modrm decoded_modrm;
748 fcml_st_modrm_details details;
749
750 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
751
752 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
753 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_IP );
754 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
755 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
756 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
757 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
758 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
759 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EDX );
760 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, FCML_DS_32 );
761 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0xFF7FE000 );
762 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_TRUE );
763 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
764 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
765 STF_ASSERT_EQUAL( decoded_modrm.is_rip, FCML_TRUE );
766
767 fcml_st_offset address = {0};
768 error = fcml_fn_modrm_decode_rip( 0x401000, FCML_DS_64, &(decoded_modrm.address.offset), &address );
769
770 STF_ASSERT_EQUAL( address.size, FCML_DS_64 );
771 STF_ASSERT_EQUAL( address.off64, 0xffffffffffbff000UL );
772
773 }
774
775 /* RIP-addressing.*/
776 void fcml_tf_modrm_3264_decoder_test_12(void) {
777
778 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
779
780 context.op_mode = FCML_OM_64_BIT;
781 context.effective_address_size = FCML_DS_32;
782
783 fcml_uint8_t buffer[] = {0x15, 0x00, 0xE0, 0x7F, 0xFF};
784
785 fcml_st_memory_stream stream;
786 stream.base_address = &buffer;
787 stream.size = sizeof( buffer );
788 stream.offset = 0;
789
790 fcml_st_modrm_source modrm_source = {0};
791 modrm_source.ext_B = 0;
792 modrm_source.ext_R = 0;
793 modrm_source.ext_X = 0;
794 modrm_source.stream = &stream;
795 fcml_st_modrm decoded_modrm;
796 fcml_st_modrm_details details;
797
798 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
799
800 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
801 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_IP );
802 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
803 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
804 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
805 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
806 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
807 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_EDX );
808 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, FCML_DS_32 );
809 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0xFF7FE000 );
810 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_TRUE );
811 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
812 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
813 STF_ASSERT_EQUAL( decoded_modrm.is_rip, FCML_TRUE );
814
815 fcml_st_offset address = {0};
816 error = fcml_fn_modrm_decode_rip( 0x401000, FCML_DS_32, &(decoded_modrm.address.offset), &address );
817
818 STF_ASSERT_EQUAL( address.size, FCML_DS_64 );
819 STF_ASSERT_EQUAL( address.off64, 0x00000000ffbff000UL );
820
821 }
822
823 /* [01020304], R8*/
824 void fcml_tf_modrm_3264_decoder_sib_test_1(void) {
825
826 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
827
828 context.op_mode = FCML_OM_64_BIT;
829 context.effective_address_size = FCML_DS_64;
830
831 fcml_uint8_t buffer[] = { 0x04, 0x25, 0x04, 0x03, 0x02, 0x01 };
832
833 fcml_st_memory_stream stream;
834 stream.base_address = &buffer;
835 stream.size = sizeof( buffer );
836 stream.offset = 0;
837
838 fcml_st_modrm_source modrm_source = {0};
839 modrm_source.ext_B = 1;
840 modrm_source.ext_R = 1;
841 modrm_source.ext_X = 0;
842 modrm_source.stream = &stream;
843 fcml_st_modrm decoded_modrm;
844 fcml_st_modrm_details details;
845
846 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
847
848 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
849 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
850 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
851 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_UNDEFINED );
852 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
853 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, 0 );
854 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
855 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
856 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
857 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
858 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, FCML_DS_64 );
859 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off64, 0x01020304 );
860 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_TRUE );
861 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
862 }
863
864 /* [EBX]+0x01020304, R8*/
865 void fcml_tf_modrm_3264_decoder_sib_test_2(void) {
866
867 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
868
869 context.op_mode = FCML_OM_64_BIT;
870 context.effective_address_size = FCML_DS_64;
871
872 fcml_uint8_t buffer[] = { 0x04, 0x1D, 0x04, 0x03, 0x02, 0x01 };
873
874 fcml_st_memory_stream stream;
875 stream.base_address = &buffer;
876 stream.size = sizeof( buffer );
877 stream.offset = 0;
878
879 fcml_st_modrm_source modrm_source = {0};
880 modrm_source.ext_B = 0;
881 modrm_source.ext_R = 1;
882 modrm_source.ext_X = 1;
883 modrm_source.stream = &stream;
884 fcml_st_modrm decoded_modrm;
885 fcml_st_modrm_details details;
886
887 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
888
889 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
890 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
891 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
892 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_UNDEFINED );
893 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, 0 );
894 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, 0 );
895 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
896 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
897 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
898 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
899 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 32 );
900 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
901 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
902 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
903 }
904
905 /* [ECX+EBX]+0x01, R8*/
906 void fcml_tf_modrm_3264_decoder_sib_test_3(void) {
907
908 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
909
910 context.op_mode = FCML_OM_64_BIT;
911 context.effective_address_size = FCML_DS_64;
912
913 fcml_uint8_t buffer[] = { 0x04, 0x19 };
914
915 fcml_st_memory_stream stream;
916 stream.base_address = &buffer;
917 stream.size = sizeof( buffer );
918 stream.offset = 0;
919
920 fcml_st_modrm_source modrm_source = {0};
921 modrm_source.ext_B = 1;
922 modrm_source.ext_R = 1;
923 modrm_source.ext_X = 1;
924 modrm_source.stream = &stream;
925 fcml_st_modrm decoded_modrm;
926 fcml_st_modrm_details details;
927
928 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
929
930 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
931 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
932 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
933 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
934 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
935 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
936 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
937 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
938 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
939 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
940 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
941 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
942 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
943 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, 0 );
944 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0 );
945 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
946 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
947 }
948
949 /* [ECX+EBX*2]+0x01, R8*/
950 void fcml_tf_modrm_3264_decoder_sib_test_4(void) {
951
952 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
953
954 context.op_mode = FCML_OM_64_BIT;
955 context.effective_address_size = FCML_DS_64;
956
957 fcml_uint8_t buffer[] = { 0x04, 0x59 };
958
959 fcml_st_memory_stream stream;
960 stream.base_address = &buffer;
961 stream.size = sizeof( buffer );
962 stream.offset = 0;
963
964 fcml_st_modrm_source modrm_source = {0};
965 modrm_source.ext_B = 1;
966 modrm_source.ext_R = 1;
967 modrm_source.ext_X = 1;
968 modrm_source.stream = &stream;
969 fcml_st_modrm decoded_modrm;
970 fcml_st_modrm_details details;
971
972 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
973
974 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
975 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
976 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
977 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
978 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
979 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
980 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
981 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
982 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
983 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
984 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
985 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
986 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
987 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, 0 );
988 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0 );
989 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
990 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 2 );
991 }
992
993 /* [ECX+EBX*4], R8*/
994 void fcml_tf_modrm_3264_decoder_sib_test_5(void) {
995
996 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
997
998 context.op_mode = FCML_OM_64_BIT;
999 context.effective_address_size = FCML_DS_64;
1000
1001 fcml_uint8_t buffer[] = { 0x04, 0x99 };
1002
1003 fcml_st_memory_stream stream;
1004 stream.base_address = &buffer;
1005 stream.size = sizeof( buffer );
1006 stream.offset = 0;
1007
1008 fcml_st_modrm_source modrm_source = {0};
1009 modrm_source.ext_B = 1;
1010 modrm_source.ext_R = 1;
1011 modrm_source.ext_X = 1;
1012 modrm_source.stream = &stream;
1013 fcml_st_modrm decoded_modrm;
1014 fcml_st_modrm_details details;
1015
1016 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1017
1018 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1019 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1020 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1021 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1022 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1023 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1024 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
1025 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
1026 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
1027 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1028 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
1029 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
1030 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
1031 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, 0 );
1032 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0 );
1033 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
1034 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 4 );
1035 }
1036
1037 /* [ECX+EBX*8], R8*/
1038 void fcml_tf_modrm_3264_decoder_sib_test_6(void) {
1039
1040 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1041
1042 context.op_mode = FCML_OM_64_BIT;
1043 context.effective_address_size = FCML_DS_64;
1044
1045 fcml_uint8_t buffer[] = { 0x04, 0xD9 };
1046
1047 fcml_st_memory_stream stream;
1048 stream.base_address = &buffer;
1049 stream.size = sizeof( buffer );
1050 stream.offset = 0;
1051
1052 fcml_st_modrm_source modrm_source = {0};
1053 modrm_source.ext_B = 1;
1054 modrm_source.ext_R = 1;
1055 modrm_source.ext_X = 1;
1056 modrm_source.stream = &stream;
1057 fcml_st_modrm decoded_modrm;
1058 fcml_st_modrm_details details;
1059
1060 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1061
1062 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1063 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1064 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1065 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1066 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1067 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1068 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
1069 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
1070 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
1071 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1072 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, 0 );
1073 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0 );
1074 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_FALSE );
1075 STF_ASSERT_EQUAL( decoded_modrm.address.offset.size, 0 );
1076 STF_ASSERT_EQUAL( decoded_modrm.address.offset.off32, 0 );
1077 STF_ASSERT_EQUAL( decoded_modrm.address.offset.is_signed, FCML_FALSE );
1078 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 8 );
1079 }
1080
1081 /* [ECX+EBX*8]+0x55, R8*/
1082 void fcml_tf_modrm_3264_decoder_sib_test_7(void) {
1083
1084 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1085
1086 context.op_mode = FCML_OM_64_BIT;
1087 context.effective_address_size = FCML_DS_64;
1088
1089 fcml_uint8_t buffer[] = { 0x44, 0xD9, 0x55 };
1090
1091 fcml_st_memory_stream stream;
1092 stream.base_address = &buffer;
1093 stream.size = sizeof( buffer );
1094 stream.offset = 0;
1095
1096 fcml_st_modrm_source modrm_source = {0};
1097 modrm_source.ext_B = 1;
1098 modrm_source.ext_R = 1;
1099 modrm_source.ext_X = 1;
1100 modrm_source.stream = &stream;
1101 fcml_st_modrm decoded_modrm;
1102 fcml_st_modrm_details details;
1103
1104 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1105
1106 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1107 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1108 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1109 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1110 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1111 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1112 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
1113 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
1114 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
1115 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1116 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_8 );
1117 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int8, 0x55 );
1118 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
1119 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 8 );
1120 }
1121
1122 /* [ECX+EBX*8]+0x01020304, R8*/
1123 void fcml_tf_modrm_3264_decoder_sib_test_8(void) {
1124
1125 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1126
1127 context.op_mode = FCML_OM_64_BIT;
1128 context.effective_address_size = FCML_DS_64;
1129
1130 fcml_uint8_t buffer[] = { 0x84, 0xD9, 0x04, 0x03, 0x02, 0x01 };
1131
1132 fcml_st_memory_stream stream;
1133 stream.base_address = &buffer;
1134 stream.size = sizeof( buffer );
1135 stream.offset = 0;
1136
1137 fcml_st_modrm_source modrm_source = {0};
1138 modrm_source.ext_B = 1;
1139 modrm_source.ext_R = 1;
1140 modrm_source.ext_X = 1;
1141 modrm_source.stream = &stream;
1142 fcml_st_modrm decoded_modrm;
1143 fcml_st_modrm_details details;
1144
1145 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1146
1147 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1148 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1149 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1150 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1151 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1152 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1153 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_GPR );
1154 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_R11 );
1155 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_64 );
1156 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1157 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_32 );
1158 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
1159 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
1160 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 8 );
1161 }
1162
1163 /* [R9]+0x01020304, R8*/
1164 void fcml_tf_modrm_3264_decoder_sib_test_9(void) {
1165
1166 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1167
1168 context.op_mode = FCML_OM_64_BIT;
1169 context.effective_address_size = FCML_DS_64;
1170
1171 fcml_uint8_t buffer[] = { 0x84, 0xE1, 0x04, 0x03, 0x02, 0x01 };
1172
1173 fcml_st_memory_stream stream;
1174 stream.base_address = &buffer;
1175 stream.size = sizeof( buffer );
1176 stream.offset = 0;
1177
1178 fcml_st_modrm_source modrm_source = {0};
1179 modrm_source.ext_B = 1;
1180 modrm_source.ext_R = 1;
1181 modrm_source.ext_X = 1;
1182 modrm_source.stream = &stream;
1183 fcml_st_modrm decoded_modrm;
1184 fcml_st_modrm_details details;
1185
1186 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1187
1188 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1189 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1190 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1191 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1192 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1193 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1194 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_UNDEFINED );
1195 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, 0 );
1196 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, 0 );
1197 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1198 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_32 );
1199 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
1200 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
1201 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 0 );
1202 }
1203
1204 /* [ECX+XMM1*8]+0x01020304, R8*/
1205 void fcml_tf_modrm_3264_decoder_sib_test_10(void) {
1206
1207 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1208
1209 context.op_mode = FCML_OM_64_BIT;
1210 context.effective_address_size = FCML_DS_64;
1211
1212 fcml_uint8_t buffer[] = { 0x84, 0xD9, 0x04, 0x03, 0x02, 0x01 };
1213
1214 fcml_st_memory_stream stream;
1215 stream.base_address = &buffer;
1216 stream.size = sizeof( buffer );
1217 stream.offset = 0;
1218
1219 fcml_st_modrm_source modrm_source = {0};
1220 modrm_source.ext_B = 1;
1221 modrm_source.ext_R = 1;
1222 modrm_source.ext_X = 1;
1223 modrm_source.stream = &stream;
1224 modrm_source.is_vsib = FCML_TRUE;
1225 modrm_source.vsib_index_size = FCML_DS_128;
1226 fcml_st_modrm decoded_modrm;
1227 fcml_st_modrm_details details;
1228
1229 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1230
1231 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1232 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1233 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1234 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1235 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1236 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1237 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_SIMD );
1238 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_XMM11 );
1239 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_128 );
1240 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1241 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_32 );
1242 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
1243 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
1244 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 8 );
1245 }
1246
1247 /* [ECX+YMM1*8]+0x01020304, R8*/
1248 void fcml_tf_modrm_3264_decoder_sib_test_11(void) {
1249
1250 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1251
1252 context.op_mode = FCML_OM_64_BIT;
1253 context.effective_address_size = FCML_DS_64;
1254
1255 fcml_uint8_t buffer[] = { 0x84, 0xD9, 0x04, 0x03, 0x02, 0x01 };
1256
1257 fcml_st_memory_stream stream;
1258 stream.base_address = &buffer;
1259 stream.size = sizeof( buffer );
1260 stream.offset = 0;
1261
1262 fcml_st_modrm_source modrm_source = {0};
1263 modrm_source.ext_B = 1;
1264 modrm_source.ext_R = 1;
1265 modrm_source.ext_X = 1;
1266 modrm_source.stream = &stream;
1267 modrm_source.is_vsib = FCML_TRUE;
1268 modrm_source.vsib_index_size = FCML_DS_256;
1269 fcml_st_modrm decoded_modrm;
1270 fcml_st_modrm_details details;
1271
1272 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source, &decoded_modrm, &details, 0 );
1273
1274 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1275 STF_ASSERT_EQUAL( decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1276 STF_ASSERT_EQUAL( decoded_modrm.reg.is_not_null, FCML_FALSE );
1277 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.type, FCML_REG_GPR );
1278 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.reg, FCML_REG_R9 );
1279 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.base.size, FCML_DS_64 );
1280 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.type, FCML_REG_SIMD );
1281 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.reg, FCML_REG_XMM11 );
1282 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.index.size, FCML_DS_256 );
1283 STF_ASSERT_EQUAL( decoded_modrm.reg_opcode, FCML_REG_R8 );
1284 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.size, FCML_DS_32 );
1285 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.int32, 0x01020304 );
1286 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.displacement.is_signed, FCML_TRUE );
1287 STF_ASSERT_EQUAL( decoded_modrm.address.effective_address.scale_factor, 8 );
1288 }
1289
1290 void fcml_tf_modrm_3264_decoder_sib_test_compressed_disp8(void) {
1291
1292 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1293
1294 context.op_mode = FCML_OM_64_BIT;
1295 context.effective_address_size = FCML_DS_64;
1296 context.input_size = FCML_DS_32;
1297 context.vector_length = FCML_DS_128;
1298 context.is_evex = FCML_TRUE;
1299 context.tuple_type = FCML_TT_FV;
1300 context.b = FCML_TRUE;
1301
1302 fcml_uint8_t buffer[] = { 0x4C, 0x24, 0x08 };
1303
1304 fcml_st_memory_stream stream;
1305 stream.base_address = &buffer;
1306 stream.size = sizeof( buffer );
1307 stream.offset = 0;
1308
1309 fcml_st_modrm_source modrm_source = {0};
1310 modrm_source.ext_B = 0;
1311 modrm_source.ext_R = 0;
1312 modrm_source.ext_X = 0;
1313 modrm_source.stream = &stream;
1314
1315 fcml_st_modrm decoded_modrm;
1316 fcml_st_modrm_details details;
1317
1318 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source,
1319 &decoded_modrm, &details, 0 );
1320
1321 STF_ASSERT_EQUAL(error, FCML_CEH_GEC_NO_ERROR );
1322 STF_ASSERT_EQUAL(decoded_modrm.reg.value, FCML_REG_UNDEFINED );
1323 STF_ASSERT_EQUAL(decoded_modrm.reg.is_not_null, FCML_FALSE );
1324 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.base.type,
1325 FCML_REG_GPR );
1326 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.base.reg,
1327 FCML_REG_RSP );
1328 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.base.size,
1329 FCML_DS_64 );
1330 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.type,
1331 FCML_REG_UNDEFINED );
1332 STF_ASSERT_EQUAL(decoded_modrm.reg_opcode, FCML_REG_XMM1 );
1333 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement.size,
1334 FCML_DS_32);
1335 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement.int32,
1336 32);
1337 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement
1338 .is_signed, FCML_TRUE);
1339 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.scale_factor, 0);
1340
1341 STF_ASSERT_EQUAL(details.displacement.displacement.int8, 8);
1342 STF_ASSERT_EQUAL(details.displacement.displacement.size, FCML_DS_8);
1343 STF_ASSERT_EQUAL(details.displacement.displacement.is_signed, FCML_TRUE);
1344 STF_ASSERT_EQUAL(details.displacement.N.is_not_null, FCML_TRUE);
1345 STF_ASSERT_EQUAL(details.displacement.N.value, 4);
1346 }
1347
1348 /* [ECX+ZMM17*8]+0x01020304, ZMM24 */
1349 void fcml_tf_modrm_3264_decoder_sib_vsib_evex_test(void) {
1350
1351 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1352
1353 context.op_mode = FCML_OM_64_BIT;
1354 context.effective_address_size = FCML_DS_64;
1355 context.is_evex = FCML_TRUE;
1356
1357 fcml_uint8_t buffer[] = { 0x84, 0xD9, 0x04, 0x03, 0x02, 0x01 };
1358
1359 fcml_st_memory_stream stream;
1360 stream.base_address = &buffer;
1361 stream.size = sizeof(buffer);
1362 stream.offset = 0;
1363
1364 fcml_st_modrm_source modrm_source = {0};
1365 modrm_source.ext_B = 1;
1366 modrm_source.ext_R = 1;
1367 modrm_source.ext_R_prim = 1;
1368 modrm_source.ext_X = 1;
1369 modrm_source.ext_V_prim = 1;
1370 modrm_source.stream = &stream;
1371 modrm_source.is_vsib = FCML_TRUE;
1372 modrm_source.vsib_index_size = FCML_DS_512;
1373 fcml_st_modrm decoded_modrm;
1374 fcml_st_modrm_details details;
1375
1376 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source,
1377 &decoded_modrm, &details, 0 );
1378
1379 STF_ASSERT_EQUAL(error, FCML_CEH_GEC_NO_ERROR);
1380 STF_ASSERT_EQUAL(decoded_modrm.reg.value, FCML_REG_UNDEFINED);
1381 STF_ASSERT_EQUAL(decoded_modrm.reg.is_not_null, FCML_FALSE);
1382 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.base.type,
1383 FCML_REG_GPR);
1384 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.base.reg,
1385 FCML_REG_R9);
1386 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.base.size,
1387 FCML_DS_64);
1388 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.type,
1389 FCML_REG_SIMD);
1390 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.reg,
1391 FCML_REG_XMM27);
1392 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.size,
1393 FCML_DS_512);
1394 STF_ASSERT_EQUAL(decoded_modrm.reg_opcode, FCML_REG_ZMM24);
1395 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement.size,
1396 FCML_DS_32);
1397 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement.int32,
1398 0x01020304 );
1399 STF_ASSERT_EQUAL(
1400 decoded_modrm.address.effective_address.displacement.is_signed,
1401 FCML_TRUE );
1402 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.scale_factor, 8);
1403 }
1404
1405 /* ZMM24, MM27*/
1406 void fcml_tf_modrm_3264_decoder_EVEX_extended_reg_test(void) {
1407
1408 fcml_st_modrm_decoder_context context = fcml_ifn_modrm_decoder_alloc_ctx();
1409
1410 context.op_mode = FCML_OM_64_BIT;
1411 context.effective_address_size = FCML_DS_64;
1412 context.is_evex = FCML_TRUE;
1413
1414 fcml_uint8_t buffer[] = {0xD8};
1415
1416 fcml_st_memory_stream stream;
1417 stream.base_address = &buffer;
1418 stream.size = sizeof( buffer );
1419 stream.offset = 0;
1420
1421 fcml_st_modrm_source modrm_source = {0};
1422 modrm_source.ext_B = 1;
1423 modrm_source.ext_R = 1;
1424 modrm_source.ext_R_prim = 1;
1425 modrm_source.ext_X = 1;
1426 modrm_source.stream = &stream;
1427 fcml_st_modrm decoded_modrm;
1428 fcml_st_modrm_details details;
1429
1430 fcml_ceh_error error = fcml_fn_modrm_decode( &context, &modrm_source,
1431 &decoded_modrm, &details, 0);
1432
1433 STF_ASSERT_EQUAL(error, FCML_CEH_GEC_NO_ERROR);
1434 STF_ASSERT_EQUAL(decoded_modrm.reg.value, FCML_REG_ZMM24);
1435 STF_ASSERT_EQUAL(decoded_modrm.reg.is_not_null, FCML_TRUE);
1436 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.type,
1437 FCML_REG_UNDEFINED);
1438 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.reg, 0 );
1439 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.index.size, 0 );
1440 STF_ASSERT_EQUAL(decoded_modrm.reg_opcode, FCML_REG_ZMM27);
1441 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement
1442 .size,0);
1443 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement
1444 .int32, 0);
1445 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.displacement
1446 .is_signed, FCML_FALSE);
1447 STF_ASSERT_EQUAL(decoded_modrm.address.offset.size, 0);
1448 STF_ASSERT_EQUAL(decoded_modrm.address.offset.off32, 0);
1449 STF_ASSERT_EQUAL(decoded_modrm.address.offset.is_signed, FCML_FALSE);
1450 STF_ASSERT_EQUAL(decoded_modrm.address.effective_address.scale_factor, 0);
1451 }
1452
1453 fcml_stf_test_case fctl_ti_modrm_decoder[] = {
1454 { "fcml_tf_modrm_decoder_test_1", fcml_tf_modrm_decoder_test_1 },
1455 { "fcml_tf_modrm_decoder_test_2", fcml_tf_modrm_decoder_test_2 },
1456 { "fcml_tf_modrm_decoder_test_3", fcml_tf_modrm_decoder_test_3 },
1457 { "fcml_tf_modrm_decoder_test_4", fcml_tf_modrm_decoder_test_4 },
1458 { "fcml_tf_modrm_decoder_test_5", fcml_tf_modrm_decoder_test_5 },
1459 { "fcml_tf_modrm_decoder_test_6", fcml_tf_modrm_decoder_test_6 },
1460 { "fcml_tf_modrm_decoder_test_7", fcml_tf_modrm_decoder_test_7 },
1461 { "fcml_tf_modrm_3264_decoder_test_1", fcml_tf_modrm_3264_decoder_test_1 },
1462 { "fcml_tf_modrm_3264_decoder_test_2", fcml_tf_modrm_3264_decoder_test_2 },
1463 { "fcml_tf_modrm_3264_decoder_test_3", fcml_tf_modrm_3264_decoder_test_3 },
1464 { "fcml_tf_modrm_3264_decoder_test_4", fcml_tf_modrm_3264_decoder_test_4 },
1465 { "fcml_tf_modrm_3264_decoder_test_5", fcml_tf_modrm_3264_decoder_test_5 },
1466 { "fcml_tf_modrm_3264_decoder_test_6", fcml_tf_modrm_3264_decoder_test_6 },
1467 { "fcml_tf_modrm_3264_decoder_test_7", fcml_tf_modrm_3264_decoder_test_7 },
1468 { "fcml_tf_modrm_3264_decoder_test_8", fcml_tf_modrm_3264_decoder_test_8 },
1469 { "fcml_tf_modrm_3264_decoder_test_9", fcml_tf_modrm_3264_decoder_test_9 },
1470 { "fcml_tf_modrm_3264_decoder_test_10", fcml_tf_modrm_3264_decoder_test_10 },
1471 { "fcml_tf_modrm_3264_decoder_test_11", fcml_tf_modrm_3264_decoder_test_11 },
1472 { "fcml_tf_modrm_3264_decoder_test_12", fcml_tf_modrm_3264_decoder_test_12 },
1473 { "fcml_tf_modrm_3264_decoder_sib_test_1", fcml_tf_modrm_3264_decoder_sib_test_1 },
1474 { "fcml_tf_modrm_3264_decoder_sib_test_2", fcml_tf_modrm_3264_decoder_sib_test_2 },
1475 { "fcml_tf_modrm_3264_decoder_sib_test_3", fcml_tf_modrm_3264_decoder_sib_test_3 },
1476 { "fcml_tf_modrm_3264_decoder_sib_test_4", fcml_tf_modrm_3264_decoder_sib_test_4 },
1477 { "fcml_tf_modrm_3264_decoder_sib_test_5", fcml_tf_modrm_3264_decoder_sib_test_5 },
1478 { "fcml_tf_modrm_3264_decoder_sib_test_6", fcml_tf_modrm_3264_decoder_sib_test_6 },
1479 { "fcml_tf_modrm_3264_decoder_sib_test_7", fcml_tf_modrm_3264_decoder_sib_test_7 },
1480 { "fcml_tf_modrm_3264_decoder_sib_test_8", fcml_tf_modrm_3264_decoder_sib_test_8 },
1481 { "fcml_tf_modrm_3264_decoder_sib_test_9", fcml_tf_modrm_3264_decoder_sib_test_9 },
1482 { "fcml_tf_modrm_3264_decoder_sib_test_10", fcml_tf_modrm_3264_decoder_sib_test_10 },
1483 { "fcml_tf_modrm_3264_decoder_sib_test_11", fcml_tf_modrm_3264_decoder_sib_test_11 },
1484 { "fcml_tf_modrm_3264_decoder_sib_test_compressed_disp8",
1485 fcml_tf_modrm_3264_decoder_sib_test_compressed_disp8},
1486 { "fcml_tf_modrm_3264_decoder_sib_vsib_evex_test",
1487 fcml_tf_modrm_3264_decoder_sib_vsib_evex_test},
1488 { "fcml_tf_modrm_3264_decoder_EVEX_extended_reg_test",
1489 fcml_tf_modrm_3264_decoder_EVEX_extended_reg_test},
1490 FCML_STF_NULL_TEST
1491 };
1492
1493 fcml_stf_test_suite fctl_si_modrm_decoder = {
1494 "suite-modrm", fcml_tf_modrm_decoder_suite_init, fcml_tf_modrm_decoder_suite_cleanup, fctl_ti_modrm_decoder
1495 };
1496
1497
1498