?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
assemble: Only treat a displacement as signed if it is < asize
[nasm.git] / disasm.c
blobb7c5027f750cd65f4e6652c46aaa81727a54d010
1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 1996-2012 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 * ----------------------------------------------------------------------- */
33
34 /*
35 * disasm.c where all the _work_ gets done in the Netwide Disassembler
36 */
37
38 #include "compiler.h"
39
40 #include <stdio.h>
41 #include <string.h>
42 #include <limits.h>
43 #include <inttypes.h>
44
45 #include "nasm.h"
46 #include "disasm.h"
47 #include "sync.h"
48 #include "insns.h"
49 #include "tables.h"
50 #include "regdis.h"
51 #include "disp8.h"
52
53 /*
54 * Flags that go into the `segment' field of `insn' structures
55 * during disassembly.
56 */
57 #define SEG_RELATIVE 1
58 #define SEG_32BIT 2
59 #define SEG_RMREG 4
60 #define SEG_DISP8 8
61 #define SEG_DISP16 16
62 #define SEG_DISP32 32
63 #define SEG_NODISP 64
64 #define SEG_SIGNED 128
65 #define SEG_64BIT 256
66
67 /*
68 * Prefix information
69 */
70 struct prefix_info {
71 uint8_t osize; /* Operand size */
72 uint8_t asize; /* Address size */
73 uint8_t osp; /* Operand size prefix present */
74 uint8_t asp; /* Address size prefix present */
75 uint8_t rep; /* Rep prefix present */
76 uint8_t seg; /* Segment override prefix present */
77 uint8_t wait; /* WAIT "prefix" present */
78 uint8_t lock; /* Lock prefix present */
79 uint8_t vex[3]; /* VEX prefix present */
80 uint8_t vex_c; /* VEX "class" (VEX, XOP, ...) */
81 uint8_t vex_m; /* VEX.M field */
82 uint8_t vex_v;
83 uint8_t vex_lp; /* VEX.LP fields */
84 uint32_t rex; /* REX prefix present */
85 uint8_t evex[3]; /* EVEX prefix present */
86 };
87
88 #define getu8(x) (*(uint8_t *)(x))
89 #if X86_MEMORY
90 /* Littleendian CPU which can handle unaligned references */
91 #define getu16(x) (*(uint16_t *)(x))
92 #define getu32(x) (*(uint32_t *)(x))
93 #define getu64(x) (*(uint64_t *)(x))
94 #else
95 static uint16_t getu16(uint8_t *data)
96 {
97 return (uint16_t)data[0] + ((uint16_t)data[1] << 8);
98 }
99 static uint32_t getu32(uint8_t *data)
100 {
101 return (uint32_t)getu16(data) + ((uint32_t)getu16(data+2) << 16);
102 }
103 static uint64_t getu64(uint8_t *data)
104 {
105 return (uint64_t)getu32(data) + ((uint64_t)getu32(data+4) << 32);
106 }
107 #endif
108
109 #define gets8(x) ((int8_t)getu8(x))
110 #define gets16(x) ((int16_t)getu16(x))
111 #define gets32(x) ((int32_t)getu32(x))
112 #define gets64(x) ((int64_t)getu64(x))
113
114 /* Important: regval must already have been adjusted for rex extensions */
115 static enum reg_enum whichreg(opflags_t regflags, int regval, int rex)
116 {
117 size_t i;
118
119 static const struct {
120 opflags_t flags;
121 enum reg_enum reg;
122 } specific_registers[] = {
123 {REG_AL, R_AL},
124 {REG_AX, R_AX},
125 {REG_EAX, R_EAX},
126 {REG_RAX, R_RAX},
127 {REG_DL, R_DL},
128 {REG_DX, R_DX},
129 {REG_EDX, R_EDX},
130 {REG_RDX, R_RDX},
131 {REG_CL, R_CL},
132 {REG_CX, R_CX},
133 {REG_ECX, R_ECX},
134 {REG_RCX, R_RCX},
135 {FPU0, R_ST0},
136 {XMM0, R_XMM0},
137 {YMM0, R_YMM0},
138 {ZMM0, R_ZMM0},
139 {REG_ES, R_ES},
140 {REG_CS, R_CS},
141 {REG_SS, R_SS},
142 {REG_DS, R_DS},
143 {REG_FS, R_FS},
144 {REG_GS, R_GS},
145 {OPMASK0, R_K0},
146 };
147
148 if (!(regflags & (REGISTER|REGMEM)))
149 return 0; /* Registers not permissible?! */
150
151 regflags |= REGISTER;
152
153 for (i = 0; i < ARRAY_SIZE(specific_registers); i++)
154 if (!(specific_registers[i].flags & ~regflags))
155 return specific_registers[i].reg;
156
157 /* All the entries below look up regval in an 16-entry array */
158 if (regval < 0 || regval > (rex & REX_EV ? 31 : 15))
159 return 0;
160
161 if (!(REG8 & ~regflags)) {
162 if (rex & (REX_P|REX_NH))
163 return nasm_rd_reg8_rex[regval];
164 else
165 return nasm_rd_reg8[regval];
166 }
167 if (!(REG16 & ~regflags))
168 return nasm_rd_reg16[regval];
169 if (!(REG32 & ~regflags))
170 return nasm_rd_reg32[regval];
171 if (!(REG64 & ~regflags))
172 return nasm_rd_reg64[regval];
173 if (!(REG_SREG & ~regflags))
174 return nasm_rd_sreg[regval & 7]; /* Ignore REX */
175 if (!(REG_CREG & ~regflags))
176 return nasm_rd_creg[regval];
177 if (!(REG_DREG & ~regflags))
178 return nasm_rd_dreg[regval];
179 if (!(REG_TREG & ~regflags)) {
180 if (regval > 7)
181 return 0; /* TR registers are ill-defined with rex */
182 return nasm_rd_treg[regval];
183 }
184 if (!(FPUREG & ~regflags))
185 return nasm_rd_fpureg[regval & 7]; /* Ignore REX */
186 if (!(MMXREG & ~regflags))
187 return nasm_rd_mmxreg[regval & 7]; /* Ignore REX */
188 if (!(XMMREG & ~regflags))
189 return nasm_rd_xmmreg[regval];
190 if (!(YMMREG & ~regflags))
191 return nasm_rd_ymmreg[regval];
192 if (!(ZMMREG & ~regflags))
193 return nasm_rd_zmmreg[regval];
194 if (!(OPMASKREG & ~regflags))
195 return nasm_rd_opmaskreg[regval];
196 if (!(BNDREG & ~regflags))
197 return nasm_rd_bndreg[regval];
198
199 return 0;
200 }
201
202 static uint32_t append_evex_reg_deco(char *buf, uint32_t num,
203 decoflags_t deco, uint8_t *evex)
204 {
205 const char * const er_names[] = {"rn-sae", "rd-sae", "ru-sae", "rz-sae"};
206 uint32_t num_chars = 0;
207
208 if ((deco & MASK) && (evex[2] & EVEX_P2AAA)) {
209 enum reg_enum opmasknum = nasm_rd_opmaskreg[evex[2] & EVEX_P2AAA];
210 const char * regname = nasm_reg_names[opmasknum - EXPR_REG_START];
211
212 num_chars += snprintf(buf + num_chars, num - num_chars,
213 "{%s}", regname);
214
215 if ((deco & Z) && (evex[2] & EVEX_P2Z)) {
216 num_chars += snprintf(buf + num_chars, num - num_chars,
217 "{z}");
218 }
219 }
220
221 if (evex[2] & EVEX_P2B) {
222 if (deco & ER) {
223 uint8_t er_type = (evex[2] & EVEX_P2LL) >> 5;
224 num_chars += snprintf(buf + num_chars, num - num_chars,
225 ",{%s}", er_names[er_type]);
226 } else if (deco & SAE) {
227 num_chars += snprintf(buf + num_chars, num - num_chars,
228 ",{sae}");
229 }
230 }
231
232 return num_chars;
233 }
234
235 static uint32_t append_evex_mem_deco(char *buf, uint32_t num, opflags_t type,
236 decoflags_t deco, uint8_t *evex)
237 {
238 uint32_t num_chars = 0;
239
240 if ((evex[2] & EVEX_P2B) && (deco & BRDCAST_MASK)) {
241 decoflags_t deco_brsize = deco & BRSIZE_MASK;
242 opflags_t template_opsize = (deco_brsize == BR_BITS32 ? BITS32 : BITS64);
243 uint8_t br_num = (type & SIZE_MASK) / BITS128 *
244 BITS64 / template_opsize * 2;
245
246 num_chars += snprintf(buf + num_chars, num - num_chars,
247 "{1to%d}", br_num);
248 }
249
250 if ((deco & MASK) && (evex[2] & EVEX_P2AAA)) {
251 enum reg_enum opmasknum = nasm_rd_opmaskreg[evex[2] & EVEX_P2AAA];
252 const char * regname = nasm_reg_names[opmasknum - EXPR_REG_START];
253
254 num_chars += snprintf(buf + num_chars, num - num_chars,
255 "{%s}", regname);
256
257 if ((deco & Z) && (evex[2] & EVEX_P2Z)) {
258 num_chars += snprintf(buf + num_chars, num - num_chars,
259 "{z}");
260 }
261 }
262
263
264 return num_chars;
265 }
266
267 /*
268 * Process an effective address (ModRM) specification.
269 */
270 static uint8_t *do_ea(uint8_t *data, int modrm, int asize,
271 int segsize, enum ea_type type,
272 operand *op, insn *ins)
273 {
274 int mod, rm, scale, index, base;
275 int rex;
276 uint8_t *evex;
277 uint8_t sib = 0;
278 bool is_evex = !!(ins->rex & REX_EV);
279
280 mod = (modrm >> 6) & 03;
281 rm = modrm & 07;
282
283 if (mod != 3 && asize != 16 && rm == 4)
284 sib = *data++;
285
286 rex = ins->rex;
287 evex = ins->evex_p;
288
289 if (mod == 3) { /* pure register version */
290 op->basereg = rm+(rex & REX_B ? 8 : 0);
291 op->segment |= SEG_RMREG;
292 if (is_evex && segsize == 64) {
293 op->basereg += (evex[0] & EVEX_P0X ? 0 : 16);
294 }
295 return data;
296 }
297
298 op->disp_size = 0;
299 op->eaflags = 0;
300
301 if (asize == 16) {
302 /*
303 * <mod> specifies the displacement size (none, byte or
304 * word), and <rm> specifies the register combination.
305 * Exception: mod=0,rm=6 does not specify [BP] as one might
306 * expect, but instead specifies [disp16].
307 */
308
309 if (type != EA_SCALAR)
310 return NULL;
311
312 op->indexreg = op->basereg = -1;
313 op->scale = 1; /* always, in 16 bits */
314 switch (rm) {
315 case 0:
316 op->basereg = R_BX;
317 op->indexreg = R_SI;
318 break;
319 case 1:
320 op->basereg = R_BX;
321 op->indexreg = R_DI;
322 break;
323 case 2:
324 op->basereg = R_BP;
325 op->indexreg = R_SI;
326 break;
327 case 3:
328 op->basereg = R_BP;
329 op->indexreg = R_DI;
330 break;
331 case 4:
332 op->basereg = R_SI;
333 break;
334 case 5:
335 op->basereg = R_DI;
336 break;
337 case 6:
338 op->basereg = R_BP;
339 break;
340 case 7:
341 op->basereg = R_BX;
342 break;
343 }
344 if (rm == 6 && mod == 0) { /* special case */
345 op->basereg = -1;
346 if (segsize != 16)
347 op->disp_size = 16;
348 mod = 2; /* fake disp16 */
349 }
350 switch (mod) {
351 case 0:
352 op->segment |= SEG_NODISP;
353 break;
354 case 1:
355 op->segment |= SEG_DISP8;
356 if (ins->evex_tuple != 0) {
357 op->offset = gets8(data) * get_disp8N(ins);
358 } else {
359 op->offset = gets8(data);
360 }
361 data++;
362 break;
363 case 2:
364 op->segment |= SEG_DISP16;
365 op->offset = *data++;
366 op->offset |= ((unsigned)*data++) << 8;
367 break;
368 }
369 return data;
370 } else {
371 /*
372 * Once again, <mod> specifies displacement size (this time
373 * none, byte or *dword*), while <rm> specifies the base
374 * register. Again, [EBP] is missing, replaced by a pure
375 * disp32 (this time that's mod=0,rm=*5*) in 32-bit mode,
376 * and RIP-relative addressing in 64-bit mode.
377 *
378 * However, rm=4
379 * indicates not a single base register, but instead the
380 * presence of a SIB byte...
381 */
382 int a64 = asize == 64;
383
384 op->indexreg = -1;
385
386 if (a64)
387 op->basereg = nasm_rd_reg64[rm | ((rex & REX_B) ? 8 : 0)];
388 else
389 op->basereg = nasm_rd_reg32[rm | ((rex & REX_B) ? 8 : 0)];
390
391 if (rm == 5 && mod == 0) {
392 if (segsize == 64) {
393 op->eaflags |= EAF_REL;
394 op->segment |= SEG_RELATIVE;
395 mod = 2; /* fake disp32 */
396 }
397
398 if (asize != 64)
399 op->disp_size = asize;
400
401 op->basereg = -1;
402 mod = 2; /* fake disp32 */
403 }
404
405
406 if (rm == 4) { /* process SIB */
407 uint8_t vsib_hi = 0;
408 scale = (sib >> 6) & 03;
409 index = (sib >> 3) & 07;
410 base = sib & 07;
411
412 op->scale = 1 << scale;
413
414 if (segsize == 64) {
415 vsib_hi = (rex & REX_X ? 8 : 0) |
416 (evex[2] & EVEX_P2VP ? 0 : 16);
417 }
418
419 if (type == EA_XMMVSIB)
420 op->indexreg = nasm_rd_xmmreg[index | vsib_hi];
421 else if (type == EA_YMMVSIB)
422 op->indexreg = nasm_rd_ymmreg[index | vsib_hi];
423 else if (type == EA_ZMMVSIB)
424 op->indexreg = nasm_rd_zmmreg[index | vsib_hi];
425 else if (index == 4 && !(rex & REX_X))
426 op->indexreg = -1; /* ESP/RSP cannot be an index */
427 else if (a64)
428 op->indexreg = nasm_rd_reg64[index | ((rex & REX_X) ? 8 : 0)];
429 else
430 op->indexreg = nasm_rd_reg32[index | ((rex & REX_X) ? 8 : 0)];
431
432 if (base == 5 && mod == 0) {
433 op->basereg = -1;
434 mod = 2; /* Fake disp32 */
435 } else if (a64)
436 op->basereg = nasm_rd_reg64[base | ((rex & REX_B) ? 8 : 0)];
437 else
438 op->basereg = nasm_rd_reg32[base | ((rex & REX_B) ? 8 : 0)];
439
440 if (segsize == 16)
441 op->disp_size = 32;
442 } else if (type != EA_SCALAR) {
443 /* Can't have VSIB without SIB */
444 return NULL;
445 }
446
447 switch (mod) {
448 case 0:
449 op->segment |= SEG_NODISP;
450 break;
451 case 1:
452 op->segment |= SEG_DISP8;
453 if (ins->evex_tuple != 0) {
454 op->offset = gets8(data) * get_disp8N(ins);
455 } else {
456 op->offset = gets8(data);
457 }
458 data++;
459 break;
460 case 2:
461 op->segment |= SEG_DISP32;
462 op->offset = gets32(data);
463 data += 4;
464 break;
465 }
466 return data;
467 }
468 }
469
470 /*
471 * Determine whether the instruction template in t corresponds to the data
472 * stream in data. Return the number of bytes matched if so.
473 */
474 #define case4(x) case (x): case (x)+1: case (x)+2: case (x)+3
475
476 static int matches(const struct itemplate *t, uint8_t *data,
477 const struct prefix_info *prefix, int segsize, insn *ins)
478 {
479 uint8_t *r = (uint8_t *)(t->code);
480 uint8_t *origdata = data;
481 bool a_used = false, o_used = false;
482 enum prefixes drep = 0;
483 enum prefixes dwait = 0;
484 uint8_t lock = prefix->lock;
485 int osize = prefix->osize;
486 int asize = prefix->asize;
487 int i, c;
488 int op1, op2;
489 struct operand *opx, *opy;
490 uint8_t opex = 0;
491 bool vex_ok = false;
492 int regmask = (segsize == 64) ? 15 : 7;
493 enum ea_type eat = EA_SCALAR;
494
495 for (i = 0; i < MAX_OPERANDS; i++) {
496 ins->oprs[i].segment = ins->oprs[i].disp_size =
497 (segsize == 64 ? SEG_64BIT : segsize == 32 ? SEG_32BIT : 0);
498 }
499 ins->condition = -1;
500 ins->evex_tuple = 0;
501 ins->rex = prefix->rex;
502 memset(ins->prefixes, 0, sizeof ins->prefixes);
503
504 if (itemp_has(t, (segsize == 64 ? IF_NOLONG : IF_LONG)))
505 return false;
506
507 if (prefix->rep == 0xF2)
508 drep = (itemp_has(t, IF_BND) ? P_BND : P_REPNE);
509 else if (prefix->rep == 0xF3)
510 drep = P_REP;
511
512 dwait = prefix->wait ? P_WAIT : 0;
513
514 while ((c = *r++) != 0) {
515 op1 = (c & 3) + ((opex & 1) << 2);
516 op2 = ((c >> 3) & 3) + ((opex & 2) << 1);
517 opx = &ins->oprs[op1];
518 opy = &ins->oprs[op2];
519 opex = 0;
520
521 switch (c) {
522 case 01:
523 case 02:
524 case 03:
525 case 04:
526 while (c--)
527 if (*r++ != *data++)
528 return false;
529 break;
530
531 case 05:
532 case 06:
533 case 07:
534 opex = c;
535 break;
536
537 case4(010):
538 {
539 int t = *r++, d = *data++;
540 if (d < t || d > t + 7)
541 return false;
542 else {
543 opx->basereg = (d-t)+
544 (ins->rex & REX_B ? 8 : 0);
545 opx->segment |= SEG_RMREG;
546 }
547 break;
548 }
549
550 case4(014):
551 /* this is an separate index reg position of MIB operand (ICC) */
552 /* Disassembler uses NASM's split EA form only */
553 break;
554
555 case4(0274):
556 opx->offset = (int8_t)*data++;
557 opx->segment |= SEG_SIGNED;
558 break;
559
560 case4(020):
561 opx->offset = *data++;
562 break;
563
564 case4(024):
565 opx->offset = *data++;
566 break;
567
568 case4(030):
569 opx->offset = getu16(data);
570 data += 2;
571 break;
572
573 case4(034):
574 if (osize == 32) {
575 opx->offset = getu32(data);
576 data += 4;
577 } else {
578 opx->offset = getu16(data);
579 data += 2;
580 }
581 if (segsize != asize)
582 opx->disp_size = asize;
583 break;
584
585 case4(040):
586 opx->offset = getu32(data);
587 data += 4;
588 break;
589
590 case4(0254):
591 opx->offset = gets32(data);
592 data += 4;
593 break;
594
595 case4(044):
596 switch (asize) {
597 case 16:
598 opx->offset = getu16(data);
599 data += 2;
600 if (segsize != 16)
601 opx->disp_size = 16;
602 break;
603 case 32:
604 opx->offset = getu32(data);
605 data += 4;
606 if (segsize == 16)
607 opx->disp_size = 32;
608 break;
609 case 64:
610 opx->offset = getu64(data);
611 opx->disp_size = 64;
612 data += 8;
613 break;
614 }
615 break;
616
617 case4(050):
618 opx->offset = gets8(data++);
619 opx->segment |= SEG_RELATIVE;
620 break;
621
622 case4(054):
623 opx->offset = getu64(data);
624 data += 8;
625 break;
626
627 case4(060):
628 opx->offset = gets16(data);
629 data += 2;
630 opx->segment |= SEG_RELATIVE;
631 opx->segment &= ~SEG_32BIT;
632 break;
633
634 case4(064): /* rel */
635 opx->segment |= SEG_RELATIVE;
636 /* In long mode rel is always 32 bits, sign extended. */
637 if (segsize == 64 || osize == 32) {
638 opx->offset = gets32(data);
639 data += 4;
640 if (segsize != 64)
641 opx->segment |= SEG_32BIT;
642 opx->type = (opx->type & ~SIZE_MASK)
643 | (segsize == 64 ? BITS64 : BITS32);
644 } else {
645 opx->offset = gets16(data);
646 data += 2;
647 opx->segment &= ~SEG_32BIT;
648 opx->type = (opx->type & ~SIZE_MASK) | BITS16;
649 }
650 break;
651
652 case4(070):
653 opx->offset = gets32(data);
654 data += 4;
655 opx->segment |= SEG_32BIT | SEG_RELATIVE;
656 break;
657
658 case4(0100):
659 case4(0110):
660 case4(0120):
661 case4(0130):
662 {
663 int modrm = *data++;
664 opx->segment |= SEG_RMREG;
665 data = do_ea(data, modrm, asize, segsize, eat, opy, ins);
666 if (!data)
667 return false;
668 opx->basereg = ((modrm >> 3) & 7) + (ins->rex & REX_R ? 8 : 0);
669 if ((ins->rex & REX_EV) && (segsize == 64))
670 opx->basereg += (ins->evex_p[0] & EVEX_P0RP ? 0 : 16);
671 break;
672 }
673
674 case 0172:
675 {
676 uint8_t ximm = *data++;
677 c = *r++;
678 ins->oprs[c >> 3].basereg = (ximm >> 4) & regmask;
679 ins->oprs[c >> 3].segment |= SEG_RMREG;
680 ins->oprs[c & 7].offset = ximm & 15;
681 }
682 break;
683
684 case 0173:
685 {
686 uint8_t ximm = *data++;
687 c = *r++;
688
689 if ((c ^ ximm) & 15)
690 return false;
691
692 ins->oprs[c >> 4].basereg = (ximm >> 4) & regmask;
693 ins->oprs[c >> 4].segment |= SEG_RMREG;
694 }
695 break;
696
697 case4(0174):
698 {
699 uint8_t ximm = *data++;
700
701 opx->basereg = (ximm >> 4) & regmask;
702 opx->segment |= SEG_RMREG;
703 }
704 break;
705
706 case4(0200):
707 case4(0204):
708 case4(0210):
709 case4(0214):
710 case4(0220):
711 case4(0224):
712 case4(0230):
713 case4(0234):
714 {
715 int modrm = *data++;
716 if (((modrm >> 3) & 07) != (c & 07))
717 return false; /* spare field doesn't match up */
718 data = do_ea(data, modrm, asize, segsize, eat, opy, ins);
719 if (!data)
720 return false;
721 break;
722 }
723
724 case4(0240):
725 case 0250:
726 {
727 uint8_t evexm = *r++;
728 uint8_t evexwlp = *r++;
729 ins->evex_tuple = *r++ - 0300;
730
731 ins->rex |= REX_EV;
732 if ((prefix->rex & (REX_EV|REX_V|REX_P)) != REX_EV)
733 return false;
734
735 if ((evexm & 0x1f) != prefix->vex_m)
736 return false;
737
738 switch (evexwlp & 060) {
739 case 000:
740 if (prefix->rex & REX_W)
741 return false;
742 break;
743 case 020:
744 if (!(prefix->rex & REX_W))
745 return false;
746 ins->rex |= REX_W;
747 break;
748 case 040: /* VEX.W is a don't care */
749 ins->rex &= ~REX_W;
750 break;
751 case 060:
752 break;
753 }
754
755 /* If EVEX.b is set, EVEX.L'L can be rounding control bits */
756 if ((evexwlp ^ prefix->vex_lp) &
757 ((prefix->evex[2] & EVEX_P2B) ? 0x03 : 0x0f))
758 return false;
759
760 if (c == 0250) {
761 if ((prefix->vex_v != 0) ||
762 (!(prefix->evex[2] & EVEX_P2VP) &&
763 ((eat < EA_XMMVSIB) || (eat > EA_ZMMVSIB))))
764 return false;
765 } else {
766 opx->segment |= SEG_RMREG;
767 opx->basereg = ((~prefix->evex[2] & EVEX_P2VP) << (4 - 3) ) |
768 prefix->vex_v;
769 }
770 vex_ok = true;
771 memcpy(ins->evex_p, prefix->evex, 3);
772 break;
773 }
774
775 case4(0260):
776 case 0270:
777 {
778 int vexm = *r++;
779 int vexwlp = *r++;
780
781 ins->rex |= REX_V;
782 if ((prefix->rex & (REX_V|REX_P)) != REX_V)
783 return false;
784
785 if ((vexm & 0x1f) != prefix->vex_m)
786 return false;
787
788 switch (vexwlp & 060) {
789 case 000:
790 if (prefix->rex & REX_W)
791 return false;
792 break;
793 case 020:
794 if (!(prefix->rex & REX_W))
795 return false;
796 ins->rex &= ~REX_W;
797 break;
798 case 040: /* VEX.W is a don't care */
799 ins->rex &= ~REX_W;
800 break;
801 case 060:
802 break;
803 }
804
805 /* The 010 bit of vexwlp is set if VEX.L is ignored */
806 if ((vexwlp ^ prefix->vex_lp) & ((vexwlp & 010) ? 03 : 07))
807 return false;
808
809 if (c == 0270) {
810 if (prefix->vex_v != 0)
811 return false;
812 } else {
813 opx->segment |= SEG_RMREG;
814 opx->basereg = prefix->vex_v;
815 }
816 vex_ok = true;
817 break;
818 }
819
820 case 0271:
821 if (prefix->rep == 0xF3)
822 drep = P_XRELEASE;
823 break;
824
825 case 0272:
826 if (prefix->rep == 0xF2)
827 drep = P_XACQUIRE;
828 else if (prefix->rep == 0xF3)
829 drep = P_XRELEASE;
830 break;
831
832 case 0273:
833 if (prefix->lock == 0xF0) {
834 if (prefix->rep == 0xF2)
835 drep = P_XACQUIRE;
836 else if (prefix->rep == 0xF3)
837 drep = P_XRELEASE;
838 }
839 break;
840
841 case 0310:
842 if (asize != 16)
843 return false;
844 else
845 a_used = true;
846 break;
847
848 case 0311:
849 if (asize != 32)
850 return false;
851 else
852 a_used = true;
853 break;
854
855 case 0312:
856 if (asize != segsize)
857 return false;
858 else
859 a_used = true;
860 break;
861
862 case 0313:
863 if (asize != 64)
864 return false;
865 else
866 a_used = true;
867 break;
868
869 case 0314:
870 if (prefix->rex & REX_B)
871 return false;
872 break;
873
874 case 0315:
875 if (prefix->rex & REX_X)
876 return false;
877 break;
878
879 case 0316:
880 if (prefix->rex & REX_R)
881 return false;
882 break;
883
884 case 0317:
885 if (prefix->rex & REX_W)
886 return false;
887 break;
888
889 case 0320:
890 if (osize != 16)
891 return false;
892 else
893 o_used = true;
894 break;
895
896 case 0321:
897 if (osize != 32)
898 return false;
899 else
900 o_used = true;
901 break;
902
903 case 0322:
904 if (osize != (segsize == 16) ? 16 : 32)
905 return false;
906 else
907 o_used = true;
908 break;
909
910 case 0323:
911 ins->rex |= REX_W; /* 64-bit only instruction */
912 osize = 64;
913 o_used = true;
914 break;
915
916 case 0324:
917 if (osize != 64)
918 return false;
919 o_used = true;
920 break;
921
922 case 0325:
923 ins->rex |= REX_NH;
924 break;
925
926 case 0330:
927 {
928 int t = *r++, d = *data++;
929 if (d < t || d > t + 15)
930 return false;
931 else
932 ins->condition = d - t;
933 break;
934 }
935
936 case 0326:
937 if (prefix->rep == 0xF3)
938 return false;
939 break;
940
941 case 0331:
942 if (prefix->rep)
943 return false;
944 break;
945
946 case 0332:
947 if (prefix->rep != 0xF2)
948 return false;
949 drep = 0;
950 break;
951
952 case 0333:
953 if (prefix->rep != 0xF3)
954 return false;
955 drep = 0;
956 break;
957
958 case 0334:
959 if (lock) {
960 ins->rex |= REX_R;
961 lock = 0;
962 }
963 break;
964
965 case 0335:
966 if (drep == P_REP)
967 drep = P_REPE;
968 break;
969
970 case 0336:
971 case 0337:
972 break;
973
974 case 0340:
975 return false;
976
977 case 0341:
978 if (prefix->wait != 0x9B)
979 return false;
980 dwait = 0;
981 break;
982
983 case 0360:
984 if (prefix->osp || prefix->rep)
985 return false;
986 break;
987
988 case 0361:
989 if (!prefix->osp || prefix->rep)
990 return false;
991 o_used = true;
992 break;
993
994 case 0364:
995 if (prefix->osp)
996 return false;
997 break;
998
999 case 0365:
1000 if (prefix->asp)
1001 return false;
1002 break;
1003
1004 case 0366:
1005 if (!prefix->osp)
1006 return false;
1007 o_used = true;
1008 break;
1009
1010 case 0367:
1011 if (!prefix->asp)
1012 return false;
1013 a_used = true;
1014 break;
1015
1016 case 0370:
1017 case 0371:
1018 break;
1019
1020 case 0374:
1021 eat = EA_XMMVSIB;
1022 break;
1023
1024 case 0375:
1025 eat = EA_YMMVSIB;
1026 break;
1027
1028 case 0376:
1029 eat = EA_ZMMVSIB;
1030 break;
1031
1032 default:
1033 return false; /* Unknown code */
1034 }
1035 }
1036
1037 if (!vex_ok && (ins->rex & (REX_V | REX_EV)))
1038 return false;
1039
1040 /* REX cannot be combined with VEX */
1041 if ((ins->rex & REX_V) && (prefix->rex & REX_P))
1042 return false;
1043
1044 /*
1045 * Check for unused rep or a/o prefixes.
1046 */
1047 for (i = 0; i < t->operands; i++) {
1048 if (ins->oprs[i].segment != SEG_RMREG)
1049 a_used = true;
1050 }
1051
1052 if (lock) {
1053 if (ins->prefixes[PPS_LOCK])
1054 return false;
1055 ins->prefixes[PPS_LOCK] = P_LOCK;
1056 }
1057 if (drep) {
1058 if (ins->prefixes[PPS_REP])
1059 return false;
1060 ins->prefixes[PPS_REP] = drep;
1061 }
1062 ins->prefixes[PPS_WAIT] = dwait;
1063 if (!o_used) {
1064 if (osize != ((segsize == 16) ? 16 : 32)) {
1065 enum prefixes pfx = 0;
1066
1067 switch (osize) {
1068 case 16:
1069 pfx = P_O16;
1070 break;
1071 case 32:
1072 pfx = P_O32;
1073 break;
1074 case 64:
1075 pfx = P_O64;
1076 break;
1077 }
1078
1079 if (ins->prefixes[PPS_OSIZE])
1080 return false;
1081 ins->prefixes[PPS_OSIZE] = pfx;
1082 }
1083 }
1084 if (!a_used && asize != segsize) {
1085 if (ins->prefixes[PPS_ASIZE])
1086 return false;
1087 ins->prefixes[PPS_ASIZE] = asize == 16 ? P_A16 : P_A32;
1088 }
1089
1090 /* Fix: check for redundant REX prefixes */
1091
1092 return data - origdata;
1093 }
1094
1095 /* Condition names for disassembly, sorted by x86 code */
1096 static const char * const condition_name[16] = {
1097 "o", "no", "c", "nc", "z", "nz", "na", "a",
1098 "s", "ns", "pe", "po", "l", "nl", "ng", "g"
1099 };
1100
1101 int32_t disasm(uint8_t *data, char *output, int outbufsize, int segsize,
1102 int32_t offset, int autosync, iflag_t *prefer)
1103 {
1104 const struct itemplate * const *p, * const *best_p;
1105 const struct disasm_index *ix;
1106 uint8_t *dp;
1107 int length, best_length = 0;
1108 char *segover;
1109 int i, slen, colon, n;
1110 uint8_t *origdata;
1111 int works;
1112 insn tmp_ins, ins;
1113 iflag_t goodness, best;
1114 int best_pref;
1115 struct prefix_info prefix;
1116 bool end_prefix;
1117 bool is_evex;
1118
1119 memset(&ins, 0, sizeof ins);
1120
1121 /*
1122 * Scan for prefixes.
1123 */
1124 memset(&prefix, 0, sizeof prefix);
1125 prefix.asize = segsize;
1126 prefix.osize = (segsize == 64) ? 32 : segsize;
1127 segover = NULL;
1128 origdata = data;
1129
1130 ix = itable;
1131
1132 end_prefix = false;
1133 while (!end_prefix) {
1134 switch (*data) {
1135 case 0xF2:
1136 case 0xF3:
1137 prefix.rep = *data++;
1138 break;
1139
1140 case 0x9B:
1141 prefix.wait = *data++;
1142 break;
1143
1144 case 0xF0:
1145 prefix.lock = *data++;
1146 break;
1147
1148 case 0x2E:
1149 segover = "cs", prefix.seg = *data++;
1150 break;
1151 case 0x36:
1152 segover = "ss", prefix.seg = *data++;
1153 break;
1154 case 0x3E:
1155 segover = "ds", prefix.seg = *data++;
1156 break;
1157 case 0x26:
1158 segover = "es", prefix.seg = *data++;
1159 break;
1160 case 0x64:
1161 segover = "fs", prefix.seg = *data++;
1162 break;
1163 case 0x65:
1164 segover = "gs", prefix.seg = *data++;
1165 break;
1166
1167 case 0x66:
1168 prefix.osize = (segsize == 16) ? 32 : 16;
1169 prefix.osp = *data++;
1170 break;
1171 case 0x67:
1172 prefix.asize = (segsize == 32) ? 16 : 32;
1173 prefix.asp = *data++;
1174 break;
1175
1176 case 0xC4:
1177 case 0xC5:
1178 if (segsize == 64 || (data[1] & 0xc0) == 0xc0) {
1179 prefix.vex[0] = *data++;
1180 prefix.vex[1] = *data++;
1181
1182 prefix.rex = REX_V;
1183 prefix.vex_c = RV_VEX;
1184
1185 if (prefix.vex[0] == 0xc4) {
1186 prefix.vex[2] = *data++;
1187 prefix.rex |= (~prefix.vex[1] >> 5) & 7; /* REX_RXB */
1188 prefix.rex |= (prefix.vex[2] >> (7-3)) & REX_W;
1189 prefix.vex_m = prefix.vex[1] & 0x1f;
1190 prefix.vex_v = (~prefix.vex[2] >> 3) & 15;
1191 prefix.vex_lp = prefix.vex[2] & 7;
1192 } else {
1193 prefix.rex |= (~prefix.vex[1] >> (7-2)) & REX_R;
1194 prefix.vex_m = 1;
1195 prefix.vex_v = (~prefix.vex[1] >> 3) & 15;
1196 prefix.vex_lp = prefix.vex[1] & 7;
1197 }
1198
1199 ix = itable_vex[RV_VEX][prefix.vex_m][prefix.vex_lp & 3];
1200 }
1201 end_prefix = true;
1202 break;
1203
1204 case 0x62:
1205 {
1206 uint8_t evex_p0 = data[1] & 0x0f;
1207 if (segsize == 64 ||
1208 ((evex_p0 >= 0x01) && (evex_p0 <= 0x03))) {
1209 data++; /* 62h EVEX prefix */
1210 prefix.evex[0] = *data++;
1211 prefix.evex[1] = *data++;
1212 prefix.evex[2] = *data++;
1213
1214 prefix.rex = REX_EV;
1215 prefix.vex_c = RV_EVEX;
1216 prefix.rex |= (~prefix.evex[0] >> 5) & 7; /* REX_RXB */
1217 prefix.rex |= (prefix.evex[1] >> (7-3)) & REX_W;
1218 prefix.vex_m = prefix.evex[0] & EVEX_P0MM;
1219 prefix.vex_v = (~prefix.evex[1] & EVEX_P1VVVV) >> 3;
1220 prefix.vex_lp = ((prefix.evex[2] & EVEX_P2LL) >> (5-2)) |
1221 (prefix.evex[1] & EVEX_P1PP);
1222
1223 ix = itable_vex[prefix.vex_c][prefix.vex_m][prefix.vex_lp & 3];
1224 }
1225 end_prefix = true;
1226 break;
1227 }
1228
1229 case 0x8F:
1230 if ((data[1] & 030) != 0 &&
1231 (segsize == 64 || (data[1] & 0xc0) == 0xc0)) {
1232 prefix.vex[0] = *data++;
1233 prefix.vex[1] = *data++;
1234 prefix.vex[2] = *data++;
1235
1236 prefix.rex = REX_V;
1237 prefix.vex_c = RV_XOP;
1238
1239 prefix.rex |= (~prefix.vex[1] >> 5) & 7; /* REX_RXB */
1240 prefix.rex |= (prefix.vex[2] >> (7-3)) & REX_W;
1241 prefix.vex_m = prefix.vex[1] & 0x1f;
1242 prefix.vex_v = (~prefix.vex[2] >> 3) & 15;
1243 prefix.vex_lp = prefix.vex[2] & 7;
1244
1245 ix = itable_vex[RV_XOP][prefix.vex_m][prefix.vex_lp & 3];
1246 }
1247 end_prefix = true;
1248 break;
1249
1250 case REX_P + 0x0:
1251 case REX_P + 0x1:
1252 case REX_P + 0x2:
1253 case REX_P + 0x3:
1254 case REX_P + 0x4:
1255 case REX_P + 0x5:
1256 case REX_P + 0x6:
1257 case REX_P + 0x7:
1258 case REX_P + 0x8:
1259 case REX_P + 0x9:
1260 case REX_P + 0xA:
1261 case REX_P + 0xB:
1262 case REX_P + 0xC:
1263 case REX_P + 0xD:
1264 case REX_P + 0xE:
1265 case REX_P + 0xF:
1266 if (segsize == 64) {
1267 prefix.rex = *data++;
1268 if (prefix.rex & REX_W)
1269 prefix.osize = 64;
1270 }
1271 end_prefix = true;
1272 break;
1273
1274 default:
1275 end_prefix = true;
1276 break;
1277 }
1278 }
1279
1280 iflag_set_all(&best); /* Worst possible */
1281 best_p = NULL;
1282 best_pref = INT_MAX;
1283
1284 if (!ix)
1285 return 0; /* No instruction table at all... */
1286
1287 dp = data;
1288 ix += *dp++;
1289 while (ix->n == -1) {
1290 ix = (const struct disasm_index *)ix->p + *dp++;
1291 }
1292
1293 p = (const struct itemplate * const *)ix->p;
1294 for (n = ix->n; n; n--, p++) {
1295 if ((length = matches(*p, data, &prefix, segsize, &tmp_ins))) {
1296 works = true;
1297 /*
1298 * Final check to make sure the types of r/m match up.
1299 * XXX: Need to make sure this is actually correct.
1300 */
1301 for (i = 0; i < (*p)->operands; i++) {
1302 if (
1303 /* If it's a mem-only EA but we have a
1304 register, die. */
1305 ((tmp_ins.oprs[i].segment & SEG_RMREG) &&
1306 is_class(MEMORY, (*p)->opd[i])) ||
1307 /* If it's a reg-only EA but we have a memory
1308 ref, die. */
1309 (!(tmp_ins.oprs[i].segment & SEG_RMREG) &&
1310 !(REG_EA & ~(*p)->opd[i]) &&
1311 !((*p)->opd[i] & REG_SMASK)) ||
1312 /* Register type mismatch (eg FS vs REG_DESS):
1313 die. */
1314 ((((*p)->opd[i] & (REGISTER | FPUREG)) ||
1315 (tmp_ins.oprs[i].segment & SEG_RMREG)) &&
1316 !whichreg((*p)->opd[i],
1317 tmp_ins.oprs[i].basereg, tmp_ins.rex))
1318 ) {
1319 works = false;
1320 break;
1321 }
1322 }
1323
1324 /*
1325 * Note: we always prefer instructions which incorporate
1326 * prefixes in the instructions themselves. This is to allow
1327 * e.g. PAUSE to be preferred to REP NOP, and deal with
1328 * MMX/SSE instructions where prefixes are used to select
1329 * between MMX and SSE register sets or outright opcode
1330 * selection.
1331 */
1332 if (works) {
1333 int i, nprefix;
1334 goodness = iflag_pfmask(*p);
1335 goodness = iflag_xor(&goodness, prefer);
1336 nprefix = 0;
1337 for (i = 0; i < MAXPREFIX; i++)
1338 if (tmp_ins.prefixes[i])
1339 nprefix++;
1340 if (nprefix < best_pref ||
1341 (nprefix == best_pref && iflag_cmp(&goodness, &best) == -1)) {
1342 /* This is the best one found so far */
1343 best = goodness;
1344 best_p = p;
1345 best_pref = nprefix;
1346 best_length = length;
1347 ins = tmp_ins;
1348 }
1349 }
1350 }
1351 }
1352
1353 if (!best_p)
1354 return 0; /* no instruction was matched */
1355
1356 /* Pick the best match */
1357 p = best_p;
1358 length = best_length;
1359
1360 slen = 0;
1361
1362 /* TODO: snprintf returns the value that the string would have if
1363 * the buffer were long enough, and not the actual length of
1364 * the returned string, so each instance of using the return
1365 * value of snprintf should actually be checked to assure that
1366 * the return value is "sane." Maybe a macro wrapper could
1367 * be used for that purpose.
1368 */
1369 for (i = 0; i < MAXPREFIX; i++) {
1370 const char *prefix = prefix_name(ins.prefixes[i]);
1371 if (prefix)
1372 slen += snprintf(output+slen, outbufsize-slen, "%s ", prefix);
1373 }
1374
1375 i = (*p)->opcode;
1376 if (i >= FIRST_COND_OPCODE)
1377 slen += snprintf(output + slen, outbufsize - slen, "%s%s",
1378 nasm_insn_names[i], condition_name[ins.condition]);
1379 else
1380 slen += snprintf(output + slen, outbufsize - slen, "%s",
1381 nasm_insn_names[i]);
1382
1383 colon = false;
1384 is_evex = !!(ins.rex & REX_EV);
1385 length += data - origdata; /* fix up for prefixes */
1386 for (i = 0; i < (*p)->operands; i++) {
1387 opflags_t t = (*p)->opd[i];
1388 decoflags_t deco = (*p)->deco[i];
1389 const operand *o = &ins.oprs[i];
1390 int64_t offs;
1391
1392 output[slen++] = (colon ? ':' : i == 0 ? ' ' : ',');
1393
1394 offs = o->offset;
1395 if (o->segment & SEG_RELATIVE) {
1396 offs += offset + length;
1397 /*
1398 * sort out wraparound
1399 */
1400 if (!(o->segment & (SEG_32BIT|SEG_64BIT)))
1401 offs &= 0xffff;
1402 else if (segsize != 64)
1403 offs &= 0xffffffff;
1404
1405 /*
1406 * add sync marker, if autosync is on
1407 */
1408 if (autosync)
1409 add_sync(offs, 0L);
1410 }
1411
1412 if (t & COLON)
1413 colon = true;
1414 else
1415 colon = false;
1416
1417 if ((t & (REGISTER | FPUREG)) ||
1418 (o->segment & SEG_RMREG)) {
1419 enum reg_enum reg;
1420 reg = whichreg(t, o->basereg, ins.rex);
1421 if (t & TO)
1422 slen += snprintf(output + slen, outbufsize - slen, "to ");
1423 slen += snprintf(output + slen, outbufsize - slen, "%s",
1424 nasm_reg_names[reg-EXPR_REG_START]);
1425 if (is_evex && deco)
1426 slen += append_evex_reg_deco(output + slen, outbufsize - slen,
1427 deco, ins.evex_p);
1428 } else if (!(UNITY & ~t)) {
1429 output[slen++] = '1';
1430 } else if (t & IMMEDIATE) {
1431 if (t & BITS8) {
1432 slen +=
1433 snprintf(output + slen, outbufsize - slen, "byte ");
1434 if (o->segment & SEG_SIGNED) {
1435 if (offs < 0) {
1436 offs *= -1;
1437 output[slen++] = '-';
1438 } else
1439 output[slen++] = '+';
1440 }
1441 } else if (t & BITS16) {
1442 slen +=
1443 snprintf(output + slen, outbufsize - slen, "word ");
1444 } else if (t & BITS32) {
1445 slen +=
1446 snprintf(output + slen, outbufsize - slen, "dword ");
1447 } else if (t & BITS64) {
1448 slen +=
1449 snprintf(output + slen, outbufsize - slen, "qword ");
1450 } else if (t & NEAR) {
1451 slen +=
1452 snprintf(output + slen, outbufsize - slen, "near ");
1453 } else if (t & SHORT) {
1454 slen +=
1455 snprintf(output + slen, outbufsize - slen, "short ");
1456 }
1457 slen +=
1458 snprintf(output + slen, outbufsize - slen, "0x%"PRIx64"",
1459 offs);
1460 } else if (!(MEM_OFFS & ~t)) {
1461 slen +=
1462 snprintf(output + slen, outbufsize - slen,
1463 "[%s%s%s0x%"PRIx64"]",
1464 (segover ? segover : ""),
1465 (segover ? ":" : ""),
1466 (o->disp_size == 64 ? "qword " :
1467 o->disp_size == 32 ? "dword " :
1468 o->disp_size == 16 ? "word " : ""), offs);
1469 segover = NULL;
1470 } else if (is_class(REGMEM, t)) {
1471 int started = false;
1472 if (t & BITS8)
1473 slen +=
1474 snprintf(output + slen, outbufsize - slen, "byte ");
1475 if (t & BITS16)
1476 slen +=
1477 snprintf(output + slen, outbufsize - slen, "word ");
1478 if (t & BITS32)
1479 slen +=
1480 snprintf(output + slen, outbufsize - slen, "dword ");
1481 if (t & BITS64)
1482 slen +=
1483 snprintf(output + slen, outbufsize - slen, "qword ");
1484 if (t & BITS80)
1485 slen +=
1486 snprintf(output + slen, outbufsize - slen, "tword ");
1487 if ((ins.evex_p[2] & EVEX_P2B) && (deco & BRDCAST_MASK)) {
1488 /* when broadcasting, each element size should be used */
1489 if (deco & BR_BITS32)
1490 slen +=
1491 snprintf(output + slen, outbufsize - slen, "dword ");
1492 else if (deco & BR_BITS64)
1493 slen +=
1494 snprintf(output + slen, outbufsize - slen, "qword ");
1495 } else {
1496 if (t & BITS128)
1497 slen +=
1498 snprintf(output + slen, outbufsize - slen, "oword ");
1499 if (t & BITS256)
1500 slen +=
1501 snprintf(output + slen, outbufsize - slen, "yword ");
1502 if (t & BITS512)
1503 slen +=
1504 snprintf(output + slen, outbufsize - slen, "zword ");
1505 }
1506 if (t & FAR)
1507 slen += snprintf(output + slen, outbufsize - slen, "far ");
1508 if (t & NEAR)
1509 slen +=
1510 snprintf(output + slen, outbufsize - slen, "near ");
1511 output[slen++] = '[';
1512 if (o->disp_size)
1513 slen += snprintf(output + slen, outbufsize - slen, "%s",
1514 (o->disp_size == 64 ? "qword " :
1515 o->disp_size == 32 ? "dword " :
1516 o->disp_size == 16 ? "word " :
1517 ""));
1518 if (o->eaflags & EAF_REL)
1519 slen += snprintf(output + slen, outbufsize - slen, "rel ");
1520 if (segover) {
1521 slen +=
1522 snprintf(output + slen, outbufsize - slen, "%s:",
1523 segover);
1524 segover = NULL;
1525 }
1526 if (o->basereg != -1) {
1527 slen += snprintf(output + slen, outbufsize - slen, "%s",
1528 nasm_reg_names[(o->basereg-EXPR_REG_START)]);
1529 started = true;
1530 }
1531 if (o->indexreg != -1 && !itemp_has(*best_p, IF_MIB)) {
1532 if (started)
1533 output[slen++] = '+';
1534 slen += snprintf(output + slen, outbufsize - slen, "%s",
1535 nasm_reg_names[(o->indexreg-EXPR_REG_START)]);
1536 if (o->scale > 1)
1537 slen +=
1538 snprintf(output + slen, outbufsize - slen, "*%d",
1539 o->scale);
1540 started = true;
1541 }
1542
1543
1544 if (o->segment & SEG_DISP8) {
1545 if (is_evex) {
1546 const char *prefix;
1547 uint32_t offset = offs;
1548 if ((int32_t)offset < 0) {
1549 prefix = "-";
1550 offset = -offset;
1551 } else {
1552 prefix = "+";
1553 }
1554 slen +=
1555 snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx32"",
1556 prefix, offset);
1557 } else {
1558 const char *prefix;
1559 uint8_t offset = offs;
1560 if ((int8_t)offset < 0) {
1561 prefix = "-";
1562 offset = -offset;
1563 } else {
1564 prefix = "+";
1565 }
1566 slen +=
1567 snprintf(output + slen, outbufsize - slen, "%s0x%"PRIx8"",
1568 prefix, offset);
1569 }
1570 } else if (o->segment & SEG_DISP16) {
1571 const char *prefix;
1572 uint16_t offset = offs;
1573 if ((int16_t)offset < 0 && started) {
1574 offset = -offset;
1575 prefix = "-";
1576 } else {
1577 prefix = started ? "+" : "";
1578 }
1579 slen +=
1580 snprintf(output + slen, outbufsize - slen,
1581 "%s0x%"PRIx16"", prefix, offset);
1582 } else if (o->segment & SEG_DISP32) {
1583 if (prefix.asize == 64) {
1584 const char *prefix;
1585 uint64_t offset = (int64_t)(int32_t)offs;
1586 if ((int32_t)offs < 0 && started) {
1587 offset = -offset;
1588 prefix = "-";
1589 } else {
1590 prefix = started ? "+" : "";
1591 }
1592 slen +=
1593 snprintf(output + slen, outbufsize - slen,
1594 "%s0x%"PRIx64"", prefix, offset);
1595 } else {
1596 const char *prefix;
1597 uint32_t offset = offs;
1598 if ((int32_t) offset < 0 && started) {
1599 offset = -offset;
1600 prefix = "-";
1601 } else {
1602 prefix = started ? "+" : "";
1603 }
1604 slen +=
1605 snprintf(output + slen, outbufsize - slen,
1606 "%s0x%"PRIx32"", prefix, offset);
1607 }
1608 }
1609
1610 if (o->indexreg != -1 && itemp_has(*best_p, IF_MIB)) {
1611 output[slen++] = ',';
1612 slen += snprintf(output + slen, outbufsize - slen, "%s",
1613 nasm_reg_names[(o->indexreg-EXPR_REG_START)]);
1614 if (o->scale > 1)
1615 slen +=
1616 snprintf(output + slen, outbufsize - slen, "*%d",
1617 o->scale);
1618 started = true;
1619 }
1620
1621 output[slen++] = ']';
1622
1623 if (is_evex && deco)
1624 slen += append_evex_mem_deco(output + slen, outbufsize - slen,
1625 t, deco, ins.evex_p);
1626 } else {
1627 slen +=
1628 snprintf(output + slen, outbufsize - slen, "<operand%d>",
1629 i);
1630 }
1631 }
1632 output[slen] = '\0';
1633 if (segover) { /* unused segment override */
1634 char *p = output;
1635 int count = slen + 1;
1636 while (count--)
1637 p[count + 3] = p[count];
1638 strncpy(output, segover, 2);
1639 output[2] = ' ';
1640 }
1641 return length;
1642 }
1643
1644 /*
1645 * This is called when we don't have a complete instruction. If it
1646 * is a standalone *single-byte* prefix show it as such, otherwise
1647 * print it as a literal.
1648 */
1649 int32_t eatbyte(uint8_t *data, char *output, int outbufsize, int segsize)
1650 {
1651 uint8_t byte = *data;
1652 const char *str = NULL;
1653
1654 switch (byte) {
1655 case 0xF2:
1656 str = "repne";
1657 break;
1658 case 0xF3:
1659 str = "rep";
1660 break;
1661 case 0x9B:
1662 str = "wait";
1663 break;
1664 case 0xF0:
1665 str = "lock";
1666 break;
1667 case 0x2E:
1668 str = "cs";
1669 break;
1670 case 0x36:
1671 str = "ss";
1672 break;
1673 case 0x3E:
1674 str = "ss";
1675 break;
1676 case 0x26:
1677 str = "es";
1678 break;
1679 case 0x64:
1680 str = "fs";
1681 break;
1682 case 0x65:
1683 str = "gs";
1684 break;
1685 case 0x66:
1686 str = (segsize == 16) ? "o32" : "o16";
1687 break;
1688 case 0x67:
1689 str = (segsize == 32) ? "a16" : "a32";
1690 break;
1691 case REX_P + 0x0:
1692 case REX_P + 0x1:
1693 case REX_P + 0x2:
1694 case REX_P + 0x3:
1695 case REX_P + 0x4:
1696 case REX_P + 0x5:
1697 case REX_P + 0x6:
1698 case REX_P + 0x7:
1699 case REX_P + 0x8:
1700 case REX_P + 0x9:
1701 case REX_P + 0xA:
1702 case REX_P + 0xB:
1703 case REX_P + 0xC:
1704 case REX_P + 0xD:
1705 case REX_P + 0xE:
1706 case REX_P + 0xF:
1707 if (segsize == 64) {
1708 snprintf(output, outbufsize, "rex%s%s%s%s%s",
1709 (byte == REX_P) ? "" : ".",
1710 (byte & REX_W) ? "w" : "",
1711 (byte & REX_R) ? "r" : "",
1712 (byte & REX_X) ? "x" : "",
1713 (byte & REX_B) ? "b" : "");
1714 break;
1715 }
1716 /* else fall through */
1717 default:
1718 snprintf(output, outbufsize, "db 0x%02x", byte);
1719 break;
1720 }
1721
1722 if (str)
1723 snprintf(output, outbufsize, "%s", str);
1724
1725 return 1;
1726 }
The Netwide Assembler