gas/config/tc-i386.c

   1 /* i386.c -- Assemble code for the Intel 80386
   2    Copyright (C) 1989, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
   3    Free Software Foundation.
   4
   5    This file is part of GAS, the GNU Assembler.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /*
  23   Intel 80386 machine specific gas.
  24   Written by Eliot Dresselhaus ([email protected]).
  25   Bugs & suggestions are completely welcome.  This is free software.
  26   Please help us make it better.
  27   */
  28
  29 #include <ctype.h>
  30
  31 #include "as.h"
  32 #include "subsegs.h"
  33 #include "opcode/i386.h"
  34
  35 #ifndef REGISTER_WARNINGS
  36 #define REGISTER_WARNINGS 1
  37 #endif
  38
  39 #ifndef INFER_ADDR_PREFIX
  40 #define INFER_ADDR_PREFIX 1
  41 #endif
  42
  43 #ifndef SCALE1_WHEN_NO_INDEX
  44 /* Specifying a scale factor besides 1 when there is no index is
  45    futile.  eg. `mov (%ebx,2),%al' does exactly the same as
  46    `mov (%ebx),%al'.  To slavishly follow what the programmer
  47    specified, set SCALE1_WHEN_NO_INDEX to 0.  */
  48 #define SCALE1_WHEN_NO_INDEX 1
  49 #endif
  50
  51 #define true 1
  52 #define false 0
  53
  54 static unsigned int mode_from_disp_size PARAMS ((unsigned int));
  55 static int fits_in_signed_byte PARAMS ((long));
  56 static int fits_in_unsigned_byte PARAMS ((long));
  57 static int fits_in_unsigned_word PARAMS ((long));
  58 static int fits_in_signed_word PARAMS ((long));
  59 static int smallest_imm_type PARAMS ((long));
  60 static int add_prefix PARAMS ((unsigned int));
  61 static void set_16bit_code_flag PARAMS ((int));
  62 static void set_16bit_gcc_code_flag PARAMS((int));
  63 static void set_intel_syntax PARAMS ((int));
  64
  65 #ifdef BFD_ASSEMBLER
  66 static bfd_reloc_code_real_type reloc
  67   PARAMS ((int, int, bfd_reloc_code_real_type));
  68 #endif
  69
  70 /* 'md_assemble ()' gathers together information and puts it into a
  71    i386_insn. */
  72
  73 union i386_op
  74   {
  75     expressionS *disps;
  76     expressionS *imms;
  77     const reg_entry *regs;
  78   };
  79
  80 struct _i386_insn
  81   {
  82     /* TM holds the template for the insn were currently assembling. */
  83     template tm;
  84
  85     /* SUFFIX holds the instruction mnemonic suffix if given.
  86        (e.g. 'l' for 'movl')  */
  87     char suffix;
  88
  89     /* OPERANDS gives the number of given operands. */
  90     unsigned int operands;
  91
  92     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
  93        of given register, displacement, memory operands and immediate
  94        operands. */
  95     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
  96
  97     /* TYPES [i] is the type (see above #defines) which tells us how to
  98        use OP[i] for the corresponding operand.  */
  99     unsigned int types[MAX_OPERANDS];
 100
 101     /* Displacement expression, immediate expression, or register for each
 102        operand.  */
 103     union i386_op op[MAX_OPERANDS];
 104
 105     /* Relocation type for operand */
 106 #ifdef BFD_ASSEMBLER
 107     enum bfd_reloc_code_real disp_reloc[MAX_OPERANDS];
 108 #else
 109     int disp_reloc[MAX_OPERANDS];
 110 #endif
 111
 112     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
 113        the base index byte below.  */
 114     const reg_entry *base_reg;
 115     const reg_entry *index_reg;
 116     unsigned int log2_scale_factor;
 117
 118     /* SEG gives the seg_entries of this insn.  They are zero unless
 119        explicit segment overrides are given. */
 120     const seg_entry *seg[2];    /* segments for memory operands (if given) */
 121
 122     /* PREFIX holds all the given prefix opcodes (usually null).
 123        PREFIXES is the number of prefix opcodes.  */
 124     unsigned int prefixes;
 125     unsigned char prefix[MAX_PREFIXES];
 126
 127     /* RM and SIB are the modrm byte and the sib byte where the
 128        addressing modes of this insn are encoded.  */
 129
 130     modrm_byte rm;
 131     sib_byte sib;
 132   };
 133
 134 typedef struct _i386_insn i386_insn;
 135
 136 /* List of chars besides those in app.c:symbol_chars that can start an
 137    operand.  Used to prevent the scrubber eating vital white-space.  */
 138 #ifdef LEX_AT
 139 const char extra_symbol_chars[] = "*%-(@";
 140 #else
 141 const char extra_symbol_chars[] = "*%-(";
 142 #endif
 143
 144 /* This array holds the chars that always start a comment.  If the
 145    pre-processor is disabled, these aren't very useful */
 146 #if defined (TE_I386AIX) || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) && ! defined (TE_LINUX))
 147 /* Putting '/' here makes it impossible to use the divide operator.
 148    However, we need it for compatibility with SVR4 systems.  */
 149 const char comment_chars[] = "#/";
 150 #define PREFIX_SEPARATOR '\\'
 151 #else
 152 const char comment_chars[] = "#";
 153 #define PREFIX_SEPARATOR '/'
 154 #endif
 155
 156 /* This array holds the chars that only start a comment at the beginning of
 157    a line.  If the line seems to have the form '# 123 filename'
 158    .line and .file directives will appear in the pre-processed output */
 159 /* Note that input_file.c hand checks for '#' at the beginning of the
 160    first line of the input file.  This is because the compiler outputs
 161    #NO_APP at the beginning of its output. */
 162 /* Also note that comments started like this one will always work if
 163    '/' isn't otherwise defined.  */
 164 #if defined (TE_I386AIX) || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) && ! defined (TE_LINUX))
 165 const char line_comment_chars[] = "";
 166 #else
 167 const char line_comment_chars[] = "/";
 168 #endif
 169
 170 const char line_separator_chars[] = "";
 171
 172 /* Chars that can be used to separate mant from exp in floating point nums */
 173 const char EXP_CHARS[] = "eE";
 174
 175 /* Chars that mean this number is a floating point constant */
 176 /* As in 0f12.456 */
 177 /* or    0d1.2345e12 */
 178 const char FLT_CHARS[] = "fFdDxX";
 179
 180 /* tables for lexical analysis */
 181 static char mnemonic_chars[256];
 182 static char register_chars[256];
 183 static char operand_chars[256];
 184 static char identifier_chars[256];
 185 static char digit_chars[256];
 186
 187 /* lexical macros */
 188 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 189 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 190 #define is_register_char(x) (register_chars[(unsigned char) x])
 191 #define is_space_char(x) ((x) == ' ')
 192 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 193 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 194
 195 /* put here all non-digit non-letter charcters that may occur in an operand */
 196 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 197
 198 /* md_assemble() always leaves the strings it's passed unaltered.  To
 199    effect this we maintain a stack of saved characters that we've smashed
 200    with '\0's (indicating end of strings for various sub-fields of the
 201    assembler instruction). */
 202 static char save_stack[32];
 203 static char *save_stack_p;      /* stack pointer */
 204 #define END_STRING_AND_SAVE(s) \
 205         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 206 #define RESTORE_END_STRING(s) \
 207         do { *(s) = *--save_stack_p; } while (0)
 208
 209 /* The instruction we're assembling. */
 210 static i386_insn i;
 211
 212 /* Possible templates for current insn.  */
 213 static const templates *current_templates;
 214
 215 /* Per instruction expressionS buffers: 2 displacements & 2 immediate max. */
 216 static expressionS disp_expressions[2], im_expressions[2];
 217
 218 static int this_operand;        /* current operand we are working on */
 219
 220 static int flag_do_long_jump;   /* FIXME what does this do? */
 221
 222 static int flag_16bit_code;     /* 1 if we're writing 16-bit code, 0 if 32-bit */
 223
 224 static int intel_syntax = 0;    /* 1 for intel syntax, 0 if att syntax */
 225
 226 static int allow_naked_reg = 0;  /* 1 if register prefix % not required */
 227
 228 static char stackop_size = '\0';  /* Used in 16 bit gcc mode to add an l
 229                                      suffix to call, ret, enter, leave, push,
 230                                      and pop instructions so that gcc has the
 231                                      same stack frame as in 32 bit mode.  */
 232
 233 /* Interface to relax_segment.
 234    There are 2 relax states for 386 jump insns: one for conditional &
 235    one for unconditional jumps.  This is because these two types of
 236    jumps add different sizes to frags when we're figuring out what
 237    sort of jump to choose to reach a given label.  */
 238
 239 /* types */
 240 #define COND_JUMP 1             /* conditional jump */
 241 #define UNCOND_JUMP 2           /* unconditional jump */
 242 /* sizes */
 243 #define CODE16  1
 244 #define SMALL   0
 245 #define SMALL16 (SMALL|CODE16)
 246 #define BIG     2
 247 #define BIG16   (BIG|CODE16)
 248
 249 #ifndef INLINE
 250 #ifdef __GNUC__
 251 #define INLINE __inline__
 252 #else
 253 #define INLINE
 254 #endif
 255 #endif
 256
 257 #define ENCODE_RELAX_STATE(type,size) \
 258   ((relax_substateT)((type<<2) | (size)))
 259 #define SIZE_FROM_RELAX_STATE(s) \
 260     ( (((s) & 0x3) == BIG ? 4 : (((s) & 0x3) == BIG16 ? 2 : 1)) )
 261
 262 /* This table is used by relax_frag to promote short jumps to long
 263    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 264    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 265    don't allow a short jump in a 32 bit code segment to be promoted to
 266    a 16 bit offset jump because it's slower (requires data size
 267    prefix), and doesn't work, unless the destination is in the bottom
 268    64k of the code segment (The top 16 bits of eip are zeroed).  */
 269
 270 const relax_typeS md_relax_table[] =
 271 {
 272   /* The fields are:
 273      1) most positive reach of this state,
 274      2) most negative reach of this state,
 275      3) how many bytes this mode will add to the size of the current frag
 276      4) which index into the table to try if we can't fit into this one.
 277   */
 278   {1, 1, 0, 0},
 279   {1, 1, 0, 0},
 280   {1, 1, 0, 0},
 281   {1, 1, 0, 0},
 282
 283   {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 284   {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 285   /* dword conditionals adds 4 bytes to frag:
 286      1 extra opcode byte, 3 extra displacement bytes.  */
 287   {0, 0, 4, 0},
 288   /* word conditionals add 2 bytes to frag:
 289      1 extra opcode byte, 1 extra displacement byte.  */
 290   {0, 0, 2, 0},
 291
 292   {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 293   {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 294   /* dword jmp adds 3 bytes to frag:
 295      0 extra opcode bytes, 3 extra displacement bytes.  */
 296   {0, 0, 3, 0},
 297   /* word jmp adds 1 byte to frag:
 298      0 extra opcode bytes, 1 extra displacement byte.  */
 299   {0, 0, 1, 0}
 300
 301 };
 302
 303
 304 void
 305 i386_align_code (fragP, count)
 306      fragS *fragP;
 307      int count;
 308 {
 309   /* Various efficient no-op patterns for aligning code labels.  */
 310   /* Note: Don't try to assemble the instructions in the comments. */
 311   /*       0L and 0w are not legal */
 312   static const char f32_1[] =
 313     {0x90};                                     /* nop                  */
 314   static const char f32_2[] =
 315     {0x89,0xf6};                                /* movl %esi,%esi       */
 316   static const char f32_3[] =
 317     {0x8d,0x76,0x00};                           /* leal 0(%esi),%esi    */
 318   static const char f32_4[] =
 319     {0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
 320   static const char f32_5[] =
 321     {0x90,                                      /* nop                  */
 322      0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
 323   static const char f32_6[] =
 324     {0x8d,0xb6,0x00,0x00,0x00,0x00};            /* leal 0L(%esi),%esi   */
 325   static const char f32_7[] =
 326     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
 327   static const char f32_8[] =
 328     {0x90,                                      /* nop                  */
 329      0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
 330   static const char f32_9[] =
 331     {0x89,0xf6,                                 /* movl %esi,%esi       */
 332      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 333   static const char f32_10[] =
 334     {0x8d,0x76,0x00,                            /* leal 0(%esi),%esi    */
 335      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 336   static const char f32_11[] =
 337     {0x8d,0x74,0x26,0x00,                       /* leal 0(%esi,1),%esi  */
 338      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 339   static const char f32_12[] =
 340     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
 341      0x8d,0xbf,0x00,0x00,0x00,0x00};            /* leal 0L(%edi),%edi   */
 342   static const char f32_13[] =
 343     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
 344      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 345   static const char f32_14[] =
 346     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00,        /* leal 0L(%esi,1),%esi */
 347      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 348   static const char f32_15[] =
 349     {0xeb,0x0d,0x90,0x90,0x90,0x90,0x90,        /* jmp .+15; lotsa nops */
 350      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
 351   static const char f16_3[] =
 352     {0x8d,0x74,0x00};                           /* lea 0(%esi),%esi     */
 353   static const char f16_4[] =
 354     {0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
 355   static const char f16_5[] =
 356     {0x90,                                      /* nop                  */
 357      0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
 358   static const char f16_6[] =
 359     {0x89,0xf6,                                 /* mov %si,%si          */
 360      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 361   static const char f16_7[] =
 362     {0x8d,0x74,0x00,                            /* lea 0(%si),%si       */
 363      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 364   static const char f16_8[] =
 365     {0x8d,0xb4,0x00,0x00,                       /* lea 0w(%si),%si      */
 366      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 367   static const char *const f32_patt[] = {
 368     f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
 369     f32_9, f32_10, f32_11, f32_12, f32_13, f32_14, f32_15
 370   };
 371   static const char *const f16_patt[] = {
 372     f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8,
 373     f32_15, f32_15, f32_15, f32_15, f32_15, f32_15, f32_15
 374   };
 375
 376   if (count > 0 && count <= 15)
 377     {
 378       if (flag_16bit_code)
 379         {
 380           memcpy(fragP->fr_literal + fragP->fr_fix,
 381                  f16_patt[count - 1], count);
 382           if (count > 8) /* adjust jump offset */
 383             fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
 384         }
 385       else
 386         memcpy(fragP->fr_literal + fragP->fr_fix,
 387                f32_patt[count - 1], count);
 388       fragP->fr_var = count;
 389     }
 390 }
 391
 392 static char *output_invalid PARAMS ((int c));
 393 static int i386_operand PARAMS ((char *operand_string));
 394 static int i386_intel_operand PARAMS ((char *operand_string, int got_a_float));
 395 static const reg_entry *parse_register PARAMS ((char *reg_string,
 396                                                 char **end_op));
 397
 398 #ifndef I386COFF
 399 static void s_bss PARAMS ((int));
 400 #endif
 401
 402 symbolS *GOT_symbol;            /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
 403
 404 static INLINE unsigned int
 405 mode_from_disp_size (t)
 406      unsigned int t;
 407 {
 408   return (t & Disp8) ? 1 : (t & (Disp16|Disp32)) ? 2 : 0;
 409 }
 410
 411 static INLINE int
 412 fits_in_signed_byte (num)
 413      long num;
 414 {
 415   return (num >= -128) && (num <= 127);
 416 }                               /* fits_in_signed_byte() */
 417
 418 static INLINE int
 419 fits_in_unsigned_byte (num)
 420      long num;
 421 {
 422   return (num & 0xff) == num;
 423 }                               /* fits_in_unsigned_byte() */
 424
 425 static INLINE int
 426 fits_in_unsigned_word (num)
 427      long num;
 428 {
 429   return (num & 0xffff) == num;
 430 }                               /* fits_in_unsigned_word() */
 431
 432 static INLINE int
 433 fits_in_signed_word (num)
 434      long num;
 435 {
 436   return (-32768 <= num) && (num <= 32767);
 437 }                               /* fits_in_signed_word() */
 438
 439 static int
 440 smallest_imm_type (num)
 441      long num;
 442 {
 443 #if 0
 444   /* This code is disabled because all the Imm1 forms in the opcode table
 445      are slower on the i486, and they're the versions with the implicitly
 446      specified single-position displacement, which has another syntax if
 447      you really want to use that form.  If you really prefer to have the
 448      one-byte-shorter Imm1 form despite these problems, re-enable this
 449      code.  */
 450   if (num == 1)
 451     return Imm1 | Imm8 | Imm8S | Imm16 | Imm32;
 452 #endif
 453   return (fits_in_signed_byte (num)
 454           ? (Imm8S | Imm8 | Imm16 | Imm32)
 455           : fits_in_unsigned_byte (num)
 456           ? (Imm8 | Imm16 | Imm32)
 457           : (fits_in_signed_word (num) || fits_in_unsigned_word (num))
 458           ? (Imm16 | Imm32)
 459           : (Imm32));
 460 }                               /* smallest_imm_type() */
 461
 462 /* Returns 0 if attempting to add a prefix where one from the same
 463    class already exists, 1 if non rep/repne added, 2 if rep/repne
 464    added.  */
 465 static int
 466 add_prefix (prefix)
 467      unsigned int prefix;
 468 {
 469   int ret = 1;
 470   int q;
 471
 472   switch (prefix)
 473     {
 474     default:
 475       abort ();
 476
 477     case CS_PREFIX_OPCODE:
 478     case DS_PREFIX_OPCODE:
 479     case ES_PREFIX_OPCODE:
 480     case FS_PREFIX_OPCODE:
 481     case GS_PREFIX_OPCODE:
 482     case SS_PREFIX_OPCODE:
 483       q = SEG_PREFIX;
 484       break;
 485
 486     case REPNE_PREFIX_OPCODE:
 487     case REPE_PREFIX_OPCODE:
 488       ret = 2;
 489       /* fall thru */
 490     case LOCK_PREFIX_OPCODE:
 491       q = LOCKREP_PREFIX;
 492       break;
 493
 494     case FWAIT_OPCODE:
 495       q = WAIT_PREFIX;
 496       break;
 497
 498     case ADDR_PREFIX_OPCODE:
 499       q = ADDR_PREFIX;
 500       break;
 501
 502     case DATA_PREFIX_OPCODE:
 503       q = DATA_PREFIX;
 504       break;
 505     }
 506
 507   if (i.prefix[q])
 508     {
 509       as_bad (_("same type of prefix used twice"));
 510       return 0;
 511     }
 512
 513   i.prefixes += 1;
 514   i.prefix[q] = prefix;
 515   return ret;
 516 }
 517
 518 static void
 519 set_16bit_code_flag (new_16bit_code_flag)
 520      int new_16bit_code_flag;
 521 {
 522   flag_16bit_code = new_16bit_code_flag;
 523   stackop_size = '\0';
 524 }
 525
 526 static void
 527 set_16bit_gcc_code_flag (new_16bit_code_flag)
 528      int new_16bit_code_flag;
 529 {
 530   flag_16bit_code = new_16bit_code_flag;
 531   stackop_size = new_16bit_code_flag ? 'l' : '\0';
 532 }
 533
 534 static void
 535 set_intel_syntax (syntax_flag)
 536      int syntax_flag;
 537 {
 538   /* Find out if register prefixing is specified.  */
 539   int ask_naked_reg = 0;
 540
 541   SKIP_WHITESPACE ();
 542   if (! is_end_of_line[(unsigned char) *input_line_pointer])
 543     {
 544       char *string = input_line_pointer;
 545       int e = get_symbol_end ();
 546
 547       if (strcmp(string, "prefix") == 0)
 548         ask_naked_reg = 1;
 549       else if (strcmp(string, "noprefix") == 0)
 550         ask_naked_reg = -1;
 551       else
 552         as_bad (_("Bad argument to syntax directive."));
 553       *input_line_pointer = e;
 554     }
 555   demand_empty_rest_of_line ();
 556
 557   intel_syntax = syntax_flag;
 558
 559   if (ask_naked_reg == 0)
 560     {
 561 #ifdef BFD_ASSEMBLER
 562       allow_naked_reg = (intel_syntax
 563                          && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
 564 #else
 565       allow_naked_reg = 0; /* conservative default */
 566 #endif
 567     }
 568   else
 569     allow_naked_reg = (ask_naked_reg < 0);
 570 }
 571
 572 const pseudo_typeS md_pseudo_table[] =
 573 {
 574 #ifndef I386COFF
 575   {"bss", s_bss, 0},
 576 #endif
 577 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
 578   {"align", s_align_bytes, 0},
 579 #else
 580   {"align", s_align_ptwo, 0},
 581 #endif
 582   {"ffloat", float_cons, 'f'},
 583   {"dfloat", float_cons, 'd'},
 584   {"tfloat", float_cons, 'x'},
 585   {"value", cons, 2},
 586   {"noopt", s_ignore, 0},
 587   {"optim", s_ignore, 0},
 588   {"code16gcc", set_16bit_gcc_code_flag, 1},
 589   {"code16", set_16bit_code_flag, 1},
 590   {"code32", set_16bit_code_flag, 0},
 591   {"intel_syntax", set_intel_syntax, 1},
 592   {"att_syntax", set_intel_syntax, 0},
 593   {0, 0, 0}
 594 };
 595
 596 /* for interface with expression () */
 597 extern char *input_line_pointer;
 598
 599 /* hash table for instruction mnemonic lookup */
 600 static struct hash_control *op_hash;
 601 /* hash table for register lookup */
 602 static struct hash_control *reg_hash;
 603 \f
 604
 605 void
 606 md_begin ()
 607 {
 608   const char *hash_err;
 609
 610   /* initialize op_hash hash table */
 611   op_hash = hash_new ();
 612
 613   {
 614     register const template *optab;
 615     register templates *core_optab;
 616
 617     optab = i386_optab;         /* setup for loop */
 618     core_optab = (templates *) xmalloc (sizeof (templates));
 619     core_optab->start = optab;
 620
 621     while (1)
 622       {
 623         ++optab;
 624         if (optab->name == NULL
 625             || strcmp (optab->name, (optab - 1)->name) != 0)
 626           {
 627             /* different name --> ship out current template list;
 628                add to hash table; & begin anew */
 629             core_optab->end = optab;
 630             hash_err = hash_insert (op_hash,
 631                                     (optab - 1)->name,
 632                                     (PTR) core_optab);
 633             if (hash_err)
 634               {
 635               hash_error:
 636                 as_fatal (_("Internal Error:  Can't hash %s: %s"),
 637                           (optab - 1)->name,
 638                           hash_err);
 639               }
 640             if (optab->name == NULL)
 641               break;
 642             core_optab = (templates *) xmalloc (sizeof (templates));
 643             core_optab->start = optab;
 644           }
 645       }
 646   }
 647
 648   /* initialize reg_hash hash table */
 649   reg_hash = hash_new ();
 650   {
 651     register const reg_entry *regtab;
 652
 653     for (regtab = i386_regtab;
 654          regtab < i386_regtab + sizeof (i386_regtab) / sizeof (i386_regtab[0]);
 655          regtab++)
 656       {
 657         hash_err = hash_insert (reg_hash, regtab->reg_name, (PTR) regtab);
 658         if (hash_err)
 659           goto hash_error;
 660       }
 661   }
 662
 663   /* fill in lexical tables:  mnemonic_chars, operand_chars.  */
 664   {
 665     register int c;
 666     register char *p;
 667
 668     for (c = 0; c < 256; c++)
 669       {
 670         if (isdigit (c))
 671           {
 672             digit_chars[c] = c;
 673             mnemonic_chars[c] = c;
 674             register_chars[c] = c;
 675             operand_chars[c] = c;
 676           }
 677         else if (islower (c))
 678           {
 679             mnemonic_chars[c] = c;
 680             register_chars[c] = c;
 681             operand_chars[c] = c;
 682           }
 683         else if (isupper (c))
 684           {
 685             mnemonic_chars[c] = tolower (c);
 686             register_chars[c] = mnemonic_chars[c];
 687             operand_chars[c] = c;
 688           }
 689
 690         if (isalpha (c) || isdigit (c))
 691           identifier_chars[c] = c;
 692         else if (c >= 128)
 693           {
 694             identifier_chars[c] = c;
 695             operand_chars[c] = c;
 696           }
 697       }
 698
 699 #ifdef LEX_AT
 700     identifier_chars['@'] = '@';
 701 #endif
 702     digit_chars['-'] = '-';
 703     identifier_chars['_'] = '_';
 704     identifier_chars['.'] = '.';
 705
 706     for (p = operand_special_chars; *p != '\0'; p++)
 707       operand_chars[(unsigned char) *p] = *p;
 708   }
 709
 710 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 711   if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
 712     {
 713       record_alignment (text_section, 2);
 714       record_alignment (data_section, 2);
 715       record_alignment (bss_section, 2);
 716     }
 717 #endif
 718 }
 719
 720 void
 721 i386_print_statistics (file)
 722      FILE *file;
 723 {
 724   hash_print_statistics (file, "i386 opcode", op_hash);
 725   hash_print_statistics (file, "i386 register", reg_hash);
 726 }
 727 \f
 728
 729 #ifdef DEBUG386
 730
 731 /* debugging routines for md_assemble */
 732 static void pi PARAMS ((char *, i386_insn *));
 733 static void pte PARAMS ((template *));
 734 static void pt PARAMS ((unsigned int));
 735 static void pe PARAMS ((expressionS *));
 736 static void ps PARAMS ((symbolS *));
 737
 738 static void
 739 pi (line, x)
 740      char *line;
 741      i386_insn *x;
 742 {
 743   register template *p;
 744   int i;
 745
 746   fprintf (stdout, "%s: template ", line);
 747   pte (&x->tm);
 748   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x",
 749            x->rm.mode, x->rm.reg, x->rm.regmem);
 750   fprintf (stdout, " base %x  index %x  scale %x\n",
 751            x->bi.base, x->bi.index, x->bi.scale);
 752   for (i = 0; i < x->operands; i++)
 753     {
 754       fprintf (stdout, "    #%d:  ", i + 1);
 755       pt (x->types[i]);
 756       fprintf (stdout, "\n");
 757       if (x->types[i]
 758           & (Reg | SReg2 | SReg3 | Control | Debug | Test | RegMMX | RegXMM))
 759         fprintf (stdout, "%s\n", x->op[i].regs->reg_name);
 760       if (x->types[i] & Imm)
 761         pe (x->op[i].imms);
 762       if (x->types[i] & Disp)
 763         pe (x->op[i].disps);
 764     }
 765 }
 766
 767 static void
 768 pte (t)
 769      template *t;
 770 {
 771   int i;
 772   fprintf (stdout, " %d operands ", t->operands);
 773   fprintf (stdout, "opcode %x ",
 774            t->base_opcode);
 775   if (t->extension_opcode != None)
 776     fprintf (stdout, "ext %x ", t->extension_opcode);
 777   if (t->opcode_modifier & D)
 778     fprintf (stdout, "D");
 779   if (t->opcode_modifier & W)
 780     fprintf (stdout, "W");
 781   fprintf (stdout, "\n");
 782   for (i = 0; i < t->operands; i++)
 783     {
 784       fprintf (stdout, "    #%d type ", i + 1);
 785       pt (t->operand_types[i]);
 786       fprintf (stdout, "\n");
 787     }
 788 }
 789
 790 static void
 791 pe (e)
 792      expressionS *e;
 793 {
 794   fprintf (stdout, "    operation     %d\n", e->X_op);
 795   fprintf (stdout, "    add_number    %ld (%lx)\n",
 796            (long) e->X_add_number, (long) e->X_add_number);
 797   if (e->X_add_symbol)
 798     {
 799       fprintf (stdout, "    add_symbol    ");
 800       ps (e->X_add_symbol);
 801       fprintf (stdout, "\n");
 802     }
 803   if (e->X_op_symbol)
 804     {
 805       fprintf (stdout, "    op_symbol    ");
 806       ps (e->X_op_symbol);
 807       fprintf (stdout, "\n");
 808     }
 809 }
 810
 811 static void
 812 ps (s)
 813      symbolS *s;
 814 {
 815   fprintf (stdout, "%s type %s%s",
 816            S_GET_NAME (s),
 817            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
 818            segment_name (S_GET_SEGMENT (s)));
 819 }
 820
 821 struct type_name
 822   {
 823     unsigned int mask;
 824     char *tname;
 825   }
 826
 827 type_names[] =
 828 {
 829   { Reg8, "r8" },
 830   { Reg16, "r16" },
 831   { Reg32, "r32" },
 832   { Imm8, "i8" },
 833   { Imm8S, "i8s" },
 834   { Imm16, "i16" },
 835   { Imm32, "i32" },
 836   { Imm1, "i1" },
 837   { BaseIndex, "BaseIndex" },
 838   { Disp8, "d8" },
 839   { Disp16, "d16" },
 840   { Disp32, "d32" },
 841   { InOutPortReg, "InOutPortReg" },
 842   { ShiftCount, "ShiftCount" },
 843   { Control, "control reg" },
 844   { Test, "test reg" },
 845   { Debug, "debug reg" },
 846   { FloatReg, "FReg" },
 847   { FloatAcc, "FAcc" },
 848   { SReg2, "SReg2" },
 849   { SReg3, "SReg3" },
 850   { Acc, "Acc" },
 851   { JumpAbsolute, "Jump Absolute" },
 852   { RegMMX, "rMMX" },
 853   { RegXMM, "rXMM" },
 854   { EsSeg, "es" },
 855   { 0, "" }
 856 };
 857
 858 static void
 859 pt (t)
 860      unsigned int t;
 861 {
 862   register struct type_name *ty;
 863
 864   if (t == Unknown)
 865     {
 866       fprintf (stdout, _("Unknown"));
 867     }
 868   else
 869     {
 870       for (ty = type_names; ty->mask; ty++)
 871         if (t & ty->mask)
 872           fprintf (stdout, "%s, ", ty->tname);
 873     }
 874   fflush (stdout);
 875 }
 876
 877 #endif /* DEBUG386 */
 878 \f
 879 int
 880 tc_i386_force_relocation (fixp)
 881      struct fix *fixp;
 882 {
 883 #ifdef BFD_ASSEMBLER
 884   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
 885       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
 886     return 1;
 887   return 0;
 888 #else
 889   /* For COFF */
 890   return fixp->fx_r_type == 7;
 891 #endif
 892 }
 893
 894 #ifdef BFD_ASSEMBLER
 895 static bfd_reloc_code_real_type reloc
 896   PARAMS ((int, int, bfd_reloc_code_real_type));
 897
 898 static bfd_reloc_code_real_type
 899 reloc (size, pcrel, other)
 900      int size;
 901      int pcrel;
 902      bfd_reloc_code_real_type other;
 903 {
 904   if (other != NO_RELOC) return other;
 905
 906   if (pcrel)
 907     {
 908       switch (size)
 909         {
 910         case 1: return BFD_RELOC_8_PCREL;
 911         case 2: return BFD_RELOC_16_PCREL;
 912         case 4: return BFD_RELOC_32_PCREL;
 913         }
 914       as_bad (_("Can not do %d byte pc-relative relocation"), size);
 915     }
 916   else
 917     {
 918       switch (size)
 919         {
 920         case 1: return BFD_RELOC_8;
 921         case 2: return BFD_RELOC_16;
 922         case 4: return BFD_RELOC_32;
 923         }
 924       as_bad (_("Can not do %d byte relocation"), size);
 925     }
 926
 927   return BFD_RELOC_NONE;
 928 }
 929
 930 /*
 931  * Here we decide which fixups can be adjusted to make them relative to
 932  * the beginning of the section instead of the symbol.  Basically we need
 933  * to make sure that the dynamic relocations are done correctly, so in
 934  * some cases we force the original symbol to be used.
 935  */
 936 int
 937 tc_i386_fix_adjustable (fixP)
 938      fixS *fixP;
 939 {
 940 #if defined (OBJ_ELF) || defined (TE_PE)
 941   /* Prevent all adjustments to global symbols, or else dynamic
 942      linking will not work correctly.  */
 943   if (S_IS_EXTERN (fixP->fx_addsy))
 944     return 0;
 945   if (S_IS_WEAK (fixP->fx_addsy))
 946     return 0;
 947 #endif
 948   /* adjust_reloc_syms doesn't know about the GOT */
 949   if (fixP->fx_r_type == BFD_RELOC_386_GOTOFF
 950       || fixP->fx_r_type == BFD_RELOC_386_PLT32
 951       || fixP->fx_r_type == BFD_RELOC_386_GOT32
 952       || fixP->fx_r_type == BFD_RELOC_RVA
 953       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
 954       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
 955     return 0;
 956   return 1;
 957 }
 958 #else
 959 #define reloc(SIZE,PCREL,OTHER) 0
 960 #define BFD_RELOC_16            0
 961 #define BFD_RELOC_32            0
 962 #define BFD_RELOC_16_PCREL      0
 963 #define BFD_RELOC_32_PCREL      0
 964 #define BFD_RELOC_386_PLT32     0
 965 #define BFD_RELOC_386_GOT32     0
 966 #define BFD_RELOC_386_GOTOFF    0
 967 #endif
 968
 969 static int
 970 intel_float_operand PARAMS ((char *mnemonic));
 971
 972 static int
 973 intel_float_operand (mnemonic)
 974      char *mnemonic;
 975 {
 976   if (mnemonic[0] == 'f' && mnemonic[1] =='i')
 977     return 0;
 978
 979   if (mnemonic[0] == 'f')
 980     return 1;
 981
 982   return 0;
 983 }
 984
 985 /* This is the guts of the machine-dependent assembler.  LINE points to a
 986    machine dependent instruction.  This function is supposed to emit
 987    the frags/bytes it assembles to.  */
 988
 989 void
 990 md_assemble (line)
 991      char *line;
 992 {
 993   /* Points to template once we've found it. */
 994   const template *t;
 995
 996   /* Count the size of the instruction generated.  */
 997   int insn_size = 0;
 998
 999   int j;
1000
1001   char mnemonic[MAX_MNEM_SIZE];
1002
1003   /* Initialize globals. */
1004   memset (&i, '\0', sizeof (i));
1005   for (j = 0; j < MAX_OPERANDS; j++)
1006     i.disp_reloc[j] = NO_RELOC;
1007   memset (disp_expressions, '\0', sizeof (disp_expressions));
1008   memset (im_expressions, '\0', sizeof (im_expressions));
1009   save_stack_p = save_stack;    /* reset stack pointer */
1010
1011   /* First parse an instruction mnemonic & call i386_operand for the operands.
1012      We assume that the scrubber has arranged it so that line[0] is the valid
1013      start of a (possibly prefixed) mnemonic. */
1014   {
1015     char *l = line;
1016     char *token_start = l;
1017     char *mnem_p;
1018
1019     /* Non-zero if we found a prefix only acceptable with string insns. */
1020     const char *expecting_string_instruction = NULL;
1021
1022     while (1)
1023       {
1024         mnem_p = mnemonic;
1025         while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
1026           {
1027             mnem_p++;
1028             if (mnem_p >= mnemonic + sizeof (mnemonic))
1029               {
1030                 as_bad (_("no such 386 instruction: `%s'"), token_start);
1031                 return;
1032               }
1033             l++;
1034           }
1035         if (!is_space_char (*l)
1036             && *l != END_OF_INSN
1037             && *l != PREFIX_SEPARATOR)
1038           {
1039             as_bad (_("invalid character %s in mnemonic"),
1040                     output_invalid (*l));
1041             return;
1042           }
1043         if (token_start == l)
1044           {
1045             if (*l == PREFIX_SEPARATOR)
1046               as_bad (_("expecting prefix; got nothing"));
1047             else
1048               as_bad (_("expecting mnemonic; got nothing"));
1049             return;
1050           }
1051
1052         /* Look up instruction (or prefix) via hash table.  */
1053         current_templates = hash_find (op_hash, mnemonic);
1054
1055         if (*l != END_OF_INSN
1056             && (! is_space_char (*l) || l[1] != END_OF_INSN)
1057             && current_templates
1058             && (current_templates->start->opcode_modifier & IsPrefix))
1059           {
1060             /* If we are in 16-bit mode, do not allow addr16 or data16.
1061                Similarly, in 32-bit mode, do not allow addr32 or data32.  */
1062             if ((current_templates->start->opcode_modifier & (Size16 | Size32))
1063                 && (((current_templates->start->opcode_modifier & Size32) != 0)
1064                     ^ flag_16bit_code))
1065               {
1066                 as_bad (_("redundant %s prefix"),
1067                         current_templates->start->name);
1068                 return;
1069               }
1070             /* Add prefix, checking for repeated prefixes.  */
1071             switch (add_prefix (current_templates->start->base_opcode))
1072               {
1073               case 0:
1074                 return;
1075               case 2:
1076                 expecting_string_instruction =
1077                   current_templates->start->name;
1078                 break;
1079               }
1080             /* Skip past PREFIX_SEPARATOR and reset token_start.  */
1081             token_start = ++l;
1082           }
1083         else
1084           break;
1085       }
1086
1087     if (!current_templates)
1088       {
1089         /* See if we can get a match by trimming off a suffix.  */
1090         switch (mnem_p[-1])
1091           {
1092           case WORD_MNEM_SUFFIX:
1093           case BYTE_MNEM_SUFFIX:
1094           case SHORT_MNEM_SUFFIX:
1095           case LONG_MNEM_SUFFIX:
1096             i.suffix = mnem_p[-1];
1097             mnem_p[-1] = '\0';
1098             current_templates = hash_find (op_hash, mnemonic);
1099             break;
1100
1101           /* Intel Syntax */
1102           case DWORD_MNEM_SUFFIX:
1103             if (intel_syntax)
1104               {
1105                 i.suffix = mnem_p[-1];
1106                 mnem_p[-1] = '\0';
1107                 current_templates = hash_find (op_hash, mnemonic);
1108                 break;
1109               }
1110           }
1111         if (!current_templates)
1112           {
1113             as_bad (_("no such 386 instruction: `%s'"), token_start);
1114             return;
1115           }
1116       }
1117
1118     /* check for rep/repne without a string instruction */
1119     if (expecting_string_instruction
1120         && !(current_templates->start->opcode_modifier & IsString))
1121       {
1122         as_bad (_("expecting string instruction after `%s'"),
1123                 expecting_string_instruction);
1124         return;
1125       }
1126
1127     /* There may be operands to parse. */
1128     if (*l != END_OF_INSN)
1129       {
1130         /* parse operands */
1131
1132         /* 1 if operand is pending after ','. */
1133         unsigned int expecting_operand = 0;
1134
1135         /* Non-zero if operand parens not balanced. */
1136         unsigned int paren_not_balanced;
1137
1138         do
1139           {
1140             /* skip optional white space before operand */
1141             if (is_space_char (*l))
1142               ++l;
1143             if (!is_operand_char (*l) && *l != END_OF_INSN)
1144               {
1145                 as_bad (_("invalid character %s before operand %d"),
1146                         output_invalid (*l),
1147                         i.operands + 1);
1148                 return;
1149               }
1150             token_start = l;    /* after white space */
1151             paren_not_balanced = 0;
1152             while (paren_not_balanced || *l != ',')
1153               {
1154                 if (*l == END_OF_INSN)
1155                   {
1156                     if (paren_not_balanced)
1157                       {
1158                         if (!intel_syntax)
1159                           as_bad (_("unbalanced parenthesis in operand %d."),
1160                                   i.operands + 1);
1161                         else
1162                           as_bad (_("unbalanced brackets in operand %d."),
1163                                   i.operands + 1);
1164                         return;
1165                       }
1166                     else
1167                       break;    /* we are done */
1168                   }
1169                 else if (!is_operand_char (*l) && !is_space_char (*l))
1170                   {
1171                     as_bad (_("invalid character %s in operand %d"),
1172                             output_invalid (*l),
1173                             i.operands + 1);
1174                     return;
1175                   }
1176                 if (!intel_syntax)
1177                   {
1178                     if (*l == '(')
1179                       ++paren_not_balanced;
1180                     if (*l == ')')
1181                       --paren_not_balanced;
1182                   }
1183                 else
1184                   {
1185                     if (*l == '[')
1186                       ++paren_not_balanced;
1187                     if (*l == ']')
1188                       --paren_not_balanced;
1189                   }
1190                 l++;
1191               }
1192             if (l != token_start)
1193               {                 /* yes, we've read in another operand */
1194                 unsigned int operand_ok;
1195                 this_operand = i.operands++;
1196                 if (i.operands > MAX_OPERANDS)
1197                   {
1198                     as_bad (_("spurious operands; (%d operands/instruction max)"),
1199                             MAX_OPERANDS);
1200                     return;
1201                   }
1202                 /* now parse operand adding info to 'i' as we go along */
1203                 END_STRING_AND_SAVE (l);
1204
1205                 if (intel_syntax)
1206                   operand_ok = i386_intel_operand (token_start, intel_float_operand (mnemonic));
1207                 else
1208                   operand_ok = i386_operand (token_start);
1209
1210                 RESTORE_END_STRING (l); /* restore old contents */
1211                 if (!operand_ok)
1212                   return;
1213               }
1214             else
1215               {
1216                 if (expecting_operand)
1217                   {
1218                   expecting_operand_after_comma:
1219                     as_bad (_("expecting operand after ','; got nothing"));
1220                     return;
1221                   }
1222                 if (*l == ',')
1223                   {
1224                     as_bad (_("expecting operand before ','; got nothing"));
1225                     return;
1226                   }
1227               }
1228
1229             /* now *l must be either ',' or END_OF_INSN */
1230             if (*l == ',')
1231               {
1232                 if (*++l == END_OF_INSN)
1233                   {             /* just skip it, if it's \n complain */
1234                     goto expecting_operand_after_comma;
1235                   }
1236                 expecting_operand = 1;
1237               }
1238           }
1239         while (*l != END_OF_INSN);      /* until we get end of insn */
1240       }
1241   }
1242
1243   /* Now we've parsed the mnemonic into a set of templates, and have the
1244      operands at hand.
1245
1246      Next, we find a template that matches the given insn,
1247      making sure the overlap of the given operands types is consistent
1248      with the template operand types. */
1249
1250 #define MATCH(overlap, given, template) \
1251   ((overlap & ~JumpAbsolute) \
1252    && ((given) & (BaseIndex|JumpAbsolute)) == ((overlap) & (BaseIndex|JumpAbsolute)))
1253
1254   /* If given types r0 and r1 are registers they must be of the same type
1255      unless the expected operand type register overlap is null.
1256      Note that Acc in a template matches every size of reg.  */
1257 #define CONSISTENT_REGISTER_MATCH(m0, g0, t0, m1, g1, t1) \
1258   ( ((g0) & Reg) == 0 || ((g1) & Reg) == 0 || \
1259     ((g0) & Reg) == ((g1) & Reg) || \
1260     ((((m0) & Acc) ? Reg : (t0)) & (((m1) & Acc) ? Reg : (t1)) & Reg) == 0 )
1261
1262   {
1263     register unsigned int overlap0, overlap1;
1264     unsigned int overlap2;
1265     unsigned int found_reverse_match;
1266     int suffix_check;
1267
1268     /* All intel opcodes have reversed operands except for BOUND and ENTER */
1269     if (intel_syntax && i.operands > 1
1270         && (strcmp (mnemonic, "enter") != 0)
1271         && (strcmp (mnemonic, "bound") != 0))
1272       {
1273         union i386_op temp_op;
1274         unsigned int temp_type;
1275         int xchg1 = 0;
1276         int xchg2 = 0;
1277
1278         if (i.operands == 2)
1279           {
1280             xchg1 = 0;
1281             xchg2 = 1;
1282           }
1283         else if (i.operands == 3)
1284           {
1285             xchg1 = 0;
1286             xchg2 = 2;
1287           }
1288         temp_type = i.types[xchg2];
1289         i.types[xchg2] = i.types[xchg1];
1290         i.types[xchg1] = temp_type;
1291         temp_op = i.op[xchg2];
1292         i.op[xchg2] = i.op[xchg1];
1293         i.op[xchg1] = temp_op;
1294       }
1295     overlap0 = 0;
1296     overlap1 = 0;
1297     overlap2 = 0;
1298     found_reverse_match = 0;
1299     suffix_check = (i.suffix == BYTE_MNEM_SUFFIX
1300                     ? No_bSuf
1301                     : (i.suffix == WORD_MNEM_SUFFIX
1302                        ? No_wSuf
1303                        : (i.suffix == SHORT_MNEM_SUFFIX
1304                           ? No_sSuf
1305                           : (i.suffix == LONG_MNEM_SUFFIX
1306                              ? No_lSuf
1307                              : (i.suffix == DWORD_MNEM_SUFFIX
1308                                 ? No_dSuf
1309                                 : (i.suffix == LONG_DOUBLE_MNEM_SUFFIX ? No_xSuf : 0))))));
1310
1311     for (t = current_templates->start;
1312          t < current_templates->end;
1313          t++)
1314       {
1315         /* Must have right number of operands. */
1316         if (i.operands != t->operands)
1317           continue;
1318
1319         /* Check the suffix, except for some instructions in intel mode.  */
1320         if ((t->opcode_modifier & suffix_check)
1321             && !(intel_syntax
1322                  && t->base_opcode == 0xd9
1323                  && (t->extension_opcode == 5   /* 0xd9,5 "fldcw"  */
1324                      || t->extension_opcode == 7))) /* 0xd9,7 "f{n}stcw"  */
1325           continue;
1326
1327         else if (!t->operands)
1328           break;                /* 0 operands always matches */
1329
1330         overlap0 = i.types[0] & t->operand_types[0];
1331         switch (t->operands)
1332           {
1333           case 1:
1334             if (!MATCH (overlap0, i.types[0], t->operand_types[0]))
1335               continue;
1336             break;
1337           case 2:
1338           case 3:
1339             overlap1 = i.types[1] & t->operand_types[1];
1340             if (!MATCH (overlap0, i.types[0], t->operand_types[0])
1341                 || !MATCH (overlap1, i.types[1], t->operand_types[1])
1342                 || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
1343                                                t->operand_types[0],
1344                                                overlap1, i.types[1],
1345                                                t->operand_types[1]))
1346               {
1347
1348                 /* check if other direction is valid ... */
1349                 if ((t->opcode_modifier & (D|FloatD)) == 0)
1350                   continue;
1351
1352                 /* try reversing direction of operands */
1353                 overlap0 = i.types[0] & t->operand_types[1];
1354                 overlap1 = i.types[1] & t->operand_types[0];
1355                 if (!MATCH (overlap0, i.types[0], t->operand_types[1])
1356                     || !MATCH (overlap1, i.types[1], t->operand_types[0])
1357                     || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
1358                                                    t->operand_types[1],
1359                                                    overlap1, i.types[1],
1360                                                    t->operand_types[0]))
1361                   {
1362                     /* does not match either direction */
1363                     continue;
1364                   }
1365                 /* found_reverse_match holds which of D or FloatDR
1366                    we've found.  */
1367                 found_reverse_match = t->opcode_modifier & (D|FloatDR);
1368                 break;
1369               }
1370             /* found a forward 2 operand match here */
1371             if (t->operands == 3)
1372               {
1373                 /* Here we make use of the fact that there are no
1374                    reverse match 3 operand instructions, and all 3
1375                    operand instructions only need to be checked for
1376                    register consistency between operands 2 and 3.  */
1377                 overlap2 = i.types[2] & t->operand_types[2];
1378                 if (!MATCH (overlap2, i.types[2], t->operand_types[2])
1379                     || !CONSISTENT_REGISTER_MATCH (overlap1, i.types[1],
1380                                                    t->operand_types[1],
1381                                                    overlap2, i.types[2],
1382                                                    t->operand_types[2]))
1383
1384                   continue;
1385               }
1386             /* found either forward/reverse 2 or 3 operand match here:
1387                slip through to break */
1388           }
1389         break;                  /* we've found a match; break out of loop */
1390       }                         /* for (t = ... */
1391     if (t == current_templates->end)
1392       {                         /* we found no match */
1393         as_bad (_("suffix or operands invalid for `%s'"),
1394                 current_templates->start->name);
1395         return;
1396       }
1397
1398     if (!intel_syntax
1399         && (i.types[0] & JumpAbsolute) != (t->operand_types[0] & JumpAbsolute))
1400       {
1401         as_warn (_("Indirect %s without `*'"), t->name);
1402       }
1403
1404     if ((t->opcode_modifier & (IsPrefix|IgnoreSize)) == (IsPrefix|IgnoreSize))
1405       {
1406         /* Warn them that a data or address size prefix doesn't affect
1407            assembly of the next line of code.  */
1408         as_warn (_("stand-alone `%s' prefix"), t->name);
1409       }
1410
1411     /* Copy the template we found.  */
1412     i.tm = *t;
1413     if (found_reverse_match)
1414       {
1415         /* If we found a reverse match we must alter the opcode
1416            direction bit.  found_reverse_match holds bits to change
1417            (different for int & float insns).  */
1418
1419         i.tm.base_opcode ^= found_reverse_match;
1420
1421         i.tm.operand_types[0] = t->operand_types[1];
1422         i.tm.operand_types[1] = t->operand_types[0];
1423       }
1424
1425     /* Undo UNIXWARE_COMPAT brokenness when in Intel mode.  See i386.h  */
1426      if (UNIXWARE_COMPAT
1427          && intel_syntax
1428          && (i.tm.base_opcode & 0xfffffde0) == 0xdce0)
1429        i.tm.base_opcode ^= FloatR;
1430
1431     if (i.tm.opcode_modifier & FWait)
1432       if (! add_prefix (FWAIT_OPCODE))
1433         return;
1434
1435     /* Check string instruction segment overrides */
1436     if ((i.tm.opcode_modifier & IsString) != 0 && i.mem_operands != 0)
1437       {
1438         int mem_op = (i.types[0] & AnyMem) ? 0 : 1;
1439         if ((i.tm.operand_types[mem_op] & EsSeg) != 0)
1440           {
1441             if (i.seg[0] != NULL && i.seg[0] != &es)
1442               {
1443                 as_bad (_("`%s' operand %d must use `%%es' segment"),
1444                         i.tm.name,
1445                         mem_op + 1);
1446                 return;
1447               }
1448             /* There's only ever one segment override allowed per instruction.
1449                This instruction possibly has a legal segment override on the
1450                second operand, so copy the segment to where non-string
1451                instructions store it, allowing common code.  */
1452             i.seg[0] = i.seg[1];
1453           }
1454         else if ((i.tm.operand_types[mem_op + 1] & EsSeg) != 0)
1455           {
1456             if (i.seg[1] != NULL && i.seg[1] != &es)
1457               {
1458                 as_bad (_("`%s' operand %d must use `%%es' segment"),
1459                         i.tm.name,
1460                         mem_op + 2);
1461                 return;
1462               }
1463           }
1464       }
1465
1466     /* If matched instruction specifies an explicit instruction mnemonic
1467        suffix, use it.  */
1468     if (i.tm.opcode_modifier & (Size16 | Size32))
1469       {
1470         if (i.tm.opcode_modifier & Size16)
1471           i.suffix = WORD_MNEM_SUFFIX;
1472         else
1473           i.suffix = LONG_MNEM_SUFFIX;
1474       }
1475     else if (i.reg_operands)
1476       {
1477         /* If there's no instruction mnemonic suffix we try to invent one
1478            based on register operands. */
1479         if (!i.suffix)
1480           {
1481             /* We take i.suffix from the last register operand specified,
1482                Destination register type is more significant than source
1483                register type.  */
1484             int op;
1485             for (op = i.operands; --op >= 0; )
1486               if (i.types[op] & Reg)
1487                 {
1488                   i.suffix = ((i.types[op] & Reg8) ? BYTE_MNEM_SUFFIX :
1489                               (i.types[op] & Reg16) ? WORD_MNEM_SUFFIX :
1490                               LONG_MNEM_SUFFIX);
1491                   break;
1492                 }
1493           }
1494         else if (i.suffix == BYTE_MNEM_SUFFIX)
1495           {
1496             int op;
1497             for (op = i.operands; --op >= 0; )
1498               {
1499                 /* If this is an eight bit register, it's OK.  If it's
1500                    the 16 or 32 bit version of an eight bit register,
1501                    we will just use the low portion, and that's OK too. */
1502                 if (i.types[op] & Reg8)
1503                   continue;
1504
1505                 /* movzx and movsx should not generate this warning. */
1506                 if (intel_syntax
1507                     && (i.tm.base_opcode == 0xfb7
1508                         || i.tm.base_opcode == 0xfb6
1509                         || i.tm.base_opcode == 0xfbe
1510                         || i.tm.base_opcode == 0xfbf))
1511                   continue;
1512
1513                 if ((i.types[op] & WordReg) && i.op[op].regs->reg_num < 4
1514 #if 0
1515                     /* Check that the template allows eight bit regs
1516                        This kills insns such as `orb $1,%edx', which
1517                        maybe should be allowed.  */
1518                     && (i.tm.operand_types[op] & (Reg8|InOutPortReg))
1519 #endif
1520                     )
1521                   {
1522 #if REGISTER_WARNINGS
1523                     if ((i.tm.operand_types[op] & InOutPortReg) == 0)
1524                       as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
1525                                (i.op[op].regs - (i.types[op] & Reg16 ? 8 : 16))->reg_name,
1526                                i.op[op].regs->reg_name,
1527                                i.suffix);
1528 #endif
1529                     continue;
1530                   }
1531                 /* Any other register is bad */
1532                 if (i.types[op] & (Reg | RegMMX | RegXMM
1533                                    | SReg2 | SReg3
1534                                    | Control | Debug | Test
1535                                    | FloatReg | FloatAcc))
1536                   {
1537                     as_bad (_("`%%%s' not allowed with `%s%c'"),
1538                             i.op[op].regs->reg_name,
1539                             i.tm.name,
1540                             i.suffix);
1541                     return;
1542                   }
1543               }
1544           }
1545         else if (i.suffix == LONG_MNEM_SUFFIX)
1546           {
1547             int op;
1548             for (op = i.operands; --op >= 0; )
1549               /* Reject eight bit registers, except where the template
1550                  requires them. (eg. movzb)  */
1551               if ((i.types[op] & Reg8) != 0
1552                   && (i.tm.operand_types[op] & (Reg16|Reg32|Acc)) != 0)
1553                 {
1554                   as_bad (_("`%%%s' not allowed with `%s%c'"),
1555                           i.op[op].regs->reg_name,
1556                           i.tm.name,
1557                           i.suffix);
1558                   return;
1559                 }
1560 #if REGISTER_WARNINGS
1561               /* Warn if the e prefix on a general reg is missing.  */
1562               else if ((i.types[op] & Reg16) != 0
1563                        && (i.tm.operand_types[op] & (Reg32|Acc)) != 0)
1564                 {
1565                   as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
1566                            (i.op[op].regs + 8)->reg_name,
1567                            i.op[op].regs->reg_name,
1568                            i.suffix);
1569                 }
1570 #endif
1571           }
1572         else if (i.suffix == WORD_MNEM_SUFFIX)
1573           {
1574             int op;
1575             for (op = i.operands; --op >= 0; )
1576               /* Reject eight bit registers, except where the template
1577                  requires them. (eg. movzb)  */
1578               if ((i.types[op] & Reg8) != 0
1579                   && (i.tm.operand_types[op] & (Reg16|Reg32|Acc)) != 0)
1580                 {
1581                   as_bad (_("`%%%s' not allowed with `%s%c'"),
1582                           i.op[op].regs->reg_name,
1583                           i.tm.name,
1584                           i.suffix);
1585                   return;
1586                 }
1587 #if REGISTER_WARNINGS
1588               /* Warn if the e prefix on a general reg is present.  */
1589               else if ((i.types[op] & Reg32) != 0
1590                        && (i.tm.operand_types[op] & (Reg16|Acc)) != 0)
1591                 {
1592                   as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
1593                            (i.op[op].regs - 8)->reg_name,
1594                            i.op[op].regs->reg_name,
1595                            i.suffix);
1596                 }
1597 #endif
1598           }
1599         else
1600           abort();
1601       }
1602     else if ((i.tm.opcode_modifier & DefaultSize) && !i.suffix)
1603       {
1604         i.suffix = stackop_size;
1605       }
1606
1607     /* Make still unresolved immediate matches conform to size of immediate
1608        given in i.suffix.  Note: overlap2 cannot be an immediate!  */
1609     if ((overlap0 & (Imm8 | Imm8S | Imm16 | Imm32))
1610         && overlap0 != Imm8 && overlap0 != Imm8S
1611         && overlap0 != Imm16 && overlap0 != Imm32)
1612       {
1613         if (i.suffix)
1614           {
1615             overlap0 &= (i.suffix == BYTE_MNEM_SUFFIX ? (Imm8 | Imm8S) :
1616                          (i.suffix == WORD_MNEM_SUFFIX ? Imm16 : Imm32));
1617           }
1618         else if (overlap0 == (Imm16 | Imm32))
1619           {
1620             overlap0 =
1621               (flag_16bit_code ^ (i.prefix[DATA_PREFIX] != 0)) ? Imm16 : Imm32;
1622           }
1623         else
1624           {
1625             as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
1626             return;
1627           }
1628       }
1629     if ((overlap1 & (Imm8 | Imm8S | Imm16 | Imm32))
1630         && overlap1 != Imm8 && overlap1 != Imm8S
1631         && overlap1 != Imm16 && overlap1 != Imm32)
1632       {
1633         if (i.suffix)
1634           {
1635             overlap1 &= (i.suffix == BYTE_MNEM_SUFFIX ? (Imm8 | Imm8S) :
1636                          (i.suffix == WORD_MNEM_SUFFIX ? Imm16 : Imm32));
1637           }
1638         else if (overlap1 == (Imm16 | Imm32))
1639           {
1640             overlap1 =
1641               (flag_16bit_code ^ (i.prefix[DATA_PREFIX] != 0)) ? Imm16 : Imm32;
1642           }
1643         else
1644           {
1645             as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
1646             return;
1647           }
1648       }
1649     assert ((overlap2 & Imm) == 0);
1650
1651     i.types[0] = overlap0;
1652     if (overlap0 & ImplicitRegister)
1653       i.reg_operands--;
1654     if (overlap0 & Imm1)
1655       i.imm_operands = 0;       /* kludge for shift insns */
1656
1657     i.types[1] = overlap1;
1658     if (overlap1 & ImplicitRegister)
1659       i.reg_operands--;
1660
1661     i.types[2] = overlap2;
1662     if (overlap2 & ImplicitRegister)
1663       i.reg_operands--;
1664
1665     /* Finalize opcode.  First, we change the opcode based on the operand
1666        size given by i.suffix:  We need not change things for byte insns.  */
1667
1668     if (!i.suffix && (i.tm.opcode_modifier & W))
1669       {
1670         as_bad (_("no instruction mnemonic suffix given and no register operands; can't size instruction"));
1671         return;
1672       }
1673
1674     /* For movzx and movsx, need to check the register type */
1675     if (intel_syntax
1676         && (i.tm.base_opcode == 0xfb6 || i.tm.base_opcode == 0xfbe))
1677       if (i.suffix && i.suffix == BYTE_MNEM_SUFFIX)
1678         {
1679           unsigned int prefix = DATA_PREFIX_OPCODE;
1680
1681           if ((i.op[1].regs->reg_type & Reg16) != 0)
1682             if (!add_prefix (prefix))
1683               return;
1684         }
1685
1686     if (i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
1687       {
1688         /* It's not a byte, select word/dword operation.  */
1689         if (i.tm.opcode_modifier & W)
1690           {
1691             if (i.tm.opcode_modifier & ShortForm)
1692               i.tm.base_opcode |= 8;
1693             else
1694               i.tm.base_opcode |= 1;
1695           }
1696         /* Now select between word & dword operations via the operand
1697            size prefix, except for instructions that will ignore this
1698            prefix anyway.  */
1699         if (((intel_syntax && (i.suffix == DWORD_MNEM_SUFFIX))
1700              || i.suffix == LONG_MNEM_SUFFIX) == flag_16bit_code
1701             && !(i.tm.opcode_modifier & IgnoreSize))
1702           {
1703             unsigned int prefix = DATA_PREFIX_OPCODE;
1704             if (i.tm.opcode_modifier & JumpByte) /* jcxz, loop */
1705               prefix = ADDR_PREFIX_OPCODE;
1706
1707             if (! add_prefix (prefix))
1708               return;
1709           }
1710         /* Size floating point instruction.  */
1711         if (i.suffix == LONG_MNEM_SUFFIX
1712             || (intel_syntax && i.suffix == DWORD_MNEM_SUFFIX))
1713           {
1714             if (i.tm.opcode_modifier & FloatMF)
1715               i.tm.base_opcode ^= 4;
1716           }
1717       }
1718
1719     if (i.tm.opcode_modifier & ImmExt)
1720       {
1721         /* These AMD 3DNow! and Intel Katmai New Instructions have an
1722            opcode suffix which is coded in the same place as an 8-bit
1723            immediate field would be.  Here we fake an 8-bit immediate
1724            operand from the opcode suffix stored in tm.extension_opcode.  */
1725
1726         expressionS *exp;
1727
1728         assert(i.imm_operands == 0 && i.operands <= 2 && 2 < MAX_OPERANDS);
1729
1730         exp = &im_expressions[i.imm_operands++];
1731         i.op[i.operands].imms = exp;
1732         i.types[i.operands++] = Imm8;
1733         exp->X_op = O_constant;
1734         exp->X_add_number = i.tm.extension_opcode;
1735         i.tm.extension_opcode = None;
1736       }
1737
1738     /* For insns with operands there are more diddles to do to the opcode. */
1739     if (i.operands)
1740       {
1741         /* Default segment register this instruction will use
1742            for memory accesses.  0 means unknown.
1743            This is only for optimizing out unnecessary segment overrides.  */
1744         const seg_entry *default_seg = 0;
1745
1746         /* The imul $imm, %reg instruction is converted into
1747            imul $imm, %reg, %reg, and the clr %reg instruction
1748            is converted into xor %reg, %reg.  */
1749         if (i.tm.opcode_modifier & regKludge)
1750           {
1751             unsigned int first_reg_op = (i.types[0] & Reg) ? 0 : 1;
1752             /* Pretend we saw the extra register operand. */
1753             assert (i.op[first_reg_op+1].regs == 0);
1754             i.op[first_reg_op+1].regs = i.op[first_reg_op].regs;
1755             i.types[first_reg_op+1] = i.types[first_reg_op];
1756             i.reg_operands = 2;
1757           }
1758
1759         if (i.tm.opcode_modifier & ShortForm)
1760           {
1761             /* The register or float register operand is in operand 0 or 1. */
1762             unsigned int op = (i.types[0] & (Reg | FloatReg)) ? 0 : 1;
1763             /* Register goes in low 3 bits of opcode. */
1764             i.tm.base_opcode |= i.op[op].regs->reg_num;
1765             if ((i.tm.opcode_modifier & Ugh) != 0)
1766               {
1767                 /* Warn about some common errors, but press on regardless.
1768                    The first case can be generated by gcc (<= 2.8.1).  */
1769                 if (i.operands == 2)
1770                   {
1771                     /* reversed arguments on faddp, fsubp, etc. */
1772                     as_warn (_("translating to `%s %%%s,%%%s'"), i.tm.name,
1773                              i.op[1].regs->reg_name,
1774                              i.op[0].regs->reg_name);
1775                   }
1776                 else
1777                   {
1778                     /* extraneous `l' suffix on fp insn */
1779                     as_warn (_("translating to `%s %%%s'"), i.tm.name,
1780                              i.op[0].regs->reg_name);
1781                   }
1782               }
1783           }
1784         else if (i.tm.opcode_modifier & Modrm)
1785           {
1786             /* The opcode is completed (modulo i.tm.extension_opcode which
1787                must be put into the modrm byte).
1788                Now, we make the modrm & index base bytes based on all the
1789                info we've collected. */
1790
1791             /* i.reg_operands MUST be the number of real register operands;
1792                implicit registers do not count. */
1793             if (i.reg_operands == 2)
1794               {
1795                 unsigned int source, dest;
1796                 source = ((i.types[0]
1797                            & (Reg | RegMMX | RegXMM
1798                               | SReg2 | SReg3
1799                               | Control | Debug | Test))
1800                           ? 0 : 1);
1801                 dest = source + 1;
1802
1803                 i.rm.mode = 3;
1804                 /* One of the register operands will be encoded in the
1805                    i.tm.reg field, the other in the combined i.tm.mode
1806                    and i.tm.regmem fields.  If no form of this
1807                    instruction supports a memory destination operand,
1808                    then we assume the source operand may sometimes be
1809                    a memory operand and so we need to store the
1810                    destination in the i.rm.reg field.  */
1811                 if ((i.tm.operand_types[dest] & AnyMem) == 0)
1812                   {
1813                     i.rm.reg = i.op[dest].regs->reg_num;
1814                     i.rm.regmem = i.op[source].regs->reg_num;
1815                   }
1816                 else
1817                   {
1818                     i.rm.reg = i.op[source].regs->reg_num;
1819                     i.rm.regmem = i.op[dest].regs->reg_num;
1820                   }
1821               }
1822             else
1823               {                 /* if it's not 2 reg operands... */
1824                 if (i.mem_operands)
1825                   {
1826                     unsigned int fake_zero_displacement = 0;
1827                     unsigned int op = ((i.types[0] & AnyMem)
1828                                        ? 0
1829                                        : (i.types[1] & AnyMem) ? 1 : 2);
1830
1831                     default_seg = &ds;
1832
1833                     if (! i.base_reg)
1834                       {
1835                         i.rm.mode = 0;
1836                         if (! i.disp_operands)
1837                           fake_zero_displacement = 1;
1838                         if (! i.index_reg)
1839                           {
1840                             /* Operand is just <disp> */
1841                             if (flag_16bit_code ^ (i.prefix[ADDR_PREFIX] != 0))
1842                               {
1843                                 i.rm.regmem = NO_BASE_REGISTER_16;
1844                                 i.types[op] &= ~Disp;
1845                                 i.types[op] |= Disp16;
1846                               }
1847                             else
1848                               {
1849                                 i.rm.regmem = NO_BASE_REGISTER;
1850                                 i.types[op] &= ~Disp;
1851                                 i.types[op] |= Disp32;
1852                               }
1853                           }
1854                         else /* ! i.base_reg && i.index_reg */
1855                           {
1856                             i.sib.index = i.index_reg->reg_num;
1857                             i.sib.base = NO_BASE_REGISTER;
1858                             i.sib.scale = i.log2_scale_factor;
1859                             i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
1860                             i.types[op] &= ~Disp;
1861                             i.types[op] |= Disp32;      /* Must be 32 bit */
1862                           }
1863                       }
1864                     else if (i.base_reg->reg_type & Reg16)
1865                       {
1866                         switch (i.base_reg->reg_num)
1867                           {
1868                           case 3: /* (%bx) */
1869                             if (! i.index_reg)
1870                               i.rm.regmem = 7;
1871                             else /* (%bx,%si) -> 0, or (%bx,%di) -> 1 */
1872                               i.rm.regmem = i.index_reg->reg_num - 6;
1873                             break;
1874                           case 5: /* (%bp) */
1875                             default_seg = &ss;
1876                             if (! i.index_reg)
1877                               {
1878                                 i.rm.regmem = 6;
1879                                 if ((i.types[op] & Disp) == 0)
1880                                   {
1881                                     /* fake (%bp) into 0(%bp) */
1882                                     i.types[op] |= Disp8;
1883                                     fake_zero_displacement = 1;
1884                                   }
1885                               }
1886                             else /* (%bp,%si) -> 2, or (%bp,%di) -> 3 */
1887                               i.rm.regmem = i.index_reg->reg_num - 6 + 2;
1888                             break;
1889                           default: /* (%si) -> 4 or (%di) -> 5 */
1890                             i.rm.regmem = i.base_reg->reg_num - 6 + 4;
1891                           }
1892                         i.rm.mode = mode_from_disp_size (i.types[op]);
1893                       }
1894                     else /* i.base_reg and 32 bit mode */
1895                       {
1896                         i.rm.regmem = i.base_reg->reg_num;
1897                         i.sib.base = i.base_reg->reg_num;
1898                         if (i.base_reg->reg_num == EBP_REG_NUM)
1899                           {
1900                             default_seg = &ss;
1901                             if (i.disp_operands == 0)
1902                               {
1903                                 fake_zero_displacement = 1;
1904                                 i.types[op] |= Disp8;
1905                               }
1906                           }
1907                         else if (i.base_reg->reg_num == ESP_REG_NUM)
1908                           {
1909                             default_seg = &ss;
1910                           }
1911                         i.sib.scale = i.log2_scale_factor;
1912                         if (! i.index_reg)
1913                           {
1914                             /* <disp>(%esp) becomes two byte modrm
1915                                with no index register.  We've already
1916                                stored the code for esp in i.rm.regmem
1917                                ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.  Any
1918                                base register besides %esp will not use
1919                                the extra modrm byte.  */
1920                             i.sib.index = NO_INDEX_REGISTER;
1921 #if ! SCALE1_WHEN_NO_INDEX
1922                             /* Another case where we force the second
1923                                modrm byte.  */
1924                             if (i.log2_scale_factor)
1925                               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
1926 #endif
1927                           }
1928                         else
1929                           {
1930                             i.sib.index = i.index_reg->reg_num;
1931                             i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
1932                           }
1933                         i.rm.mode = mode_from_disp_size (i.types[op]);
1934                       }
1935
1936                     if (fake_zero_displacement)
1937                       {
1938                         /* Fakes a zero displacement assuming that i.types[op]
1939                            holds the correct displacement size. */
1940                         expressionS *exp;
1941
1942                         assert (i.op[op].disps == 0);
1943                         exp = &disp_expressions[i.disp_operands++];
1944                         i.op[op].disps = exp;
1945                         exp->X_op = O_constant;
1946                         exp->X_add_number = 0;
1947                         exp->X_add_symbol = (symbolS *) 0;
1948                         exp->X_op_symbol = (symbolS *) 0;
1949                       }
1950                   }
1951
1952                 /* Fill in i.rm.reg or i.rm.regmem field with register
1953                    operand (if any) based on i.tm.extension_opcode.
1954                    Again, we must be careful to make sure that
1955                    segment/control/debug/test/MMX registers are coded
1956                    into the i.rm.reg field. */
1957                 if (i.reg_operands)
1958                   {
1959                     unsigned int op =
1960                       ((i.types[0]
1961                         & (Reg | RegMMX | RegXMM
1962                            | SReg2 | SReg3
1963                            | Control | Debug | Test))
1964                        ? 0
1965                        : ((i.types[1]
1966                            & (Reg | RegMMX | RegXMM
1967                               | SReg2 | SReg3
1968                               | Control | Debug | Test))
1969                           ? 1
1970                           : 2));
1971                     /* If there is an extension opcode to put here, the
1972                        register number must be put into the regmem field. */
1973                     if (i.tm.extension_opcode != None)
1974                       i.rm.regmem = i.op[op].regs->reg_num;
1975                     else
1976                       i.rm.reg = i.op[op].regs->reg_num;
1977
1978                     /* Now, if no memory operand has set i.rm.mode = 0, 1, 2
1979                        we must set it to 3 to indicate this is a register
1980                        operand in the regmem field.  */
1981                     if (!i.mem_operands)
1982                       i.rm.mode = 3;
1983                   }
1984
1985                 /* Fill in i.rm.reg field with extension opcode (if any). */
1986                 if (i.tm.extension_opcode != None)
1987                   i.rm.reg = i.tm.extension_opcode;
1988               }
1989           }
1990         else if (i.tm.opcode_modifier & (Seg2ShortForm | Seg3ShortForm))
1991           {
1992             if (i.tm.base_opcode == POP_SEG_SHORT && i.op[0].regs->reg_num == 1)
1993               {
1994                 as_bad (_("you can't `pop %%cs'"));
1995                 return;
1996               }
1997             i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
1998           }
1999         else if ((i.tm.base_opcode & ~(D|W)) == MOV_AX_DISP32)
2000           {
2001             default_seg = &ds;
2002           }
2003         else if ((i.tm.opcode_modifier & IsString) != 0)
2004           {
2005             /* For the string instructions that allow a segment override
2006                on one of their operands, the default segment is ds.  */
2007             default_seg = &ds;
2008           }
2009
2010         /* If a segment was explicitly specified,
2011            and the specified segment is not the default,
2012            use an opcode prefix to select it.
2013            If we never figured out what the default segment is,
2014            then default_seg will be zero at this point,
2015            and the specified segment prefix will always be used.  */
2016         if ((i.seg[0]) && (i.seg[0] != default_seg))
2017           {
2018             if (! add_prefix (i.seg[0]->seg_prefix))
2019               return;
2020           }
2021       }
2022     else if ((i.tm.opcode_modifier & Ugh) != 0)
2023       {
2024         /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
2025         as_warn (_("translating to `%sp'"), i.tm.name);
2026       }
2027   }
2028
2029   /* Handle conversion of 'int $3' --> special int3 insn. */
2030   if (i.tm.base_opcode == INT_OPCODE && i.op[0].imms->X_add_number == 3)
2031     {
2032       i.tm.base_opcode = INT3_OPCODE;
2033       i.imm_operands = 0;
2034     }
2035
2036   if ((i.tm.opcode_modifier & (Jump | JumpByte | JumpDword))
2037       && i.op[0].disps->X_op == O_constant)
2038     {
2039       /* Convert "jmp constant" (and "call constant") to a jump (call) to
2040          the absolute address given by the constant.  Since ix86 jumps and
2041          calls are pc relative, we need to generate a reloc.  */
2042       i.op[0].disps->X_add_symbol = &abs_symbol;
2043       i.op[0].disps->X_op = O_symbol;
2044     }
2045
2046   /* We are ready to output the insn. */
2047   {
2048     register char *p;
2049
2050     /* Output jumps. */
2051     if (i.tm.opcode_modifier & Jump)
2052       {
2053         int size;
2054         int code16;
2055         int prefix;
2056
2057         code16 = 0;
2058         if (flag_16bit_code)
2059           code16 = CODE16;
2060
2061         prefix = 0;
2062         if (i.prefix[DATA_PREFIX])
2063           {
2064             prefix = 1;
2065             i.prefixes -= 1;
2066             code16 ^= CODE16;
2067           }
2068
2069         size = 4;
2070         if (code16)
2071           size = 2;
2072
2073         if (i.prefixes != 0 && !intel_syntax)
2074           as_warn (_("skipping prefixes on this instruction"));
2075
2076         /* It's always a symbol;  End frag & setup for relax.
2077            Make sure there is enough room in this frag for the largest
2078            instruction we may generate in md_convert_frag.  This is 2
2079            bytes for the opcode and room for the prefix and largest
2080            displacement.  */
2081         frag_grow (prefix + 2 + size);
2082         insn_size += prefix + 1;
2083         /* Prefix and 1 opcode byte go in fr_fix.  */
2084         p = frag_more (prefix + 1);
2085         if (prefix)
2086           *p++ = DATA_PREFIX_OPCODE;
2087         *p = i.tm.base_opcode;
2088         /* 1 possible extra opcode + displacement go in fr_var.  */
2089         frag_var (rs_machine_dependent,
2090                   1 + size,
2091                   1,
2092                   ((unsigned char) *p == JUMP_PC_RELATIVE
2093                    ? ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL) | code16
2094                    : ENCODE_RELAX_STATE (COND_JUMP, SMALL) | code16),
2095                   i.op[0].disps->X_add_symbol,
2096                   i.op[0].disps->X_add_number,
2097                   p);
2098       }
2099     else if (i.tm.opcode_modifier & (JumpByte | JumpDword))
2100       {
2101         int size;
2102
2103         if (i.tm.opcode_modifier & JumpByte)
2104           {
2105             /* This is a loop or jecxz type instruction.  */
2106             size = 1;
2107             if (i.prefix[ADDR_PREFIX])
2108               {
2109                 insn_size += 1;
2110                 FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
2111                 i.prefixes -= 1;
2112               }
2113           }
2114         else
2115           {
2116             int code16;
2117
2118             code16 = 0;
2119             if (flag_16bit_code)
2120               code16 = CODE16;
2121
2122             if (i.prefix[DATA_PREFIX])
2123               {
2124                 insn_size += 1;
2125                 FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
2126                 i.prefixes -= 1;
2127                 code16 ^= CODE16;
2128               }
2129
2130             size = 4;
2131             if (code16)
2132               size = 2;
2133           }
2134
2135         if (i.prefixes != 0 && !intel_syntax)
2136           as_warn (_("skipping prefixes on this instruction"));
2137
2138         if (fits_in_unsigned_byte (i.tm.base_opcode))
2139           {
2140             insn_size += 1 + size;
2141             p = frag_more (1 + size);
2142           }
2143         else
2144           {
2145             /* opcode can be at most two bytes */
2146             insn_size += 2 + size;
2147             p = frag_more (2 + size);
2148             *p++ = (i.tm.base_opcode >> 8) & 0xff;
2149           }
2150         *p++ = i.tm.base_opcode & 0xff;
2151
2152         fix_new_exp (frag_now, p - frag_now->fr_literal, size,
2153                      i.op[0].disps, 1, reloc (size, 1, i.disp_reloc[0]));
2154       }
2155     else if (i.tm.opcode_modifier & JumpInterSegment)
2156       {
2157         int size;
2158         int prefix;
2159         int code16;
2160
2161         code16 = 0;
2162         if (flag_16bit_code)
2163           code16 = CODE16;
2164
2165         prefix = 0;
2166         if (i.prefix[DATA_PREFIX])
2167           {
2168             prefix = 1;
2169             i.prefixes -= 1;
2170             code16 ^= CODE16;
2171           }
2172
2173         size = 4;
2174         if (code16)
2175           size = 2;
2176
2177         if (i.prefixes != 0 && !intel_syntax)
2178           as_warn (_("skipping prefixes on this instruction"));
2179
2180         insn_size += prefix + 1 + 2 + size;  /* 1 opcode; 2 segment; offset */
2181         p = frag_more (prefix + 1 + 2 + size);
2182         if (prefix)
2183           *p++ = DATA_PREFIX_OPCODE;
2184         *p++ = i.tm.base_opcode;
2185         if (i.op[1].imms->X_op == O_constant)
2186           {
2187             long n = (long) i.op[1].imms->X_add_number;
2188
2189             if (size == 2 && !fits_in_unsigned_word (n))
2190               {
2191                 as_bad (_("16-bit jump out of range"));
2192                 return;
2193               }
2194             md_number_to_chars (p, (valueT) n, size);
2195           }
2196         else
2197           fix_new_exp (frag_now, p - frag_now->fr_literal, size,
2198                        i.op[1].imms, 0, reloc (size, 0, i.disp_reloc[0]));
2199         if (i.op[0].imms->X_op != O_constant)
2200           as_bad (_("can't handle non absolute segment in `%s'"),
2201                   i.tm.name);
2202         md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
2203       }
2204     else
2205       {
2206         /* Output normal instructions here. */
2207         unsigned char *q;
2208
2209         /* The prefix bytes. */
2210         for (q = i.prefix;
2211              q < i.prefix + sizeof (i.prefix) / sizeof (i.prefix[0]);
2212              q++)
2213           {
2214             if (*q)
2215               {
2216                 insn_size += 1;
2217                 p = frag_more (1);
2218                 md_number_to_chars (p, (valueT) *q, 1);
2219               }
2220           }
2221
2222         /* Now the opcode; be careful about word order here! */
2223         if (fits_in_unsigned_byte (i.tm.base_opcode))
2224           {
2225             insn_size += 1;
2226             FRAG_APPEND_1_CHAR (i.tm.base_opcode);
2227           }
2228         else if (fits_in_unsigned_word (i.tm.base_opcode))
2229           {
2230             insn_size += 2;
2231             p = frag_more (2);
2232             /* put out high byte first: can't use md_number_to_chars! */
2233             *p++ = (i.tm.base_opcode >> 8) & 0xff;
2234             *p = i.tm.base_opcode & 0xff;
2235           }
2236         else
2237           {                     /* opcode is either 3 or 4 bytes */
2238             if (i.tm.base_opcode & 0xff000000)
2239               {
2240                 insn_size += 4;
2241                 p = frag_more (4);
2242                 *p++ = (i.tm.base_opcode >> 24) & 0xff;
2243               }
2244             else
2245               {
2246                 insn_size += 3;
2247                 p = frag_more (3);
2248               }
2249             *p++ = (i.tm.base_opcode >> 16) & 0xff;
2250             *p++ = (i.tm.base_opcode >> 8) & 0xff;
2251             *p = (i.tm.base_opcode) & 0xff;
2252           }
2253
2254         /* Now the modrm byte and sib byte (if present).  */
2255         if (i.tm.opcode_modifier & Modrm)
2256           {
2257             insn_size += 1;
2258             p = frag_more (1);
2259             md_number_to_chars (p,
2260                                 (valueT) (i.rm.regmem << 0
2261                                           | i.rm.reg << 3
2262                                           | i.rm.mode << 6),
2263                                 1);
2264             /* If i.rm.regmem == ESP (4)
2265                && i.rm.mode != (Register mode)
2266                && not 16 bit
2267                ==> need second modrm byte.  */
2268             if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
2269                 && i.rm.mode != 3
2270                 && !(i.base_reg && (i.base_reg->reg_type & Reg16) != 0))
2271               {
2272                 insn_size += 1;
2273                 p = frag_more (1);
2274                 md_number_to_chars (p,
2275                                     (valueT) (i.sib.base << 0
2276                                               | i.sib.index << 3
2277                                               | i.sib.scale << 6),
2278                                     1);
2279               }
2280           }
2281
2282         if (i.disp_operands)
2283           {
2284             register unsigned int n;
2285
2286             for (n = 0; n < i.operands; n++)
2287               {
2288                 if (i.types[n] & Disp)
2289                   {
2290                     if (i.op[n].disps->X_op == O_constant)
2291                       {
2292                         int size = 4;
2293                         long val = (long) i.op[n].disps->X_add_number;
2294
2295                         if (i.types[n] & (Disp8 | Disp16))
2296                           {
2297                             long mask;
2298
2299                             size = 2;
2300                             mask = ~ (long) 0xffff;
2301                             if (i.types[n] & Disp8)
2302                               {
2303                                 size = 1;
2304                                 mask = ~ (long) 0xff;
2305                               }
2306
2307                             if ((val & mask) != 0 && (val & mask) != mask)
2308                               as_warn (_("%ld shortened to %ld"),
2309                                        val, val & ~mask);
2310                           }
2311                         insn_size += size;
2312                         p = frag_more (size);
2313                         md_number_to_chars (p, (valueT) val, size);
2314                       }
2315                     else
2316                       {
2317                         int size = 4;
2318
2319                         if (i.types[n] & Disp16)
2320                           size = 2;
2321
2322                         insn_size += size;
2323                         p = frag_more (size);
2324                         fix_new_exp (frag_now, p - frag_now->fr_literal, size,
2325                                      i.op[n].disps, 0,
2326                                      reloc (size, 0, i.disp_reloc[n]));
2327                       }
2328                   }
2329               }
2330           }                     /* end displacement output */
2331
2332         /* output immediate */
2333         if (i.imm_operands)
2334           {
2335             register unsigned int n;
2336
2337             for (n = 0; n < i.operands; n++)
2338               {
2339                 if (i.types[n] & Imm)
2340                   {
2341                     if (i.op[n].imms->X_op == O_constant)
2342                       {
2343                         int size = 4;
2344                         long val = (long) i.op[n].imms->X_add_number;
2345
2346                         if (i.types[n] & (Imm8 | Imm8S | Imm16))
2347                           {
2348                             long mask;
2349
2350                             size = 2;
2351                             mask = ~ (long) 0xffff;
2352                             if (i.types[n] & (Imm8 | Imm8S))
2353                               {
2354                                 size = 1;
2355                                 mask = ~ (long) 0xff;
2356                               }
2357                             if ((val & mask) != 0 && (val & mask) != mask)
2358                               as_warn (_("%ld shortened to %ld"),
2359                                        val, val & ~mask);
2360                           }
2361                         insn_size += size;
2362                         p = frag_more (size);
2363                         md_number_to_chars (p, (valueT) val, size);
2364                       }
2365                     else
2366                       {         /* not absolute_section */
2367                         /* Need a 32-bit fixup (don't support 8bit
2368                            non-absolute imms).  Try to support other
2369                            sizes ... */
2370 #ifdef BFD_ASSEMBLER
2371                         enum bfd_reloc_code_real reloc_type;
2372 #else
2373                         int reloc_type;
2374 #endif
2375                         int size = 4;
2376
2377                         if (i.types[n] & Imm16)
2378                           size = 2;
2379                         else if (i.types[n] & (Imm8 | Imm8S))
2380                           size = 1;
2381
2382                         insn_size += size;
2383                         p = frag_more (size);
2384                         reloc_type = reloc (size, 0, i.disp_reloc[0]);
2385 #ifdef BFD_ASSEMBLER
2386                         if (reloc_type == BFD_RELOC_32
2387                             && GOT_symbol
2388                             && GOT_symbol == i.op[n].imms->X_add_symbol
2389                             && (i.op[n].imms->X_op == O_symbol
2390                                 || (i.op[n].imms->X_op == O_add
2391                                     && ((symbol_get_value_expression
2392                                          (i.op[n].imms->X_op_symbol)->X_op)
2393                                         == O_subtract))))
2394                           {
2395                             reloc_type = BFD_RELOC_386_GOTPC;
2396                             i.op[n].imms->X_add_number += 3;
2397                           }
2398 #endif
2399                         fix_new_exp (frag_now, p - frag_now->fr_literal, size,
2400                                      i.op[n].imms, 0, reloc_type);
2401                       }
2402                   }
2403               }
2404           }                     /* end immediate output */
2405       }
2406
2407 #ifdef DEBUG386
2408     if (flag_debug)
2409       {
2410         pi (line, &i);
2411       }
2412 #endif /* DEBUG386 */
2413   }
2414 }
2415 \f
2416 static int i386_immediate PARAMS ((char *));
2417
2418 static int
2419 i386_immediate (imm_start)
2420      char *imm_start;
2421 {
2422   char *save_input_line_pointer;
2423   segT exp_seg = 0;
2424   expressionS * exp;
2425
2426   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
2427     {
2428       as_bad (_("Only 1 or 2 immediate operands are allowed"));
2429       return 0;
2430     }
2431
2432   exp = &im_expressions[i.imm_operands++];
2433   i.op[this_operand].imms = exp;
2434
2435   if (is_space_char (*imm_start))
2436     ++imm_start;
2437
2438   save_input_line_pointer = input_line_pointer;
2439   input_line_pointer = imm_start;
2440
2441 #ifndef LEX_AT
2442   {
2443     /*
2444      * We can have operands of the form
2445      *   <symbol>@GOTOFF+<nnn>
2446      * Take the easy way out here and copy everything
2447      * into a temporary buffer...
2448      */
2449     register char *cp;
2450
2451     cp = strchr (input_line_pointer, '@');
2452     if (cp != NULL)
2453       {
2454         char *tmpbuf;
2455         int len = 0;
2456         int first;
2457
2458         /* GOT relocations are not supported in 16 bit mode */
2459         if (flag_16bit_code)
2460           as_bad (_("GOT relocations not supported in 16 bit mode"));
2461
2462         if (GOT_symbol == NULL)
2463           GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
2464
2465         if (strncmp (cp + 1, "PLT", 3) == 0)
2466           {
2467             i.disp_reloc[this_operand] = BFD_RELOC_386_PLT32;
2468             len = 3;
2469           }
2470         else if (strncmp (cp + 1, "GOTOFF", 6) == 0)
2471           {
2472             i.disp_reloc[this_operand] = BFD_RELOC_386_GOTOFF;
2473             len = 6;
2474           }
2475         else if (strncmp (cp + 1, "GOT", 3) == 0)
2476           {
2477             i.disp_reloc[this_operand] = BFD_RELOC_386_GOT32;
2478             len = 3;
2479           }
2480         else
2481           as_bad (_("Bad reloc specifier in expression"));
2482
2483         /* Replace the relocation token with ' ', so that errors like
2484            foo@GOTOFF1 will be detected.  */
2485         first = cp - input_line_pointer;
2486         tmpbuf = (char *) alloca (strlen(input_line_pointer));
2487         memcpy (tmpbuf, input_line_pointer, first);
2488         tmpbuf[first] = ' ';
2489         strcpy (tmpbuf + first + 1, cp + 1 + len);
2490         input_line_pointer = tmpbuf;
2491       }
2492   }
2493 #endif
2494
2495   exp_seg = expression (exp);
2496
2497   SKIP_WHITESPACE ();
2498   if (*input_line_pointer)
2499     as_bad (_("Ignoring junk `%s' after expression"), input_line_pointer);
2500
2501   input_line_pointer = save_input_line_pointer;
2502
2503   if (exp->X_op == O_absent || exp->X_op == O_big)
2504     {
2505       /* missing or bad expr becomes absolute 0 */
2506       as_bad (_("Missing or invalid immediate expression `%s' taken as 0"),
2507               imm_start);
2508       exp->X_op = O_constant;
2509       exp->X_add_number = 0;
2510       exp->X_add_symbol = (symbolS *) 0;
2511       exp->X_op_symbol = (symbolS *) 0;
2512     }
2513
2514   if (exp->X_op == O_constant)
2515     {
2516       int bigimm = Imm32;
2517       if (flag_16bit_code ^ (i.prefix[DATA_PREFIX] != 0))
2518         bigimm = Imm16;
2519
2520       i.types[this_operand] |=
2521         (bigimm | smallest_imm_type ((long) exp->X_add_number));
2522
2523       /* If a suffix is given, this operand may be shortened.  */
2524       switch (i.suffix)
2525         {
2526         case WORD_MNEM_SUFFIX:
2527           i.types[this_operand] |= Imm16;
2528           break;
2529         case BYTE_MNEM_SUFFIX:
2530           i.types[this_operand] |= Imm16 | Imm8 | Imm8S;
2531           break;
2532         }
2533     }
2534 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
2535   else if (
2536 #ifdef BFD_ASSEMBLER
2537            OUTPUT_FLAVOR == bfd_target_aout_flavour &&
2538 #endif
2539            exp_seg != text_section
2540            && exp_seg != data_section
2541            && exp_seg != bss_section
2542            && exp_seg != undefined_section
2543 #ifdef BFD_ASSEMBLER
2544            && !bfd_is_com_section (exp_seg)
2545 #endif
2546            )
2547     {
2548 #ifdef BFD_ASSEMBLER
2549       as_bad (_("Unimplemented segment %s in operand"), exp_seg->name);
2550 #else
2551       as_bad (_("Unimplemented segment type %d in operand"), exp_seg);
2552 #endif
2553       return 0;
2554     }
2555 #endif
2556   else
2557     {
2558       /* This is an address.  The size of the address will be
2559          determined later, depending on destination register,
2560          suffix, or the default for the section.  We exclude
2561          Imm8S here so that `push $foo' and other instructions
2562          with an Imm8S form will use Imm16 or Imm32.  */
2563       i.types[this_operand] |= (Imm8 | Imm16 | Imm32);
2564     }
2565
2566   return 1;
2567 }
2568
2569 static int i386_scale PARAMS ((char *));
2570
2571 static int
2572 i386_scale (scale)
2573      char *scale;
2574 {
2575   if (!isdigit (*scale))
2576     goto bad_scale;
2577
2578   switch (*scale)
2579     {
2580     case '0':
2581     case '1':
2582       i.log2_scale_factor = 0;
2583       break;
2584     case '2':
2585       i.log2_scale_factor = 1;
2586       break;
2587     case '4':
2588       i.log2_scale_factor = 2;
2589       break;
2590     case '8':
2591       i.log2_scale_factor = 3;
2592       break;
2593     default:
2594     bad_scale:
2595       as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
2596               scale);
2597       return 0;
2598     }
2599   if (i.log2_scale_factor != 0 && ! i.index_reg)
2600     {
2601       as_warn (_("scale factor of %d without an index register"),
2602                1 << i.log2_scale_factor);
2603 #if SCALE1_WHEN_NO_INDEX
2604       i.log2_scale_factor = 0;
2605 #endif
2606     }
2607   return 1;
2608 }
2609
2610 static int i386_displacement PARAMS ((char *, char *));
2611
2612 static int
2613 i386_displacement (disp_start, disp_end)
2614      char *disp_start;
2615      char *disp_end;
2616 {
2617   register expressionS *exp;
2618   segT exp_seg = 0;
2619   char *save_input_line_pointer;
2620   int bigdisp = Disp32;
2621
2622   if (flag_16bit_code ^ (i.prefix[ADDR_PREFIX] != 0))
2623     bigdisp = Disp16;
2624   i.types[this_operand] |= bigdisp;
2625
2626   exp = &disp_expressions[i.disp_operands];
2627   i.op[this_operand].disps = exp;
2628   i.disp_operands++;
2629   save_input_line_pointer = input_line_pointer;
2630   input_line_pointer = disp_start;
2631   END_STRING_AND_SAVE (disp_end);
2632
2633 #ifndef GCC_ASM_O_HACK
2634 #define GCC_ASM_O_HACK 0
2635 #endif
2636 #if GCC_ASM_O_HACK
2637   END_STRING_AND_SAVE (disp_end + 1);
2638   if ((i.types[this_operand] & BaseIndex) != 0
2639       && displacement_string_end[-1] == '+')
2640     {
2641       /* This hack is to avoid a warning when using the "o"
2642          constraint within gcc asm statements.
2643          For instance:
2644
2645          #define _set_tssldt_desc(n,addr,limit,type) \
2646          __asm__ __volatile__ ( \
2647          "movw %w2,%0\n\t" \
2648          "movw %w1,2+%0\n\t" \
2649          "rorl $16,%1\n\t" \
2650          "movb %b1,4+%0\n\t" \
2651          "movb %4,5+%0\n\t" \
2652          "movb $0,6+%0\n\t" \
2653          "movb %h1,7+%0\n\t" \
2654          "rorl $16,%1" \
2655          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
2656
2657          This works great except that the output assembler ends
2658          up looking a bit weird if it turns out that there is
2659          no offset.  You end up producing code that looks like:
2660
2661          #APP
2662          movw $235,(%eax)
2663          movw %dx,2+(%eax)
2664          rorl $16,%edx
2665          movb %dl,4+(%eax)
2666          movb $137,5+(%eax)
2667          movb $0,6+(%eax)
2668          movb %dh,7+(%eax)
2669          rorl $16,%edx
2670          #NO_APP
2671
2672          So here we provide the missing zero.
2673       */
2674
2675       *displacement_string_end = '0';
2676     }
2677 #endif
2678 #ifndef LEX_AT
2679   {
2680     /*
2681      * We can have operands of the form
2682      *   <symbol>@GOTOFF+<nnn>
2683      * Take the easy way out here and copy everything
2684      * into a temporary buffer...
2685      */
2686     register char *cp;
2687
2688     cp = strchr (input_line_pointer, '@');
2689     if (cp != NULL)
2690       {
2691         char *tmpbuf;
2692         int len = 0;
2693         int first;
2694
2695         /* GOT relocations are not supported in 16 bit mode */
2696         if (flag_16bit_code)
2697           as_bad (_("GOT relocations not supported in 16 bit mode"));
2698
2699         if (GOT_symbol == NULL)
2700           GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
2701
2702         if (strncmp (cp + 1, "PLT", 3) == 0)
2703           {
2704             i.disp_reloc[this_operand] = BFD_RELOC_386_PLT32;
2705             len = 3;
2706           }
2707         else if (strncmp (cp + 1, "GOTOFF", 6) == 0)
2708           {
2709             i.disp_reloc[this_operand] = BFD_RELOC_386_GOTOFF;
2710             len = 6;
2711           }
2712         else if (strncmp (cp + 1, "GOT", 3) == 0)
2713           {
2714             i.disp_reloc[this_operand] = BFD_RELOC_386_GOT32;
2715             len = 3;
2716           }
2717         else
2718           as_bad (_("Bad reloc specifier in expression"));
2719
2720         /* Replace the relocation token with ' ', so that errors like
2721            foo@GOTOFF1 will be detected.  */
2722         first = cp - input_line_pointer;
2723         tmpbuf = (char *) alloca (strlen(input_line_pointer));
2724         memcpy (tmpbuf, input_line_pointer, first);
2725         tmpbuf[first] = ' ';
2726         strcpy (tmpbuf + first + 1, cp + 1 + len);
2727         input_line_pointer = tmpbuf;
2728       }
2729   }
2730 #endif
2731
2732   exp_seg = expression (exp);
2733
2734 #ifdef BFD_ASSEMBLER
2735   /* We do this to make sure that the section symbol is in
2736      the symbol table.  We will ultimately change the relocation
2737      to be relative to the beginning of the section */
2738   if (i.disp_reloc[this_operand] == BFD_RELOC_386_GOTOFF)
2739     {
2740       if (S_IS_LOCAL(exp->X_add_symbol)
2741           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section)
2742         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
2743       assert (exp->X_op == O_symbol);
2744       exp->X_op = O_subtract;
2745       exp->X_op_symbol = GOT_symbol;
2746       i.disp_reloc[this_operand] = BFD_RELOC_32;
2747     }
2748 #endif
2749
2750   SKIP_WHITESPACE ();
2751   if (*input_line_pointer)
2752     as_bad (_("Ignoring junk `%s' after expression"),
2753             input_line_pointer);
2754 #if GCC_ASM_O_HACK
2755   RESTORE_END_STRING (disp_end + 1);
2756 #endif
2757   RESTORE_END_STRING (disp_end);
2758   input_line_pointer = save_input_line_pointer;
2759
2760   if (exp->X_op == O_absent || exp->X_op == O_big)
2761     {
2762       /* missing or bad expr becomes absolute 0 */
2763       as_bad (_("Missing or invalid displacement expression `%s' taken as 0"),
2764               disp_start);
2765       exp->X_op = O_constant;
2766       exp->X_add_number = 0;
2767       exp->X_add_symbol = (symbolS *) 0;
2768       exp->X_op_symbol = (symbolS *) 0;
2769     }
2770
2771   if (exp->X_op == O_constant)
2772     {
2773       if (fits_in_signed_byte (exp->X_add_number))
2774         i.types[this_operand] |= Disp8;
2775     }
2776 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
2777   else if (
2778 #ifdef BFD_ASSEMBLER
2779            OUTPUT_FLAVOR == bfd_target_aout_flavour &&
2780 #endif
2781            exp_seg != text_section
2782            && exp_seg != data_section
2783            && exp_seg != bss_section
2784            && exp_seg != undefined_section)
2785     {
2786 #ifdef BFD_ASSEMBLER
2787       as_bad (_("Unimplemented segment %s in operand"), exp_seg->name);
2788 #else
2789       as_bad (_("Unimplemented segment type %d in operand"), exp_seg);
2790 #endif
2791       return 0;
2792     }
2793 #endif
2794   return 1;
2795 }
2796
2797 static int i386_operand_modifier PARAMS ((char **, int));
2798
2799 static int
2800 i386_operand_modifier (op_string, got_a_float)
2801      char **op_string;
2802      int got_a_float;
2803 {
2804   if (!strncasecmp (*op_string, "BYTE PTR", 8))
2805     {
2806       i.suffix = BYTE_MNEM_SUFFIX;
2807       *op_string += 8;
2808       return BYTE_PTR;
2809
2810     }
2811   else if (!strncasecmp (*op_string, "WORD PTR", 8))
2812     {
2813       i.suffix = WORD_MNEM_SUFFIX;
2814       *op_string += 8;
2815       return WORD_PTR;
2816     }
2817
2818   else if (!strncasecmp (*op_string, "DWORD PTR", 9))
2819     {
2820       if (got_a_float)
2821         i.suffix = SHORT_MNEM_SUFFIX;
2822       else
2823         i.suffix = LONG_MNEM_SUFFIX;
2824       *op_string += 9;
2825       return DWORD_PTR;
2826     }
2827
2828   else if (!strncasecmp (*op_string, "QWORD PTR", 9))
2829     {
2830       i.suffix = DWORD_MNEM_SUFFIX;
2831       *op_string += 9;
2832       return QWORD_PTR;
2833     }
2834
2835   else if (!strncasecmp (*op_string, "XWORD PTR", 9))
2836     {
2837       i.suffix = LONG_DOUBLE_MNEM_SUFFIX;
2838       *op_string += 9;
2839       return XWORD_PTR;
2840     }
2841
2842   else if (!strncasecmp (*op_string, "SHORT", 5))
2843     {
2844       *op_string += 5;
2845       return SHORT;
2846     }
2847
2848   else if (!strncasecmp (*op_string, "OFFSET FLAT:", 12))
2849     {
2850       *op_string += 12;
2851       return OFFSET_FLAT;
2852     }
2853
2854   else if (!strncasecmp (*op_string, "FLAT", 4))
2855     {
2856       *op_string += 4;
2857       return FLAT;
2858     }
2859
2860   else return NONE_FOUND;
2861 }
2862
2863 static char * build_displacement_string PARAMS ((int, char *));
2864
2865 static char *
2866 build_displacement_string (initial_disp, op_string)
2867      int initial_disp;
2868      char *op_string;
2869 {
2870   char *temp_string = (char *) malloc (strlen (op_string) + 1);
2871   char *end_of_operand_string;
2872   char *tc;
2873   char *temp_disp;
2874
2875   temp_string[0] = '\0';
2876   tc = end_of_operand_string = strchr (op_string, '[');
2877   if ( initial_disp && !end_of_operand_string)
2878     {
2879       strcpy (temp_string, op_string);
2880       return (temp_string);
2881     }
2882
2883   /* Build the whole displacement string */
2884   if (initial_disp)
2885     {
2886       strncpy (temp_string, op_string, end_of_operand_string - op_string);
2887       temp_string[end_of_operand_string - op_string] = '\0';
2888       temp_disp = tc;
2889     }
2890   else
2891     temp_disp = op_string;
2892
2893   while (*temp_disp != '\0')
2894     {
2895       char *end_op;
2896       int add_minus = (*temp_disp == '-');
2897
2898       if (*temp_disp == '+' || *temp_disp == '-' || *temp_disp == '[')
2899         temp_disp++;
2900
2901       if (is_space_char (*temp_disp))
2902         temp_disp++;
2903
2904       /* Don't consider registers */
2905       if ( !((*temp_disp == REGISTER_PREFIX || allow_naked_reg)
2906              && parse_register (temp_disp, &end_op)) )
2907         {
2908           char *string_start = temp_disp;
2909
2910           while (*temp_disp != ']'
2911                  && *temp_disp != '+'
2912                  && *temp_disp != '-'
2913                  && *temp_disp != '*')
2914             ++temp_disp;
2915
2916           if (add_minus)
2917             strcat (temp_string, "-");
2918           else
2919             strcat (temp_string, "+");
2920
2921           strncat (temp_string, string_start, temp_disp - string_start);
2922           if (*temp_disp == '+' || *temp_disp == '-')
2923             --temp_disp;
2924         }
2925
2926       while (*temp_disp != '\0'
2927              && *temp_disp != '+'
2928              && *temp_disp != '-')
2929         ++temp_disp;
2930     }
2931
2932   return temp_string;
2933 }
2934
2935 static int i386_parse_seg PARAMS ((char *));
2936
2937 static int
2938 i386_parse_seg (op_string)
2939      char *op_string;
2940 {
2941   if (is_space_char (*op_string))
2942     ++op_string;
2943
2944   /* Should be one of es, cs, ss, ds fs or gs */
2945   switch (*op_string++)
2946     {
2947     case 'e':
2948       i.seg[i.mem_operands] = &es;
2949       break;
2950     case 'c':
2951       i.seg[i.mem_operands] = &cs;
2952       break;
2953     case 's':
2954       i.seg[i.mem_operands] = &ss;
2955       break;
2956     case 'd':
2957       i.seg[i.mem_operands] = &ds;
2958       break;
2959     case 'f':
2960       i.seg[i.mem_operands] = &fs;
2961       break;
2962     case 'g':
2963       i.seg[i.mem_operands] = &gs;
2964       break;
2965     default:
2966       as_bad (_("bad segment name `%s'"), op_string);
2967       return 0;
2968     }
2969
2970   if (*op_string++ != 's')
2971     {
2972       as_bad (_("bad segment name `%s'"), op_string);
2973       return 0;
2974     }
2975
2976   if (is_space_char (*op_string))
2977     ++op_string;
2978
2979   if (*op_string != ':')
2980     {
2981       as_bad (_("bad segment name `%s'"), op_string);
2982       return 0;
2983     }
2984
2985   return 1;
2986
2987 }
2988
2989 static int i386_index_check PARAMS((const char *));
2990
2991 /* Make sure the memory operand we've been dealt is valid.
2992    Returns 1 on success, 0 on a failure.
2993 */
2994 static int
2995 i386_index_check (operand_string)
2996      const char *operand_string;
2997 {
2998 #if INFER_ADDR_PREFIX
2999   int fudged = 0;
3000
3001  tryprefix:
3002 #endif
3003   if (flag_16bit_code ^ (i.prefix[ADDR_PREFIX] != 0) ?
3004       /* 16 bit mode checks */
3005       ((i.base_reg
3006         && ((i.base_reg->reg_type & (Reg16|BaseIndex))
3007             != (Reg16|BaseIndex)))
3008        || (i.index_reg
3009            && (((i.index_reg->reg_type & (Reg16|BaseIndex))
3010                 != (Reg16|BaseIndex))
3011                || ! (i.base_reg
3012                      && i.base_reg->reg_num < 6
3013                      && i.index_reg->reg_num >= 6
3014                      && i.log2_scale_factor == 0)))) :
3015       /* 32 bit mode checks */
3016       ((i.base_reg
3017         && (i.base_reg->reg_type & Reg32) == 0)
3018        || (i.index_reg
3019            && ((i.index_reg->reg_type & (Reg32|BaseIndex))
3020                != (Reg32|BaseIndex)))))
3021     {
3022 #if INFER_ADDR_PREFIX
3023       if (i.prefix[ADDR_PREFIX] == 0 && stackop_size != '\0')
3024         {
3025           i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
3026           i.prefixes += 1;
3027           /* Change the size of any displacement too.  At most one of
3028              Disp16 or Disp32 is set.
3029              FIXME.  There doesn't seem to be any real need for separate
3030              Disp16 and Disp32 flags.  The same goes for Imm16 and Imm32.
3031              Removing them would probably clean up the code quite a lot.
3032           */
3033           if (i.types[this_operand] & (Disp16|Disp32))
3034              i.types[this_operand] ^= (Disp16|Disp32);
3035           fudged = 1;
3036           goto tryprefix;
3037         }
3038       if (fudged)
3039         as_bad (_("`%s' is not a valid base/index expression"),
3040                 operand_string);
3041       else
3042 #endif
3043         as_bad (_("`%s' is not a valid %s bit base/index expression"),
3044                 operand_string,
3045                 flag_16bit_code ^ (i.prefix[ADDR_PREFIX] != 0) ? "16" : "32");
3046       return 0;
3047     }
3048   return 1;
3049 }
3050
3051 static int i386_intel_memory_operand PARAMS ((char *));
3052
3053 static int
3054 i386_intel_memory_operand (operand_string)
3055      char *operand_string;
3056 {
3057   char *op_string = operand_string;
3058   char *end_of_operand_string;
3059
3060   if ((i.mem_operands == 1
3061        && (current_templates->start->opcode_modifier & IsString) == 0)
3062       || i.mem_operands == 2)
3063     {
3064       as_bad (_("too many memory references for `%s'"),
3065               current_templates->start->name);
3066       return 0;
3067     }
3068
3069   /* Look for displacement preceding open bracket */
3070   if (*op_string != '[')
3071     {
3072       char *end_seg;
3073       char *temp_string;
3074
3075       end_seg = strchr (op_string, ':');
3076       if (end_seg)
3077         {
3078           if (!i386_parse_seg (op_string))
3079             return 0;
3080           op_string = end_seg + 1;
3081         }
3082
3083       temp_string = build_displacement_string (true, op_string);
3084
3085       if (i.disp_operands == 0 &&
3086           !i386_displacement (temp_string, temp_string + strlen (temp_string)))
3087         return 0;
3088
3089       end_of_operand_string = strchr (op_string, '[');
3090       if (!end_of_operand_string)
3091         end_of_operand_string = op_string + strlen (op_string);
3092
3093       if (is_space_char (*end_of_operand_string))
3094         --end_of_operand_string;
3095
3096       op_string = end_of_operand_string;
3097     }
3098
3099   if (*op_string == '[')
3100     {
3101       ++op_string;
3102
3103       /* Pick off each component and figure out where it belongs */
3104
3105       end_of_operand_string = op_string;
3106
3107       while (*op_string != ']')
3108         {
3109           const reg_entry *temp_reg;
3110           char *end_op;
3111           char *temp_string;
3112
3113           while (*end_of_operand_string != '+'
3114                  && *end_of_operand_string != '-'
3115                  && *end_of_operand_string != '*'
3116                  && *end_of_operand_string != ']')
3117             end_of_operand_string++;
3118
3119           temp_string = op_string;
3120           if (*temp_string == '+')
3121             {
3122               ++temp_string;
3123               if (is_space_char (*temp_string))
3124                 ++temp_string;
3125             }
3126
3127           if ((*temp_string == REGISTER_PREFIX || allow_naked_reg)
3128               && (temp_reg = parse_register (temp_string, &end_op)) != NULL)
3129             {
3130               if (i.base_reg == NULL)
3131                 i.base_reg = temp_reg;
3132               else
3133                 i.index_reg = temp_reg;
3134
3135               i.types[this_operand] |= BaseIndex;
3136             }
3137           else if (*temp_string == REGISTER_PREFIX)
3138             {
3139               as_bad (_("bad register name `%s'"), temp_string);
3140               return 0;
3141             }
3142           else if (is_digit_char (*op_string)
3143                    || *op_string == '+' || *op_string == '-')
3144             {
3145               temp_string = build_displacement_string (false, op_string);
3146
3147               if (*temp_string == '+')
3148                 ++temp_string;
3149
3150               if (i.disp_operands == 0 &&
3151                   !i386_displacement (temp_string, temp_string + strlen (temp_string)))
3152                 return 0;
3153
3154               ++op_string;
3155               end_of_operand_string = op_string;
3156               while (*end_of_operand_string != ']'
3157                      && *end_of_operand_string != '+'
3158                      && *end_of_operand_string != '-'
3159                      && *end_of_operand_string != '*')
3160                 ++end_of_operand_string;
3161             }
3162           else if (*op_string == '*')
3163             {
3164               ++op_string;
3165
3166               if (i.base_reg && !i.index_reg)
3167                 {
3168                   i.index_reg = i.base_reg;
3169                   i.base_reg = 0;
3170                 }
3171
3172               if (!i386_scale (op_string))
3173                 return 0;
3174             }
3175           op_string = end_of_operand_string;
3176           ++end_of_operand_string;
3177         }
3178     }
3179
3180   if (i386_index_check (operand_string) == 0)
3181     return 0;
3182
3183   i.mem_operands++;
3184   return 1;
3185 }
3186
3187 static int
3188 i386_intel_operand (operand_string, got_a_float)
3189      char *operand_string;
3190      int got_a_float;
3191 {
3192   const reg_entry * r;
3193   char *end_op;
3194   char *op_string = operand_string;
3195
3196   int operand_modifier = i386_operand_modifier (&op_string, got_a_float);
3197   if (is_space_char (*op_string))
3198     ++op_string;
3199
3200   switch (operand_modifier)
3201     {
3202     case BYTE_PTR:
3203     case WORD_PTR:
3204     case DWORD_PTR:
3205     case QWORD_PTR:
3206     case XWORD_PTR:
3207       if (!i386_intel_memory_operand (op_string))
3208         return 0;
3209       break;
3210
3211     case FLAT:
3212     case OFFSET_FLAT:
3213       if (!i386_immediate (op_string))
3214         return 0;
3215       break;
3216
3217     case SHORT:
3218     case NONE_FOUND:
3219       /* Should be register or immediate */
3220       if (is_digit_char (*op_string)
3221           && strchr (op_string, '[') == 0)
3222         {
3223           if (!i386_immediate (op_string))
3224             return 0;
3225         }
3226       else if ((*op_string == REGISTER_PREFIX || allow_naked_reg)
3227                && (r = parse_register (op_string, &end_op)) != NULL)
3228         {
3229           /* Check for a segment override by searching for ':' after a
3230              segment register.  */
3231           op_string = end_op;
3232           if (is_space_char (*op_string))
3233             ++op_string;
3234           if (*op_string == ':' && (r->reg_type & (SReg2 | SReg3)))
3235             {
3236               switch (r->reg_num)
3237                 {
3238                 case 0:
3239                   i.seg[i.mem_operands] = &es;
3240                   break;
3241                 case 1:
3242                   i.seg[i.mem_operands] = &cs;
3243                   break;
3244                 case 2:
3245                   i.seg[i.mem_operands] = &ss;
3246                   break;
3247                 case 3:
3248                   i.seg[i.mem_operands] = &ds;
3249                   break;
3250                 case 4:
3251                   i.seg[i.mem_operands] = &fs;
3252                   break;
3253                 case 5:
3254                   i.seg[i.mem_operands] = &gs;
3255                   break;
3256                 }
3257
3258             }
3259           i.types[this_operand] |= r->reg_type & ~BaseIndex;
3260           i.op[this_operand].regs = r;
3261           i.reg_operands++;
3262         }
3263       else if (*op_string == REGISTER_PREFIX)
3264         {
3265           as_bad (_("bad register name `%s'"), op_string);
3266           return 0;
3267         }
3268       else if (!i386_intel_memory_operand (op_string))
3269         return 0;
3270
3271       break;
3272     }  /* end switch */
3273
3274   return 1;
3275 }
3276
3277 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns non-zero
3278    on error. */
3279
3280 static int
3281 i386_operand (operand_string)
3282      char *operand_string;
3283 {
3284   const reg_entry *r;
3285   char *end_op;
3286   char *op_string = operand_string;
3287
3288   if (is_space_char (*op_string))
3289     ++op_string;
3290
3291   /* We check for an absolute prefix (differentiating,
3292      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'. */
3293   if (*op_string == ABSOLUTE_PREFIX)
3294     {
3295       ++op_string;
3296       if (is_space_char (*op_string))
3297         ++op_string;
3298       i.types[this_operand] |= JumpAbsolute;
3299     }
3300
3301   /* Check if operand is a register. */
3302   if ((*op_string == REGISTER_PREFIX || allow_naked_reg)
3303       && (r = parse_register (op_string, &end_op)) != NULL)
3304     {
3305       /* Check for a segment override by searching for ':' after a
3306          segment register.  */
3307       op_string = end_op;
3308       if (is_space_char (*op_string))
3309         ++op_string;
3310       if (*op_string == ':' && (r->reg_type & (SReg2 | SReg3)))
3311         {
3312           switch (r->reg_num)
3313             {
3314             case 0:
3315               i.seg[i.mem_operands] = &es;
3316               break;
3317             case 1:
3318               i.seg[i.mem_operands] = &cs;
3319               break;
3320             case 2:
3321               i.seg[i.mem_operands] = &ss;
3322               break;
3323             case 3:
3324               i.seg[i.mem_operands] = &ds;
3325               break;
3326             case 4:
3327               i.seg[i.mem_operands] = &fs;
3328               break;
3329             case 5:
3330               i.seg[i.mem_operands] = &gs;
3331               break;
3332             }
3333
3334           /* Skip the ':' and whitespace.  */
3335           ++op_string;
3336           if (is_space_char (*op_string))
3337             ++op_string;
3338
3339           if (!is_digit_char (*op_string)
3340               && !is_identifier_char (*op_string)
3341               && *op_string != '('
3342               && *op_string != ABSOLUTE_PREFIX)
3343             {
3344               as_bad (_("bad memory operand `%s'"), op_string);
3345               return 0;
3346             }
3347           /* Handle case of %es:*foo. */
3348           if (*op_string == ABSOLUTE_PREFIX)
3349             {
3350               ++op_string;
3351               if (is_space_char (*op_string))
3352                 ++op_string;
3353               i.types[this_operand] |= JumpAbsolute;
3354             }
3355           goto do_memory_reference;
3356         }
3357       if (*op_string)
3358         {
3359           as_bad (_("Junk `%s' after register"), op_string);
3360           return 0;
3361         }
3362       i.types[this_operand] |= r->reg_type & ~BaseIndex;
3363       i.op[this_operand].regs = r;
3364       i.reg_operands++;
3365     }
3366   else if (*op_string == REGISTER_PREFIX)
3367     {
3368       as_bad (_("bad register name `%s'"), op_string);
3369       return 0;
3370     }
3371   else if (*op_string == IMMEDIATE_PREFIX)
3372     {                           /* ... or an immediate */
3373       ++op_string;
3374       if (i.types[this_operand] & JumpAbsolute)
3375         {
3376           as_bad (_("Immediate operand illegal with absolute jump"));
3377           return 0;
3378         }
3379       if (!i386_immediate (op_string))
3380         return 0;
3381     }
3382   else if (is_digit_char (*op_string)
3383            || is_identifier_char (*op_string)
3384            || *op_string == '(' )
3385     {
3386       /* This is a memory reference of some sort. */
3387       char *base_string;
3388
3389       /* Start and end of displacement string expression (if found). */
3390       char *displacement_string_start;
3391       char *displacement_string_end;
3392
3393     do_memory_reference:
3394       if ((i.mem_operands == 1
3395            && (current_templates->start->opcode_modifier & IsString) == 0)
3396           || i.mem_operands == 2)
3397         {
3398           as_bad (_("too many memory references for `%s'"),
3399                   current_templates->start->name);
3400           return 0;
3401         }
3402
3403       /* Check for base index form.  We detect the base index form by
3404          looking for an ')' at the end of the operand, searching
3405          for the '(' matching it, and finding a REGISTER_PREFIX or ','
3406          after the '('.  */
3407       base_string = op_string + strlen (op_string);
3408
3409       --base_string;
3410       if (is_space_char (*base_string))
3411         --base_string;
3412
3413       /* If we only have a displacement, set-up for it to be parsed later. */
3414       displacement_string_start = op_string;
3415       displacement_string_end = base_string + 1;
3416
3417       if (*base_string == ')')
3418         {
3419           char *temp_string;
3420           unsigned int parens_balanced = 1;
3421           /* We've already checked that the number of left & right ()'s are
3422              equal, so this loop will not be infinite. */
3423           do
3424             {
3425               base_string--;
3426               if (*base_string == ')')
3427                 parens_balanced++;
3428               if (*base_string == '(')
3429                 parens_balanced--;
3430             }
3431           while (parens_balanced);
3432
3433           temp_string = base_string;
3434
3435           /* Skip past '(' and whitespace.  */
3436           ++base_string;
3437           if (is_space_char (*base_string))
3438             ++base_string;
3439
3440           if (*base_string == ','
3441               || ((*base_string == REGISTER_PREFIX || allow_naked_reg)
3442                   && (i.base_reg = parse_register (base_string, &end_op)) != NULL))
3443             {
3444               displacement_string_end = temp_string;
3445
3446               i.types[this_operand] |= BaseIndex;
3447
3448               if (i.base_reg)
3449                 {
3450                   base_string = end_op;
3451                   if (is_space_char (*base_string))
3452                     ++base_string;
3453                 }
3454
3455               /* There may be an index reg or scale factor here.  */
3456               if (*base_string == ',')
3457                 {
3458                   ++base_string;
3459                   if (is_space_char (*base_string))
3460                     ++base_string;
3461
3462                   if ((*base_string == REGISTER_PREFIX || allow_naked_reg)
3463                       && (i.index_reg = parse_register (base_string, &end_op)) != NULL)
3464                     {
3465                       base_string = end_op;
3466                       if (is_space_char (*base_string))
3467                         ++base_string;
3468                       if (*base_string == ',')
3469                         {
3470                           ++base_string;
3471                           if (is_space_char (*base_string))
3472                             ++base_string;
3473                         }
3474                       else if (*base_string != ')' )
3475                         {
3476                           as_bad (_("expecting `,' or `)' after index register in `%s'"),
3477                                   operand_string);
3478                           return 0;
3479                         }
3480                     }
3481                   else if (*base_string == REGISTER_PREFIX)
3482                     {
3483                       as_bad (_("bad register name `%s'"), base_string);
3484                       return 0;
3485                     }
3486
3487                   /* Check for scale factor. */
3488                   if (isdigit ((unsigned char) *base_string))
3489                     {
3490                       if (!i386_scale (base_string))
3491                         return 0;
3492
3493                       ++base_string;
3494                       if (is_space_char (*base_string))
3495                         ++base_string;
3496                       if (*base_string != ')')
3497                         {
3498                           as_bad (_("expecting `)' after scale factor in `%s'"),
3499                                   operand_string);
3500                           return 0;
3501                         }
3502                     }
3503                   else if (!i.index_reg)
3504                     {
3505                       as_bad (_("expecting index register or scale factor after `,'; got '%c'"),
3506                               *base_string);
3507                       return 0;
3508                     }
3509                 }
3510               else if (*base_string != ')')
3511                 {
3512                   as_bad (_("expecting `,' or `)' after base register in `%s'"),
3513                           operand_string);
3514                   return 0;
3515                 }
3516             }
3517           else if (*base_string == REGISTER_PREFIX)
3518             {
3519               as_bad (_("bad register name `%s'"), base_string);
3520               return 0;
3521             }
3522         }
3523
3524       /* If there's an expression beginning the operand, parse it,
3525          assuming displacement_string_start and
3526          displacement_string_end are meaningful.  */
3527       if (displacement_string_start != displacement_string_end)
3528         {
3529           if (!i386_displacement (displacement_string_start,
3530                                   displacement_string_end))
3531             return 0;
3532         }
3533
3534       /* Special case for (%dx) while doing input/output op.  */
3535       if (i.base_reg
3536           && i.base_reg->reg_type == (Reg16 | InOutPortReg)
3537           && i.index_reg == 0
3538           && i.log2_scale_factor == 0
3539           && i.seg[i.mem_operands] == 0
3540           && (i.types[this_operand] & Disp) == 0)
3541         {
3542           i.types[this_operand] = InOutPortReg;
3543           return 1;
3544         }
3545
3546       if (i386_index_check (operand_string) == 0)
3547         return 0;
3548       i.mem_operands++;
3549     }
3550   else
3551     {                           /* it's not a memory operand; argh! */
3552       as_bad (_("invalid char %s beginning operand %d `%s'"),
3553               output_invalid (*op_string),
3554               this_operand + 1,
3555               op_string);
3556       return 0;
3557     }
3558   return 1;                     /* normal return */
3559 }
3560 \f
3561 /*
3562  * md_estimate_size_before_relax()
3563  *
3564  * Called just before relax().
3565  * Any symbol that is now undefined will not become defined.
3566  * Return the correct fr_subtype in the frag.
3567  * Return the initial "guess for fr_var" to caller.
3568  * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
3569  * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
3570  * Although it may not be explicit in the frag, pretend fr_var starts with a
3571  * 0 value.
3572  */
3573 int
3574 md_estimate_size_before_relax (fragP, segment)
3575      register fragS *fragP;
3576      register segT segment;
3577 {
3578   register unsigned char *opcode;
3579   register int old_fr_fix;
3580
3581   old_fr_fix = fragP->fr_fix;
3582   opcode = (unsigned char *) fragP->fr_opcode;
3583   /* We've already got fragP->fr_subtype right;  all we have to do is
3584      check for un-relaxable symbols.  */
3585   if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
3586     {
3587       /* symbol is undefined in this segment */
3588       int code16 = fragP->fr_subtype & CODE16;
3589       int size = code16 ? 2 : 4;
3590 #ifdef BFD_ASSEMBLER
3591       enum bfd_reloc_code_real reloc_type;
3592 #else
3593       int reloc_type;
3594 #endif
3595
3596       if (GOT_symbol /* Not quite right - we should switch on presence of
3597                         @PLT, but I cannot see how to get to that from
3598                         here.  We should have done this in md_assemble to
3599                         really get it right all of the time, but I think it
3600                         does not matter that much, as this will be right
3601                         most of the time. ERY  */
3602           && S_GET_SEGMENT(fragP->fr_symbol) == undefined_section)
3603         reloc_type = BFD_RELOC_386_PLT32;
3604       else if (code16)
3605         reloc_type = BFD_RELOC_16_PCREL;
3606       else
3607         reloc_type = BFD_RELOC_32_PCREL;
3608
3609       switch (opcode[0])
3610         {
3611         case JUMP_PC_RELATIVE:  /* make jmp (0xeb) a dword displacement jump */
3612           opcode[0] = 0xe9;     /* dword disp jmp */
3613           fragP->fr_fix += size;
3614           fix_new (fragP, old_fr_fix, size,
3615                    fragP->fr_symbol,
3616                    fragP->fr_offset, 1,
3617                    reloc_type);
3618           break;
3619
3620         default:
3621           /* This changes the byte-displacement jump 0x7N
3622              to the dword-displacement jump 0x0f,0x8N.  */
3623           opcode[1] = opcode[0] + 0x10;
3624           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
3625           fragP->fr_fix += 1 + size;    /* we've added an opcode byte */
3626           fix_new (fragP, old_fr_fix + 1, size,
3627                    fragP->fr_symbol,
3628                    fragP->fr_offset, 1,
3629                    reloc_type);
3630           break;
3631         }
3632       frag_wane (fragP);
3633     }
3634   return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
3635 }                               /* md_estimate_size_before_relax() */
3636 \f
3637 /*
3638  *                      md_convert_frag();
3639  *
3640  * Called after relax() is finished.
3641  * In:  Address of frag.
3642  *      fr_type == rs_machine_dependent.
3643  *      fr_subtype is what the address relaxed to.
3644  *
3645  * Out: Any fixSs and constants are set up.
3646  *      Caller will turn frag into a ".space 0".
3647  */
3648 #ifndef BFD_ASSEMBLER
3649 void
3650 md_convert_frag (headers, sec, fragP)
3651      object_headers *headers ATTRIBUTE_UNUSED;
3652      segT sec ATTRIBUTE_UNUSED;
3653      register fragS *fragP;
3654 #else
3655 void
3656 md_convert_frag (abfd, sec, fragP)
3657      bfd *abfd ATTRIBUTE_UNUSED;
3658      segT sec ATTRIBUTE_UNUSED;
3659      register fragS *fragP;
3660 #endif
3661 {
3662   register unsigned char *opcode;
3663   unsigned char *where_to_put_displacement = NULL;
3664   unsigned int target_address;
3665   unsigned int opcode_address;
3666   unsigned int extension = 0;
3667   int displacement_from_opcode_start;
3668
3669   opcode = (unsigned char *) fragP->fr_opcode;
3670
3671   /* Address we want to reach in file space. */
3672   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
3673 #ifdef BFD_ASSEMBLER /* not needed otherwise? */
3674   target_address += symbol_get_frag (fragP->fr_symbol)->fr_address;
3675 #endif
3676
3677   /* Address opcode resides at in file space. */
3678   opcode_address = fragP->fr_address + fragP->fr_fix;
3679
3680   /* Displacement from opcode start to fill into instruction. */
3681   displacement_from_opcode_start = target_address - opcode_address;
3682
3683   switch (fragP->fr_subtype)
3684     {
3685     case ENCODE_RELAX_STATE (COND_JUMP, SMALL):
3686     case ENCODE_RELAX_STATE (COND_JUMP, SMALL16):
3687     case ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL):
3688     case ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL16):
3689       /* don't have to change opcode */
3690       extension = 1;            /* 1 opcode + 1 displacement */
3691       where_to_put_displacement = &opcode[1];
3692       break;
3693
3694     case ENCODE_RELAX_STATE (COND_JUMP, BIG):
3695       extension = 5;            /* 2 opcode + 4 displacement */
3696       opcode[1] = opcode[0] + 0x10;
3697       opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
3698       where_to_put_displacement = &opcode[2];
3699       break;
3700
3701     case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
3702       extension = 4;            /* 1 opcode + 4 displacement */
3703       opcode[0] = 0xe9;
3704       where_to_put_displacement = &opcode[1];
3705       break;
3706
3707     case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
3708       extension = 3;            /* 2 opcode + 2 displacement */
3709       opcode[1] = opcode[0] + 0x10;
3710       opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
3711       where_to_put_displacement = &opcode[2];
3712       break;
3713
3714     case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
3715       extension = 2;            /* 1 opcode + 2 displacement */
3716       opcode[0] = 0xe9;
3717       where_to_put_displacement = &opcode[1];
3718       break;
3719
3720     default:
3721       BAD_CASE (fragP->fr_subtype);
3722       break;
3723     }
3724   /* now put displacement after opcode */
3725   md_number_to_chars ((char *) where_to_put_displacement,
3726                       (valueT) (displacement_from_opcode_start - extension),
3727                       SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
3728   fragP->fr_fix += extension;
3729 }
3730 \f
3731
3732 int md_short_jump_size = 2;     /* size of byte displacement jmp */
3733 int md_long_jump_size = 5;      /* size of dword displacement jmp */
3734 const int md_reloc_size = 8;    /* Size of relocation record */
3735
3736 void
3737 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
3738      char *ptr;
3739      addressT from_addr, to_addr;
3740      fragS *frag ATTRIBUTE_UNUSED;
3741      symbolS *to_symbol ATTRIBUTE_UNUSED;
3742 {
3743   long offset;
3744
3745   offset = to_addr - (from_addr + 2);
3746   md_number_to_chars (ptr, (valueT) 0xeb, 1);   /* opcode for byte-disp jump */
3747   md_number_to_chars (ptr + 1, (valueT) offset, 1);
3748 }
3749
3750 void
3751 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
3752      char *ptr;
3753      addressT from_addr, to_addr;
3754      fragS *frag;
3755      symbolS *to_symbol;
3756 {
3757   long offset;
3758
3759   if (flag_do_long_jump)
3760     {
3761       offset = to_addr - S_GET_VALUE (to_symbol);
3762       md_number_to_chars (ptr, (valueT) 0xe9, 1);/* opcode for long jmp */
3763       md_number_to_chars (ptr + 1, (valueT) offset, 4);
3764       fix_new (frag, (ptr + 1) - frag->fr_literal, 4,
3765                to_symbol, (offsetT) 0, 0, BFD_RELOC_32);
3766     }
3767   else
3768     {
3769       offset = to_addr - (from_addr + 5);
3770       md_number_to_chars (ptr, (valueT) 0xe9, 1);
3771       md_number_to_chars (ptr + 1, (valueT) offset, 4);
3772     }
3773 }
3774 \f
3775 /* Apply a fixup (fixS) to segment data, once it has been determined
3776    by our caller that we have all the info we need to fix it up.
3777
3778    On the 386, immediates, displacements, and data pointers are all in
3779    the same (little-endian) format, so we don't need to care about which
3780    we are handling.  */
3781
3782 int
3783 md_apply_fix3 (fixP, valp, seg)
3784      fixS *fixP;                /* The fix we're to put in.  */
3785      valueT *valp;              /* Pointer to the value of the bits.  */
3786      segT seg ATTRIBUTE_UNUSED; /* Segment fix is from.  */
3787 {
3788   register char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
3789   valueT value = *valp;
3790
3791 #if defined (BFD_ASSEMBLER) && !defined (TE_Mach)
3792   if (fixP->fx_pcrel)
3793     {
3794       switch (fixP->fx_r_type)
3795         {
3796         default:
3797           break;
3798
3799         case BFD_RELOC_32:
3800           fixP->fx_r_type = BFD_RELOC_32_PCREL;
3801           break;
3802         case BFD_RELOC_16:
3803           fixP->fx_r_type = BFD_RELOC_16_PCREL;
3804           break;
3805         case BFD_RELOC_8:
3806           fixP->fx_r_type = BFD_RELOC_8_PCREL;
3807           break;
3808         }
3809     }
3810
3811   /* This is a hack.  There should be a better way to handle this.
3812      This covers for the fact that bfd_install_relocation will
3813      subtract the current location (for partial_inplace, PC relative
3814      relocations); see more below.  */
3815   if ((fixP->fx_r_type == BFD_RELOC_32_PCREL
3816        || fixP->fx_r_type == BFD_RELOC_16_PCREL
3817        || fixP->fx_r_type == BFD_RELOC_8_PCREL)
3818       && fixP->fx_addsy)
3819     {
3820 #ifndef OBJ_AOUT
3821       if (OUTPUT_FLAVOR == bfd_target_elf_flavour
3822 #ifdef TE_PE
3823           || OUTPUT_FLAVOR == bfd_target_coff_flavour
3824 #endif
3825           )
3826         value += fixP->fx_where + fixP->fx_frag->fr_address;
3827 #endif
3828 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3829       if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
3830         {
3831           segT fseg = S_GET_SEGMENT (fixP->fx_addsy);
3832
3833           if ((fseg == seg
3834                || (symbol_section_p (fixP->fx_addsy)
3835                    && fseg != absolute_section))
3836               && ! S_IS_EXTERNAL (fixP->fx_addsy)
3837               && ! S_IS_WEAK (fixP->fx_addsy)
3838               && S_IS_DEFINED (fixP->fx_addsy)
3839               && ! S_IS_COMMON (fixP->fx_addsy))
3840             {
3841               /* Yes, we add the values in twice.  This is because
3842                  bfd_perform_relocation subtracts them out again.  I think
3843                  bfd_perform_relocation is broken, but I don't dare change
3844                  it.  FIXME.  */
3845               value += fixP->fx_where + fixP->fx_frag->fr_address;
3846             }
3847         }
3848 #endif
3849 #if defined (OBJ_COFF) && defined (TE_PE)
3850       /* For some reason, the PE format does not store a section
3851          address offset for a PC relative symbol.  */
3852       if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
3853         value += md_pcrel_from (fixP);
3854       else if (S_IS_EXTERNAL (fixP->fx_addsy)
3855                || S_IS_WEAK (fixP->fx_addsy))
3856         {
3857           /* We are generating an external relocation for this defined
3858              symbol.  We add the address, because
3859              bfd_install_relocation will subtract it.  VALUE already
3860              holds the symbol value, because fixup_segment added it
3861              in.  We subtract it out, and then we subtract it out
3862              again because bfd_install_relocation will add it in
3863              again.  */
3864           value += md_pcrel_from (fixP);
3865           value -= 2 * S_GET_VALUE (fixP->fx_addsy);
3866         }
3867 #endif
3868     }
3869 #ifdef TE_PE
3870   else if (fixP->fx_addsy != NULL
3871            && S_IS_DEFINED (fixP->fx_addsy)
3872            && (S_IS_EXTERNAL (fixP->fx_addsy)
3873                || S_IS_WEAK (fixP->fx_addsy)))
3874     {
3875       /* We are generating an external relocation for this defined
3876          symbol.  VALUE already holds the symbol value, and
3877          bfd_install_relocation will add it in again.  We don't want
3878          either addition.  */
3879       value -= 2 * S_GET_VALUE (fixP->fx_addsy);
3880     }
3881 #endif
3882
3883   /* Fix a few things - the dynamic linker expects certain values here,
3884      and we must not dissappoint it. */
3885 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3886   if (OUTPUT_FLAVOR == bfd_target_elf_flavour
3887       && fixP->fx_addsy)
3888     switch (fixP->fx_r_type) {
3889     case BFD_RELOC_386_PLT32:
3890       /* Make the jump instruction point to the address of the operand.  At
3891          runtime we merely add the offset to the actual PLT entry. */
3892       value = 0xfffffffc;
3893       break;
3894     case BFD_RELOC_386_GOTPC:
3895 /*
3896  *   This is tough to explain.  We end up with this one if we have
3897  * operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal
3898  * here is to obtain the absolute address of the GOT, and it is strongly
3899  * preferable from a performance point of view to avoid using a runtime
3900  * relocation for this.  The actual sequence of instructions often look
3901  * something like:
3902  *
3903  *      call    .L66
3904  * .L66:
3905  *      popl    %ebx
3906  *      addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
3907  *
3908  *   The call and pop essentially return the absolute address of
3909  * the label .L66 and store it in %ebx.  The linker itself will
3910  * ultimately change the first operand of the addl so that %ebx points to
3911  * the GOT, but to keep things simple, the .o file must have this operand
3912  * set so that it generates not the absolute address of .L66, but the
3913  * absolute address of itself.  This allows the linker itself simply
3914  * treat a GOTPC relocation as asking for a pcrel offset to the GOT to be
3915  * added in, and the addend of the relocation is stored in the operand
3916  * field for the instruction itself.
3917  *
3918  *   Our job here is to fix the operand so that it would add the correct
3919  * offset so that %ebx would point to itself.  The thing that is tricky is
3920  * that .-.L66 will point to the beginning of the instruction, so we need
3921  * to further modify the operand so that it will point to itself.
3922  * There are other cases where you have something like:
3923  *
3924  *      .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
3925  *
3926  * and here no correction would be required.  Internally in the assembler
3927  * we treat operands of this form as not being pcrel since the '.' is
3928  * explicitly mentioned, and I wonder whether it would simplify matters
3929  * to do it this way.  Who knows.  In earlier versions of the PIC patches,
3930  * the pcrel_adjust field was used to store the correction, but since the
3931  * expression is not pcrel, I felt it would be confusing to do it this way.
3932  */
3933       value -= 1;
3934       break;
3935     case BFD_RELOC_386_GOT32:
3936       value = 0; /* Fully resolved at runtime.  No addend.  */
3937       break;
3938     case BFD_RELOC_386_GOTOFF:
3939       break;
3940
3941     case BFD_RELOC_VTABLE_INHERIT:
3942     case BFD_RELOC_VTABLE_ENTRY:
3943       fixP->fx_done = 0;
3944       return 1;
3945
3946     default:
3947       break;
3948     }
3949 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) */
3950   *valp = value;
3951 #endif /* defined (BFD_ASSEMBLER) && !defined (TE_Mach) */
3952   md_number_to_chars (p, value, fixP->fx_size);
3953
3954   return 1;
3955 }
3956
3957 #if 0
3958 /* This is never used.  */
3959 long                            /* Knows about the byte order in a word. */
3960 md_chars_to_number (con, nbytes)
3961      unsigned char con[];       /* Low order byte 1st. */
3962      int nbytes;                /* Number of bytes in the input. */
3963 {
3964   long retval;
3965   for (retval = 0, con += nbytes - 1; nbytes--; con--)
3966     {
3967       retval <<= BITS_PER_CHAR;
3968       retval |= *con;
3969     }
3970   return retval;
3971 }
3972 #endif /* 0 */
3973 \f
3974
3975 #define MAX_LITTLENUMS 6
3976
3977 /* Turn the string pointed to by litP into a floating point constant of type
3978    type, and emit the appropriate bytes.  The number of LITTLENUMS emitted
3979    is stored in *sizeP .  An error message is returned, or NULL on OK.  */
3980 char *
3981 md_atof (type, litP, sizeP)
3982      int type;
3983      char *litP;
3984      int *sizeP;
3985 {
3986   int prec;
3987   LITTLENUM_TYPE words[MAX_LITTLENUMS];
3988   LITTLENUM_TYPE *wordP;
3989   char *t;
3990
3991   switch (type)
3992     {
3993     case 'f':
3994     case 'F':
3995       prec = 2;
3996       break;
3997
3998     case 'd':
3999     case 'D':
4000       prec = 4;
4001       break;
4002
4003     case 'x':
4004     case 'X':
4005       prec = 5;
4006       break;
4007
4008     default:
4009       *sizeP = 0;
4010       return _("Bad call to md_atof ()");
4011     }
4012   t = atof_ieee (input_line_pointer, type, words);
4013   if (t)
4014     input_line_pointer = t;
4015
4016   *sizeP = prec * sizeof (LITTLENUM_TYPE);
4017   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
4018      the bigendian 386.  */
4019   for (wordP = words + prec - 1; prec--;)
4020     {
4021       md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
4022       litP += sizeof (LITTLENUM_TYPE);
4023     }
4024   return 0;
4025 }
4026 \f
4027 char output_invalid_buf[8];
4028
4029 static char * output_invalid PARAMS ((int));
4030
4031 static char *
4032 output_invalid (c)
4033      int c;
4034 {
4035   if (isprint (c))
4036     sprintf (output_invalid_buf, "'%c'", c);
4037   else
4038     sprintf (output_invalid_buf, "(0x%x)", (unsigned) c);
4039   return output_invalid_buf;
4040 }
4041
4042
4043 /* REG_STRING starts *before* REGISTER_PREFIX.  */
4044
4045 static const reg_entry *
4046 parse_register (reg_string, end_op)
4047      char *reg_string;
4048      char **end_op;
4049 {
4050   char *s = reg_string;
4051   char *p;
4052   char reg_name_given[MAX_REG_NAME_SIZE + 1];
4053   const reg_entry *r;
4054
4055   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
4056   if (*s == REGISTER_PREFIX)
4057     ++s;
4058
4059   if (is_space_char (*s))
4060     ++s;
4061
4062   p = reg_name_given;
4063   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
4064     {
4065       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
4066         return (const reg_entry *) NULL;
4067       s++;
4068     }
4069
4070   *end_op = s;
4071
4072   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
4073
4074   /* Handle floating point regs, allowing spaces in the (i) part.  */
4075   if (r == i386_regtab /* %st is first entry of table */)
4076     {
4077       if (is_space_char (*s))
4078         ++s;
4079       if (*s == '(')
4080         {
4081           ++s;
4082           if (is_space_char (*s))
4083             ++s;
4084           if (*s >= '0' && *s <= '7')
4085             {
4086               r = &i386_float_regtab[*s - '0'];
4087               ++s;
4088               if (is_space_char (*s))
4089                 ++s;
4090               if (*s == ')')
4091                 {
4092                   *end_op = s + 1;
4093                   return r;
4094                 }
4095             }
4096           /* We have "%st(" then garbage */
4097           return (const reg_entry *) NULL;
4098         }
4099     }
4100
4101   return r;
4102 }
4103 \f
4104 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4105 CONST char *md_shortopts = "kmVQ:sq";
4106 #else
4107 CONST char *md_shortopts = "m";
4108 #endif
4109 struct option md_longopts[] = {
4110   {NULL, no_argument, NULL, 0}
4111 };
4112 size_t md_longopts_size = sizeof (md_longopts);
4113
4114 int
4115 md_parse_option (c, arg)
4116      int c;
4117      char *arg ATTRIBUTE_UNUSED;
4118 {
4119   switch (c)
4120     {
4121     case 'm':
4122       flag_do_long_jump = 1;
4123       break;
4124
4125 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4126       /* -k: Ignore for FreeBSD compatibility.  */
4127     case 'k':
4128       break;
4129
4130       /* -V: SVR4 argument to print version ID.  */
4131     case 'V':
4132       print_version_id ();
4133       break;
4134
4135       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
4136          should be emitted or not.  FIXME: Not implemented.  */
4137     case 'Q':
4138       break;
4139
4140     case 's':
4141       /* -s: On i386 Solaris, this tells the native assembler to use
4142          .stab instead of .stab.excl.  We always use .stab anyhow.  */
4143       break;
4144
4145     case 'q':
4146       /* -q: On i386 Solaris, this tells the native assembler does
4147          fewer checks.  */
4148       break;
4149 #endif
4150
4151     default:
4152       return 0;
4153     }
4154   return 1;
4155 }
4156
4157 void
4158 md_show_usage (stream)
4159      FILE *stream;
4160 {
4161   fprintf (stream, _("\
4162   -m                      do long jump\n"));
4163 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4164   fprintf (stream, _("\
4165   -V                      print assembler version number\n\
4166   -k                      ignored\n\
4167   -Qy, -Qn                ignored\n\
4168   -q                      ignored\n\
4169   -s                      ignored\n"));
4170 #endif
4171 }
4172
4173 #ifdef BFD_ASSEMBLER
4174 #if ((defined (OBJ_MAYBE_ELF) && defined (OBJ_MAYBE_COFF)) \
4175      || (defined (OBJ_MAYBE_ELF) && defined (OBJ_MAYBE_AOUT)) \
4176      || (defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)))
4177
4178 /* Pick the target format to use.  */
4179
4180 const char  *
4181 i386_target_format ()
4182 {
4183   switch (OUTPUT_FLAVOR)
4184     {
4185 #ifdef OBJ_MAYBE_AOUT
4186     case bfd_target_aout_flavour:
4187      return AOUT_TARGET_FORMAT;
4188 #endif
4189 #ifdef OBJ_MAYBE_COFF
4190     case bfd_target_coff_flavour:
4191       return "coff-i386";
4192 #endif
4193 #ifdef OBJ_MAYBE_ELF
4194     case bfd_target_elf_flavour:
4195       return "elf32-i386";
4196 #endif
4197     default:
4198       abort ();
4199       return NULL;
4200     }
4201 }
4202
4203 #endif /* OBJ_MAYBE_ more than one */
4204 #endif /* BFD_ASSEMBLER */
4205 \f
4206 symbolS *
4207 md_undefined_symbol (name)
4208      char *name;
4209 {
4210   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
4211       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
4212       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
4213       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
4214     {
4215       if (!GOT_symbol)
4216         {
4217           if (symbol_find (name))
4218             as_bad (_("GOT already in symbol table"));
4219           GOT_symbol = symbol_new (name, undefined_section,
4220                                    (valueT) 0, &zero_address_frag);
4221         };
4222       return GOT_symbol;
4223     }
4224   return 0;
4225 }
4226
4227 /* Round up a section size to the appropriate boundary.  */
4228 valueT
4229 md_section_align (segment, size)
4230      segT segment ATTRIBUTE_UNUSED;
4231      valueT size;
4232 {
4233 #ifdef BFD_ASSEMBLER
4234 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
4235   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
4236     {
4237       /* For a.out, force the section size to be aligned.  If we don't do
4238          this, BFD will align it for us, but it will not write out the
4239          final bytes of the section.  This may be a bug in BFD, but it is
4240          easier to fix it here since that is how the other a.out targets
4241          work.  */
4242       int align;
4243
4244       align = bfd_get_section_alignment (stdoutput, segment);
4245       size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
4246     }
4247 #endif
4248 #endif
4249
4250   return size;
4251 }
4252
4253 /* On the i386, PC-relative offsets are relative to the start of the
4254    next instruction.  That is, the address of the offset, plus its
4255    size, since the offset is always the last part of the insn.  */
4256
4257 long
4258 md_pcrel_from (fixP)
4259      fixS *fixP;
4260 {
4261   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
4262 }
4263
4264 #ifndef I386COFF
4265
4266 static void
4267 s_bss (ignore)
4268      int ignore ATTRIBUTE_UNUSED;
4269 {
4270   register int temp;
4271
4272   temp = get_absolute_expression ();
4273   subseg_set (bss_section, (subsegT) temp);
4274   demand_empty_rest_of_line ();
4275 }
4276
4277 #endif
4278
4279
4280 #ifdef BFD_ASSEMBLER
4281
4282 void
4283 i386_validate_fix (fixp)
4284      fixS *fixp;
4285 {
4286   if (fixp->fx_subsy && fixp->fx_subsy == GOT_symbol)
4287     {
4288       fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
4289       fixp->fx_subsy = 0;
4290     }
4291 }
4292
4293 arelent *
4294 tc_gen_reloc (section, fixp)
4295      asection *section ATTRIBUTE_UNUSED;
4296      fixS *fixp;
4297 {
4298   arelent *rel;
4299   bfd_reloc_code_real_type code;
4300
4301   switch (fixp->fx_r_type)
4302     {
4303     case BFD_RELOC_386_PLT32:
4304     case BFD_RELOC_386_GOT32:
4305     case BFD_RELOC_386_GOTOFF:
4306     case BFD_RELOC_386_GOTPC:
4307     case BFD_RELOC_RVA:
4308     case BFD_RELOC_VTABLE_ENTRY:
4309     case BFD_RELOC_VTABLE_INHERIT:
4310       code = fixp->fx_r_type;
4311       break;
4312     default:
4313       if (fixp->fx_pcrel)
4314         {
4315           switch (fixp->fx_size)
4316             {
4317             default:
4318               as_bad (_("Can not do %d byte pc-relative relocation"),
4319                       fixp->fx_size);
4320               code = BFD_RELOC_32_PCREL;
4321               break;
4322             case 1: code = BFD_RELOC_8_PCREL;  break;
4323             case 2: code = BFD_RELOC_16_PCREL; break;
4324             case 4: code = BFD_RELOC_32_PCREL; break;
4325             }
4326         }
4327       else
4328         {
4329           switch (fixp->fx_size)
4330             {
4331             default:
4332               as_bad (_("Can not do %d byte relocation"), fixp->fx_size);
4333               code = BFD_RELOC_32;
4334               break;
4335             case 1: code = BFD_RELOC_8;  break;
4336             case 2: code = BFD_RELOC_16; break;
4337             case 4: code = BFD_RELOC_32; break;
4338             }
4339         }
4340       break;
4341     }
4342
4343   if (code == BFD_RELOC_32
4344       && GOT_symbol
4345       && fixp->fx_addsy == GOT_symbol)
4346     code = BFD_RELOC_386_GOTPC;
4347
4348   rel = (arelent *) xmalloc (sizeof (arelent));
4349   rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
4350   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
4351
4352   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
4353   /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
4354      vtable entry to be used in the relocation's section offset.  */
4355   if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
4356     rel->address = fixp->fx_offset;
4357
4358   if (fixp->fx_pcrel)
4359     rel->addend = fixp->fx_addnumber;
4360   else
4361     rel->addend = 0;
4362
4363   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
4364   if (rel->howto == NULL)
4365     {
4366       as_bad_where (fixp->fx_file, fixp->fx_line,
4367                     _("Cannot represent relocation type %s"),
4368                     bfd_get_reloc_code_name (code));
4369       /* Set howto to a garbage value so that we can keep going.  */
4370       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
4371       assert (rel->howto != NULL);
4372     }
4373
4374   return rel;
4375 }
4376
4377 #else /* ! BFD_ASSEMBLER */
4378
4379 #if (defined(OBJ_AOUT) | defined(OBJ_BOUT))
4380 void
4381 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
4382      char *where;
4383      fixS *fixP;
4384      relax_addressT segment_address_in_file;
4385 {
4386   /*
4387    * In: length of relocation (or of address) in chars: 1, 2 or 4.
4388    * Out: GNU LD relocation length code: 0, 1, or 2.
4389    */
4390
4391   static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
4392   long r_symbolnum;
4393
4394   know (fixP->fx_addsy != NULL);
4395
4396   md_number_to_chars (where,
4397                       (valueT) (fixP->fx_frag->fr_address
4398                                 + fixP->fx_where - segment_address_in_file),
4399                       4);
4400
4401   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
4402                  ? S_GET_TYPE (fixP->fx_addsy)
4403                  : fixP->fx_addsy->sy_number);
4404
4405   where[6] = (r_symbolnum >> 16) & 0x0ff;
4406   where[5] = (r_symbolnum >> 8) & 0x0ff;
4407   where[4] = r_symbolnum & 0x0ff;
4408   where[7] = ((((!S_IS_DEFINED (fixP->fx_addsy)) << 3) & 0x08)
4409               | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
4410               | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
4411 }
4412
4413 #endif /* OBJ_AOUT or OBJ_BOUT */
4414
4415 #if defined (I386COFF)
4416
4417 short
4418 tc_coff_fix2rtype (fixP)
4419      fixS *fixP;
4420 {
4421   if (fixP->fx_r_type == R_IMAGEBASE)
4422     return R_IMAGEBASE;
4423
4424   return (fixP->fx_pcrel ?
4425           (fixP->fx_size == 1 ? R_PCRBYTE :
4426            fixP->fx_size == 2 ? R_PCRWORD :
4427            R_PCRLONG) :
4428           (fixP->fx_size == 1 ? R_RELBYTE :
4429            fixP->fx_size == 2 ? R_RELWORD :
4430            R_DIR32));
4431 }
4432
4433 int
4434 tc_coff_sizemachdep (frag)
4435      fragS *frag;
4436 {
4437   if (frag->fr_next)
4438     return (frag->fr_next->fr_address - frag->fr_address);
4439   else
4440     return 0;
4441 }
4442
4443 #endif /* I386COFF */
4444
4445 #endif /* ! BFD_ASSEMBLER */
4446 \f
4447 /* end of tc-i386.c */