gas/config/tc-i386.c

   1 /* i386.c -- Assemble code for the Intel 80386
   2    Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 /* Intel 80386 machine specific gas.
  24    Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
  25    x86_64 support by Jan Hubicka (jh@suse.cz)
  26    Bugs & suggestions are completely welcome.  This is free software.
  27    Please help us make it better.  */
  28
  29 #include "as.h"
  30 #include "safe-ctype.h"
  31 #include "subsegs.h"
  32 #include "dwarf2dbg.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 #ifdef BFD_ASSEMBLER
  52 #define RELOC_ENUM enum bfd_reloc_code_real
  53 #else
  54 #define RELOC_ENUM int
  55 #endif
  56
  57 #ifndef DEFAULT_ARCH
  58 #define DEFAULT_ARCH "i386"
  59 #endif
  60
  61 #ifndef INLINE
  62 #if __GNUC__ >= 2
  63 #define INLINE __inline__
  64 #else
  65 #define INLINE
  66 #endif
  67 #endif
  68
  69 static INLINE unsigned int mode_from_disp_size PARAMS ((unsigned int));
  70 static INLINE int fits_in_signed_byte PARAMS ((offsetT));
  71 static INLINE int fits_in_unsigned_byte PARAMS ((offsetT));
  72 static INLINE int fits_in_unsigned_word PARAMS ((offsetT));
  73 static INLINE int fits_in_signed_word PARAMS ((offsetT));
  74 static INLINE int fits_in_unsigned_long PARAMS ((offsetT));
  75 static INLINE int fits_in_signed_long PARAMS ((offsetT));
  76 static int smallest_imm_type PARAMS ((offsetT));
  77 static offsetT offset_in_range PARAMS ((offsetT, int));
  78 static int add_prefix PARAMS ((unsigned int));
  79 static void set_code_flag PARAMS ((int));
  80 static void set_16bit_gcc_code_flag PARAMS ((int));
  81 static void set_intel_syntax PARAMS ((int));
  82 static void set_cpu_arch PARAMS ((int));
  83 static char *output_invalid PARAMS ((int c));
  84 static int i386_operand PARAMS ((char *operand_string));
  85 static int i386_intel_operand PARAMS ((char *operand_string, int got_a_float));
  86 static const reg_entry *parse_register PARAMS ((char *reg_string,
  87                                                 char **end_op));
  88 static char *parse_insn PARAMS ((char *, char *));
  89 static char *parse_operands PARAMS ((char *, const char *));
  90 static void swap_operands PARAMS ((void));
  91 static void optimize_imm PARAMS ((void));
  92 static void optimize_disp PARAMS ((void));
  93 static int match_template PARAMS ((void));
  94 static int check_string PARAMS ((void));
  95 static int process_suffix PARAMS ((void));
  96 static int check_byte_reg PARAMS ((void));
  97 static int check_long_reg PARAMS ((void));
  98 static int check_qword_reg PARAMS ((void));
  99 static int check_word_reg PARAMS ((void));
 100 static int finalize_imm PARAMS ((void));
 101 static int process_operands PARAMS ((void));
 102 static const seg_entry *build_modrm_byte PARAMS ((void));
 103 static void output_insn PARAMS ((void));
 104 static void output_branch PARAMS ((void));
 105 static void output_jump PARAMS ((void));
 106 static void output_interseg_jump PARAMS ((void));
 107 static void output_imm PARAMS ((fragS *insn_start_frag,
 108                                 offsetT insn_start_off));
 109 static void output_disp PARAMS ((fragS *insn_start_frag,
 110                                  offsetT insn_start_off));
 111 #ifndef I386COFF
 112 static void s_bss PARAMS ((int));
 113 #endif
 114
 115 static const char *default_arch = DEFAULT_ARCH;
 116
 117 /* 'md_assemble ()' gathers together information and puts it into a
 118    i386_insn.  */
 119
 120 union i386_op
 121   {
 122     expressionS *disps;
 123     expressionS *imms;
 124     const reg_entry *regs;
 125   };
 126
 127 struct _i386_insn
 128   {
 129     /* TM holds the template for the insn were currently assembling.  */
 130     template tm;
 131
 132     /* SUFFIX holds the instruction mnemonic suffix if given.
 133        (e.g. 'l' for 'movl')  */
 134     char suffix;
 135
 136     /* OPERANDS gives the number of given operands.  */
 137     unsigned int operands;
 138
 139     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
 140        of given register, displacement, memory operands and immediate
 141        operands.  */
 142     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
 143
 144     /* TYPES [i] is the type (see above #defines) which tells us how to
 145        use OP[i] for the corresponding operand.  */
 146     unsigned int types[MAX_OPERANDS];
 147
 148     /* Displacement expression, immediate expression, or register for each
 149        operand.  */
 150     union i386_op op[MAX_OPERANDS];
 151
 152     /* Flags for operands.  */
 153     unsigned int flags[MAX_OPERANDS];
 154 #define Operand_PCrel 1
 155
 156     /* Relocation type for operand */
 157     RELOC_ENUM reloc[MAX_OPERANDS];
 158
 159     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
 160        the base index byte below.  */
 161     const reg_entry *base_reg;
 162     const reg_entry *index_reg;
 163     unsigned int log2_scale_factor;
 164
 165     /* SEG gives the seg_entries of this insn.  They are zero unless
 166        explicit segment overrides are given.  */
 167     const seg_entry *seg[2];
 168
 169     /* PREFIX holds all the given prefix opcodes (usually null).
 170        PREFIXES is the number of prefix opcodes.  */
 171     unsigned int prefixes;
 172     unsigned char prefix[MAX_PREFIXES];
 173
 174     /* RM and SIB are the modrm byte and the sib byte where the
 175        addressing modes of this insn are encoded.  */
 176
 177     modrm_byte rm;
 178     rex_byte rex;
 179     sib_byte sib;
 180   };
 181
 182 typedef struct _i386_insn i386_insn;
 183
 184 /* List of chars besides those in app.c:symbol_chars that can start an
 185    operand.  Used to prevent the scrubber eating vital white-space.  */
 186 #ifdef LEX_AT
 187 const char extra_symbol_chars[] = "*%-(@[";
 188 #else
 189 const char extra_symbol_chars[] = "*%-([";
 190 #endif
 191
 192 #if (defined (TE_I386AIX)                               \
 193      || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
 194          && !defined (TE_LINUX)                         \
 195          && !defined (TE_FreeBSD)                       \
 196          && !defined (TE_NetBSD)))
 197 /* This array holds the chars that always start a comment.  If the
 198    pre-processor is disabled, these aren't very useful.  */
 199 const char comment_chars[] = "#/";
 200 #define PREFIX_SEPARATOR '\\'
 201
 202 /* This array holds the chars that only start a comment at the beginning of
 203    a line.  If the line seems to have the form '# 123 filename'
 204    .line and .file directives will appear in the pre-processed output.
 205    Note that input_file.c hand checks for '#' at the beginning of the
 206    first line of the input file.  This is because the compiler outputs
 207    #NO_APP at the beginning of its output.
 208    Also note that comments started like this one will always work if
 209    '/' isn't otherwise defined.  */
 210 const char line_comment_chars[] = "";
 211
 212 #else
 213 /* Putting '/' here makes it impossible to use the divide operator.
 214    However, we need it for compatibility with SVR4 systems.  */
 215 const char comment_chars[] = "#";
 216 #define PREFIX_SEPARATOR '/'
 217
 218 const char line_comment_chars[] = "/";
 219 #endif
 220
 221 const char line_separator_chars[] = ";";
 222
 223 /* Chars that can be used to separate mant from exp in floating point
 224    nums.  */
 225 const char EXP_CHARS[] = "eE";
 226
 227 /* Chars that mean this number is a floating point constant
 228    As in 0f12.456
 229    or    0d1.2345e12.  */
 230 const char FLT_CHARS[] = "fFdDxX";
 231
 232 /* Tables for lexical analysis.  */
 233 static char mnemonic_chars[256];
 234 static char register_chars[256];
 235 static char operand_chars[256];
 236 static char identifier_chars[256];
 237 static char digit_chars[256];
 238
 239 /* Lexical macros.  */
 240 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 241 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 242 #define is_register_char(x) (register_chars[(unsigned char) x])
 243 #define is_space_char(x) ((x) == ' ')
 244 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 245 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 246
 247 /* All non-digit non-letter charcters that may occur in an operand.  */
 248 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 249
 250 /* md_assemble() always leaves the strings it's passed unaltered.  To
 251    effect this we maintain a stack of saved characters that we've smashed
 252    with '\0's (indicating end of strings for various sub-fields of the
 253    assembler instruction).  */
 254 static char save_stack[32];
 255 static char *save_stack_p;
 256 #define END_STRING_AND_SAVE(s) \
 257         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 258 #define RESTORE_END_STRING(s) \
 259         do { *(s) = *--save_stack_p; } while (0)
 260
 261 /* The instruction we're assembling.  */
 262 static i386_insn i;
 263
 264 /* Possible templates for current insn.  */
 265 static const templates *current_templates;
 266
 267 /* Per instruction expressionS buffers: 2 displacements & 2 immediate max.  */
 268 static expressionS disp_expressions[2], im_expressions[2];
 269
 270 /* Current operand we are working on.  */
 271 static int this_operand;
 272
 273 /* We support four different modes.  FLAG_CODE variable is used to distinguish
 274    these.  */
 275
 276 enum flag_code {
 277         CODE_32BIT,
 278         CODE_16BIT,
 279         CODE_64BIT };
 280 #define NUM_FLAG_CODE ((int) CODE_64BIT + 1)
 281
 282 static enum flag_code flag_code;
 283 static int use_rela_relocations = 0;
 284
 285 /* The names used to print error messages.  */
 286 static const char *flag_code_names[] =
 287   {
 288     "32",
 289     "16",
 290     "64"
 291   };
 292
 293 /* 1 for intel syntax,
 294    0 if att syntax.  */
 295 static int intel_syntax = 0;
 296
 297 /* 1 if register prefix % not required.  */
 298 static int allow_naked_reg = 0;
 299
 300 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
 301    leave, push, and pop instructions so that gcc has the same stack
 302    frame as in 32 bit mode.  */
 303 static char stackop_size = '\0';
 304
 305 /* Non-zero to quieten some warnings.  */
 306 static int quiet_warnings = 0;
 307
 308 /* CPU name.  */
 309 static const char *cpu_arch_name = NULL;
 310
 311 /* CPU feature flags.  */
 312 static unsigned int cpu_arch_flags = CpuUnknownFlags | CpuNo64;
 313
 314 /* If set, conditional jumps are not automatically promoted to handle
 315    larger than a byte offset.  */
 316 static unsigned int no_cond_jump_promotion = 0;
 317
 318 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 319 symbolS *GOT_symbol;
 320
 321 /* Interface to relax_segment.
 322    There are 3 major relax states for 386 jump insns because the
 323    different types of jumps add different sizes to frags when we're
 324    figuring out what sort of jump to choose to reach a given label.  */
 325
 326 /* Types.  */
 327 #define UNCOND_JUMP 0
 328 #define COND_JUMP 1
 329 #define COND_JUMP86 2
 330
 331 /* Sizes.  */
 332 #define CODE16  1
 333 #define SMALL   0
 334 #define SMALL16 (SMALL | CODE16)
 335 #define BIG     2
 336 #define BIG16   (BIG | CODE16)
 337
 338 #ifndef INLINE
 339 #ifdef __GNUC__
 340 #define INLINE __inline__
 341 #else
 342 #define INLINE
 343 #endif
 344 #endif
 345
 346 #define ENCODE_RELAX_STATE(type, size) \
 347   ((relax_substateT) (((type) << 2) | (size)))
 348 #define TYPE_FROM_RELAX_STATE(s) \
 349   ((s) >> 2)
 350 #define DISP_SIZE_FROM_RELAX_STATE(s) \
 351     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
 352
 353 /* This table is used by relax_frag to promote short jumps to long
 354    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 355    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 356    don't allow a short jump in a 32 bit code segment to be promoted to
 357    a 16 bit offset jump because it's slower (requires data size
 358    prefix), and doesn't work, unless the destination is in the bottom
 359    64k of the code segment (The top 16 bits of eip are zeroed).  */
 360
 361 const relax_typeS md_relax_table[] =
 362 {
 363   /* The fields are:
 364      1) most positive reach of this state,
 365      2) most negative reach of this state,
 366      3) how many bytes this mode will have in the variable part of the frag
 367      4) which index into the table to try if we can't fit into this one.  */
 368
 369   /* UNCOND_JUMP states.  */
 370   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 371   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 372   /* dword jmp adds 4 bytes to frag:
 373      0 extra opcode bytes, 4 displacement bytes.  */
 374   {0, 0, 4, 0},
 375   /* word jmp adds 2 byte2 to frag:
 376      0 extra opcode bytes, 2 displacement bytes.  */
 377   {0, 0, 2, 0},
 378
 379   /* COND_JUMP states.  */
 380   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 381   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 382   /* dword conditionals adds 5 bytes to frag:
 383      1 extra opcode byte, 4 displacement bytes.  */
 384   {0, 0, 5, 0},
 385   /* word conditionals add 3 bytes to frag:
 386      1 extra opcode byte, 2 displacement bytes.  */
 387   {0, 0, 3, 0},
 388
 389   /* COND_JUMP86 states.  */
 390   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
 391   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
 392   /* dword conditionals adds 5 bytes to frag:
 393      1 extra opcode byte, 4 displacement bytes.  */
 394   {0, 0, 5, 0},
 395   /* word conditionals add 4 bytes to frag:
 396      1 displacement byte and a 3 byte long branch insn.  */
 397   {0, 0, 4, 0}
 398 };
 399
 400 static const arch_entry cpu_arch[] = {
 401   {"i8086",     Cpu086 },
 402   {"i186",      Cpu086|Cpu186 },
 403   {"i286",      Cpu086|Cpu186|Cpu286 },
 404   {"i386",      Cpu086|Cpu186|Cpu286|Cpu386 },
 405   {"i486",      Cpu086|Cpu186|Cpu286|Cpu386|Cpu486 },
 406   {"i586",      Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuMMX },
 407   {"i686",      Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuSSE },
 408   {"pentium",   Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuMMX },
 409   {"pentiumpro",Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuSSE },
 410   {"pentium4",  Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2 },
 411   {"k6",        Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX|Cpu3dnow },
 412   {"athlon",    Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuAthlon|CpuMMX|Cpu3dnow },
 413   {"sledgehammer",Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuAthlon|CpuSledgehammer|CpuMMX|Cpu3dnow|CpuSSE|CpuSSE2 },
 414   {NULL, 0 }
 415 };
 416
 417 const pseudo_typeS md_pseudo_table[] =
 418 {
 419 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
 420   {"align", s_align_bytes, 0},
 421 #else
 422   {"align", s_align_ptwo, 0},
 423 #endif
 424   {"arch", set_cpu_arch, 0},
 425 #ifndef I386COFF
 426   {"bss", s_bss, 0},
 427 #endif
 428   {"ffloat", float_cons, 'f'},
 429   {"dfloat", float_cons, 'd'},
 430   {"tfloat", float_cons, 'x'},
 431   {"value", cons, 2},
 432   {"noopt", s_ignore, 0},
 433   {"optim", s_ignore, 0},
 434   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
 435   {"code16", set_code_flag, CODE_16BIT},
 436   {"code32", set_code_flag, CODE_32BIT},
 437   {"code64", set_code_flag, CODE_64BIT},
 438   {"intel_syntax", set_intel_syntax, 1},
 439   {"att_syntax", set_intel_syntax, 0},
 440   {"file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0},
 441   {"loc", dwarf2_directive_loc, 0},
 442   {0, 0, 0}
 443 };
 444
 445 /* For interface with expression ().  */
 446 extern char *input_line_pointer;
 447
 448 /* Hash table for instruction mnemonic lookup.  */
 449 static struct hash_control *op_hash;
 450
 451 /* Hash table for register lookup.  */
 452 static struct hash_control *reg_hash;
 453 \f
 454 void
 455 i386_align_code (fragP, count)
 456      fragS *fragP;
 457      int count;
 458 {
 459   /* Various efficient no-op patterns for aligning code labels.
 460      Note: Don't try to assemble the instructions in the comments.
 461      0L and 0w are not legal.  */
 462   static const char f32_1[] =
 463     {0x90};                                     /* nop                  */
 464   static const char f32_2[] =
 465     {0x89,0xf6};                                /* movl %esi,%esi       */
 466   static const char f32_3[] =
 467     {0x8d,0x76,0x00};                           /* leal 0(%esi),%esi    */
 468   static const char f32_4[] =
 469     {0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
 470   static const char f32_5[] =
 471     {0x90,                                      /* nop                  */
 472      0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
 473   static const char f32_6[] =
 474     {0x8d,0xb6,0x00,0x00,0x00,0x00};            /* leal 0L(%esi),%esi   */
 475   static const char f32_7[] =
 476     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
 477   static const char f32_8[] =
 478     {0x90,                                      /* nop                  */
 479      0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
 480   static const char f32_9[] =
 481     {0x89,0xf6,                                 /* movl %esi,%esi       */
 482      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 483   static const char f32_10[] =
 484     {0x8d,0x76,0x00,                            /* leal 0(%esi),%esi    */
 485      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 486   static const char f32_11[] =
 487     {0x8d,0x74,0x26,0x00,                       /* leal 0(%esi,1),%esi  */
 488      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 489   static const char f32_12[] =
 490     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
 491      0x8d,0xbf,0x00,0x00,0x00,0x00};            /* leal 0L(%edi),%edi   */
 492   static const char f32_13[] =
 493     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
 494      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 495   static const char f32_14[] =
 496     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00,        /* leal 0L(%esi,1),%esi */
 497      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 498   static const char f32_15[] =
 499     {0xeb,0x0d,0x90,0x90,0x90,0x90,0x90,        /* jmp .+15; lotsa nops */
 500      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
 501   static const char f16_3[] =
 502     {0x8d,0x74,0x00};                           /* lea 0(%esi),%esi     */
 503   static const char f16_4[] =
 504     {0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
 505   static const char f16_5[] =
 506     {0x90,                                      /* nop                  */
 507      0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
 508   static const char f16_6[] =
 509     {0x89,0xf6,                                 /* mov %si,%si          */
 510      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 511   static const char f16_7[] =
 512     {0x8d,0x74,0x00,                            /* lea 0(%si),%si       */
 513      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 514   static const char f16_8[] =
 515     {0x8d,0xb4,0x00,0x00,                       /* lea 0w(%si),%si      */
 516      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 517   static const char *const f32_patt[] = {
 518     f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
 519     f32_9, f32_10, f32_11, f32_12, f32_13, f32_14, f32_15
 520   };
 521   static const char *const f16_patt[] = {
 522     f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8,
 523     f32_15, f32_15, f32_15, f32_15, f32_15, f32_15, f32_15
 524   };
 525
 526   if (count <= 0 || count > 15)
 527     return;
 528
 529   /* The recommended way to pad 64bit code is to use NOPs preceded by
 530      maximally four 0x66 prefixes.  Balance the size of nops.  */
 531   if (flag_code == CODE_64BIT)
 532     {
 533       int i;
 534       int nnops = (count + 3) / 4;
 535       int len = count / nnops;
 536       int remains = count - nnops * len;
 537       int pos = 0;
 538
 539       for (i = 0; i < remains; i++)
 540         {
 541           memset (fragP->fr_literal + fragP->fr_fix + pos, 0x66, len);
 542           fragP->fr_literal[fragP->fr_fix + pos + len] = 0x90;
 543           pos += len + 1;
 544         }
 545       for (; i < nnops; i++)
 546         {
 547           memset (fragP->fr_literal + fragP->fr_fix + pos, 0x66, len - 1);
 548           fragP->fr_literal[fragP->fr_fix + pos + len - 1] = 0x90;
 549           pos += len;
 550         }
 551     }
 552   else
 553     if (flag_code == CODE_16BIT)
 554       {
 555         memcpy (fragP->fr_literal + fragP->fr_fix,
 556                 f16_patt[count - 1], count);
 557         if (count > 8)
 558           /* Adjust jump offset.  */
 559           fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
 560       }
 561     else
 562       memcpy (fragP->fr_literal + fragP->fr_fix,
 563               f32_patt[count - 1], count);
 564   fragP->fr_var = count;
 565 }
 566
 567 static INLINE unsigned int
 568 mode_from_disp_size (t)
 569      unsigned int t;
 570 {
 571   return (t & Disp8) ? 1 : (t & (Disp16 | Disp32 | Disp32S)) ? 2 : 0;
 572 }
 573
 574 static INLINE int
 575 fits_in_signed_byte (num)
 576      offsetT num;
 577 {
 578   return (num >= -128) && (num <= 127);
 579 }
 580
 581 static INLINE int
 582 fits_in_unsigned_byte (num)
 583      offsetT num;
 584 {
 585   return (num & 0xff) == num;
 586 }
 587
 588 static INLINE int
 589 fits_in_unsigned_word (num)
 590      offsetT num;
 591 {
 592   return (num & 0xffff) == num;
 593 }
 594
 595 static INLINE int
 596 fits_in_signed_word (num)
 597      offsetT num;
 598 {
 599   return (-32768 <= num) && (num <= 32767);
 600 }
 601 static INLINE int
 602 fits_in_signed_long (num)
 603      offsetT num ATTRIBUTE_UNUSED;
 604 {
 605 #ifndef BFD64
 606   return 1;
 607 #else
 608   return (!(((offsetT) -1 << 31) & num)
 609           || (((offsetT) -1 << 31) & num) == ((offsetT) -1 << 31));
 610 #endif
 611 }                               /* fits_in_signed_long() */
 612 static INLINE int
 613 fits_in_unsigned_long (num)
 614      offsetT num ATTRIBUTE_UNUSED;
 615 {
 616 #ifndef BFD64
 617   return 1;
 618 #else
 619   return (num & (((offsetT) 2 << 31) - 1)) == num;
 620 #endif
 621 }                               /* fits_in_unsigned_long() */
 622
 623 static int
 624 smallest_imm_type (num)
 625      offsetT num;
 626 {
 627   if (cpu_arch_flags != (Cpu086 | Cpu186 | Cpu286 | Cpu386 | Cpu486 | CpuNo64))
 628     {
 629       /* This code is disabled on the 486 because all the Imm1 forms
 630          in the opcode table are slower on the i486.  They're the
 631          versions with the implicitly specified single-position
 632          displacement, which has another syntax if you really want to
 633          use that form.  */
 634       if (num == 1)
 635         return Imm1 | Imm8 | Imm8S | Imm16 | Imm32 | Imm32S | Imm64;
 636     }
 637   return (fits_in_signed_byte (num)
 638           ? (Imm8S | Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
 639           : fits_in_unsigned_byte (num)
 640           ? (Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
 641           : (fits_in_signed_word (num) || fits_in_unsigned_word (num))
 642           ? (Imm16 | Imm32 | Imm32S | Imm64)
 643           : fits_in_signed_long (num)
 644           ? (Imm32 | Imm32S | Imm64)
 645           : fits_in_unsigned_long (num)
 646           ? (Imm32 | Imm64)
 647           : Imm64);
 648 }
 649
 650 static offsetT
 651 offset_in_range (val, size)
 652      offsetT val;
 653      int size;
 654 {
 655   addressT mask;
 656
 657   switch (size)
 658     {
 659     case 1: mask = ((addressT) 1 <<  8) - 1; break;
 660     case 2: mask = ((addressT) 1 << 16) - 1; break;
 661     case 4: mask = ((addressT) 2 << 31) - 1; break;
 662 #ifdef BFD64
 663     case 8: mask = ((addressT) 2 << 63) - 1; break;
 664 #endif
 665     default: abort ();
 666     }
 667
 668   /* If BFD64, sign extend val.  */
 669   if (!use_rela_relocations)
 670     if ((val & ~(((addressT) 2 << 31) - 1)) == 0)
 671       val = (val ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
 672
 673   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
 674     {
 675       char buf1[40], buf2[40];
 676
 677       sprint_value (buf1, val);
 678       sprint_value (buf2, val & mask);
 679       as_warn (_("%s shortened to %s"), buf1, buf2);
 680     }
 681   return val & mask;
 682 }
 683
 684 /* Returns 0 if attempting to add a prefix where one from the same
 685    class already exists, 1 if non rep/repne added, 2 if rep/repne
 686    added.  */
 687 static int
 688 add_prefix (prefix)
 689      unsigned int prefix;
 690 {
 691   int ret = 1;
 692   int q;
 693
 694   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
 695       && flag_code == CODE_64BIT)
 696     q = REX_PREFIX;
 697   else
 698     switch (prefix)
 699       {
 700       default:
 701         abort ();
 702
 703       case CS_PREFIX_OPCODE:
 704       case DS_PREFIX_OPCODE:
 705       case ES_PREFIX_OPCODE:
 706       case FS_PREFIX_OPCODE:
 707       case GS_PREFIX_OPCODE:
 708       case SS_PREFIX_OPCODE:
 709         q = SEG_PREFIX;
 710         break;
 711
 712       case REPNE_PREFIX_OPCODE:
 713       case REPE_PREFIX_OPCODE:
 714         ret = 2;
 715         /* fall thru */
 716       case LOCK_PREFIX_OPCODE:
 717         q = LOCKREP_PREFIX;
 718         break;
 719
 720       case FWAIT_OPCODE:
 721         q = WAIT_PREFIX;
 722         break;
 723
 724       case ADDR_PREFIX_OPCODE:
 725         q = ADDR_PREFIX;
 726         break;
 727
 728       case DATA_PREFIX_OPCODE:
 729         q = DATA_PREFIX;
 730         break;
 731       }
 732
 733   if (i.prefix[q] != 0)
 734     {
 735       as_bad (_("same type of prefix used twice"));
 736       return 0;
 737     }
 738
 739   i.prefixes += 1;
 740   i.prefix[q] = prefix;
 741   return ret;
 742 }
 743
 744 static void
 745 set_code_flag (value)
 746      int value;
 747 {
 748   flag_code = value;
 749   cpu_arch_flags &= ~(Cpu64 | CpuNo64);
 750   cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
 751   if (value == CODE_64BIT && !(cpu_arch_flags & CpuSledgehammer))
 752     {
 753       as_bad (_("64bit mode not supported on this CPU."));
 754     }
 755   if (value == CODE_32BIT && !(cpu_arch_flags & Cpu386))
 756     {
 757       as_bad (_("32bit mode not supported on this CPU."));
 758     }
 759   stackop_size = '\0';
 760 }
 761
 762 static void
 763 set_16bit_gcc_code_flag (new_code_flag)
 764      int new_code_flag;
 765 {
 766   flag_code = new_code_flag;
 767   cpu_arch_flags &= ~(Cpu64 | CpuNo64);
 768   cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
 769   stackop_size = 'l';
 770 }
 771
 772 static void
 773 set_intel_syntax (syntax_flag)
 774      int syntax_flag;
 775 {
 776   /* Find out if register prefixing is specified.  */
 777   int ask_naked_reg = 0;
 778
 779   SKIP_WHITESPACE ();
 780   if (!is_end_of_line[(unsigned char) *input_line_pointer])
 781     {
 782       char *string = input_line_pointer;
 783       int e = get_symbol_end ();
 784
 785       if (strcmp (string, "prefix") == 0)
 786         ask_naked_reg = 1;
 787       else if (strcmp (string, "noprefix") == 0)
 788         ask_naked_reg = -1;
 789       else
 790         as_bad (_("bad argument to syntax directive."));
 791       *input_line_pointer = e;
 792     }
 793   demand_empty_rest_of_line ();
 794
 795   intel_syntax = syntax_flag;
 796
 797   if (ask_naked_reg == 0)
 798     {
 799 #ifdef BFD_ASSEMBLER
 800       allow_naked_reg = (intel_syntax
 801                          && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
 802 #else
 803       /* Conservative default.  */
 804       allow_naked_reg = 0;
 805 #endif
 806     }
 807   else
 808     allow_naked_reg = (ask_naked_reg < 0);
 809 }
 810
 811 static void
 812 set_cpu_arch (dummy)
 813      int dummy ATTRIBUTE_UNUSED;
 814 {
 815   SKIP_WHITESPACE ();
 816
 817   if (!is_end_of_line[(unsigned char) *input_line_pointer])
 818     {
 819       char *string = input_line_pointer;
 820       int e = get_symbol_end ();
 821       int i;
 822
 823       for (i = 0; cpu_arch[i].name; i++)
 824         {
 825           if (strcmp (string, cpu_arch[i].name) == 0)
 826             {
 827               cpu_arch_name = cpu_arch[i].name;
 828               cpu_arch_flags = (cpu_arch[i].flags
 829                                 | (flag_code == CODE_64BIT ? Cpu64 : CpuNo64));
 830               break;
 831             }
 832         }
 833       if (!cpu_arch[i].name)
 834         as_bad (_("no such architecture: `%s'"), string);
 835
 836       *input_line_pointer = e;
 837     }
 838   else
 839     as_bad (_("missing cpu architecture"));
 840
 841   no_cond_jump_promotion = 0;
 842   if (*input_line_pointer == ','
 843       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
 844     {
 845       char *string = ++input_line_pointer;
 846       int e = get_symbol_end ();
 847
 848       if (strcmp (string, "nojumps") == 0)
 849         no_cond_jump_promotion = 1;
 850       else if (strcmp (string, "jumps") == 0)
 851         ;
 852       else
 853         as_bad (_("no such architecture modifier: `%s'"), string);
 854
 855       *input_line_pointer = e;
 856     }
 857
 858   demand_empty_rest_of_line ();
 859 }
 860
 861 #ifdef BFD_ASSEMBLER
 862 unsigned long
 863 i386_mach ()
 864 {
 865   if (!strcmp (default_arch, "x86_64"))
 866     return bfd_mach_x86_64;
 867   else if (!strcmp (default_arch, "i386"))
 868     return bfd_mach_i386_i386;
 869   else
 870     as_fatal (_("Unknown architecture"));
 871 }
 872 #endif
 873 \f
 874 void
 875 md_begin ()
 876 {
 877   const char *hash_err;
 878
 879   /* Initialize op_hash hash table.  */
 880   op_hash = hash_new ();
 881
 882   {
 883     const template *optab;
 884     templates *core_optab;
 885
 886     /* Setup for loop.  */
 887     optab = i386_optab;
 888     core_optab = (templates *) xmalloc (sizeof (templates));
 889     core_optab->start = optab;
 890
 891     while (1)
 892       {
 893         ++optab;
 894         if (optab->name == NULL
 895             || strcmp (optab->name, (optab - 1)->name) != 0)
 896           {
 897             /* different name --> ship out current template list;
 898                add to hash table; & begin anew.  */
 899             core_optab->end = optab;
 900             hash_err = hash_insert (op_hash,
 901                                     (optab - 1)->name,
 902                                     (PTR) core_optab);
 903             if (hash_err)
 904               {
 905                 as_fatal (_("Internal Error:  Can't hash %s: %s"),
 906                           (optab - 1)->name,
 907                           hash_err);
 908               }
 909             if (optab->name == NULL)
 910               break;
 911             core_optab = (templates *) xmalloc (sizeof (templates));
 912             core_optab->start = optab;
 913           }
 914       }
 915   }
 916
 917   /* Initialize reg_hash hash table.  */
 918   reg_hash = hash_new ();
 919   {
 920     const reg_entry *regtab;
 921
 922     for (regtab = i386_regtab;
 923          regtab < i386_regtab + sizeof (i386_regtab) / sizeof (i386_regtab[0]);
 924          regtab++)
 925       {
 926         hash_err = hash_insert (reg_hash, regtab->reg_name, (PTR) regtab);
 927         if (hash_err)
 928           as_fatal (_("Internal Error:  Can't hash %s: %s"),
 929                     regtab->reg_name,
 930                     hash_err);
 931       }
 932   }
 933
 934   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
 935   {
 936     int c;
 937     char *p;
 938
 939     for (c = 0; c < 256; c++)
 940       {
 941         if (ISDIGIT (c))
 942           {
 943             digit_chars[c] = c;
 944             mnemonic_chars[c] = c;
 945             register_chars[c] = c;
 946             operand_chars[c] = c;
 947           }
 948         else if (ISLOWER (c))
 949           {
 950             mnemonic_chars[c] = c;
 951             register_chars[c] = c;
 952             operand_chars[c] = c;
 953           }
 954         else if (ISUPPER (c))
 955           {
 956             mnemonic_chars[c] = TOLOWER (c);
 957             register_chars[c] = mnemonic_chars[c];
 958             operand_chars[c] = c;
 959           }
 960
 961         if (ISALPHA (c) || ISDIGIT (c))
 962           identifier_chars[c] = c;
 963         else if (c >= 128)
 964           {
 965             identifier_chars[c] = c;
 966             operand_chars[c] = c;
 967           }
 968       }
 969
 970 #ifdef LEX_AT
 971     identifier_chars['@'] = '@';
 972 #endif
 973     digit_chars['-'] = '-';
 974     identifier_chars['_'] = '_';
 975     identifier_chars['.'] = '.';
 976
 977     for (p = operand_special_chars; *p != '\0'; p++)
 978       operand_chars[(unsigned char) *p] = *p;
 979   }
 980
 981 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 982   if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
 983     {
 984       record_alignment (text_section, 2);
 985       record_alignment (data_section, 2);
 986       record_alignment (bss_section, 2);
 987     }
 988 #endif
 989 }
 990
 991 void
 992 i386_print_statistics (file)
 993      FILE *file;
 994 {
 995   hash_print_statistics (file, "i386 opcode", op_hash);
 996   hash_print_statistics (file, "i386 register", reg_hash);
 997 }
 998 \f
 999 #ifdef DEBUG386
1000
1001 /* Debugging routines for md_assemble.  */
1002 static void pi PARAMS ((char *, i386_insn *));
1003 static void pte PARAMS ((template *));
1004 static void pt PARAMS ((unsigned int));
1005 static void pe PARAMS ((expressionS *));
1006 static void ps PARAMS ((symbolS *));
1007
1008 static void
1009 pi (line, x)
1010      char *line;
1011      i386_insn *x;
1012 {
1013   unsigned int i;
1014
1015   fprintf (stdout, "%s: template ", line);
1016   pte (&x->tm);
1017   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
1018            x->base_reg ? x->base_reg->reg_name : "none",
1019            x->index_reg ? x->index_reg->reg_name : "none",
1020            x->log2_scale_factor);
1021   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
1022            x->rm.mode, x->rm.reg, x->rm.regmem);
1023   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
1024            x->sib.base, x->sib.index, x->sib.scale);
1025   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
1026            (x->rex & REX_MODE64) != 0,
1027            (x->rex & REX_EXTX) != 0,
1028            (x->rex & REX_EXTY) != 0,
1029            (x->rex & REX_EXTZ) != 0);
1030   for (i = 0; i < x->operands; i++)
1031     {
1032       fprintf (stdout, "    #%d:  ", i + 1);
1033       pt (x->types[i]);
1034       fprintf (stdout, "\n");
1035       if (x->types[i]
1036           & (Reg | SReg2 | SReg3 | Control | Debug | Test | RegMMX | RegXMM))
1037         fprintf (stdout, "%s\n", x->op[i].regs->reg_name);
1038       if (x->types[i] & Imm)
1039         pe (x->op[i].imms);
1040       if (x->types[i] & Disp)
1041         pe (x->op[i].disps);
1042     }
1043 }
1044
1045 static void
1046 pte (t)
1047      template *t;
1048 {
1049   unsigned int i;
1050   fprintf (stdout, " %d operands ", t->operands);
1051   fprintf (stdout, "opcode %x ", t->base_opcode);
1052   if (t->extension_opcode != None)
1053     fprintf (stdout, "ext %x ", t->extension_opcode);
1054   if (t->opcode_modifier & D)
1055     fprintf (stdout, "D");
1056   if (t->opcode_modifier & W)
1057     fprintf (stdout, "W");
1058   fprintf (stdout, "\n");
1059   for (i = 0; i < t->operands; i++)
1060     {
1061       fprintf (stdout, "    #%d type ", i + 1);
1062       pt (t->operand_types[i]);
1063       fprintf (stdout, "\n");
1064     }
1065 }
1066
1067 static void
1068 pe (e)
1069      expressionS *e;
1070 {
1071   fprintf (stdout, "    operation     %d\n", e->X_op);
1072   fprintf (stdout, "    add_number    %ld (%lx)\n",
1073            (long) e->X_add_number, (long) e->X_add_number);
1074   if (e->X_add_symbol)
1075     {
1076       fprintf (stdout, "    add_symbol    ");
1077       ps (e->X_add_symbol);
1078       fprintf (stdout, "\n");
1079     }
1080   if (e->X_op_symbol)
1081     {
1082       fprintf (stdout, "    op_symbol    ");
1083       ps (e->X_op_symbol);
1084       fprintf (stdout, "\n");
1085     }
1086 }
1087
1088 static void
1089 ps (s)
1090      symbolS *s;
1091 {
1092   fprintf (stdout, "%s type %s%s",
1093            S_GET_NAME (s),
1094            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
1095            segment_name (S_GET_SEGMENT (s)));
1096 }
1097
1098 struct type_name
1099   {
1100     unsigned int mask;
1101     char *tname;
1102   }
1103
1104 static const type_names[] =
1105 {
1106   { Reg8, "r8" },
1107   { Reg16, "r16" },
1108   { Reg32, "r32" },
1109   { Reg64, "r64" },
1110   { Imm8, "i8" },
1111   { Imm8S, "i8s" },
1112   { Imm16, "i16" },
1113   { Imm32, "i32" },
1114   { Imm32S, "i32s" },
1115   { Imm64, "i64" },
1116   { Imm1, "i1" },
1117   { BaseIndex, "BaseIndex" },
1118   { Disp8, "d8" },
1119   { Disp16, "d16" },
1120   { Disp32, "d32" },
1121   { Disp32S, "d32s" },
1122   { Disp64, "d64" },
1123   { InOutPortReg, "InOutPortReg" },
1124   { ShiftCount, "ShiftCount" },
1125   { Control, "control reg" },
1126   { Test, "test reg" },
1127   { Debug, "debug reg" },
1128   { FloatReg, "FReg" },
1129   { FloatAcc, "FAcc" },
1130   { SReg2, "SReg2" },
1131   { SReg3, "SReg3" },
1132   { Acc, "Acc" },
1133   { JumpAbsolute, "Jump Absolute" },
1134   { RegMMX, "rMMX" },
1135   { RegXMM, "rXMM" },
1136   { EsSeg, "es" },
1137   { 0, "" }
1138 };
1139
1140 static void
1141 pt (t)
1142      unsigned int t;
1143 {
1144   const struct type_name *ty;
1145
1146   for (ty = type_names; ty->mask; ty++)
1147     if (t & ty->mask)
1148       fprintf (stdout, "%s, ", ty->tname);
1149   fflush (stdout);
1150 }
1151
1152 #endif /* DEBUG386 */
1153 \f
1154 #ifdef BFD_ASSEMBLER
1155 static bfd_reloc_code_real_type reloc
1156   PARAMS ((int, int, int, bfd_reloc_code_real_type));
1157
1158 static bfd_reloc_code_real_type
1159 reloc (size, pcrel, sign, other)
1160      int size;
1161      int pcrel;
1162      int sign;
1163      bfd_reloc_code_real_type other;
1164 {
1165   if (other != NO_RELOC)
1166     return other;
1167
1168   if (pcrel)
1169     {
1170       if (!sign)
1171         as_bad (_("There are no unsigned pc-relative relocations"));
1172       switch (size)
1173         {
1174         case 1: return BFD_RELOC_8_PCREL;
1175         case 2: return BFD_RELOC_16_PCREL;
1176         case 4: return BFD_RELOC_32_PCREL;
1177         }
1178       as_bad (_("can not do %d byte pc-relative relocation"), size);
1179     }
1180   else
1181     {
1182       if (sign)
1183         switch (size)
1184           {
1185           case 4: return BFD_RELOC_X86_64_32S;
1186           }
1187       else
1188         switch (size)
1189           {
1190           case 1: return BFD_RELOC_8;
1191           case 2: return BFD_RELOC_16;
1192           case 4: return BFD_RELOC_32;
1193           case 8: return BFD_RELOC_64;
1194           }
1195       as_bad (_("can not do %s %d byte relocation"),
1196               sign ? "signed" : "unsigned", size);
1197     }
1198
1199   abort ();
1200   return BFD_RELOC_NONE;
1201 }
1202
1203 /* Here we decide which fixups can be adjusted to make them relative to
1204    the beginning of the section instead of the symbol.  Basically we need
1205    to make sure that the dynamic relocations are done correctly, so in
1206    some cases we force the original symbol to be used.  */
1207
1208 int
1209 tc_i386_fix_adjustable (fixP)
1210      fixS *fixP ATTRIBUTE_UNUSED;
1211 {
1212 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1213   if (OUTPUT_FLAVOR != bfd_target_elf_flavour)
1214     return 1;
1215
1216   /* Don't adjust pc-relative references to merge sections in 64-bit
1217      mode.  */
1218   if (use_rela_relocations
1219       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
1220       && fixP->fx_pcrel)
1221     return 0;
1222
1223   /* adjust_reloc_syms doesn't know about the GOT.  */
1224   if (fixP->fx_r_type == BFD_RELOC_386_GOTOFF
1225       || fixP->fx_r_type == BFD_RELOC_386_PLT32
1226       || fixP->fx_r_type == BFD_RELOC_386_GOT32
1227       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
1228       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
1229       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
1230       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
1231       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
1232       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
1233       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
1234       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
1235       || fixP->fx_r_type == BFD_RELOC_X86_64_PLT32
1236       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
1237       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
1238       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1239       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1240     return 0;
1241 #endif
1242   return 1;
1243 }
1244 #else
1245 #define reloc(SIZE,PCREL,SIGN,OTHER)    0
1246 #define BFD_RELOC_8                     0
1247 #define BFD_RELOC_16                    0
1248 #define BFD_RELOC_32                    0
1249 #define BFD_RELOC_8_PCREL               0
1250 #define BFD_RELOC_16_PCREL              0
1251 #define BFD_RELOC_32_PCREL              0
1252 #define BFD_RELOC_386_PLT32             0
1253 #define BFD_RELOC_386_GOT32             0
1254 #define BFD_RELOC_386_GOTOFF            0
1255 #define BFD_RELOC_386_TLS_GD            0
1256 #define BFD_RELOC_386_TLS_LDM           0
1257 #define BFD_RELOC_386_TLS_LDO_32        0
1258 #define BFD_RELOC_386_TLS_IE_32         0
1259 #define BFD_RELOC_386_TLS_IE            0
1260 #define BFD_RELOC_386_TLS_GOTIE         0
1261 #define BFD_RELOC_386_TLS_LE_32         0
1262 #define BFD_RELOC_386_TLS_LE            0
1263 #define BFD_RELOC_X86_64_PLT32          0
1264 #define BFD_RELOC_X86_64_GOT32          0
1265 #define BFD_RELOC_X86_64_GOTPCREL       0
1266 #endif
1267
1268 static int intel_float_operand PARAMS ((const char *mnemonic));
1269
1270 static int
1271 intel_float_operand (mnemonic)
1272      const char *mnemonic;
1273 {
1274   if (mnemonic[0] == 'f' && mnemonic[1] == 'i')
1275     return 2;
1276
1277   if (mnemonic[0] == 'f')
1278     return 1;
1279
1280   return 0;
1281 }
1282
1283 /* This is the guts of the machine-dependent assembler.  LINE points to a
1284    machine dependent instruction.  This function is supposed to emit
1285    the frags/bytes it assembles to.  */
1286
1287 void
1288 md_assemble (line)
1289      char *line;
1290 {
1291   int j;
1292   char mnemonic[MAX_MNEM_SIZE];
1293
1294   /* Initialize globals.  */
1295   memset (&i, '\0', sizeof (i));
1296   for (j = 0; j < MAX_OPERANDS; j++)
1297     i.reloc[j] = NO_RELOC;
1298   memset (disp_expressions, '\0', sizeof (disp_expressions));
1299   memset (im_expressions, '\0', sizeof (im_expressions));
1300   save_stack_p = save_stack;
1301
1302   /* First parse an instruction mnemonic & call i386_operand for the operands.
1303      We assume that the scrubber has arranged it so that line[0] is the valid
1304      start of a (possibly prefixed) mnemonic.  */
1305
1306   line = parse_insn (line, mnemonic);
1307   if (line == NULL)
1308     return;
1309
1310   line = parse_operands (line, mnemonic);
1311   if (line == NULL)
1312     return;
1313
1314   /* Now we've parsed the mnemonic into a set of templates, and have the
1315      operands at hand.  */
1316
1317   /* All intel opcodes have reversed operands except for "bound" and
1318      "enter".  We also don't reverse intersegment "jmp" and "call"
1319      instructions with 2 immediate operands so that the immediate segment
1320      precedes the offset, as it does when in AT&T mode.  "enter" and the
1321      intersegment "jmp" and "call" instructions are the only ones that
1322      have two immediate operands.  */
1323   if (intel_syntax && i.operands > 1
1324       && (strcmp (mnemonic, "bound") != 0)
1325       && !((i.types[0] & Imm) && (i.types[1] & Imm)))
1326     swap_operands ();
1327
1328   if (i.imm_operands)
1329     optimize_imm ();
1330
1331   if (i.disp_operands)
1332     optimize_disp ();
1333
1334   /* Next, we find a template that matches the given insn,
1335      making sure the overlap of the given operands types is consistent
1336      with the template operand types.  */
1337
1338   if (!match_template ())
1339     return;
1340
1341   if (intel_syntax)
1342     {
1343       /* Undo SYSV386_COMPAT brokenness when in Intel mode.  See i386.h  */
1344       if (SYSV386_COMPAT
1345           && (i.tm.base_opcode & 0xfffffde0) == 0xdce0)
1346         i.tm.base_opcode ^= FloatR;
1347
1348       /* Zap movzx and movsx suffix.  The suffix may have been set from
1349          "word ptr" or "byte ptr" on the source operand, but we'll use
1350          the suffix later to choose the destination register.  */
1351       if ((i.tm.base_opcode & ~9) == 0x0fb6)
1352         i.suffix = 0;
1353     }
1354
1355   if (i.tm.opcode_modifier & FWait)
1356     if (!add_prefix (FWAIT_OPCODE))
1357       return;
1358
1359   /* Check string instruction segment overrides.  */
1360   if ((i.tm.opcode_modifier & IsString) != 0 && i.mem_operands != 0)
1361     {
1362       if (!check_string ())
1363         return;
1364     }
1365
1366   if (!process_suffix ())
1367     return;
1368
1369   /* Make still unresolved immediate matches conform to size of immediate
1370      given in i.suffix.  */
1371   if (!finalize_imm ())
1372     return;
1373
1374   if (i.types[0] & Imm1)
1375     i.imm_operands = 0; /* kludge for shift insns.  */
1376   if (i.types[0] & ImplicitRegister)
1377     i.reg_operands--;
1378   if (i.types[1] & ImplicitRegister)
1379     i.reg_operands--;
1380   if (i.types[2] & ImplicitRegister)
1381     i.reg_operands--;
1382
1383   if (i.tm.opcode_modifier & ImmExt)
1384     {
1385       /* These AMD 3DNow! and Intel Katmai New Instructions have an
1386          opcode suffix which is coded in the same place as an 8-bit
1387          immediate field would be.  Here we fake an 8-bit immediate
1388          operand from the opcode suffix stored in tm.extension_opcode.  */
1389
1390       expressionS *exp;
1391
1392       assert (i.imm_operands == 0 && i.operands <= 2 && 2 < MAX_OPERANDS);
1393
1394       exp = &im_expressions[i.imm_operands++];
1395       i.op[i.operands].imms = exp;
1396       i.types[i.operands++] = Imm8;
1397       exp->X_op = O_constant;
1398       exp->X_add_number = i.tm.extension_opcode;
1399       i.tm.extension_opcode = None;
1400     }
1401
1402   /* For insns with operands there are more diddles to do to the opcode.  */
1403   if (i.operands)
1404     {
1405       if (!process_operands ())
1406         return;
1407     }
1408   else if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
1409     {
1410       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
1411       as_warn (_("translating to `%sp'"), i.tm.name);
1412     }
1413
1414   /* Handle conversion of 'int $3' --> special int3 insn.  */
1415   if (i.tm.base_opcode == INT_OPCODE && i.op[0].imms->X_add_number == 3)
1416     {
1417       i.tm.base_opcode = INT3_OPCODE;
1418       i.imm_operands = 0;
1419     }
1420
1421   if ((i.tm.opcode_modifier & (Jump | JumpByte | JumpDword))
1422       && i.op[0].disps->X_op == O_constant)
1423     {
1424       /* Convert "jmp constant" (and "call constant") to a jump (call) to
1425          the absolute address given by the constant.  Since ix86 jumps and
1426          calls are pc relative, we need to generate a reloc.  */
1427       i.op[0].disps->X_add_symbol = &abs_symbol;
1428       i.op[0].disps->X_op = O_symbol;
1429     }
1430
1431   if ((i.tm.opcode_modifier & Rex64) != 0)
1432     i.rex |= REX_MODE64;
1433
1434   /* For 8 bit registers we need an empty rex prefix.  Also if the
1435      instruction already has a prefix, we need to convert old
1436      registers to new ones.  */
1437
1438   if (((i.types[0] & Reg8) != 0
1439        && (i.op[0].regs->reg_flags & RegRex64) != 0)
1440       || ((i.types[1] & Reg8) != 0
1441           && (i.op[1].regs->reg_flags & RegRex64) != 0)
1442       || (((i.types[0] & Reg8) != 0 || (i.types[1] & Reg8) != 0)
1443           && i.rex != 0))
1444     {
1445       int x;
1446
1447       i.rex |= REX_OPCODE;
1448       for (x = 0; x < 2; x++)
1449         {
1450           /* Look for 8 bit operand that uses old registers.  */
1451           if ((i.types[x] & Reg8) != 0
1452               && (i.op[x].regs->reg_flags & RegRex64) == 0)
1453             {
1454               /* In case it is "hi" register, give up.  */
1455               if (i.op[x].regs->reg_num > 3)
1456                 as_bad (_("can't encode register '%%%s' in an instruction requiring REX prefix.\n"),
1457                         i.op[x].regs->reg_name);
1458
1459               /* Otherwise it is equivalent to the extended register.
1460                  Since the encoding doesn't change this is merely
1461                  cosmetic cleanup for debug output.  */
1462
1463               i.op[x].regs = i.op[x].regs + 8;
1464             }
1465         }
1466     }
1467
1468   if (i.rex != 0)
1469     add_prefix (REX_OPCODE | i.rex);
1470
1471   /* We are ready to output the insn.  */
1472   output_insn ();
1473 }
1474
1475 static char *
1476 parse_insn (line, mnemonic)
1477      char *line;
1478      char *mnemonic;
1479 {
1480   char *l = line;
1481   char *token_start = l;
1482   char *mnem_p;
1483
1484   /* Non-zero if we found a prefix only acceptable with string insns.  */
1485   const char *expecting_string_instruction = NULL;
1486
1487   while (1)
1488     {
1489       mnem_p = mnemonic;
1490       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
1491         {
1492           mnem_p++;
1493           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
1494             {
1495               as_bad (_("no such instruction: `%s'"), token_start);
1496               return NULL;
1497             }
1498           l++;
1499         }
1500       if (!is_space_char (*l)
1501           && *l != END_OF_INSN
1502           && *l != PREFIX_SEPARATOR
1503           && *l != ',')
1504         {
1505           as_bad (_("invalid character %s in mnemonic"),
1506                   output_invalid (*l));
1507           return NULL;
1508         }
1509       if (token_start == l)
1510         {
1511           if (*l == PREFIX_SEPARATOR)
1512             as_bad (_("expecting prefix; got nothing"));
1513           else
1514             as_bad (_("expecting mnemonic; got nothing"));
1515           return NULL;
1516         }
1517
1518       /* Look up instruction (or prefix) via hash table.  */
1519       current_templates = hash_find (op_hash, mnemonic);
1520
1521       if (*l != END_OF_INSN
1522           && (!is_space_char (*l) || l[1] != END_OF_INSN)
1523           && current_templates
1524           && (current_templates->start->opcode_modifier & IsPrefix))
1525         {
1526           /* If we are in 16-bit mode, do not allow addr16 or data16.
1527              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
1528           if ((current_templates->start->opcode_modifier & (Size16 | Size32))
1529               && flag_code != CODE_64BIT
1530               && (((current_templates->start->opcode_modifier & Size32) != 0)
1531                   ^ (flag_code == CODE_16BIT)))
1532             {
1533               as_bad (_("redundant %s prefix"),
1534                       current_templates->start->name);
1535               return NULL;
1536             }
1537           /* Add prefix, checking for repeated prefixes.  */
1538           switch (add_prefix (current_templates->start->base_opcode))
1539             {
1540             case 0:
1541               return NULL;
1542             case 2:
1543               expecting_string_instruction = current_templates->start->name;
1544               break;
1545             }
1546           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
1547           token_start = ++l;
1548         }
1549       else
1550         break;
1551     }
1552
1553   if (!current_templates)
1554     {
1555       /* See if we can get a match by trimming off a suffix.  */
1556       switch (mnem_p[-1])
1557         {
1558         case WORD_MNEM_SUFFIX:
1559         case BYTE_MNEM_SUFFIX:
1560         case QWORD_MNEM_SUFFIX:
1561           i.suffix = mnem_p[-1];
1562           mnem_p[-1] = '\0';
1563           current_templates = hash_find (op_hash, mnemonic);
1564           break;
1565         case SHORT_MNEM_SUFFIX:
1566         case LONG_MNEM_SUFFIX:
1567           if (!intel_syntax)
1568             {
1569               i.suffix = mnem_p[-1];
1570               mnem_p[-1] = '\0';
1571               current_templates = hash_find (op_hash, mnemonic);
1572             }
1573           break;
1574
1575           /* Intel Syntax.  */
1576         case 'd':
1577           if (intel_syntax)
1578             {
1579               if (intel_float_operand (mnemonic))
1580                 i.suffix = SHORT_MNEM_SUFFIX;
1581               else
1582                 i.suffix = LONG_MNEM_SUFFIX;
1583               mnem_p[-1] = '\0';
1584               current_templates = hash_find (op_hash, mnemonic);
1585             }
1586           break;
1587         }
1588       if (!current_templates)
1589         {
1590           as_bad (_("no such instruction: `%s'"), token_start);
1591           return NULL;
1592         }
1593     }
1594
1595   if (current_templates->start->opcode_modifier & (Jump | JumpByte))
1596     {
1597       /* Check for a branch hint.  We allow ",pt" and ",pn" for
1598          predict taken and predict not taken respectively.
1599          I'm not sure that branch hints actually do anything on loop
1600          and jcxz insns (JumpByte) for current Pentium4 chips.  They
1601          may work in the future and it doesn't hurt to accept them
1602          now.  */
1603       if (l[0] == ',' && l[1] == 'p')
1604         {
1605           if (l[2] == 't')
1606             {
1607               if (!add_prefix (DS_PREFIX_OPCODE))
1608                 return NULL;
1609               l += 3;
1610             }
1611           else if (l[2] == 'n')
1612             {
1613               if (!add_prefix (CS_PREFIX_OPCODE))
1614                 return NULL;
1615               l += 3;
1616             }
1617         }
1618     }
1619   /* Any other comma loses.  */
1620   if (*l == ',')
1621     {
1622       as_bad (_("invalid character %s in mnemonic"),
1623               output_invalid (*l));
1624       return NULL;
1625     }
1626
1627   /* Check if instruction is supported on specified architecture.  */
1628   if ((current_templates->start->cpu_flags & ~(Cpu64 | CpuNo64))
1629       & ~(cpu_arch_flags & ~(Cpu64 | CpuNo64)))
1630     {
1631       as_warn (_("`%s' is not supported on `%s'"),
1632                current_templates->start->name, cpu_arch_name);
1633     }
1634   else if ((Cpu386 & ~cpu_arch_flags) && (flag_code != CODE_16BIT))
1635     {
1636       as_warn (_("use .code16 to ensure correct addressing mode"));
1637     }
1638
1639   /* Check for rep/repne without a string instruction.  */
1640   if (expecting_string_instruction
1641       && !(current_templates->start->opcode_modifier & IsString))
1642     {
1643       as_bad (_("expecting string instruction after `%s'"),
1644               expecting_string_instruction);
1645       return NULL;
1646     }
1647
1648   return l;
1649 }
1650
1651 static char *
1652 parse_operands (l, mnemonic)
1653      char *l;
1654      const char *mnemonic;
1655 {
1656   char *token_start;
1657
1658   /* 1 if operand is pending after ','.  */
1659   unsigned int expecting_operand = 0;
1660
1661   /* Non-zero if operand parens not balanced.  */
1662   unsigned int paren_not_balanced;
1663
1664   while (*l != END_OF_INSN)
1665     {
1666       /* Skip optional white space before operand.  */
1667       if (is_space_char (*l))
1668         ++l;
1669       if (!is_operand_char (*l) && *l != END_OF_INSN)
1670         {
1671           as_bad (_("invalid character %s before operand %d"),
1672                   output_invalid (*l),
1673                   i.operands + 1);
1674           return NULL;
1675         }
1676       token_start = l;  /* after white space */
1677       paren_not_balanced = 0;
1678       while (paren_not_balanced || *l != ',')
1679         {
1680           if (*l == END_OF_INSN)
1681             {
1682               if (paren_not_balanced)
1683                 {
1684                   if (!intel_syntax)
1685                     as_bad (_("unbalanced parenthesis in operand %d."),
1686                             i.operands + 1);
1687                   else
1688                     as_bad (_("unbalanced brackets in operand %d."),
1689                             i.operands + 1);
1690                   return NULL;
1691                 }
1692               else
1693                 break;  /* we are done */
1694             }
1695           else if (!is_operand_char (*l) && !is_space_char (*l))
1696             {
1697               as_bad (_("invalid character %s in operand %d"),
1698                       output_invalid (*l),
1699                       i.operands + 1);
1700               return NULL;
1701             }
1702           if (!intel_syntax)
1703             {
1704               if (*l == '(')
1705                 ++paren_not_balanced;
1706               if (*l == ')')
1707                 --paren_not_balanced;
1708             }
1709           else
1710             {
1711               if (*l == '[')
1712                 ++paren_not_balanced;
1713               if (*l == ']')
1714                 --paren_not_balanced;
1715             }
1716           l++;
1717         }
1718       if (l != token_start)
1719         {                       /* Yes, we've read in another operand.  */
1720           unsigned int operand_ok;
1721           this_operand = i.operands++;
1722           if (i.operands > MAX_OPERANDS)
1723             {
1724               as_bad (_("spurious operands; (%d operands/instruction max)"),
1725                       MAX_OPERANDS);
1726               return NULL;
1727             }
1728           /* Now parse operand adding info to 'i' as we go along.  */
1729           END_STRING_AND_SAVE (l);
1730
1731           if (intel_syntax)
1732             operand_ok =
1733               i386_intel_operand (token_start,
1734                                   intel_float_operand (mnemonic));
1735           else
1736             operand_ok = i386_operand (token_start);
1737
1738           RESTORE_END_STRING (l);
1739           if (!operand_ok)
1740             return NULL;
1741         }
1742       else
1743         {
1744           if (expecting_operand)
1745             {
1746             expecting_operand_after_comma:
1747               as_bad (_("expecting operand after ','; got nothing"));
1748               return NULL;
1749             }
1750           if (*l == ',')
1751             {
1752               as_bad (_("expecting operand before ','; got nothing"));
1753               return NULL;
1754             }
1755         }
1756
1757       /* Now *l must be either ',' or END_OF_INSN.  */
1758       if (*l == ',')
1759         {
1760           if (*++l == END_OF_INSN)
1761             {
1762               /* Just skip it, if it's \n complain.  */
1763               goto expecting_operand_after_comma;
1764             }
1765           expecting_operand = 1;
1766         }
1767     }
1768   return l;
1769 }
1770
1771 static void
1772 swap_operands ()
1773 {
1774   union i386_op temp_op;
1775   unsigned int temp_type;
1776   RELOC_ENUM temp_reloc;
1777   int xchg1 = 0;
1778   int xchg2 = 0;
1779
1780   if (i.operands == 2)
1781     {
1782       xchg1 = 0;
1783       xchg2 = 1;
1784     }
1785   else if (i.operands == 3)
1786     {
1787       xchg1 = 0;
1788       xchg2 = 2;
1789     }
1790   temp_type = i.types[xchg2];
1791   i.types[xchg2] = i.types[xchg1];
1792   i.types[xchg1] = temp_type;
1793   temp_op = i.op[xchg2];
1794   i.op[xchg2] = i.op[xchg1];
1795   i.op[xchg1] = temp_op;
1796   temp_reloc = i.reloc[xchg2];
1797   i.reloc[xchg2] = i.reloc[xchg1];
1798   i.reloc[xchg1] = temp_reloc;
1799
1800   if (i.mem_operands == 2)
1801     {
1802       const seg_entry *temp_seg;
1803       temp_seg = i.seg[0];
1804       i.seg[0] = i.seg[1];
1805       i.seg[1] = temp_seg;
1806     }
1807 }
1808
1809 /* Try to ensure constant immediates are represented in the smallest
1810    opcode possible.  */
1811 static void
1812 optimize_imm ()
1813 {
1814   char guess_suffix = 0;
1815   int op;
1816
1817   if (i.suffix)
1818     guess_suffix = i.suffix;
1819   else if (i.reg_operands)
1820     {
1821       /* Figure out a suffix from the last register operand specified.
1822          We can't do this properly yet, ie. excluding InOutPortReg,
1823          but the following works for instructions with immediates.
1824          In any case, we can't set i.suffix yet.  */
1825       for (op = i.operands; --op >= 0;)
1826         if (i.types[op] & Reg)
1827           {
1828             if (i.types[op] & Reg8)
1829               guess_suffix = BYTE_MNEM_SUFFIX;
1830             else if (i.types[op] & Reg16)
1831               guess_suffix = WORD_MNEM_SUFFIX;
1832             else if (i.types[op] & Reg32)
1833               guess_suffix = LONG_MNEM_SUFFIX;
1834             else if (i.types[op] & Reg64)
1835               guess_suffix = QWORD_MNEM_SUFFIX;
1836             break;
1837           }
1838     }
1839   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
1840     guess_suffix = WORD_MNEM_SUFFIX;
1841
1842   for (op = i.operands; --op >= 0;)
1843     if (i.types[op] & Imm)
1844       {
1845         switch (i.op[op].imms->X_op)
1846           {
1847           case O_constant:
1848             /* If a suffix is given, this operand may be shortened.  */
1849             switch (guess_suffix)
1850               {
1851               case LONG_MNEM_SUFFIX:
1852                 i.types[op] |= Imm32 | Imm64;
1853                 break;
1854               case WORD_MNEM_SUFFIX:
1855                 i.types[op] |= Imm16 | Imm32S | Imm32 | Imm64;
1856                 break;
1857               case BYTE_MNEM_SUFFIX:
1858                 i.types[op] |= Imm16 | Imm8 | Imm8S | Imm32S | Imm32 | Imm64;
1859                 break;
1860               }
1861
1862             /* If this operand is at most 16 bits, convert it
1863                to a signed 16 bit number before trying to see
1864                whether it will fit in an even smaller size.
1865                This allows a 16-bit operand such as $0xffe0 to
1866                be recognised as within Imm8S range.  */
1867             if ((i.types[op] & Imm16)
1868                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
1869               {
1870                 i.op[op].imms->X_add_number =
1871                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
1872               }
1873             if ((i.types[op] & Imm32)
1874                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
1875                     == 0))
1876               {
1877                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
1878                                                 ^ ((offsetT) 1 << 31))
1879                                                - ((offsetT) 1 << 31));
1880               }
1881             i.types[op] |= smallest_imm_type (i.op[op].imms->X_add_number);
1882
1883             /* We must avoid matching of Imm32 templates when 64bit
1884                only immediate is available.  */
1885             if (guess_suffix == QWORD_MNEM_SUFFIX)
1886               i.types[op] &= ~Imm32;
1887             break;
1888
1889           case O_absent:
1890           case O_register:
1891             abort ();
1892
1893             /* Symbols and expressions.  */
1894           default:
1895             /* Convert symbolic operand to proper sizes for matching.  */
1896             switch (guess_suffix)
1897               {
1898               case QWORD_MNEM_SUFFIX:
1899                 i.types[op] = Imm64 | Imm32S;
1900                 break;
1901               case LONG_MNEM_SUFFIX:
1902                 i.types[op] = Imm32 | Imm64;
1903                 break;
1904               case WORD_MNEM_SUFFIX:
1905                 i.types[op] = Imm16 | Imm32 | Imm64;
1906                 break;
1907                 break;
1908               case BYTE_MNEM_SUFFIX:
1909                 i.types[op] = Imm8 | Imm8S | Imm16 | Imm32S | Imm32;
1910                 break;
1911                 break;
1912               }
1913             break;
1914           }
1915       }
1916 }
1917
1918 /* Try to use the smallest displacement type too.  */
1919 static void
1920 optimize_disp ()
1921 {
1922   int op;
1923
1924   for (op = i.operands; --op >= 0;)
1925     if ((i.types[op] & Disp) && i.op[op].disps->X_op == O_constant)
1926       {
1927         offsetT disp = i.op[op].disps->X_add_number;
1928
1929         if (i.types[op] & Disp16)
1930           {
1931             /* We know this operand is at most 16 bits, so
1932                convert to a signed 16 bit number before trying
1933                to see whether it will fit in an even smaller
1934                size.  */
1935
1936             disp = (((disp & 0xffff) ^ 0x8000) - 0x8000);
1937           }
1938         else if (i.types[op] & Disp32)
1939           {
1940             /* We know this operand is at most 32 bits, so convert to a
1941                signed 32 bit number before trying to see whether it will
1942                fit in an even smaller size.  */
1943             disp &= (((offsetT) 2 << 31) - 1);
1944             disp = (disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
1945           }
1946         if (flag_code == CODE_64BIT)
1947           {
1948             if (fits_in_signed_long (disp))
1949               i.types[op] |= Disp32S;
1950             if (fits_in_unsigned_long (disp))
1951               i.types[op] |= Disp32;
1952           }
1953         if ((i.types[op] & (Disp32 | Disp32S | Disp16))
1954             && fits_in_signed_byte (disp))
1955           i.types[op] |= Disp8;
1956       }
1957 }
1958
1959 static int
1960 match_template ()
1961 {
1962   /* Points to template once we've found it.  */
1963   const template *t;
1964   unsigned int overlap0, overlap1, overlap2;
1965   unsigned int found_reverse_match;
1966   int suffix_check;
1967
1968 #define MATCH(overlap, given, template)                         \
1969   ((overlap & ~JumpAbsolute)                                    \
1970    && (((given) & (BaseIndex | JumpAbsolute))                   \
1971        == ((overlap) & (BaseIndex | JumpAbsolute))))
1972
1973   /* If given types r0 and r1 are registers they must be of the same type
1974      unless the expected operand type register overlap is null.
1975      Note that Acc in a template matches every size of reg.  */
1976 #define CONSISTENT_REGISTER_MATCH(m0, g0, t0, m1, g1, t1)       \
1977   (((g0) & Reg) == 0 || ((g1) & Reg) == 0                       \
1978    || ((g0) & Reg) == ((g1) & Reg)                              \
1979    || ((((m0) & Acc) ? Reg : (t0)) & (((m1) & Acc) ? Reg : (t1)) & Reg) == 0 )
1980
1981   overlap0 = 0;
1982   overlap1 = 0;
1983   overlap2 = 0;
1984   found_reverse_match = 0;
1985   suffix_check = (i.suffix == BYTE_MNEM_SUFFIX
1986                   ? No_bSuf
1987                   : (i.suffix == WORD_MNEM_SUFFIX
1988                      ? No_wSuf
1989                      : (i.suffix == SHORT_MNEM_SUFFIX
1990                         ? No_sSuf
1991                         : (i.suffix == LONG_MNEM_SUFFIX
1992                            ? No_lSuf
1993                            : (i.suffix == QWORD_MNEM_SUFFIX
1994                               ? No_qSuf
1995                               : (i.suffix == LONG_DOUBLE_MNEM_SUFFIX
1996                                  ? No_xSuf : 0))))));
1997
1998   for (t = current_templates->start;
1999        t < current_templates->end;
2000        t++)
2001     {
2002       /* Must have right number of operands.  */
2003       if (i.operands != t->operands)
2004         continue;
2005
2006       /* Check the suffix, except for some instructions in intel mode.  */
2007       if ((t->opcode_modifier & suffix_check)
2008           && !(intel_syntax
2009                && (t->opcode_modifier & IgnoreSize))
2010           && !(intel_syntax
2011                && t->base_opcode == 0xd9
2012                && (t->extension_opcode == 5          /* 0xd9,5 "fldcw"  */
2013                    || t->extension_opcode == 7)))  /* 0xd9,7 "f{n}stcw"  */
2014         continue;
2015
2016       /* Do not verify operands when there are none.  */
2017       else if (!t->operands)
2018         {
2019           if (t->cpu_flags & ~cpu_arch_flags)
2020             continue;
2021           /* We've found a match; break out of loop.  */
2022           break;
2023         }
2024
2025       overlap0 = i.types[0] & t->operand_types[0];
2026       switch (t->operands)
2027         {
2028         case 1:
2029           if (!MATCH (overlap0, i.types[0], t->operand_types[0]))
2030             continue;
2031           break;
2032         case 2:
2033         case 3:
2034           overlap1 = i.types[1] & t->operand_types[1];
2035           if (!MATCH (overlap0, i.types[0], t->operand_types[0])
2036               || !MATCH (overlap1, i.types[1], t->operand_types[1])
2037               || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
2038                                              t->operand_types[0],
2039                                              overlap1, i.types[1],
2040                                              t->operand_types[1]))
2041             {
2042               /* Check if other direction is valid ...  */
2043               if ((t->opcode_modifier & (D | FloatD)) == 0)
2044                 continue;
2045
2046               /* Try reversing direction of operands.  */
2047               overlap0 = i.types[0] & t->operand_types[1];
2048               overlap1 = i.types[1] & t->operand_types[0];
2049               if (!MATCH (overlap0, i.types[0], t->operand_types[1])
2050                   || !MATCH (overlap1, i.types[1], t->operand_types[0])
2051                   || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
2052                                                  t->operand_types[1],
2053                                                  overlap1, i.types[1],
2054                                                  t->operand_types[0]))
2055                 {
2056                   /* Does not match either direction.  */
2057                   continue;
2058                 }
2059               /* found_reverse_match holds which of D or FloatDR
2060                  we've found.  */
2061               found_reverse_match = t->opcode_modifier & (D | FloatDR);
2062             }
2063           /* Found a forward 2 operand match here.  */
2064           else if (t->operands == 3)
2065             {
2066               /* Here we make use of the fact that there are no
2067                  reverse match 3 operand instructions, and all 3
2068                  operand instructions only need to be checked for
2069                  register consistency between operands 2 and 3.  */
2070               overlap2 = i.types[2] & t->operand_types[2];
2071               if (!MATCH (overlap2, i.types[2], t->operand_types[2])
2072                   || !CONSISTENT_REGISTER_MATCH (overlap1, i.types[1],
2073                                                  t->operand_types[1],
2074                                                  overlap2, i.types[2],
2075                                                  t->operand_types[2]))
2076
2077                 continue;
2078             }
2079           /* Found either forward/reverse 2 or 3 operand match here:
2080              slip through to break.  */
2081         }
2082       if (t->cpu_flags & ~cpu_arch_flags)
2083         {
2084           found_reverse_match = 0;
2085           continue;
2086         }
2087       /* We've found a match; break out of loop.  */
2088       break;
2089     }
2090
2091   if (t == current_templates->end)
2092     {
2093       /* We found no match.  */
2094       as_bad (_("suffix or operands invalid for `%s'"),
2095               current_templates->start->name);
2096       return 0;
2097     }
2098
2099   if (!quiet_warnings)
2100     {
2101       if (!intel_syntax
2102           && ((i.types[0] & JumpAbsolute)
2103               != (t->operand_types[0] & JumpAbsolute)))
2104         {
2105           as_warn (_("indirect %s without `*'"), t->name);
2106         }
2107
2108       if ((t->opcode_modifier & (IsPrefix | IgnoreSize))
2109           == (IsPrefix | IgnoreSize))
2110         {
2111           /* Warn them that a data or address size prefix doesn't
2112              affect assembly of the next line of code.  */
2113           as_warn (_("stand-alone `%s' prefix"), t->name);
2114         }
2115     }
2116
2117   /* Copy the template we found.  */
2118   i.tm = *t;
2119   if (found_reverse_match)
2120     {
2121       /* If we found a reverse match we must alter the opcode
2122          direction bit.  found_reverse_match holds bits to change
2123          (different for int & float insns).  */
2124
2125       i.tm.base_opcode ^= found_reverse_match;
2126
2127       i.tm.operand_types[0] = t->operand_types[1];
2128       i.tm.operand_types[1] = t->operand_types[0];
2129     }
2130
2131   return 1;
2132 }
2133
2134 static int
2135 check_string ()
2136 {
2137   int mem_op = (i.types[0] & AnyMem) ? 0 : 1;
2138   if ((i.tm.operand_types[mem_op] & EsSeg) != 0)
2139     {
2140       if (i.seg[0] != NULL && i.seg[0] != &es)
2141         {
2142           as_bad (_("`%s' operand %d must use `%%es' segment"),
2143                   i.tm.name,
2144                   mem_op + 1);
2145           return 0;
2146         }
2147       /* There's only ever one segment override allowed per instruction.
2148          This instruction possibly has a legal segment override on the
2149          second operand, so copy the segment to where non-string
2150          instructions store it, allowing common code.  */
2151       i.seg[0] = i.seg[1];
2152     }
2153   else if ((i.tm.operand_types[mem_op + 1] & EsSeg) != 0)
2154     {
2155       if (i.seg[1] != NULL && i.seg[1] != &es)
2156         {
2157           as_bad (_("`%s' operand %d must use `%%es' segment"),
2158                   i.tm.name,
2159                   mem_op + 2);
2160           return 0;
2161         }
2162     }
2163   return 1;
2164 }
2165
2166 static int
2167 process_suffix ()
2168 {
2169   /* If matched instruction specifies an explicit instruction mnemonic
2170      suffix, use it.  */
2171   if (i.tm.opcode_modifier & (Size16 | Size32 | Size64))
2172     {
2173       if (i.tm.opcode_modifier & Size16)
2174         i.suffix = WORD_MNEM_SUFFIX;
2175       else if (i.tm.opcode_modifier & Size64)
2176         i.suffix = QWORD_MNEM_SUFFIX;
2177       else
2178         i.suffix = LONG_MNEM_SUFFIX;
2179     }
2180   else if (i.reg_operands)
2181     {
2182       /* If there's no instruction mnemonic suffix we try to invent one
2183          based on register operands.  */
2184       if (!i.suffix)
2185         {
2186           /* We take i.suffix from the last register operand specified,
2187              Destination register type is more significant than source
2188              register type.  */
2189           int op;
2190           for (op = i.operands; --op >= 0;)
2191             if ((i.types[op] & Reg)
2192                 && !(i.tm.operand_types[op] & InOutPortReg))
2193               {
2194                 i.suffix = ((i.types[op] & Reg8) ? BYTE_MNEM_SUFFIX :
2195                             (i.types[op] & Reg16) ? WORD_MNEM_SUFFIX :
2196                             (i.types[op] & Reg64) ? QWORD_MNEM_SUFFIX :
2197                             LONG_MNEM_SUFFIX);
2198                 break;
2199               }
2200         }
2201       else if (i.suffix == BYTE_MNEM_SUFFIX)
2202         {
2203           if (!check_byte_reg ())
2204             return 0;
2205         }
2206       else if (i.suffix == LONG_MNEM_SUFFIX)
2207         {
2208           if (!check_long_reg ())
2209             return 0;
2210         }
2211       else if (i.suffix == QWORD_MNEM_SUFFIX)
2212         {
2213           if (!check_qword_reg ())
2214             return 0;
2215         }
2216       else if (i.suffix == WORD_MNEM_SUFFIX)
2217         {
2218           if (!check_word_reg ())
2219             return 0;
2220         }
2221       else if (intel_syntax && (i.tm.opcode_modifier & IgnoreSize))
2222         /* Do nothing if the instruction is going to ignore the prefix.  */
2223         ;
2224       else
2225         abort ();
2226     }
2227   else if ((i.tm.opcode_modifier & DefaultSize) && !i.suffix)
2228     {
2229       i.suffix = stackop_size;
2230     }
2231
2232   /* Change the opcode based on the operand size given by i.suffix;
2233      We need not change things for byte insns.  */
2234
2235   if (!i.suffix && (i.tm.opcode_modifier & W))
2236     {
2237       as_bad (_("no instruction mnemonic suffix given and no register operands; can't size instruction"));
2238       return 0;
2239     }
2240
2241   if (i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
2242     {
2243       /* It's not a byte, select word/dword operation.  */
2244       if (i.tm.opcode_modifier & W)
2245         {
2246           if (i.tm.opcode_modifier & ShortForm)
2247             i.tm.base_opcode |= 8;
2248           else
2249             i.tm.base_opcode |= 1;
2250         }
2251
2252       /* Now select between word & dword operations via the operand
2253          size prefix, except for instructions that will ignore this
2254          prefix anyway.  */
2255       if (i.suffix != QWORD_MNEM_SUFFIX
2256           && !(i.tm.opcode_modifier & IgnoreSize)
2257           && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
2258               || (flag_code == CODE_64BIT
2259                   && (i.tm.opcode_modifier & JumpByte))))
2260         {
2261           unsigned int prefix = DATA_PREFIX_OPCODE;
2262           if (i.tm.opcode_modifier & JumpByte) /* jcxz, loop */
2263             prefix = ADDR_PREFIX_OPCODE;
2264
2265           if (!add_prefix (prefix))
2266             return 0;
2267         }
2268
2269       /* Set mode64 for an operand.  */
2270       if (i.suffix == QWORD_MNEM_SUFFIX
2271           && flag_code == CODE_64BIT
2272           && (i.tm.opcode_modifier & NoRex64) == 0)
2273         i.rex |= REX_MODE64;
2274
2275       /* Size floating point instruction.  */
2276       if (i.suffix == LONG_MNEM_SUFFIX)
2277         {
2278           if (i.tm.opcode_modifier & FloatMF)
2279             i.tm.base_opcode ^= 4;
2280         }
2281     }
2282
2283   return 1;
2284 }
2285
2286 static int
2287 check_byte_reg ()
2288 {
2289   int op;
2290   for (op = i.operands; --op >= 0;)
2291     {
2292       /* If this is an eight bit register, it's OK.  If it's the 16 or
2293          32 bit version of an eight bit register, we will just use the
2294          low portion, and that's OK too.  */
2295       if (i.types[op] & Reg8)
2296         continue;
2297
2298       /* movzx and movsx should not generate this warning.  */
2299       if (intel_syntax
2300           && (i.tm.base_opcode == 0xfb7
2301               || i.tm.base_opcode == 0xfb6
2302               || i.tm.base_opcode == 0x63
2303               || i.tm.base_opcode == 0xfbe
2304               || i.tm.base_opcode == 0xfbf))
2305         continue;
2306
2307       if ((i.types[op] & WordReg) && i.op[op].regs->reg_num < 4
2308 #if 0
2309           /* Check that the template allows eight bit regs.  This
2310              kills insns such as `orb $1,%edx', which maybe should be
2311              allowed.  */
2312           && (i.tm.operand_types[op] & (Reg8 | InOutPortReg))
2313 #endif
2314           )
2315         {
2316           /* Prohibit these changes in the 64bit mode, since the
2317              lowering is more complicated.  */
2318           if (flag_code == CODE_64BIT
2319               && (i.tm.operand_types[op] & InOutPortReg) == 0)
2320             {
2321               as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2322                       i.op[op].regs->reg_name,
2323                       i.suffix);
2324               return 0;
2325             }
2326 #if REGISTER_WARNINGS
2327           if (!quiet_warnings
2328               && (i.tm.operand_types[op] & InOutPortReg) == 0)
2329             as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
2330                      (i.op[op].regs + (i.types[op] & Reg16
2331                                        ? REGNAM_AL - REGNAM_AX
2332                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
2333                      i.op[op].regs->reg_name,
2334                      i.suffix);
2335 #endif
2336           continue;
2337         }
2338       /* Any other register is bad.  */
2339       if (i.types[op] & (Reg | RegMMX | RegXMM
2340                          | SReg2 | SReg3
2341                          | Control | Debug | Test
2342                          | FloatReg | FloatAcc))
2343         {
2344           as_bad (_("`%%%s' not allowed with `%s%c'"),
2345                   i.op[op].regs->reg_name,
2346                   i.tm.name,
2347                   i.suffix);
2348           return 0;
2349         }
2350     }
2351   return 1;
2352 }
2353
2354 static int
2355 check_long_reg ()
2356 {
2357   int op;
2358
2359   for (op = i.operands; --op >= 0;)
2360     /* Reject eight bit registers, except where the template requires
2361        them. (eg. movzb)  */
2362     if ((i.types[op] & Reg8) != 0
2363         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
2364       {
2365         as_bad (_("`%%%s' not allowed with `%s%c'"),
2366                 i.op[op].regs->reg_name,
2367                 i.tm.name,
2368                 i.suffix);
2369         return 0;
2370       }
2371   /* Warn if the e prefix on a general reg is missing.  */
2372     else if ((!quiet_warnings || flag_code == CODE_64BIT)
2373              && (i.types[op] & Reg16) != 0
2374              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
2375       {
2376         /* Prohibit these changes in the 64bit mode, since the
2377            lowering is more complicated.  */
2378         if (flag_code == CODE_64BIT)
2379           {
2380             as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2381                     i.op[op].regs->reg_name,
2382                     i.suffix);
2383             return 0;
2384           }
2385 #if REGISTER_WARNINGS
2386         else
2387           as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
2388                    (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
2389                    i.op[op].regs->reg_name,
2390                    i.suffix);
2391 #endif
2392       }
2393   /* Warn if the r prefix on a general reg is missing.  */
2394     else if ((i.types[op] & Reg64) != 0
2395              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
2396       {
2397         as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2398                 i.op[op].regs->reg_name,
2399                 i.suffix);
2400         return 0;
2401       }
2402   return 1;
2403 }
2404
2405 static int
2406 check_qword_reg ()
2407 {
2408   int op;
2409
2410   for (op = i.operands; --op >= 0; )
2411     /* Reject eight bit registers, except where the template requires
2412        them. (eg. movzb)  */
2413     if ((i.types[op] & Reg8) != 0
2414         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
2415       {
2416         as_bad (_("`%%%s' not allowed with `%s%c'"),
2417                 i.op[op].regs->reg_name,
2418                 i.tm.name,
2419                 i.suffix);
2420         return 0;
2421       }
2422   /* Warn if the e prefix on a general reg is missing.  */
2423     else if (((i.types[op] & Reg16) != 0
2424               || (i.types[op] & Reg32) != 0)
2425              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
2426       {
2427         /* Prohibit these changes in the 64bit mode, since the
2428            lowering is more complicated.  */
2429         as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2430                 i.op[op].regs->reg_name,
2431                 i.suffix);
2432         return 0;
2433       }
2434   return 1;
2435 }
2436
2437 static int
2438 check_word_reg ()
2439 {
2440   int op;
2441   for (op = i.operands; --op >= 0;)
2442     /* Reject eight bit registers, except where the template requires
2443        them. (eg. movzb)  */
2444     if ((i.types[op] & Reg8) != 0
2445         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
2446       {
2447         as_bad (_("`%%%s' not allowed with `%s%c'"),
2448                 i.op[op].regs->reg_name,
2449                 i.tm.name,
2450                 i.suffix);
2451         return 0;
2452       }
2453   /* Warn if the e prefix on a general reg is present.  */
2454     else if ((!quiet_warnings || flag_code == CODE_64BIT)
2455              && (i.types[op] & Reg32) != 0
2456              && (i.tm.operand_types[op] & (Reg16 | Acc)) != 0)
2457       {
2458         /* Prohibit these changes in the 64bit mode, since the
2459            lowering is more complicated.  */
2460         if (flag_code == CODE_64BIT)
2461           {
2462             as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2463                     i.op[op].regs->reg_name,
2464                     i.suffix);
2465             return 0;
2466           }
2467         else
2468 #if REGISTER_WARNINGS
2469           as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
2470                    (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
2471                    i.op[op].regs->reg_name,
2472                    i.suffix);
2473 #endif
2474       }
2475   return 1;
2476 }
2477
2478 static int
2479 finalize_imm ()
2480 {
2481   unsigned int overlap0, overlap1, overlap2;
2482
2483   overlap0 = i.types[0] & i.tm.operand_types[0];
2484   if ((overlap0 & (Imm8 | Imm8S | Imm16 | Imm32 | Imm32S))
2485       && overlap0 != Imm8 && overlap0 != Imm8S
2486       && overlap0 != Imm16 && overlap0 != Imm32S
2487       && overlap0 != Imm32 && overlap0 != Imm64)
2488     {
2489       if (i.suffix)
2490         {
2491           overlap0 &= (i.suffix == BYTE_MNEM_SUFFIX
2492                        ? Imm8 | Imm8S
2493                        : (i.suffix == WORD_MNEM_SUFFIX
2494                           ? Imm16
2495                           : (i.suffix == QWORD_MNEM_SUFFIX
2496                              ? Imm64 | Imm32S
2497                              : Imm32)));
2498         }
2499       else if (overlap0 == (Imm16 | Imm32S | Imm32)
2500                || overlap0 == (Imm16 | Imm32)
2501                || overlap0 == (Imm16 | Imm32S))
2502         {
2503           overlap0 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
2504                       ? Imm16 : Imm32S);
2505         }
2506       if (overlap0 != Imm8 && overlap0 != Imm8S
2507           && overlap0 != Imm16 && overlap0 != Imm32S
2508           && overlap0 != Imm32 && overlap0 != Imm64)
2509         {
2510           as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
2511           return 0;
2512         }
2513     }
2514   i.types[0] = overlap0;
2515
2516   overlap1 = i.types[1] & i.tm.operand_types[1];
2517   if ((overlap1 & (Imm8 | Imm8S | Imm16 | Imm32S | Imm32))
2518       && overlap1 != Imm8 && overlap1 != Imm8S
2519       && overlap1 != Imm16 && overlap1 != Imm32S
2520       && overlap1 != Imm32 && overlap1 != Imm64)
2521     {
2522       if (i.suffix)
2523         {
2524           overlap1 &= (i.suffix == BYTE_MNEM_SUFFIX
2525                        ? Imm8 | Imm8S
2526                        : (i.suffix == WORD_MNEM_SUFFIX
2527                           ? Imm16
2528                           : (i.suffix == QWORD_MNEM_SUFFIX
2529                              ? Imm64 | Imm32S
2530                              : Imm32)));
2531         }
2532       else if (overlap1 == (Imm16 | Imm32 | Imm32S)
2533                || overlap1 == (Imm16 | Imm32)
2534                || overlap1 == (Imm16 | Imm32S))
2535         {
2536           overlap1 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
2537                       ? Imm16 : Imm32S);
2538         }
2539       if (overlap1 != Imm8 && overlap1 != Imm8S
2540           && overlap1 != Imm16 && overlap1 != Imm32S
2541           && overlap1 != Imm32 && overlap1 != Imm64)
2542         {
2543           as_bad (_("no instruction mnemonic suffix given; can't determine immediate size %x %c"),overlap1, i.suffix);
2544           return 0;
2545         }
2546     }
2547   i.types[1] = overlap1;
2548
2549   overlap2 = i.types[2] & i.tm.operand_types[2];
2550   assert ((overlap2 & Imm) == 0);
2551   i.types[2] = overlap2;
2552
2553   return 1;
2554 }
2555
2556 static int
2557 process_operands ()
2558 {
2559   /* Default segment register this instruction will use for memory
2560      accesses.  0 means unknown.  This is only for optimizing out
2561      unnecessary segment overrides.  */
2562   const seg_entry *default_seg = 0;
2563
2564   /* The imul $imm, %reg instruction is converted into
2565      imul $imm, %reg, %reg, and the clr %reg instruction
2566      is converted into xor %reg, %reg.  */
2567   if (i.tm.opcode_modifier & regKludge)
2568     {
2569       unsigned int first_reg_op = (i.types[0] & Reg) ? 0 : 1;
2570       /* Pretend we saw the extra register operand.  */
2571       assert (i.op[first_reg_op + 1].regs == 0);
2572       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
2573       i.types[first_reg_op + 1] = i.types[first_reg_op];
2574       i.reg_operands = 2;
2575     }
2576
2577   if (i.tm.opcode_modifier & ShortForm)
2578     {
2579       /* The register or float register operand is in operand 0 or 1.  */
2580       unsigned int op = (i.types[0] & (Reg | FloatReg)) ? 0 : 1;
2581       /* Register goes in low 3 bits of opcode.  */
2582       i.tm.base_opcode |= i.op[op].regs->reg_num;
2583       if ((i.op[op].regs->reg_flags & RegRex) != 0)
2584         i.rex |= REX_EXTZ;
2585       if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
2586         {
2587           /* Warn about some common errors, but press on regardless.
2588              The first case can be generated by gcc (<= 2.8.1).  */
2589           if (i.operands == 2)
2590             {
2591               /* Reversed arguments on faddp, fsubp, etc.  */
2592               as_warn (_("translating to `%s %%%s,%%%s'"), i.tm.name,
2593                        i.op[1].regs->reg_name,
2594                        i.op[0].regs->reg_name);
2595             }
2596           else
2597             {
2598               /* Extraneous `l' suffix on fp insn.  */
2599               as_warn (_("translating to `%s %%%s'"), i.tm.name,
2600                        i.op[0].regs->reg_name);
2601             }
2602         }
2603     }
2604   else if (i.tm.opcode_modifier & Modrm)
2605     {
2606       /* The opcode is completed (modulo i.tm.extension_opcode which
2607          must be put into the modrm byte).
2608          Now, we make the modrm & index base bytes based on all the
2609          info we've collected.  */
2610
2611       default_seg = build_modrm_byte ();
2612     }
2613   else if (i.tm.opcode_modifier & (Seg2ShortForm | Seg3ShortForm))
2614     {
2615       if (i.tm.base_opcode == POP_SEG_SHORT
2616           && i.op[0].regs->reg_num == 1)
2617         {
2618           as_bad (_("you can't `pop %%cs'"));
2619           return 0;
2620         }
2621       i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
2622       if ((i.op[0].regs->reg_flags & RegRex) != 0)
2623         i.rex |= REX_EXTZ;
2624     }
2625   else if ((i.tm.base_opcode & ~(D | W)) == MOV_AX_DISP32)
2626     {
2627       default_seg = &ds;
2628     }
2629   else if ((i.tm.opcode_modifier & IsString) != 0)
2630     {
2631       /* For the string instructions that allow a segment override
2632          on one of their operands, the default segment is ds.  */
2633       default_seg = &ds;
2634     }
2635
2636   /* If a segment was explicitly specified,
2637      and the specified segment is not the default,
2638      use an opcode prefix to select it.
2639      If we never figured out what the default segment is,
2640      then default_seg will be zero at this point,
2641      and the specified segment prefix will always be used.  */
2642   if ((i.seg[0]) && (i.seg[0] != default_seg))
2643     {
2644       if (!add_prefix (i.seg[0]->seg_prefix))
2645         return 0;
2646     }
2647   return 1;
2648 }
2649
2650 static const seg_entry *
2651 build_modrm_byte ()
2652 {
2653   const seg_entry *default_seg = 0;
2654
2655   /* i.reg_operands MUST be the number of real register operands;
2656      implicit registers do not count.  */
2657   if (i.reg_operands == 2)
2658     {
2659       unsigned int source, dest;
2660       source = ((i.types[0]
2661                  & (Reg | RegMMX | RegXMM
2662                     | SReg2 | SReg3
2663                     | Control | Debug | Test))
2664                 ? 0 : 1);
2665       dest = source + 1;
2666
2667       i.rm.mode = 3;
2668       /* One of the register operands will be encoded in the i.tm.reg
2669          field, the other in the combined i.tm.mode and i.tm.regmem
2670          fields.  If no form of this instruction supports a memory
2671          destination operand, then we assume the source operand may
2672          sometimes be a memory operand and so we need to store the
2673          destination in the i.rm.reg field.  */
2674       if ((i.tm.operand_types[dest] & AnyMem) == 0)
2675         {
2676           i.rm.reg = i.op[dest].regs->reg_num;
2677           i.rm.regmem = i.op[source].regs->reg_num;
2678           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
2679             i.rex |= REX_EXTX;
2680           if ((i.op[source].regs->reg_flags & RegRex) != 0)
2681             i.rex |= REX_EXTZ;
2682         }
2683       else
2684         {
2685           i.rm.reg = i.op[source].regs->reg_num;
2686           i.rm.regmem = i.op[dest].regs->reg_num;
2687           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
2688             i.rex |= REX_EXTZ;
2689           if ((i.op[source].regs->reg_flags & RegRex) != 0)
2690             i.rex |= REX_EXTX;
2691         }
2692     }
2693   else
2694     {                   /* If it's not 2 reg operands...  */
2695       if (i.mem_operands)
2696         {
2697           unsigned int fake_zero_displacement = 0;
2698           unsigned int op = ((i.types[0] & AnyMem)
2699                              ? 0
2700                              : (i.types[1] & AnyMem) ? 1 : 2);
2701
2702           default_seg = &ds;
2703
2704           if (i.base_reg == 0)
2705             {
2706               i.rm.mode = 0;
2707               if (!i.disp_operands)
2708                 fake_zero_displacement = 1;
2709               if (i.index_reg == 0)
2710                 {
2711                   /* Operand is just <disp>  */
2712                   if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0)
2713                       && (flag_code != CODE_64BIT))
2714                     {
2715                       i.rm.regmem = NO_BASE_REGISTER_16;
2716                       i.types[op] &= ~Disp;
2717                       i.types[op] |= Disp16;
2718                     }
2719                   else if (flag_code != CODE_64BIT
2720                            || (i.prefix[ADDR_PREFIX] != 0))
2721                     {
2722                       i.rm.regmem = NO_BASE_REGISTER;
2723                       i.types[op] &= ~Disp;
2724                       i.types[op] |= Disp32;
2725                     }
2726                   else
2727                     {
2728                       /* 64bit mode overwrites the 32bit absolute
2729                          addressing by RIP relative addressing and
2730                          absolute addressing is encoded by one of the
2731                          redundant SIB forms.  */
2732                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2733                       i.sib.base = NO_BASE_REGISTER;
2734                       i.sib.index = NO_INDEX_REGISTER;
2735                       i.types[op] &= ~Disp;
2736                       i.types[op] |= Disp32S;
2737                     }
2738                 }
2739               else /* !i.base_reg && i.index_reg  */
2740                 {
2741                   i.sib.index = i.index_reg->reg_num;
2742                   i.sib.base = NO_BASE_REGISTER;
2743                   i.sib.scale = i.log2_scale_factor;
2744                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2745                   i.types[op] &= ~Disp;
2746                   if (flag_code != CODE_64BIT)
2747                     i.types[op] |= Disp32;      /* Must be 32 bit */
2748                   else
2749                     i.types[op] |= Disp32S;
2750                   if ((i.index_reg->reg_flags & RegRex) != 0)
2751                     i.rex |= REX_EXTY;
2752                 }
2753             }
2754           /* RIP addressing for 64bit mode.  */
2755           else if (i.base_reg->reg_type == BaseIndex)
2756             {
2757               i.rm.regmem = NO_BASE_REGISTER;
2758               i.types[op] &= ~Disp;
2759               i.types[op] |= Disp32S;
2760               i.flags[op] = Operand_PCrel;
2761             }
2762           else if (i.base_reg->reg_type & Reg16)
2763             {
2764               switch (i.base_reg->reg_num)
2765                 {
2766                 case 3: /* (%bx)  */
2767                   if (i.index_reg == 0)
2768                     i.rm.regmem = 7;
2769                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
2770                     i.rm.regmem = i.index_reg->reg_num - 6;
2771                   break;
2772                 case 5: /* (%bp)  */
2773                   default_seg = &ss;
2774                   if (i.index_reg == 0)
2775                     {
2776                       i.rm.regmem = 6;
2777                       if ((i.types[op] & Disp) == 0)
2778                         {
2779                           /* fake (%bp) into 0(%bp)  */
2780                           i.types[op] |= Disp8;
2781                           fake_zero_displacement = 1;
2782                         }
2783                     }
2784                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
2785                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
2786                   break;
2787                 default: /* (%si) -> 4 or (%di) -> 5  */
2788                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
2789                 }
2790               i.rm.mode = mode_from_disp_size (i.types[op]);
2791             }
2792           else /* i.base_reg and 32/64 bit mode  */
2793             {
2794               if (flag_code == CODE_64BIT
2795                   && (i.types[op] & Disp))
2796                 {
2797                   if (i.types[op] & Disp8)
2798                     i.types[op] = Disp8 | Disp32S;
2799                   else
2800                     i.types[op] = Disp32S;
2801                 }
2802               i.rm.regmem = i.base_reg->reg_num;
2803               if ((i.base_reg->reg_flags & RegRex) != 0)
2804                 i.rex |= REX_EXTZ;
2805               i.sib.base = i.base_reg->reg_num;
2806               /* x86-64 ignores REX prefix bit here to avoid decoder
2807                  complications.  */
2808               if ((i.base_reg->reg_num & 7) == EBP_REG_NUM)
2809                 {
2810                   default_seg = &ss;
2811                   if (i.disp_operands == 0)
2812                     {
2813                       fake_zero_displacement = 1;
2814                       i.types[op] |= Disp8;
2815                     }
2816                 }
2817               else if (i.base_reg->reg_num == ESP_REG_NUM)
2818                 {
2819                   default_seg = &ss;
2820                 }
2821               i.sib.scale = i.log2_scale_factor;
2822               if (i.index_reg == 0)
2823                 {
2824                   /* <disp>(%esp) becomes two byte modrm with no index
2825                      register.  We've already stored the code for esp
2826                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
2827                      Any base register besides %esp will not use the
2828                      extra modrm byte.  */
2829                   i.sib.index = NO_INDEX_REGISTER;
2830 #if !SCALE1_WHEN_NO_INDEX
2831                   /* Another case where we force the second modrm byte.  */
2832                   if (i.log2_scale_factor)
2833                     i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2834 #endif
2835                 }
2836               else
2837                 {
2838                   i.sib.index = i.index_reg->reg_num;
2839                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2840                   if ((i.index_reg->reg_flags & RegRex) != 0)
2841                     i.rex |= REX_EXTY;
2842                 }
2843               i.rm.mode = mode_from_disp_size (i.types[op]);
2844             }
2845
2846           if (fake_zero_displacement)
2847             {
2848               /* Fakes a zero displacement assuming that i.types[op]
2849                  holds the correct displacement size.  */
2850               expressionS *exp;
2851
2852               assert (i.op[op].disps == 0);
2853               exp = &disp_expressions[i.disp_operands++];
2854               i.op[op].disps = exp;
2855               exp->X_op = O_constant;
2856               exp->X_add_number = 0;
2857               exp->X_add_symbol = (symbolS *) 0;
2858               exp->X_op_symbol = (symbolS *) 0;
2859             }
2860         }
2861
2862       /* Fill in i.rm.reg or i.rm.regmem field with register operand
2863          (if any) based on i.tm.extension_opcode.  Again, we must be
2864          careful to make sure that segment/control/debug/test/MMX
2865          registers are coded into the i.rm.reg field.  */
2866       if (i.reg_operands)
2867         {
2868           unsigned int op =
2869             ((i.types[0]
2870               & (Reg | RegMMX | RegXMM
2871                  | SReg2 | SReg3
2872                  | Control | Debug | Test))
2873              ? 0
2874              : ((i.types[1]
2875                  & (Reg | RegMMX | RegXMM
2876                     | SReg2 | SReg3
2877                     | Control | Debug | Test))
2878                 ? 1
2879                 : 2));
2880           /* If there is an extension opcode to put here, the register
2881              number must be put into the regmem field.  */
2882           if (i.tm.extension_opcode != None)
2883             {
2884               i.rm.regmem = i.op[op].regs->reg_num;
2885               if ((i.op[op].regs->reg_flags & RegRex) != 0)
2886                 i.rex |= REX_EXTZ;
2887             }
2888           else
2889             {
2890               i.rm.reg = i.op[op].regs->reg_num;
2891               if ((i.op[op].regs->reg_flags & RegRex) != 0)
2892                 i.rex |= REX_EXTX;
2893             }
2894
2895           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
2896              must set it to 3 to indicate this is a register operand
2897              in the regmem field.  */
2898           if (!i.mem_operands)
2899             i.rm.mode = 3;
2900         }
2901
2902       /* Fill in i.rm.reg field with extension opcode (if any).  */
2903       if (i.tm.extension_opcode != None)
2904         i.rm.reg = i.tm.extension_opcode;
2905     }
2906   return default_seg;
2907 }
2908
2909 static void
2910 output_branch ()
2911 {
2912   char *p;
2913   int code16;
2914   int prefix;
2915   relax_substateT subtype;
2916   symbolS *sym;
2917   offsetT off;
2918
2919   code16 = 0;
2920   if (flag_code == CODE_16BIT)
2921     code16 = CODE16;
2922
2923   prefix = 0;
2924   if (i.prefix[DATA_PREFIX] != 0)
2925     {
2926       prefix = 1;
2927       i.prefixes -= 1;
2928       code16 ^= CODE16;
2929     }
2930   /* Pentium4 branch hints.  */
2931   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
2932       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
2933     {
2934       prefix++;
2935       i.prefixes--;
2936     }
2937   if (i.prefix[REX_PREFIX] != 0)
2938     {
2939       prefix++;
2940       i.prefixes--;
2941     }
2942
2943   if (i.prefixes != 0 && !intel_syntax)
2944     as_warn (_("skipping prefixes on this instruction"));
2945
2946   /* It's always a symbol;  End frag & setup for relax.
2947      Make sure there is enough room in this frag for the largest
2948      instruction we may generate in md_convert_frag.  This is 2
2949      bytes for the opcode and room for the prefix and largest
2950      displacement.  */
2951   frag_grow (prefix + 2 + 4);
2952   /* Prefix and 1 opcode byte go in fr_fix.  */
2953   p = frag_more (prefix + 1);
2954   if (i.prefix[DATA_PREFIX] != 0)
2955     *p++ = DATA_PREFIX_OPCODE;
2956   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
2957       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
2958     *p++ = i.prefix[SEG_PREFIX];
2959   if (i.prefix[REX_PREFIX] != 0)
2960     *p++ = i.prefix[REX_PREFIX];
2961   *p = i.tm.base_opcode;
2962
2963   if ((unsigned char) *p == JUMP_PC_RELATIVE)
2964     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL);
2965   else if ((cpu_arch_flags & Cpu386) != 0)
2966     subtype = ENCODE_RELAX_STATE (COND_JUMP, SMALL);
2967   else
2968     subtype = ENCODE_RELAX_STATE (COND_JUMP86, SMALL);
2969   subtype |= code16;
2970
2971   sym = i.op[0].disps->X_add_symbol;
2972   off = i.op[0].disps->X_add_number;
2973
2974   if (i.op[0].disps->X_op != O_constant
2975       && i.op[0].disps->X_op != O_symbol)
2976     {
2977       /* Handle complex expressions.  */
2978       sym = make_expr_symbol (i.op[0].disps);
2979       off = 0;
2980     }
2981
2982   /* 1 possible extra opcode + 4 byte displacement go in var part.
2983      Pass reloc in fr_var.  */
2984   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
2985 }
2986
2987 static void
2988 output_jump ()
2989 {
2990   char *p;
2991   int size;
2992
2993   if (i.tm.opcode_modifier & JumpByte)
2994     {
2995       /* This is a loop or jecxz type instruction.  */
2996       size = 1;
2997       if (i.prefix[ADDR_PREFIX] != 0)
2998         {
2999           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
3000           i.prefixes -= 1;
3001         }
3002       /* Pentium4 branch hints.  */
3003       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
3004           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
3005         {
3006           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
3007           i.prefixes--;
3008         }
3009     }
3010   else
3011     {
3012       int code16;
3013
3014       code16 = 0;
3015       if (flag_code == CODE_16BIT)
3016         code16 = CODE16;
3017
3018       if (i.prefix[DATA_PREFIX] != 0)
3019         {
3020           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
3021           i.prefixes -= 1;
3022           code16 ^= CODE16;
3023         }
3024
3025       size = 4;
3026       if (code16)
3027         size = 2;
3028     }
3029
3030   if (i.prefix[REX_PREFIX] != 0)
3031     {
3032       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
3033       i.prefixes -= 1;
3034     }
3035
3036   if (i.prefixes != 0 && !intel_syntax)
3037     as_warn (_("skipping prefixes on this instruction"));
3038
3039   p = frag_more (1 + size);
3040   *p++ = i.tm.base_opcode;
3041
3042   fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3043                i.op[0].disps, 1, reloc (size, 1, 1, i.reloc[0]));
3044 }
3045
3046 static void
3047 output_interseg_jump ()
3048 {
3049   char *p;
3050   int size;
3051   int prefix;
3052   int code16;
3053
3054   code16 = 0;
3055   if (flag_code == CODE_16BIT)
3056     code16 = CODE16;
3057
3058   prefix = 0;
3059   if (i.prefix[DATA_PREFIX] != 0)
3060     {
3061       prefix = 1;
3062       i.prefixes -= 1;
3063       code16 ^= CODE16;
3064     }
3065   if (i.prefix[REX_PREFIX] != 0)
3066     {
3067       prefix++;
3068       i.prefixes -= 1;
3069     }
3070
3071   size = 4;
3072   if (code16)
3073     size = 2;
3074
3075   if (i.prefixes != 0 && !intel_syntax)
3076     as_warn (_("skipping prefixes on this instruction"));
3077
3078   /* 1 opcode; 2 segment; offset  */
3079   p = frag_more (prefix + 1 + 2 + size);
3080
3081   if (i.prefix[DATA_PREFIX] != 0)
3082     *p++ = DATA_PREFIX_OPCODE;
3083
3084   if (i.prefix[REX_PREFIX] != 0)
3085     *p++ = i.prefix[REX_PREFIX];
3086
3087   *p++ = i.tm.base_opcode;
3088   if (i.op[1].imms->X_op == O_constant)
3089     {
3090       offsetT n = i.op[1].imms->X_add_number;
3091
3092       if (size == 2
3093           && !fits_in_unsigned_word (n)
3094           && !fits_in_signed_word (n))
3095         {
3096           as_bad (_("16-bit jump out of range"));
3097           return;
3098         }
3099       md_number_to_chars (p, n, size);
3100     }
3101   else
3102     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3103                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
3104   if (i.op[0].imms->X_op != O_constant)
3105     as_bad (_("can't handle non absolute segment in `%s'"),
3106             i.tm.name);
3107   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
3108 }
3109
3110
3111 static void
3112 output_insn ()
3113 {
3114   fragS *insn_start_frag;
3115   offsetT insn_start_off;
3116
3117   /* Tie dwarf2 debug info to the address at the start of the insn.
3118      We can't do this after the insn has been output as the current
3119      frag may have been closed off.  eg. by frag_var.  */
3120   dwarf2_emit_insn (0);
3121
3122   insn_start_frag = frag_now;
3123   insn_start_off = frag_now_fix ();
3124
3125   /* Output jumps.  */
3126   if (i.tm.opcode_modifier & Jump)
3127     output_branch ();
3128   else if (i.tm.opcode_modifier & (JumpByte | JumpDword))
3129     output_jump ();
3130   else if (i.tm.opcode_modifier & JumpInterSegment)
3131     output_interseg_jump ();
3132   else
3133     {
3134       /* Output normal instructions here.  */
3135       char *p;
3136       unsigned char *q;
3137
3138       /* All opcodes on i386 have either 1 or 2 bytes.  We may use third
3139          byte for the SSE instructions to specify a prefix they require.  */
3140       if (i.tm.base_opcode & 0xff0000)
3141         add_prefix ((i.tm.base_opcode >> 16) & 0xff);
3142
3143       /* The prefix bytes.  */
3144       for (q = i.prefix;
3145            q < i.prefix + sizeof (i.prefix) / sizeof (i.prefix[0]);
3146            q++)
3147         {
3148           if (*q)
3149             {
3150               p = frag_more (1);
3151               md_number_to_chars (p, (valueT) *q, 1);
3152             }
3153         }
3154
3155       /* Now the opcode; be careful about word order here!  */
3156       if (fits_in_unsigned_byte (i.tm.base_opcode))
3157         {
3158           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
3159         }
3160       else
3161         {
3162           p = frag_more (2);
3163           /* Put out high byte first: can't use md_number_to_chars!  */
3164           *p++ = (i.tm.base_opcode >> 8) & 0xff;
3165           *p = i.tm.base_opcode & 0xff;
3166         }
3167
3168       /* Now the modrm byte and sib byte (if present).  */
3169       if (i.tm.opcode_modifier & Modrm)
3170         {
3171           p = frag_more (1);
3172           md_number_to_chars (p,
3173                               (valueT) (i.rm.regmem << 0
3174                                         | i.rm.reg << 3
3175                                         | i.rm.mode << 6),
3176                               1);
3177           /* If i.rm.regmem == ESP (4)
3178              && i.rm.mode != (Register mode)
3179              && not 16 bit
3180              ==> need second modrm byte.  */
3181           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
3182               && i.rm.mode != 3
3183               && !(i.base_reg && (i.base_reg->reg_type & Reg16) != 0))
3184             {
3185               p = frag_more (1);
3186               md_number_to_chars (p,
3187                                   (valueT) (i.sib.base << 0
3188                                             | i.sib.index << 3
3189                                             | i.sib.scale << 6),
3190                                   1);
3191             }
3192         }
3193
3194       if (i.disp_operands)
3195         output_disp (insn_start_frag, insn_start_off);
3196
3197       if (i.imm_operands)
3198         output_imm (insn_start_frag, insn_start_off);
3199     }
3200
3201 #ifdef DEBUG386
3202   if (flag_debug)
3203     {
3204       pi (line, &i);
3205     }
3206 #endif /* DEBUG386  */
3207 }
3208
3209 static void
3210 output_disp (insn_start_frag, insn_start_off)
3211     fragS *insn_start_frag;
3212     offsetT insn_start_off;
3213 {
3214   char *p;
3215   unsigned int n;
3216
3217   for (n = 0; n < i.operands; n++)
3218     {
3219       if (i.types[n] & Disp)
3220         {
3221           if (i.op[n].disps->X_op == O_constant)
3222             {
3223               int size;
3224               offsetT val;
3225
3226               size = 4;
3227               if (i.types[n] & (Disp8 | Disp16 | Disp64))
3228                 {
3229                   size = 2;
3230                   if (i.types[n] & Disp8)
3231                     size = 1;
3232                   if (i.types[n] & Disp64)
3233                     size = 8;
3234                 }
3235               val = offset_in_range (i.op[n].disps->X_add_number,
3236                                      size);
3237               p = frag_more (size);
3238               md_number_to_chars (p, val, size);
3239             }
3240           else
3241             {
3242               RELOC_ENUM reloc_type;
3243               int size = 4;
3244               int sign = 0;
3245               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
3246
3247               /* The PC relative address is computed relative
3248                  to the instruction boundary, so in case immediate
3249                  fields follows, we need to adjust the value.  */
3250               if (pcrel && i.imm_operands)
3251                 {
3252                   int imm_size = 4;
3253                   unsigned int n1;
3254
3255                   for (n1 = 0; n1 < i.operands; n1++)
3256                     if (i.types[n1] & Imm)
3257                       {
3258                         if (i.types[n1] & (Imm8 | Imm8S | Imm16 | Imm64))
3259                           {
3260                             imm_size = 2;
3261                             if (i.types[n1] & (Imm8 | Imm8S))
3262                               imm_size = 1;
3263                             if (i.types[n1] & Imm64)
3264                               imm_size = 8;
3265                           }
3266                         break;
3267                       }
3268                   /* We should find the immediate.  */
3269                   if (n1 == i.operands)
3270                     abort ();
3271                   i.op[n].disps->X_add_number -= imm_size;
3272                 }
3273
3274               if (i.types[n] & Disp32S)
3275                 sign = 1;
3276
3277               if (i.types[n] & (Disp16 | Disp64))
3278                 {
3279                   size = 2;
3280                   if (i.types[n] & Disp64)
3281                     size = 8;
3282                 }
3283
3284               p = frag_more (size);
3285               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
3286 #ifdef BFD_ASSEMBLER
3287               if (reloc_type == BFD_RELOC_32
3288                   && GOT_symbol
3289                   && GOT_symbol == i.op[n].disps->X_add_symbol
3290                   && (i.op[n].disps->X_op == O_symbol
3291                       || (i.op[n].disps->X_op == O_add
3292                           && ((symbol_get_value_expression
3293                                (i.op[n].disps->X_op_symbol)->X_op)
3294                               == O_subtract))))
3295                 {
3296                   offsetT add;
3297
3298                   if (insn_start_frag == frag_now)
3299                     add = (p - frag_now->fr_literal) - insn_start_off;
3300                   else
3301                     {
3302                       fragS *fr;
3303
3304                       add = insn_start_frag->fr_fix - insn_start_off;
3305                       for (fr = insn_start_frag->fr_next;
3306                            fr && fr != frag_now; fr = fr->fr_next)
3307                         add += fr->fr_fix;
3308                       add += p - frag_now->fr_literal;
3309                     }
3310
3311                   /* We don't support dynamic linking on x86-64 yet.  */
3312                   if (flag_code == CODE_64BIT)
3313                     abort ();
3314                   reloc_type = BFD_RELOC_386_GOTPC;
3315                   i.op[n].disps->X_add_number += add;
3316                 }
3317 #endif
3318               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3319                            i.op[n].disps, pcrel, reloc_type);
3320             }
3321         }
3322     }
3323 }
3324
3325 static void
3326 output_imm (insn_start_frag, insn_start_off)
3327     fragS *insn_start_frag;
3328     offsetT insn_start_off;
3329 {
3330   char *p;
3331   unsigned int n;
3332
3333   for (n = 0; n < i.operands; n++)
3334     {
3335       if (i.types[n] & Imm)
3336         {
3337           if (i.op[n].imms->X_op == O_constant)
3338             {
3339               int size;
3340               offsetT val;
3341
3342               size = 4;
3343               if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
3344                 {
3345                   size = 2;
3346                   if (i.types[n] & (Imm8 | Imm8S))
3347                     size = 1;
3348                   else if (i.types[n] & Imm64)
3349                     size = 8;
3350                 }
3351               val = offset_in_range (i.op[n].imms->X_add_number,
3352                                      size);
3353               p = frag_more (size);
3354               md_number_to_chars (p, val, size);
3355             }
3356           else
3357             {
3358               /* Not absolute_section.
3359                  Need a 32-bit fixup (don't support 8bit
3360                  non-absolute imms).  Try to support other
3361                  sizes ...  */
3362               RELOC_ENUM reloc_type;
3363               int size = 4;
3364               int sign = 0;
3365
3366               if ((i.types[n] & (Imm32S))
3367                   && i.suffix == QWORD_MNEM_SUFFIX)
3368                 sign = 1;
3369               if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
3370                 {
3371                   size = 2;
3372                   if (i.types[n] & (Imm8 | Imm8S))
3373                     size = 1;
3374                   if (i.types[n] & Imm64)
3375                     size = 8;
3376                 }
3377
3378               p = frag_more (size);
3379               reloc_type = reloc (size, 0, sign, i.reloc[n]);
3380 #ifdef BFD_ASSEMBLER
3381               /*   This is tough to explain.  We end up with this one if we
3382                * have operands that look like
3383                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
3384                * obtain the absolute address of the GOT, and it is strongly
3385                * preferable from a performance point of view to avoid using
3386                * a runtime relocation for this.  The actual sequence of
3387                * instructions often look something like:
3388                *
3389                *        call    .L66
3390                * .L66:
3391                *        popl    %ebx
3392                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
3393                *
3394                *   The call and pop essentially return the absolute address
3395                * of the label .L66 and store it in %ebx.  The linker itself
3396                * will ultimately change the first operand of the addl so
3397                * that %ebx points to the GOT, but to keep things simple, the
3398                * .o file must have this operand set so that it generates not
3399                * the absolute address of .L66, but the absolute address of
3400                * itself.  This allows the linker itself simply treat a GOTPC
3401                * relocation as asking for a pcrel offset to the GOT to be
3402                * added in, and the addend of the relocation is stored in the
3403                * operand field for the instruction itself.
3404                *
3405                *   Our job here is to fix the operand so that it would add
3406                * the correct offset so that %ebx would point to itself.  The
3407                * thing that is tricky is that .-.L66 will point to the
3408                * beginning of the instruction, so we need to further modify
3409                * the operand so that it will point to itself.  There are
3410                * other cases where you have something like:
3411                *
3412                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
3413                *
3414                * and here no correction would be required.  Internally in
3415                * the assembler we treat operands of this form as not being
3416                * pcrel since the '.' is explicitly mentioned, and I wonder
3417                * whether it would simplify matters to do it this way.  Who
3418                * knows.  In earlier versions of the PIC patches, the
3419                * pcrel_adjust field was used to store the correction, but
3420                * since the expression is not pcrel, I felt it would be
3421                * confusing to do it this way.  */
3422
3423               if (reloc_type == BFD_RELOC_32
3424                   && GOT_symbol
3425                   && GOT_symbol == i.op[n].imms->X_add_symbol
3426                   && (i.op[n].imms->X_op == O_symbol
3427                       || (i.op[n].imms->X_op == O_add
3428                           && ((symbol_get_value_expression
3429                                (i.op[n].imms->X_op_symbol)->X_op)
3430                               == O_subtract))))
3431                 {
3432                   offsetT add;
3433
3434                   if (insn_start_frag == frag_now)
3435                     add = (p - frag_now->fr_literal) - insn_start_off;
3436                   else
3437                     {
3438                       fragS *fr;
3439
3440                       add = insn_start_frag->fr_fix - insn_start_off;
3441                       for (fr = insn_start_frag->fr_next;
3442                            fr && fr != frag_now; fr = fr->fr_next)
3443                         add += fr->fr_fix;
3444                       add += p - frag_now->fr_literal;
3445                     }
3446
3447                   /* We don't support dynamic linking on x86-64 yet.  */
3448                   if (flag_code == CODE_64BIT)
3449                     abort ();
3450                   reloc_type = BFD_RELOC_386_GOTPC;
3451                   i.op[n].imms->X_add_number += add;
3452                 }
3453 #endif
3454               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3455                            i.op[n].imms, 0, reloc_type);
3456             }
3457         }
3458     }
3459 }
3460 \f
3461 #ifndef LEX_AT
3462 static char *lex_got PARAMS ((RELOC_ENUM *, int *));
3463
3464 /* Parse operands of the form
3465    <symbol>@GOTOFF+<nnn>
3466    and similar .plt or .got references.
3467
3468    If we find one, set up the correct relocation in RELOC and copy the
3469    input string, minus the `@GOTOFF' into a malloc'd buffer for
3470    parsing by the calling routine.  Return this buffer, and if ADJUST
3471    is non-null set it to the length of the string we removed from the
3472    input line.  Otherwise return NULL.  */
3473 static char *
3474 lex_got (reloc, adjust)
3475      RELOC_ENUM *reloc;
3476      int *adjust;
3477 {
3478   static const char * const mode_name[NUM_FLAG_CODE] = { "32", "16", "64" };
3479   static const struct {
3480     const char *str;
3481     const RELOC_ENUM rel[NUM_FLAG_CODE];
3482   } gotrel[] = {
3483     { "PLT",      { BFD_RELOC_386_PLT32,      0, BFD_RELOC_X86_64_PLT32    } },
3484     { "GOTOFF",   { BFD_RELOC_386_GOTOFF,     0, 0                         } },
3485     { "GOTPCREL", { 0,                        0, BFD_RELOC_X86_64_GOTPCREL } },
3486     { "TLSGD",    { BFD_RELOC_386_TLS_GD,     0, 0                         } },
3487     { "TLSLDM",   { BFD_RELOC_386_TLS_LDM,    0, 0                         } },
3488     { "GOTTPOFF", { BFD_RELOC_386_TLS_IE_32,  0, 0                         } },
3489     { "TPOFF",    { BFD_RELOC_386_TLS_LE_32,  0, 0                         } },
3490     { "NTPOFF",   { BFD_RELOC_386_TLS_LE,     0, 0                         } },
3491     { "DTPOFF",   { BFD_RELOC_386_TLS_LDO_32, 0, 0                         } },
3492     { "GOTNTPOFF",{ BFD_RELOC_386_TLS_GOTIE,  0, 0                         } },
3493     { "INDNTPOFF",{ BFD_RELOC_386_TLS_IE,     0, 0                         } },
3494     { "GOT",      { BFD_RELOC_386_GOT32,      0, BFD_RELOC_X86_64_GOT32    } }
3495   };
3496   char *cp;
3497   unsigned int j;
3498
3499   for (cp = input_line_pointer; *cp != '@'; cp++)
3500     if (is_end_of_line[(unsigned char) *cp])
3501       return NULL;
3502
3503   for (j = 0; j < sizeof (gotrel) / sizeof (gotrel[0]); j++)
3504     {
3505       int len;
3506
3507       len = strlen (gotrel[j].str);
3508       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
3509         {
3510           if (gotrel[j].rel[(unsigned int) flag_code] != 0)
3511             {
3512               int first, second;
3513               char *tmpbuf, *past_reloc;
3514
3515               *reloc = gotrel[j].rel[(unsigned int) flag_code];
3516               if (adjust)
3517                 *adjust = len;
3518
3519               if (GOT_symbol == NULL)
3520                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
3521
3522               /* Replace the relocation token with ' ', so that
3523                  errors like foo@GOTOFF1 will be detected.  */
3524
3525               /* The length of the first part of our input line.  */
3526               first = cp - input_line_pointer;
3527
3528               /* The second part goes from after the reloc token until
3529                  (and including) an end_of_line char.  Don't use strlen
3530                  here as the end_of_line char may not be a NUL.  */
3531               past_reloc = cp + 1 + len;
3532               for (cp = past_reloc; !is_end_of_line[(unsigned char) *cp++]; )
3533                 ;
3534               second = cp - past_reloc;
3535
3536               /* Allocate and copy string.  The trailing NUL shouldn't
3537                  be necessary, but be safe.  */
3538               tmpbuf = xmalloc (first + second + 2);
3539               memcpy (tmpbuf, input_line_pointer, first);
3540               tmpbuf[first] = ' ';
3541               memcpy (tmpbuf + first + 1, past_reloc, second);
3542               tmpbuf[first + second + 1] = '\0';
3543               return tmpbuf;
3544             }
3545
3546           as_bad (_("@%s reloc is not supported in %s bit mode"),
3547                   gotrel[j].str, mode_name[(unsigned int) flag_code]);
3548           return NULL;
3549         }
3550     }
3551
3552   /* Might be a symbol version string.  Don't as_bad here.  */
3553   return NULL;
3554 }
3555
3556 /* x86_cons_fix_new is called via the expression parsing code when a
3557    reloc is needed.  We use this hook to get the correct .got reloc.  */
3558 static RELOC_ENUM got_reloc = NO_RELOC;
3559
3560 void
3561 x86_cons_fix_new (frag, off, len, exp)
3562      fragS *frag;
3563      unsigned int off;
3564      unsigned int len;
3565      expressionS *exp;
3566 {
3567   RELOC_ENUM r = reloc (len, 0, 0, got_reloc);
3568   got_reloc = NO_RELOC;
3569   fix_new_exp (frag, off, len, exp, 0, r);
3570 }
3571
3572 void
3573 x86_cons (exp, size)
3574      expressionS *exp;
3575      int size;
3576 {
3577   if (size == 4)
3578     {
3579       /* Handle @GOTOFF and the like in an expression.  */
3580       char *save;
3581       char *gotfree_input_line;
3582       int adjust;
3583
3584       save = input_line_pointer;
3585       gotfree_input_line = lex_got (&got_reloc, &adjust);
3586       if (gotfree_input_line)
3587         input_line_pointer = gotfree_input_line;
3588
3589       expression (exp);
3590
3591       if (gotfree_input_line)
3592         {
3593           /* expression () has merrily parsed up to the end of line,
3594              or a comma - in the wrong buffer.  Transfer how far
3595              input_line_pointer has moved to the right buffer.  */
3596           input_line_pointer = (save
3597                                 + (input_line_pointer - gotfree_input_line)
3598                                 + adjust);
3599           free (gotfree_input_line);
3600         }
3601     }
3602   else
3603     expression (exp);
3604 }
3605 #endif
3606
3607 static int i386_immediate PARAMS ((char *));
3608
3609 static int
3610 i386_immediate (imm_start)
3611      char *imm_start;
3612 {
3613   char *save_input_line_pointer;
3614 #ifndef LEX_AT
3615   char *gotfree_input_line;
3616 #endif
3617   segT exp_seg = 0;
3618   expressionS *exp;
3619
3620   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
3621     {
3622       as_bad (_("only 1 or 2 immediate operands are allowed"));
3623       return 0;
3624     }
3625
3626   exp = &im_expressions[i.imm_operands++];
3627   i.op[this_operand].imms = exp;
3628
3629   if (is_space_char (*imm_start))
3630     ++imm_start;
3631
3632   save_input_line_pointer = input_line_pointer;
3633   input_line_pointer = imm_start;
3634
3635 #ifndef LEX_AT
3636   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL);
3637   if (gotfree_input_line)
3638     input_line_pointer = gotfree_input_line;
3639 #endif
3640
3641   exp_seg = expression (exp);
3642
3643   SKIP_WHITESPACE ();
3644   if (*input_line_pointer)
3645     as_bad (_("junk `%s' after expression"), input_line_pointer);
3646
3647   input_line_pointer = save_input_line_pointer;
3648 #ifndef LEX_AT
3649   if (gotfree_input_line)
3650     free (gotfree_input_line);
3651 #endif
3652
3653   if (exp->X_op == O_absent || exp->X_op == O_big)
3654     {
3655       /* Missing or bad expr becomes absolute 0.  */
3656       as_bad (_("missing or invalid immediate expression `%s' taken as 0"),
3657               imm_start);
3658       exp->X_op = O_constant;
3659       exp->X_add_number = 0;
3660       exp->X_add_symbol = (symbolS *) 0;
3661       exp->X_op_symbol = (symbolS *) 0;
3662     }
3663   else if (exp->X_op == O_constant)
3664     {
3665       /* Size it properly later.  */
3666       i.types[this_operand] |= Imm64;
3667       /* If BFD64, sign extend val.  */
3668       if (!use_rela_relocations)
3669         if ((exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
3670           exp->X_add_number = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
3671     }
3672 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
3673   else if (1
3674 #ifdef BFD_ASSEMBLER
3675            && OUTPUT_FLAVOR == bfd_target_aout_flavour
3676 #endif
3677            && exp_seg != absolute_section
3678            && exp_seg != text_section
3679            && exp_seg != data_section
3680            && exp_seg != bss_section
3681            && exp_seg != undefined_section
3682 #ifdef BFD_ASSEMBLER
3683            && !bfd_is_com_section (exp_seg)
3684 #endif
3685            )
3686     {
3687 #ifdef BFD_ASSEMBLER
3688       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
3689 #else
3690       as_bad (_("unimplemented segment type %d in operand"), exp_seg);
3691 #endif
3692       return 0;
3693     }
3694 #endif
3695   else
3696     {
3697       /* This is an address.  The size of the address will be
3698          determined later, depending on destination register,
3699          suffix, or the default for the section.  */
3700       i.types[this_operand] |= Imm8 | Imm16 | Imm32 | Imm32S | Imm64;
3701     }
3702
3703   return 1;
3704 }
3705
3706 static char *i386_scale PARAMS ((char *));
3707
3708 static char *
3709 i386_scale (scale)
3710      char *scale;
3711 {
3712   offsetT val;
3713   char *save = input_line_pointer;
3714
3715   input_line_pointer = scale;
3716   val = get_absolute_expression ();
3717
3718   switch (val)
3719     {
3720     case 0:
3721     case 1:
3722       i.log2_scale_factor = 0;
3723       break;
3724     case 2:
3725       i.log2_scale_factor = 1;
3726       break;
3727     case 4:
3728       i.log2_scale_factor = 2;
3729       break;
3730     case 8:
3731       i.log2_scale_factor = 3;
3732       break;
3733     default:
3734       as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
3735               scale);
3736       input_line_pointer = save;
3737       return NULL;
3738     }
3739   if (i.log2_scale_factor != 0 && i.index_reg == 0)
3740     {
3741       as_warn (_("scale factor of %d without an index register"),
3742                1 << i.log2_scale_factor);
3743 #if SCALE1_WHEN_NO_INDEX
3744       i.log2_scale_factor = 0;
3745 #endif
3746     }
3747   scale = input_line_pointer;
3748   input_line_pointer = save;
3749   return scale;
3750 }
3751
3752 static int i386_displacement PARAMS ((char *, char *));
3753
3754 static int
3755 i386_displacement (disp_start, disp_end)
3756      char *disp_start;
3757      char *disp_end;
3758 {
3759   expressionS *exp;
3760   segT exp_seg = 0;
3761   char *save_input_line_pointer;
3762 #ifndef LEX_AT
3763   char *gotfree_input_line;
3764 #endif
3765   int bigdisp = Disp32;
3766
3767   if (flag_code == CODE_64BIT)
3768     {
3769       if (i.prefix[ADDR_PREFIX] == 0)
3770         bigdisp = Disp64;
3771     }
3772   else if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0))
3773     bigdisp = Disp16;
3774   i.types[this_operand] |= bigdisp;
3775
3776   exp = &disp_expressions[i.disp_operands];
3777   i.op[this_operand].disps = exp;
3778   i.disp_operands++;
3779   save_input_line_pointer = input_line_pointer;
3780   input_line_pointer = disp_start;
3781   END_STRING_AND_SAVE (disp_end);
3782
3783 #ifndef GCC_ASM_O_HACK
3784 #define GCC_ASM_O_HACK 0
3785 #endif
3786 #if GCC_ASM_O_HACK
3787   END_STRING_AND_SAVE (disp_end + 1);
3788   if ((i.types[this_operand] & BaseIndex) != 0
3789       && displacement_string_end[-1] == '+')
3790     {
3791       /* This hack is to avoid a warning when using the "o"
3792          constraint within gcc asm statements.
3793          For instance:
3794
3795          #define _set_tssldt_desc(n,addr,limit,type) \
3796          __asm__ __volatile__ ( \
3797          "movw %w2,%0\n\t" \
3798          "movw %w1,2+%0\n\t" \
3799          "rorl $16,%1\n\t" \
3800          "movb %b1,4+%0\n\t" \
3801          "movb %4,5+%0\n\t" \
3802          "movb $0,6+%0\n\t" \
3803          "movb %h1,7+%0\n\t" \
3804          "rorl $16,%1" \
3805          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
3806
3807          This works great except that the output assembler ends
3808          up looking a bit weird if it turns out that there is
3809          no offset.  You end up producing code that looks like:
3810
3811          #APP
3812          movw $235,(%eax)
3813          movw %dx,2+(%eax)
3814          rorl $16,%edx
3815          movb %dl,4+(%eax)
3816          movb $137,5+(%eax)
3817          movb $0,6+(%eax)
3818          movb %dh,7+(%eax)
3819          rorl $16,%edx
3820          #NO_APP
3821
3822          So here we provide the missing zero.  */
3823
3824       *displacement_string_end = '0';
3825     }
3826 #endif
3827 #ifndef LEX_AT
3828   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL);
3829   if (gotfree_input_line)
3830     input_line_pointer = gotfree_input_line;
3831 #endif
3832
3833   exp_seg = expression (exp);
3834
3835   SKIP_WHITESPACE ();
3836   if (*input_line_pointer)
3837     as_bad (_("junk `%s' after expression"), input_line_pointer);
3838 #if GCC_ASM_O_HACK
3839   RESTORE_END_STRING (disp_end + 1);
3840 #endif
3841   RESTORE_END_STRING (disp_end);
3842   input_line_pointer = save_input_line_pointer;
3843 #ifndef LEX_AT
3844   if (gotfree_input_line)
3845     free (gotfree_input_line);
3846 #endif
3847
3848 #ifdef BFD_ASSEMBLER
3849   /* We do this to make sure that the section symbol is in
3850      the symbol table.  We will ultimately change the relocation
3851      to be relative to the beginning of the section.  */
3852   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
3853       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
3854     {
3855       if (exp->X_op != O_symbol)
3856         {
3857           as_bad (_("bad expression used with @%s"),
3858                   (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
3859                    ? "GOTPCREL"
3860                    : "GOTOFF"));
3861           return 0;
3862         }
3863
3864       if (S_IS_LOCAL (exp->X_add_symbol)
3865           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section)
3866         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
3867       exp->X_op = O_subtract;
3868       exp->X_op_symbol = GOT_symbol;
3869       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
3870         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
3871       else
3872         i.reloc[this_operand] = BFD_RELOC_32;
3873     }
3874 #endif
3875
3876   if (exp->X_op == O_absent || exp->X_op == O_big)
3877     {
3878       /* Missing or bad expr becomes absolute 0.  */
3879       as_bad (_("missing or invalid displacement expression `%s' taken as 0"),
3880               disp_start);
3881       exp->X_op = O_constant;
3882       exp->X_add_number = 0;
3883       exp->X_add_symbol = (symbolS *) 0;
3884       exp->X_op_symbol = (symbolS *) 0;
3885     }
3886
3887 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
3888   if (exp->X_op != O_constant
3889 #ifdef BFD_ASSEMBLER
3890       && OUTPUT_FLAVOR == bfd_target_aout_flavour
3891 #endif
3892       && exp_seg != absolute_section
3893       && exp_seg != text_section
3894       && exp_seg != data_section
3895       && exp_seg != bss_section
3896       && exp_seg != undefined_section
3897 #ifdef BFD_ASSEMBLER
3898       && !bfd_is_com_section (exp_seg)
3899 #endif
3900       )
3901     {
3902 #ifdef BFD_ASSEMBLER
3903       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
3904 #else
3905       as_bad (_("unimplemented segment type %d in operand"), exp_seg);
3906 #endif
3907       return 0;
3908     }
3909 #endif
3910   else if (flag_code == CODE_64BIT)
3911     i.types[this_operand] |= Disp32S | Disp32;
3912   return 1;
3913 }
3914
3915 static int i386_index_check PARAMS ((const char *));
3916
3917 /* Make sure the memory operand we've been dealt is valid.
3918    Return 1 on success, 0 on a failure.  */
3919
3920 static int
3921 i386_index_check (operand_string)
3922      const char *operand_string;
3923 {
3924   int ok;
3925 #if INFER_ADDR_PREFIX
3926   int fudged = 0;
3927
3928  tryprefix:
3929 #endif
3930   ok = 1;
3931   if (flag_code == CODE_64BIT)
3932     {
3933       if (i.prefix[ADDR_PREFIX] == 0)
3934         {
3935           /* 64bit checks.  */
3936           if ((i.base_reg
3937                && ((i.base_reg->reg_type & Reg64) == 0)
3938                    && (i.base_reg->reg_type != BaseIndex
3939                        || i.index_reg))
3940               || (i.index_reg
3941                   && ((i.index_reg->reg_type & (Reg64 | BaseIndex))
3942                       != (Reg64 | BaseIndex))))
3943             ok = 0;
3944         }
3945       else
3946         {
3947           /* 32bit checks.  */
3948           if ((i.base_reg
3949                && (i.base_reg->reg_type & (Reg32 | RegRex)) != Reg32)
3950               || (i.index_reg
3951                   && ((i.index_reg->reg_type & (Reg32 | BaseIndex | RegRex))
3952                       != (Reg32 | BaseIndex))))
3953             ok = 0;
3954         }
3955     }
3956   else
3957     {
3958       if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0))
3959         {
3960           /* 16bit checks.  */
3961           if ((i.base_reg
3962                && ((i.base_reg->reg_type & (Reg16 | BaseIndex | RegRex))
3963                    != (Reg16 | BaseIndex)))
3964               || (i.index_reg
3965                   && (((i.index_reg->reg_type & (Reg16 | BaseIndex))
3966                        != (Reg16 | BaseIndex))
3967                       || !(i.base_reg
3968                            && i.base_reg->reg_num < 6
3969                            && i.index_reg->reg_num >= 6
3970                            && i.log2_scale_factor == 0))))
3971             ok = 0;
3972         }
3973       else
3974         {
3975           /* 32bit checks.  */
3976           if ((i.base_reg
3977                && (i.base_reg->reg_type & (Reg32 | RegRex)) != Reg32)
3978               || (i.index_reg
3979                   && ((i.index_reg->reg_type & (Reg32 | BaseIndex | RegRex))
3980                       != (Reg32 | BaseIndex))))
3981             ok = 0;
3982         }
3983     }
3984   if (!ok)
3985     {
3986 #if INFER_ADDR_PREFIX
3987       if (flag_code != CODE_64BIT
3988           && i.prefix[ADDR_PREFIX] == 0 && stackop_size != '\0')
3989         {
3990           i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
3991           i.prefixes += 1;
3992           /* Change the size of any displacement too.  At most one of
3993              Disp16 or Disp32 is set.
3994              FIXME.  There doesn't seem to be any real need for separate
3995              Disp16 and Disp32 flags.  The same goes for Imm16 and Imm32.
3996              Removing them would probably clean up the code quite a lot.  */
3997           if (i.types[this_operand] & (Disp16 | Disp32))
3998              i.types[this_operand] ^= (Disp16 | Disp32);
3999           fudged = 1;
4000           goto tryprefix;
4001         }
4002       if (fudged)
4003         as_bad (_("`%s' is not a valid base/index expression"),
4004                 operand_string);
4005       else
4006 #endif
4007         as_bad (_("`%s' is not a valid %s bit base/index expression"),
4008                 operand_string,
4009                 flag_code_names[flag_code]);
4010       return 0;
4011     }
4012   return 1;
4013 }
4014
4015 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns non-zero
4016    on error.  */
4017
4018 static int
4019 i386_operand (operand_string)
4020      char *operand_string;
4021 {
4022   const reg_entry *r;
4023   char *end_op;
4024   char *op_string = operand_string;
4025
4026   if (is_space_char (*op_string))
4027     ++op_string;
4028
4029   /* We check for an absolute prefix (differentiating,
4030      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
4031   if (*op_string == ABSOLUTE_PREFIX)
4032     {
4033       ++op_string;
4034       if (is_space_char (*op_string))
4035         ++op_string;
4036       i.types[this_operand] |= JumpAbsolute;
4037     }
4038
4039   /* Check if operand is a register.  */
4040   if ((*op_string == REGISTER_PREFIX || allow_naked_reg)
4041       && (r = parse_register (op_string, &end_op)) != NULL)
4042     {
4043       /* Check for a segment override by searching for ':' after a
4044          segment register.  */
4045       op_string = end_op;
4046       if (is_space_char (*op_string))
4047         ++op_string;
4048       if (*op_string == ':' && (r->reg_type & (SReg2 | SReg3)))
4049         {
4050           switch (r->reg_num)
4051             {
4052             case 0:
4053               i.seg[i.mem_operands] = &es;
4054               break;
4055             case 1:
4056               i.seg[i.mem_operands] = &cs;
4057               break;
4058             case 2:
4059               i.seg[i.mem_operands] = &ss;
4060               break;
4061             case 3:
4062               i.seg[i.mem_operands] = &ds;
4063               break;
4064             case 4:
4065               i.seg[i.mem_operands] = &fs;
4066               break;
4067             case 5:
4068               i.seg[i.mem_operands] = &gs;
4069               break;
4070             }
4071
4072           /* Skip the ':' and whitespace.  */
4073           ++op_string;
4074           if (is_space_char (*op_string))
4075             ++op_string;
4076
4077           if (!is_digit_char (*op_string)
4078               && !is_identifier_char (*op_string)
4079               && *op_string != '('
4080               && *op_string != ABSOLUTE_PREFIX)
4081             {
4082               as_bad (_("bad memory operand `%s'"), op_string);
4083               return 0;
4084             }
4085           /* Handle case of %es:*foo.  */
4086           if (*op_string == ABSOLUTE_PREFIX)
4087             {
4088               ++op_string;
4089               if (is_space_char (*op_string))
4090                 ++op_string;
4091               i.types[this_operand] |= JumpAbsolute;
4092             }
4093           goto do_memory_reference;
4094         }
4095       if (*op_string)
4096         {
4097           as_bad (_("junk `%s' after register"), op_string);
4098           return 0;
4099         }
4100       i.types[this_operand] |= r->reg_type & ~BaseIndex;
4101       i.op[this_operand].regs = r;
4102       i.reg_operands++;
4103     }
4104   else if (*op_string == REGISTER_PREFIX)
4105     {
4106       as_bad (_("bad register name `%s'"), op_string);
4107       return 0;
4108     }
4109   else if (*op_string == IMMEDIATE_PREFIX)
4110     {
4111       ++op_string;
4112       if (i.types[this_operand] & JumpAbsolute)
4113         {
4114           as_bad (_("immediate operand illegal with absolute jump"));
4115           return 0;
4116         }
4117       if (!i386_immediate (op_string))
4118         return 0;
4119     }
4120   else if (is_digit_char (*op_string)
4121            || is_identifier_char (*op_string)
4122            || *op_string == '(')
4123     {
4124       /* This is a memory reference of some sort.  */
4125       char *base_string;
4126
4127       /* Start and end of displacement string expression (if found).  */
4128       char *displacement_string_start;
4129       char *displacement_string_end;
4130
4131     do_memory_reference:
4132       if ((i.mem_operands == 1
4133            && (current_templates->start->opcode_modifier & IsString) == 0)
4134           || i.mem_operands == 2)
4135         {
4136           as_bad (_("too many memory references for `%s'"),
4137                   current_templates->start->name);
4138           return 0;
4139         }
4140
4141       /* Check for base index form.  We detect the base index form by
4142          looking for an ')' at the end of the operand, searching
4143          for the '(' matching it, and finding a REGISTER_PREFIX or ','
4144          after the '('.  */
4145       base_string = op_string + strlen (op_string);
4146
4147       --base_string;
4148       if (is_space_char (*base_string))
4149         --base_string;
4150
4151       /* If we only have a displacement, set-up for it to be parsed later.  */
4152       displacement_string_start = op_string;
4153       displacement_string_end = base_string + 1;
4154
4155       if (*base_string == ')')
4156         {
4157           char *temp_string;
4158           unsigned int parens_balanced = 1;
4159           /* We've already checked that the number of left & right ()'s are
4160              equal, so this loop will not be infinite.  */
4161           do
4162             {
4163               base_string--;
4164               if (*base_string == ')')
4165                 parens_balanced++;
4166               if (*base_string == '(')
4167                 parens_balanced--;
4168             }
4169           while (parens_balanced);
4170
4171           temp_string = base_string;
4172
4173           /* Skip past '(' and whitespace.  */
4174           ++base_string;
4175           if (is_space_char (*base_string))
4176             ++base_string;
4177
4178           if (*base_string == ','
4179               || ((*base_string == REGISTER_PREFIX || allow_naked_reg)
4180                   && (i.base_reg = parse_register (base_string, &end_op)) != NULL))
4181             {
4182               displacement_string_end = temp_string;
4183
4184               i.types[this_operand] |= BaseIndex;
4185
4186               if (i.base_reg)
4187                 {
4188                   base_string = end_op;
4189                   if (is_space_char (*base_string))
4190                     ++base_string;
4191                 }
4192
4193               /* There may be an index reg or scale factor here.  */
4194               if (*base_string == ',')
4195                 {
4196                   ++base_string;
4197                   if (is_space_char (*base_string))
4198                     ++base_string;
4199
4200                   if ((*base_string == REGISTER_PREFIX || allow_naked_reg)
4201                       && (i.index_reg = parse_register (base_string, &end_op)) != NULL)
4202                     {
4203                       base_string = end_op;
4204                       if (is_space_char (*base_string))
4205                         ++base_string;
4206                       if (*base_string == ',')
4207                         {
4208                           ++base_string;
4209                           if (is_space_char (*base_string))
4210                             ++base_string;
4211                         }
4212                       else if (*base_string != ')')
4213                         {
4214                           as_bad (_("expecting `,' or `)' after index register in `%s'"),
4215                                   operand_string);
4216                           return 0;
4217                         }
4218                     }
4219                   else if (*base_string == REGISTER_PREFIX)
4220                     {
4221                       as_bad (_("bad register name `%s'"), base_string);
4222                       return 0;
4223                     }
4224
4225                   /* Check for scale factor.  */
4226                   if (*base_string != ')')
4227                     {
4228                       char *end_scale = i386_scale (base_string);
4229
4230                       if (!end_scale)
4231                         return 0;
4232
4233                       base_string = end_scale;
4234                       if (is_space_char (*base_string))
4235                         ++base_string;
4236                       if (*base_string != ')')
4237                         {
4238                           as_bad (_("expecting `)' after scale factor in `%s'"),
4239                                   operand_string);
4240                           return 0;
4241                         }
4242                     }
4243                   else if (!i.index_reg)
4244                     {
4245                       as_bad (_("expecting index register or scale factor after `,'; got '%c'"),
4246                               *base_string);
4247                       return 0;
4248                     }
4249                 }
4250               else if (*base_string != ')')
4251                 {
4252                   as_bad (_("expecting `,' or `)' after base register in `%s'"),
4253                           operand_string);
4254                   return 0;
4255                 }
4256             }
4257           else if (*base_string == REGISTER_PREFIX)
4258             {
4259               as_bad (_("bad register name `%s'"), base_string);
4260               return 0;
4261             }
4262         }
4263
4264       /* If there's an expression beginning the operand, parse it,
4265          assuming displacement_string_start and
4266          displacement_string_end are meaningful.  */
4267       if (displacement_string_start != displacement_string_end)
4268         {
4269           if (!i386_displacement (displacement_string_start,
4270                                   displacement_string_end))
4271             return 0;
4272         }
4273
4274       /* Special case for (%dx) while doing input/output op.  */
4275       if (i.base_reg
4276           && i.base_reg->reg_type == (Reg16 | InOutPortReg)
4277           && i.index_reg == 0
4278           && i.log2_scale_factor == 0
4279           && i.seg[i.mem_operands] == 0
4280           && (i.types[this_operand] & Disp) == 0)
4281         {
4282           i.types[this_operand] = InOutPortReg;
4283           return 1;
4284         }
4285
4286       if (i386_index_check (operand_string) == 0)
4287         return 0;
4288       i.mem_operands++;
4289     }
4290   else
4291     {
4292       /* It's not a memory operand; argh!  */
4293       as_bad (_("invalid char %s beginning operand %d `%s'"),
4294               output_invalid (*op_string),
4295               this_operand + 1,
4296               op_string);
4297       return 0;
4298     }
4299   return 1;                     /* Normal return.  */
4300 }
4301 \f
4302 /* md_estimate_size_before_relax()
4303
4304    Called just before relax() for rs_machine_dependent frags.  The x86
4305    assembler uses these frags to handle variable size jump
4306    instructions.
4307
4308    Any symbol that is now undefined will not become defined.
4309    Return the correct fr_subtype in the frag.
4310    Return the initial "guess for variable size of frag" to caller.
4311    The guess is actually the growth beyond the fixed part.  Whatever
4312    we do to grow the fixed or variable part contributes to our
4313    returned value.  */
4314
4315 int
4316 md_estimate_size_before_relax (fragP, segment)
4317      fragS *fragP;
4318      segT segment;
4319 {
4320   /* We've already got fragP->fr_subtype right;  all we have to do is
4321      check for un-relaxable symbols.  On an ELF system, we can't relax
4322      an externally visible symbol, because it may be overridden by a
4323      shared library.  */
4324   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
4325 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4326       || (OUTPUT_FLAVOR == bfd_target_elf_flavour
4327           && (S_IS_EXTERNAL (fragP->fr_symbol)
4328               || S_IS_WEAK (fragP->fr_symbol)))
4329 #endif
4330       )
4331     {
4332       /* Symbol is undefined in this segment, or we need to keep a
4333          reloc so that weak symbols can be overridden.  */
4334       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
4335       RELOC_ENUM reloc_type;
4336       unsigned char *opcode;
4337       int old_fr_fix;
4338
4339       if (fragP->fr_var != NO_RELOC)
4340         reloc_type = fragP->fr_var;
4341       else if (size == 2)
4342         reloc_type = BFD_RELOC_16_PCREL;
4343       else
4344         reloc_type = BFD_RELOC_32_PCREL;
4345
4346       old_fr_fix = fragP->fr_fix;
4347       opcode = (unsigned char *) fragP->fr_opcode;
4348
4349       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
4350         {
4351         case UNCOND_JUMP:
4352           /* Make jmp (0xeb) a (d)word displacement jump.  */
4353           opcode[0] = 0xe9;
4354           fragP->fr_fix += size;
4355           fix_new (fragP, old_fr_fix, size,
4356                    fragP->fr_symbol,
4357                    fragP->fr_offset, 1,
4358                    reloc_type);
4359           break;
4360
4361         case COND_JUMP86:
4362           if (size == 2
4363               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
4364             {
4365               /* Negate the condition, and branch past an
4366                  unconditional jump.  */
4367               opcode[0] ^= 1;
4368               opcode[1] = 3;
4369               /* Insert an unconditional jump.  */
4370               opcode[2] = 0xe9;
4371               /* We added two extra opcode bytes, and have a two byte
4372                  offset.  */
4373               fragP->fr_fix += 2 + 2;
4374               fix_new (fragP, old_fr_fix + 2, 2,
4375                        fragP->fr_symbol,
4376                        fragP->fr_offset, 1,
4377                        reloc_type);
4378               break;
4379             }
4380           /* Fall through.  */
4381
4382         case COND_JUMP:
4383           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
4384             {
4385               fragP->fr_fix += 1;
4386               fix_new (fragP, old_fr_fix, 1,
4387                        fragP->fr_symbol,
4388                        fragP->fr_offset, 1,
4389                        BFD_RELOC_8_PCREL);
4390               break;
4391             }
4392
4393           /* This changes the byte-displacement jump 0x7N
4394              to the (d)word-displacement jump 0x0f,0x8N.  */
4395           opcode[1] = opcode[0] + 0x10;
4396           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
4397           /* We've added an opcode byte.  */
4398           fragP->fr_fix += 1 + size;
4399           fix_new (fragP, old_fr_fix + 1, size,
4400                    fragP->fr_symbol,
4401                    fragP->fr_offset, 1,
4402                    reloc_type);
4403           break;
4404
4405         default:
4406           BAD_CASE (fragP->fr_subtype);
4407           break;
4408         }
4409       frag_wane (fragP);
4410       return fragP->fr_fix - old_fr_fix;
4411     }
4412
4413   /* Guess size depending on current relax state.  Initially the relax
4414      state will correspond to a short jump and we return 1, because
4415      the variable part of the frag (the branch offset) is one byte
4416      long.  However, we can relax a section more than once and in that
4417      case we must either set fr_subtype back to the unrelaxed state,
4418      or return the value for the appropriate branch.  */
4419   return md_relax_table[fragP->fr_subtype].rlx_length;
4420 }
4421
4422 /* Called after relax() is finished.
4423
4424    In:  Address of frag.
4425         fr_type == rs_machine_dependent.
4426         fr_subtype is what the address relaxed to.
4427
4428    Out: Any fixSs and constants are set up.
4429         Caller will turn frag into a ".space 0".  */
4430
4431 #ifndef BFD_ASSEMBLER
4432 void
4433 md_convert_frag (headers, sec, fragP)
4434      object_headers *headers ATTRIBUTE_UNUSED;
4435      segT sec ATTRIBUTE_UNUSED;
4436      fragS *fragP;
4437 #else
4438 void
4439 md_convert_frag (abfd, sec, fragP)
4440      bfd *abfd ATTRIBUTE_UNUSED;
4441      segT sec ATTRIBUTE_UNUSED;
4442      fragS *fragP;
4443 #endif
4444 {
4445   unsigned char *opcode;
4446   unsigned char *where_to_put_displacement = NULL;
4447   offsetT target_address;
4448   offsetT opcode_address;
4449   unsigned int extension = 0;
4450   offsetT displacement_from_opcode_start;
4451
4452   opcode = (unsigned char *) fragP->fr_opcode;
4453
4454   /* Address we want to reach in file space.  */
4455   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
4456
4457   /* Address opcode resides at in file space.  */
4458   opcode_address = fragP->fr_address + fragP->fr_fix;
4459
4460   /* Displacement from opcode start to fill into instruction.  */
4461   displacement_from_opcode_start = target_address - opcode_address;
4462
4463   if ((fragP->fr_subtype & BIG) == 0)
4464     {
4465       /* Don't have to change opcode.  */
4466       extension = 1;            /* 1 opcode + 1 displacement  */
4467       where_to_put_displacement = &opcode[1];
4468     }
4469   else
4470     {
4471       if (no_cond_jump_promotion
4472           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
4473         as_warn_where (fragP->fr_file, fragP->fr_line, _("long jump required"));
4474
4475       switch (fragP->fr_subtype)
4476         {
4477         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
4478           extension = 4;                /* 1 opcode + 4 displacement  */
4479           opcode[0] = 0xe9;
4480           where_to_put_displacement = &opcode[1];
4481           break;
4482
4483         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
4484           extension = 2;                /* 1 opcode + 2 displacement  */
4485           opcode[0] = 0xe9;
4486           where_to_put_displacement = &opcode[1];
4487           break;
4488
4489         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
4490         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
4491           extension = 5;                /* 2 opcode + 4 displacement  */
4492           opcode[1] = opcode[0] + 0x10;
4493           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
4494           where_to_put_displacement = &opcode[2];
4495           break;
4496
4497         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
4498           extension = 3;                /* 2 opcode + 2 displacement  */
4499           opcode[1] = opcode[0] + 0x10;
4500           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
4501           where_to_put_displacement = &opcode[2];
4502           break;
4503
4504         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
4505           extension = 4;
4506           opcode[0] ^= 1;
4507           opcode[1] = 3;
4508           opcode[2] = 0xe9;
4509           where_to_put_displacement = &opcode[3];
4510           break;
4511
4512         default:
4513           BAD_CASE (fragP->fr_subtype);
4514           break;
4515         }
4516     }
4517
4518   /* Now put displacement after opcode.  */
4519   md_number_to_chars ((char *) where_to_put_displacement,
4520                       (valueT) (displacement_from_opcode_start - extension),
4521                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
4522   fragP->fr_fix += extension;
4523 }
4524 \f
4525 /* Size of byte displacement jmp.  */
4526 int md_short_jump_size = 2;
4527
4528 /* Size of dword displacement jmp.  */
4529 int md_long_jump_size = 5;
4530
4531 /* Size of relocation record.  */
4532 const int md_reloc_size = 8;
4533
4534 void
4535 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
4536      char *ptr;
4537      addressT from_addr, to_addr;
4538      fragS *frag ATTRIBUTE_UNUSED;
4539      symbolS *to_symbol ATTRIBUTE_UNUSED;
4540 {
4541   offsetT offset;
4542
4543   offset = to_addr - (from_addr + 2);
4544   /* Opcode for byte-disp jump.  */
4545   md_number_to_chars (ptr, (valueT) 0xeb, 1);
4546   md_number_to_chars (ptr + 1, (valueT) offset, 1);
4547 }
4548
4549 void
4550 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
4551      char *ptr;
4552      addressT from_addr, to_addr;
4553      fragS *frag ATTRIBUTE_UNUSED;
4554      symbolS *to_symbol ATTRIBUTE_UNUSED;
4555 {
4556   offsetT offset;
4557
4558   offset = to_addr - (from_addr + 5);
4559   md_number_to_chars (ptr, (valueT) 0xe9, 1);
4560   md_number_to_chars (ptr + 1, (valueT) offset, 4);
4561 }
4562 \f
4563 /* Apply a fixup (fixS) to segment data, once it has been determined
4564    by our caller that we have all the info we need to fix it up.
4565
4566    On the 386, immediates, displacements, and data pointers are all in
4567    the same (little-endian) format, so we don't need to care about which
4568    we are handling.  */
4569
4570 void
4571 md_apply_fix3 (fixP, valP, seg)
4572      /* The fix we're to put in.  */
4573      fixS *fixP;
4574      /* Pointer to the value of the bits.  */
4575      valueT *valP;
4576      /* Segment fix is from.  */
4577      segT seg ATTRIBUTE_UNUSED;
4578 {
4579   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
4580   valueT value = *valP;
4581
4582 #if defined (BFD_ASSEMBLER) && !defined (TE_Mach)
4583   if (fixP->fx_pcrel)
4584     {
4585       switch (fixP->fx_r_type)
4586         {
4587         default:
4588           break;
4589
4590         case BFD_RELOC_32:
4591           fixP->fx_r_type = BFD_RELOC_32_PCREL;
4592           break;
4593         case BFD_RELOC_16:
4594           fixP->fx_r_type = BFD_RELOC_16_PCREL;
4595           break;
4596         case BFD_RELOC_8:
4597           fixP->fx_r_type = BFD_RELOC_8_PCREL;
4598           break;
4599         }
4600     }
4601
4602   if (fixP->fx_addsy != NULL
4603       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
4604           || fixP->fx_r_type == BFD_RELOC_16_PCREL
4605           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
4606       && !use_rela_relocations)
4607     {
4608       /* This is a hack.  There should be a better way to handle this.
4609          This covers for the fact that bfd_install_relocation will
4610          subtract the current location (for partial_inplace, PC relative
4611          relocations); see more below.  */
4612 #ifndef OBJ_AOUT
4613       if (OUTPUT_FLAVOR == bfd_target_elf_flavour
4614 #ifdef TE_PE
4615           || OUTPUT_FLAVOR == bfd_target_coff_flavour
4616 #endif
4617           )
4618         value += fixP->fx_where + fixP->fx_frag->fr_address;
4619 #endif
4620 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4621       if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
4622         {
4623           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
4624
4625           if ((sym_seg == seg
4626                || (symbol_section_p (fixP->fx_addsy)
4627                    && sym_seg != absolute_section))
4628               && !S_FORCE_RELOC (fixP->fx_addsy))
4629             {
4630               /* Yes, we add the values in twice.  This is because
4631                  bfd_install_relocation subtracts them out again.  I think
4632                  bfd_install_relocation is broken, but I don't dare change
4633                  it.  FIXME.  */
4634               value += fixP->fx_where + fixP->fx_frag->fr_address;
4635             }
4636         }
4637 #endif
4638 #if defined (OBJ_COFF) && defined (TE_PE)
4639       /* For some reason, the PE format does not store a section
4640          address offset for a PC relative symbol.  */
4641       if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
4642         value += md_pcrel_from (fixP);
4643 #endif
4644     }
4645
4646   /* Fix a few things - the dynamic linker expects certain values here,
4647      and we must not dissappoint it.  */
4648 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4649   if (OUTPUT_FLAVOR == bfd_target_elf_flavour
4650       && fixP->fx_addsy)
4651     switch (fixP->fx_r_type)
4652       {
4653       case BFD_RELOC_386_PLT32:
4654       case BFD_RELOC_X86_64_PLT32:
4655         /* Make the jump instruction point to the address of the operand.  At
4656            runtime we merely add the offset to the actual PLT entry.  */
4657         value = -4;
4658         break;
4659
4660       case BFD_RELOC_386_GOT32:
4661       case BFD_RELOC_386_TLS_GD:
4662       case BFD_RELOC_386_TLS_LDM:
4663       case BFD_RELOC_386_TLS_IE_32:
4664       case BFD_RELOC_386_TLS_IE:
4665       case BFD_RELOC_386_TLS_GOTIE:
4666       case BFD_RELOC_X86_64_GOT32:
4667         value = 0; /* Fully resolved at runtime.  No addend.  */
4668         break;
4669
4670       case BFD_RELOC_VTABLE_INHERIT:
4671       case BFD_RELOC_VTABLE_ENTRY:
4672         fixP->fx_done = 0;
4673         return;
4674
4675       default:
4676         break;
4677       }
4678 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
4679   *valP = value;
4680 #endif /* defined (BFD_ASSEMBLER) && !defined (TE_Mach)  */
4681
4682   /* Are we finished with this relocation now?  */
4683   if (fixP->fx_addsy == NULL)
4684     fixP->fx_done = 1;
4685 #ifdef BFD_ASSEMBLER
4686   else if (use_rela_relocations)
4687     {
4688       fixP->fx_no_overflow = 1;
4689       /* Remember value for tc_gen_reloc.  */
4690       fixP->fx_addnumber = value;
4691       value = 0;
4692     }
4693 #endif
4694   md_number_to_chars (p, value, fixP->fx_size);
4695 }
4696 \f
4697 #define MAX_LITTLENUMS 6
4698
4699 /* Turn the string pointed to by litP into a floating point constant
4700    of type TYPE, and emit the appropriate bytes.  The number of
4701    LITTLENUMS emitted is stored in *SIZEP.  An error message is
4702    returned, or NULL on OK.  */
4703
4704 char *
4705 md_atof (type, litP, sizeP)
4706      int type;
4707      char *litP;
4708      int *sizeP;
4709 {
4710   int prec;
4711   LITTLENUM_TYPE words[MAX_LITTLENUMS];
4712   LITTLENUM_TYPE *wordP;
4713   char *t;
4714
4715   switch (type)
4716     {
4717     case 'f':
4718     case 'F':
4719       prec = 2;
4720       break;
4721
4722     case 'd':
4723     case 'D':
4724       prec = 4;
4725       break;
4726
4727     case 'x':
4728     case 'X':
4729       prec = 5;
4730       break;
4731
4732     default:
4733       *sizeP = 0;
4734       return _("Bad call to md_atof ()");
4735     }
4736   t = atof_ieee (input_line_pointer, type, words);
4737   if (t)
4738     input_line_pointer = t;
4739
4740   *sizeP = prec * sizeof (LITTLENUM_TYPE);
4741   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
4742      the bigendian 386.  */
4743   for (wordP = words + prec - 1; prec--;)
4744     {
4745       md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
4746       litP += sizeof (LITTLENUM_TYPE);
4747     }
4748   return 0;
4749 }
4750 \f
4751 char output_invalid_buf[8];
4752
4753 static char *
4754 output_invalid (c)
4755      int c;
4756 {
4757   if (ISPRINT (c))
4758     sprintf (output_invalid_buf, "'%c'", c);
4759   else
4760     sprintf (output_invalid_buf, "(0x%x)", (unsigned) c);
4761   return output_invalid_buf;
4762 }
4763
4764 /* REG_STRING starts *before* REGISTER_PREFIX.  */
4765
4766 static const reg_entry *
4767 parse_register (reg_string, end_op)
4768      char *reg_string;
4769      char **end_op;
4770 {
4771   char *s = reg_string;
4772   char *p;
4773   char reg_name_given[MAX_REG_NAME_SIZE + 1];
4774   const reg_entry *r;
4775
4776   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
4777   if (*s == REGISTER_PREFIX)
4778     ++s;
4779
4780   if (is_space_char (*s))
4781     ++s;
4782
4783   p = reg_name_given;
4784   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
4785     {
4786       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
4787         return (const reg_entry *) NULL;
4788       s++;
4789     }
4790
4791   /* For naked regs, make sure that we are not dealing with an identifier.
4792      This prevents confusing an identifier like `eax_var' with register
4793      `eax'.  */
4794   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
4795     return (const reg_entry *) NULL;
4796
4797   *end_op = s;
4798
4799   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
4800
4801   /* Handle floating point regs, allowing spaces in the (i) part.  */
4802   if (r == i386_regtab /* %st is first entry of table  */)
4803     {
4804       if (is_space_char (*s))
4805         ++s;
4806       if (*s == '(')
4807         {
4808           ++s;
4809           if (is_space_char (*s))
4810             ++s;
4811           if (*s >= '0' && *s <= '7')
4812             {
4813               r = &i386_float_regtab[*s - '0'];
4814               ++s;
4815               if (is_space_char (*s))
4816                 ++s;
4817               if (*s == ')')
4818                 {
4819                   *end_op = s + 1;
4820                   return r;
4821                 }
4822             }
4823           /* We have "%st(" then garbage.  */
4824           return (const reg_entry *) NULL;
4825         }
4826     }
4827
4828   if (r != NULL
4829       && (r->reg_flags & (RegRex64 | RegRex)) != 0
4830       && flag_code != CODE_64BIT)
4831     {
4832       return (const reg_entry *) NULL;
4833     }
4834
4835   return r;
4836 }
4837 \f
4838 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4839 const char *md_shortopts = "kVQ:sq";
4840 #else
4841 const char *md_shortopts = "q";
4842 #endif
4843
4844 struct option md_longopts[] = {
4845 #define OPTION_32 (OPTION_MD_BASE + 0)
4846   {"32", no_argument, NULL, OPTION_32},
4847 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4848 #define OPTION_64 (OPTION_MD_BASE + 1)
4849   {"64", no_argument, NULL, OPTION_64},
4850 #endif
4851   {NULL, no_argument, NULL, 0}
4852 };
4853 size_t md_longopts_size = sizeof (md_longopts);
4854
4855 int
4856 md_parse_option (c, arg)
4857      int c;
4858      char *arg ATTRIBUTE_UNUSED;
4859 {
4860   switch (c)
4861     {
4862     case 'q':
4863       quiet_warnings = 1;
4864       break;
4865
4866 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4867       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
4868          should be emitted or not.  FIXME: Not implemented.  */
4869     case 'Q':
4870       break;
4871
4872       /* -V: SVR4 argument to print version ID.  */
4873     case 'V':
4874       print_version_id ();
4875       break;
4876
4877       /* -k: Ignore for FreeBSD compatibility.  */
4878     case 'k':
4879       break;
4880
4881     case 's':
4882       /* -s: On i386 Solaris, this tells the native assembler to use
4883          .stab instead of .stab.excl.  We always use .stab anyhow.  */
4884       break;
4885
4886     case OPTION_64:
4887       {
4888         const char **list, **l;
4889
4890         list = bfd_target_list ();
4891         for (l = list; *l != NULL; l++)
4892           if (strcmp (*l, "elf64-x86-64") == 0)
4893             {
4894               default_arch = "x86_64";
4895               break;
4896             }
4897         if (*l == NULL)
4898           as_fatal (_("No compiled in support for x86_64"));
4899         free (list);
4900       }
4901       break;
4902 #endif
4903
4904     case OPTION_32:
4905       default_arch = "i386";
4906       break;
4907
4908     default:
4909       return 0;
4910     }
4911   return 1;
4912 }
4913
4914 void
4915 md_show_usage (stream)
4916      FILE *stream;
4917 {
4918 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4919   fprintf (stream, _("\
4920   -Q                      ignored\n\
4921   -V                      print assembler version number\n\
4922   -k                      ignored\n\
4923   -q                      quieten some warnings\n\
4924   -s                      ignored\n"));
4925 #else
4926   fprintf (stream, _("\
4927   -q                      quieten some warnings\n"));
4928 #endif
4929 }
4930
4931 #ifdef BFD_ASSEMBLER
4932 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
4933      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))
4934
4935 /* Pick the target format to use.  */
4936
4937 const char *
4938 i386_target_format ()
4939 {
4940   if (!strcmp (default_arch, "x86_64"))
4941     set_code_flag (CODE_64BIT);
4942   else if (!strcmp (default_arch, "i386"))
4943     set_code_flag (CODE_32BIT);
4944   else
4945     as_fatal (_("Unknown architecture"));
4946   switch (OUTPUT_FLAVOR)
4947     {
4948 #ifdef OBJ_MAYBE_AOUT
4949     case bfd_target_aout_flavour:
4950       return AOUT_TARGET_FORMAT;
4951 #endif
4952 #ifdef OBJ_MAYBE_COFF
4953     case bfd_target_coff_flavour:
4954       return "coff-i386";
4955 #endif
4956 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
4957     case bfd_target_elf_flavour:
4958       {
4959         if (flag_code == CODE_64BIT)
4960           use_rela_relocations = 1;
4961         return flag_code == CODE_64BIT ? "elf64-x86-64" : ELF_TARGET_FORMAT;
4962       }
4963 #endif
4964     default:
4965       abort ();
4966       return NULL;
4967     }
4968 }
4969
4970 #endif /* OBJ_MAYBE_ more than one  */
4971
4972 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))
4973 void i386_elf_emit_arch_note ()
4974 {
4975   if (OUTPUT_FLAVOR == bfd_target_elf_flavour
4976       && cpu_arch_name != NULL)
4977     {
4978       char *p;
4979       asection *seg = now_seg;
4980       subsegT subseg = now_subseg;
4981       Elf_Internal_Note i_note;
4982       Elf_External_Note e_note;
4983       asection *note_secp;
4984       int len;
4985
4986       /* Create the .note section.  */
4987       note_secp = subseg_new (".note", 0);
4988       bfd_set_section_flags (stdoutput,
4989                              note_secp,
4990                              SEC_HAS_CONTENTS | SEC_READONLY);
4991
4992       /* Process the arch string.  */
4993       len = strlen (cpu_arch_name);
4994
4995       i_note.namesz = len + 1;
4996       i_note.descsz = 0;
4997       i_note.type = NT_ARCH;
4998       p = frag_more (sizeof (e_note.namesz));
4999       md_number_to_chars (p, (valueT) i_note.namesz, sizeof (e_note.namesz));
5000       p = frag_more (sizeof (e_note.descsz));
5001       md_number_to_chars (p, (valueT) i_note.descsz, sizeof (e_note.descsz));
5002       p = frag_more (sizeof (e_note.type));
5003       md_number_to_chars (p, (valueT) i_note.type, sizeof (e_note.type));
5004       p = frag_more (len + 1);
5005       strcpy (p, cpu_arch_name);
5006
5007       frag_align (2, 0, 0);
5008
5009       subseg_set (seg, subseg);
5010     }
5011 }
5012 #endif
5013 #endif /* BFD_ASSEMBLER  */
5014 \f
5015 symbolS *
5016 md_undefined_symbol (name)
5017      char *name;
5018 {
5019   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
5020       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
5021       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
5022       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
5023     {
5024       if (!GOT_symbol)
5025         {
5026           if (symbol_find (name))
5027             as_bad (_("GOT already in symbol table"));
5028           GOT_symbol = symbol_new (name, undefined_section,
5029                                    (valueT) 0, &zero_address_frag);
5030         };
5031       return GOT_symbol;
5032     }
5033   return 0;
5034 }
5035
5036 /* Round up a section size to the appropriate boundary.  */
5037
5038 valueT
5039 md_section_align (segment, size)
5040      segT segment ATTRIBUTE_UNUSED;
5041      valueT size;
5042 {
5043 #ifdef BFD_ASSEMBLER
5044 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
5045   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
5046     {
5047       /* For a.out, force the section size to be aligned.  If we don't do
5048          this, BFD will align it for us, but it will not write out the
5049          final bytes of the section.  This may be a bug in BFD, but it is
5050          easier to fix it here since that is how the other a.out targets
5051          work.  */
5052       int align;
5053
5054       align = bfd_get_section_alignment (stdoutput, segment);
5055       size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
5056     }
5057 #endif
5058 #endif
5059
5060   return size;
5061 }
5062
5063 /* On the i386, PC-relative offsets are relative to the start of the
5064    next instruction.  That is, the address of the offset, plus its
5065    size, since the offset is always the last part of the insn.  */
5066
5067 long
5068 md_pcrel_from (fixP)
5069      fixS *fixP;
5070 {
5071   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
5072 }
5073
5074 #ifndef I386COFF
5075
5076 static void
5077 s_bss (ignore)
5078      int ignore ATTRIBUTE_UNUSED;
5079 {
5080   int temp;
5081
5082   temp = get_absolute_expression ();
5083   subseg_set (bss_section, (subsegT) temp);
5084   demand_empty_rest_of_line ();
5085 }
5086
5087 #endif
5088
5089 #ifdef BFD_ASSEMBLER
5090
5091 void
5092 i386_validate_fix (fixp)
5093      fixS *fixp;
5094 {
5095   if (fixp->fx_subsy && fixp->fx_subsy == GOT_symbol)
5096     {
5097       /* GOTOFF relocation are nonsense in 64bit mode.  */
5098       if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
5099         {
5100           if (flag_code != CODE_64BIT)
5101             abort ();
5102           fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
5103         }
5104       else
5105         {
5106           if (flag_code == CODE_64BIT)
5107             abort ();
5108           fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
5109         }
5110       fixp->fx_subsy = 0;
5111     }
5112 }
5113
5114 boolean
5115 i386_force_relocation (fixp)
5116      fixS *fixp;
5117 {
5118   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
5119       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5120     return 1;
5121
5122   return S_FORCE_RELOC (fixp->fx_addsy);
5123 }
5124
5125 arelent *
5126 tc_gen_reloc (section, fixp)
5127      asection *section ATTRIBUTE_UNUSED;
5128      fixS *fixp;
5129 {
5130   arelent *rel;
5131   bfd_reloc_code_real_type code;
5132
5133   switch (fixp->fx_r_type)
5134     {
5135     case BFD_RELOC_X86_64_PLT32:
5136     case BFD_RELOC_X86_64_GOT32:
5137     case BFD_RELOC_X86_64_GOTPCREL:
5138     case BFD_RELOC_386_PLT32:
5139     case BFD_RELOC_386_GOT32:
5140     case BFD_RELOC_386_GOTOFF:
5141     case BFD_RELOC_386_GOTPC:
5142     case BFD_RELOC_386_TLS_GD:
5143     case BFD_RELOC_386_TLS_LDM:
5144     case BFD_RELOC_386_TLS_LDO_32:
5145     case BFD_RELOC_386_TLS_IE_32:
5146     case BFD_RELOC_386_TLS_IE:
5147     case BFD_RELOC_386_TLS_GOTIE:
5148     case BFD_RELOC_386_TLS_LE_32:
5149     case BFD_RELOC_386_TLS_LE:
5150     case BFD_RELOC_X86_64_32S:
5151     case BFD_RELOC_RVA:
5152     case BFD_RELOC_VTABLE_ENTRY:
5153     case BFD_RELOC_VTABLE_INHERIT:
5154       code = fixp->fx_r_type;
5155       break;
5156     default:
5157       if (fixp->fx_pcrel)
5158         {
5159           switch (fixp->fx_size)
5160             {
5161             default:
5162               as_bad_where (fixp->fx_file, fixp->fx_line,
5163                             _("can not do %d byte pc-relative relocation"),
5164                             fixp->fx_size);
5165               code = BFD_RELOC_32_PCREL;
5166               break;
5167             case 1: code = BFD_RELOC_8_PCREL;  break;
5168             case 2: code = BFD_RELOC_16_PCREL; break;
5169             case 4: code = BFD_RELOC_32_PCREL; break;
5170             }
5171         }
5172       else
5173         {
5174           switch (fixp->fx_size)
5175             {
5176             default:
5177               as_bad_where (fixp->fx_file, fixp->fx_line,
5178                             _("can not do %d byte relocation"),
5179                             fixp->fx_size);
5180               code = BFD_RELOC_32;
5181               break;
5182             case 1: code = BFD_RELOC_8;  break;
5183             case 2: code = BFD_RELOC_16; break;
5184             case 4: code = BFD_RELOC_32; break;
5185 #ifdef BFD64
5186             case 8: code = BFD_RELOC_64; break;
5187 #endif
5188             }
5189         }
5190       break;
5191     }
5192
5193   if (code == BFD_RELOC_32
5194       && GOT_symbol
5195       && fixp->fx_addsy == GOT_symbol)
5196     {
5197       /* We don't support GOTPC on 64bit targets.  */
5198       if (flag_code == CODE_64BIT)
5199         abort ();
5200       code = BFD_RELOC_386_GOTPC;
5201     }
5202
5203   rel = (arelent *) xmalloc (sizeof (arelent));
5204   rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5205   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5206
5207   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
5208   if (!use_rela_relocations)
5209     {
5210       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
5211          vtable entry to be used in the relocation's section offset.  */
5212       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
5213         rel->address = fixp->fx_offset;
5214
5215       rel->addend = 0;
5216     }
5217   /* Use the rela in 64bit mode.  */
5218   else
5219     {
5220       if (!fixp->fx_pcrel)
5221         rel->addend = fixp->fx_offset;
5222       else
5223         switch (code)
5224           {
5225           case BFD_RELOC_X86_64_PLT32:
5226           case BFD_RELOC_X86_64_GOT32:
5227           case BFD_RELOC_X86_64_GOTPCREL:
5228             rel->addend = fixp->fx_offset - fixp->fx_size;
5229             break;
5230           default:
5231             rel->addend = (section->vma
5232                            - fixp->fx_size
5233                            + fixp->fx_addnumber
5234                            + md_pcrel_from (fixp));
5235             break;
5236           }
5237     }
5238
5239   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
5240   if (rel->howto == NULL)
5241     {
5242       as_bad_where (fixp->fx_file, fixp->fx_line,
5243                     _("cannot represent relocation type %s"),
5244                     bfd_get_reloc_code_name (code));
5245       /* Set howto to a garbage value so that we can keep going.  */
5246       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
5247       assert (rel->howto != NULL);
5248     }
5249
5250   return rel;
5251 }
5252
5253 #else /* !BFD_ASSEMBLER  */
5254
5255 #if (defined(OBJ_AOUT) | defined(OBJ_BOUT))
5256 void
5257 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
5258      char *where;
5259      fixS *fixP;
5260      relax_addressT segment_address_in_file;
5261 {
5262   /* In:  length of relocation (or of address) in chars: 1, 2 or 4.
5263      Out: GNU LD relocation length code: 0, 1, or 2.  */
5264
5265   static const unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
5266   long r_symbolnum;
5267
5268   know (fixP->fx_addsy != NULL);
5269
5270   md_number_to_chars (where,
5271                       (valueT) (fixP->fx_frag->fr_address
5272                                 + fixP->fx_where - segment_address_in_file),
5273                       4);
5274
5275   r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
5276                  ? S_GET_TYPE (fixP->fx_addsy)
5277                  : fixP->fx_addsy->sy_number);
5278
5279   where[6] = (r_symbolnum >> 16) & 0x0ff;
5280   where[5] = (r_symbolnum >> 8) & 0x0ff;
5281   where[4] = r_symbolnum & 0x0ff;
5282   where[7] = ((((!S_IS_DEFINED (fixP->fx_addsy)) << 3) & 0x08)
5283               | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
5284               | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
5285 }
5286
5287 #endif /* OBJ_AOUT or OBJ_BOUT.  */
5288
5289 #if defined (I386COFF)
5290
5291 short
5292 tc_coff_fix2rtype (fixP)
5293      fixS *fixP;
5294 {
5295   if (fixP->fx_r_type == R_IMAGEBASE)
5296     return R_IMAGEBASE;
5297
5298   return (fixP->fx_pcrel ?
5299           (fixP->fx_size == 1 ? R_PCRBYTE :
5300            fixP->fx_size == 2 ? R_PCRWORD :
5301            R_PCRLONG) :
5302           (fixP->fx_size == 1 ? R_RELBYTE :
5303            fixP->fx_size == 2 ? R_RELWORD :
5304            R_DIR32));
5305 }
5306
5307 int
5308 tc_coff_sizemachdep (frag)
5309      fragS *frag;
5310 {
5311   if (frag->fr_next)
5312     return (frag->fr_next->fr_address - frag->fr_address);
5313   else
5314     return 0;
5315 }
5316
5317 #endif /* I386COFF  */
5318
5319 #endif /* !BFD_ASSEMBLER  */
5320 \f
5321 /* Parse operands using Intel syntax. This implements a recursive descent
5322    parser based on the BNF grammar published in Appendix B of the MASM 6.1
5323    Programmer's Guide.
5324
5325    FIXME: We do not recognize the full operand grammar defined in the MASM
5326           documentation.  In particular, all the structure/union and
5327           high-level macro operands are missing.
5328
5329    Uppercase words are terminals, lower case words are non-terminals.
5330    Objects surrounded by double brackets '[[' ']]' are optional. Vertical
5331    bars '|' denote choices. Most grammar productions are implemented in
5332    functions called 'intel_<production>'.
5333
5334    Initial production is 'expr'.
5335
5336     addOp               + | -
5337
5338     alpha               [a-zA-Z]
5339
5340     byteRegister        AL | AH | BL | BH | CL | CH | DL | DH
5341
5342     constant            digits [[ radixOverride ]]
5343
5344     dataType            BYTE | WORD | DWORD | QWORD | XWORD
5345
5346     digits              decdigit
5347                         | digits decdigit
5348                         | digits hexdigit
5349
5350     decdigit            [0-9]
5351
5352     e05                 e05 addOp e06
5353                         | e06
5354
5355     e06                 e06 mulOp e09
5356                         | e09
5357
5358     e09                 OFFSET e10
5359                         | e09 PTR e10
5360                         | e09 : e10
5361                         | e10
5362
5363     e10                 e10 [ expr ]
5364                         | e11
5365
5366     e11                 ( expr )
5367                         | [ expr ]
5368                         | constant
5369                         | dataType
5370                         | id
5371                         | $
5372                         | register
5373
5374  => expr                SHORT e05
5375                         | e05
5376
5377     gpRegister          AX | EAX | BX | EBX | CX | ECX | DX | EDX
5378                         | BP | EBP | SP | ESP | DI | EDI | SI | ESI
5379
5380     hexdigit            a | b | c | d | e | f
5381                         | A | B | C | D | E | F
5382
5383     id                  alpha
5384                         | id alpha
5385                         | id decdigit
5386
5387     mulOp               * | / | MOD
5388
5389     quote               " | '
5390
5391     register            specialRegister
5392                         | gpRegister
5393                         | byteRegister
5394
5395     segmentRegister     CS | DS | ES | FS | GS | SS
5396
5397     specialRegister     CR0 | CR2 | CR3
5398                         | DR0 | DR1 | DR2 | DR3 | DR6 | DR7
5399                         | TR3 | TR4 | TR5 | TR6 | TR7
5400
5401     We simplify the grammar in obvious places (e.g., register parsing is
5402     done by calling parse_register) and eliminate immediate left recursion
5403     to implement a recursive-descent parser.
5404
5405     expr        SHORT e05
5406                 | e05
5407
5408     e05         e06 e05'
5409
5410     e05'        addOp e06 e05'
5411                 | Empty
5412
5413     e06         e09 e06'
5414
5415     e06'        mulOp e09 e06'
5416                 | Empty
5417
5418     e09         OFFSET e10 e09'
5419                 | e10 e09'
5420
5421     e09'        PTR e10 e09'
5422                 | : e10 e09'
5423                 | Empty
5424
5425     e10         e11 e10'
5426
5427     e10'        [ expr ] e10'
5428                 | Empty
5429
5430     e11         ( expr )
5431                 | [ expr ]
5432                 | BYTE
5433                 | WORD
5434                 | DWORD
5435                 | QWORD
5436                 | XWORD
5437                 | .
5438                 | $
5439                 | register
5440                 | id
5441                 | constant  */
5442
5443 /* Parsing structure for the intel syntax parser. Used to implement the
5444    semantic actions for the operand grammar.  */
5445 struct intel_parser_s
5446   {
5447     char *op_string;            /* The string being parsed.  */
5448     int got_a_float;            /* Whether the operand is a float.  */
5449     int op_modifier;            /* Operand modifier.  */
5450     int is_mem;                 /* 1 if operand is memory reference.  */
5451     const reg_entry *reg;       /* Last register reference found.  */
5452     char *disp;                 /* Displacement string being built.  */
5453   };
5454
5455 static struct intel_parser_s intel_parser;
5456
5457 /* Token structure for parsing intel syntax.  */
5458 struct intel_token
5459   {
5460     int code;                   /* Token code.  */
5461     const reg_entry *reg;       /* Register entry for register tokens.  */
5462     char *str;                  /* String representation.  */
5463   };
5464
5465 static struct intel_token cur_token, prev_token;
5466
5467 /* Token codes for the intel parser. Since T_SHORT is already used
5468    by COFF, undefine it first to prevent a warning.  */
5469 #define T_NIL           -1
5470 #define T_CONST         1
5471 #define T_REG           2
5472 #define T_BYTE          3
5473 #define T_WORD          4
5474 #define T_DWORD         5
5475 #define T_QWORD         6
5476 #define T_XWORD         7
5477 #undef  T_SHORT
5478 #define T_SHORT         8
5479 #define T_OFFSET        9
5480 #define T_PTR           10
5481 #define T_ID            11
5482
5483 /* Prototypes for intel parser functions.  */
5484 static int intel_match_token    PARAMS ((int code));
5485 static void intel_get_token     PARAMS ((void));
5486 static void intel_putback_token PARAMS ((void));
5487 static int intel_expr           PARAMS ((void));
5488 static int intel_e05            PARAMS ((void));
5489 static int intel_e05_1          PARAMS ((void));
5490 static int intel_e06            PARAMS ((void));
5491 static int intel_e06_1          PARAMS ((void));
5492 static int intel_e09            PARAMS ((void));
5493 static int intel_e09_1          PARAMS ((void));
5494 static int intel_e10            PARAMS ((void));
5495 static int intel_e10_1          PARAMS ((void));
5496 static int intel_e11            PARAMS ((void));
5497
5498 static int
5499 i386_intel_operand (operand_string, got_a_float)
5500      char *operand_string;
5501      int got_a_float;
5502 {
5503   int ret;
5504   char *p;
5505
5506   /* Initialize token holders.  */
5507   cur_token.code = prev_token.code = T_NIL;
5508   cur_token.reg = prev_token.reg = NULL;
5509   cur_token.str = prev_token.str = NULL;
5510
5511   /* Initialize parser structure.  */
5512   p = intel_parser.op_string = (char *) malloc (strlen (operand_string) + 1);
5513   if (p == NULL)
5514     abort ();
5515   strcpy (intel_parser.op_string, operand_string);
5516   intel_parser.got_a_float = got_a_float;
5517   intel_parser.op_modifier = -1;
5518   intel_parser.is_mem = 0;
5519   intel_parser.reg = NULL;
5520   intel_parser.disp = (char *) malloc (strlen (operand_string) + 1);
5521   if (intel_parser.disp == NULL)
5522     abort ();
5523   intel_parser.disp[0] = '\0';
5524
5525   /* Read the first token and start the parser.  */
5526   intel_get_token ();
5527   ret = intel_expr ();
5528
5529   if (ret)
5530     {
5531       /* If we found a memory reference, hand it over to i386_displacement
5532          to fill in the rest of the operand fields.  */
5533       if (intel_parser.is_mem)
5534         {
5535           if ((i.mem_operands == 1
5536                && (current_templates->start->opcode_modifier & IsString) == 0)
5537               || i.mem_operands == 2)
5538             {
5539               as_bad (_("too many memory references for '%s'"),
5540                       current_templates->start->name);
5541               ret = 0;
5542             }
5543           else
5544             {
5545               char *s = intel_parser.disp;
5546               i.mem_operands++;
5547
5548               /* Add the displacement expression.  */
5549               if (*s != '\0')
5550                 ret = i386_displacement (s, s + strlen (s))
5551                       && i386_index_check (s);
5552             }
5553         }
5554
5555       /* Constant and OFFSET expressions are handled by i386_immediate.  */
5556       else if (intel_parser.op_modifier == OFFSET_FLAT
5557                || intel_parser.reg == NULL)
5558         ret = i386_immediate (intel_parser.disp);
5559     }
5560
5561   free (p);
5562   free (intel_parser.disp);
5563
5564   return ret;
5565 }
5566
5567 /* expr SHORT e05
5568         | e05  */
5569 static int
5570 intel_expr ()
5571 {
5572   /* expr  SHORT e05  */
5573   if (cur_token.code == T_SHORT)
5574     {
5575       intel_parser.op_modifier = SHORT;
5576       intel_match_token (T_SHORT);
5577
5578       return (intel_e05 ());
5579     }
5580
5581   /* expr  e05  */
5582   else
5583     return intel_e05 ();
5584 }
5585
5586 /* e05  e06 e05'
5587
5588    e05' addOp e06 e05'
5589         | Empty  */
5590 static int
5591 intel_e05 ()
5592 {
5593   return (intel_e06 () && intel_e05_1 ());
5594 }
5595
5596 static int
5597 intel_e05_1 ()
5598 {
5599   /* e05'  addOp e06 e05'  */
5600   if (cur_token.code == '+' || cur_token.code == '-')
5601     {
5602       strcat (intel_parser.disp, cur_token.str);
5603       intel_match_token (cur_token.code);
5604
5605       return (intel_e06 () && intel_e05_1 ());
5606     }
5607
5608   /* e05'  Empty  */
5609   else
5610     return 1;
5611 }
5612
5613 /* e06  e09 e06'
5614
5615    e06' mulOp e09 e06'
5616         | Empty  */
5617 static int
5618 intel_e06 ()
5619 {
5620   return (intel_e09 () && intel_e06_1 ());
5621 }
5622
5623 static int
5624 intel_e06_1 ()
5625 {
5626   /* e06'  mulOp e09 e06'  */
5627   if (cur_token.code == '*' || cur_token.code == '/')
5628     {
5629       strcat (intel_parser.disp, cur_token.str);
5630       intel_match_token (cur_token.code);
5631
5632       return (intel_e09 () && intel_e06_1 ());
5633     }
5634
5635   /* e06'  Empty  */
5636   else
5637     return 1;
5638 }
5639
5640 /* e09  OFFSET e10 e09'
5641         | e10 e09'
5642
5643    e09' PTR e10 e09'
5644         | : e10 e09'
5645         | Empty */
5646 static int
5647 intel_e09 ()
5648 {
5649   /* e09  OFFSET e10 e09'  */
5650   if (cur_token.code == T_OFFSET)
5651     {
5652       intel_parser.is_mem = 0;
5653       intel_parser.op_modifier = OFFSET_FLAT;
5654       intel_match_token (T_OFFSET);
5655
5656       return (intel_e10 () && intel_e09_1 ());
5657     }
5658
5659   /* e09  e10 e09'  */
5660   else
5661     return (intel_e10 () && intel_e09_1 ());
5662 }
5663
5664 static int
5665 intel_e09_1 ()
5666 {
5667   /* e09'  PTR e10 e09' */
5668   if (cur_token.code == T_PTR)
5669     {
5670       if (prev_token.code == T_BYTE)
5671         i.suffix = BYTE_MNEM_SUFFIX;
5672
5673       else if (prev_token.code == T_WORD)
5674         {
5675           if (intel_parser.got_a_float == 2)    /* "fi..." */
5676             i.suffix = SHORT_MNEM_SUFFIX;
5677           else
5678             i.suffix = WORD_MNEM_SUFFIX;
5679         }
5680
5681       else if (prev_token.code == T_DWORD)
5682         {
5683           if (intel_parser.got_a_float == 1)    /* "f..." */
5684             i.suffix = SHORT_MNEM_SUFFIX;
5685           else
5686             i.suffix = LONG_MNEM_SUFFIX;
5687         }
5688
5689       else if (prev_token.code == T_QWORD)
5690         {
5691           if (intel_parser.got_a_float == 1)    /* "f..." */
5692             i.suffix = LONG_MNEM_SUFFIX;
5693           else
5694             i.suffix = QWORD_MNEM_SUFFIX;
5695         }
5696
5697       else if (prev_token.code == T_XWORD)
5698         i.suffix = LONG_DOUBLE_MNEM_SUFFIX;
5699
5700       else
5701         {
5702           as_bad (_("Unknown operand modifier `%s'\n"), prev_token.str);
5703           return 0;
5704         }
5705
5706       intel_match_token (T_PTR);
5707
5708       return (intel_e10 () && intel_e09_1 ());
5709     }
5710
5711   /* e09  : e10 e09'  */
5712   else if (cur_token.code == ':')
5713     {
5714       /* Mark as a memory operand only if it's not already known to be an
5715          offset expression.  */
5716       if (intel_parser.op_modifier != OFFSET_FLAT)
5717         intel_parser.is_mem = 1;
5718
5719       return (intel_match_token (':') && intel_e10 () && intel_e09_1 ());
5720     }
5721
5722   /* e09'  Empty  */
5723   else
5724     return 1;
5725 }
5726
5727 /* e10  e11 e10'
5728
5729    e10' [ expr ] e10'
5730         | Empty  */
5731 static int
5732 intel_e10 ()
5733 {
5734   return (intel_e11 () && intel_e10_1 ());
5735 }
5736
5737 static int
5738 intel_e10_1 ()
5739 {
5740   /* e10'  [ expr ]  e10'  */
5741   if (cur_token.code == '[')
5742     {
5743       intel_match_token ('[');
5744
5745       /* Mark as a memory operand only if it's not already known to be an
5746          offset expression.  If it's an offset expression, we need to keep
5747          the brace in.  */
5748       if (intel_parser.op_modifier != OFFSET_FLAT)
5749         intel_parser.is_mem = 1;
5750       else
5751         strcat (intel_parser.disp, "[");
5752
5753       /* Add a '+' to the displacement string if necessary.  */
5754       if (*intel_parser.disp != '\0'
5755           && *(intel_parser.disp + strlen (intel_parser.disp) - 1) != '+')
5756         strcat (intel_parser.disp, "+");
5757
5758       if (intel_expr () && intel_match_token (']'))
5759         {
5760           /* Preserve brackets when the operand is an offset expression.  */
5761           if (intel_parser.op_modifier == OFFSET_FLAT)
5762             strcat (intel_parser.disp, "]");
5763
5764           return intel_e10_1 ();
5765         }
5766       else
5767         return 0;
5768     }
5769
5770   /* e10'  Empty  */
5771   else
5772     return 1;
5773 }
5774
5775 /* e11  ( expr )
5776         | [ expr ]
5777         | BYTE
5778         | WORD
5779         | DWORD
5780         | QWORD
5781         | XWORD
5782         | $
5783         | .
5784         | register
5785         | id
5786         | constant  */
5787 static int
5788 intel_e11 ()
5789 {
5790   /* e11  ( expr ) */
5791   if (cur_token.code == '(')
5792     {
5793       intel_match_token ('(');
5794       strcat (intel_parser.disp, "(");
5795
5796       if (intel_expr () && intel_match_token (')'))
5797         {
5798           strcat (intel_parser.disp, ")");
5799           return 1;
5800         }
5801       else
5802         return 0;
5803     }
5804
5805   /* e11  [ expr ] */
5806   else if (cur_token.code == '[')
5807     {
5808       intel_match_token ('[');
5809
5810       /* Mark as a memory operand only if it's not already known to be an
5811          offset expression.  If it's an offset expression, we need to keep
5812          the brace in.  */
5813       if (intel_parser.op_modifier != OFFSET_FLAT)
5814         intel_parser.is_mem = 1;
5815       else
5816         strcat (intel_parser.disp, "[");
5817
5818       /* Operands for jump/call inside brackets denote absolute addresses.  */
5819       if (current_templates->start->opcode_modifier & Jump
5820           || current_templates->start->opcode_modifier & JumpDword
5821           || current_templates->start->opcode_modifier & JumpByte
5822           || current_templates->start->opcode_modifier & JumpInterSegment)
5823         i.types[this_operand] |= JumpAbsolute;
5824
5825       /* Add a '+' to the displacement string if necessary.  */
5826       if (*intel_parser.disp != '\0'
5827           && *(intel_parser.disp + strlen (intel_parser.disp) - 1) != '+')
5828         strcat (intel_parser.disp, "+");
5829
5830       if (intel_expr () && intel_match_token (']'))
5831         {
5832           /* Preserve brackets when the operand is an offset expression.  */
5833           if (intel_parser.op_modifier == OFFSET_FLAT)
5834             strcat (intel_parser.disp, "]");
5835
5836           return 1;
5837         }
5838       else
5839         return 0;
5840     }
5841
5842   /* e11  BYTE
5843           | WORD
5844           | DWORD
5845           | QWORD
5846           | XWORD  */
5847   else if (cur_token.code == T_BYTE
5848            || cur_token.code == T_WORD
5849            || cur_token.code == T_DWORD
5850            || cur_token.code == T_QWORD
5851            || cur_token.code == T_XWORD)
5852     {
5853       intel_match_token (cur_token.code);
5854
5855       return 1;
5856     }
5857
5858   /* e11  $
5859           | .  */
5860   else if (cur_token.code == '$' || cur_token.code == '.')
5861     {
5862       strcat (intel_parser.disp, cur_token.str);
5863       intel_match_token (cur_token.code);
5864
5865       /* Mark as a memory operand only if it's not already known to be an
5866          offset expression.  */
5867       if (intel_parser.op_modifier != OFFSET_FLAT)
5868         intel_parser.is_mem = 1;
5869
5870       return 1;
5871     }
5872
5873   /* e11  register  */
5874   else if (cur_token.code == T_REG)
5875     {
5876       const reg_entry *reg = intel_parser.reg = cur_token.reg;
5877
5878       intel_match_token (T_REG);
5879
5880       /* Check for segment change.  */
5881       if (cur_token.code == ':')
5882         {
5883           if (reg->reg_type & (SReg2 | SReg3))
5884             {
5885               switch (reg->reg_num)
5886                 {
5887                 case 0:
5888                   i.seg[i.mem_operands] = &es;
5889                   break;
5890                 case 1:
5891                   i.seg[i.mem_operands] = &cs;
5892                   break;
5893                 case 2:
5894                   i.seg[i.mem_operands] = &ss;
5895                   break;
5896                 case 3:
5897                   i.seg[i.mem_operands] = &ds;
5898                   break;
5899                 case 4:
5900                   i.seg[i.mem_operands] = &fs;
5901                   break;
5902                 case 5:
5903                   i.seg[i.mem_operands] = &gs;
5904                   break;
5905                 }
5906             }
5907           else
5908             {
5909               as_bad (_("`%s' is not a valid segment register"), reg->reg_name);
5910               return 0;
5911             }
5912         }
5913
5914       /* Not a segment register. Check for register scaling.  */
5915       else if (cur_token.code == '*')
5916         {
5917           if (!intel_parser.is_mem)
5918             {
5919               as_bad (_("Register scaling only allowed in memory operands."));
5920               return 0;
5921             }
5922
5923           /* What follows must be a valid scale.  */
5924           if (intel_match_token ('*')
5925               && strchr ("01248", *cur_token.str))
5926             {
5927               i.index_reg = reg;
5928               i.types[this_operand] |= BaseIndex;
5929
5930               /* Set the scale after setting the register (otherwise,
5931                  i386_scale will complain)  */
5932               i386_scale (cur_token.str);
5933               intel_match_token (T_CONST);
5934             }
5935           else
5936             {
5937               as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
5938                       cur_token.str);
5939               return 0;
5940             }
5941         }
5942
5943       /* No scaling. If this is a memory operand, the register is either a
5944          base register (first occurrence) or an index register (second
5945          occurrence).  */
5946       else if (intel_parser.is_mem && !(reg->reg_type & (SReg2 | SReg3)))
5947         {
5948           if (i.base_reg && i.index_reg)
5949             {
5950               as_bad (_("Too many register references in memory operand.\n"));
5951               return 0;
5952             }
5953
5954           if (i.base_reg == NULL)
5955             i.base_reg = reg;
5956           else
5957             i.index_reg = reg;
5958
5959           i.types[this_operand] |= BaseIndex;
5960         }
5961
5962       /* Offset modifier. Add the register to the displacement string to be
5963          parsed as an immediate expression after we're done.  */
5964       else if (intel_parser.op_modifier == OFFSET_FLAT)
5965         strcat (intel_parser.disp, reg->reg_name);
5966
5967       /* It's neither base nor index nor offset.  */
5968       else
5969         {
5970           i.types[this_operand] |= reg->reg_type & ~BaseIndex;
5971           i.op[this_operand].regs = reg;
5972           i.reg_operands++;
5973         }
5974
5975       /* Since registers are not part of the displacement string (except
5976          when we're parsing offset operands), we may need to remove any
5977          preceding '+' from the displacement string.  */
5978       if (*intel_parser.disp != '\0'
5979           && intel_parser.op_modifier != OFFSET_FLAT)
5980         {
5981           char *s = intel_parser.disp;
5982           s += strlen (s) - 1;
5983           if (*s == '+')
5984             *s = '\0';
5985         }
5986
5987       return 1;
5988     }
5989
5990   /* e11  id  */
5991   else if (cur_token.code == T_ID)
5992     {
5993       /* Add the identifier to the displacement string.  */
5994       strcat (intel_parser.disp, cur_token.str);
5995       intel_match_token (T_ID);
5996
5997       /* The identifier represents a memory reference only if it's not
5998          preceded by an offset modifier.  */
5999       if (intel_parser.op_modifier != OFFSET_FLAT)
6000         intel_parser.is_mem = 1;
6001
6002       return 1;
6003     }
6004
6005   /* e11  constant  */
6006   else if (cur_token.code == T_CONST
6007            || cur_token.code == '-'
6008            || cur_token.code == '+')
6009     {
6010       char *save_str;
6011
6012       /* Allow constants that start with `+' or `-'.  */
6013       if (cur_token.code == '-' || cur_token.code == '+')
6014         {
6015           strcat (intel_parser.disp, cur_token.str);
6016           intel_match_token (cur_token.code);
6017           if (cur_token.code != T_CONST)
6018             {
6019               as_bad (_("Syntax error. Expecting a constant. Got `%s'.\n"),
6020                       cur_token.str);
6021               return 0;
6022             }
6023         }
6024
6025       save_str = (char *) malloc (strlen (cur_token.str) + 1);
6026       if (save_str == NULL)
6027         abort ();
6028       strcpy (save_str, cur_token.str);
6029
6030       /* Get the next token to check for register scaling.  */
6031       intel_match_token (cur_token.code);
6032
6033       /* Check if this constant is a scaling factor for an index register.  */
6034       if (cur_token.code == '*')
6035         {
6036           if (intel_match_token ('*') && cur_token.code == T_REG)
6037             {
6038               if (!intel_parser.is_mem)
6039                 {
6040                   as_bad (_("Register scaling only allowed in memory operands."));
6041                   return 0;
6042                 }
6043
6044               /* The constant is followed by `* reg', so it must be
6045                  a valid scale.  */
6046               if (strchr ("01248", *save_str))
6047                 {
6048                   i.index_reg = cur_token.reg;
6049                   i.types[this_operand] |= BaseIndex;
6050
6051                   /* Set the scale after setting the register (otherwise,
6052                      i386_scale will complain)  */
6053                   i386_scale (save_str);
6054                   intel_match_token (T_REG);
6055
6056                   /* Since registers are not part of the displacement
6057                      string, we may need to remove any preceding '+' from
6058                      the displacement string.  */
6059                   if (*intel_parser.disp != '\0')
6060                     {
6061                       char *s = intel_parser.disp;
6062                       s += strlen (s) - 1;
6063                       if (*s == '+')
6064                         *s = '\0';
6065                     }
6066
6067                   free (save_str);
6068
6069                   return 1;
6070                 }
6071               else
6072                 return 0;
6073             }
6074
6075           /* The constant was not used for register scaling. Since we have
6076              already consumed the token following `*' we now need to put it
6077              back in the stream.  */
6078           else
6079             intel_putback_token ();
6080         }
6081
6082       /* Add the constant to the displacement string.  */
6083       strcat (intel_parser.disp, save_str);
6084       free (save_str);
6085
6086       return 1;
6087     }
6088
6089   as_bad (_("Unrecognized token '%s'"), cur_token.str);
6090   return 0;
6091 }
6092
6093 /* Match the given token against cur_token. If they match, read the next
6094    token from the operand string.  */
6095 static int
6096 intel_match_token (code)
6097      int code;
6098 {
6099   if (cur_token.code == code)
6100     {
6101       intel_get_token ();
6102       return 1;
6103     }
6104   else
6105     {
6106       as_bad (_("Unexpected token `%s'\n"), cur_token.str);
6107       return 0;
6108     }
6109 }
6110
6111 /* Read a new token from intel_parser.op_string and store it in cur_token.  */
6112 static void
6113 intel_get_token ()
6114 {
6115   char *end_op;
6116   const reg_entry *reg;
6117   struct intel_token new_token;
6118
6119   new_token.code = T_NIL;
6120   new_token.reg = NULL;
6121   new_token.str = NULL;
6122
6123   /* Free the memory allocated to the previous token and move
6124      cur_token to prev_token.  */
6125   if (prev_token.str)
6126     free (prev_token.str);
6127
6128   prev_token = cur_token;
6129
6130   /* Skip whitespace.  */
6131   while (is_space_char (*intel_parser.op_string))
6132     intel_parser.op_string++;
6133
6134   /* Return an empty token if we find nothing else on the line.  */
6135   if (*intel_parser.op_string == '\0')
6136     {
6137       cur_token = new_token;
6138       return;
6139     }
6140
6141   /* The new token cannot be larger than the remainder of the operand
6142      string.  */
6143   new_token.str = (char *) malloc (strlen (intel_parser.op_string) + 1);
6144   if (new_token.str == NULL)
6145     abort ();
6146   new_token.str[0] = '\0';
6147
6148   if (strchr ("0123456789", *intel_parser.op_string))
6149     {
6150       char *p = new_token.str;
6151       char *q = intel_parser.op_string;
6152       new_token.code = T_CONST;
6153
6154       /* Allow any kind of identifier char to encompass floating point and
6155          hexadecimal numbers.  */
6156       while (is_identifier_char (*q))
6157         *p++ = *q++;
6158       *p = '\0';
6159
6160       /* Recognize special symbol names [0-9][bf].  */
6161       if (strlen (intel_parser.op_string) == 2
6162           && (intel_parser.op_string[1] == 'b'
6163               || intel_parser.op_string[1] == 'f'))
6164         new_token.code = T_ID;
6165     }
6166
6167   else if (strchr ("+-/*:[]()", *intel_parser.op_string))
6168     {
6169       new_token.code = *intel_parser.op_string;
6170       new_token.str[0] = *intel_parser.op_string;
6171       new_token.str[1] = '\0';
6172     }
6173
6174   else if ((*intel_parser.op_string == REGISTER_PREFIX || allow_naked_reg)
6175            && ((reg = parse_register (intel_parser.op_string, &end_op)) != NULL))
6176     {
6177       new_token.code = T_REG;
6178       new_token.reg = reg;
6179
6180       if (*intel_parser.op_string == REGISTER_PREFIX)
6181         {
6182           new_token.str[0] = REGISTER_PREFIX;
6183           new_token.str[1] = '\0';
6184         }
6185
6186       strcat (new_token.str, reg->reg_name);
6187     }
6188
6189   else if (is_identifier_char (*intel_parser.op_string))
6190     {
6191       char *p = new_token.str;
6192       char *q = intel_parser.op_string;
6193
6194       /* A '.' or '$' followed by an identifier char is an identifier.
6195          Otherwise, it's operator '.' followed by an expression.  */
6196       if ((*q == '.' || *q == '$') && !is_identifier_char (*(q + 1)))
6197         {
6198           new_token.code = *q;
6199           new_token.str[0] = *q;
6200           new_token.str[1] = '\0';
6201         }
6202       else
6203         {
6204           while (is_identifier_char (*q) || *q == '@')
6205             *p++ = *q++;
6206           *p = '\0';
6207
6208           if (strcasecmp (new_token.str, "BYTE") == 0)
6209             new_token.code = T_BYTE;
6210
6211           else if (strcasecmp (new_token.str, "WORD") == 0)
6212             new_token.code = T_WORD;
6213
6214           else if (strcasecmp (new_token.str, "DWORD") == 0)
6215             new_token.code = T_DWORD;
6216
6217           else if (strcasecmp (new_token.str, "QWORD") == 0)
6218             new_token.code = T_QWORD;
6219
6220           else if (strcasecmp (new_token.str, "XWORD") == 0)
6221             new_token.code = T_XWORD;
6222
6223           else if (strcasecmp (new_token.str, "PTR") == 0)
6224             new_token.code = T_PTR;
6225
6226           else if (strcasecmp (new_token.str, "SHORT") == 0)
6227             new_token.code = T_SHORT;
6228
6229           else if (strcasecmp (new_token.str, "OFFSET") == 0)
6230             {
6231               new_token.code = T_OFFSET;
6232
6233               /* ??? This is not mentioned in the MASM grammar but gcc
6234                      makes use of it with -mintel-syntax.  OFFSET may be
6235                      followed by FLAT:  */
6236               if (strncasecmp (q, " FLAT:", 6) == 0)
6237                 strcat (new_token.str, " FLAT:");
6238             }
6239
6240           /* ??? This is not mentioned in the MASM grammar.  */
6241           else if (strcasecmp (new_token.str, "FLAT") == 0)
6242             new_token.code = T_OFFSET;
6243
6244           else
6245             new_token.code = T_ID;
6246         }
6247     }
6248
6249   else
6250     as_bad (_("Unrecognized token `%s'\n"), intel_parser.op_string);
6251
6252   intel_parser.op_string += strlen (new_token.str);
6253   cur_token = new_token;
6254 }
6255
6256 /* Put cur_token back into the token stream and make cur_token point to
6257    prev_token.  */
6258 static void
6259 intel_putback_token ()
6260 {
6261   intel_parser.op_string -= strlen (cur_token.str);
6262   free (cur_token.str);
6263   cur_token = prev_token;
6264
6265   /* Forget prev_token.  */
6266   prev_token.code = T_NIL;
6267   prev_token.reg = NULL;
6268   prev_token.str = NULL;
6269 }