1 /* Helper routines for disassembler for x86/x86-64. 2 Copyright (C) 2007, 2008 Red Hat, Inc. 3 This file is part of Red Hat elfutils. 4 Written by Ulrich Drepper <drepper (at) redhat.com>, 2007. 5 6 Red Hat elfutils is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by the 8 Free Software Foundation; version 2 of the License. 9 10 Red Hat elfutils is distributed in the hope that it will be useful, but 11 WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 General Public License for more details. 14 15 You should have received a copy of the GNU General Public License along 16 with Red Hat elfutils; if not, write to the Free Software Foundation, 17 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 18 19 Red Hat elfutils is an included package of the Open Invention Network. 20 An included package of the Open Invention Network is a package for which 21 Open Invention Network licensees cross-license their patents. No patent 22 license is granted, either expressly or impliedly, by designation as an 23 included package. Should you wish to participate in the Open Invention 24 Network licensing program, please visit www.openinventionnetwork.com 25 <http://www.openinventionnetwork.com>. */ 26 27 #include <inttypes.h> 28 #include <stddef.h> 29 #include <stdio.h> 30 #include <stdint.h> 31 #include <libasm.h> 32 33 struct instr_enc 34 { 35 /* The mnemonic. Especially encoded for the optimized table. */ 36 unsigned int mnemonic : MNEMONIC_BITS; 37 38 /* The rep/repe prefixes. */ 39 unsigned int rep : 1; 40 unsigned int repe : 1; 41 42 /* Mnemonic suffix. */ 43 unsigned int suffix : SUFFIX_BITS; 44 45 /* Nonzero if the instruction uses modr/m. */ 46 unsigned int modrm : 1; 47 48 /* 1st parameter. */ 49 unsigned int fct1 : FCT1_BITS; 50 #ifdef STR1_BITS 51 unsigned int str1 : STR1_BITS; 52 #endif 53 unsigned int off1_1 : OFF1_1_BITS; 54 unsigned int off1_2 : OFF1_2_BITS; 55 unsigned int off1_3 : OFF1_3_BITS; 56 57 /* 2nd parameter. */ 58 unsigned int fct2 : FCT2_BITS; 59 #ifdef STR2_BITS 60 unsigned int str2 : STR2_BITS; 61 #endif 62 unsigned int off2_1 : OFF2_1_BITS; 63 unsigned int off2_2 : OFF2_2_BITS; 64 unsigned int off2_3 : OFF2_3_BITS; 65 66 /* 3rd parameter. */ 67 unsigned int fct3 : FCT3_BITS; 68 #ifdef STR3_BITS 69 unsigned int str3 : STR3_BITS; 70 #endif 71 unsigned int off3_1 : OFF3_1_BITS; 72 #ifdef OFF3_2_BITS 73 unsigned int off3_2 : OFF3_2_BITS; 74 #endif 75 #ifdef OFF3_3_BITS 76 unsigned int off3_3 : OFF3_3_BITS; 77 #endif 78 }; 79 80 81 typedef int (*opfct_t) (struct output_data *); 82 83 84 static int 85 data_prefix (struct output_data *d) 86 { 87 char ch = '\0'; 88 if (*d->prefixes & has_cs) 89 { 90 ch = 'c'; 91 *d->prefixes &= ~has_cs; 92 } 93 else if (*d->prefixes & has_ds) 94 { 95 ch = 'd'; 96 *d->prefixes &= ~has_ds; 97 } 98 else if (*d->prefixes & has_es) 99 { 100 ch = 'e'; 101 *d->prefixes &= ~has_es; 102 } 103 else if (*d->prefixes & has_fs) 104 { 105 ch = 'f'; 106 *d->prefixes &= ~has_fs; 107 } 108 else if (*d->prefixes & has_gs) 109 { 110 ch = 'g'; 111 *d->prefixes &= ~has_gs; 112 } 113 else if (*d->prefixes & has_ss) 114 { 115 ch = 's'; 116 *d->prefixes &= ~has_ss; 117 } 118 else 119 return 0; 120 121 if (*d->bufcntp + 4 > d->bufsize) 122 return *d->bufcntp + 4 - d->bufsize; 123 124 d->bufp[(*d->bufcntp)++] = '%'; 125 d->bufp[(*d->bufcntp)++] = ch; 126 d->bufp[(*d->bufcntp)++] = 's'; 127 d->bufp[(*d->bufcntp)++] = ':'; 128 129 return 0; 130 } 131 132 #ifdef X86_64 133 static const char hiregs[8][4] = 134 { 135 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 136 }; 137 static const char aregs[8][4] = 138 { 139 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi" 140 }; 141 static const char dregs[8][4] = 142 { 143 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" 144 }; 145 #else 146 static const char aregs[8][4] = 147 { 148 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi" 149 }; 150 # define dregs aregs 151 #endif 152 153 static int 154 general_mod$r_m (struct output_data *d) 155 { 156 int r = data_prefix (d); 157 if (r != 0) 158 return r; 159 160 int prefixes = *d->prefixes; 161 const uint8_t *data = &d->data[d->opoff1 / 8]; 162 char *bufp = d->bufp; 163 size_t *bufcntp = d->bufcntp; 164 size_t bufsize = d->bufsize; 165 166 uint_fast8_t modrm = data[0]; 167 #ifndef X86_64 168 if (unlikely ((prefixes & has_addr16) != 0)) 169 { 170 int16_t disp = 0; 171 bool nodisp = false; 172 173 if ((modrm & 0xc7) == 6 || (modrm & 0xc0) == 0x80) 174 /* 16 bit displacement. */ 175 disp = read_2sbyte_unaligned (&data[1]); 176 else if ((modrm & 0xc0) == 0x40) 177 /* 8 bit displacement. */ 178 disp = *(const int8_t *) &data[1]; 179 else if ((modrm & 0xc0) == 0) 180 nodisp = true; 181 182 char tmpbuf[sizeof ("-0x1234(%rr,%rr)")]; 183 int n; 184 if ((modrm & 0xc7) == 6) 185 n = snprintf (tmpbuf, sizeof (tmpbuf), "0x%" PRIx16, disp); 186 else 187 { 188 n = 0; 189 if (!nodisp) 190 n = snprintf (tmpbuf, sizeof (tmpbuf), "%s0x%" PRIx16, 191 disp < 0 ? "-" : "", disp < 0 ? -disp : disp); 192 193 if ((modrm & 0x4) == 0) 194 n += snprintf (tmpbuf + n, sizeof (tmpbuf) - n, "(%%b%c,%%%ci)", 195 "xp"[(modrm >> 1) & 1], "sd"[modrm & 1]); 196 else 197 n += snprintf (tmpbuf + n, sizeof (tmpbuf) - n, "(%%%s)", 198 ((const char [4][3]) { "si", "di", "bp", "bx" })[modrm & 3]); 199 } 200 201 if (*bufcntp + n + 1 > bufsize) 202 return *bufcntp + n + 1 - bufsize; 203 204 memcpy (&bufp[*bufcntp], tmpbuf, n + 1); 205 *bufcntp += n; 206 } 207 else 208 #endif 209 { 210 if ((modrm & 7) != 4) 211 { 212 int32_t disp = 0; 213 bool nodisp = false; 214 215 if ((modrm & 0xc7) == 5 || (modrm & 0xc0) == 0x80) 216 /* 32 bit displacement. */ 217 disp = read_4sbyte_unaligned (&data[1]); 218 else if ((modrm & 0xc0) == 0x40) 219 /* 8 bit displacement. */ 220 disp = *(const int8_t *) &data[1]; 221 else if ((modrm & 0xc0) == 0) 222 nodisp = true; 223 224 char tmpbuf[sizeof ("-0x12345678(%rrrr)")]; 225 int n; 226 if (nodisp) 227 { 228 n = snprintf (tmpbuf, sizeof (tmpbuf), "(%%%s)", 229 #ifdef X86_64 230 (prefixes & has_rex_b) ? hiregs[modrm & 7] : 231 #endif 232 aregs[modrm & 7]); 233 #ifdef X86_64 234 if (prefixes & has_addr16) 235 { 236 if (prefixes & has_rex_b) 237 tmpbuf[n++] = 'd'; 238 else 239 tmpbuf[2] = 'e'; 240 } 241 #endif 242 } 243 else if ((modrm & 0xc7) != 5) 244 { 245 int p; 246 n = snprintf (tmpbuf, sizeof (tmpbuf), "%s0x%" PRIx32 "(%%%n%s)", 247 disp < 0 ? "-" : "", disp < 0 ? -disp : disp, &p, 248 #ifdef X86_64 249 (prefixes & has_rex_b) ? hiregs[modrm & 7] : 250 #endif 251 aregs[modrm & 7]); 252 #ifdef X86_64 253 if (prefixes & has_addr16) 254 { 255 if (prefixes & has_rex_b) 256 tmpbuf[n++] = 'd'; 257 else 258 tmpbuf[p] = 'e'; 259 } 260 #endif 261 } 262 else 263 { 264 #ifdef X86_64 265 n = snprintf (tmpbuf, sizeof (tmpbuf), "%s0x%" PRIx32 "(%%rip)", 266 disp < 0 ? "-" : "", disp < 0 ? -disp : disp); 267 268 d->symaddr_use = addr_rel_always; 269 d->symaddr = disp; 270 #else 271 n = snprintf (tmpbuf, sizeof (tmpbuf), "0x%" PRIx32, disp); 272 #endif 273 } 274 275 if (*bufcntp + n + 1 > bufsize) 276 return *bufcntp + n + 1 - bufsize; 277 278 memcpy (&bufp[*bufcntp], tmpbuf, n + 1); 279 *bufcntp += n; 280 } 281 else 282 { 283 /* SIB */ 284 uint_fast8_t sib = data[1]; 285 int32_t disp = 0; 286 bool nodisp = false; 287 288 if ((modrm & 0xc7) == 5 || (modrm & 0xc0) == 0x80 289 || ((modrm & 0xc7) == 0x4 && (sib & 0x7) == 0x5)) 290 /* 32 bit displacement. */ 291 disp = read_4sbyte_unaligned (&data[2]); 292 else if ((modrm & 0xc0) == 0x40) 293 /* 8 bit displacement. */ 294 disp = *(const int8_t *) &data[2]; 295 else 296 nodisp = true; 297 298 char tmpbuf[sizeof ("-0x12345678(%rrrr,%rrrr,N)")]; 299 char *cp = tmpbuf; 300 int n; 301 if ((modrm & 0xc0) != 0 || (sib & 0x3f) != 0x25 302 #ifdef X86_64 303 || (prefixes & has_rex_x) != 0 304 #endif 305 ) 306 { 307 if (!nodisp) 308 { 309 n = snprintf (cp, sizeof (tmpbuf), "%s0x%" PRIx32, 310 disp < 0 ? "-" : "", disp < 0 ? -disp : disp); 311 cp += n; 312 } 313 314 *cp++ = '('; 315 316 if ((modrm & 0xc7) != 0x4 || (sib & 0x7) != 0x5) 317 { 318 *cp++ = '%'; 319 cp = stpcpy (cp, 320 #ifdef X86_64 321 (prefixes & has_rex_b) ? hiregs[sib & 7] : 322 (prefixes & has_addr16) ? dregs[sib & 7] : 323 #endif 324 aregs[sib & 7]); 325 #ifdef X86_64 326 if ((prefixes & (has_rex_b | has_addr16)) 327 == (has_rex_b | has_addr16)) 328 *cp++ = 'd'; 329 #endif 330 } 331 332 if ((sib & 0x38) != 0x20 333 #ifdef X86_64 334 || (prefixes & has_rex_x) != 0 335 #endif 336 ) 337 { 338 *cp++ = ','; 339 *cp++ = '%'; 340 cp = stpcpy (cp, 341 #ifdef X86_64 342 (prefixes & has_rex_x) 343 ? hiregs[(sib >> 3) & 7] : 344 (prefixes & has_addr16) 345 ? dregs[(sib >> 3) & 7] : 346 #endif 347 aregs[(sib >> 3) & 7]); 348 #ifdef X86_64 349 if ((prefixes & (has_rex_b | has_addr16)) 350 == (has_rex_b | has_addr16)) 351 *cp++ = 'd'; 352 #endif 353 354 *cp++ = ','; 355 *cp++ = '0' + (1 << (sib >> 6)); 356 } 357 358 *cp++ = ')'; 359 } 360 else 361 { 362 assert (! nodisp); 363 #ifdef X86_64 364 if ((prefixes & has_addr16) == 0) 365 n = snprintf (cp, sizeof (tmpbuf), "0x%" PRIx64, 366 (int64_t) disp); 367 else 368 #endif 369 n = snprintf (cp, sizeof (tmpbuf), "0x%" PRIx32, disp); 370 cp += n; 371 } 372 373 if (*bufcntp + (cp - tmpbuf) > bufsize) 374 return *bufcntp + (cp - tmpbuf) - bufsize; 375 376 memcpy (&bufp[*bufcntp], tmpbuf, cp - tmpbuf); 377 *bufcntp += cp - tmpbuf; 378 } 379 } 380 return 0; 381 } 382 383 384 static int 385 FCT_MOD$R_M (struct output_data *d) 386 { 387 assert (d->opoff1 % 8 == 0); 388 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 389 if ((modrm & 0xc0) == 0xc0) 390 { 391 assert (d->opoff1 / 8 == d->opoff2 / 8); 392 assert (d->opoff2 % 8 == 5); 393 //uint_fast8_t byte = d->data[d->opoff2 / 8] & 7; 394 uint_fast8_t byte = modrm & 7; 395 396 size_t *bufcntp = d->bufcntp; 397 char *buf = d->bufp + *bufcntp; 398 size_t avail = d->bufsize - *bufcntp; 399 int needed; 400 if (*d->prefixes & (has_rep | has_repne)) 401 needed = snprintf (buf, avail, "%%%s", dregs[byte]); 402 else 403 needed = snprintf (buf, avail, "%%mm%" PRIxFAST8, byte); 404 if ((size_t) needed > avail) 405 return needed - avail; 406 *bufcntp += needed; 407 return 0; 408 } 409 410 return general_mod$r_m (d); 411 } 412 413 414 static int 415 FCT_Mod$R_m (struct output_data *d) 416 { 417 assert (d->opoff1 % 8 == 0); 418 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 419 if ((modrm & 0xc0) == 0xc0) 420 { 421 assert (d->opoff1 / 8 == d->opoff2 / 8); 422 assert (d->opoff2 % 8 == 5); 423 //uint_fast8_t byte = data[opoff2 / 8] & 7; 424 uint_fast8_t byte = modrm & 7; 425 426 size_t *bufcntp = d->bufcntp; 427 size_t avail = d->bufsize - *bufcntp; 428 int needed = snprintf (&d->bufp[*bufcntp], avail, "%%xmm%" PRIxFAST8, 429 byte); 430 if ((size_t) needed > avail) 431 return needed - avail; 432 *d->bufcntp += needed; 433 return 0; 434 } 435 436 return general_mod$r_m (d); 437 } 438 439 static int 440 generic_abs (struct output_data *d, const char *absstring 441 #ifdef X86_64 442 , int abslen 443 #else 444 # define abslen 4 445 #endif 446 ) 447 { 448 int r = data_prefix (d); 449 if (r != 0) 450 return r; 451 452 assert (d->opoff1 % 8 == 0); 453 assert (d->opoff1 / 8 == 1); 454 if (*d->param_start + abslen > d->end) 455 return -1; 456 *d->param_start += abslen; 457 #ifndef X86_64 458 uint32_t absval; 459 # define ABSPRIFMT PRIx32 460 #else 461 uint64_t absval; 462 # define ABSPRIFMT PRIx64 463 if (abslen == 8) 464 absval = read_8ubyte_unaligned (&d->data[1]); 465 else 466 #endif 467 absval = read_4ubyte_unaligned (&d->data[1]); 468 size_t *bufcntp = d->bufcntp; 469 size_t avail = d->bufsize - *bufcntp; 470 int needed = snprintf (&d->bufp[*bufcntp], avail, "%s0x%" ABSPRIFMT, 471 absstring, absval); 472 if ((size_t) needed > avail) 473 return needed - avail; 474 *bufcntp += needed; 475 return 0; 476 } 477 478 479 static int 480 FCT_absval (struct output_data *d) 481 { 482 return generic_abs (d, "$" 483 #ifdef X86_64 484 , 4 485 #endif 486 ); 487 } 488 489 static int 490 FCT_abs (struct output_data *d) 491 { 492 return generic_abs (d, "" 493 #ifdef X86_64 494 , 8 495 #endif 496 ); 497 } 498 499 static int 500 FCT_ax (struct output_data *d) 501 { 502 int is_16bit = (*d->prefixes & has_data16) != 0; 503 504 size_t *bufcntp = d->bufcntp; 505 char *bufp = d->bufp; 506 size_t bufsize = d->bufsize; 507 508 if (*bufcntp + 4 - is_16bit > bufsize) 509 return *bufcntp + 4 - is_16bit - bufsize; 510 511 bufp[(*bufcntp)++] = '%'; 512 if (! is_16bit) 513 bufp[(*bufcntp)++] = ( 514 #ifdef X86_64 515 (*d->prefixes & has_rex_w) ? 'r' : 516 #endif 517 'e'); 518 bufp[(*bufcntp)++] = 'a'; 519 bufp[(*bufcntp)++] = 'x'; 520 521 return 0; 522 } 523 524 525 static int 526 FCT_ax$w (struct output_data *d) 527 { 528 if ((d->data[d->opoff2 / 8] & (1 << (7 - (d->opoff2 & 7)))) != 0) 529 return FCT_ax (d); 530 531 size_t *bufcntp = d->bufcntp; 532 char *bufp = d->bufp; 533 size_t bufsize = d->bufsize; 534 535 if (*bufcntp + 3 > bufsize) 536 return *bufcntp + 3 - bufsize; 537 538 bufp[(*bufcntp)++] = '%'; 539 bufp[(*bufcntp)++] = 'a'; 540 bufp[(*bufcntp)++] = 'l'; 541 542 return 0; 543 } 544 545 546 static int 547 __attribute__ ((noinline)) 548 FCT_crdb (struct output_data *d, const char *regstr) 549 { 550 if (*d->prefixes & has_data16) 551 return -1; 552 553 size_t *bufcntp = d->bufcntp; 554 555 // XXX If this assert is true, use absolute offset below 556 assert (d->opoff1 / 8 == 2); 557 assert (d->opoff1 % 8 == 2); 558 size_t avail = d->bufsize - *bufcntp; 559 int needed = snprintf (&d->bufp[*bufcntp], avail, "%%%s%" PRIx32, 560 regstr, (uint32_t) (d->data[d->opoff1 / 8] >> 3) & 7); 561 if ((size_t) needed > avail) 562 return needed - avail; 563 *bufcntp += needed; 564 return 0; 565 } 566 567 568 static int 569 FCT_ccc (struct output_data *d) 570 { 571 return FCT_crdb (d, "cr"); 572 } 573 574 575 static int 576 FCT_ddd (struct output_data *d) 577 { 578 return FCT_crdb (d, "db"); 579 } 580 581 582 static int 583 FCT_disp8 (struct output_data *d) 584 { 585 assert (d->opoff1 % 8 == 0); 586 if (*d->param_start >= d->end) 587 return -1; 588 int32_t offset = *(const int8_t *) (*d->param_start)++; 589 590 size_t *bufcntp = d->bufcntp; 591 size_t avail = d->bufsize - *bufcntp; 592 int needed = snprintf (&d->bufp[*bufcntp], avail, "0x%" PRIx32, 593 (uint32_t) (d->addr + (*d->param_start - d->data) 594 + offset)); 595 if ((size_t) needed > avail) 596 return needed - avail; 597 *bufcntp += needed; 598 return 0; 599 } 600 601 602 static int 603 __attribute__ ((noinline)) 604 FCT_ds_xx (struct output_data *d, const char *reg) 605 { 606 int prefix = *d->prefixes & SEGMENT_PREFIXES; 607 608 if (prefix == 0) 609 *d->prefixes |= prefix = has_ds; 610 /* Make sure only one bit is set. */ 611 else if ((prefix - 1) & prefix) 612 return -1; 613 614 int r = data_prefix (d); 615 616 assert ((*d->prefixes & prefix) == 0); 617 618 if (r != 0) 619 return r; 620 621 size_t *bufcntp = d->bufcntp; 622 size_t avail = d->bufsize - *bufcntp; 623 int needed = snprintf (&d->bufp[*bufcntp], avail, "(%%%s%s)", 624 #ifdef X86_64 625 *d->prefixes & idx_addr16 ? "e" : "r", 626 #else 627 *d->prefixes & idx_addr16 ? "" : "e", 628 #endif 629 reg); 630 if ((size_t) needed > avail) 631 return (size_t) needed - avail; 632 *bufcntp += needed; 633 634 return 0; 635 } 636 637 638 static int 639 FCT_ds_bx (struct output_data *d) 640 { 641 return FCT_ds_xx (d, "bx"); 642 } 643 644 645 static int 646 FCT_ds_si (struct output_data *d) 647 { 648 return FCT_ds_xx (d, "si"); 649 } 650 651 652 static int 653 FCT_dx (struct output_data *d) 654 { 655 size_t *bufcntp = d->bufcntp; 656 657 if (*bufcntp + 7 > d->bufsize) 658 return *bufcntp + 7 - d->bufsize; 659 660 memcpy (&d->bufp[*bufcntp], "(%dx)", 5); 661 *bufcntp += 5; 662 663 return 0; 664 } 665 666 667 static int 668 FCT_es_di (struct output_data *d) 669 { 670 size_t *bufcntp = d->bufcntp; 671 size_t avail = d->bufsize - *bufcntp; 672 int needed = snprintf (&d->bufp[*bufcntp], avail, "%%es:(%%%sdi)", 673 #ifdef X86_64 674 *d->prefixes & idx_addr16 ? "e" : "r" 675 #else 676 *d->prefixes & idx_addr16 ? "" : "e" 677 #endif 678 ); 679 if ((size_t) needed > avail) 680 return (size_t) needed - avail; 681 *bufcntp += needed; 682 683 return 0; 684 } 685 686 687 static int 688 FCT_imm (struct output_data *d) 689 { 690 size_t *bufcntp = d->bufcntp; 691 size_t avail = d->bufsize - *bufcntp; 692 int needed; 693 if (*d->prefixes & has_data16) 694 { 695 if (*d->param_start + 2 > d->end) 696 return -1; 697 uint16_t word = read_2ubyte_unaligned_inc (*d->param_start); 698 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx16, word); 699 } 700 else 701 { 702 if (*d->param_start + 4 > d->end) 703 return -1; 704 int32_t word = read_4sbyte_unaligned_inc (*d->param_start); 705 #ifdef X86_64 706 if (*d->prefixes & has_rex_w) 707 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx64, 708 (int64_t) word); 709 else 710 #endif 711 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx32, word); 712 } 713 if ((size_t) needed > avail) 714 return (size_t) needed - avail; 715 *bufcntp += needed; 716 return 0; 717 } 718 719 720 static int 721 FCT_imm$w (struct output_data *d) 722 { 723 if ((d->data[d->opoff2 / 8] & (1 << (7 - (d->opoff2 & 7)))) != 0) 724 return FCT_imm (d); 725 726 size_t *bufcntp = d->bufcntp; 727 size_t avail = d->bufsize - *bufcntp; 728 if (*d->param_start>= d->end) 729 return -1; 730 uint_fast8_t word = *(*d->param_start)++; 731 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIxFAST8, word); 732 if ((size_t) needed > avail) 733 return (size_t) needed - avail; 734 *bufcntp += needed; 735 return 0; 736 } 737 738 739 #ifdef X86_64 740 static int 741 FCT_imm64$w (struct output_data *d) 742 { 743 if ((d->data[d->opoff2 / 8] & (1 << (7 - (d->opoff2 & 7)))) == 0 744 || (*d->prefixes & has_data16) != 0) 745 return FCT_imm$w (d); 746 747 size_t *bufcntp = d->bufcntp; 748 size_t avail = d->bufsize - *bufcntp; 749 int needed; 750 if (*d->prefixes & has_rex_w) 751 { 752 if (*d->param_start + 8 > d->end) 753 return -1; 754 uint64_t word = read_8ubyte_unaligned_inc (*d->param_start); 755 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx64, word); 756 } 757 else 758 { 759 if (*d->param_start + 4 > d->end) 760 return -1; 761 int32_t word = read_4sbyte_unaligned_inc (*d->param_start); 762 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx32, word); 763 } 764 if ((size_t) needed > avail) 765 return (size_t) needed - avail; 766 *bufcntp += needed; 767 return 0; 768 } 769 #endif 770 771 772 static int 773 FCT_imms (struct output_data *d) 774 { 775 size_t *bufcntp = d->bufcntp; 776 size_t avail = d->bufsize - *bufcntp; 777 if (*d->param_start>= d->end) 778 return -1; 779 int8_t byte = *(*d->param_start)++; 780 #ifdef X86_64 781 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx64, 782 (int64_t) byte); 783 #else 784 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx32, 785 (int32_t) byte); 786 #endif 787 if ((size_t) needed > avail) 788 return (size_t) needed - avail; 789 *bufcntp += needed; 790 return 0; 791 } 792 793 794 static int 795 FCT_imm$s (struct output_data *d) 796 { 797 uint_fast8_t opcode = d->data[d->opoff2 / 8]; 798 size_t *bufcntp = d->bufcntp; 799 size_t avail = d->bufsize - *bufcntp; 800 if ((opcode & 2) != 0) 801 return FCT_imms (d); 802 803 if ((*d->prefixes & has_data16) == 0) 804 { 805 if (*d->param_start + 4 > d->end) 806 return -1; 807 int32_t word = read_4sbyte_unaligned_inc (*d->param_start); 808 #ifdef X86_64 809 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx64, 810 (int64_t) word); 811 #else 812 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx32, word); 813 #endif 814 if ((size_t) needed > avail) 815 return (size_t) needed - avail; 816 *bufcntp += needed; 817 } 818 else 819 { 820 if (*d->param_start + 2 > d->end) 821 return -1; 822 uint16_t word = read_2ubyte_unaligned_inc (*d->param_start); 823 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx16, word); 824 if ((size_t) needed > avail) 825 return (size_t) needed - avail; 826 *bufcntp += needed; 827 } 828 return 0; 829 } 830 831 832 static int 833 FCT_imm16 (struct output_data *d) 834 { 835 if (*d->param_start + 2 > d->end) 836 return -1; 837 uint16_t word = read_2ubyte_unaligned_inc (*d->param_start); 838 size_t *bufcntp = d->bufcntp; 839 size_t avail = d->bufsize - *bufcntp; 840 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx16, word); 841 if ((size_t) needed > avail) 842 return (size_t) needed - avail; 843 *bufcntp += needed; 844 return 0; 845 } 846 847 848 static int 849 FCT_imms8 (struct output_data *d) 850 { 851 size_t *bufcntp = d->bufcntp; 852 size_t avail = d->bufsize - *bufcntp; 853 if (*d->param_start >= d->end) 854 return -1; 855 int_fast8_t byte = *(*d->param_start)++; 856 int needed; 857 #ifdef X86_64 858 if (*d->prefixes & has_rex_w) 859 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx64, 860 (int64_t) byte); 861 else 862 #endif 863 needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx32, 864 (int32_t) byte); 865 if ((size_t) needed > avail) 866 return (size_t) needed - avail; 867 *bufcntp += needed; 868 return 0; 869 } 870 871 872 static int 873 FCT_imm8 (struct output_data *d) 874 { 875 size_t *bufcntp = d->bufcntp; 876 size_t avail = d->bufsize - *bufcntp; 877 if (*d->param_start >= d->end) 878 return -1; 879 uint_fast8_t byte = *(*d->param_start)++; 880 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx32, 881 (uint32_t) byte); 882 if ((size_t) needed > avail) 883 return (size_t) needed - avail; 884 *bufcntp += needed; 885 return 0; 886 } 887 888 889 static int 890 FCT_rel (struct output_data *d) 891 { 892 size_t *bufcntp = d->bufcntp; 893 size_t avail = d->bufsize - *bufcntp; 894 if (*d->param_start + 4 > d->end) 895 return -1; 896 int32_t rel = read_4sbyte_unaligned_inc (*d->param_start); 897 #ifdef X86_64 898 int needed = snprintf (&d->bufp[*bufcntp], avail, "0x%" PRIx64, 899 (uint64_t) (d->addr + rel 900 + (*d->param_start - d->data))); 901 #else 902 int needed = snprintf (&d->bufp[*bufcntp], avail, "0x%" PRIx32, 903 (uint32_t) (d->addr + rel 904 + (*d->param_start - d->data))); 905 #endif 906 if ((size_t) needed > avail) 907 return (size_t) needed - avail; 908 *bufcntp += needed; 909 return 0; 910 } 911 912 913 static int 914 FCT_mmxreg (struct output_data *d) 915 { 916 uint_fast8_t byte = d->data[d->opoff1 / 8]; 917 assert (d->opoff1 % 8 == 2 || d->opoff1 % 8 == 5); 918 byte = (byte >> (5 - d->opoff1 % 8)) & 7; 919 size_t *bufcntp = d->bufcntp; 920 size_t avail = d->bufsize - *bufcntp; 921 int needed = snprintf (&d->bufp[*bufcntp], avail, "%%mm%" PRIxFAST8, byte); 922 if ((size_t) needed > avail) 923 return needed - avail; 924 *bufcntp += needed; 925 return 0; 926 } 927 928 929 static int 930 FCT_mod$r_m (struct output_data *d) 931 { 932 assert (d->opoff1 % 8 == 0); 933 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 934 if ((modrm & 0xc0) == 0xc0) 935 { 936 int prefixes = *d->prefixes; 937 if (prefixes & has_addr16) 938 return -1; 939 940 int is_16bit = (prefixes & has_data16) != 0; 941 942 size_t *bufcntp = d->bufcntp; 943 char *bufp = d->bufp; 944 if (*bufcntp + 5 - is_16bit > d->bufsize) 945 return *bufcntp + 5 - is_16bit - d->bufsize; 946 bufp[(*bufcntp)++] = '%'; 947 948 char *cp; 949 #ifdef X86_64 950 if ((prefixes & has_rex_b) != 0 && !is_16bit) 951 { 952 cp = stpcpy (&bufp[*bufcntp], hiregs[modrm & 7]); 953 if ((prefixes & has_rex_w) == 0) 954 *cp++ = 'd'; 955 } 956 else 957 #endif 958 { 959 cp = stpcpy (&bufp[*bufcntp], dregs[modrm & 7] + is_16bit); 960 #ifdef X86_64 961 if ((prefixes & has_rex_w) != 0) 962 bufp[*bufcntp] = 'r'; 963 #endif 964 } 965 *bufcntp = cp - bufp; 966 return 0; 967 } 968 969 return general_mod$r_m (d); 970 } 971 972 973 #ifndef X86_64 974 static int 975 FCT_moda$r_m (struct output_data *d) 976 { 977 assert (d->opoff1 % 8 == 0); 978 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 979 if ((modrm & 0xc0) == 0xc0) 980 { 981 if (*d->prefixes & has_addr16) 982 return -1; 983 984 size_t *bufcntp = d->bufcntp; 985 if (*bufcntp + 3 > d->bufsize) 986 return *bufcntp + 3 - d->bufsize; 987 988 memcpy (&d->bufp[*bufcntp], "???", 3); 989 *bufcntp += 3; 990 991 return 0; 992 } 993 994 return general_mod$r_m (d); 995 } 996 #endif 997 998 999 #ifdef X86_64 1000 static const char rex_8bit[8][3] = 1001 { 1002 [0] = "a", [1] = "c", [2] = "d", [3] = "b", 1003 [4] = "sp", [5] = "bp", [6] = "si", [7] = "di" 1004 }; 1005 #endif 1006 1007 1008 static int 1009 FCT_mod$r_m$w (struct output_data *d) 1010 { 1011 assert (d->opoff1 % 8 == 0); 1012 const uint8_t *data = d->data; 1013 uint_fast8_t modrm = data[d->opoff1 / 8]; 1014 if ((modrm & 0xc0) == 0xc0) 1015 { 1016 int prefixes = *d->prefixes; 1017 1018 if (prefixes & has_addr16) 1019 return -1; 1020 1021 size_t *bufcntp = d->bufcntp; 1022 char *bufp = d->bufp; 1023 if (*bufcntp + 5 > d->bufsize) 1024 return *bufcntp + 5 - d->bufsize; 1025 1026 if ((data[d->opoff3 / 8] & (1 << (7 - (d->opoff3 & 7)))) == 0) 1027 { 1028 bufp[(*bufcntp)++] = '%'; 1029 1030 #ifdef X86_64 1031 if (prefixes & has_rex) 1032 { 1033 if (prefixes & has_rex_r) 1034 *bufcntp += snprintf (bufp + *bufcntp, d->bufsize - *bufcntp, 1035 "r%db", 8 + (modrm & 7)); 1036 else 1037 { 1038 char *cp = stpcpy (bufp + *bufcntp, hiregs[modrm & 7]); 1039 *cp++ = 'l'; 1040 *bufcntp = cp - bufp; 1041 } 1042 } 1043 else 1044 #endif 1045 { 1046 bufp[(*bufcntp)++] = "acdb"[modrm & 3]; 1047 bufp[(*bufcntp)++] = "lh"[(modrm & 4) >> 2]; 1048 } 1049 } 1050 else 1051 { 1052 int is_16bit = (prefixes & has_data16) != 0; 1053 1054 bufp[(*bufcntp)++] = '%'; 1055 1056 char *cp; 1057 #ifdef X86_64 1058 if ((prefixes & has_rex_b) != 0 && !is_16bit) 1059 { 1060 cp = stpcpy (&bufp[*bufcntp], hiregs[modrm & 7]); 1061 if ((prefixes & has_rex_w) == 0) 1062 *cp++ = 'd'; 1063 } 1064 else 1065 #endif 1066 { 1067 cp = stpcpy (&bufp[*bufcntp], dregs[modrm & 7] + is_16bit); 1068 #ifdef X86_64 1069 if ((prefixes & has_rex_w) != 0) 1070 bufp[*bufcntp] = 'r'; 1071 #endif 1072 } 1073 *bufcntp = cp - bufp; 1074 } 1075 return 0; 1076 } 1077 1078 return general_mod$r_m (d); 1079 } 1080 1081 1082 static int 1083 FCT_mod$8r_m (struct output_data *d) 1084 { 1085 assert (d->opoff1 % 8 == 0); 1086 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 1087 if ((modrm & 0xc0) == 0xc0) 1088 { 1089 size_t *bufcntp = d->bufcntp; 1090 char *bufp = d->bufp; 1091 if (*bufcntp + 3 > d->bufsize) 1092 return *bufcntp + 3 - d->bufsize; 1093 bufp[(*bufcntp)++] = '%'; 1094 bufp[(*bufcntp)++] = "acdb"[modrm & 3]; 1095 bufp[(*bufcntp)++] = "lh"[(modrm & 4) >> 2]; 1096 return 0; 1097 } 1098 1099 return general_mod$r_m (d); 1100 } 1101 1102 1103 static int 1104 FCT_mod$16r_m (struct output_data *d) 1105 { 1106 assert (d->opoff1 % 8 == 0); 1107 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 1108 if ((modrm & 0xc0) == 0xc0) 1109 { 1110 assert (d->opoff1 / 8 == d->opoff2 / 8); 1111 //uint_fast8_t byte = data[opoff2 / 8] & 7; 1112 uint_fast8_t byte = modrm & 7; 1113 1114 size_t *bufcntp = d->bufcntp; 1115 if (*bufcntp + 3 > d->bufsize) 1116 return *bufcntp + 3 - d->bufsize; 1117 d->bufp[(*bufcntp)++] = '%'; 1118 memcpy (&d->bufp[*bufcntp], dregs[byte] + 1, sizeof (dregs[0]) - 1); 1119 *bufcntp += 2; 1120 return 0; 1121 } 1122 1123 return general_mod$r_m (d); 1124 } 1125 1126 1127 #ifdef X86_64 1128 static int 1129 FCT_mod$64r_m (struct output_data *d) 1130 { 1131 assert (d->opoff1 % 8 == 0); 1132 uint_fast8_t modrm = d->data[d->opoff1 / 8]; 1133 if ((modrm & 0xc0) == 0xc0) 1134 { 1135 assert (d->opoff1 / 8 == d->opoff2 / 8); 1136 //uint_fast8_t byte = data[opoff2 / 8] & 7; 1137 uint_fast8_t byte = modrm & 7; 1138 1139 size_t *bufcntp = d->bufcntp; 1140 if (*bufcntp + 4 > d->bufsize) 1141 return *bufcntp + 4 - d->bufsize; 1142 char *cp = &d->bufp[*bufcntp]; 1143 *cp++ = '%'; 1144 cp = stpcpy (cp, 1145 (*d->prefixes & has_rex_b) ? hiregs[byte] : aregs[byte]); 1146 *bufcntp = cp - d->bufp; 1147 return 0; 1148 } 1149 1150 return general_mod$r_m (d); 1151 } 1152 #else 1153 static typeof (FCT_mod$r_m) FCT_mod$64r_m __attribute__ ((alias ("FCT_mod$r_m"))); 1154 #endif 1155 1156 1157 static int 1158 FCT_reg (struct output_data *d) 1159 { 1160 uint_fast8_t byte = d->data[d->opoff1 / 8]; 1161 assert (d->opoff1 % 8 + 3 <= 8); 1162 byte >>= 8 - (d->opoff1 % 8 + 3); 1163 byte &= 7; 1164 int is_16bit = (*d->prefixes & has_data16) != 0; 1165 size_t *bufcntp = d->bufcntp; 1166 if (*bufcntp + 5 > d->bufsize) 1167 return *bufcntp + 5 - d->bufsize; 1168 d->bufp[(*bufcntp)++] = '%'; 1169 #ifdef X86_64 1170 if ((*d->prefixes & has_rex_r) != 0 && !is_16bit) 1171 { 1172 *bufcntp += snprintf (&d->bufp[*bufcntp], d->bufsize - *bufcntp, "r%d", 1173 8 + byte); 1174 if ((*d->prefixes & has_rex_w) == 0) 1175 d->bufp[(*bufcntp)++] = 'd'; 1176 } 1177 else 1178 #endif 1179 { 1180 memcpy (&d->bufp[*bufcntp], dregs[byte] + is_16bit, 3 - is_16bit); 1181 #ifdef X86_64 1182 if ((*d->prefixes & has_rex_w) != 0 && !is_16bit) 1183 d->bufp[*bufcntp] = 'r'; 1184 #endif 1185 *bufcntp += 3 - is_16bit; 1186 } 1187 return 0; 1188 } 1189 1190 1191 #ifdef X86_64 1192 static int 1193 FCT_oreg (struct output_data *d) 1194 { 1195 /* Special form where register comes from opcode. The rex.B bit is used, 1196 rex.R and rex.X are ignored. */ 1197 int save_prefixes = *d->prefixes; 1198 1199 *d->prefixes = ((save_prefixes & ~has_rex_r) 1200 | ((save_prefixes & has_rex_b) << (idx_rex_r - idx_rex_b))); 1201 1202 int r = FCT_reg (d); 1203 1204 *d->prefixes = save_prefixes; 1205 1206 return r; 1207 } 1208 #endif 1209 1210 1211 static int 1212 FCT_reg64 (struct output_data *d) 1213 { 1214 uint_fast8_t byte = d->data[d->opoff1 / 8]; 1215 assert (d->opoff1 % 8 + 3 <= 8); 1216 byte >>= 8 - (d->opoff1 % 8 + 3); 1217 byte &= 7; 1218 if ((*d->prefixes & has_data16) != 0) 1219 return -1; 1220 size_t *bufcntp = d->bufcntp; 1221 if (*bufcntp + 5 > d->bufsize) 1222 return *bufcntp + 5 - d->bufsize; 1223 d->bufp[(*bufcntp)++] = '%'; 1224 #ifdef X86_64 1225 if ((*d->prefixes & has_rex_r) != 0) 1226 { 1227 *bufcntp += snprintf (&d->bufp[*bufcntp], d->bufsize - *bufcntp, "r%d", 1228 8 + byte); 1229 if ((*d->prefixes & has_rex_w) == 0) 1230 d->bufp[(*bufcntp)++] = 'd'; 1231 } 1232 else 1233 #endif 1234 { 1235 memcpy (&d->bufp[*bufcntp], aregs[byte], 3); 1236 *bufcntp += 3; 1237 } 1238 return 0; 1239 } 1240 1241 1242 static int 1243 FCT_reg$w (struct output_data *d) 1244 { 1245 if (d->data[d->opoff2 / 8] & (1 << (7 - (d->opoff2 & 7)))) 1246 return FCT_reg (d); 1247 1248 uint_fast8_t byte = d->data[d->opoff1 / 8]; 1249 assert (d->opoff1 % 8 + 3 <= 8); 1250 byte >>= 8 - (d->opoff1 % 8 + 3); 1251 byte &= 7; 1252 1253 size_t *bufcntp = d->bufcntp; 1254 if (*bufcntp + 4 > d->bufsize) 1255 return *bufcntp + 4 - d->bufsize; 1256 1257 d->bufp[(*bufcntp)++] = '%'; 1258 1259 #ifdef X86_64 1260 if (*d->prefixes & has_rex) 1261 { 1262 if (*d->prefixes & has_rex_r) 1263 *bufcntp += snprintf (d->bufp + *bufcntp, d->bufsize - *bufcntp, 1264 "r%db", 8 + byte); 1265 else 1266 { 1267 char* cp = stpcpy (d->bufp + *bufcntp, rex_8bit[byte]); 1268 *cp++ = 'l'; 1269 *bufcntp = cp - d->bufp; 1270 } 1271 } 1272 else 1273 #endif 1274 { 1275 d->bufp[(*bufcntp)++] = "acdb"[byte & 3]; 1276 d->bufp[(*bufcntp)++] = "lh"[byte >> 2]; 1277 } 1278 return 0; 1279 } 1280 1281 1282 #ifdef X86_64 1283 static int 1284 FCT_oreg$w (struct output_data *d) 1285 { 1286 /* Special form where register comes from opcode. The rex.B bit is used, 1287 rex.R and rex.X are ignored. */ 1288 int save_prefixes = *d->prefixes; 1289 1290 *d->prefixes = ((save_prefixes & ~has_rex_r) 1291 | ((save_prefixes & has_rex_b) << (idx_rex_r - idx_rex_b))); 1292 1293 int r = FCT_reg$w (d); 1294 1295 *d->prefixes = save_prefixes; 1296 1297 return r; 1298 } 1299 #endif 1300 1301 1302 static int 1303 FCT_freg (struct output_data *d) 1304 { 1305 assert (d->opoff1 / 8 == 1); 1306 assert (d->opoff1 % 8 == 5); 1307 size_t *bufcntp = d->bufcntp; 1308 size_t avail = d->bufsize - *bufcntp; 1309 int needed = snprintf (&d->bufp[*bufcntp], avail, "%%st(%" PRIx32 ")", 1310 (uint32_t) (d->data[1] & 7)); 1311 if ((size_t) needed > avail) 1312 return (size_t) needed - avail; 1313 *bufcntp += needed; 1314 return 0; 1315 } 1316 1317 1318 #ifndef X86_64 1319 static int 1320 FCT_reg16 (struct output_data *d) 1321 { 1322 if (*d->prefixes & has_data16) 1323 return -1; 1324 1325 *d->prefixes |= has_data16; 1326 return FCT_reg (d); 1327 } 1328 #endif 1329 1330 1331 static int 1332 FCT_sel (struct output_data *d) 1333 { 1334 assert (d->opoff1 % 8 == 0); 1335 assert (d->opoff1 / 8 == 5); 1336 if (*d->param_start + 2 > d->end) 1337 return -1; 1338 *d->param_start += 2; 1339 uint16_t absval = read_2ubyte_unaligned (&d->data[5]); 1340 1341 size_t *bufcntp = d->bufcntp; 1342 size_t avail = d->bufsize - *bufcntp; 1343 int needed = snprintf (&d->bufp[*bufcntp], avail, "$0x%" PRIx16, absval); 1344 if ((size_t) needed > avail) 1345 return needed - avail; 1346 *bufcntp += needed; 1347 return 0; 1348 } 1349 1350 1351 static int 1352 FCT_sreg2 (struct output_data *d) 1353 { 1354 uint_fast8_t byte = d->data[d->opoff1 / 8]; 1355 assert (d->opoff1 % 8 + 3 <= 8); 1356 byte >>= 8 - (d->opoff1 % 8 + 2); 1357 1358 size_t *bufcntp = d->bufcntp; 1359 char *bufp = d->bufp; 1360 if (*bufcntp + 3 > d->bufsize) 1361 return *bufcntp + 3 - d->bufsize; 1362 1363 bufp[(*bufcntp)++] = '%'; 1364 bufp[(*bufcntp)++] = "ecsd"[byte & 3]; 1365 bufp[(*bufcntp)++] = 's'; 1366 1367 return 0; 1368 } 1369 1370 1371 static int 1372 FCT_sreg3 (struct output_data *d) 1373 { 1374 uint_fast8_t byte = d->data[d->opoff1 / 8]; 1375 assert (d->opoff1 % 8 + 4 <= 8); 1376 byte >>= 8 - (d->opoff1 % 8 + 3); 1377 1378 if ((byte & 7) >= 6) 1379 return -1; 1380 1381 size_t *bufcntp = d->bufcntp; 1382 char *bufp = d->bufp; 1383 if (*bufcntp + 3 > d->bufsize) 1384 return *bufcntp + 3 - d->bufsize; 1385 1386 bufp[(*bufcntp)++] = '%'; 1387 bufp[(*bufcntp)++] = "ecsdfg"[byte & 7]; 1388 bufp[(*bufcntp)++] = 's'; 1389 1390 return 0; 1391 } 1392 1393 1394 static int 1395 FCT_string (struct output_data *d __attribute__ ((unused))) 1396 { 1397 return 0; 1398 } 1399 1400 1401 static int 1402 FCT_xmmreg (struct output_data *d) 1403 { 1404 uint_fast8_t byte = d->data[d->opoff1 / 8]; 1405 assert (d->opoff1 % 8 == 2 || d->opoff1 % 8 == 5); 1406 byte = (byte >> (5 - d->opoff1 % 8)) & 7; 1407 1408 size_t *bufcntp = d->bufcntp; 1409 size_t avail = d->bufsize - *bufcntp; 1410 int needed = snprintf (&d->bufp[*bufcntp], avail, "%%xmm%" PRIxFAST8, byte); 1411 if ((size_t) needed > avail) 1412 return needed - avail; 1413 *bufcntp += needed; 1414 return 0; 1415 } 1416
