Debian Codegraph @

check/cpp-tests/disassembler_t.cpp

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 /* Test suite initialization. */
21
22 #include "disassembler_t.hpp"
23
24 #include <fcml_common.hpp>
25 #include <fcml_disassembler.hpp>
26 #include <fcml_renderer.hpp>
27 #include <fcml_registers.hpp>
28 #include <fcml_intel_dialect.hpp>
29 #include <fcml_gas_dialect.hpp>
30 #include <fcml_stateful_disassembler.hpp>
31 #include <fcml_gas_mnemonics.hpp>
32 #include <string.h>
33
34 using namespace fcml;
35 using namespace fcml::gas;
36
37 fcml_bool fcml_tf_cpp_disassembler_suite_init(void) {
38 return FCML_TRUE;
39 }
40
41 fcml_bool fcml_tf_cpp_disassembler_suite_cleanup(void) {
42 return FCML_TRUE;
43 }
44
45 void fcml_tf_cpp_disassemble(void) {
46
47 fcml_uint8_t code[] = {0x80, 0x54, 0x01, 0x02, 0x03};
48
49 try {
50
51 IntelDialect dialect;
52
53 Disassembler disassembler( dialect );
54
55 DisassemblerContext ctx( code , sizeof( code ) );
56 ctx.setIP(0x401000);
57 ctx.setOperatingMode(EntryPoint::OM_32_BIT);
58
59 DisassemblerResult result;
60
61 disassembler.disassemble( ctx, result );
62
63 const Instruction &instruction = result.getInstruction();
64
65 STF_ASSERT( instruction.getMnemonic() == M_ADC );
66
67 Renderer renderer( dialect );
68
69 RenderConfig config;
70
71 fcml_cstring instructionMnemonic;
72
73 renderer.render( config, result, instructionMnemonic );
74
75 STF_ASSERT_STRING_EQUAL( instructionMnemonic.c_str(), FCML_TEXT("adc byte ptr [ecx+eax+2],3") );
76
77 } catch( BaseException &exc ) {
78 STF_FAIL("Exception while disassembling the code.");
79 }
80
81 }
82
83 /* A 64-bit GDB dump used as an example.
84 Dump of assembler code for function main(int, char**):
85 0x0000000000404ddc <+0>: 55 push %rbp
86 0x0000000000404ddd <+1>: 48 89 e5 mov %rsp,%rbp
87 0x0000000000404de0 <+4>: 48 83 ec 20 sub $0x20,%rsp
88 0x0000000000404de4 <+8>: 89 7d ec mov %edi,-0x14(%rbp)
89 0x0000000000404de7 <+11>: 48 89 75 e0 mov %rsi,-0x20(%rbp)
90 0x0000000000404deb <+15>: be 60 d2 62 00 mov $0x62d260,%esi
91 0x0000000000404df0 <+20>: bf e8 db 41 00 mov $0x41dbe8,%edi
92 0x0000000000404df5 <+25>: e8 1f 89 01 00 callq 0x41d719
93 */
94
95 fcml_uint8_t fcml_iarr_instruction_buffer_binary_code[] = {
96 0x55,
97 0x48, 0x89, 0xe5,
98 0x48, 0x83, 0xec, 0x20,
99 0x89, 0x7d, 0xec,
100 0x48, 0x89, 0x75, 0xe0,
101 0xbe, 0x60, 0xd2, 0x62, 0x00,
102 0xbf, 0xe8, 0xdb, 0x41, 0x00,
103 0xe8, 0x1f, 0x89, 0x01, 0x00
104 };
105
106 void fcml_tf_cpp_disassemble_instruction_buffer_disassemble_only(void) {
107
108 try {
109
110 GASDialect dialect;
111
112 Disassembler disassembler( dialect );
113
114 DisassemblerContext ctx( fcml_iarr_instruction_buffer_binary_code , sizeof( fcml_iarr_instruction_buffer_binary_code ) );
115 ctx.setIP(0x404ddc);
116 ctx.setOperatingMode(EntryPoint::OM_64_BIT);
117
118 StatefulDisassembler disas( disassembler, ctx, true );
119
120 Instruction instruction;
121
122 disas >> instruction;
123 STF_ASSERT( instruction.getMnemonic() == M_PUSH );
124 disas >> instruction;
125 STF_ASSERT( instruction.getMnemonic() == M_MOV );
126
127 } catch( BaseException &exc ) {
128 STF_FAIL("Exception while disassembling the code.");
129 }
130
131 }
132
133 void fcml_tf_cpp_disassemble_instruction_buffer_disassemble_render(void) {
134
135 try {
136
137 GASDialect dialect;
138
139 Disassembler disassembler( dialect );
140
141 DisassemblerContext ctx( fcml_iarr_instruction_buffer_binary_code , sizeof( fcml_iarr_instruction_buffer_binary_code ) );
142 ctx.setIP(0x404ddc);
143 ctx.setOperatingMode(EntryPoint::OM_64_BIT);
144
145 StatefulDisassembler disas( disassembler, ctx, true );
146
147 fcml_cstring instruction;
148
149 disas >> instruction;
150 STF_ASSERT( instruction == FCML_TEXT( "push %rbp" ) );
151 disas >> instruction;
152 STF_ASSERT( instruction == FCML_TEXT( "mov %rsp,%rbp" ) );
153 disas >> instruction;
154 STF_ASSERT( instruction == FCML_TEXT( "sub $32,%rsp" ) );
155 disas >> instruction;
156 STF_ASSERT( instruction == FCML_TEXT( "mov %edi,-20(%ebp)" ) );
157 disas >> instruction;
158 STF_ASSERT( instruction == FCML_TEXT( "mov %rsi,-32(%ebp)" ) );
159 disas >> instruction;
160 STF_ASSERT( instruction == FCML_TEXT( "mov $6476384,%esi" ) );
161 disas >> instruction;
162 STF_ASSERT( instruction == FCML_TEXT( "mov $4316136,%edi" ) );
163 disas >> instruction;
164 STF_ASSERT( instruction == FCML_TEXT( "callq 0x000000000041d719" ) );
165
166 } catch( BaseException &exc ) {
167 STF_FAIL("Exception while disassembling the code.");
168 }
169
170 }
171
172 void fcml_tf_cpp_disassemble_instruction_buffer_disassemble_only_stream(void) {
173
174 try {
175
176 GASDialect dialect;
177
178 Disassembler disassembler( dialect );
179
180 DisassemblerContext ctx( fcml_iarr_instruction_buffer_binary_code , sizeof( fcml_iarr_instruction_buffer_binary_code ) );
181 ctx.setIP(0x404ddc);
182 ctx.setOperatingMode(EntryPoint::OM_64_BIT);
183
184 StatefulDisassembler disas( disassembler, ctx, true );
185
186 fcml_costream ostream;
187
188 disas >> ostream;
189 disas >> ostream;
190
191 fcml_cstring src = ostream.str();
192
193 #if defined(_WIN32)
194 STF_ASSERT( src == _FT("push %rbp\r\nmov %rsp,%rbp\r\n") );
195 #else
196 STF_ASSERT( src == _FT("push %rbp\nmov %rsp,%rbp\n") );
197 #endif
198
199 } catch( BaseException &exc ) {
200 STF_FAIL("Exception while disassembling the code.");
201 }
202
203 }
204
205 void fcml_tf_cpp_disassembleshould_convert_instruction_details_correctly(void) {
206
207 fcml_st_instruction_details details = {};
208
209 fcml_st_prefixes_details *prefixes_details = &(details.prefixes_details);
210 prefixes_details->B = 1;
211 prefixes_details->L = 2;
212 prefixes_details->L_prim = 3;
213 prefixes_details->R = 4;
214 prefixes_details->R_prim = 5;
215 prefixes_details->V_prim = 6;
216 prefixes_details->W = 7;
217 prefixes_details->X = 8;
218 prefixes_details->aaa = 9;
219 prefixes_details->avx_first_byte = 10;
220 prefixes_details->b = 1;
221 prefixes_details->is_avx = FCML_TRUE;
222 prefixes_details->is_branch = FCML_TRUE;
223 prefixes_details->is_evex = FCML_TRUE;
224 prefixes_details->is_lock = FCML_TRUE;
225 prefixes_details->is_nobranch = FCML_TRUE;
226 prefixes_details->is_rep = FCML_TRUE;
227 prefixes_details->is_repne = FCML_TRUE;
228 prefixes_details->is_rex = FCML_TRUE;
229 prefixes_details->is_vex = FCML_TRUE;
230 prefixes_details->is_xacquire = FCML_TRUE;
231 prefixes_details->is_xop = FCML_TRUE;
232 prefixes_details->is_xrelease = FCML_TRUE;
233 prefixes_details->mmmm = 12;
234 prefixes_details->pp = 13;
235
236 fcml_st_instruction_prefix *prefix = &(prefixes_details->prefixes[0]);
237 prefix->prefix = 0x62;
238 prefix->avx_bytes[0] = 0x31;
239 prefix->avx_bytes[1] = 0x40;
240 prefix->avx_bytes[2] = 0x64;
241 prefix->prefix_type = FCML_PT_EVEX;
242 prefix->mandatory_prefix = FCML_TRUE;
243
244 prefixes_details->prefixes_bytes_count = 1;
245 prefixes_details->prefixes_count = 8;
246 prefixes_details->vvvv = 14;
247 prefixes_details->z = 1;
248
249 fcml_st_decoded_modrm_details *modrm_details = &(details.modrm_details);
250 modrm_details->displacement.N.value = 8;
251 modrm_details->displacement.N.is_not_null = FCML_TRUE;
252 modrm_details->displacement.displacement.size = 32;
253 modrm_details->displacement.displacement.int32= 0x12345678;
254 modrm_details->is_modrm = FCML_TRUE;
255 modrm_details->is_rip = FCML_TRUE;
256 modrm_details->modrm = 0x40;
257 modrm_details->sib.value = 0x20;
258 modrm_details->sib.is_not_null = FCML_TRUE;
259
260 details.operand_details[0].access_mode = FCML_AM_READ_WRITE;
261 details.operand_details[1].access_mode = FCML_AM_READ;
262 details.operand_details[2].access_mode = FCML_AM_WRITE;
263 details.operand_details[3].access_mode = FCML_AM_READ_WRITE;
264 details.operand_details[4].access_mode = FCML_AM_READ_WRITE;
265
266 details.is_shortcut = FCML_TRUE;
267 details.is_pseudo_op = FCML_TRUE;
268 details.instruction_code[0] = 0x01;
269 details.instruction_code[FCML_INSTRUCTION_SIZE - 1] = 0xFF;
270
271 details.instruction_size = 15;
272 details.opcode_field_s_bit = FCML_TRUE;
273 details.opcode_field_w_bit = FCML_TRUE;
274 details.instruction = F_VAESDEC;
275 details.pseudo_op = FP_DB;
276
277 details.pseudo_op = FP_DB;
278 details.addr_mode = 0x1111;
279 details.instruction_group = FCML_AMT_GPI;
280 details.tuple_type = FCML_TT_M128;
281
282 InstructionDetails destDetails;
283
284 DisassemblerTypeConverter::convert(details, destDetails);
285
286 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getB(), 1);
287 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getL(), 2);
288 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getLPrim(), 3);
289 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getR(), 4);
290 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getRPrim(), 5);
291 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getVPrim(), 6);
292 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getW(), 7);
293 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getX(), 8);
294 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getAaa(), 9);
295 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getAvxFirstByte(), 10);
296 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getBcast(), true);
297 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isAvx(), true);
298 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isBranch(), true);
299 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isEvex(), true);
300 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isLock(), true);
301 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isNobranch(), true);
302 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isRep(), true);
303 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isRepne(), true);
304 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isRex(), true);
305 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isVex(), true);
306 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isXacquire(), true);
307 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isXop(), true);
308 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().isXrelease(), true);
309 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getMmmm(), 12);
310 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPp(), 13);
311 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixesBytesCount(), 1);
312 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixesCount(), 8);
313 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getVvvv(), 14);
314 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getZ(), true);
315
316 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixes(0).getPrefix(), 0x62);
317 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixes(0).getAvxBytes()[0], 0x31);
318 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixes(0).getAvxBytes()[1], 0x40);
319 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixes(0).getAvxBytes()[2], 0x64);
320 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixes(0).getPrefixType(), InstructionPrefixDetails::PT_EVEX);
321 STF_ASSERT_EQUAL(destDetails.getPrefixesDetails().getPrefixes(0).isMandatoryPrefix(), true);
322
323 DecodedModRMDetails &modrmDetails = destDetails.getModRmDetails();
324 STF_ASSERT(modrmDetails.getN() == Nullable<fcml_uint32_t>(8));
325 STF_ASSERT(modrmDetails.getDisplacement() == Integer(fcml_int32_t(0x12345678)));
326 STF_ASSERT(modrmDetails.getModRM() == Nullable<fcml_uint8_t>(0x40));
327 STF_ASSERT(modrmDetails.isRip());
328 STF_ASSERT(modrmDetails.getSib() == Nullable<fcml_uint8_t>(0x20));
329
330 STF_ASSERT_EQUAL(destDetails.getOperandDetails(0).getAccessMode(), OperandDetails::AM_READ_WRITE);
331 STF_ASSERT_EQUAL(destDetails.getOperandDetails(1).getAccessMode(), OperandDetails::AM_READ);
332 STF_ASSERT_EQUAL(destDetails.getOperandDetails(2).getAccessMode(), OperandDetails::AM_WRITE);
333 STF_ASSERT_EQUAL(destDetails.getOperandDetails(3).getAccessMode(), OperandDetails::AM_READ_WRITE);
334 STF_ASSERT_EQUAL(destDetails.getOperandDetails(4).getAccessMode(), OperandDetails::AM_READ_WRITE);
335
336 STF_ASSERT(destDetails.isShortcut());
337 STF_ASSERT(destDetails.isPseudoOp());
338 STF_ASSERT_EQUAL(destDetails.getInstructionCode()[0], 0x01);
339 STF_ASSERT_EQUAL(destDetails.getInstructionCode()[FCML_INSTRUCTION_SIZE - 1], 0xFF);
340 STF_ASSERT_EQUAL(destDetails.getInstructionSize(), 15);
341 STF_ASSERT(destDetails.isOpcodeFieldSBit());
342 STF_ASSERT(destDetails.isOpcodeFieldWBit());
343 STF_ASSERT_EQUAL(destDetails.getInstruction(), F_VAESDEC);
344 STF_ASSERT_EQUAL(destDetails.getPseudoOp(), FP_DB);
345 STF_ASSERT(destDetails.getAddrMode() == 0x1111);
346 STF_ASSERT(destDetails.getInstructionGroup() == FCML_AMT_GPI);
347 STF_ASSERT(destDetails.getTupleType() == FCML_TT_M128);
348
349 fcml_st_instruction_details det = {};
350
351 DisassemblerTypeConverter::convert(destDetails, det);
352
353 prefixes_details = &(det.prefixes_details);
354 STF_ASSERT_EQUAL(prefixes_details->B, 1);
355 STF_ASSERT_EQUAL(prefixes_details->L, 2);
356 STF_ASSERT_EQUAL(prefixes_details->L_prim, 3);
357 STF_ASSERT_EQUAL(prefixes_details->R, 4);
358 STF_ASSERT_EQUAL(prefixes_details->R_prim, 5);
359 STF_ASSERT_EQUAL(prefixes_details->V_prim, 6);
360 STF_ASSERT_EQUAL(prefixes_details->W, 7);
361 STF_ASSERT_EQUAL(prefixes_details->X, 8);
362 STF_ASSERT_EQUAL(prefixes_details->aaa, 9);
363 STF_ASSERT_EQUAL(prefixes_details->avx_first_byte, 10);
364 STF_ASSERT(prefixes_details->b);
365 STF_ASSERT(prefixes_details->is_avx);
366 STF_ASSERT(prefixes_details->is_branch);
367 STF_ASSERT(prefixes_details->is_evex);
368 STF_ASSERT(prefixes_details->is_lock);
369 STF_ASSERT(prefixes_details->is_nobranch);
370 STF_ASSERT(prefixes_details->is_rep);
371 STF_ASSERT(prefixes_details->is_repne);
372 STF_ASSERT(prefixes_details->is_rex);
373 STF_ASSERT(prefixes_details->is_vex);
374 STF_ASSERT(prefixes_details->is_xacquire);
375 STF_ASSERT(prefixes_details->is_xop);
376 STF_ASSERT(prefixes_details->is_xrelease);
377 STF_ASSERT_EQUAL(prefixes_details->mmmm, 12);
378 STF_ASSERT_EQUAL(prefixes_details->pp, 13);
379
380 prefix = &(prefixes_details->prefixes[0]);
381 STF_ASSERT_EQUAL(prefix->prefix, 0x62);
382 STF_ASSERT_EQUAL(prefix->avx_bytes[0], 0x31);
383 STF_ASSERT_EQUAL(prefix->avx_bytes[1], 0x40);
384 STF_ASSERT_EQUAL(prefix->avx_bytes[2], 0x64);
385 STF_ASSERT_EQUAL(prefix->prefix_type, FCML_PT_EVEX);
386 STF_ASSERT_EQUAL(prefix->mandatory_prefix, FCML_TRUE);
387
388 STF_ASSERT_EQUAL(prefixes_details->prefixes_bytes_count, 1);
389 STF_ASSERT_EQUAL(prefixes_details->prefixes_count, 8);
390 STF_ASSERT_EQUAL(prefixes_details->vvvv, 14);
391 STF_ASSERT_EQUAL(prefixes_details->z, 1);
392
393 modrm_details = &(det.modrm_details);
394 STF_ASSERT_EQUAL(modrm_details->displacement.N.value, 8);
395 STF_ASSERT_EQUAL(modrm_details->displacement.N.is_not_null, FCML_TRUE);
396 STF_ASSERT_EQUAL(modrm_details->displacement.displacement.size, 32);
397 STF_ASSERT_EQUAL(modrm_details->displacement.displacement.int32, 0x12345678);
398 STF_ASSERT_EQUAL(modrm_details->is_modrm, FCML_TRUE);
399 STF_ASSERT_EQUAL(modrm_details->is_rip, FCML_TRUE);
400 STF_ASSERT_EQUAL(modrm_details->modrm, 0x40);
401 STF_ASSERT_EQUAL(modrm_details->sib.value, 0x20);
402 STF_ASSERT_EQUAL(modrm_details->sib.is_not_null, FCML_TRUE);
403
404 STF_ASSERT_EQUAL(det.operand_details[0].access_mode, FCML_AM_READ_WRITE);
405 STF_ASSERT_EQUAL(det.operand_details[1].access_mode, FCML_AM_READ);
406 STF_ASSERT_EQUAL(det.operand_details[2].access_mode, FCML_AM_WRITE);
407 STF_ASSERT_EQUAL(det.operand_details[3].access_mode, FCML_AM_READ_WRITE);
408 STF_ASSERT_EQUAL(det.operand_details[4].access_mode, FCML_AM_READ_WRITE);
409
410 STF_ASSERT_EQUAL(det.is_shortcut, FCML_TRUE);
411 STF_ASSERT_EQUAL(det.is_pseudo_op, FCML_TRUE);
412 STF_ASSERT_EQUAL(det.instruction_code[0], 0x01);
413 STF_ASSERT_EQUAL(det.instruction_code[FCML_INSTRUCTION_SIZE - 1], 0xFF);
414
415 STF_ASSERT_EQUAL(det.instruction_size, 15);
416 STF_ASSERT_EQUAL(det.opcode_field_s_bit, FCML_TRUE);
417 STF_ASSERT_EQUAL(det.opcode_field_w_bit, FCML_TRUE);
418 STF_ASSERT_EQUAL(det.instruction, F_VAESDEC);
419 STF_ASSERT_EQUAL(det.pseudo_op, FP_DB);
420
421 STF_ASSERT_EQUAL(det.pseudo_op, FP_DB);
422 STF_ASSERT_EQUAL(det.addr_mode, 0x1111);
423 STF_ASSERT_EQUAL(det.instruction_group, FCML_AMT_GPI);
424 STF_ASSERT_EQUAL(det.tuple_type, FCML_TT_M128);
425
426 // To make sure that all fields are taken into account while converting these structs.
427 STF_ASSERT_EQUAL(memcmp(&det, &details, sizeof(details)), 0);
428 }
429
430 void fcml_tf_cpp_disassemble_avx512_disp8_bcast(void) {
431
432
433 fcml_uint8_t code[] = {0x62, 0xf2, 0xed, 0x58, 0x0d, 0x4c, 0x24, 0x08};
434
435 try {
436
437 IntelDialect dialect;
438
439 Disassembler disassembler( dialect );
440
441 DisassemblerContext ctx( code , sizeof( code ) );
442 ctx.setIP(0x401000);
443 ctx.setOperatingMode(EntryPoint::OM_64_BIT);
444 ctx.setAddressSizeAttribute(64);
445 ctx.setOperandSizeAttribute(64);
446
447 DisassemblerResult result;
448
449 disassembler.disassemble( ctx, result );
450
451 const Instruction &instruction = result.getInstruction();
452 const InstructionDetails &details = result.getInstructionDetails();
453
454 STF_ASSERT( instruction.getMnemonic() == M_VPERMILPD );
455
456 STF_ASSERT_EQUAL(instruction[2].getAddress().getEffectiveAddress().getDisplacement(), 64);
457 STF_ASSERT_EQUAL(instruction[2].getDecorators().getBcast(), fcml::Nullable<fcml_uint8_t>(8, true));
458 STF_ASSERT_EQUAL(details.getModRmDetails().getN(), fcml::Nullable<fcml_uint32_t>(8, true));
459
460 Renderer renderer( dialect );
461
462 RenderConfig config;
463
464 fcml_cstring instructionMnemonic;
465
466 renderer.render( config, result, instructionMnemonic );
467
468 STF_ASSERT_STRING_EQUAL( instructionMnemonic.c_str(), FCML_TEXT("vpermilpd zmm1,zmm2,mmword ptr [rsp+64]{1to8}") );
469
470 } catch( BaseException &exc ) {
471 STF_FAIL("Exception while disassembling the code.");
472 }
473 }
474
475 fcml_stf_test_case fcml_ti_cpp_disassembler[] = {
476 { "fcml_tf_cpp_disassemble", fcml_tf_cpp_disassemble },
477 { "fcml_tf_cpp_disassemble_instruction_buffer_disassemble_only", fcml_tf_cpp_disassemble_instruction_buffer_disassemble_only },
478 { "fcml_tf_cpp_disassemble_instruction_buffer_disassemble_render", fcml_tf_cpp_disassemble_instruction_buffer_disassemble_render },
479 { "fcml_tf_cpp_disassemble_instruction_buffer_disassemble_only_stream", fcml_tf_cpp_disassemble_instruction_buffer_disassemble_only_stream },
480 { "fcml_tf_cpp_disassembleshould_convert_instruction_details_correctly", fcml_tf_cpp_disassembleshould_convert_instruction_details_correctly },
481 { "fcml_tf_cpp_disassemble_avx512_disp8_bcast", fcml_tf_cpp_disassemble_avx512_disp8_bcast },
482 FCML_STF_NULL_TEST
483 };
484
485 fcml_stf_test_suite fcml_si_cpp_disassembler = {
486 "suite-fcml-cpp-disassembler", fcml_tf_cpp_disassembler_suite_init, fcml_tf_cpp_disassembler_suite_cleanup, fcml_ti_cpp_disassembler
487 };