Debian Codegraph @

check/internal-tests/modrm_encoder_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_encoder_t.h"
21
22 #include <fcml_env_int.h>
23 #include <fcml_modrm_encoder.h>
24 #include <fcml_errors.h>
25 #include <fcml_common.h>
26
27 fcml_bool fcml_tf_modrm_encoder_suite_init(void) {
28 return FCML_TRUE;
29 }
30
31 fcml_bool fcml_tf_modrm_encoder_suite_cleanup(void) {
32 return FCML_TRUE;
33 }
34
35 /* [EAX]*/
36 void fcml_tf_modrm_encoder_test_1(void) {
37
38 fcml_flags effective_address_size;
39
40 fcml_st_modrm modrm;
41 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
42
43 modrm.address.effective_address.base.type = FCML_REG_GPR;
44 modrm.address.effective_address.base.reg = FCML_REG_EAX;
45 modrm.address.effective_address.base.size = FCML_DS_32;
46
47 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
48
49 STF_ASSERT_EQUAL( effective_address_size, FCML_EN_ASF_32 );
50 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
51 }
52
53 /* [RAX]*/
54 void fcml_tf_modrm_encoder_test_2(void) {
55
56 fcml_flags effective_address_size;
57
58 fcml_st_modrm modrm;
59 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
60
61 modrm.address.effective_address.base.type = FCML_REG_GPR;
62 modrm.address.effective_address.base.reg = FCML_REG_RAX;
63 modrm.address.effective_address.base.size = FCML_DS_64;
64
65 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
66
67 STF_ASSERT_EQUAL( effective_address_size, FCML_EN_ASF_64 );
68 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
69 }
70
71 /* [AX]*/
72 void fcml_tf_modrm_encoder_test_3(void) {
73
74 fcml_flags effective_address_size;
75
76 fcml_st_modrm modrm;
77 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
78
79 modrm.address.effective_address.base.type = FCML_REG_GPR;
80 modrm.address.effective_address.base.reg = FCML_REG_AX;
81 modrm.address.effective_address.base.size = FCML_DS_16;
82
83 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
84
85 STF_ASSERT_EQUAL( effective_address_size, FCML_EN_ASF_16 );
86 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
87 }
88
89
90 /* SIB index [AX]*/
91 void fcml_tf_modrm_encoder_test_4(void) {
92
93 fcml_flags effective_address_size;
94
95 fcml_st_modrm modrm;
96 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
97
98 modrm.address.effective_address.index.type = FCML_REG_GPR;
99 modrm.address.effective_address.index.reg = FCML_REG_AX;
100 modrm.address.effective_address.index.size = FCML_DS_16;
101
102 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
103
104 STF_ASSERT_EQUAL( effective_address_size, FCML_EN_ASF_16 );
105 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
106 }
107
108 /* SIB index [EAX]*/
109 void fcml_tf_modrm_encoder_test_5(void) {
110
111 fcml_flags effective_address_size;
112
113 fcml_st_modrm modrm;
114 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
115
116 modrm.address.effective_address.index.type = FCML_REG_GPR;
117 modrm.address.effective_address.index.reg = FCML_REG_EAX;
118 modrm.address.effective_address.index.size = FCML_DS_32;
119
120 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
121
122 STF_ASSERT_EQUAL( effective_address_size, FCML_EN_ASF_32 );
123 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
124 }
125
126 /* SIB index [RAX]*/
127 void fcml_tf_modrm_encoder_test_6(void) {
128
129 fcml_flags effective_address_size;
130
131 fcml_st_modrm modrm;
132 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
133
134 modrm.address.effective_address.index.type = FCML_REG_GPR;
135 modrm.address.effective_address.index.reg = FCML_REG_RAX;
136 modrm.address.effective_address.index.size = FCML_DS_64;
137
138 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
139
140 STF_ASSERT_EQUAL( effective_address_size, FCML_EN_ASF_64 );
141 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
142 }
143
144 /* displacement 8*/
145 void fcml_tf_modrm_encoder_test_7(void) {
146
147 fcml_flags effective_address_size;
148
149 fcml_st_modrm modrm;
150 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
151
152 modrm.address.effective_address.displacement.size = FCML_DS_8;
153
154 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
155
156 STF_ASSERT( effective_address_size & FCML_EN_ASF_16 );
157 STF_ASSERT( effective_address_size & FCML_EN_ASF_32 );
158 STF_ASSERT( effective_address_size & FCML_EN_ASF_64 );
159 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
160 }
161
162 /* displacement 16*/
163 void fcml_tf_modrm_encoder_test_8(void) {
164
165 fcml_flags effective_address_size;
166
167 fcml_st_modrm modrm;
168 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
169
170 modrm.address.effective_address.displacement.size = FCML_DS_16;
171
172 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
173
174 STF_ASSERT( effective_address_size & FCML_EN_ASF_16 );
175 STF_ASSERT( effective_address_size & FCML_EN_ASF_32 );
176 STF_ASSERT( effective_address_size & FCML_EN_ASF_64 );
177 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
178 }
179
180 /* displacement 64*/
181 void fcml_tf_modrm_encoder_test_9(void) {
182
183 fcml_flags effective_address_size;
184
185 fcml_st_modrm modrm;
186 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
187
188 modrm.address.effective_address.displacement.size = FCML_DS_32;
189
190 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
191
192 STF_ASSERT( effective_address_size & FCML_EN_ASF_16 );
193 STF_ASSERT( effective_address_size & FCML_EN_ASF_32 );
194 STF_ASSERT( effective_address_size & FCML_EN_ASF_64 );
195 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
196 }
197
198 /* SIB index [XMM]*/
199 void fcml_tf_modrm_encoder_test_10(void) {
200
201 fcml_flags effective_address_size;
202
203 fcml_st_modrm modrm;
204 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
205
206 modrm.address.effective_address.index.type = FCML_REG_SIMD;
207 modrm.address.effective_address.index.reg = FCML_REG_XMM1;
208 modrm.address.effective_address.index.size = FCML_DS_128;
209
210 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
211
212 STF_ASSERT( !(effective_address_size & FCML_EN_ASF_16 ) );
213 STF_ASSERT( effective_address_size & FCML_EN_ASF_32 );
214 STF_ASSERT( effective_address_size & FCML_EN_ASF_64 );
215 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
216 }
217
218 /* SIB index [YMM]*/
219 void fcml_tf_modrm_encoder_test_11(void) {
220
221 fcml_flags effective_address_size;
222
223 fcml_st_modrm modrm;
224 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
225
226 modrm.address.effective_address.index.type = FCML_REG_SIMD;
227 modrm.address.effective_address.index.reg = FCML_REG_XMM1;
228 modrm.address.effective_address.index.size = FCML_DS_256;
229
230 fcml_ceh_error error = fcml_fn_modrm_calculate_effective_address_size( &modrm, &effective_address_size );
231
232 STF_ASSERT( !(effective_address_size & FCML_EN_ASF_16) );
233 STF_ASSERT( effective_address_size & FCML_EN_ASF_32 );
234 STF_ASSERT( effective_address_size & FCML_EN_ASF_64 );
235 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
236 }
237
238 /* Encode disp16*/
239 void fcml_tf_modrm_encoder_test_12(void) {
240
241 fcml_st_modrm modrm;
242
243 /* As displacement.*/
244
245 /* Exactly the same size.*/
246
247 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
248
249 modrm.address.effective_address.displacement.size = FCML_DS_16;
250 modrm.address.effective_address.displacement.int16 = (fcml_int16_t)0xF2F1;
251 modrm.address.address_form = FCML_AF_OFFSET;
252
253 fcml_st_modrm_encoder_context context = {0};
254 context.op_mode = FCML_OM_16_BIT;
255 context.effective_address_size = FCML_DS_16;
256
257 fcml_st_encoded_modrm encoded_modrm;
258 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
259
260 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
261
262 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
263 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
264 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xF2 );
265 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
266
267 /* 8 bit sign extended.*/
268
269 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
270
271 modrm.address.effective_address.displacement.size = FCML_DS_8;
272 modrm.address.effective_address.displacement.int8 = (fcml_int8_t)0xF1;
273 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
274 modrm.address.address_form = FCML_AF_OFFSET;
275
276 context.effective_address_size = FCML_DS_16;
277
278 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
279
280 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
281
282 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
283 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
284 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xFF );
285 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
286
287 /* 32 bits - to 16 bits.*/
288
289 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
290
291 modrm.address.effective_address.displacement.size = FCML_DS_32;
292 modrm.address.effective_address.displacement.int32 = 0xFFFFFFF1;
293 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
294 modrm.address.address_form = FCML_AF_OFFSET;
295
296 context.effective_address_size = FCML_DS_16;
297
298 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
299
300 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
301
302 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
303 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
304 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xFF );
305 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
306
307 /* 64 bits - to 16 bits.*/
308
309 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
310
311 modrm.address.effective_address.displacement.size = FCML_DS_64;
312 modrm.address.effective_address.displacement.int64 = 0xFFFFFFFFFFFFFFF1ULL;
313 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
314 modrm.address.address_form = FCML_AF_OFFSET;
315
316 context.effective_address_size = FCML_DS_16;
317
318 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
319
320 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
321
322 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
323 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
324 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xFF );
325 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
326
327 /* 64 bits - to 16 bits, overflow.*/
328
329 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
330
331 modrm.address.effective_address.displacement.size = FCML_DS_64;
332 modrm.address.effective_address.displacement.int64 = 0x1FFFFFFFFFFFFFF1ULL;
333 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
334 modrm.address.address_form = FCML_AF_OFFSET;
335
336 context.effective_address_size = FCML_DS_16;
337
338 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
339
340 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
341
342 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_VALUE_OUT_OF_RANGE );
343
344 /* 32 bits - to 16 bits, overflow.*/
345
346 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
347
348 modrm.address.effective_address.displacement.size = FCML_DS_64;
349 modrm.address.effective_address.displacement.int64 = 0x1FFFFFF1ULL;
350 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
351 modrm.address.address_form = FCML_AF_OFFSET;
352
353 context.effective_address_size = FCML_DS_16;
354
355 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
356
357 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
358
359 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_VALUE_OUT_OF_RANGE );
360 }
361
362 /* Encode disp8*/
363 void fcml_tf_modrm_encoder_test_13(void) {
364
365 fcml_st_modrm modrm;
366 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
367
368 modrm.address.effective_address.displacement.size = FCML_DS_8;
369 modrm.address.effective_address.displacement.int8 = (fcml_int8_t)0xF1;
370 modrm.address.effective_address.displacement.is_signed = FCML_FALSE;
371 modrm.address.address_form = FCML_AF_OFFSET;
372
373 fcml_st_modrm_encoder_context context = {0};
374 context.op_mode = FCML_OM_16_BIT;
375 context.effective_address_size = FCML_DS_16;
376
377 fcml_st_encoded_modrm encoded_modrm;
378 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
379
380 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
381
382 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
383 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
384 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x00 );
385 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
386 }
387
388 /* Encode disp16*/
389 void fcml_tf_modrm_encoder_test_14(void) {
390
391 fcml_st_modrm modrm;
392
393 /* As displacement.*/
394
395 /* Exactly the same size.*/
396
397 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
398
399 modrm.address.offset.size = FCML_DS_16;
400 modrm.address.offset.off16 = (fcml_int16_t)0xF2F1;
401 modrm.address.address_form = FCML_AF_OFFSET;
402
403 fcml_st_modrm_encoder_context context = {0};
404 context.op_mode = FCML_OM_16_BIT;
405 context.effective_address_size = FCML_DS_16;
406
407 fcml_st_encoded_modrm encoded_modrm;
408 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
409
410 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
411
412 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
413 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
414 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xF2 );
415 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
416
417 /* 32 bits - to 16 bits.*/
418
419 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
420
421 modrm.address.offset.size = FCML_DS_32;
422 modrm.address.offset.off32 = 0xFFFFFFF1;
423 modrm.address.offset.is_signed = FCML_TRUE;
424 modrm.address.address_form = FCML_AF_OFFSET;
425
426 context.effective_address_size = FCML_DS_16;
427
428 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
429
430 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
431
432 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
433 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
434 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xFF );
435 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
436
437 /* 64 bits - to 16 bits.*/
438
439 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
440
441 modrm.address.offset.size = FCML_DS_64;
442 modrm.address.offset.off64 = 0xFFFFFFFFFFFFFFF1ULL;
443 modrm.address.offset.is_signed = FCML_TRUE;
444 modrm.address.address_form = FCML_AF_OFFSET;
445
446 context.effective_address_size = FCML_DS_16;
447
448 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
449
450 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
451
452 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
453 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
454 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0xFF );
455 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
456
457 /* 64 bits - to 16 bits, overflow.*/
458
459 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
460
461 modrm.address.offset.size = FCML_DS_64;
462 modrm.address.offset.off64 = 0x1FFFFFFFFFFFFFF1ULL;
463 modrm.address.offset.is_signed = FCML_TRUE;
464 modrm.address.address_form = FCML_AF_OFFSET;
465
466 context.effective_address_size = FCML_DS_16;
467
468 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
469
470 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
471
472 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_VALUE_OUT_OF_RANGE );
473
474 /* 32 bits - to 16 bits, overflow.*/
475
476 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
477
478 modrm.address.offset.size = FCML_DS_64;
479 modrm.address.offset.off64 = 0x1FFFFFF1ULL;
480 modrm.address.offset.is_signed = FCML_TRUE;
481 modrm.address.address_form = FCML_AF_OFFSET;
482
483 context.effective_address_size = FCML_DS_16;
484
485 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
486
487 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
488
489 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_VALUE_OUT_OF_RANGE );
490 }
491
492 /* Encode [BX+SI]*/
493 void fcml_tf_modrm_encoder_16_bit_encoding_1(void) {
494
495 fcml_st_modrm modrm;
496 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
497 fcml_st_encoded_modrm encoded_modrm;
498 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
499 fcml_st_modrm_encoder_context context;
500 fcml_fn_env_memory_clear( &context, sizeof( context ) );
501 context.effective_address_size = FCML_DS_16;
502
503 modrm.address.effective_address.base.type = FCML_REG_GPR;
504 modrm.address.effective_address.base.size = FCML_DS_16;
505 modrm.address.effective_address.base.reg = FCML_REG_BX;
506 modrm.address.effective_address.index.type = FCML_REG_GPR;
507 modrm.address.effective_address.index.size = FCML_DS_16;
508 modrm.address.effective_address.index.reg = FCML_REG_SI;
509 modrm.address.address_form = FCML_AF_COMBINED;
510
511 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
512
513 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
514 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
515 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
516 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
517 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
518 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
519 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
520 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0 );
521 }
522
523 /* Encode [BX+DI]*/
524 void fcml_tf_modrm_encoder_16_bit_encoding_2(void) {
525
526 fcml_st_modrm modrm;
527 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
528 fcml_st_encoded_modrm encoded_modrm;
529 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
530 fcml_st_modrm_encoder_context context;
531 fcml_fn_env_memory_clear( &context, sizeof( context ) );
532 context.effective_address_size = FCML_DS_16;
533
534 modrm.address.effective_address.base.type = FCML_REG_GPR;
535 modrm.address.effective_address.base.size = FCML_DS_16;
536 modrm.address.effective_address.base.reg = FCML_REG_BX;
537 modrm.address.effective_address.index.type = FCML_REG_GPR;
538 modrm.address.effective_address.index.size = FCML_DS_16;
539 modrm.address.effective_address.index.reg = FCML_REG_DI;
540 modrm.address.address_form = FCML_AF_COMBINED;
541
542 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
543
544 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
545 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
546 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
547 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
548 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
549 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
550 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
551 STF_ASSERT_EQUAL( encoded_modrm.modrm, 1 );
552 }
553
554 /* Encode [BP+SI]*/
555 void fcml_tf_modrm_encoder_16_bit_encoding_3(void) {
556
557 fcml_st_modrm modrm;
558 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
559 fcml_st_encoded_modrm encoded_modrm;
560 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
561 fcml_st_modrm_encoder_context context;
562 fcml_fn_env_memory_clear( &context, sizeof( context ) );
563 context.effective_address_size = FCML_DS_16;
564
565 modrm.address.effective_address.base.type = FCML_REG_GPR;
566 modrm.address.effective_address.base.size = FCML_DS_16;
567 modrm.address.effective_address.base.reg = FCML_REG_BP;
568 modrm.address.effective_address.index.type = FCML_REG_GPR;
569 modrm.address.effective_address.index.size = FCML_DS_16;
570 modrm.address.effective_address.index.reg = FCML_REG_SI;
571 modrm.address.address_form = FCML_AF_COMBINED;
572
573 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
574
575 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
576 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
577 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
578 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
579 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
580 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
581 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
582 STF_ASSERT_EQUAL( encoded_modrm.modrm, 2 );
583 }
584
585 /* Encode [BP+DI]*/
586 void fcml_tf_modrm_encoder_16_bit_encoding_4(void) {
587
588 fcml_st_modrm modrm;
589 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
590 fcml_st_encoded_modrm encoded_modrm;
591 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
592 fcml_st_modrm_encoder_context context;
593 fcml_fn_env_memory_clear( &context, sizeof( context ) );
594 context.effective_address_size = FCML_DS_16;
595
596 modrm.address.effective_address.base.type = FCML_REG_GPR;
597 modrm.address.effective_address.base.size = FCML_DS_16;
598 modrm.address.effective_address.base.reg = FCML_REG_BP;
599 modrm.address.effective_address.index.type = FCML_REG_GPR;
600 modrm.address.effective_address.index.size = FCML_DS_16;
601 modrm.address.effective_address.index.reg = FCML_REG_DI;
602 modrm.address.address_form = FCML_AF_COMBINED;
603
604 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
605
606 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
607 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
608 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
609 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
610 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
611 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
612 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
613 STF_ASSERT_EQUAL( encoded_modrm.modrm, 3 );
614 }
615
616 /* Encode [SI]*/
617 void fcml_tf_modrm_encoder_16_bit_encoding_5(void) {
618
619 fcml_st_modrm modrm;
620 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
621 fcml_st_encoded_modrm encoded_modrm;
622 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
623 fcml_st_modrm_encoder_context context;
624 fcml_fn_env_memory_clear( &context, sizeof( context ) );
625 context.effective_address_size = FCML_DS_16;
626
627 modrm.address.effective_address.base.type = FCML_REG_GPR;
628 modrm.address.effective_address.base.size = FCML_DS_16;
629 modrm.address.effective_address.base.reg = FCML_REG_SI;
630 modrm.address.address_form = FCML_AF_COMBINED;
631
632 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
633
634 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
635 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
636 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
637 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
638 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
639 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
640 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
641 STF_ASSERT_EQUAL( encoded_modrm.modrm, 4 );
642 }
643
644 /* Encode [DI]*/
645 void fcml_tf_modrm_encoder_16_bit_encoding_6(void) {
646
647 fcml_st_modrm modrm;
648 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
649 fcml_st_encoded_modrm encoded_modrm;
650 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
651 fcml_st_modrm_encoder_context context;
652 fcml_fn_env_memory_clear( &context, sizeof( context ) );
653 context.effective_address_size = FCML_DS_16;
654
655 modrm.address.effective_address.base.type = FCML_REG_GPR;
656 modrm.address.effective_address.base.size = FCML_DS_16;
657 modrm.address.effective_address.base.reg = FCML_REG_DI;
658 modrm.address.address_form = FCML_AF_COMBINED;
659
660 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
661
662 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
663 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
664 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
665 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
666 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
667 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
668 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
669 STF_ASSERT_EQUAL( encoded_modrm.modrm, 5 );
670 }
671
672 /* Encode [BP]*/
673 void fcml_tf_modrm_encoder_16_bit_encoding_7(void) {
674
675 fcml_st_modrm modrm;
676 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
677 fcml_st_encoded_modrm encoded_modrm;
678 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
679 fcml_st_modrm_encoder_context context;
680 fcml_fn_env_memory_clear( &context, sizeof( context ) );
681 context.effective_address_size = FCML_DS_16;
682
683 modrm.address.effective_address.base.type = FCML_REG_GPR;
684 modrm.address.effective_address.base.size = FCML_DS_16;
685 modrm.address.effective_address.base.reg = FCML_REG_BP;
686 modrm.address.address_form = FCML_AF_COMBINED;
687
688 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
689
690 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
691 }
692
693 /* Encode [BX]*/
694 void fcml_tf_modrm_encoder_16_bit_encoding_8(void) {
695
696 fcml_st_modrm modrm;
697 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
698 fcml_st_encoded_modrm encoded_modrm;
699 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
700 fcml_st_modrm_encoder_context context;
701 fcml_fn_env_memory_clear( &context, sizeof( context ) );
702 context.effective_address_size = FCML_DS_16;
703
704 modrm.address.effective_address.base.type = FCML_REG_GPR;
705 modrm.address.effective_address.base.size = FCML_DS_16;
706 modrm.address.effective_address.base.reg = FCML_REG_BX;
707 modrm.address.address_form = FCML_AF_COMBINED;
708
709 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
710
711 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
712 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
713 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
714 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
715 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
716 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
717 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
718 STF_ASSERT_EQUAL( encoded_modrm.modrm, 7 );
719
720 }
721
722 /* Encode [BX+DI]+disp8*/
723 void fcml_tf_modrm_encoder_16_bit_encoding_9(void) {
724
725 fcml_st_modrm modrm;
726 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
727 fcml_st_encoded_modrm encoded_modrm;
728 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
729 fcml_st_modrm_encoder_context context;
730 fcml_fn_env_memory_clear( &context, sizeof( context ) );
731 context.effective_address_size = FCML_DS_16;
732
733 modrm.address.effective_address.base.type = FCML_REG_GPR;
734 modrm.address.effective_address.base.size = FCML_DS_16;
735 modrm.address.effective_address.base.reg = FCML_REG_BX;
736 modrm.address.effective_address.index.type = FCML_REG_GPR;
737 modrm.address.effective_address.index.size = FCML_DS_16;
738 modrm.address.effective_address.index.reg = FCML_REG_DI;
739 modrm.address.effective_address.displacement.size = FCML_DS_8;
740 modrm.address.effective_address.displacement.int8 = 0x12;
741 modrm.address.effective_address.displacement.is_signed = FCML_FALSE;
742 modrm.address.address_form = FCML_AF_COMBINED;
743
744 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
745
746 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
747 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
748 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x12 );
749 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
750 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
751 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
752 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
753 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
754 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x41 );
755
756 modrm.address.effective_address.displacement.size = FCML_DS_16;
757 modrm.address.effective_address.displacement.int16 = 0x12;
758
759 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
760
761 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
762 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
763 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x12 );
764 }
765
766 /* Encode [BP]+disp8*/
767 void fcml_tf_modrm_encoder_16_bit_encoding_10(void) {
768
769 fcml_st_modrm modrm;
770 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
771 fcml_st_encoded_modrm encoded_modrm;
772 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
773 fcml_st_modrm_encoder_context context;
774 fcml_fn_env_memory_clear( &context, sizeof( context ) );
775 context.effective_address_size = FCML_DS_16;
776
777 modrm.address.effective_address.base.type = FCML_REG_GPR;
778 modrm.address.effective_address.base.size = FCML_DS_16;
779 modrm.address.effective_address.base.reg = FCML_REG_BP;
780 modrm.address.effective_address.displacement.size = FCML_DS_8;
781 modrm.address.effective_address.displacement.int8 = (fcml_int8_t)0xFF;
782 modrm.address.address_form = FCML_AF_COMBINED;
783
784 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
785
786 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
787 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
788 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xFF );
789 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
790 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
791 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
792 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
793 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
794 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x46 );
795 }
796
797 /* Encode [SI]+disp16*/
798 void fcml_tf_modrm_encoder_16_bit_encoding_11(void) {
799
800 fcml_st_modrm modrm;
801 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
802 fcml_st_encoded_modrm encoded_modrm;
803 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
804 fcml_st_modrm_encoder_context context;
805 fcml_fn_env_memory_clear( &context, sizeof( context ) );
806 context.effective_address_size = FCML_DS_16;
807
808 modrm.address.effective_address.base.type = FCML_REG_GPR;
809 modrm.address.effective_address.base.size = FCML_DS_16;
810 modrm.address.effective_address.base.reg = FCML_REG_SI;
811 modrm.address.effective_address.displacement.size = FCML_DS_16;
812 modrm.address.effective_address.displacement.int16 = 0x0102;
813 modrm.address.address_form = FCML_AF_COMBINED;
814
815 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
816
817 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
818 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
819 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x02 );
820 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x01 );
821 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
822 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
823 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
824 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
825 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
826 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x84 );
827 }
828
829 /* Encode [BX]+disp16*/
830 void fcml_tf_modrm_encoder_16_bit_encoding_12(void) {
831
832 fcml_st_modrm modrm;
833 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
834 fcml_st_encoded_modrm encoded_modrm;
835 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
836 fcml_st_modrm_encoder_context context;
837 fcml_fn_env_memory_clear( &context, sizeof( context ) );
838 context.effective_address_size = FCML_DS_16;
839
840 modrm.address.effective_address.base.type = FCML_REG_GPR;
841 modrm.address.effective_address.base.size = FCML_DS_16;
842 modrm.address.effective_address.base.reg = FCML_REG_BX;
843 modrm.address.effective_address.displacement.size = FCML_DS_16;
844 modrm.address.effective_address.displacement.int16 = (fcml_int16_t)0xFFF1;
845 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
846 modrm.address.address_form = FCML_AF_COMBINED;
847
848 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
849
850 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
851 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
852 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
853 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
854 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
855 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
856 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
857 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
858 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x47 );
859
860 modrm.address.effective_address.displacement.int16 = 0x1FF1;
861
862 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
863
864 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 2 );
865 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF1 );
866 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x1F );
867 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x87 );
868 }
869
870 /* Encode DX, BP*/
871 void fcml_tf_modrm_encoder_16_bit_encoding_13(void) {
872
873 fcml_st_modrm modrm;
874 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
875 fcml_st_encoded_modrm encoded_modrm;
876 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
877 fcml_st_modrm_encoder_context context;
878 fcml_fn_env_memory_clear( &context, sizeof( context ) );
879 context.effective_address_size = FCML_DS_16;
880
881 modrm.reg.is_not_null = FCML_TRUE;
882 modrm.reg.value = FCML_REG_DI;
883 modrm.reg_opcode = FCML_REG_BP;
884
885 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
886
887 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
888 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
889 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
890 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
891 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
892 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
893 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
894 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xEF );
895 }
896
897 /* Encode [EAX], EAX*/
898 void fcml_tf_modrm_encoder_3264_bit_encoding_1(void) {
899
900 fcml_st_modrm modrm;
901 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
902 fcml_st_encoded_modrm encoded_modrm;
903 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
904 fcml_st_modrm_encoder_context context;
905 fcml_fn_env_memory_clear( &context, sizeof( context ) );
906 context.effective_address_size = FCML_DS_32;
907
908 modrm.address.effective_address.base.type = FCML_REG_GPR;
909 modrm.address.effective_address.base.reg = FCML_REG_EAX;
910 modrm.address.effective_address.base.size = FCML_DS_32;
911 modrm.address.address_form = FCML_AF_COMBINED;
912 modrm.reg_opcode = FCML_REG_EAX;
913
914 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
915
916 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
917 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
918 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
919 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
920 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
921 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
922 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
923 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x00 );
924 }
925
926 /* Encode [ECX], EDI*/
927 void fcml_tf_modrm_encoder_3264_bit_encoding_2(void) {
928
929 fcml_st_modrm modrm;
930 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
931 fcml_st_encoded_modrm encoded_modrm;
932 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
933 fcml_st_modrm_encoder_context context;
934 fcml_fn_env_memory_clear( &context, sizeof( context ) );
935 context.effective_address_size = FCML_DS_32;
936
937 modrm.address.effective_address.base.type = FCML_REG_GPR;
938 modrm.address.effective_address.base.reg = FCML_REG_ECX;
939 modrm.address.effective_address.base.size = FCML_DS_32;
940 modrm.address.address_form = FCML_AF_COMBINED;
941 modrm.reg_opcode = FCML_REG_EDI;
942
943 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
944
945 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
946 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
947 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
948 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
949 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
950 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
951 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
952 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x39 );
953 }
954
955 /* Encode [RCX], RDI*/
956 void fcml_tf_modrm_encoder_3264_bit_encoding_3(void) {
957
958 fcml_st_modrm modrm;
959 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
960 fcml_st_encoded_modrm encoded_modrm;
961 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
962 fcml_st_modrm_encoder_context context;
963 fcml_fn_env_memory_clear( &context, sizeof( context ) );
964 context.effective_address_size = FCML_DS_64;
965 context.op_mode = FCML_OM_64_BIT;
966
967 modrm.address.effective_address.base.type = FCML_REG_GPR;
968 modrm.address.effective_address.base.reg = FCML_REG_RCX;
969 modrm.address.effective_address.base.size = FCML_DS_64;
970 modrm.address.address_form = FCML_AF_COMBINED;
971 modrm.reg_opcode = FCML_REG_RDI;
972
973 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
974
975 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
976 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
977 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
978 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
979 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
980 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
981 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
982 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x39 );
983 }
984
985 /* Encode [ECX], RDI*/
986 void fcml_tf_modrm_encoder_3264_bit_encoding_4(void) {
987
988 fcml_st_modrm modrm;
989 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
990 fcml_st_encoded_modrm encoded_modrm;
991 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
992 fcml_st_modrm_encoder_context context;
993 fcml_fn_env_memory_clear( &context, sizeof( context ) );
994 context.effective_address_size = FCML_DS_64;
995
996 modrm.address.effective_address.base.type = FCML_REG_GPR;
997 modrm.address.effective_address.base.reg = FCML_REG_ECX;
998 modrm.address.effective_address.base.size = FCML_DS_32;
999 modrm.address.address_form = FCML_AF_COMBINED;
1000 modrm.reg_opcode = FCML_REG_RDI;
1001
1002 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1003
1004 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
1005 }
1006
1007 /* Encode [R12D], EDI (failed, because 32 bit addressing is used.)*/
1008 void fcml_tf_modrm_encoder_3264_bit_encoding_5(void) {
1009
1010 fcml_st_modrm modrm;
1011 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1012 fcml_st_encoded_modrm encoded_modrm;
1013 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1014 fcml_st_modrm_encoder_context context = {0};
1015 context.effective_address_size = FCML_DS_32;
1016 context.op_mode = FCML_OM_32_BIT;
1017 context.choose_sib_encoding = FCML_TRUE;
1018 context.chosen_effective_address_size = FCML_DS_32;
1019
1020 modrm.address.effective_address.base.type = FCML_REG_GPR;
1021 modrm.address.effective_address.base.reg = FCML_REG_R12D;
1022 modrm.address.effective_address.base.size = FCML_DS_32;
1023 modrm.address.address_form = FCML_AF_COMBINED;
1024 modrm.reg_opcode = FCML_REG_EDI;
1025
1026 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1027
1028 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
1029 }
1030
1031 /* Encode [01020304], ECX*/
1032 /* Encode [0102], ECX*/
1033 /* Encode [01], ECX*/
1034 void fcml_tf_modrm_encoder_3264_bit_encoding_6(void) {
1035
1036 fcml_st_modrm modrm;
1037 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1038 fcml_st_encoded_modrm encoded_modrm;
1039 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1040 fcml_st_modrm_encoder_context context;
1041 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1042 context.effective_address_size = FCML_DS_32;
1043
1044 modrm.address.effective_address.displacement.size = FCML_DS_32;
1045 modrm.address.effective_address.displacement.int32 = 0x01020304;
1046 modrm.address.address_form = FCML_AF_OFFSET;
1047 modrm.reg_opcode = FCML_REG_ECX;
1048
1049 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1050
1051 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1052 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1053 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x04 );
1054 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x03 );
1055 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x02 );
1056 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x01 );
1057 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1058 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1059 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1060 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1061 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1062 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x0D );
1063 STF_ASSERT_EQUAL( context.is_sib_alternative, FCML_TRUE );
1064
1065 modrm.address.effective_address.displacement.size = FCML_DS_16;
1066 modrm.address.effective_address.displacement.int16 = 0x0102;
1067 modrm.reg_opcode = FCML_REG_ECX;
1068
1069 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1070
1071 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1072 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1073 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x02 );
1074 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x01 );
1075 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
1076 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
1077 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1078 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1079 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1080 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1081 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1082 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x0D );
1083 STF_ASSERT_EQUAL( context.is_sib_alternative, FCML_TRUE );
1084
1085 modrm.address.effective_address.displacement.size = FCML_DS_8;
1086 modrm.address.effective_address.displacement.int8 = 0x01;
1087 modrm.address.address_form = FCML_AF_OFFSET;
1088 modrm.reg_opcode = FCML_REG_ECX;
1089
1090 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1091
1092 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1093 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1094 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x01 );
1095 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x00 );
1096 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
1097 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
1098 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1099 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1100 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1101 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1102 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1103 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x0D );
1104 STF_ASSERT_EQUAL( context.is_sib_alternative, FCML_TRUE );
1105 }
1106
1107 /* Encode [EDI], R12D*/
1108 void fcml_tf_modrm_encoder_3264_bit_encoding_7(void) {
1109
1110 fcml_st_modrm modrm;
1111 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1112 fcml_st_encoded_modrm encoded_modrm;
1113 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1114 fcml_st_modrm_encoder_context context;
1115 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1116 context.effective_address_size = FCML_DS_32;
1117 context.op_mode = FCML_OM_64_BIT;
1118
1119 modrm.address.effective_address.base.type = FCML_REG_GPR;
1120 modrm.address.effective_address.base.reg = FCML_REG_EDI;
1121 modrm.address.effective_address.base.size = FCML_DS_32;
1122 modrm.address.address_form = FCML_AF_COMBINED;
1123 modrm.reg_opcode = FCML_REG_R12D;
1124
1125 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1126
1127 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1128 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1129 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1130 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 1 );
1131 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1132 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1133 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1134 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x27 );
1135 STF_ASSERT_EQUAL( context.is_sib_alternative, FCML_TRUE );
1136
1137 }
1138
1139 /* Encode [EDX]+01020304, EBP*/
1140 /* Encode [EDX]+0102, EBP*/
1141 /* Encode [EDX]+01, EBP*/
1142 void fcml_tf_modrm_encoder_3264_bit_encoding_8(void) {
1143
1144 fcml_st_modrm modrm;
1145 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1146 fcml_st_encoded_modrm encoded_modrm;
1147 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1148 fcml_st_modrm_encoder_context context;
1149 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1150 context.effective_address_size = FCML_DS_32;
1151
1152 modrm.address.effective_address.base.type = FCML_REG_GPR;
1153 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1154 modrm.address.effective_address.base.size = FCML_DS_32;
1155 modrm.address.effective_address.displacement.size = FCML_DS_32;
1156 modrm.address.effective_address.displacement.int32 = 0x01020304;
1157 modrm.address.address_form = FCML_AF_COMBINED;
1158 modrm.reg_opcode = FCML_REG_EBP;
1159
1160 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1161
1162 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1163 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1164 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x04 );
1165 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x03 );
1166 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x02 );
1167 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x01 );
1168 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1169 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1170 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1171 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1172 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1173 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xAA );
1174
1175 modrm.address.effective_address.base.type = FCML_REG_GPR;
1176 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1177 modrm.address.effective_address.base.size = FCML_DS_32;
1178 modrm.address.effective_address.displacement.size = FCML_DS_16;
1179 modrm.address.effective_address.displacement.int16 = 0x0102;
1180 modrm.address.address_form = FCML_AF_COMBINED;
1181 modrm.reg_opcode = FCML_REG_EBP;
1182
1183 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1184
1185 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1186 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1187 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x02 );
1188 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x01 );
1189 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
1190 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
1191 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1192 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1193 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1194 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1195 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1196 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xAA );
1197
1198 modrm.address.effective_address.base.type = FCML_REG_GPR;
1199 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1200 modrm.address.effective_address.base.size = FCML_DS_32;
1201 modrm.address.effective_address.displacement.size = FCML_DS_8;
1202 modrm.address.effective_address.displacement.int8 = 0x01;
1203 modrm.address.address_form = FCML_AF_COMBINED;
1204 modrm.reg_opcode = FCML_REG_EBP;
1205
1206 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1207
1208 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1209 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
1210 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x01 );
1211 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1212 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1213 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1214 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1215 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1216 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x6A );
1217
1218 modrm.address.effective_address.base.type = FCML_REG_GPR;
1219 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1220 modrm.address.effective_address.base.size = FCML_DS_32;
1221 modrm.address.effective_address.displacement.size = FCML_DS_32;
1222 modrm.address.effective_address.displacement.int32 = 0x01;
1223 modrm.address.address_form = FCML_AF_COMBINED;
1224 modrm.reg_opcode = FCML_REG_EBP;
1225
1226 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1227
1228 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1229 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
1230 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x01 );
1231 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1232 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1233 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1234 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1235 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1236 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x6A );
1237 }
1238
1239 /* Encode EBP, R12D*/
1240 void fcml_tf_modrm_encoder_3264_bit_encoding_9(void) {
1241
1242 fcml_st_modrm modrm;
1243 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1244 fcml_st_encoded_modrm encoded_modrm;
1245 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1246 fcml_st_modrm_encoder_context context;
1247 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1248 context.effective_address_size = FCML_DS_32;
1249 context.op_mode = FCML_OM_64_BIT;
1250
1251 modrm.reg.is_not_null = FCML_TRUE;
1252 modrm.reg.value = FCML_REG_EBP;
1253 modrm.reg_opcode = FCML_REG_R12D;
1254
1255 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1256
1257 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1258 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1259 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1260 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 1 );
1261 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1262 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1263 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0 );
1264 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xE5 );
1265 }
1266
1267 /* Encode EBP+0x01, R12D*/
1268 void fcml_tf_modrm_encoder_3264_bit_encoding_10(void) {
1269
1270 fcml_st_modrm modrm;
1271 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1272 fcml_st_encoded_modrm encoded_modrm;
1273 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1274 fcml_st_modrm_encoder_context context;
1275 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1276 context.effective_address_size = FCML_DS_32;
1277
1278 modrm.address.effective_address.displacement.size = FCML_DS_8;
1279 modrm.address.effective_address.displacement.int32 = 0x01;
1280 modrm.address.address_form = FCML_AF_COMBINED;
1281 modrm.reg.is_not_null = FCML_TRUE;
1282 modrm.reg.value = FCML_REG_EBP;
1283 modrm.reg_opcode = FCML_REG_R12D;
1284
1285 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1286
1287 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
1288 }
1289
1290 /* Encode [R12D], EDI*/
1291 void fcml_tf_modrm_encoder_3264_bit_encoding_11(void) {
1292
1293 fcml_st_modrm modrm;
1294 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1295 fcml_st_encoded_modrm encoded_modrm;
1296 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1297 fcml_st_modrm_encoder_context context;
1298 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1299 context.effective_address_size = FCML_DS_32;
1300 context.op_mode = FCML_OM_64_BIT;
1301
1302 modrm.address.effective_address.base.type = FCML_REG_GPR;
1303 modrm.address.effective_address.base.reg = FCML_REG_R12D;
1304 modrm.address.effective_address.base.size = FCML_DS_32;
1305 modrm.address.address_form = FCML_AF_COMBINED;
1306 modrm.reg_opcode = FCML_REG_EDI;
1307
1308 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1309
1310 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1311 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1312 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 1 );
1313 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1314 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1315 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1316 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x00 );
1317 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x3c );
1318 }
1319
1320 /* Encode [RAX], RDI (failed, 32 bits)*/
1321 void fcml_tf_modrm_encoder_3264_bit_encoding_12(void) {
1322
1323 fcml_st_modrm modrm;
1324 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1325 fcml_st_encoded_modrm encoded_modrm;
1326 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1327 fcml_st_modrm_encoder_context context;
1328 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1329 context.effective_address_size = FCML_DS_64;
1330 context.op_mode = FCML_OM_32_BIT;
1331
1332 modrm.address.effective_address.base.type = FCML_REG_GPR;
1333 modrm.address.effective_address.base.reg = FCML_REG_RAX;
1334 modrm.address.effective_address.base.size = FCML_DS_64;
1335 modrm.address.address_form = FCML_AF_COMBINED;
1336 modrm.reg_opcode = FCML_REG_RDI;
1337
1338 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1339
1340 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_INVALID_ADDRESSING_FORM );
1341 }
1342
1343 /* Encode [EAX+EBX], ESP*/
1344 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_1(void) {
1345
1346 fcml_st_modrm modrm;
1347 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1348 fcml_st_encoded_modrm encoded_modrm;
1349 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1350 fcml_st_modrm_encoder_context context;
1351 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1352 context.effective_address_size = FCML_DS_32;
1353
1354 modrm.address.effective_address.base.type = FCML_REG_GPR;
1355 modrm.address.effective_address.base.reg = FCML_REG_EAX;
1356 modrm.address.effective_address.base.size = FCML_DS_32;
1357 modrm.address.effective_address.index.type = FCML_REG_GPR;
1358 modrm.address.effective_address.index.reg = FCML_REG_EBX;
1359 modrm.address.effective_address.index.size = FCML_DS_32;
1360 modrm.address.address_form = FCML_AF_COMBINED;
1361 modrm.reg_opcode = FCML_REG_ESP;
1362
1363 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1364
1365 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1366 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1367 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1368 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1369 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1370 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1371 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x18 );
1372 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1373 }
1374
1375 /* Encode [EBP+EDX], ESP*/
1376 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_2(void) {
1377
1378 fcml_st_modrm modrm;
1379 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1380 fcml_st_encoded_modrm encoded_modrm;
1381 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1382 fcml_st_modrm_encoder_context context;
1383 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1384 context.effective_address_size = FCML_DS_32;
1385
1386 modrm.address.effective_address.base.type = FCML_REG_GPR;
1387 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1388 modrm.address.effective_address.base.size = FCML_DS_32;
1389 modrm.address.effective_address.index.type = FCML_REG_GPR;
1390 modrm.address.effective_address.index.reg = FCML_REG_EDX;
1391 modrm.address.effective_address.index.size = FCML_DS_32;
1392 modrm.address.address_form = FCML_AF_COMBINED;
1393 modrm.reg_opcode = FCML_REG_ESP;
1394
1395 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1396
1397 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1398 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1399 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1400 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1401 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1402 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1403 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x15 );
1404 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1405 }
1406
1407 /* Encode [EBP+EBP*2], ESP*/
1408 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_3(void) {
1409
1410 fcml_st_modrm modrm;
1411 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1412 fcml_st_encoded_modrm encoded_modrm;
1413 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1414 fcml_st_modrm_encoder_context context;
1415 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1416 context.effective_address_size = FCML_DS_32;
1417
1418 modrm.address.effective_address.base.type = FCML_REG_GPR;
1419 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1420 modrm.address.effective_address.base.size = FCML_DS_32;
1421 modrm.address.effective_address.index.type = FCML_REG_GPR;
1422 modrm.address.effective_address.index.reg = FCML_REG_EBP;
1423 modrm.address.effective_address.index.size = FCML_DS_32;
1424 modrm.address.effective_address.scale_factor = 2;
1425 modrm.address.address_form = FCML_AF_COMBINED;
1426 modrm.reg_opcode = FCML_REG_ESP;
1427
1428 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1429
1430 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1431 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1432 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1433 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1434 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1435 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1436 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x6D );
1437 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1438 }
1439
1440 /* Encode [EBP+EBP*4], ESP*/
1441 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_4(void) {
1442
1443 fcml_st_modrm modrm;
1444 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1445 fcml_st_encoded_modrm encoded_modrm;
1446 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1447 fcml_st_modrm_encoder_context context;
1448 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1449 context.effective_address_size = FCML_DS_32;
1450
1451 modrm.address.effective_address.base.type = FCML_REG_GPR;
1452 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1453 modrm.address.effective_address.base.size = FCML_DS_32;
1454 modrm.address.effective_address.index.type = FCML_REG_GPR;
1455 modrm.address.effective_address.index.reg = FCML_REG_EBP;
1456 modrm.address.effective_address.index.size = FCML_DS_32;
1457 modrm.address.effective_address.scale_factor = 4;
1458 modrm.address.address_form = FCML_AF_COMBINED;
1459 modrm.reg_opcode = FCML_REG_ESP;
1460
1461 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1462
1463 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1464 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1465 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1466 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1467 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1468 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1469 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0xAD );
1470 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1471 }
1472
1473 /* Encode [EBP+EBP*8], ESP*/
1474 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_5(void) {
1475
1476 fcml_st_modrm modrm;
1477 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1478 fcml_st_encoded_modrm encoded_modrm;
1479 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1480 fcml_st_modrm_encoder_context context = {0};
1481 context.effective_address_size = FCML_DS_32;
1482 context.op_mode = FCML_OM_32_BIT;
1483
1484 modrm.address.effective_address.base.type = FCML_REG_GPR;
1485 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1486 modrm.address.effective_address.base.size = FCML_DS_32;
1487 modrm.address.effective_address.index.type = FCML_REG_GPR;
1488 modrm.address.effective_address.index.reg = FCML_REG_EBP;
1489 modrm.address.effective_address.index.size = FCML_DS_32;
1490 modrm.address.effective_address.scale_factor = 8;
1491 modrm.address.address_form = FCML_AF_COMBINED;
1492 modrm.reg_opcode = FCML_REG_ESP;
1493
1494 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1495
1496 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1497 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1498 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1499 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1500 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1501 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1502 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0xED );
1503 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1504 }
1505
1506 /* Encode [EBP+EBP*8]+disp8, ESP*/
1507 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_6(void) {
1508
1509 fcml_st_modrm modrm;
1510 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1511 fcml_st_encoded_modrm encoded_modrm;
1512 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1513 fcml_st_modrm_encoder_context context;
1514 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1515 context.effective_address_size = FCML_DS_32;
1516
1517 modrm.address.effective_address.displacement.size = FCML_DS_8;
1518 modrm.address.effective_address.displacement.int8 = 0x50;
1519 modrm.address.effective_address.base.type = FCML_REG_GPR;
1520 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1521 modrm.address.effective_address.base.size = FCML_DS_32;
1522 modrm.address.effective_address.index.type = FCML_REG_GPR;
1523 modrm.address.effective_address.index.reg = FCML_REG_EBP;
1524 modrm.address.effective_address.index.size = FCML_DS_32;
1525 modrm.address.effective_address.scale_factor = 8;
1526 modrm.address.address_form = FCML_AF_COMBINED;
1527 modrm.reg_opcode = FCML_REG_ESP;
1528
1529 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1530
1531 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1532 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
1533 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x50 );
1534 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1535 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1536 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1537 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1538 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0xED );
1539 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x64 );
1540 }
1541
1542 /* Encode [EBP+EBP*8]+disp16, ESP*/
1543 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_7(void) {
1544
1545 fcml_st_modrm modrm;
1546 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1547 fcml_st_encoded_modrm encoded_modrm;
1548 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1549 fcml_st_modrm_encoder_context context;
1550 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1551 context.effective_address_size = FCML_DS_32;
1552
1553 modrm.address.effective_address.displacement.size = FCML_DS_16;
1554 modrm.address.effective_address.displacement.int16 = 0x5051;
1555 modrm.address.effective_address.base.type = FCML_REG_GPR;
1556 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1557 modrm.address.effective_address.base.size = FCML_DS_32;
1558 modrm.address.effective_address.index.type = FCML_REG_GPR;
1559 modrm.address.effective_address.index.reg = FCML_REG_EBP;
1560 modrm.address.effective_address.index.size = FCML_DS_32;
1561 modrm.address.effective_address.scale_factor = 8;
1562 modrm.address.address_form = FCML_AF_COMBINED;
1563 modrm.reg_opcode = FCML_REG_ESP;
1564
1565 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1566
1567 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1568 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1569 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x51 );
1570 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x50 );
1571 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
1572 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
1573 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1574 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1575 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1576 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1577 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0xED );
1578 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xA4 );
1579 }
1580
1581 /* Encode [EBP+EBP*8]+disp32, ESP*/
1582 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_8(void) {
1583
1584 fcml_st_modrm modrm;
1585 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1586 fcml_st_encoded_modrm encoded_modrm;
1587 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1588 fcml_st_modrm_encoder_context context;
1589 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1590 context.effective_address_size = FCML_DS_32;
1591
1592 modrm.address.effective_address.displacement.size = FCML_DS_32;
1593 modrm.address.effective_address.displacement.int32 = 0x50515253;
1594 modrm.address.effective_address.base.type = FCML_REG_GPR;
1595 modrm.address.effective_address.base.reg = FCML_REG_EBP;
1596 modrm.address.effective_address.base.size = FCML_DS_32;
1597 modrm.address.effective_address.index.type = FCML_REG_GPR;
1598 modrm.address.effective_address.index.reg = FCML_REG_EBP;
1599 modrm.address.effective_address.index.size = FCML_DS_32;
1600 modrm.address.effective_address.scale_factor = 8;
1601 modrm.address.address_form = FCML_AF_COMBINED;
1602 modrm.reg_opcode = FCML_REG_ESP;
1603
1604 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1605
1606 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1607 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1608 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x53 );
1609 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x52 );
1610 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x51 );
1611 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x50 );
1612 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1613 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1614 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1615 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1616 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0xED );
1617 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xA4 );
1618 }
1619
1620 /* Encode [EDX]+01020304, EBP*/
1621 /* Encode [EDX]+0102, EBP*/
1622 /* Encode [EDX]+01, EBP*/
1623 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_9(void) {
1624
1625 fcml_st_modrm modrm;
1626 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1627 fcml_st_encoded_modrm encoded_modrm;
1628 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1629 fcml_st_modrm_encoder_context context;
1630 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1631 context.effective_address_size = FCML_DS_32;
1632 context.choose_sib_encoding = FCML_TRUE;
1633
1634 modrm.address.effective_address.base.type = FCML_REG_GPR;
1635 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1636 modrm.address.effective_address.base.size = FCML_DS_32;
1637 modrm.address.effective_address.displacement.size = FCML_DS_32;
1638 modrm.address.effective_address.displacement.int32 = 0x01020304;
1639 modrm.address.address_form = FCML_AF_COMBINED;
1640 modrm.reg_opcode = FCML_REG_EBP;
1641
1642 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1643
1644 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1645 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1646 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x04 );
1647 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x03 );
1648 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x02 );
1649 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x01 );
1650 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1651 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1652 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1653 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1654 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x22 );
1655 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xAC );
1656
1657 modrm.address.effective_address.base.type = FCML_REG_GPR;
1658 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1659 modrm.address.effective_address.base.size = FCML_DS_32;
1660 modrm.address.effective_address.displacement.size = FCML_DS_16;
1661 modrm.address.effective_address.displacement.int16 = 0x0102;
1662 modrm.address.address_form = FCML_AF_COMBINED;
1663 modrm.reg_opcode = FCML_REG_EBP;
1664
1665 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1666
1667 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1668 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
1669 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x02 );
1670 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x01 );
1671 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
1672 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
1673 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1674 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1675 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1676 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1677 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x22 );
1678 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0xAC );
1679
1680 modrm.address.effective_address.base.type = FCML_REG_GPR;
1681 modrm.address.effective_address.base.reg = FCML_REG_EDX;
1682 modrm.address.effective_address.base.size = FCML_DS_32;
1683 modrm.address.effective_address.displacement.size = FCML_DS_8;
1684 modrm.address.effective_address.displacement.int8 = 0x01;
1685 modrm.address.address_form = FCML_AF_COMBINED;
1686 modrm.reg_opcode = FCML_REG_EBP;
1687
1688 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1689
1690 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1691 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
1692 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x01 );
1693 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1694 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1695 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1696 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1697 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x22 );
1698 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x6C );
1699 }
1700
1701 /* Encode [R15D], R12D*/
1702 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_10(void) {
1703
1704 fcml_st_modrm modrm;
1705 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1706 fcml_st_encoded_modrm encoded_modrm;
1707 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1708 fcml_st_modrm_encoder_context context;
1709 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1710 context.effective_address_size = FCML_DS_32;
1711 context.op_mode = FCML_OM_64_BIT;
1712 context.choose_sib_encoding = FCML_TRUE;
1713
1714 modrm.address.effective_address.base.type = FCML_REG_GPR;
1715 modrm.address.effective_address.base.reg = FCML_REG_R15D;
1716 modrm.address.effective_address.base.size = FCML_DS_32;
1717 modrm.address.address_form = FCML_AF_COMBINED;
1718 modrm.reg_opcode = FCML_REG_R12D;
1719
1720 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1721
1722 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1723 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1724 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 1 );
1725 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 1 );
1726 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1727 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1728 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x27 );
1729 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1730 STF_ASSERT_EQUAL( context.is_sib_alternative, FCML_TRUE );
1731
1732 }
1733
1734 /* Encode [R15D+R10D*4], R12D*/
1735 void fcml_tf_modrm_sib_encoder_3264_bit_encoding_11(void) {
1736 fcml_st_modrm modrm;
1737 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1738 fcml_st_encoded_modrm encoded_modrm;
1739 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1740 fcml_st_modrm_encoder_context context;
1741 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1742 context.effective_address_size = FCML_DS_32;
1743 context.op_mode = FCML_OM_64_BIT;
1744 context.choose_sib_encoding = FCML_TRUE;
1745
1746 modrm.address.effective_address.base.type = FCML_REG_GPR;
1747 modrm.address.effective_address.base.reg = FCML_REG_R15D;
1748 modrm.address.effective_address.base.size = FCML_DS_32;
1749 modrm.address.effective_address.index.type = FCML_REG_GPR;
1750 modrm.address.effective_address.index.reg = FCML_REG_R10D;
1751 modrm.address.effective_address.index.size = FCML_DS_32;
1752 modrm.address.effective_address.scale_factor = 4;
1753 modrm.address.address_form = FCML_AF_COMBINED;
1754 modrm.reg_opcode = FCML_REG_R12D;
1755
1756 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1757
1758 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1759 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1760 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 1 );
1761 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 1 );
1762 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 1 );
1763 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_TRUE );
1764 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x97 );
1765 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x24 );
1766 STF_ASSERT_EQUAL( context.is_sib_alternative, FCML_FALSE );
1767
1768 }
1769
1770 void fcml_tf_modrm_rip_encoder_3264_bit_encoding_1(void) {
1771
1772 fcml_st_modrm modrm;
1773 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1774 fcml_st_encoded_modrm encoded_modrm;
1775 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1776 fcml_st_modrm_encoder_context context;
1777 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1778 context.effective_address_size = FCML_DS_32;
1779 context.op_mode = FCML_OM_64_BIT;
1780 context.choose_sib_encoding = FCML_TRUE;
1781 context.choose_rip_encoding = FCML_TRUE;
1782
1783 modrm.address.effective_address.base.type = FCML_REG_UNDEFINED;
1784 modrm.address.effective_address.base.reg = 0;
1785 modrm.address.effective_address.base.size = 0;
1786 modrm.address.effective_address.index.type = FCML_REG_UNDEFINED;
1787 modrm.address.effective_address.index.reg = 0;
1788 modrm.address.effective_address.index.size = 0;
1789 modrm.address.effective_address.scale_factor = 0;
1790 modrm.reg_opcode = 0;
1791 modrm.address.offset.size = FCML_DS_32;
1792 modrm.address.offset.off32 = 0x00401008;
1793 modrm.address.address_form = FCML_AF_OFFSET;
1794
1795 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1796
1797 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1798 /* Displacement is not encoded yet.*/
1799 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1800 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1801 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1802 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1803 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1804 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x00 );
1805 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x05 );
1806 STF_ASSERT_EQUAL( encoded_modrm.is_rip, FCML_TRUE );
1807 STF_ASSERT_EQUAL( encoded_modrm.rip_address, 0x00401008 );
1808
1809 fcml_uint8_t buff[4];
1810 fcml_st_memory_stream stream;
1811 stream.base_address = &buff;
1812 stream.offset = 0;
1813 stream.size = 4;
1814 error = fcml_fn_modrm_encode_rip_offset( &stream, 0x0000000000401000ULL, 8, &encoded_modrm );
1815
1816 STF_ASSERT_EQUAL( buff[0], 0x00 );
1817 STF_ASSERT_EQUAL( buff[1], 0x00 );
1818 STF_ASSERT_EQUAL( buff[2], 0x00 );
1819 STF_ASSERT_EQUAL( buff[3], 0x00 );
1820
1821 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1822 }
1823
1824 void fcml_tf_modrm_rip_encoder_3264_bit_encoding_2(void) {
1825
1826 fcml_st_modrm modrm;
1827 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1828 fcml_st_encoded_modrm encoded_modrm;
1829 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1830 fcml_st_modrm_encoder_context context;
1831 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1832 context.effective_address_size = FCML_DS_32;
1833 context.op_mode = FCML_OM_64_BIT;
1834 context.choose_sib_encoding = FCML_TRUE;
1835 context.choose_rip_encoding = FCML_TRUE;
1836
1837 modrm.address.effective_address.base.type = FCML_REG_UNDEFINED;
1838 modrm.address.effective_address.base.reg = 0;
1839 modrm.address.effective_address.base.size = 0;
1840 modrm.address.effective_address.index.type = FCML_REG_UNDEFINED;
1841 modrm.address.effective_address.index.reg = 0;
1842 modrm.address.effective_address.index.size = 0;
1843 modrm.address.effective_address.scale_factor = 0;
1844 modrm.reg_opcode = 0;
1845 modrm.address.offset.size = FCML_DS_32;
1846 modrm.address.address_form = FCML_AF_OFFSET;
1847
1848 /* Dispalcement range sanity check.*/
1849
1850 modrm.address.offset.size = FCML_DS_32;
1851 modrm.address.offset.off32 = 0xFFFFFFFFU;
1852 modrm.address.offset.is_signed = FCML_FALSE;
1853 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1854 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1855
1856 modrm.address.offset.size = FCML_DS_32;
1857 modrm.address.offset.off32 = 0x0U;
1858 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1859 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1860
1861 modrm.address.offset.size = FCML_DS_64;
1862 modrm.address.offset.off64 = 0x100000000U;
1863 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1864 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_VALUE_OUT_OF_RANGE );
1865
1866 modrm.address.offset.size = FCML_DS_64;
1867 modrm.address.offset.off64 = 0xFFFFFFFFFFFFFFFFU;
1868 modrm.address.offset.is_signed = FCML_TRUE;
1869 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1870 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1871
1872 modrm.address.offset.size = FCML_DS_64;
1873 modrm.address.offset.off64 = 0xFFFFFFFFFFFFFFFFU;
1874 modrm.address.offset.is_signed = FCML_FALSE;
1875 error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1876 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_VALUE_OUT_OF_RANGE );
1877
1878 }
1879
1880 void fcml_tf_modrm_rip_encoder_3264_bit_encoding_3(void) {
1881
1882 fcml_st_modrm modrm;
1883 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1884 fcml_st_encoded_modrm encoded_modrm;
1885 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1886 fcml_st_modrm_encoder_context context;
1887 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1888 context.effective_address_size = FCML_DS_32;
1889 context.op_mode = FCML_OM_64_BIT;
1890 context.choose_sib_encoding = FCML_TRUE;
1891 context.choose_rip_encoding = FCML_TRUE;
1892
1893 modrm.address.effective_address.base.type = FCML_REG_UNDEFINED;
1894 modrm.address.effective_address.base.reg = 0;
1895 modrm.address.effective_address.base.size = 0;
1896 modrm.address.effective_address.index.type = FCML_REG_UNDEFINED;
1897 modrm.address.effective_address.index.reg = 0;
1898 modrm.address.effective_address.index.size = 0;
1899 modrm.address.effective_address.scale_factor = 0;
1900 modrm.reg_opcode = 0;
1901 modrm.address.offset.size = FCML_DS_32;
1902 modrm.address.offset.off32 = 0x00000000;
1903 modrm.address.address_form = FCML_AF_OFFSET;
1904
1905 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1906
1907 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1908 /* Displacement is not encoded yet.*/
1909 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1910 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1911 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1912 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1913 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1914 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x00 );
1915 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x05 );
1916 STF_ASSERT_EQUAL( encoded_modrm.is_rip, FCML_TRUE );
1917 STF_ASSERT_EQUAL( encoded_modrm.rip_address, 0x00000000 );
1918
1919 fcml_uint8_t buff[4];
1920 fcml_st_memory_stream stream;
1921 stream.base_address = &buff;
1922 stream.offset = 0;
1923 stream.size = 4;
1924 error = fcml_fn_modrm_encode_rip_offset( &stream, 0x0000000000401000ULL, 8, &encoded_modrm );
1925
1926 STF_ASSERT_EQUAL( buff[0], 0xF8 );
1927 STF_ASSERT_EQUAL( buff[1], 0xEF );
1928 STF_ASSERT_EQUAL( buff[2], 0xBF );
1929 STF_ASSERT_EQUAL( buff[3], 0xFF );
1930
1931 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1932 }
1933
1934 void fcml_tf_modrm_rip_encoder_3264_bit_encoding_4(void) {
1935
1936 fcml_st_modrm modrm;
1937 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1938 fcml_st_encoded_modrm encoded_modrm;
1939 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1940 fcml_st_modrm_encoder_context context;
1941 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1942 context.effective_address_size = FCML_DS_32;
1943 context.op_mode = FCML_OM_64_BIT;
1944 context.choose_sib_encoding = FCML_TRUE;
1945 context.choose_rip_encoding = FCML_TRUE;
1946
1947 modrm.address.effective_address.base.type = FCML_REG_UNDEFINED;
1948 modrm.address.effective_address.base.reg = 0;
1949 modrm.address.effective_address.base.size = 0;
1950 modrm.address.effective_address.index.type = FCML_REG_UNDEFINED;
1951 modrm.address.effective_address.index.reg = 0;
1952 modrm.address.effective_address.index.size = 0;
1953 modrm.address.effective_address.scale_factor = 0;
1954 modrm.reg_opcode = 0;
1955 modrm.address.offset.size = FCML_DS_32;
1956 modrm.address.offset.off32 = 0xFFFFFFFF;
1957 modrm.address.offset.is_signed = FCML_TRUE;
1958 modrm.address.address_form = FCML_AF_OFFSET;
1959
1960 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
1961
1962 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1963 /* Displacement is not encoded yet.*/
1964 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 0 );
1965 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
1966 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
1967 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
1968 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
1969 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x00 );
1970 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x05 );
1971 STF_ASSERT_EQUAL( encoded_modrm.is_rip, FCML_TRUE );
1972 STF_ASSERT_EQUAL( encoded_modrm.rip_address, 0xFFFFFFFFFFFFFFFFLL );
1973
1974 fcml_uint8_t buff[4];
1975 fcml_st_memory_stream stream;
1976 stream.base_address = &buff;
1977 stream.offset = 0;
1978 stream.size = 4;
1979 error = fcml_fn_modrm_encode_rip_offset( &stream, 0x0000000000401000ULL, 8, &encoded_modrm );
1980
1981 STF_ASSERT_EQUAL( buff[0], 0xF7 );
1982 STF_ASSERT_EQUAL( buff[1], 0xEF );
1983 STF_ASSERT_EQUAL( buff[2], 0xBF );
1984 STF_ASSERT_EQUAL( buff[3], 0xFF );
1985
1986 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
1987 }
1988
1989 void fcml_tf_modrm_rip_encoder_3264_bit_encoding_5(void) {
1990
1991 fcml_st_modrm modrm;
1992 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
1993 fcml_st_encoded_modrm encoded_modrm;
1994 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
1995 fcml_st_modrm_encoder_context context;
1996 fcml_fn_env_memory_clear( &context, sizeof( context ) );
1997 context.effective_address_size = FCML_DS_64;
1998 context.op_mode = FCML_OM_64_BIT;
1999 context.choose_rip_encoding = FCML_FALSE;
2000
2001 modrm.address.effective_address.base.type = FCML_REG_IP;
2002 modrm.address.effective_address.base.reg = 0;
2003 modrm.address.effective_address.base.size = FCML_DS_64;
2004 modrm.address.effective_address.scale_factor = 0;
2005 modrm.address.effective_address.displacement.size = FCML_DS_32;
2006 modrm.address.effective_address.displacement.int32 = 0x100;
2007 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
2008 modrm.address.address_form = FCML_AF_COMBINED;
2009
2010 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm, &encoded_modrm );
2011
2012 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
2013 /* Displacement is not encoded yet.*/
2014 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
2015 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x00 );
2016 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x01 );
2017 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
2018 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
2019 STF_ASSERT_EQUAL( encoded_modrm.ext_B, 0 );
2020 STF_ASSERT_EQUAL( encoded_modrm.ext_R, 0 );
2021 STF_ASSERT_EQUAL( encoded_modrm.ext_X, 0 );
2022 STF_ASSERT_EQUAL( encoded_modrm.sib.is_not_null, FCML_FALSE );
2023 STF_ASSERT_EQUAL( encoded_modrm.sib.value, 0x00 );
2024 STF_ASSERT_EQUAL( encoded_modrm.modrm, 0x05 );
2025 STF_ASSERT_EQUAL( encoded_modrm.is_rip, FCML_TRUE );
2026 STF_ASSERT_EQUAL( encoded_modrm.is_rip_encoded, FCML_TRUE );
2027 STF_ASSERT_EQUAL( encoded_modrm.rip_address, 0x0LL );
2028 }
2029
2030 /* Encode [EBP+ZMM28*8], ZMM23 */
2031 void fcml_tf_modrm_vsib_EVEX_encoder_3264_bit_encoding(void) {
2032
2033 fcml_st_modrm modrm;
2034 fcml_fn_env_memory_clear(&modrm, sizeof(modrm));
2035 fcml_st_encoded_modrm encoded_modrm;
2036 fcml_fn_env_memory_clear(&encoded_modrm, sizeof(encoded_modrm));
2037 fcml_st_modrm_encoder_context context = { 0 };
2038 context.effective_address_size = FCML_DS_32;
2039 context.op_mode = FCML_OM_64_BIT;
2040
2041 modrm.address.effective_address.base.type = FCML_REG_GPR;
2042 modrm.address.effective_address.base.reg = FCML_REG_RBP;
2043 modrm.address.effective_address.base.size = FCML_DS_64;
2044 modrm.address.effective_address.index.type = FCML_REG_SIMD;
2045 modrm.address.effective_address.index.reg = FCML_REG_ZMM28;
2046 modrm.address.effective_address.index.size = FCML_DS_512;
2047 modrm.address.effective_address.scale_factor = 8;
2048 modrm.address.address_form = FCML_AF_COMBINED;
2049 modrm.reg_opcode = FCML_REG_ZMM23;
2050
2051 fcml_ceh_error error = fcml_fn_modrm_encode(&context, &modrm,
2052 &encoded_modrm);
2053
2054 STF_ASSERT_EQUAL(error, FCML_CEH_GEC_NO_ERROR);
2055 STF_ASSERT_EQUAL(encoded_modrm.displacement_size, 0);
2056 STF_ASSERT_EQUAL(encoded_modrm.ext_B, 0);
2057 STF_ASSERT_EQUAL(encoded_modrm.ext_R, 0);
2058 STF_ASSERT_EQUAL(encoded_modrm.ext_R_prim, 1);
2059 STF_ASSERT_EQUAL(encoded_modrm.ext_X, 1);
2060 STF_ASSERT_EQUAL(encoded_modrm.ext_V_prim, 1);
2061 STF_ASSERT_EQUAL(encoded_modrm.sib.is_not_null, FCML_TRUE);
2062 STF_ASSERT_EQUAL(encoded_modrm.sib.value, 0xE5);
2063 STF_ASSERT_EQUAL(encoded_modrm.modrm, 0x3C);
2064 }
2065
2066 /* Encode ZMM29, ZMM31 */
2067 void fcml_tf_modrm_encoder_EVEX_ext_reg_3264_bit_encoding(void) {
2068
2069 fcml_st_modrm modrm;
2070 fcml_fn_env_memory_clear(&modrm, sizeof(modrm));
2071 fcml_st_encoded_modrm encoded_modrm;
2072 fcml_fn_env_memory_clear(&encoded_modrm, sizeof(encoded_modrm));
2073 fcml_st_modrm_encoder_context context;
2074 fcml_fn_env_memory_clear(&context, sizeof(context));
2075 context.effective_address_size = FCML_DS_32;
2076 context.op_mode = FCML_OM_64_BIT;
2077
2078 modrm.reg.is_not_null = FCML_TRUE;
2079 modrm.reg.value = FCML_REG_ZMM29;
2080 modrm.reg_opcode = FCML_REG_ZMM31;
2081
2082 fcml_ceh_error error = fcml_fn_modrm_encode(&context, &modrm,
2083 &encoded_modrm);
2084
2085 STF_ASSERT_EQUAL(error, FCML_CEH_GEC_NO_ERROR);
2086 STF_ASSERT_EQUAL(encoded_modrm.displacement_size, 0);
2087 STF_ASSERT_EQUAL(encoded_modrm.ext_B, 1);
2088 STF_ASSERT_EQUAL(encoded_modrm.ext_R, 1);
2089 STF_ASSERT_EQUAL(encoded_modrm.ext_R_prim, 1);
2090 STF_ASSERT_EQUAL(encoded_modrm.ext_X, 1);
2091 STF_ASSERT_EQUAL(encoded_modrm.ext_V_prim, 0);
2092 STF_ASSERT_EQUAL(encoded_modrm.sib.is_not_null, FCML_FALSE);
2093 STF_ASSERT_EQUAL(encoded_modrm.sib.value, 0);
2094 STF_ASSERT_EQUAL(encoded_modrm.modrm, 0xFD);
2095 }
2096
2097 /* Encode compressed disp8 - uncompressed disp8n is used because ASA = 16.
2098 * In fact such an addressing mode is not allowed! */
2099 void fcml_tf_modrm_encoder_16bit_compressed_disp8_not_available_test(void) {
2100
2101 fcml_st_modrm modrm;
2102 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
2103
2104 modrm.address.effective_address.base.reg = FCML_REG_BP;
2105 modrm.address.effective_address.base.type = FCML_REG_GPR;
2106 modrm.address.effective_address.base.size = FCML_DS_16;
2107 modrm.address.effective_address.displacement.size = FCML_DS_8;
2108 modrm.address.effective_address.displacement.int8 = (fcml_int8_t)0xF0;
2109 modrm.address.effective_address.displacement.is_signed = FCML_FALSE;
2110 modrm.address.address_form = FCML_AF_COMBINED;
2111
2112 fcml_st_modrm_encoder_context context = {0};
2113 context.op_mode = FCML_OM_16_BIT;
2114 context.effective_address_size = FCML_DS_16;
2115 context.is_evex = FCML_TRUE;
2116 context.input_size = FCML_DS_16;
2117 context.vector_length = FCML_DS_128;
2118
2119 fcml_st_encoded_modrm encoded_modrm;
2120 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
2121
2122 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm,
2123 &encoded_modrm );
2124
2125 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
2126 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0xF0 );
2127 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
2128 }
2129
2130 /* Encode disp8 - 16-bit addressing mode but ASA overridden to 32-bites, so
2131 * compression can be used. */
2132 void fcml_tf_modrm_encoder_16bit_compressed_disp8_available_test(void) {
2133
2134 fcml_st_modrm modrm;
2135 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
2136
2137 modrm.address.effective_address.base.reg = FCML_REG_EBP;
2138 modrm.address.effective_address.base.type = FCML_REG_GPR;
2139 modrm.address.effective_address.base.size = FCML_DS_32;
2140 modrm.address.effective_address.displacement.size = FCML_DS_8;
2141 modrm.address.effective_address.displacement.int8 = (fcml_int8_t)0xF0;
2142 modrm.address.effective_address.displacement.is_signed = FCML_FALSE;
2143 modrm.address.address_form = FCML_AF_COMBINED;
2144
2145 fcml_st_modrm_encoder_context context = {0};
2146 context.op_mode = FCML_OM_16_BIT;
2147 context.effective_address_size = FCML_DS_32;
2148 context.is_evex = FCML_TRUE;
2149 context.input_size = FCML_DS_32;
2150 context.vector_length = FCML_DS_128;
2151 context.tuple_type = FCML_TT_FV;
2152
2153 fcml_st_encoded_modrm encoded_modrm;
2154 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
2155
2156 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm,
2157 &encoded_modrm );
2158
2159 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
2160 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x0F ); /* Compressed. */
2161 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
2162 }
2163
2164 /* Encode disp8 - 32-bit addressing. Value cannot be encoded as compressed
2165 * displacement because it's too big. */
2166 void fcml_tf_modrm_encoder_32bit_compressed_disp8_not_available_test(void) {
2167
2168 fcml_st_modrm modrm;
2169 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
2170
2171 modrm.address.effective_address.base.reg = FCML_REG_EBP;
2172 modrm.address.effective_address.base.type = FCML_REG_GPR;
2173 modrm.address.effective_address.base.size = FCML_DS_32;
2174 modrm.address.effective_address.displacement.size = FCML_DS_32;
2175 modrm.address.effective_address.displacement.int32 = 128 * 16;
2176 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
2177 modrm.address.address_form = FCML_AF_COMBINED;
2178
2179 fcml_st_modrm_encoder_context context = {0};
2180 context.op_mode = FCML_OM_32_BIT;
2181 context.effective_address_size = FCML_DS_32;
2182 context.is_evex = FCML_TRUE;
2183 context.input_size = FCML_DS_32;
2184 context.vector_length = FCML_DS_128;
2185 context.tuple_type = FCML_TT_FV;
2186
2187 fcml_st_encoded_modrm encoded_modrm;
2188 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
2189
2190 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm,
2191 &encoded_modrm );
2192
2193 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
2194 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x00 );
2195 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x08 );
2196 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
2197 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
2198 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
2199 }
2200
2201 /* Encode disp8 - 32-bit addressing. 32-bit displacement compressed to
2202 * disp8, becaue after compression it fits 8-bits. */
2203 void fcml_tf_modrm_encoder_32bit_compressed_disp8_available_test(void) {
2204
2205 fcml_st_modrm modrm;
2206 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
2207
2208 modrm.address.effective_address.base.reg = FCML_REG_EBP;
2209 modrm.address.effective_address.base.type = FCML_REG_GPR;
2210 modrm.address.effective_address.base.size = FCML_DS_32;
2211 modrm.address.effective_address.displacement.size = FCML_DS_32;
2212 modrm.address.effective_address.displacement.int32 = 127 * 16;
2213 modrm.address.effective_address.displacement.is_signed = FCML_FALSE;
2214 modrm.address.address_form = FCML_AF_COMBINED;
2215
2216 fcml_st_modrm_encoder_context context = {0};
2217 context.op_mode = FCML_OM_32_BIT;
2218 context.effective_address_size = FCML_DS_32;
2219 context.is_evex = FCML_TRUE;
2220 context.input_size = FCML_DS_32;
2221 context.vector_length = FCML_DS_128;
2222 context.tuple_type = FCML_TT_FV;
2223
2224 fcml_st_encoded_modrm encoded_modrm;
2225 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
2226
2227 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm,
2228 &encoded_modrm );
2229
2230 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
2231 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x7f ); /* Compressed. */
2232 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 1 );
2233 }
2234
2235 /* Encode disp8 - Disp8 cannot be used because there is a remainder
2236 * after division by N. */
2237 void fcml_tf_modrm_encoder_32bit_compressed_disp8_not_available_rem_test(void) {
2238
2239 fcml_st_modrm modrm;
2240 fcml_fn_env_memory_clear( &modrm, sizeof( modrm ) );
2241
2242 modrm.address.effective_address.base.reg = FCML_REG_EBP;
2243 modrm.address.effective_address.base.type = FCML_REG_GPR;
2244 modrm.address.effective_address.base.size = FCML_DS_32;
2245 modrm.address.effective_address.displacement.size = FCML_DS_32;
2246 modrm.address.effective_address.displacement.int32 = 5 * 16 + 1;
2247 modrm.address.effective_address.displacement.is_signed = FCML_TRUE;
2248 modrm.address.address_form = FCML_AF_COMBINED;
2249
2250 fcml_st_modrm_encoder_context context = {0};
2251 context.op_mode = FCML_OM_32_BIT;
2252 context.effective_address_size = FCML_DS_32;
2253 context.is_evex = FCML_TRUE;
2254 context.input_size = FCML_DS_32;
2255 context.vector_length = FCML_DS_128;
2256 context.tuple_type = FCML_TT_FV;
2257
2258 fcml_st_encoded_modrm encoded_modrm;
2259 fcml_fn_env_memory_clear( &encoded_modrm, sizeof( encoded_modrm ) );
2260
2261 fcml_ceh_error error = fcml_fn_modrm_encode( &context, &modrm,
2262 &encoded_modrm );
2263
2264 STF_ASSERT_EQUAL( error, FCML_CEH_GEC_NO_ERROR );
2265 STF_ASSERT_EQUAL( encoded_modrm.displacement[0], 0x51 );
2266 STF_ASSERT_EQUAL( encoded_modrm.displacement[1], 0x00 );
2267 STF_ASSERT_EQUAL( encoded_modrm.displacement[2], 0x00 );
2268 STF_ASSERT_EQUAL( encoded_modrm.displacement[3], 0x00 );
2269 STF_ASSERT_EQUAL( encoded_modrm.displacement_size, 4 );
2270 }
2271
2272 fcml_stf_test_case fctl_ti_modrm_encoder[] = {
2273 { "fcml_tf_modrm_encoder_test_1", fcml_tf_modrm_encoder_test_1 },
2274 { "fcml_tf_modrm_encoder_test_2", fcml_tf_modrm_encoder_test_2 },
2275 { "fcml_tf_modrm_encoder_test_3", fcml_tf_modrm_encoder_test_3 },
2276 { "fcml_tf_modrm_encoder_test_4", fcml_tf_modrm_encoder_test_4 },
2277 { "fcml_tf_modrm_encoder_test_5", fcml_tf_modrm_encoder_test_5 },
2278 { "fcml_tf_modrm_encoder_test_6", fcml_tf_modrm_encoder_test_6 },
2279 { "fcml_tf_modrm_encoder_test_7", fcml_tf_modrm_encoder_test_7 },
2280 { "fcml_tf_modrm_encoder_test_8", fcml_tf_modrm_encoder_test_8 },
2281 { "fcml_tf_modrm_encoder_test_9", fcml_tf_modrm_encoder_test_9 },
2282 { "fcml_tf_modrm_encoder_test_10", fcml_tf_modrm_encoder_test_10 },
2283 { "fcml_tf_modrm_encoder_test_11", fcml_tf_modrm_encoder_test_11 },
2284 { "fcml_tf_modrm_encoder_test_12", fcml_tf_modrm_encoder_test_12 },
2285 { "fcml_tf_modrm_encoder_test_13", fcml_tf_modrm_encoder_test_13 },
2286 { "fcml_tf_modrm_encoder_test_14", fcml_tf_modrm_encoder_test_14 },
2287 { "fcml_tf_modrm_encoder_16_bit_encoding_1", fcml_tf_modrm_encoder_16_bit_encoding_1 },
2288 { "fcml_tf_modrm_encoder_16_bit_encoding_2", fcml_tf_modrm_encoder_16_bit_encoding_2 },
2289 { "fcml_tf_modrm_encoder_16_bit_encoding_3", fcml_tf_modrm_encoder_16_bit_encoding_3 },
2290 { "fcml_tf_modrm_encoder_16_bit_encoding_4", fcml_tf_modrm_encoder_16_bit_encoding_4 },
2291 { "fcml_tf_modrm_encoder_16_bit_encoding_5", fcml_tf_modrm_encoder_16_bit_encoding_5 },
2292 { "fcml_tf_modrm_encoder_16_bit_encoding_6", fcml_tf_modrm_encoder_16_bit_encoding_6 },
2293 { "fcml_tf_modrm_encoder_16_bit_encoding_7", fcml_tf_modrm_encoder_16_bit_encoding_7 },
2294 { "fcml_tf_modrm_encoder_16_bit_encoding_8", fcml_tf_modrm_encoder_16_bit_encoding_8 },
2295 { "fcml_tf_modrm_encoder_16_bit_encoding_9", fcml_tf_modrm_encoder_16_bit_encoding_9 },
2296 { "fcml_tf_modrm_encoder_16_bit_encoding_10", fcml_tf_modrm_encoder_16_bit_encoding_10 },
2297 { "fcml_tf_modrm_encoder_16_bit_encoding_11", fcml_tf_modrm_encoder_16_bit_encoding_11 },
2298 { "fcml_tf_modrm_encoder_16_bit_encoding_12", fcml_tf_modrm_encoder_16_bit_encoding_12 },
2299 { "fcml_tf_modrm_encoder_16_bit_encoding_13", fcml_tf_modrm_encoder_16_bit_encoding_13 },
2300 { "fcml_tf_modrm_encoder_3264_bit_encoding_1", fcml_tf_modrm_encoder_3264_bit_encoding_1 },
2301 { "fcml_tf_modrm_encoder_3264_bit_encoding_2", fcml_tf_modrm_encoder_3264_bit_encoding_2 },
2302 { "fcml_tf_modrm_encoder_3264_bit_encoding_3", fcml_tf_modrm_encoder_3264_bit_encoding_3 },
2303 { "fcml_tf_modrm_encoder_3264_bit_encoding_4", fcml_tf_modrm_encoder_3264_bit_encoding_4 },
2304 { "fcml_tf_modrm_encoder_3264_bit_encoding_5", fcml_tf_modrm_encoder_3264_bit_encoding_5 },
2305 { "fcml_tf_modrm_encoder_3264_bit_encoding_6", fcml_tf_modrm_encoder_3264_bit_encoding_6 },
2306 { "fcml_tf_modrm_encoder_3264_bit_encoding_7", fcml_tf_modrm_encoder_3264_bit_encoding_7 },
2307 { "fcml_tf_modrm_encoder_3264_bit_encoding_8", fcml_tf_modrm_encoder_3264_bit_encoding_8 },
2308 { "fcml_tf_modrm_encoder_3264_bit_encoding_9", fcml_tf_modrm_encoder_3264_bit_encoding_9 },
2309 { "fcml_tf_modrm_encoder_3264_bit_encoding_10", fcml_tf_modrm_encoder_3264_bit_encoding_10 },
2310 { "fcml_tf_modrm_encoder_3264_bit_encoding_11", fcml_tf_modrm_encoder_3264_bit_encoding_11 },
2311 { "fcml_tf_modrm_encoder_3264_bit_encoding_12", fcml_tf_modrm_encoder_3264_bit_encoding_12 },
2312 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_1", fcml_tf_modrm_sib_encoder_3264_bit_encoding_1 },
2313 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_2", fcml_tf_modrm_sib_encoder_3264_bit_encoding_2 },
2314 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_3", fcml_tf_modrm_sib_encoder_3264_bit_encoding_3 },
2315 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_4", fcml_tf_modrm_sib_encoder_3264_bit_encoding_4 },
2316 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_5", fcml_tf_modrm_sib_encoder_3264_bit_encoding_5 },
2317 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_6", fcml_tf_modrm_sib_encoder_3264_bit_encoding_6 },
2318 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_7", fcml_tf_modrm_sib_encoder_3264_bit_encoding_7 },
2319 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_8", fcml_tf_modrm_sib_encoder_3264_bit_encoding_8 },
2320 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_9", fcml_tf_modrm_sib_encoder_3264_bit_encoding_9 },
2321 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_10", fcml_tf_modrm_sib_encoder_3264_bit_encoding_10 },
2322 { "fcml_tf_modrm_sib_encoder_3264_bit_encoding_11", fcml_tf_modrm_sib_encoder_3264_bit_encoding_11 },
2323 { "fcml_tf_modrm_rip_encoder_3264_bit_encoding_1", fcml_tf_modrm_rip_encoder_3264_bit_encoding_1 },
2324 { "fcml_tf_modrm_rip_encoder_3264_bit_encoding_2", fcml_tf_modrm_rip_encoder_3264_bit_encoding_2 },
2325 { "fcml_tf_modrm_rip_encoder_3264_bit_encoding_3", fcml_tf_modrm_rip_encoder_3264_bit_encoding_3 },
2326 { "fcml_tf_modrm_rip_encoder_3264_bit_encoding_4", fcml_tf_modrm_rip_encoder_3264_bit_encoding_4 },
2327 { "fcml_tf_modrm_rip_encoder_3264_bit_encoding_5", fcml_tf_modrm_rip_encoder_3264_bit_encoding_5 },
2328 { "fcml_tf_modrm_vsib_EVEX_encoder_3264_bit_encoding",
2329 fcml_tf_modrm_vsib_EVEX_encoder_3264_bit_encoding },
2330 { "fcml_tf_modrm_encoder_EVEX_ext_reg_3264_bit_encoding",
2331 fcml_tf_modrm_encoder_EVEX_ext_reg_3264_bit_encoding },
2332 { "fcml_tf_modrm_encoder_16bit_compressed_disp8_not_available_test",
2333 fcml_tf_modrm_encoder_16bit_compressed_disp8_not_available_test },
2334 { "fcml_tf_modrm_encoder_16bit_compressed_disp8_available_test",
2335 fcml_tf_modrm_encoder_16bit_compressed_disp8_available_test },
2336 { "fcml_tf_modrm_encoder_32bit_compressed_disp8_not_available_test",
2337 fcml_tf_modrm_encoder_32bit_compressed_disp8_not_available_test },
2338 { "fcml_tf_modrm_encoder_32bit_compressed_disp8_available_test",
2339 fcml_tf_modrm_encoder_32bit_compressed_disp8_available_test },
2340 { "fcml_tf_modrm_encoder_32bit_compressed_disp8_not_available_rem_test",
2341 fcml_tf_modrm_encoder_32bit_compressed_disp8_not_available_rem_test },
2342 FCML_STF_NULL_TEST
2343 };
2344
2345 fcml_stf_test_suite fctl_si_modrm_encoder = {
2346 "suite-modrm-encoder", fcml_tf_modrm_encoder_suite_init, fcml_tf_modrm_encoder_suite_cleanup, fctl_ti_modrm_encoder
2347 };