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