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