gas/config/tc-i386.c

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