libcpu/i386_disasm.c

   1 /* Disassembler for x86.
   2    Copyright (C) 2007, 2008, 2009, 2011 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2007.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of either
   8
   9      * the GNU Lesser General Public License as published by the Free
  10        Software Foundation; either version 3 of the License, or (at
  11        your option) any later version
  12
  13    or
  14
  15      * the GNU General Public License as published by the Free
  16        Software Foundation; either version 2 of the License, or (at
  17        your option) any later version
  18
  19    or both in parallel, as here.
  20
  21    elfutils is distributed in the hope that it will be useful, but
  22    WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24    General Public License for more details.
  25
  26    You should have received copies of the GNU General Public License and
  27    the GNU Lesser General Public License along with this program.  If
  28    not, see <http://www.gnu.org/licenses/>.  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include <config.h>
  32 #endif
  33
  34 #include <assert.h>
  35 #include <config.h>
  36 #include <ctype.h>
  37 #include <endian.h>
  38 #include <errno.h>
  39 #include <gelf.h>
  40 #include <stddef.h>
  41 #include <stdint.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <sys/param.h>
  45
  46 #include "../libebl/libeblP.h"
  47
  48 #define MACHINE_ENCODING __LITTLE_ENDIAN
  49 #include "memory-access.h"
  50
  51
  52 #ifndef MNEFILE
  53 # define MNEFILE "i386.mnemonics"
  54 #endif
  55
  56 #define MNESTRFIELD(line) MNESTRFIELD1 (line)
  57 #define MNESTRFIELD1(line) str##line
  58 static const union mnestr_t
  59 {
  60   struct
  61   {
  62 #define MNE(name) char MNESTRFIELD (__LINE__)[sizeof (#name)];
  63 #include MNEFILE
  64 #undef MNE
  65   };
  66   char str[0];
  67 } mnestr =
  68   {
  69     {
  70 #define MNE(name) #name,
  71 #include MNEFILE
  72 #undef MNE
  73     }
  74   };
  75
  76 /* The index can be stored in the instrtab.  */
  77 enum
  78   {
  79 #define MNE(name) MNE_##name,
  80 #include MNEFILE
  81 #undef MNE
  82     MNE_INVALID
  83   };
  84
  85 static const unsigned short int mneidx[] =
  86   {
  87 #define MNE(name) \
  88   [MNE_##name] = offsetof (union mnestr_t, MNESTRFIELD (__LINE__)),
  89 #include MNEFILE
  90 #undef MNE
  91   };
  92
  93
  94 enum
  95   {
  96     idx_rex_b = 0,
  97     idx_rex_x,
  98     idx_rex_r,
  99     idx_rex_w,
 100     idx_rex,
 101     idx_cs,
 102     idx_ds,
 103     idx_es,
 104     idx_fs,
 105     idx_gs,
 106     idx_ss,
 107     idx_data16,
 108     idx_addr16,
 109     idx_rep,
 110     idx_repne,
 111     idx_lock
 112   };
 113
 114 enum
 115   {
 116 #define prefbit(pref) has_##pref = 1 << idx_##pref
 117     prefbit (rex_b),
 118     prefbit (rex_x),
 119     prefbit (rex_r),
 120     prefbit (rex_w),
 121     prefbit (rex),
 122     prefbit (cs),
 123     prefbit (ds),
 124     prefbit (es),
 125     prefbit (fs),
 126     prefbit (gs),
 127     prefbit (ss),
 128     prefbit (data16),
 129     prefbit (addr16),
 130     prefbit (rep),
 131     prefbit (repne),
 132     prefbit (lock)
 133 #undef prefbit
 134   };
 135 #define SEGMENT_PREFIXES \
 136   (has_cs | has_ds | has_es | has_fs | has_gs | has_ss)
 137
 138 #define prefix_cs       0x2e
 139 #define prefix_ds       0x3e
 140 #define prefix_es       0x26
 141 #define prefix_fs       0x64
 142 #define prefix_gs       0x65
 143 #define prefix_ss       0x36
 144 #define prefix_data16   0x66
 145 #define prefix_addr16   0x67
 146 #define prefix_rep      0xf3
 147 #define prefix_repne    0xf2
 148 #define prefix_lock     0xf0
 149
 150
 151 static const uint8_t known_prefixes[] =
 152   {
 153 #define newpref(pref) [idx_##pref] = prefix_##pref
 154     newpref (cs),
 155     newpref (ds),
 156     newpref (es),
 157     newpref (fs),
 158     newpref (gs),
 159     newpref (ss),
 160     newpref (data16),
 161     newpref (addr16),
 162     newpref (rep),
 163     newpref (repne),
 164     newpref (lock)
 165 #undef newpref
 166   };
 167 #define nknown_prefixes (sizeof (known_prefixes) / sizeof (known_prefixes[0]))
 168
 169
 170 #if 0
 171 static const char *prefix_str[] =
 172   {
 173 #define newpref(pref) [idx_##pref] = #pref
 174     newpref (cs),
 175     newpref (ds),
 176     newpref (es),
 177     newpref (fs),
 178     newpref (gs),
 179     newpref (ss),
 180     newpref (data16),
 181     newpref (addr16),
 182     newpref (rep),
 183     newpref (repne),
 184     newpref (lock)
 185 #undef newpref
 186   };
 187 #endif
 188
 189
 190 static const char amd3dnowstr[] =
 191 #define MNE_3DNOW_PAVGUSB 1
 192   "pavgusb\0"
 193 #define MNE_3DNOW_PFADD (MNE_3DNOW_PAVGUSB + 8)
 194   "pfadd\0"
 195 #define MNE_3DNOW_PFSUB (MNE_3DNOW_PFADD + 6)
 196   "pfsub\0"
 197 #define MNE_3DNOW_PFSUBR (MNE_3DNOW_PFSUB + 6)
 198   "pfsubr\0"
 199 #define MNE_3DNOW_PFACC (MNE_3DNOW_PFSUBR + 7)
 200   "pfacc\0"
 201 #define MNE_3DNOW_PFCMPGE (MNE_3DNOW_PFACC + 6)
 202   "pfcmpge\0"
 203 #define MNE_3DNOW_PFCMPGT (MNE_3DNOW_PFCMPGE + 8)
 204   "pfcmpgt\0"
 205 #define MNE_3DNOW_PFCMPEQ (MNE_3DNOW_PFCMPGT + 8)
 206   "pfcmpeq\0"
 207 #define MNE_3DNOW_PFMIN (MNE_3DNOW_PFCMPEQ + 8)
 208   "pfmin\0"
 209 #define MNE_3DNOW_PFMAX (MNE_3DNOW_PFMIN + 6)
 210   "pfmax\0"
 211 #define MNE_3DNOW_PI2FD (MNE_3DNOW_PFMAX + 6)
 212   "pi2fd\0"
 213 #define MNE_3DNOW_PF2ID (MNE_3DNOW_PI2FD + 6)
 214   "pf2id\0"
 215 #define MNE_3DNOW_PFRCP (MNE_3DNOW_PF2ID + 6)
 216   "pfrcp\0"
 217 #define MNE_3DNOW_PFRSQRT (MNE_3DNOW_PFRCP + 6)
 218   "pfrsqrt\0"
 219 #define MNE_3DNOW_PFMUL (MNE_3DNOW_PFRSQRT + 8)
 220   "pfmul\0"
 221 #define MNE_3DNOW_PFRCPIT1 (MNE_3DNOW_PFMUL + 6)
 222   "pfrcpit1\0"
 223 #define MNE_3DNOW_PFRSQIT1 (MNE_3DNOW_PFRCPIT1 + 9)
 224   "pfrsqit1\0"
 225 #define MNE_3DNOW_PFRCPIT2 (MNE_3DNOW_PFRSQIT1 + 9)
 226   "pfrcpit2\0"
 227 #define MNE_3DNOW_PMULHRW (MNE_3DNOW_PFRCPIT2 + 9)
 228   "pmulhrw";
 229
 230 #define AMD3DNOW_LOW_IDX 0x0d
 231 #define AMD3DNOW_HIGH_IDX (sizeof (amd3dnow) + AMD3DNOW_LOW_IDX - 1)
 232 #define AMD3DNOW_IDX(val) ((val) - AMD3DNOW_LOW_IDX)
 233 static const unsigned char amd3dnow[] =
 234   {
 235     [AMD3DNOW_IDX (0xbf)] = MNE_3DNOW_PAVGUSB,
 236     [AMD3DNOW_IDX (0x9e)] = MNE_3DNOW_PFADD,
 237     [AMD3DNOW_IDX (0x9a)] = MNE_3DNOW_PFSUB,
 238     [AMD3DNOW_IDX (0xaa)] = MNE_3DNOW_PFSUBR,
 239     [AMD3DNOW_IDX (0xae)] = MNE_3DNOW_PFACC,
 240     [AMD3DNOW_IDX (0x90)] = MNE_3DNOW_PFCMPGE,
 241     [AMD3DNOW_IDX (0xa0)] = MNE_3DNOW_PFCMPGT,
 242     [AMD3DNOW_IDX (0xb0)] = MNE_3DNOW_PFCMPEQ,
 243     [AMD3DNOW_IDX (0x94)] = MNE_3DNOW_PFMIN,
 244     [AMD3DNOW_IDX (0xa4)] = MNE_3DNOW_PFMAX,
 245     [AMD3DNOW_IDX (0x0d)] = MNE_3DNOW_PI2FD,
 246     [AMD3DNOW_IDX (0x1d)] = MNE_3DNOW_PF2ID,
 247     [AMD3DNOW_IDX (0x96)] = MNE_3DNOW_PFRCP,
 248     [AMD3DNOW_IDX (0x97)] = MNE_3DNOW_PFRSQRT,
 249     [AMD3DNOW_IDX (0xb4)] = MNE_3DNOW_PFMUL,
 250     [AMD3DNOW_IDX (0xa6)] = MNE_3DNOW_PFRCPIT1,
 251     [AMD3DNOW_IDX (0xa7)] = MNE_3DNOW_PFRSQIT1,
 252     [AMD3DNOW_IDX (0xb6)] = MNE_3DNOW_PFRCPIT2,
 253     [AMD3DNOW_IDX (0xb7)] = MNE_3DNOW_PMULHRW
 254   };
 255
 256
 257 struct output_data
 258 {
 259   GElf_Addr addr;
 260   int *prefixes;
 261   size_t opoff1;
 262   size_t opoff2;
 263   size_t opoff3;
 264   char *bufp;
 265   size_t *bufcntp;
 266   size_t bufsize;
 267   const uint8_t *data;
 268   const uint8_t **param_start;
 269   const uint8_t *end;
 270   char *labelbuf;
 271   size_t labelbufsize;
 272   enum
 273     {
 274       addr_none = 0,
 275       addr_abs_symbolic,
 276       addr_abs_always,
 277       addr_rel_symbolic,
 278       addr_rel_always
 279     } symaddr_use;
 280   GElf_Addr symaddr;
 281 };
 282
 283
 284 #ifndef DISFILE
 285 # define DISFILE "i386_dis.h"
 286 #endif
 287 #include DISFILE
 288
 289
 290 #define ADD_CHAR(ch) \
 291   do {                                                                        \
 292     if (unlikely (bufcnt == bufsize))                                         \
 293       goto enomem;                                                            \
 294     buf[bufcnt++] = (ch);                                                     \
 295   } while (0)
 296
 297 #define ADD_STRING(str) \
 298   do {                                                                        \
 299     const char *_str0 = (str);                                                \
 300     size_t _len0 = strlen (_str0);                                            \
 301     ADD_NSTRING (_str0, _len0);                                               \
 302   } while (0)
 303
 304 #define ADD_NSTRING(str, len) \
 305   do {                                                                        \
 306     const char *_str = (str);                                                 \
 307     size_t _len = (len);                                                      \
 308     if (unlikely (bufcnt + _len > bufsize))                                   \
 309       goto enomem;                                                            \
 310     memcpy (buf + bufcnt, _str, _len);                                        \
 311     bufcnt += _len;                                                           \
 312   } while (0)
 313
 314
 315 int
 316 i386_disasm (const uint8_t **startp, const uint8_t *end, GElf_Addr addr,
 317              const char *fmt, DisasmOutputCB_t outcb, DisasmGetSymCB_t symcb,
 318              void *outcbarg, void *symcbarg)
 319 {
 320   const char *save_fmt = fmt;
 321
 322 #define BUFSIZE 512
 323   char initbuf[BUFSIZE];
 324   int prefixes;
 325   size_t bufcnt;
 326   size_t bufsize = BUFSIZE;
 327   char *buf = initbuf;
 328   const uint8_t *param_start;
 329
 330   struct output_data output_data =
 331     {
 332       .prefixes = &prefixes,
 333       .bufp = buf,
 334       .bufsize = bufsize,
 335       .bufcntp = &bufcnt,
 336       .param_start = &param_start,
 337       .end = end
 338     };
 339
 340   int retval = 0;
 341   while (1)
 342     {
 343       prefixes = 0;
 344
 345       const uint8_t *data = *startp;
 346       const uint8_t *begin = data;
 347
 348       /* Recognize all prefixes.  */
 349       int last_prefix_bit = 0;
 350       while (data < end)
 351         {
 352           unsigned int i;
 353           for (i = idx_cs; i < nknown_prefixes; ++i)
 354             if (known_prefixes[i] == *data)
 355               break;
 356           if (i == nknown_prefixes)
 357             break;
 358
 359           prefixes |= last_prefix_bit = 1 << i;
 360
 361           ++data;
 362         }
 363
 364 #ifdef X86_64
 365       if (data < end && (*data & 0xf0) == 0x40)
 366         prefixes |= ((*data++) & 0xf) | has_rex;
 367 #endif
 368
 369       bufcnt = 0;
 370       size_t cnt = 0;
 371
 372       const uint8_t *curr = match_data;
 373       const uint8_t *const match_end = match_data + sizeof (match_data);
 374
 375       assert (data <= end);
 376       if (data == end)
 377         {
 378           if (prefixes != 0)
 379             goto print_prefix;
 380
 381           retval = -1;
 382           goto do_ret;
 383         }
 384
 385     next_match:
 386       while (curr < match_end)
 387         {
 388           uint_fast8_t len = *curr++;
 389           uint_fast8_t clen = len >> 4;
 390           len &= 0xf;
 391           const uint8_t *next_curr = curr + clen + (len - clen) * 2;
 392
 393           assert (len > 0);
 394           assert (curr + clen + 2 * (len - clen) <= match_end);
 395
 396           const uint8_t *codep = data;
 397           int correct_prefix = 0;
 398           int opoff = 0;
 399
 400           if (data > begin && codep[-1] == *curr && clen > 0)
 401             {
 402               /* We match a prefix byte.  This is exactly one byte and
 403                  is matched exactly, without a mask.  */
 404               --len;
 405               --clen;
 406               opoff = 8;
 407
 408               ++curr;
 409
 410               assert (last_prefix_bit != 0);
 411               correct_prefix = last_prefix_bit;
 412             }
 413
 414           size_t avail = len;
 415           while (clen > 0)
 416             {
 417               if (*codep++ != *curr++)
 418                 goto not;
 419               --avail;
 420               --clen;
 421               if (codep == end && avail > 0)
 422                 goto do_ret;
 423             }
 424
 425           while (avail > 0)
 426             {
 427               uint_fast8_t masked = *codep++ & *curr++;
 428               if (masked != *curr++)
 429                 {
 430                 not:
 431                   curr = next_curr;
 432                   ++cnt;
 433                   bufcnt = 0;
 434                   goto next_match;
 435                 }
 436
 437               --avail;
 438               if (codep == end && avail > 0)
 439                 goto do_ret;
 440             }
 441
 442           if (len > end - data)
 443             /* There is not enough data for the entire instruction.  The
 444                caller can figure this out by looking at the pointer into
 445                the input data.  */
 446             goto do_ret;
 447
 448           assert (correct_prefix == 0
 449                   || (prefixes & correct_prefix) != 0);
 450           prefixes ^= correct_prefix;
 451
 452           if (0)
 453             {
 454               /* Resize the buffer.  */
 455               char *oldbuf;
 456             enomem:
 457               oldbuf = buf;
 458               if (buf == initbuf)
 459                 buf = malloc (2 * bufsize);
 460               else
 461                 buf = realloc (buf, 2 * bufsize);
 462               if (buf == NULL)
 463                 {
 464                   buf = oldbuf;
 465                   retval = ENOMEM;
 466                   goto do_ret;
 467                 }
 468               bufsize *= 2;
 469
 470               output_data.bufp = buf;
 471               output_data.bufsize = bufsize;
 472               bufcnt = 0;
 473
 474               if (data == end)
 475                 {
 476                   assert (prefixes != 0);
 477                   goto print_prefix;
 478                 }
 479
 480               /* gcc is not clever enough to see the following variables
 481                  are not used uninitialized.  */
 482               asm (""
 483                    : "=mr" (opoff), "=mr" (correct_prefix), "=mr" (codep),
 484                      "=mr" (next_curr), "=mr" (len));
 485             }
 486
 487           size_t prefix_size = 0;
 488
 489           // XXXonly print as prefix if valid?
 490           if ((prefixes & has_lock) != 0)
 491             {
 492               ADD_STRING ("lock ");
 493               prefix_size += 5;
 494             }
 495
 496           if (instrtab[cnt].rep)
 497             {
 498               if ((prefixes & has_rep) !=  0)
 499                 {
 500                   ADD_STRING ("rep ");
 501                   prefix_size += 4;
 502                 }
 503             }
 504           else if (instrtab[cnt].repe
 505                    && (prefixes & (has_rep | has_repne)) != 0)
 506             {
 507               if ((prefixes & has_repne) != 0)
 508                 {
 509                   ADD_STRING ("repne ");
 510                   prefix_size += 6;
 511                 }
 512               else if ((prefixes & has_rep) != 0)
 513                 {
 514                   ADD_STRING ("repe ");
 515                   prefix_size += 5;
 516                 }
 517             }
 518           else if ((prefixes & (has_rep | has_repne)) != 0)
 519             {
 520               uint_fast8_t byte;
 521             print_prefix:
 522               bufcnt = 0;
 523               byte = *begin;
 524               /* This is a prefix byte.  Print it.  */
 525               switch (byte)
 526                 {
 527                 case prefix_rep:
 528                   ADD_STRING ("rep");
 529                   break;
 530                 case prefix_repne:
 531                   ADD_STRING ("repne");
 532                   break;
 533                 case prefix_cs:
 534                   ADD_STRING ("cs");
 535                   break;
 536                 case prefix_ds:
 537                   ADD_STRING ("ds");
 538                   break;
 539                 case prefix_es:
 540                   ADD_STRING ("es");
 541                   break;
 542                 case prefix_fs:
 543                   ADD_STRING ("fs");
 544                   break;
 545                 case prefix_gs:
 546                   ADD_STRING ("gs");
 547                   break;
 548                 case prefix_ss:
 549                   ADD_STRING ("ss");
 550                   break;
 551                 case prefix_data16:
 552                   ADD_STRING ("data16");
 553                   break;
 554                 case prefix_addr16:
 555                   ADD_STRING ("addr16");
 556                   break;
 557                 case prefix_lock:
 558                   ADD_STRING ("lock");
 559                   break;
 560 #ifdef X86_64
 561                 case 0x40 ... 0x4f:
 562                   ADD_STRING ("rex");
 563                   if (byte != 0x40)
 564                     {
 565                       ADD_CHAR ('.');
 566                       if (byte & 0x8)
 567                         ADD_CHAR ('w');
 568                       if (byte & 0x4)
 569                         ADD_CHAR ('r');
 570                       if (byte & 0x3)
 571                         ADD_CHAR ('x');
 572                       if (byte & 0x1)
 573                         ADD_CHAR ('b');
 574                     }
 575                   break;
 576 #endif
 577                 default:
 578                   /* Cannot happen.  */
 579                   puts ("unknown prefix");
 580                   abort ();
 581                 }
 582               data = begin + 1;
 583               ++addr;
 584
 585               goto out;
 586             }
 587
 588           /* We have a match.  First determine how many bytes are
 589              needed for the adressing mode.  */
 590           param_start = codep;
 591           if (instrtab[cnt].modrm)
 592             {
 593               uint_fast8_t modrm = codep[-1];
 594
 595 #ifndef X86_64
 596               if (likely ((prefixes & has_addr16) != 0))
 597                 {
 598                   /* Account for displacement.  */
 599                   if ((modrm & 0xc7) == 6 || (modrm & 0xc0) == 0x80)
 600                     param_start += 2;
 601                   else if ((modrm & 0xc0) == 0x40)
 602                     param_start += 1;
 603                 }
 604               else
 605 #endif
 606                 {
 607                   /* Account for SIB.  */
 608                   if ((modrm & 0xc0) != 0xc0 && (modrm & 0x7) == 0x4)
 609                     param_start += 1;
 610
 611                   /* Account for displacement.  */
 612                   if ((modrm & 0xc7) == 5 || (modrm & 0xc0) == 0x80
 613                       || ((modrm & 0xc7) == 0x4 && (codep[0] & 0x7) == 0x5))
 614                     param_start += 4;
 615                   else if ((modrm & 0xc0) == 0x40)
 616                     param_start += 1;
 617                 }
 618
 619               if (unlikely (param_start > end))
 620                 goto not;
 621             }
 622
 623           output_data.addr = addr + (data - begin);
 624           output_data.data = data;
 625
 626           unsigned long string_end_idx = 0;
 627           fmt = save_fmt;
 628           const char *deferred_start = NULL;
 629           size_t deferred_len = 0;
 630           // XXX Can we get this from color.c?
 631           static const char color_off[] = "\e[0m";
 632           while (*fmt != '\0')
 633             {
 634               if (*fmt != '%')
 635                 {
 636                   char ch = *fmt++;
 637                   if (ch == '\\')
 638                     {
 639                       switch ((ch = *fmt++))
 640                         {
 641                         case '0' ... '7':
 642                           {
 643                             int val = ch - '0';
 644                             ch = *fmt;
 645                             if (ch >= '0' && ch <= '7')
 646                               {
 647                                 val *= 8;
 648                                 val += ch - '0';
 649                                 ch = *++fmt;
 650                                 if (ch >= '0' && ch <= '7' && val < 32)
 651                                   {
 652                                     val *= 8;
 653                                     val += ch - '0';
 654                                     ++fmt;
 655                                   }
 656                               }
 657                             ch = val;
 658                           }
 659                           break;
 660
 661                         case 'n':
 662                           ch = '\n';
 663                           break;
 664
 665                         case 't':
 666                           ch = '\t';
 667                           break;
 668
 669                         default:
 670                           retval = EINVAL;
 671                           goto do_ret;
 672                         }
 673                     }
 674                   else if (ch == '\e' && *fmt == '[')
 675                     {
 676                       deferred_start = fmt - 1;
 677                       do
 678                         ++fmt;
 679                       while (*fmt != 'm' && *fmt != '\0');
 680
 681                       if (*fmt == 'm')
 682                         {
 683                           deferred_len = ++fmt - deferred_start;
 684                           continue;
 685                         }
 686
 687                       fmt = deferred_start + 1;
 688                       deferred_start = NULL;
 689                     }
 690                   ADD_CHAR (ch);
 691                   continue;
 692                 }
 693               ++fmt;
 694
 695               int width = 0;
 696               while (isdigit (*fmt))
 697                 width = width * 10 + (*fmt++ - '0');
 698
 699               int prec = 0;
 700               if (*fmt == '.')
 701                 while (isdigit (*++fmt))
 702                   prec = prec * 10 + (*fmt - '0');
 703
 704               size_t start_idx = bufcnt;
 705               size_t non_printing = 0;
 706               switch (*fmt++)
 707                 {
 708                   char mnebuf[16];
 709                   const char *str;
 710
 711                 case 'm':
 712                   /* Mnemonic.  */
 713
 714                   if (unlikely (instrtab[cnt].mnemonic == MNE_INVALID))
 715                     {
 716                       switch (*data)
 717                         {
 718 #ifdef X86_64
 719                         case 0x90:
 720                           if (prefixes & has_rex_b)
 721                             goto not;
 722                           str = "nop";
 723                           break;
 724 #endif
 725
 726                         case 0x98:
 727 #ifdef X86_64
 728                           if (prefixes == (has_rex_w | has_rex))
 729                             {
 730                               str = "cltq";
 731                               break;
 732                             }
 733 #endif
 734                           if (prefixes & ~has_data16)
 735                             goto print_prefix;
 736                           str = prefixes & has_data16 ? "cbtw" : "cwtl";
 737                           break;
 738
 739                         case 0x99:
 740 #ifdef X86_64
 741                           if (prefixes == (has_rex_w | has_rex))
 742                             {
 743                               str = "cqto";
 744                               break;
 745                             }
 746 #endif
 747                           if (prefixes & ~has_data16)
 748                             goto print_prefix;
 749                           str = prefixes & has_data16 ? "cwtd" : "cltd";
 750                           break;
 751
 752                         case 0xe3:
 753                           if (prefixes & ~has_addr16)
 754                             goto print_prefix;
 755 #ifdef X86_64
 756                           str = prefixes & has_addr16 ? "jecxz" : "jrcxz";
 757 #else
 758                           str = prefixes & has_addr16 ? "jcxz" : "jecxz";
 759 #endif
 760                           break;
 761
 762                         case 0x0f:
 763                           if (data[1] == 0x0f)
 764                             {
 765                               /* AMD 3DNOW.  We need one more byte.  */
 766                               if (param_start >= end)
 767                                 goto not;
 768                               if (*param_start < AMD3DNOW_LOW_IDX
 769                                   || *param_start > AMD3DNOW_HIGH_IDX)
 770                                 goto not;
 771                               unsigned int idx
 772                                 = amd3dnow[AMD3DNOW_IDX (*param_start)];
 773                               if (idx == 0)
 774                                 goto not;
 775                               str = amd3dnowstr + idx - 1;
 776                               /* Eat the immediate byte indicating the
 777                                  operation.  */
 778                               ++param_start;
 779                               break;
 780                             }
 781 #ifdef X86_64
 782                           if (data[1] == 0xc7)
 783                             {
 784                               str = ((prefixes & has_rex_w)
 785                                      ? "cmpxchg16b" : "cmpxchg8b");
 786                               break;
 787                             }
 788 #endif
 789                           if (data[1] == 0xc2)
 790                             {
 791                               if (param_start >= end)
 792                                 goto not;
 793                               if (*param_start > 7)
 794                                 goto not;
 795                               static const char cmpops[][9] =
 796                                 {
 797                                   [0] = "cmpeq",
 798                                   [1] = "cmplt",
 799                                   [2] = "cmple",
 800                                   [3] = "cmpunord",
 801                                   [4] = "cmpneq",
 802                                   [5] = "cmpnlt",
 803                                   [6] = "cmpnle",
 804                                   [7] = "cmpord"
 805                                 };
 806                               char *cp = stpcpy (mnebuf, cmpops[*param_start]);
 807                               if (correct_prefix & (has_rep | has_repne))
 808                                 *cp++ = 's';
 809                               else
 810                                 *cp++ = 'p';
 811                               if (correct_prefix & (has_data16 | has_repne))
 812                                 *cp++ = 'd';
 813                               else
 814                                 *cp++ = 's';
 815                               *cp = '\0';
 816                               str = mnebuf;
 817                               /* Eat the immediate byte indicating the
 818                                  operation.  */
 819                               ++param_start;
 820                               break;
 821                             }
 822
 823                         default:
 824                           assert (! "INVALID not handled");
 825                         }
 826                     }
 827                   else
 828                     str = mnestr.str + mneidx[instrtab[cnt].mnemonic];
 829
 830                   if (deferred_start != NULL)
 831                     {
 832                       ADD_NSTRING (deferred_start, deferred_len);
 833                       non_printing += deferred_len;
 834                     }
 835
 836                   ADD_STRING (str);
 837
 838                   switch (instrtab[cnt].suffix)
 839                     {
 840                     case suffix_none:
 841                       break;
 842
 843                     case suffix_w:
 844                       if ((codep[-1] & 0xc0) != 0xc0)
 845                         {
 846                           char ch;
 847
 848                           if (data[0] & 1)
 849                             {
 850                               if (prefixes & has_data16)
 851                                 ch = 'w';
 852 #ifdef X86_64
 853                               else if (prefixes & has_rex_w)
 854                                 ch = 'q';
 855 #endif
 856                               else
 857                                 ch = 'l';
 858                             }
 859                           else
 860                             ch = 'b';
 861
 862                           ADD_CHAR (ch);
 863                         }
 864                       break;
 865
 866                     case suffix_w0:
 867                       if ((codep[-1] & 0xc0) != 0xc0)
 868                         ADD_CHAR ('l');
 869                       break;
 870
 871                     case suffix_w1:
 872                       if ((data[0] & 0x4) == 0)
 873                         ADD_CHAR ('l');
 874                       break;
 875
 876                     case suffix_W:
 877                       if (prefixes & has_data16)
 878                         {
 879                           ADD_CHAR ('w');
 880                           prefixes &= ~has_data16;
 881                         }
 882 #ifdef X86_64
 883                       else
 884                         ADD_CHAR ('q');
 885 #endif
 886                       break;
 887
 888                     case suffix_W1:
 889                       if (prefixes & has_data16)
 890                         {
 891                           ADD_CHAR ('w');
 892                           prefixes &= ~has_data16;
 893                         }
 894 #ifdef X86_64
 895                       else if (prefixes & has_rex_w)
 896                         ADD_CHAR ('q');
 897 #endif
 898                       break;
 899
 900                     case suffix_tttn:;
 901                       static const char tttn[16][3] =
 902                         {
 903                           "o", "no", "b", "ae", "e", "ne", "be", "a",
 904                           "s", "ns", "p", "np", "l", "ge", "le", "g"
 905                         };
 906                       ADD_STRING (tttn[codep[-1 - instrtab[cnt].modrm] & 0x0f]);
 907                       break;
 908
 909                     case suffix_D:
 910                       if ((codep[-1] & 0xc0) != 0xc0)
 911                         ADD_CHAR ((data[0] & 0x04) == 0 ? 's' : 'l');
 912                       break;
 913
 914                     default:
 915                       printf("unknown suffix %d\n", instrtab[cnt].suffix);
 916                       abort ();
 917                     }
 918
 919                   if (deferred_start != NULL)
 920                     {
 921                       ADD_STRING (color_off);
 922                       non_printing += strlen (color_off);
 923                     }
 924
 925                   string_end_idx = bufcnt;
 926                   break;
 927
 928                 case 'o':
 929                   if (prec == 1 && instrtab[cnt].fct1 != 0)
 930                     {
 931                       /* First parameter.  */
 932                       if (deferred_start != NULL)
 933                         {
 934                           ADD_NSTRING (deferred_start, deferred_len);
 935                           non_printing += deferred_len;
 936                         }
 937
 938                       if (instrtab[cnt].str1 != 0)
 939                         ADD_STRING (op1_str
 940                                     + op1_str_idx[instrtab[cnt].str1 - 1]);
 941
 942                       output_data.opoff1 = (instrtab[cnt].off1_1
 943                                             + OFF1_1_BIAS - opoff);
 944                       output_data.opoff2 = (instrtab[cnt].off1_2
 945                                             + OFF1_2_BIAS - opoff);
 946                       output_data.opoff3 = (instrtab[cnt].off1_3
 947                                             + OFF1_3_BIAS - opoff);
 948                       int r = op1_fct[instrtab[cnt].fct1] (&output_data);
 949                       if (r < 0)
 950                         goto not;
 951                       if (r > 0)
 952                         goto enomem;
 953
 954                       if (deferred_start != NULL)
 955                         {
 956                           ADD_STRING (color_off);
 957                           non_printing += strlen (color_off);
 958                         }
 959
 960                       string_end_idx = bufcnt;
 961                     }
 962                   else if (prec == 2 && instrtab[cnt].fct2 != 0)
 963                     {
 964                       /* Second parameter.  */
 965                       if (deferred_start != NULL)
 966                         {
 967                           ADD_NSTRING (deferred_start, deferred_len);
 968                           non_printing += deferred_len;
 969                         }
 970
 971                       if (instrtab[cnt].str2 != 0)
 972                         ADD_STRING (op2_str
 973                                     + op2_str_idx[instrtab[cnt].str2 - 1]);
 974
 975                       output_data.opoff1 = (instrtab[cnt].off2_1
 976                                             + OFF2_1_BIAS - opoff);
 977                       output_data.opoff2 = (instrtab[cnt].off2_2
 978                                             + OFF2_2_BIAS - opoff);
 979                       output_data.opoff3 = (instrtab[cnt].off2_3
 980                                             + OFF2_3_BIAS - opoff);
 981                       int r = op2_fct[instrtab[cnt].fct2] (&output_data);
 982                       if (r < 0)
 983                         goto not;
 984                       if (r > 0)
 985                         goto enomem;
 986
 987                       if (deferred_start != NULL)
 988                         {
 989                           ADD_STRING (color_off);
 990                           non_printing += strlen (color_off);
 991                         }
 992
 993                       string_end_idx = bufcnt;
 994                     }
 995                   else if (prec == 3 && instrtab[cnt].fct3 != 0)
 996                     {
 997                       /* Third parameter.  */
 998                       if (deferred_start != NULL)
 999                         {
1000                           ADD_NSTRING (deferred_start, deferred_len);
1001                           non_printing += deferred_len;
1002                         }
1003
1004                       if (instrtab[cnt].str3 != 0)
1005                         ADD_STRING (op3_str
1006                                     + op3_str_idx[instrtab[cnt].str3 - 1]);
1007
1008                       output_data.opoff1 = (instrtab[cnt].off3_1
1009                                             + OFF3_1_BIAS - opoff);
1010                       output_data.opoff2 = (instrtab[cnt].off3_2
1011                                             + OFF3_2_BIAS - opoff);
1012 #ifdef OFF3_3_BITS
1013                       output_data.opoff3 = (instrtab[cnt].off3_3
1014                                             + OFF3_3_BIAS - opoff);
1015 #else
1016                       output_data.opoff3 = 0;
1017 #endif
1018                       int r = op3_fct[instrtab[cnt].fct3] (&output_data);
1019                       if (r < 0)
1020                         goto not;
1021                       if (r > 0)
1022                         goto enomem;
1023
1024                       if (deferred_start != NULL)
1025                         {
1026                           ADD_STRING (color_off);
1027                           non_printing += strlen (color_off);
1028                         }
1029
1030                       string_end_idx = bufcnt;
1031                     }
1032                   else
1033                     bufcnt = string_end_idx;
1034                   break;
1035
1036                 case 'e':
1037                   string_end_idx = bufcnt;
1038                   break;
1039
1040                 case 'a':
1041                   /* Pad to requested column.  */
1042                   while (bufcnt - non_printing < (size_t) width)
1043                     ADD_CHAR (' ');
1044                   width = 0;
1045                   break;
1046
1047                 case 'l':
1048                   if (deferred_start != NULL)
1049                     {
1050                       ADD_NSTRING (deferred_start, deferred_len);
1051                       non_printing += deferred_len;
1052                     }
1053
1054                   if (output_data.labelbuf != NULL
1055                       && output_data.labelbuf[0] != '\0')
1056                     {
1057                       ADD_STRING (output_data.labelbuf);
1058                       output_data.labelbuf[0] = '\0';
1059                       string_end_idx = bufcnt;
1060                     }
1061                   else if (output_data.symaddr_use != addr_none)
1062                     {
1063                       GElf_Addr symaddr = output_data.symaddr;
1064                       if (output_data.symaddr_use >= addr_rel_symbolic)
1065                         symaddr += addr + param_start - begin;
1066
1067                       // XXX Lookup symbol based on symaddr
1068                       const char *symstr = NULL;
1069                       if (symcb != NULL
1070                           && symcb (0 /* XXX */, 0 /* XXX */, symaddr,
1071                                     &output_data.labelbuf,
1072                                     &output_data.labelbufsize, symcbarg) == 0)
1073                         symstr = output_data.labelbuf;
1074
1075                       size_t bufavail = bufsize - bufcnt;
1076                       int r = 0;
1077                       if (symstr != NULL)
1078                         r = snprintf (&buf[bufcnt], bufavail, "# <%s>",
1079                                       symstr);
1080                       else if (output_data.symaddr_use == addr_abs_always
1081                                || output_data.symaddr_use == addr_rel_always)
1082                         r = snprintf (&buf[bufcnt], bufavail, "# %#" PRIx64,
1083                                       (uint64_t) symaddr);
1084
1085                       assert (r >= 0);
1086                       if ((size_t) r >= bufavail)
1087                         goto enomem;
1088                       bufcnt += r;
1089                       string_end_idx = bufcnt;
1090
1091                       output_data.symaddr_use = addr_none;
1092                     }
1093                   if (deferred_start != NULL)
1094                     {
1095                       ADD_STRING (color_off);
1096                       non_printing += strlen (color_off);
1097                     }
1098                   break;
1099
1100                 default:
1101                   abort ();
1102                 }
1103
1104               deferred_start = NULL;
1105
1106               /* Pad according to the specified width.  */
1107               while (bufcnt + prefix_size - non_printing < start_idx + width)
1108                 ADD_CHAR (' ');
1109               prefix_size = 0;
1110             }
1111
1112           if ((prefixes & SEGMENT_PREFIXES) != 0)
1113             goto print_prefix;
1114
1115           assert (string_end_idx != ~0ul);
1116           bufcnt = string_end_idx;
1117
1118           addr += param_start - begin;
1119           data = param_start;
1120
1121           goto out;
1122         }
1123
1124       /* Invalid (or at least unhandled) opcode.  */
1125       if (prefixes != 0)
1126         goto print_prefix;
1127       assert (*startp == data);
1128       ++data;
1129       ADD_STRING ("(bad)");
1130       addr += data - begin;
1131
1132     out:
1133       if (bufcnt == bufsize)
1134         goto enomem;
1135       buf[bufcnt] = '\0';
1136
1137       *startp = data;
1138       retval = outcb (buf, bufcnt, outcbarg);
1139       if (retval != 0)
1140         goto do_ret;
1141     }
1142
1143  do_ret:
1144   free (output_data.labelbuf);
1145   if (buf != initbuf)
1146     free (buf);
1147
1148   return retval;
1149 }