/src/capstonenext/arch/X86/X86ATTInstPrinter.c
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- X86ATTInstPrinter.cpp - AT&T assembly instruction printing --------===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This file includes code for rendering MCInst instances as AT&T-style |
11 | | // assembly. |
12 | | // |
13 | | //===----------------------------------------------------------------------===// |
14 | | |
15 | | /* Capstone Disassembly Engine */ |
16 | | /* By Nguyen Anh Quynh <aquynh@gmail.com>, 2013-2019 */ |
17 | | |
18 | | // this code is only relevant when DIET mode is disable |
19 | | #if defined(CAPSTONE_HAS_X86) && !defined(CAPSTONE_DIET) && !defined(CAPSTONE_X86_ATT_DISABLE) |
20 | | |
21 | | #ifdef _MSC_VER |
22 | | #pragma warning(disable:4996) // disable MSVC's warning on strncpy() |
23 | | #pragma warning(disable:28719) // disable MSVC's warning on strncpy() |
24 | | #endif |
25 | | |
26 | | #if !defined(CAPSTONE_HAS_OSXKERNEL) |
27 | | #include <ctype.h> |
28 | | #endif |
29 | | #include <capstone/platform.h> |
30 | | |
31 | | #if defined(CAPSTONE_HAS_OSXKERNEL) |
32 | | #include <Availability.h> |
33 | | #include <libkern/libkern.h> |
34 | | #else |
35 | | #include <stdio.h> |
36 | | #include <stdlib.h> |
37 | | #endif |
38 | | |
39 | | #include <string.h> |
40 | | |
41 | | #include "../../utils.h" |
42 | | #include "../../MCInst.h" |
43 | | #include "../../SStream.h" |
44 | | #include "../../MCRegisterInfo.h" |
45 | | #include "X86Mapping.h" |
46 | | #include "X86BaseInfo.h" |
47 | | #include "X86InstPrinterCommon.h" |
48 | | |
49 | | #define GET_INSTRINFO_ENUM |
50 | | #ifdef CAPSTONE_X86_REDUCE |
51 | | #include "X86GenInstrInfo_reduce.inc" |
52 | | #else |
53 | | #include "X86GenInstrInfo.inc" |
54 | | #endif |
55 | | |
56 | | #define GET_REGINFO_ENUM |
57 | | #include "X86GenRegisterInfo.inc" |
58 | | |
59 | | static void printMemReference(MCInst *MI, unsigned Op, SStream *O); |
60 | | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O); |
61 | | |
62 | | |
63 | | static void set_mem_access(MCInst *MI, bool status) |
64 | 241k | { |
65 | 241k | if (MI->csh->detail_opt != CS_OPT_ON) |
66 | 0 | return; |
67 | | |
68 | 241k | MI->csh->doing_mem = status; |
69 | 241k | if (!status) |
70 | | // done, create the next operand slot |
71 | 120k | MI->flat_insn->detail->x86.op_count++; |
72 | 241k | } |
73 | | |
74 | | static void printopaquemem(MCInst *MI, unsigned OpNo, SStream *O) |
75 | 17.2k | { |
76 | 17.2k | switch(MI->csh->mode) { |
77 | 6.52k | case CS_MODE_16: |
78 | 6.52k | switch(MI->flat_insn->id) { |
79 | 2.27k | default: |
80 | 2.27k | MI->x86opsize = 2; |
81 | 2.27k | break; |
82 | 1.67k | case X86_INS_LJMP: |
83 | 2.11k | case X86_INS_LCALL: |
84 | 2.11k | MI->x86opsize = 4; |
85 | 2.11k | break; |
86 | 545 | case X86_INS_SGDT: |
87 | 987 | case X86_INS_SIDT: |
88 | 1.57k | case X86_INS_LGDT: |
89 | 2.12k | case X86_INS_LIDT: |
90 | 2.12k | MI->x86opsize = 6; |
91 | 2.12k | break; |
92 | 6.52k | } |
93 | 6.52k | break; |
94 | 6.52k | case CS_MODE_32: |
95 | 5.88k | switch(MI->flat_insn->id) { |
96 | 1.97k | default: |
97 | 1.97k | MI->x86opsize = 4; |
98 | 1.97k | break; |
99 | 163 | case X86_INS_LJMP: |
100 | 1.12k | case X86_INS_JMP: |
101 | 1.63k | case X86_INS_LCALL: |
102 | 2.22k | case X86_INS_SGDT: |
103 | 2.75k | case X86_INS_SIDT: |
104 | 3.12k | case X86_INS_LGDT: |
105 | 3.91k | case X86_INS_LIDT: |
106 | 3.91k | MI->x86opsize = 6; |
107 | 3.91k | break; |
108 | 5.88k | } |
109 | 5.88k | break; |
110 | 5.88k | case CS_MODE_64: |
111 | 4.79k | switch(MI->flat_insn->id) { |
112 | 1.01k | default: |
113 | 1.01k | MI->x86opsize = 8; |
114 | 1.01k | break; |
115 | 1.30k | case X86_INS_LJMP: |
116 | 1.99k | case X86_INS_LCALL: |
117 | 2.36k | case X86_INS_SGDT: |
118 | 2.85k | case X86_INS_SIDT: |
119 | 3.16k | case X86_INS_LGDT: |
120 | 3.77k | case X86_INS_LIDT: |
121 | 3.77k | MI->x86opsize = 10; |
122 | 3.77k | break; |
123 | 4.79k | } |
124 | 4.79k | break; |
125 | 4.79k | default: // never reach |
126 | 0 | break; |
127 | 17.2k | } |
128 | | |
129 | 17.2k | printMemReference(MI, OpNo, O); |
130 | 17.2k | } |
131 | | |
132 | | static void printi8mem(MCInst *MI, unsigned OpNo, SStream *O) |
133 | 213k | { |
134 | 213k | MI->x86opsize = 1; |
135 | 213k | printMemReference(MI, OpNo, O); |
136 | 213k | } |
137 | | |
138 | | static void printi16mem(MCInst *MI, unsigned OpNo, SStream *O) |
139 | 68.1k | { |
140 | 68.1k | MI->x86opsize = 2; |
141 | | |
142 | 68.1k | printMemReference(MI, OpNo, O); |
143 | 68.1k | } |
144 | | |
145 | | static void printi32mem(MCInst *MI, unsigned OpNo, SStream *O) |
146 | 66.1k | { |
147 | 66.1k | MI->x86opsize = 4; |
148 | | |
149 | 66.1k | printMemReference(MI, OpNo, O); |
150 | 66.1k | } |
151 | | |
152 | | static void printi64mem(MCInst *MI, unsigned OpNo, SStream *O) |
153 | 23.3k | { |
154 | 23.3k | MI->x86opsize = 8; |
155 | 23.3k | printMemReference(MI, OpNo, O); |
156 | 23.3k | } |
157 | | |
158 | | static void printi128mem(MCInst *MI, unsigned OpNo, SStream *O) |
159 | 7.21k | { |
160 | 7.21k | MI->x86opsize = 16; |
161 | 7.21k | printMemReference(MI, OpNo, O); |
162 | 7.21k | } |
163 | | |
164 | | static void printi512mem(MCInst *MI, unsigned OpNo, SStream *O) |
165 | 4.56k | { |
166 | 4.56k | MI->x86opsize = 64; |
167 | 4.56k | printMemReference(MI, OpNo, O); |
168 | 4.56k | } |
169 | | |
170 | | #ifndef CAPSTONE_X86_REDUCE |
171 | | static void printi256mem(MCInst *MI, unsigned OpNo, SStream *O) |
172 | 4.30k | { |
173 | 4.30k | MI->x86opsize = 32; |
174 | 4.30k | printMemReference(MI, OpNo, O); |
175 | 4.30k | } |
176 | | |
177 | | static void printf32mem(MCInst *MI, unsigned OpNo, SStream *O) |
178 | 7.60k | { |
179 | 7.60k | switch(MCInst_getOpcode(MI)) { |
180 | 5.22k | default: |
181 | 5.22k | MI->x86opsize = 4; |
182 | 5.22k | break; |
183 | 1.41k | case X86_FSTENVm: |
184 | 2.37k | case X86_FLDENVm: |
185 | | // TODO: fix this in tablegen instead |
186 | 2.37k | switch(MI->csh->mode) { |
187 | 0 | default: // never reach |
188 | 0 | break; |
189 | 1.32k | case CS_MODE_16: |
190 | 1.32k | MI->x86opsize = 14; |
191 | 1.32k | break; |
192 | 355 | case CS_MODE_32: |
193 | 1.05k | case CS_MODE_64: |
194 | 1.05k | MI->x86opsize = 28; |
195 | 1.05k | break; |
196 | 2.37k | } |
197 | 2.37k | break; |
198 | 7.60k | } |
199 | | |
200 | 7.60k | printMemReference(MI, OpNo, O); |
201 | 7.60k | } |
202 | | |
203 | | static void printf64mem(MCInst *MI, unsigned OpNo, SStream *O) |
204 | 9.46k | { |
205 | 9.46k | MI->x86opsize = 8; |
206 | 9.46k | printMemReference(MI, OpNo, O); |
207 | 9.46k | } |
208 | | |
209 | | static void printf80mem(MCInst *MI, unsigned OpNo, SStream *O) |
210 | 934 | { |
211 | 934 | MI->x86opsize = 10; |
212 | 934 | printMemReference(MI, OpNo, O); |
213 | 934 | } |
214 | | |
215 | | static void printf128mem(MCInst *MI, unsigned OpNo, SStream *O) |
216 | 5.92k | { |
217 | 5.92k | MI->x86opsize = 16; |
218 | 5.92k | printMemReference(MI, OpNo, O); |
219 | 5.92k | } |
220 | | |
221 | | static void printf256mem(MCInst *MI, unsigned OpNo, SStream *O) |
222 | 3.90k | { |
223 | 3.90k | MI->x86opsize = 32; |
224 | 3.90k | printMemReference(MI, OpNo, O); |
225 | 3.90k | } |
226 | | |
227 | | static void printf512mem(MCInst *MI, unsigned OpNo, SStream *O) |
228 | 4.45k | { |
229 | 4.45k | MI->x86opsize = 64; |
230 | 4.45k | printMemReference(MI, OpNo, O); |
231 | 4.45k | } |
232 | | |
233 | | #endif |
234 | | |
235 | | static void printRegName(SStream *OS, unsigned RegNo); |
236 | | |
237 | | // local printOperand, without updating public operands |
238 | | static void _printOperand(MCInst *MI, unsigned OpNo, SStream *O) |
239 | 619k | { |
240 | 619k | MCOperand *Op = MCInst_getOperand(MI, OpNo); |
241 | 619k | if (MCOperand_isReg(Op)) { |
242 | 619k | printRegName(O, MCOperand_getReg(Op)); |
243 | 619k | } else if (MCOperand_isImm(Op)) { |
244 | 0 | uint8_t encsize; |
245 | 0 | uint8_t opsize = X86_immediate_size(MCInst_getOpcode(MI), &encsize); |
246 | | |
247 | | // Print X86 immediates as signed values. |
248 | 0 | int64_t imm = MCOperand_getImm(Op); |
249 | 0 | if (imm < 0) { |
250 | 0 | if (MI->csh->imm_unsigned) { |
251 | 0 | if (opsize) { |
252 | 0 | switch(opsize) { |
253 | 0 | default: |
254 | 0 | break; |
255 | 0 | case 1: |
256 | 0 | imm &= 0xff; |
257 | 0 | break; |
258 | 0 | case 2: |
259 | 0 | imm &= 0xffff; |
260 | 0 | break; |
261 | 0 | case 4: |
262 | 0 | imm &= 0xffffffff; |
263 | 0 | break; |
264 | 0 | } |
265 | 0 | } |
266 | | |
267 | 0 | SStream_concat(O, "$0x%"PRIx64, imm); |
268 | 0 | } else { |
269 | 0 | if (imm < -HEX_THRESHOLD) |
270 | 0 | SStream_concat(O, "$-0x%"PRIx64, -imm); |
271 | 0 | else |
272 | 0 | SStream_concat(O, "$-%"PRIu64, -imm); |
273 | 0 | } |
274 | 0 | } else { |
275 | 0 | if (imm > HEX_THRESHOLD) |
276 | 0 | SStream_concat(O, "$0x%"PRIx64, imm); |
277 | 0 | else |
278 | 0 | SStream_concat(O, "$%"PRIu64, imm); |
279 | 0 | } |
280 | 0 | } |
281 | 619k | } |
282 | | |
283 | | // convert Intel access info to AT&T access info |
284 | | static void get_op_access(cs_struct *h, unsigned int id, uint8_t *access, uint64_t *eflags) |
285 | 2.45M | { |
286 | 2.45M | uint8_t count, i; |
287 | 2.45M | const uint8_t *arr = X86_get_op_access(h, id, eflags); |
288 | | |
289 | | // initialize access |
290 | 2.45M | memset(access, 0, CS_X86_MAXIMUM_OPERAND_SIZE * sizeof(access[0])); |
291 | | |
292 | 2.45M | if (!arr) { |
293 | 0 | access[0] = 0; |
294 | 0 | return; |
295 | 0 | } |
296 | | |
297 | | // find the non-zero last entry |
298 | 6.94M | for(count = 0; arr[count]; count++); |
299 | | |
300 | 2.45M | if (count == 0) |
301 | 147k | return; |
302 | | |
303 | | // copy in reverse order this access array from Intel syntax -> AT&T syntax |
304 | 2.30M | count--; |
305 | 6.79M | for(i = 0; i <= count; i++) { |
306 | 4.48M | if (arr[count - i] != CS_AC_IGNORE) |
307 | 3.90M | access[i] = arr[count - i]; |
308 | 582k | else |
309 | 582k | access[i] = 0; |
310 | 4.48M | } |
311 | 2.30M | } |
312 | | |
313 | | static void printSrcIdx(MCInst *MI, unsigned Op, SStream *O) |
314 | 58.5k | { |
315 | 58.5k | MCOperand *SegReg; |
316 | 58.5k | int reg; |
317 | | |
318 | 58.5k | if (MI->csh->detail_opt) { |
319 | 58.5k | uint8_t access[CS_X86_MAXIMUM_OPERAND_SIZE]; |
320 | | |
321 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; |
322 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; |
323 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; |
324 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID; |
325 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID; |
326 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1; |
327 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; |
328 | | |
329 | 58.5k | get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags); |
330 | 58.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count]; |
331 | 58.5k | } |
332 | | |
333 | 58.5k | SegReg = MCInst_getOperand(MI, Op+1); |
334 | 58.5k | reg = MCOperand_getReg(SegReg); |
335 | | // If this has a segment register, print it. |
336 | 58.5k | if (reg) { |
337 | 1.79k | _printOperand(MI, Op + 1, O); |
338 | 1.79k | SStream_concat0(O, ":"); |
339 | | |
340 | 1.79k | if (MI->csh->detail_opt) { |
341 | 1.79k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_register_map(reg); |
342 | 1.79k | } |
343 | 1.79k | } |
344 | | |
345 | 58.5k | SStream_concat0(O, "("); |
346 | 58.5k | set_mem_access(MI, true); |
347 | | |
348 | 58.5k | printOperand(MI, Op, O); |
349 | | |
350 | 58.5k | SStream_concat0(O, ")"); |
351 | 58.5k | set_mem_access(MI, false); |
352 | 58.5k | } |
353 | | |
354 | | static void printDstIdx(MCInst *MI, unsigned Op, SStream *O) |
355 | 62.3k | { |
356 | 62.3k | if (MI->csh->detail_opt) { |
357 | 62.3k | uint8_t access[CS_X86_MAXIMUM_OPERAND_SIZE]; |
358 | | |
359 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; |
360 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; |
361 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; |
362 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID; |
363 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID; |
364 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1; |
365 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; |
366 | | |
367 | 62.3k | get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags); |
368 | 62.3k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count]; |
369 | 62.3k | } |
370 | | |
371 | | // DI accesses are always ES-based on non-64bit mode |
372 | 62.3k | if (MI->csh->mode != CS_MODE_64) { |
373 | 39.5k | SStream_concat0(O, "%es:("); |
374 | 39.5k | if (MI->csh->detail_opt) { |
375 | 39.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_ES; |
376 | 39.5k | } |
377 | 39.5k | } else |
378 | 22.7k | SStream_concat0(O, "("); |
379 | | |
380 | 62.3k | set_mem_access(MI, true); |
381 | | |
382 | 62.3k | printOperand(MI, Op, O); |
383 | | |
384 | 62.3k | SStream_concat0(O, ")"); |
385 | 62.3k | set_mem_access(MI, false); |
386 | 62.3k | } |
387 | | |
388 | | static void printSrcIdx8(MCInst *MI, unsigned OpNo, SStream *O) |
389 | 20.3k | { |
390 | 20.3k | MI->x86opsize = 1; |
391 | 20.3k | printSrcIdx(MI, OpNo, O); |
392 | 20.3k | } |
393 | | |
394 | | static void printSrcIdx16(MCInst *MI, unsigned OpNo, SStream *O) |
395 | 18.7k | { |
396 | 18.7k | MI->x86opsize = 2; |
397 | 18.7k | printSrcIdx(MI, OpNo, O); |
398 | 18.7k | } |
399 | | |
400 | | static void printSrcIdx32(MCInst *MI, unsigned OpNo, SStream *O) |
401 | 15.3k | { |
402 | 15.3k | MI->x86opsize = 4; |
403 | 15.3k | printSrcIdx(MI, OpNo, O); |
404 | 15.3k | } |
405 | | |
406 | | static void printSrcIdx64(MCInst *MI, unsigned OpNo, SStream *O) |
407 | 3.98k | { |
408 | 3.98k | MI->x86opsize = 8; |
409 | 3.98k | printSrcIdx(MI, OpNo, O); |
410 | 3.98k | } |
411 | | |
412 | | static void printDstIdx8(MCInst *MI, unsigned OpNo, SStream *O) |
413 | 26.2k | { |
414 | 26.2k | MI->x86opsize = 1; |
415 | 26.2k | printDstIdx(MI, OpNo, O); |
416 | 26.2k | } |
417 | | |
418 | | static void printDstIdx16(MCInst *MI, unsigned OpNo, SStream *O) |
419 | 18.2k | { |
420 | 18.2k | MI->x86opsize = 2; |
421 | 18.2k | printDstIdx(MI, OpNo, O); |
422 | 18.2k | } |
423 | | |
424 | | static void printDstIdx32(MCInst *MI, unsigned OpNo, SStream *O) |
425 | 13.7k | { |
426 | 13.7k | MI->x86opsize = 4; |
427 | 13.7k | printDstIdx(MI, OpNo, O); |
428 | 13.7k | } |
429 | | |
430 | | static void printDstIdx64(MCInst *MI, unsigned OpNo, SStream *O) |
431 | 4.00k | { |
432 | 4.00k | MI->x86opsize = 8; |
433 | 4.00k | printDstIdx(MI, OpNo, O); |
434 | 4.00k | } |
435 | | |
436 | | static void printMemOffset(MCInst *MI, unsigned Op, SStream *O) |
437 | 11.1k | { |
438 | 11.1k | MCOperand *DispSpec = MCInst_getOperand(MI, Op); |
439 | 11.1k | MCOperand *SegReg = MCInst_getOperand(MI, Op+1); |
440 | 11.1k | int reg; |
441 | | |
442 | 11.1k | if (MI->csh->detail_opt) { |
443 | 11.1k | uint8_t access[CS_X86_MAXIMUM_OPERAND_SIZE]; |
444 | | |
445 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; |
446 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; |
447 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; |
448 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_REG_INVALID; |
449 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_REG_INVALID; |
450 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1; |
451 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; |
452 | | |
453 | 11.1k | get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags); |
454 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count]; |
455 | 11.1k | } |
456 | | |
457 | | // If this has a segment register, print it. |
458 | 11.1k | reg = MCOperand_getReg(SegReg); |
459 | 11.1k | if (reg) { |
460 | 771 | _printOperand(MI, Op + 1, O); |
461 | 771 | SStream_concat0(O, ":"); |
462 | | |
463 | 771 | if (MI->csh->detail_opt) { |
464 | 771 | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_register_map(reg); |
465 | 771 | } |
466 | 771 | } |
467 | | |
468 | 11.1k | if (MCOperand_isImm(DispSpec)) { |
469 | 11.1k | int64_t imm = MCOperand_getImm(DispSpec); |
470 | 11.1k | if (MI->csh->detail_opt) |
471 | 11.1k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = imm; |
472 | 11.1k | if (imm < 0) { |
473 | 2.01k | SStream_concat(O, "0x%"PRIx64, arch_masks[MI->csh->mode] & imm); |
474 | 9.10k | } else { |
475 | 9.10k | if (imm > HEX_THRESHOLD) |
476 | 8.64k | SStream_concat(O, "0x%"PRIx64, imm); |
477 | 459 | else |
478 | 459 | SStream_concat(O, "%"PRIu64, imm); |
479 | 9.10k | } |
480 | 11.1k | } |
481 | | |
482 | 11.1k | if (MI->csh->detail_opt) |
483 | 11.1k | MI->flat_insn->detail->x86.op_count++; |
484 | 11.1k | } |
485 | | |
486 | | static void printU8Imm(MCInst *MI, unsigned Op, SStream *O) |
487 | 48.5k | { |
488 | 48.5k | uint8_t val = MCOperand_getImm(MCInst_getOperand(MI, Op)) & 0xff; |
489 | | |
490 | 48.5k | if (val > HEX_THRESHOLD) |
491 | 42.1k | SStream_concat(O, "$0x%x", val); |
492 | 6.41k | else |
493 | 6.41k | SStream_concat(O, "$%u", val); |
494 | | |
495 | 48.5k | if (MI->csh->detail_opt) { |
496 | 48.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM; |
497 | 48.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = val; |
498 | 48.5k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = 1; |
499 | 48.5k | MI->flat_insn->detail->x86.op_count++; |
500 | 48.5k | } |
501 | 48.5k | } |
502 | | |
503 | | static void printMemOffs8(MCInst *MI, unsigned OpNo, SStream *O) |
504 | 6.49k | { |
505 | 6.49k | MI->x86opsize = 1; |
506 | 6.49k | printMemOffset(MI, OpNo, O); |
507 | 6.49k | } |
508 | | |
509 | | static void printMemOffs16(MCInst *MI, unsigned OpNo, SStream *O) |
510 | 2.08k | { |
511 | 2.08k | MI->x86opsize = 2; |
512 | 2.08k | printMemOffset(MI, OpNo, O); |
513 | 2.08k | } |
514 | | |
515 | | static void printMemOffs32(MCInst *MI, unsigned OpNo, SStream *O) |
516 | 2.18k | { |
517 | 2.18k | MI->x86opsize = 4; |
518 | 2.18k | printMemOffset(MI, OpNo, O); |
519 | 2.18k | } |
520 | | |
521 | | static void printMemOffs64(MCInst *MI, unsigned OpNo, SStream *O) |
522 | 351 | { |
523 | 351 | MI->x86opsize = 8; |
524 | 351 | printMemOffset(MI, OpNo, O); |
525 | 351 | } |
526 | | |
527 | | /// printPCRelImm - This is used to print an immediate value that ends up |
528 | | /// being encoded as a pc-relative value (e.g. for jumps and calls). These |
529 | | /// print slightly differently than normal immediates. For example, a $ is not |
530 | | /// emitted. |
531 | | static void printPCRelImm(MCInst *MI, unsigned OpNo, SStream *O) |
532 | 77.9k | { |
533 | 77.9k | MCOperand *Op = MCInst_getOperand(MI, OpNo); |
534 | 77.9k | if (MCOperand_isImm(Op)) { |
535 | 77.9k | int64_t imm = MCOperand_getImm(Op) + MI->flat_insn->size + MI->address; |
536 | | |
537 | | // truncate imm for non-64bit |
538 | 77.9k | if (MI->csh->mode != CS_MODE_64) { |
539 | 52.3k | imm = imm & 0xffffffff; |
540 | 52.3k | } |
541 | | |
542 | 77.9k | if (imm < 0) { |
543 | 1.85k | SStream_concat(O, "0x%"PRIx64, imm); |
544 | 76.1k | } else { |
545 | 76.1k | if (imm > HEX_THRESHOLD) |
546 | 76.1k | SStream_concat(O, "0x%"PRIx64, imm); |
547 | 24 | else |
548 | 24 | SStream_concat(O, "%"PRIu64, imm); |
549 | 76.1k | } |
550 | 77.9k | if (MI->csh->detail_opt) { |
551 | 77.9k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM; |
552 | 77.9k | MI->has_imm = true; |
553 | 77.9k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = imm; |
554 | 77.9k | MI->flat_insn->detail->x86.op_count++; |
555 | 77.9k | } |
556 | 77.9k | } |
557 | 77.9k | } |
558 | | |
559 | | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O) |
560 | 1.02M | { |
561 | 1.02M | MCOperand *Op = MCInst_getOperand(MI, OpNo); |
562 | 1.02M | if (MCOperand_isReg(Op)) { |
563 | 892k | unsigned int reg = MCOperand_getReg(Op); |
564 | 892k | printRegName(O, reg); |
565 | 892k | if (MI->csh->detail_opt) { |
566 | 892k | if (MI->csh->doing_mem) { |
567 | 120k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_register_map(reg); |
568 | 771k | } else { |
569 | 771k | uint8_t access[CS_X86_MAXIMUM_OPERAND_SIZE]; |
570 | | |
571 | 771k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_REG; |
572 | 771k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].reg = X86_register_map(reg); |
573 | 771k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->csh->regsize_map[X86_register_map(reg)]; |
574 | | |
575 | 771k | get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags); |
576 | 771k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count]; |
577 | | |
578 | 771k | MI->flat_insn->detail->x86.op_count++; |
579 | 771k | } |
580 | 892k | } |
581 | 892k | } else if (MCOperand_isImm(Op)) { |
582 | | // Print X86 immediates as signed values. |
583 | 132k | uint8_t encsize; |
584 | 132k | int64_t imm = MCOperand_getImm(Op); |
585 | 132k | uint8_t opsize = X86_immediate_size(MCInst_getOpcode(MI), &encsize); |
586 | | |
587 | 132k | if (opsize == 1) // print 1 byte immediate in positive form |
588 | 57.6k | imm = imm & 0xff; |
589 | | |
590 | 132k | switch(MI->flat_insn->id) { |
591 | 58.1k | default: |
592 | 58.1k | if (imm >= 0) { |
593 | 52.0k | if (imm > HEX_THRESHOLD) |
594 | 44.8k | SStream_concat(O, "$0x%"PRIx64, imm); |
595 | 7.27k | else |
596 | 7.27k | SStream_concat(O, "$%"PRIu64, imm); |
597 | 52.0k | } else { |
598 | 6.10k | if (MI->csh->imm_unsigned) { |
599 | 0 | if (opsize) { |
600 | 0 | switch(opsize) { |
601 | 0 | default: |
602 | 0 | break; |
603 | 0 | case 1: |
604 | 0 | imm &= 0xff; |
605 | 0 | break; |
606 | 0 | case 2: |
607 | 0 | imm &= 0xffff; |
608 | 0 | break; |
609 | 0 | case 4: |
610 | 0 | imm &= 0xffffffff; |
611 | 0 | break; |
612 | 0 | } |
613 | 0 | } |
614 | | |
615 | 0 | SStream_concat(O, "$0x%"PRIx64, imm); |
616 | 6.10k | } else { |
617 | 6.10k | if (imm == 0x8000000000000000LL) // imm == -imm |
618 | 0 | SStream_concat0(O, "$0x8000000000000000"); |
619 | 6.10k | else if (imm < -HEX_THRESHOLD) |
620 | 5.29k | SStream_concat(O, "$-0x%"PRIx64, -imm); |
621 | 804 | else |
622 | 804 | SStream_concat(O, "$-%"PRIu64, -imm); |
623 | 6.10k | } |
624 | 6.10k | } |
625 | 58.1k | break; |
626 | | |
627 | 58.1k | case X86_INS_MOVABS: |
628 | 21.6k | case X86_INS_MOV: |
629 | | // do not print number in negative form |
630 | 21.6k | if (imm > HEX_THRESHOLD) |
631 | 19.8k | SStream_concat(O, "$0x%"PRIx64, imm); |
632 | 1.79k | else |
633 | 1.79k | SStream_concat(O, "$%"PRIu64, imm); |
634 | 21.6k | break; |
635 | | |
636 | 0 | case X86_INS_IN: |
637 | 0 | case X86_INS_OUT: |
638 | 0 | case X86_INS_INT: |
639 | | // do not print number in negative form |
640 | 0 | imm = imm & 0xff; |
641 | 0 | if (imm >= 0 && imm <= HEX_THRESHOLD) |
642 | 0 | SStream_concat(O, "$%u", imm); |
643 | 0 | else { |
644 | 0 | SStream_concat(O, "$0x%x", imm); |
645 | 0 | } |
646 | 0 | break; |
647 | | |
648 | 2.23k | case X86_INS_LCALL: |
649 | 5.24k | case X86_INS_LJMP: |
650 | 5.24k | case X86_INS_JMP: |
651 | | // always print address in positive form |
652 | 5.24k | if (OpNo == 1) { // selector is ptr16 |
653 | 2.62k | imm = imm & 0xffff; |
654 | 2.62k | opsize = 2; |
655 | 2.62k | } else |
656 | 2.62k | opsize = 4; |
657 | 5.24k | SStream_concat(O, "$0x%"PRIx64, imm); |
658 | 5.24k | break; |
659 | | |
660 | 12.2k | case X86_INS_AND: |
661 | 25.2k | case X86_INS_OR: |
662 | 34.2k | case X86_INS_XOR: |
663 | | // do not print number in negative form |
664 | 34.2k | if (imm >= 0 && imm <= HEX_THRESHOLD) |
665 | 3.54k | SStream_concat(O, "$%u", imm); |
666 | 30.6k | else { |
667 | 30.6k | imm = arch_masks[opsize? opsize : MI->imm_size] & imm; |
668 | 30.6k | SStream_concat(O, "$0x%"PRIx64, imm); |
669 | 30.6k | } |
670 | 34.2k | break; |
671 | | |
672 | 11.1k | case X86_INS_RET: |
673 | 13.1k | case X86_INS_RETF: |
674 | | // RET imm16 |
675 | 13.1k | if (imm >= 0 && imm <= HEX_THRESHOLD) |
676 | 845 | SStream_concat(O, "$%u", imm); |
677 | 12.2k | else { |
678 | 12.2k | imm = 0xffff & imm; |
679 | 12.2k | SStream_concat(O, "$0x%x", imm); |
680 | 12.2k | } |
681 | 13.1k | break; |
682 | 132k | } |
683 | | |
684 | 132k | if (MI->csh->detail_opt) { |
685 | 132k | if (MI->csh->doing_mem) { |
686 | 0 | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; |
687 | 0 | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = imm; |
688 | 132k | } else { |
689 | 132k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_IMM; |
690 | 132k | MI->has_imm = true; |
691 | 132k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].imm = imm; |
692 | | |
693 | 132k | if (opsize > 0) { |
694 | 111k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = opsize; |
695 | 111k | MI->flat_insn->detail->x86.encoding.imm_size = encsize; |
696 | 111k | } else if (MI->op1_size > 0) |
697 | 0 | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->op1_size; |
698 | 21.0k | else |
699 | 21.0k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->imm_size; |
700 | | |
701 | 132k | MI->flat_insn->detail->x86.op_count++; |
702 | 132k | } |
703 | 132k | } |
704 | 132k | } |
705 | 1.02M | } |
706 | | |
707 | | static void printMemReference(MCInst *MI, unsigned Op, SStream *O) |
708 | 443k | { |
709 | 443k | MCOperand *BaseReg = MCInst_getOperand(MI, Op + X86_AddrBaseReg); |
710 | 443k | MCOperand *IndexReg = MCInst_getOperand(MI, Op + X86_AddrIndexReg); |
711 | 443k | MCOperand *DispSpec = MCInst_getOperand(MI, Op + X86_AddrDisp); |
712 | 443k | MCOperand *SegReg = MCInst_getOperand(MI, Op + X86_AddrSegmentReg); |
713 | 443k | uint64_t ScaleVal; |
714 | 443k | int segreg; |
715 | 443k | int64_t DispVal = 1; |
716 | | |
717 | 443k | if (MI->csh->detail_opt) { |
718 | 443k | uint8_t access[CS_X86_MAXIMUM_OPERAND_SIZE]; |
719 | | |
720 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].type = X86_OP_MEM; |
721 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].size = MI->x86opsize; |
722 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_REG_INVALID; |
723 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.base = X86_register_map(MCOperand_getReg(BaseReg)); |
724 | 443k | if (MCOperand_getReg(IndexReg) != X86_EIZ) { |
725 | 442k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.index = X86_register_map(MCOperand_getReg(IndexReg)); |
726 | 442k | } |
727 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = 1; |
728 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = 0; |
729 | | |
730 | 443k | get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags); |
731 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].access = access[MI->flat_insn->detail->x86.op_count]; |
732 | 443k | } |
733 | | |
734 | | // If this has a segment register, print it. |
735 | 443k | segreg = MCOperand_getReg(SegReg); |
736 | 443k | if (segreg) { |
737 | 10.9k | _printOperand(MI, Op + X86_AddrSegmentReg, O); |
738 | 10.9k | SStream_concat0(O, ":"); |
739 | | |
740 | 10.9k | if (MI->csh->detail_opt) { |
741 | 10.9k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.segment = X86_register_map(segreg); |
742 | 10.9k | } |
743 | 10.9k | } |
744 | | |
745 | 443k | if (MCOperand_isImm(DispSpec)) { |
746 | 443k | DispVal = MCOperand_getImm(DispSpec); |
747 | 443k | if (MI->csh->detail_opt) |
748 | 443k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.disp = DispVal; |
749 | 443k | if (DispVal) { |
750 | 137k | if (MCOperand_getReg(IndexReg) || MCOperand_getReg(BaseReg)) { |
751 | 128k | printInt64(O, DispVal); |
752 | 128k | } else { |
753 | | // only immediate as address of memory |
754 | 8.39k | if (DispVal < 0) { |
755 | 2.83k | SStream_concat(O, "0x%"PRIx64, arch_masks[MI->csh->mode] & DispVal); |
756 | 5.56k | } else { |
757 | 5.56k | if (DispVal > HEX_THRESHOLD) |
758 | 5.12k | SStream_concat(O, "0x%"PRIx64, DispVal); |
759 | 438 | else |
760 | 438 | SStream_concat(O, "%"PRIu64, DispVal); |
761 | 5.56k | } |
762 | 8.39k | } |
763 | 137k | } |
764 | 443k | } |
765 | | |
766 | 443k | if (MCOperand_getReg(IndexReg) || MCOperand_getReg(BaseReg)) { |
767 | 434k | SStream_concat0(O, "("); |
768 | | |
769 | 434k | if (MCOperand_getReg(BaseReg)) |
770 | 433k | _printOperand(MI, Op + X86_AddrBaseReg, O); |
771 | | |
772 | 434k | if (MCOperand_getReg(IndexReg) && MCOperand_getReg(IndexReg) != X86_EIZ) { |
773 | 172k | SStream_concat0(O, ", "); |
774 | 172k | _printOperand(MI, Op + X86_AddrIndexReg, O); |
775 | 172k | ScaleVal = MCOperand_getImm(MCInst_getOperand(MI, Op + X86_AddrScaleAmt)); |
776 | 172k | if (MI->csh->detail_opt) |
777 | 172k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count].mem.scale = (int)ScaleVal; |
778 | 172k | if (ScaleVal != 1) { |
779 | 11.4k | SStream_concat(O, ", %u", ScaleVal); |
780 | 11.4k | } |
781 | 172k | } |
782 | | |
783 | 434k | SStream_concat0(O, ")"); |
784 | 434k | } else { |
785 | 8.87k | if (!DispVal) |
786 | 484 | SStream_concat0(O, "0"); |
787 | 8.87k | } |
788 | | |
789 | 443k | if (MI->csh->detail_opt) |
790 | 443k | MI->flat_insn->detail->x86.op_count++; |
791 | 443k | } |
792 | | |
793 | | static void printanymem(MCInst *MI, unsigned OpNo, SStream *O) |
794 | 7.14k | { |
795 | 7.14k | switch(MI->Opcode) { |
796 | 320 | default: break; |
797 | 1.14k | case X86_LEA16r: |
798 | 1.14k | MI->x86opsize = 2; |
799 | 1.14k | break; |
800 | 750 | case X86_LEA32r: |
801 | 1.43k | case X86_LEA64_32r: |
802 | 1.43k | MI->x86opsize = 4; |
803 | 1.43k | break; |
804 | 257 | case X86_LEA64r: |
805 | 257 | MI->x86opsize = 8; |
806 | 257 | break; |
807 | 0 | #ifndef CAPSTONE_X86_REDUCE |
808 | 470 | case X86_BNDCL32rm: |
809 | 1.37k | case X86_BNDCN32rm: |
810 | 1.55k | case X86_BNDCU32rm: |
811 | 2.24k | case X86_BNDSTXmr: |
812 | 3.35k | case X86_BNDLDXrm: |
813 | 3.66k | case X86_BNDCL64rm: |
814 | 3.84k | case X86_BNDCN64rm: |
815 | 3.99k | case X86_BNDCU64rm: |
816 | 3.99k | MI->x86opsize = 16; |
817 | 3.99k | break; |
818 | 7.14k | #endif |
819 | 7.14k | } |
820 | | |
821 | 7.14k | printMemReference(MI, OpNo, O); |
822 | 7.14k | } |
823 | | |
824 | | #include "X86InstPrinter.h" |
825 | | |
826 | | // Include the auto-generated portion of the assembly writer. |
827 | | #ifdef CAPSTONE_X86_REDUCE |
828 | | #include "X86GenAsmWriter_reduce.inc" |
829 | | #else |
830 | | #include "X86GenAsmWriter.inc" |
831 | | #endif |
832 | | |
833 | | #include "X86GenRegisterName.inc" |
834 | | |
835 | | static void printRegName(SStream *OS, unsigned RegNo) |
836 | 1.51M | { |
837 | 1.51M | SStream_concat(OS, "%%%s", getRegisterName(RegNo)); |
838 | 1.51M | } |
839 | | |
840 | | void X86_ATT_printInst(MCInst *MI, SStream *OS, void *info) |
841 | 1.10M | { |
842 | 1.10M | x86_reg reg, reg2; |
843 | 1.10M | enum cs_ac_type access1, access2; |
844 | 1.10M | int i; |
845 | | |
846 | | // perhaps this instruction does not need printer |
847 | 1.10M | if (MI->assembly[0]) { |
848 | 0 | strncpy(OS->buffer, MI->assembly, sizeof(OS->buffer)); |
849 | 0 | return; |
850 | 0 | } |
851 | | |
852 | | // Output CALLpcrel32 as "callq" in 64-bit mode. |
853 | | // In Intel annotation it's always emitted as "call". |
854 | | // |
855 | | // TODO: Probably this hack should be redesigned via InstAlias in |
856 | | // InstrInfo.td as soon as Requires clause is supported properly |
857 | | // for InstAlias. |
858 | 1.10M | if (MI->csh->mode == CS_MODE_64 && MCInst_getOpcode(MI) == X86_CALLpcrel32) { |
859 | 0 | SStream_concat0(OS, "callq\t"); |
860 | 0 | MCInst_setOpcodePub(MI, X86_INS_CALL); |
861 | 0 | printPCRelImm(MI, 0, OS); |
862 | 0 | return; |
863 | 0 | } |
864 | | |
865 | 1.10M | X86_lockrep(MI, OS); |
866 | 1.10M | printInstruction(MI, OS); |
867 | | |
868 | 1.10M | if (MI->has_imm) { |
869 | | // if op_count > 1, then this operand's size is taken from the destination op |
870 | 205k | if (MI->flat_insn->detail->x86.op_count > 1) { |
871 | 109k | if (MI->flat_insn->id != X86_INS_LCALL && MI->flat_insn->id != X86_INS_LJMP && MI->flat_insn->id != X86_INS_JMP) { |
872 | 325k | for (i = 0; i < MI->flat_insn->detail->x86.op_count; i++) { |
873 | 219k | if (MI->flat_insn->detail->x86.operands[i].type == X86_OP_IMM) |
874 | 108k | MI->flat_insn->detail->x86.operands[i].size = |
875 | 108k | MI->flat_insn->detail->x86.operands[MI->flat_insn->detail->x86.op_count - 1].size; |
876 | 219k | } |
877 | 106k | } |
878 | 109k | } else |
879 | 96.5k | MI->flat_insn->detail->x86.operands[0].size = MI->imm_size; |
880 | 205k | } |
881 | | |
882 | 1.10M | if (MI->csh->detail_opt) { |
883 | 1.10M | uint8_t access[CS_X86_MAXIMUM_OPERAND_SIZE] = {0}; |
884 | | |
885 | | // some instructions need to supply immediate 1 in the first op |
886 | 1.10M | switch(MCInst_getOpcode(MI)) { |
887 | 1.04M | default: |
888 | 1.04M | break; |
889 | 1.04M | case X86_SHL8r1: |
890 | 2.37k | case X86_SHL16r1: |
891 | 3.83k | case X86_SHL32r1: |
892 | 4.56k | case X86_SHL64r1: |
893 | 4.78k | case X86_SAL8r1: |
894 | 5.90k | case X86_SAL16r1: |
895 | 6.74k | case X86_SAL32r1: |
896 | 7.16k | case X86_SAL64r1: |
897 | 7.41k | case X86_SHR8r1: |
898 | 8.37k | case X86_SHR16r1: |
899 | 10.3k | case X86_SHR32r1: |
900 | 11.4k | case X86_SHR64r1: |
901 | 12.0k | case X86_SAR8r1: |
902 | 12.8k | case X86_SAR16r1: |
903 | 13.6k | case X86_SAR32r1: |
904 | 14.0k | case X86_SAR64r1: |
905 | 16.2k | case X86_RCL8r1: |
906 | 18.1k | case X86_RCL16r1: |
907 | 20.6k | case X86_RCL32r1: |
908 | 21.4k | case X86_RCL64r1: |
909 | 21.7k | case X86_RCR8r1: |
910 | 22.2k | case X86_RCR16r1: |
911 | 23.1k | case X86_RCR32r1: |
912 | 23.8k | case X86_RCR64r1: |
913 | 24.5k | case X86_ROL8r1: |
914 | 25.1k | case X86_ROL16r1: |
915 | 25.8k | case X86_ROL32r1: |
916 | 26.4k | case X86_ROL64r1: |
917 | 27.0k | case X86_ROR8r1: |
918 | 28.7k | case X86_ROR16r1: |
919 | 30.0k | case X86_ROR32r1: |
920 | 30.3k | case X86_ROR64r1: |
921 | 31.1k | case X86_SHL8m1: |
922 | 32.2k | case X86_SHL16m1: |
923 | 33.3k | case X86_SHL32m1: |
924 | 33.9k | case X86_SHL64m1: |
925 | 34.5k | case X86_SAL8m1: |
926 | 35.2k | case X86_SAL16m1: |
927 | 35.8k | case X86_SAL32m1: |
928 | 36.2k | case X86_SAL64m1: |
929 | 37.3k | case X86_SHR8m1: |
930 | 38.0k | case X86_SHR16m1: |
931 | 38.9k | case X86_SHR32m1: |
932 | 39.4k | case X86_SHR64m1: |
933 | 40.0k | case X86_SAR8m1: |
934 | 40.4k | case X86_SAR16m1: |
935 | 41.3k | case X86_SAR32m1: |
936 | 41.8k | case X86_SAR64m1: |
937 | 42.4k | case X86_RCL8m1: |
938 | 43.1k | case X86_RCL16m1: |
939 | 43.6k | case X86_RCL32m1: |
940 | 43.9k | case X86_RCL64m1: |
941 | 44.1k | case X86_RCR8m1: |
942 | 44.9k | case X86_RCR16m1: |
943 | 45.7k | case X86_RCR32m1: |
944 | 46.2k | case X86_RCR64m1: |
945 | 47.4k | case X86_ROL8m1: |
946 | 47.9k | case X86_ROL16m1: |
947 | 50.1k | case X86_ROL32m1: |
948 | 50.4k | case X86_ROL64m1: |
949 | 51.4k | case X86_ROR8m1: |
950 | 52.4k | case X86_ROR16m1: |
951 | 54.0k | case X86_ROR32m1: |
952 | 55.3k | case X86_ROR64m1: |
953 | | // shift all the ops right to leave 1st slot for this new register op |
954 | 55.3k | memmove(&(MI->flat_insn->detail->x86.operands[1]), &(MI->flat_insn->detail->x86.operands[0]), |
955 | 55.3k | sizeof(MI->flat_insn->detail->x86.operands[0]) * (ARR_SIZE(MI->flat_insn->detail->x86.operands) - 1)); |
956 | 55.3k | MI->flat_insn->detail->x86.operands[0].type = X86_OP_IMM; |
957 | 55.3k | MI->flat_insn->detail->x86.operands[0].imm = 1; |
958 | 55.3k | MI->flat_insn->detail->x86.operands[0].size = 1; |
959 | 55.3k | MI->flat_insn->detail->x86.op_count++; |
960 | 1.10M | } |
961 | | |
962 | | // special instruction needs to supply register op |
963 | | // first op can be embedded in the asm by llvm. |
964 | | // so we have to add the missing register as the first operand |
965 | | |
966 | | //printf(">>> opcode = %u\n", MCInst_getOpcode(MI)); |
967 | | |
968 | 1.10M | reg = X86_insn_reg_att(MCInst_getOpcode(MI), &access1); |
969 | 1.10M | if (reg) { |
970 | | // shift all the ops right to leave 1st slot for this new register op |
971 | 61.1k | memmove(&(MI->flat_insn->detail->x86.operands[1]), &(MI->flat_insn->detail->x86.operands[0]), |
972 | 61.1k | sizeof(MI->flat_insn->detail->x86.operands[0]) * (ARR_SIZE(MI->flat_insn->detail->x86.operands) - 1)); |
973 | 61.1k | MI->flat_insn->detail->x86.operands[0].type = X86_OP_REG; |
974 | 61.1k | MI->flat_insn->detail->x86.operands[0].reg = reg; |
975 | 61.1k | MI->flat_insn->detail->x86.operands[0].size = MI->csh->regsize_map[reg]; |
976 | 61.1k | MI->flat_insn->detail->x86.operands[0].access = access1; |
977 | | |
978 | 61.1k | MI->flat_insn->detail->x86.op_count++; |
979 | 1.04M | } else { |
980 | 1.04M | if (X86_insn_reg_att2(MCInst_getOpcode(MI), ®, &access1, ®2, &access2)) { |
981 | | |
982 | 19.4k | MI->flat_insn->detail->x86.operands[0].type = X86_OP_REG; |
983 | 19.4k | MI->flat_insn->detail->x86.operands[0].reg = reg; |
984 | 19.4k | MI->flat_insn->detail->x86.operands[0].size = MI->csh->regsize_map[reg]; |
985 | 19.4k | MI->flat_insn->detail->x86.operands[0].access = access1; |
986 | 19.4k | MI->flat_insn->detail->x86.operands[1].type = X86_OP_REG; |
987 | 19.4k | MI->flat_insn->detail->x86.operands[1].reg = reg2; |
988 | 19.4k | MI->flat_insn->detail->x86.operands[1].size = MI->csh->regsize_map[reg2]; |
989 | 19.4k | MI->flat_insn->detail->x86.operands[1].access = access2; |
990 | 19.4k | MI->flat_insn->detail->x86.op_count = 2; |
991 | 19.4k | } |
992 | 1.04M | } |
993 | | |
994 | 1.10M | #ifndef CAPSTONE_DIET |
995 | 1.10M | get_op_access(MI->csh, MCInst_getOpcode(MI), access, &MI->flat_insn->detail->x86.eflags); |
996 | 1.10M | MI->flat_insn->detail->x86.operands[0].access = access[0]; |
997 | 1.10M | MI->flat_insn->detail->x86.operands[1].access = access[1]; |
998 | 1.10M | #endif |
999 | 1.10M | } |
1000 | 1.10M | } |
1001 | | |
1002 | | #endif |