projects / deliverable / binutils-gdb.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* config/tc-xtensa.c (insn_labels, free_insn_labels, saved_insn_labels,
[deliverable/binutils-gdb.git] / opcodes / i386-dis.c
diff --git a/opcodes/i386-dis.c b/opcodes/i386-dis.c
index 7b4b8582e3af26e02b0aaf2cd526956d3adee11c..7c03205a191a58628eb4c6a8d88be9bfd7aa0d0a 100644 (file)
--- a/opcodes/i386-dis.c
+++ b/opcodes/i386-dis.c
@@ -1,7 +1,6 @@
 /* Print i386 instructions for GDB, the GNU debugger.
    Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-   2001
-   Free Software Foundation, Inc.
+   2001, 2002, 2003 Free Software Foundation, Inc.
 
 This file is part of GDB.
 
@@ -94,6 +93,7 @@ static void OP_XS PARAMS ((int, int));
 static void OP_3DNowSuffix PARAMS ((int, int));
 static void OP_SIMD_Suffix PARAMS ((int, int));
 static void SIMD_Fixup PARAMS ((int, int));
+static void PNI_Fixup PARAMS ((int, int));
 static void BadOp PARAMS ((void));
 
 struct dis_private {
@@ -176,9 +176,9 @@ fetch_data (info, addr)
   if (status != 0)
     {
       /* If we did manage to read at least one byte, then
-         print_insn_i386 will do something sensible.  Otherwise, print
-         an error.  We do that here because this is where we know
-         STATUS.  */
+        print_insn_i386 will do something sensible.  Otherwise, print
+        an error.  We do that here because this is where we know
+        STATUS.  */
       if (priv->max_fetched == priv->the_buffer)
        (*info->memory_error_func) (status, start, info);
       longjmp (priv->bailout, 1);
@@ -193,6 +193,7 @@ fetch_data (info, addr)
 #define Eb OP_E, b_mode
 #define Ev OP_E, v_mode
 #define Ed OP_E, d_mode
+#define Edq OP_E, dq_mode
 #define indirEb OP_indirE, b_mode
 #define indirEv OP_indirE, v_mode
 #define Ew OP_E, w_mode
@@ -312,6 +313,7 @@ fetch_data (info, addr)
 #define m_mode 7  /* d_mode in 32bit, q_mode in 64bit mode.  */
 #define cond_jump_mode 8
 #define loop_jcxz_mode 9
+#define dq_mode 10 /* operand size depends on REX prefixes.  */
 
 #define es_reg 100
 #define cs_reg 101
@@ -416,6 +418,12 @@ fetch_data (info, addr)
 #define PREGRP24  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
 #define PREGRP25  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
 #define PREGRP26  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
+#define PREGRP27  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0
+#define PREGRP28  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0
+#define PREGRP29  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0
+#define PREGRP30  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0
+#define PREGRP31  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0
+#define PREGRP32  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0
 
 #define X86_64_0  NULL, NULL, X86_64_SPECIAL, NULL,  0, NULL, 0
 
@@ -735,7 +743,7 @@ static const struct dis386 dis386[] = {
   { "outS",            indirDX, eAX, XX },
   /* f0 */
   { "(bad)",           XX, XX, XX },   /* lock prefix */
-  { "(bad)",           XX, XX, XX },
+  { "icebp",           XX, XX, XX },
   { "(bad)",           XX, XX, XX },   /* repne */
   { "(bad)",           XX, XX, XX },   /* repz */
   { "hlt",             XX, XX, XX },
@@ -775,11 +783,11 @@ static const struct dis386 dis386_twobyte[] = {
   /* 10 */
   { PREGRP8 },
   { PREGRP9 },
-  { "movlpX",          XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
+  { PREGRP30 },
   { "movlpX",          EX, XM, SIMD_Fixup, 'h' },
   { "unpcklpX",                XM, EX, XX },
   { "unpckhpX",                XM, EX, XX },
-  { "movhpX",          XM, EX, SIMD_Fixup, 'l' },
+  { PREGRP31 },
   { "movhpX",          EX, XM, SIMD_Fixup, 'l' },
   /* 18 */
   { GRP14 },
@@ -878,7 +886,7 @@ static const struct dis386 dis386_twobyte[] = {
   { "packssdw",                MX, EM, XX },
   { PREGRP26 },
   { PREGRP24 },
-  { "movd",            MX, Ed, XX },
+  { "movd",            MX, Edq, XX },
   { PREGRP19 },
   /* 70 */
   { PREGRP22 },
@@ -894,8 +902,8 @@ static const struct dis386 dis386_twobyte[] = {
   { "(bad)",           XX, XX, XX },
   { "(bad)",           XX, XX, XX },
   { "(bad)",           XX, XX, XX },
-  { "(bad)",           XX, XX, XX },
-  { "(bad)",           XX, XX, XX },
+  { PREGRP28 },
+  { PREGRP29 },
   { PREGRP23 },
   { PREGRP20 },
   /* 80 */
@@ -989,7 +997,7 @@ static const struct dis386 dis386_twobyte[] = {
   { "bswap",           RMeSI, XX, XX },
   { "bswap",           RMeDI, XX, XX },
   /* d0 */
-  { "(bad)",           XX, XX, XX },
+  { PREGRP27 },
   { "psrlw",           MX, EM, XX },
   { "psrld",           MX, EM, XX },
   { "psrlq",           MX, EM, XX },
@@ -1025,7 +1033,7 @@ static const struct dis386 dis386_twobyte[] = {
   { "pmaxsw",          MX, EM, XX },
   { "pxor",            MX, EM, XX },
   /* f0 */
-  { "(bad)",           XX, XX, XX },
+  { PREGRP32 },
   { "psllw",           MX, EM, XX },
   { "pslld",           MX, EM, XX },
   { "psllq",           MX, EM, XX },
@@ -1077,15 +1085,15 @@ static const unsigned char twobyte_has_modrm[256] = {
   /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
   /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
   /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
-  /* 70 */ 1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1, /* 7f */
+  /* 70 */ 1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1, /* 7f */
   /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
   /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
   /* a0 */ 0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1, /* af */
   /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
   /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
-  /* d0 */ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
+  /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
   /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
-  /* f0 */ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  /* ff */
+  /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  /* ff */
   /*       -------------------------------        */
   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
 };
@@ -1094,21 +1102,21 @@ static const unsigned char twobyte_uses_SSE_prefix[256] = {
   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
   /*       -------------------------------        */
   /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
-  /* 10 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
+  /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
   /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */
   /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
   /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
   /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
   /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
-  /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */
+  /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */
   /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
   /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
   /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
   /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
   /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
-  /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
+  /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
   /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
-  /* f0 */ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0  /* ff */
+  /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0  /* ff */
   /*       -------------------------------        */
   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
 };
@@ -1348,7 +1356,7 @@ static const struct dis386 grps[][8] = {
   /* GRP7 */
   {
     { "sgdtQ",  M, XX, XX },
-    { "sidtQ",  M, XX, XX },
+    { "sidtQ", PNI_Fixup, 0, XX, XX },
     { "lgdtQ",  M, XX, XX },
     { "lidtQ",  M, XX, XX },
     { "smswQ", Ev, XX, XX },
@@ -1611,9 +1619,9 @@ static const struct dis386 prefix_user_table[][4] = {
   },
   /* PREGRP23 */
   {
-    { "movd", Ed, MX, XX },
+    { "movd", Edq, MX, XX },
     { "movq", XM, EX, XX },
-    { "movd", Ed, XM, XX },
+    { "movd", Edq, XM, XX },
     { "(bad)", Ed, XM, XX },
   },
   /* PREGRP24 */
@@ -1637,6 +1645,48 @@ static const struct dis386 prefix_user_table[][4] = {
     { "punpcklqdq", XM, EX, XX },
     { "(bad)", XM, EX, XX },
   },
+  /* PREGRP27 */
+  {
+    { "(bad)", MX, EX, XX },
+    { "(bad)", XM, EX, XX },
+    { "addsubpd", XM, EX, XX },
+    { "addsubps", XM, EX, XX },
+  },
+  /* PREGRP28 */
+  {
+    { "(bad)", MX, EX, XX },
+    { "(bad)", XM, EX, XX },
+    { "haddpd", XM, EX, XX },
+    { "haddps", XM, EX, XX },
+  },
+  /* PREGRP29 */
+  {
+    { "(bad)", MX, EX, XX },
+    { "(bad)", XM, EX, XX },
+    { "hsubpd", XM, EX, XX },
+    { "hsubps", XM, EX, XX },
+  },
+  /* PREGRP30 */
+  {
+    { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
+    { "movsldup", XM, EX, XX },
+    { "movlpd", XM, EX, XX },
+    { "movddup", XM, EX, XX },
+  },
+  /* PREGRP31 */
+  {
+    { "movhpX", XM, EX, SIMD_Fixup, 'l' },
+    { "movshdup", XM, EX, XX },
+    { "movhpd", XM, EX, XX },
+    { "(bad)", XM, EX, XX },
+  },
+  /* PREGRP32 */
+  {
+    { "(bad)", XM, EX, XX },
+    { "(bad)", XM, EX, XX },
+    { "(bad)", XM, EX, XX },
+    { "lddqu", XM, M, XX },
+  },
 };
 
 static const struct dis386 x86_64_table[][2] = {
@@ -1807,7 +1857,10 @@ prefix_name (pref, sizeflag)
     case 0x66:
       return (sizeflag & DFLAG) ? "data16" : "data32";
     case 0x67:
-      return (sizeflag & AFLAG) ? "addr16" : "addr32";
+      if (mode_64bit)
+       return (sizeflag & AFLAG) ? "addr32" : "addr64";
+      else
+       return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32";
     case FWAIT_OPCODE:
       return "fwait";
     default:
@@ -1887,7 +1940,7 @@ print_insn (pc, info)
   mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax
                || info->mach == bfd_mach_x86_64);
 
-  if (intel_syntax == -1)
+  if (intel_syntax == (char) -1)
     intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
                    || info->mach == bfd_mach_x86_64_intel_syntax);
 
@@ -2037,7 +2090,7 @@ print_insn (pc, info)
       const char *name;
 
       /* fwait not followed by floating point instruction.  Print the
-         first prefix, which is probably fwait itself.  */
+        first prefix, which is probably fwait itself.  */
       name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
       if (name == NULL)
        name = INTERNAL_DISASSEMBLER_ERROR;
@@ -2081,7 +2134,7 @@ print_insn (pc, info)
       sizeflag ^= AFLAG;
       if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
        {
-         if (sizeflag & AFLAG)
+         if ((sizeflag & AFLAG) || mode_64bit)
            oappend ("addr32 ");
          else
            oappend ("addr16 ");
@@ -2270,7 +2323,7 @@ static const char *float_mem[] = {
   "fsubr{s||s|}",
   "fdiv{s||s|}",
   "fdivr{s||s|}",
-  /*  d9 */
+  /* d9 */
   "fld{s||s|}",
   "(bad)",
   "fst{s||s|}",
@@ -2290,7 +2343,7 @@ static const char *float_mem[] = {
   "fidivr{l||l|}",
   /* db */
   "fild{l||l|}",
-  "(bad)",
+  "fisttp{l||l|}",
   "fist{l||l|}",
   "fistp{l||l|}",
   "(bad)",
@@ -2308,7 +2361,7 @@ static const char *float_mem[] = {
   "fdivr{l||l|}",
   /* dd */
   "fld{l||l|}",
-  "(bad)",
+  "fisttpll",
   "fst{l||l|}",
   "fstp{l||l|}",
   "frstor",
@@ -2326,7 +2379,7 @@ static const char *float_mem[] = {
   "fidivr",
   /* df */
   "fild",
-  "(bad)",
+  "fisttp",
   "fist",
   "fistp",
   "fbld",
@@ -2515,11 +2568,11 @@ dofloat (sizeflag)
       putop (float_mem[(floatop - 0xd8) * 8 + reg], sizeflag);
       obufp = op1out;
       if (floatop == 0xdb)
-        OP_E (x_mode, sizeflag);
+       OP_E (x_mode, sizeflag);
       else if (floatop == 0xdd)
-        OP_E (d_mode, sizeflag);
+       OP_E (d_mode, sizeflag);
       else
-        OP_E (v_mode, sizeflag);
+       OP_E (v_mode, sizeflag);
       return;
     }
   /* Skip mod/rm byte.  */
@@ -2614,37 +2667,45 @@ putop (template, sizeflag)
        case '}':
          break;
        case 'A':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
            *obufp++ = 'b';
          break;
        case 'B':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (sizeflag & SUFFIX_ALWAYS)
            *obufp++ = 'b';
          break;
        case 'E':               /* For jcxz/jecxz */
-         if (sizeflag & AFLAG)
-           *obufp++ = 'e';
+         if (mode_64bit)
+           {
+             if (sizeflag & AFLAG)
+               *obufp++ = 'r';
+             else
+               *obufp++ = 'e';
+           }
+         else
+           if (sizeflag & AFLAG)
+             *obufp++ = 'e';
          used_prefixes |= (prefixes & PREFIX_ADDR);
          break;
        case 'F':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
            {
              if (sizeflag & AFLAG)
-               *obufp++ = 'l';
+               *obufp++ = mode_64bit ? 'q' : 'l';
              else
-               *obufp++ = 'w';
+               *obufp++ = mode_64bit ? 'l' : 'w';
              used_prefixes |= (prefixes & PREFIX_ADDR);
            }
          break;
        case 'H':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
              || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
            {
@@ -2658,8 +2719,8 @@ putop (template, sizeflag)
            }
          break;
        case 'L':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (sizeflag & SUFFIX_ALWAYS)
            *obufp++ = 'l';
          break;
@@ -2677,8 +2738,8 @@ putop (template, sizeflag)
            *obufp++ = 'd';
          break;
        case 'T':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (mode_64bit)
            {
              *obufp++ = 'q';
@@ -2686,8 +2747,8 @@ putop (template, sizeflag)
            }
          /* Fall through.  */
        case 'P':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if ((prefixes & PREFIX_DATA)
              || (rex & REX_MODE64)
              || (sizeflag & SUFFIX_ALWAYS))
@@ -2706,8 +2767,8 @@ putop (template, sizeflag)
            }
          break;
        case 'U':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (mode_64bit)
            {
              *obufp++ = 'q';
@@ -2715,8 +2776,8 @@ putop (template, sizeflag)
            }
          /* Fall through.  */
        case 'Q':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          USED_REX (REX_MODE64);
          if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
            {
@@ -2734,7 +2795,7 @@ putop (template, sizeflag)
          break;
        case 'R':
          USED_REX (REX_MODE64);
-          if (intel_syntax)
+         if (intel_syntax)
            {
              if (rex & REX_MODE64)
                {
@@ -2765,8 +2826,8 @@ putop (template, sizeflag)
            used_prefixes |= (prefixes & PREFIX_DATA);
          break;
        case 'S':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (sizeflag & SUFFIX_ALWAYS)
            {
              if (rex & REX_MODE64)
@@ -2786,11 +2847,11 @@ putop (template, sizeflag)
            *obufp++ = 'd';
          else
            *obufp++ = 's';
-          used_prefixes |= (prefixes & PREFIX_DATA);
+         used_prefixes |= (prefixes & PREFIX_DATA);
          break;
        case 'Y':
-          if (intel_syntax)
-            break;
+         if (intel_syntax)
+           break;
          if (rex & REX_MODE64)
            {
              USED_REX (REX_MODE64);
@@ -2807,7 +2868,7 @@ putop (template, sizeflag)
            *obufp++ = 'w';
          else
            *obufp++ = 'b';
-          if (intel_syntax)
+         if (intel_syntax)
            {
              if (rex)
                {
@@ -2989,10 +3050,11 @@ OP_E (bytemode, sizeflag)
            oappend (names32[rm + add]);
          break;
        case v_mode:
+       case dq_mode:
          USED_REX (REX_MODE64);
          if (rex & REX_MODE64)
            oappend (names64[rm + add]);
-         else if (sizeflag & DFLAG)
+         else if ((sizeflag & DFLAG) || bytemode == dq_mode)
            oappend (names32[rm + add]);
          else
            oappend (names16[rm + add]);
@@ -3014,7 +3076,7 @@ OP_E (bytemode, sizeflag)
   disp = 0;
   append_seg ();
 
-  if (sizeflag & AFLAG) /* 32 bit address mode */
+  if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */
     {
       int havesib;
       int havebase;
@@ -3048,7 +3110,7 @@ OP_E (bytemode, sizeflag)
          if ((base & 7) == 5)
            {
              havebase = 0;
-             if (mode_64bit && !havesib)
+             if (mode_64bit && !havesib && (sizeflag & AFLAG))
                riprel = 1;
              disp = get32s ();
            }
@@ -3065,94 +3127,97 @@ OP_E (bytemode, sizeflag)
        }
 
       if (!intel_syntax)
-        if (mod != 0 || (base & 7) == 5)
-          {
+       if (mod != 0 || (base & 7) == 5)
+         {
            print_operand_value (scratchbuf, !riprel, disp);
-            oappend (scratchbuf);
+           oappend (scratchbuf);
            if (riprel)
              {
                set_op (disp, 1);
                oappend ("(%rip)");
              }
-          }
+         }
 
       if (havebase || (havesib && (index != 4 || scale != 0)))
        {
-          if (intel_syntax)
-            {
-              switch (bytemode)
-                {
-                case b_mode:
-                  oappend ("BYTE PTR ");
-                  break;
-                case w_mode:
-                  oappend ("WORD PTR ");
-                  break;
-                case v_mode:
-                  oappend ("DWORD PTR ");
-                  break;
-                case d_mode:
-                  oappend ("QWORD PTR ");
-                  break;
-                case m_mode:
+         if (intel_syntax)
+           {
+             switch (bytemode)
+               {
+               case b_mode:
+                 oappend ("BYTE PTR ");
+                 break;
+               case w_mode:
+                 oappend ("WORD PTR ");
+                 break;
+               case v_mode:
+                 oappend ("DWORD PTR ");
+                 break;
+               case d_mode:
+                 oappend ("QWORD PTR ");
+                 break;
+               case m_mode:
                  if (mode_64bit)
                    oappend ("DWORD PTR ");
                  else
                    oappend ("QWORD PTR ");
                  break;
-                case x_mode:
-                  oappend ("XWORD PTR ");
-                  break;
-                default:
-                  break;
-                }
-             }
+               case x_mode:
+                 oappend ("XWORD PTR ");
+                 break;
+               default:
+                 break;
+               }
+            }
          *obufp++ = open_char;
          if (intel_syntax && riprel)
            oappend ("rip + ");
-          *obufp = '\0';
+         *obufp = '\0';
          USED_REX (REX_EXTZ);
          if (!havesib && (rex & REX_EXTZ))
            base += 8;
          if (havebase)
-           oappend (mode_64bit ? names64[base] : names32[base]);
+           oappend (mode_64bit && (sizeflag & AFLAG)
+                    ? names64[base] : names32[base]);
          if (havesib)
            {
              if (index != 4)
                {
-                  if (intel_syntax)
-                    {
-                      if (havebase)
-                        {
-                          *obufp++ = separator_char;
-                          *obufp = '\0';
-                        }
-                      sprintf (scratchbuf, "%s",
-                              mode_64bit ? names64[index] : names32[index]);
-                    }
-                  else
+                 if (intel_syntax)
+                   {
+                     if (havebase)
+                       {
+                         *obufp++ = separator_char;
+                         *obufp = '\0';
+                       }
+                     sprintf (scratchbuf, "%s",
+                              mode_64bit && (sizeflag & AFLAG)
+                              ? names64[index] : names32[index]);
+                   }
+                 else
                    sprintf (scratchbuf, ",%s",
-                            mode_64bit ? names64[index] : names32[index]);
+                            mode_64bit && (sizeflag & AFLAG)
+                            ? names64[index] : names32[index]);
+                 oappend (scratchbuf);
+               }
+             if (!intel_syntax
+                 || (intel_syntax
+                     && bytemode != b_mode
+                     && bytemode != w_mode
+                     && bytemode != v_mode))
+               {
+                 *obufp++ = scale_char;
+                 *obufp = '\0';
+                 sprintf (scratchbuf, "%d", 1 << scale);
                  oappend (scratchbuf);
                }
-              if (!intel_syntax
-                  || (intel_syntax
-                      && bytemode != b_mode
-                      && bytemode != w_mode
-                      && bytemode != v_mode))
-                {
-                  *obufp++ = scale_char;
-                  *obufp = '\0';
-                 sprintf (scratchbuf, "%d", 1 << scale);
-                 oappend (scratchbuf);
-                }
            }
-          if (intel_syntax)
-            if (mod != 0 || (base & 7) == 5)
-              {
+         if (intel_syntax)
+           if (mod != 0 || (base & 7) == 5)
+             {
                /* Don't print zero displacements.  */
-                if (disp != 0)
-                  {
+               if (disp != 0)
+                 {
                    if ((bfd_signed_vma) disp > 0)
                      {
                        *obufp++ = '+';
@@ -3160,17 +3225,17 @@ OP_E (bytemode, sizeflag)
                      }
 
                    print_operand_value (scratchbuf, 0, disp);
-                    oappend (scratchbuf);
-                  }
-              }
+                   oappend (scratchbuf);
+                 }
+             }
 
          *obufp++ = close_char;
-          *obufp = '\0';
+         *obufp = '\0';
        }
       else if (intel_syntax)
-        {
-          if (mod != 0 || (base & 7) == 5)
-            {
+       {
+         if (mod != 0 || (base & 7) == 5)
+           {
              if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
                              | PREFIX_ES | PREFIX_FS | PREFIX_GS))
                ;
@@ -3180,9 +3245,9 @@ OP_E (bytemode, sizeflag)
                  oappend (":");
                }
              print_operand_value (scratchbuf, 1, disp);
-              oappend (scratchbuf);
-            }
-        }
+             oappend (scratchbuf);
+           }
+       }
     }
   else
     { /* 16 bit address mode */
@@ -3210,19 +3275,19 @@ OP_E (bytemode, sizeflag)
        }
 
       if (!intel_syntax)
-        if (mod != 0 || (rm & 7) == 6)
-          {
+       if (mod != 0 || (rm & 7) == 6)
+         {
            print_operand_value (scratchbuf, 0, disp);
-            oappend (scratchbuf);
-          }
+           oappend (scratchbuf);
+         }
 
       if (mod != 0 || (rm & 7) != 6)
        {
          *obufp++ = open_char;
-          *obufp = '\0';
+         *obufp = '\0';
          oappend (index16[rm + add]);
-          *obufp++ = close_char;
-          *obufp = '\0';
+         *obufp++ = close_char;
+         *obufp = '\0';
        }
     }
 }
@@ -3369,9 +3434,9 @@ OP_REG (code, sizeflag)
     {
     case indir_dx_reg:
       if (intel_syntax)
-        s = "[dx]";
+       s = "[dx]";
       else
-        s = "(%dx)";
+       s = "(%dx)";
       break;
     case ax_reg: case cx_reg: case dx_reg: case bx_reg:
     case sp_reg: case bp_reg: case si_reg: case di_reg:
@@ -3427,9 +3492,9 @@ OP_IMREG (code, sizeflag)
     {
     case indir_dx_reg:
       if (intel_syntax)
-        s = "[dx]";
+       s = "[dx]";
       else
-        s = "(%dx)";
+       s = "(%dx)";
       break;
     case ax_reg: case cx_reg: case dx_reg: case bx_reg:
     case sp_reg: case bp_reg: case si_reg: case di_reg:
@@ -3703,7 +3768,7 @@ OP_OFF (bytemode, sizeflag)
 
   append_seg ();
 
-  if (sizeflag & AFLAG)
+  if ((sizeflag & AFLAG) || mode_64bit)
     off = get32 ();
   else
     off = get16 ();
@@ -3711,7 +3776,7 @@ OP_OFF (bytemode, sizeflag)
   if (intel_syntax)
     {
       if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
-                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
+                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
        {
          oappend (names_seg[ds_reg - es_reg]);
          oappend (":");
@@ -3741,7 +3806,7 @@ OP_OFF64 (bytemode, sizeflag)
   if (intel_syntax)
     {
       if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
-                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
+                       | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
        {
          oappend (names_seg[ds_reg - es_reg]);
          oappend (":");
@@ -3764,7 +3829,12 @@ ptr_reg (code, sizeflag)
 
   USED_REX (REX_MODE64);
   if (rex & REX_MODE64)
-    s = names64[code - eAX_reg];
+    {
+      if (!(sizeflag & AFLAG))
+       s = names32[code - eAX_reg];
+      else
+       s = names64[code - eAX_reg];
+    }
   else if (sizeflag & AFLAG)
     s = names32[code - eAX_reg];
   else
@@ -3951,7 +4021,7 @@ OP_XS (bytemode, sizeflag)
     BadOp ();
 }
 
-static const char *Suffix3DNow[] = {
+static const char *const Suffix3DNow[] = {
 /* 00 */       NULL,           NULL,           NULL,           NULL,
 /* 04 */       NULL,           NULL,           NULL,           NULL,
 /* 08 */       NULL,           NULL,           NULL,           NULL,
@@ -4116,6 +4186,33 @@ SIMD_Fixup (extrachar, sizeflag)
     }
 }
 
+static void
+PNI_Fixup (extrachar, sizeflag)
+     int extrachar ATTRIBUTE_UNUSED;
+     int sizeflag ATTRIBUTE_UNUSED;
+{
+  if (mod == 3 && reg == 1)
+    {
+      char *p = obuf + strlen (obuf);
+
+      /* Override "sidt".  */
+      if (rm)
+       {
+         /* mwait %eax,%ecx  */
+         strcpy (p - 4, "mwait   %eax,%ecx");
+       }
+      else
+       {
+         /* monitor %eax,%ecx,%edx"  */
+         strcpy (p - 4, "monitor %eax,%ecx,%edx");
+       }
+
+      codep++;
+    }
+  else
+    OP_E (0, sizeflag);
+}
+
 static void
 BadOp (void)
 {
GDB Binutils - Deliverables
This page took 0.035162 seconds and 4 git commands to generate.