gas/config/tc-i386.c

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