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