gas/config/tc-i386.c

   1 /* tc-i386.c -- Assemble code for the Intel 80386
   2    Copyright (C) 1989-2018 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3, or (at your option)
   9    any later version.
  10
  11    GAS is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with GAS; see the file COPYING.  If not, write to the Free
  18    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 /* Intel 80386 machine specific gas.
  22    Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
  23    x86_64 support by Jan Hubicka (jh@suse.cz)
  24    VIA PadLock support by Michal Ludvig (mludvig@suse.cz)
  25    Bugs & suggestions are completely welcome.  This is free software.
  26    Please help us make it better.  */
  27
  28 #include "as.h"
  29 #include "safe-ctype.h"
  30 #include "subsegs.h"
  31 #include "dwarf2dbg.h"
  32 #include "dw2gencfi.h"
  33 #include "elf/x86-64.h"
  34 #include "opcodes/i386-init.h"
  35
  36 #ifndef REGISTER_WARNINGS
  37 #define REGISTER_WARNINGS 1
  38 #endif
  39
  40 #ifndef INFER_ADDR_PREFIX
  41 #define INFER_ADDR_PREFIX 1
  42 #endif
  43
  44 #ifndef DEFAULT_ARCH
  45 #define DEFAULT_ARCH "i386"
  46 #endif
  47
  48 #ifndef INLINE
  49 #if __GNUC__ >= 2
  50 #define INLINE __inline__
  51 #else
  52 #define INLINE
  53 #endif
  54 #endif
  55
  56 /* Prefixes will be emitted in the order defined below.
  57    WAIT_PREFIX must be the first prefix since FWAIT is really is an
  58    instruction, and so must come before any prefixes.
  59    The preferred prefix order is SEG_PREFIX, ADDR_PREFIX, DATA_PREFIX,
  60    REP_PREFIX/HLE_PREFIX, LOCK_PREFIX.  */
  61 #define WAIT_PREFIX     0
  62 #define SEG_PREFIX      1
  63 #define ADDR_PREFIX     2
  64 #define DATA_PREFIX     3
  65 #define REP_PREFIX      4
  66 #define HLE_PREFIX      REP_PREFIX
  67 #define BND_PREFIX      REP_PREFIX
  68 #define LOCK_PREFIX     5
  69 #define REX_PREFIX      6       /* must come last.  */
  70 #define MAX_PREFIXES    7       /* max prefixes per opcode */
  71
  72 /* we define the syntax here (modulo base,index,scale syntax) */
  73 #define REGISTER_PREFIX '%'
  74 #define IMMEDIATE_PREFIX '$'
  75 #define ABSOLUTE_PREFIX '*'
  76
  77 /* these are the instruction mnemonic suffixes in AT&T syntax or
  78    memory operand size in Intel syntax.  */
  79 #define WORD_MNEM_SUFFIX  'w'
  80 #define BYTE_MNEM_SUFFIX  'b'
  81 #define SHORT_MNEM_SUFFIX 's'
  82 #define LONG_MNEM_SUFFIX  'l'
  83 #define QWORD_MNEM_SUFFIX  'q'
  84 #define XMMWORD_MNEM_SUFFIX  'x'
  85 #define YMMWORD_MNEM_SUFFIX 'y'
  86 #define ZMMWORD_MNEM_SUFFIX 'z'
  87 /* Intel Syntax.  Use a non-ascii letter since since it never appears
  88    in instructions.  */
  89 #define LONG_DOUBLE_MNEM_SUFFIX '\1'
  90
  91 #define END_OF_INSN '\0'
  92
  93 /*
  94   'templates' is for grouping together 'template' structures for opcodes
  95   of the same name.  This is only used for storing the insns in the grand
  96   ole hash table of insns.
  97   The templates themselves start at START and range up to (but not including)
  98   END.
  99   */
 100 typedef struct
 101 {
 102   const insn_template *start;
 103   const insn_template *end;
 104 }
 105 templates;
 106
 107 /* 386 operand encoding bytes:  see 386 book for details of this.  */
 108 typedef struct
 109 {
 110   unsigned int regmem;  /* codes register or memory operand */
 111   unsigned int reg;     /* codes register operand (or extended opcode) */
 112   unsigned int mode;    /* how to interpret regmem & reg */
 113 }
 114 modrm_byte;
 115
 116 /* x86-64 extension prefix.  */
 117 typedef int rex_byte;
 118
 119 /* 386 opcode byte to code indirect addressing.  */
 120 typedef struct
 121 {
 122   unsigned base;
 123   unsigned index;
 124   unsigned scale;
 125 }
 126 sib_byte;
 127
 128 /* x86 arch names, types and features */
 129 typedef struct
 130 {
 131   const char *name;             /* arch name */
 132   unsigned int len;             /* arch string length */
 133   enum processor_type type;     /* arch type */
 134   i386_cpu_flags flags;         /* cpu feature flags */
 135   unsigned int skip;            /* show_arch should skip this. */
 136 }
 137 arch_entry;
 138
 139 /* Used to turn off indicated flags.  */
 140 typedef struct
 141 {
 142   const char *name;             /* arch name */
 143   unsigned int len;             /* arch string length */
 144   i386_cpu_flags flags;         /* cpu feature flags */
 145 }
 146 noarch_entry;
 147
 148 static void update_code_flag (int, int);
 149 static void set_code_flag (int);
 150 static void set_16bit_gcc_code_flag (int);
 151 static void set_intel_syntax (int);
 152 static void set_intel_mnemonic (int);
 153 static void set_allow_index_reg (int);
 154 static void set_check (int);
 155 static void set_cpu_arch (int);
 156 #ifdef TE_PE
 157 static void pe_directive_secrel (int);
 158 #endif
 159 static void signed_cons (int);
 160 static char *output_invalid (int c);
 161 static int i386_finalize_immediate (segT, expressionS *, i386_operand_type,
 162                                     const char *);
 163 static int i386_finalize_displacement (segT, expressionS *, i386_operand_type,
 164                                        const char *);
 165 static int i386_att_operand (char *);
 166 static int i386_intel_operand (char *, int);
 167 static int i386_intel_simplify (expressionS *);
 168 static int i386_intel_parse_name (const char *, expressionS *);
 169 static const reg_entry *parse_register (char *, char **);
 170 static char *parse_insn (char *, char *);
 171 static char *parse_operands (char *, const char *);
 172 static void swap_operands (void);
 173 static void swap_2_operands (int, int);
 174 static void optimize_imm (void);
 175 static void optimize_disp (void);
 176 static const insn_template *match_template (char);
 177 static int check_string (void);
 178 static int process_suffix (void);
 179 static int check_byte_reg (void);
 180 static int check_long_reg (void);
 181 static int check_qword_reg (void);
 182 static int check_word_reg (void);
 183 static int finalize_imm (void);
 184 static int process_operands (void);
 185 static const seg_entry *build_modrm_byte (void);
 186 static void output_insn (void);
 187 static void output_imm (fragS *, offsetT);
 188 static void output_disp (fragS *, offsetT);
 189 #ifndef I386COFF
 190 static void s_bss (int);
 191 #endif
 192 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 193 static void handle_large_common (int small ATTRIBUTE_UNUSED);
 194 #endif
 195
 196 static const char *default_arch = DEFAULT_ARCH;
 197
 198 /* This struct describes rounding control and SAE in the instruction.  */
 199 struct RC_Operation
 200 {
 201   enum rc_type
 202     {
 203       rne = 0,
 204       rd,
 205       ru,
 206       rz,
 207       saeonly
 208     } type;
 209   int operand;
 210 };
 211
 212 static struct RC_Operation rc_op;
 213
 214 /* The struct describes masking, applied to OPERAND in the instruction.
 215    MASK is a pointer to the corresponding mask register.  ZEROING tells
 216    whether merging or zeroing mask is used.  */
 217 struct Mask_Operation
 218 {
 219   const reg_entry *mask;
 220   unsigned int zeroing;
 221   /* The operand where this operation is associated.  */
 222   int operand;
 223 };
 224
 225 static struct Mask_Operation mask_op;
 226
 227 /* The struct describes broadcasting, applied to OPERAND.  FACTOR is
 228    broadcast factor.  */
 229 struct Broadcast_Operation
 230 {
 231   /* Type of broadcast: no broadcast, {1to8}, or {1to16}.  */
 232   int type;
 233
 234   /* Index of broadcasted operand.  */
 235   int operand;
 236 };
 237
 238 static struct Broadcast_Operation broadcast_op;
 239
 240 /* VEX prefix.  */
 241 typedef struct
 242 {
 243   /* VEX prefix is either 2 byte or 3 byte.  EVEX is 4 byte.  */
 244   unsigned char bytes[4];
 245   unsigned int length;
 246   /* Destination or source register specifier.  */
 247   const reg_entry *register_specifier;
 248 } vex_prefix;
 249
 250 /* 'md_assemble ()' gathers together information and puts it into a
 251    i386_insn.  */
 252
 253 union i386_op
 254   {
 255     expressionS *disps;
 256     expressionS *imms;
 257     const reg_entry *regs;
 258   };
 259
 260 enum i386_error
 261   {
 262     operand_size_mismatch,
 263     operand_type_mismatch,
 264     register_type_mismatch,
 265     number_of_operands_mismatch,
 266     invalid_instruction_suffix,
 267     bad_imm4,
 268     old_gcc_only,
 269     unsupported_with_intel_mnemonic,
 270     unsupported_syntax,
 271     unsupported,
 272     invalid_vsib_address,
 273     invalid_vector_register_set,
 274     unsupported_vector_index_register,
 275     unsupported_broadcast,
 276     broadcast_not_on_src_operand,
 277     broadcast_needed,
 278     unsupported_masking,
 279     mask_not_on_destination,
 280     no_default_mask,
 281     unsupported_rc_sae,
 282     rc_sae_operand_not_last_imm,
 283     invalid_register_operand,
 284   };
 285
 286 struct _i386_insn
 287   {
 288     /* TM holds the template for the insn were currently assembling.  */
 289     insn_template tm;
 290
 291     /* SUFFIX holds the instruction size suffix for byte, word, dword
 292        or qword, if given.  */
 293     char suffix;
 294
 295     /* OPERANDS gives the number of given operands.  */
 296     unsigned int operands;
 297
 298     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
 299        of given register, displacement, memory operands and immediate
 300        operands.  */
 301     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
 302
 303     /* TYPES [i] is the type (see above #defines) which tells us how to
 304        use OP[i] for the corresponding operand.  */
 305     i386_operand_type types[MAX_OPERANDS];
 306
 307     /* Displacement expression, immediate expression, or register for each
 308        operand.  */
 309     union i386_op op[MAX_OPERANDS];
 310
 311     /* Flags for operands.  */
 312     unsigned int flags[MAX_OPERANDS];
 313 #define Operand_PCrel 1
 314
 315     /* Relocation type for operand */
 316     enum bfd_reloc_code_real reloc[MAX_OPERANDS];
 317
 318     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
 319        the base index byte below.  */
 320     const reg_entry *base_reg;
 321     const reg_entry *index_reg;
 322     unsigned int log2_scale_factor;
 323
 324     /* SEG gives the seg_entries of this insn.  They are zero unless
 325        explicit segment overrides are given.  */
 326     const seg_entry *seg[2];
 327
 328     /* Copied first memory operand string, for re-checking.  */
 329     char *memop1_string;
 330
 331     /* PREFIX holds all the given prefix opcodes (usually null).
 332        PREFIXES is the number of prefix opcodes.  */
 333     unsigned int prefixes;
 334     unsigned char prefix[MAX_PREFIXES];
 335
 336     /* RM and SIB are the modrm byte and the sib byte where the
 337        addressing modes of this insn are encoded.  */
 338     modrm_byte rm;
 339     rex_byte rex;
 340     rex_byte vrex;
 341     sib_byte sib;
 342     vex_prefix vex;
 343
 344     /* Masking attributes.  */
 345     struct Mask_Operation *mask;
 346
 347     /* Rounding control and SAE attributes.  */
 348     struct RC_Operation *rounding;
 349
 350     /* Broadcasting attributes.  */
 351     struct Broadcast_Operation *broadcast;
 352
 353     /* Compressed disp8*N attribute.  */
 354     unsigned int memshift;
 355
 356     /* Prefer load or store in encoding.  */
 357     enum
 358       {
 359         dir_encoding_default = 0,
 360         dir_encoding_load,
 361         dir_encoding_store
 362       } dir_encoding;
 363
 364     /* Prefer 8bit or 32bit displacement in encoding.  */
 365     enum
 366       {
 367         disp_encoding_default = 0,
 368         disp_encoding_8bit,
 369         disp_encoding_32bit
 370       } disp_encoding;
 371
 372     /* How to encode vector instructions.  */
 373     enum
 374       {
 375         vex_encoding_default = 0,
 376         vex_encoding_vex2,
 377         vex_encoding_vex3,
 378         vex_encoding_evex
 379       } vec_encoding;
 380
 381     /* REP prefix.  */
 382     const char *rep_prefix;
 383
 384     /* HLE prefix.  */
 385     const char *hle_prefix;
 386
 387     /* Have BND prefix.  */
 388     const char *bnd_prefix;
 389
 390     /* Have NOTRACK prefix.  */
 391     const char *notrack_prefix;
 392
 393     /* Error message.  */
 394     enum i386_error error;
 395   };
 396
 397 typedef struct _i386_insn i386_insn;
 398
 399 /* Link RC type with corresponding string, that'll be looked for in
 400    asm.  */
 401 struct RC_name
 402 {
 403   enum rc_type type;
 404   const char *name;
 405   unsigned int len;
 406 };
 407
 408 static const struct RC_name RC_NamesTable[] =
 409 {
 410   {  rne, STRING_COMMA_LEN ("rn-sae") },
 411   {  rd,  STRING_COMMA_LEN ("rd-sae") },
 412   {  ru,  STRING_COMMA_LEN ("ru-sae") },
 413   {  rz,  STRING_COMMA_LEN ("rz-sae") },
 414   {  saeonly,  STRING_COMMA_LEN ("sae") },
 415 };
 416
 417 /* List of chars besides those in app.c:symbol_chars that can start an
 418    operand.  Used to prevent the scrubber eating vital white-space.  */
 419 const char extra_symbol_chars[] = "*%-([{}"
 420 #ifdef LEX_AT
 421         "@"
 422 #endif
 423 #ifdef LEX_QM
 424         "?"
 425 #endif
 426         ;
 427
 428 #if (defined (TE_I386AIX)                               \
 429      || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
 430          && !defined (TE_GNU)                           \
 431          && !defined (TE_LINUX)                         \
 432          && !defined (TE_NACL)                          \
 433          && !defined (TE_NETWARE)                       \
 434          && !defined (TE_FreeBSD)                       \
 435          && !defined (TE_DragonFly)                     \
 436          && !defined (TE_NetBSD)))
 437 /* This array holds the chars that always start a comment.  If the
 438    pre-processor is disabled, these aren't very useful.  The option
 439    --divide will remove '/' from this list.  */
 440 const char *i386_comment_chars = "#/";
 441 #define SVR4_COMMENT_CHARS 1
 442 #define PREFIX_SEPARATOR '\\'
 443
 444 #else
 445 const char *i386_comment_chars = "#";
 446 #define PREFIX_SEPARATOR '/'
 447 #endif
 448
 449 /* This array holds the chars that only start a comment at the beginning of
 450    a line.  If the line seems to have the form '# 123 filename'
 451    .line and .file directives will appear in the pre-processed output.
 452    Note that input_file.c hand checks for '#' at the beginning of the
 453    first line of the input file.  This is because the compiler outputs
 454    #NO_APP at the beginning of its output.
 455    Also note that comments started like this one will always work if
 456    '/' isn't otherwise defined.  */
 457 const char line_comment_chars[] = "#/";
 458
 459 const char line_separator_chars[] = ";";
 460
 461 /* Chars that can be used to separate mant from exp in floating point
 462    nums.  */
 463 const char EXP_CHARS[] = "eE";
 464
 465 /* Chars that mean this number is a floating point constant
 466    As in 0f12.456
 467    or    0d1.2345e12.  */
 468 const char FLT_CHARS[] = "fFdDxX";
 469
 470 /* Tables for lexical analysis.  */
 471 static char mnemonic_chars[256];
 472 static char register_chars[256];
 473 static char operand_chars[256];
 474 static char identifier_chars[256];
 475 static char digit_chars[256];
 476
 477 /* Lexical macros.  */
 478 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 479 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 480 #define is_register_char(x) (register_chars[(unsigned char) x])
 481 #define is_space_char(x) ((x) == ' ')
 482 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 483 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 484
 485 /* All non-digit non-letter characters that may occur in an operand.  */
 486 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 487
 488 /* md_assemble() always leaves the strings it's passed unaltered.  To
 489    effect this we maintain a stack of saved characters that we've smashed
 490    with '\0's (indicating end of strings for various sub-fields of the
 491    assembler instruction).  */
 492 static char save_stack[32];
 493 static char *save_stack_p;
 494 #define END_STRING_AND_SAVE(s) \
 495         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 496 #define RESTORE_END_STRING(s) \
 497         do { *(s) = *--save_stack_p; } while (0)
 498
 499 /* The instruction we're assembling.  */
 500 static i386_insn i;
 501
 502 /* Possible templates for current insn.  */
 503 static const templates *current_templates;
 504
 505 /* Per instruction expressionS buffers: max displacements & immediates.  */
 506 static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
 507 static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
 508
 509 /* Current operand we are working on.  */
 510 static int this_operand = -1;
 511
 512 /* We support four different modes.  FLAG_CODE variable is used to distinguish
 513    these.  */
 514
 515 enum flag_code {
 516         CODE_32BIT,
 517         CODE_16BIT,
 518         CODE_64BIT };
 519
 520 static enum flag_code flag_code;
 521 static unsigned int object_64bit;
 522 static unsigned int disallow_64bit_reloc;
 523 static int use_rela_relocations = 0;
 524
 525 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
 526      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
 527      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
 528
 529 /* The ELF ABI to use.  */
 530 enum x86_elf_abi
 531 {
 532   I386_ABI,
 533   X86_64_ABI,
 534   X86_64_X32_ABI
 535 };
 536
 537 static enum x86_elf_abi x86_elf_abi = I386_ABI;
 538 #endif
 539
 540 #if defined (TE_PE) || defined (TE_PEP)
 541 /* Use big object file format.  */
 542 static int use_big_obj = 0;
 543 #endif
 544
 545 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 546 /* 1 if generating code for a shared library.  */
 547 static int shared = 0;
 548 #endif
 549
 550 /* 1 for intel syntax,
 551    0 if att syntax.  */
 552 static int intel_syntax = 0;
 553
 554 /* 1 for Intel64 ISA,
 555    0 if AMD64 ISA.  */
 556 static int intel64;
 557
 558 /* 1 for intel mnemonic,
 559    0 if att mnemonic.  */
 560 static int intel_mnemonic = !SYSV386_COMPAT;
 561
 562 /* 1 if support old (<= 2.8.1) versions of gcc.  */
 563 static int old_gcc = OLDGCC_COMPAT;
 564
 565 /* 1 if pseudo registers are permitted.  */
 566 static int allow_pseudo_reg = 0;
 567
 568 /* 1 if register prefix % not required.  */
 569 static int allow_naked_reg = 0;
 570
 571 /* 1 if the assembler should add BND prefix for all control-transferring
 572    instructions supporting it, even if this prefix wasn't specified
 573    explicitly.  */
 574 static int add_bnd_prefix = 0;
 575
 576 /* 1 if pseudo index register, eiz/riz, is allowed .  */
 577 static int allow_index_reg = 0;
 578
 579 /* 1 if the assembler should ignore LOCK prefix, even if it was
 580    specified explicitly.  */
 581 static int omit_lock_prefix = 0;
 582
 583 /* 1 if the assembler should encode lfence, mfence, and sfence as
 584    "lock addl $0, (%{re}sp)".  */
 585 static int avoid_fence = 0;
 586
 587 /* 1 if the assembler should generate relax relocations.  */
 588
 589 static int generate_relax_relocations
 590   = DEFAULT_GENERATE_X86_RELAX_RELOCATIONS;
 591
 592 static enum check_kind
 593   {
 594     check_none = 0,
 595     check_warning,
 596     check_error
 597   }
 598 sse_check, operand_check = check_warning;
 599
 600 /* Register prefix used for error message.  */
 601 static const char *register_prefix = "%";
 602
 603 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
 604    leave, push, and pop instructions so that gcc has the same stack
 605    frame as in 32 bit mode.  */
 606 static char stackop_size = '\0';
 607
 608 /* Non-zero to optimize code alignment.  */
 609 int optimize_align_code = 1;
 610
 611 /* Non-zero to quieten some warnings.  */
 612 static int quiet_warnings = 0;
 613
 614 /* CPU name.  */
 615 static const char *cpu_arch_name = NULL;
 616 static char *cpu_sub_arch_name = NULL;
 617
 618 /* CPU feature flags.  */
 619 static i386_cpu_flags cpu_arch_flags = CPU_UNKNOWN_FLAGS;
 620
 621 /* If we have selected a cpu we are generating instructions for.  */
 622 static int cpu_arch_tune_set = 0;
 623
 624 /* Cpu we are generating instructions for.  */
 625 enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
 626
 627 /* CPU feature flags of cpu we are generating instructions for.  */
 628 static i386_cpu_flags cpu_arch_tune_flags;
 629
 630 /* CPU instruction set architecture used.  */
 631 enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
 632
 633 /* CPU feature flags of instruction set architecture used.  */
 634 i386_cpu_flags cpu_arch_isa_flags;
 635
 636 /* If set, conditional jumps are not automatically promoted to handle
 637    larger than a byte offset.  */
 638 static unsigned int no_cond_jump_promotion = 0;
 639
 640 /* Encode SSE instructions with VEX prefix.  */
 641 static unsigned int sse2avx;
 642
 643 /* Encode scalar AVX instructions with specific vector length.  */
 644 static enum
 645   {
 646     vex128 = 0,
 647     vex256
 648   } avxscalar;
 649
 650 /* Encode scalar EVEX LIG instructions with specific vector length.  */
 651 static enum
 652   {
 653     evexl128 = 0,
 654     evexl256,
 655     evexl512
 656   } evexlig;
 657
 658 /* Encode EVEX WIG instructions with specific evex.w.  */
 659 static enum
 660   {
 661     evexw0 = 0,
 662     evexw1
 663   } evexwig;
 664
 665 /* Value to encode in EVEX RC bits, for SAE-only instructions.  */
 666 static enum rc_type evexrcig = rne;
 667
 668 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 669 static symbolS *GOT_symbol;
 670
 671 /* The dwarf2 return column, adjusted for 32 or 64 bit.  */
 672 unsigned int x86_dwarf2_return_column;
 673
 674 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
 675 int x86_cie_data_alignment;
 676
 677 /* Interface to relax_segment.
 678    There are 3 major relax states for 386 jump insns because the
 679    different types of jumps add different sizes to frags when we're
 680    figuring out what sort of jump to choose to reach a given label.  */
 681
 682 /* Types.  */
 683 #define UNCOND_JUMP 0
 684 #define COND_JUMP 1
 685 #define COND_JUMP86 2
 686
 687 /* Sizes.  */
 688 #define CODE16  1
 689 #define SMALL   0
 690 #define SMALL16 (SMALL | CODE16)
 691 #define BIG     2
 692 #define BIG16   (BIG | CODE16)
 693
 694 #ifndef INLINE
 695 #ifdef __GNUC__
 696 #define INLINE __inline__
 697 #else
 698 #define INLINE
 699 #endif
 700 #endif
 701
 702 #define ENCODE_RELAX_STATE(type, size) \
 703   ((relax_substateT) (((type) << 2) | (size)))
 704 #define TYPE_FROM_RELAX_STATE(s) \
 705   ((s) >> 2)
 706 #define DISP_SIZE_FROM_RELAX_STATE(s) \
 707     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
 708
 709 /* This table is used by relax_frag to promote short jumps to long
 710    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 711    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 712    don't allow a short jump in a 32 bit code segment to be promoted to
 713    a 16 bit offset jump because it's slower (requires data size
 714    prefix), and doesn't work, unless the destination is in the bottom
 715    64k of the code segment (The top 16 bits of eip are zeroed).  */
 716
 717 const relax_typeS md_relax_table[] =
 718 {
 719   /* The fields are:
 720      1) most positive reach of this state,
 721      2) most negative reach of this state,
 722      3) how many bytes this mode will have in the variable part of the frag
 723      4) which index into the table to try if we can't fit into this one.  */
 724
 725   /* UNCOND_JUMP states.  */
 726   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 727   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 728   /* dword jmp adds 4 bytes to frag:
 729      0 extra opcode bytes, 4 displacement bytes.  */
 730   {0, 0, 4, 0},
 731   /* word jmp adds 2 byte2 to frag:
 732      0 extra opcode bytes, 2 displacement bytes.  */
 733   {0, 0, 2, 0},
 734
 735   /* COND_JUMP states.  */
 736   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 737   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 738   /* dword conditionals adds 5 bytes to frag:
 739      1 extra opcode byte, 4 displacement bytes.  */
 740   {0, 0, 5, 0},
 741   /* word conditionals add 3 bytes to frag:
 742      1 extra opcode byte, 2 displacement bytes.  */
 743   {0, 0, 3, 0},
 744
 745   /* COND_JUMP86 states.  */
 746   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
 747   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
 748   /* dword conditionals adds 5 bytes to frag:
 749      1 extra opcode byte, 4 displacement bytes.  */
 750   {0, 0, 5, 0},
 751   /* word conditionals add 4 bytes to frag:
 752      1 displacement byte and a 3 byte long branch insn.  */
 753   {0, 0, 4, 0}
 754 };
 755
 756 static const arch_entry cpu_arch[] =
 757 {
 758   /* Do not replace the first two entries - i386_target_format()
 759      relies on them being there in this order.  */
 760   { STRING_COMMA_LEN ("generic32"), PROCESSOR_GENERIC32,
 761     CPU_GENERIC32_FLAGS, 0 },
 762   { STRING_COMMA_LEN ("generic64"), PROCESSOR_GENERIC64,
 763     CPU_GENERIC64_FLAGS, 0 },
 764   { STRING_COMMA_LEN ("i8086"), PROCESSOR_UNKNOWN,
 765     CPU_NONE_FLAGS, 0 },
 766   { STRING_COMMA_LEN ("i186"), PROCESSOR_UNKNOWN,
 767     CPU_I186_FLAGS, 0 },
 768   { STRING_COMMA_LEN ("i286"), PROCESSOR_UNKNOWN,
 769     CPU_I286_FLAGS, 0 },
 770   { STRING_COMMA_LEN ("i386"), PROCESSOR_I386,
 771     CPU_I386_FLAGS, 0 },
 772   { STRING_COMMA_LEN ("i486"), PROCESSOR_I486,
 773     CPU_I486_FLAGS, 0 },
 774   { STRING_COMMA_LEN ("i586"), PROCESSOR_PENTIUM,
 775     CPU_I586_FLAGS, 0 },
 776   { STRING_COMMA_LEN ("i686"), PROCESSOR_PENTIUMPRO,
 777     CPU_I686_FLAGS, 0 },
 778   { STRING_COMMA_LEN ("pentium"), PROCESSOR_PENTIUM,
 779     CPU_I586_FLAGS, 0 },
 780   { STRING_COMMA_LEN ("pentiumpro"), PROCESSOR_PENTIUMPRO,
 781     CPU_PENTIUMPRO_FLAGS, 0 },
 782   { STRING_COMMA_LEN ("pentiumii"), PROCESSOR_PENTIUMPRO,
 783     CPU_P2_FLAGS, 0 },
 784   { STRING_COMMA_LEN ("pentiumiii"),PROCESSOR_PENTIUMPRO,
 785     CPU_P3_FLAGS, 0 },
 786   { STRING_COMMA_LEN ("pentium4"), PROCESSOR_PENTIUM4,
 787     CPU_P4_FLAGS, 0 },
 788   { STRING_COMMA_LEN ("prescott"), PROCESSOR_NOCONA,
 789     CPU_CORE_FLAGS, 0 },
 790   { STRING_COMMA_LEN ("nocona"), PROCESSOR_NOCONA,
 791     CPU_NOCONA_FLAGS, 0 },
 792   { STRING_COMMA_LEN ("yonah"), PROCESSOR_CORE,
 793     CPU_CORE_FLAGS, 1 },
 794   { STRING_COMMA_LEN ("core"), PROCESSOR_CORE,
 795     CPU_CORE_FLAGS, 0 },
 796   { STRING_COMMA_LEN ("merom"), PROCESSOR_CORE2,
 797     CPU_CORE2_FLAGS, 1 },
 798   { STRING_COMMA_LEN ("core2"), PROCESSOR_CORE2,
 799     CPU_CORE2_FLAGS, 0 },
 800   { STRING_COMMA_LEN ("corei7"), PROCESSOR_COREI7,
 801     CPU_COREI7_FLAGS, 0 },
 802   { STRING_COMMA_LEN ("l1om"), PROCESSOR_L1OM,
 803     CPU_L1OM_FLAGS, 0 },
 804   { STRING_COMMA_LEN ("k1om"), PROCESSOR_K1OM,
 805     CPU_K1OM_FLAGS, 0 },
 806   { STRING_COMMA_LEN ("iamcu"), PROCESSOR_IAMCU,
 807     CPU_IAMCU_FLAGS, 0 },
 808   { STRING_COMMA_LEN ("k6"), PROCESSOR_K6,
 809     CPU_K6_FLAGS, 0 },
 810   { STRING_COMMA_LEN ("k6_2"), PROCESSOR_K6,
 811     CPU_K6_2_FLAGS, 0 },
 812   { STRING_COMMA_LEN ("athlon"), PROCESSOR_ATHLON,
 813     CPU_ATHLON_FLAGS, 0 },
 814   { STRING_COMMA_LEN ("sledgehammer"), PROCESSOR_K8,
 815     CPU_K8_FLAGS, 1 },
 816   { STRING_COMMA_LEN ("opteron"), PROCESSOR_K8,
 817     CPU_K8_FLAGS, 0 },
 818   { STRING_COMMA_LEN ("k8"), PROCESSOR_K8,
 819     CPU_K8_FLAGS, 0 },
 820   { STRING_COMMA_LEN ("amdfam10"), PROCESSOR_AMDFAM10,
 821     CPU_AMDFAM10_FLAGS, 0 },
 822   { STRING_COMMA_LEN ("bdver1"), PROCESSOR_BD,
 823     CPU_BDVER1_FLAGS, 0 },
 824   { STRING_COMMA_LEN ("bdver2"), PROCESSOR_BD,
 825     CPU_BDVER2_FLAGS, 0 },
 826   { STRING_COMMA_LEN ("bdver3"), PROCESSOR_BD,
 827     CPU_BDVER3_FLAGS, 0 },
 828   { STRING_COMMA_LEN ("bdver4"), PROCESSOR_BD,
 829     CPU_BDVER4_FLAGS, 0 },
 830   { STRING_COMMA_LEN ("znver1"), PROCESSOR_ZNVER,
 831     CPU_ZNVER1_FLAGS, 0 },
 832   { STRING_COMMA_LEN ("btver1"), PROCESSOR_BT,
 833     CPU_BTVER1_FLAGS, 0 },
 834   { STRING_COMMA_LEN ("btver2"), PROCESSOR_BT,
 835     CPU_BTVER2_FLAGS, 0 },
 836   { STRING_COMMA_LEN (".8087"), PROCESSOR_UNKNOWN,
 837     CPU_8087_FLAGS, 0 },
 838   { STRING_COMMA_LEN (".287"), PROCESSOR_UNKNOWN,
 839     CPU_287_FLAGS, 0 },
 840   { STRING_COMMA_LEN (".387"), PROCESSOR_UNKNOWN,
 841     CPU_387_FLAGS, 0 },
 842   { STRING_COMMA_LEN (".687"), PROCESSOR_UNKNOWN,
 843     CPU_687_FLAGS, 0 },
 844   { STRING_COMMA_LEN (".mmx"), PROCESSOR_UNKNOWN,
 845     CPU_MMX_FLAGS, 0 },
 846   { STRING_COMMA_LEN (".sse"), PROCESSOR_UNKNOWN,
 847     CPU_SSE_FLAGS, 0 },
 848   { STRING_COMMA_LEN (".sse2"), PROCESSOR_UNKNOWN,
 849     CPU_SSE2_FLAGS, 0 },
 850   { STRING_COMMA_LEN (".sse3"), PROCESSOR_UNKNOWN,
 851     CPU_SSE3_FLAGS, 0 },
 852   { STRING_COMMA_LEN (".ssse3"), PROCESSOR_UNKNOWN,
 853     CPU_SSSE3_FLAGS, 0 },
 854   { STRING_COMMA_LEN (".sse4.1"), PROCESSOR_UNKNOWN,
 855     CPU_SSE4_1_FLAGS, 0 },
 856   { STRING_COMMA_LEN (".sse4.2"), PROCESSOR_UNKNOWN,
 857     CPU_SSE4_2_FLAGS, 0 },
 858   { STRING_COMMA_LEN (".sse4"), PROCESSOR_UNKNOWN,
 859     CPU_SSE4_2_FLAGS, 0 },
 860   { STRING_COMMA_LEN (".avx"), PROCESSOR_UNKNOWN,
 861     CPU_AVX_FLAGS, 0 },
 862   { STRING_COMMA_LEN (".avx2"), PROCESSOR_UNKNOWN,
 863     CPU_AVX2_FLAGS, 0 },
 864   { STRING_COMMA_LEN (".avx512f"), PROCESSOR_UNKNOWN,
 865     CPU_AVX512F_FLAGS, 0 },
 866   { STRING_COMMA_LEN (".avx512cd"), PROCESSOR_UNKNOWN,
 867     CPU_AVX512CD_FLAGS, 0 },
 868   { STRING_COMMA_LEN (".avx512er"), PROCESSOR_UNKNOWN,
 869     CPU_AVX512ER_FLAGS, 0 },
 870   { STRING_COMMA_LEN (".avx512pf"), PROCESSOR_UNKNOWN,
 871     CPU_AVX512PF_FLAGS, 0 },
 872   { STRING_COMMA_LEN (".avx512dq"), PROCESSOR_UNKNOWN,
 873     CPU_AVX512DQ_FLAGS, 0 },
 874   { STRING_COMMA_LEN (".avx512bw"), PROCESSOR_UNKNOWN,
 875     CPU_AVX512BW_FLAGS, 0 },
 876   { STRING_COMMA_LEN (".avx512vl"), PROCESSOR_UNKNOWN,
 877     CPU_AVX512VL_FLAGS, 0 },
 878   { STRING_COMMA_LEN (".vmx"), PROCESSOR_UNKNOWN,
 879     CPU_VMX_FLAGS, 0 },
 880   { STRING_COMMA_LEN (".vmfunc"), PROCESSOR_UNKNOWN,
 881     CPU_VMFUNC_FLAGS, 0 },
 882   { STRING_COMMA_LEN (".smx"), PROCESSOR_UNKNOWN,
 883     CPU_SMX_FLAGS, 0 },
 884   { STRING_COMMA_LEN (".xsave"), PROCESSOR_UNKNOWN,
 885     CPU_XSAVE_FLAGS, 0 },
 886   { STRING_COMMA_LEN (".xsaveopt"), PROCESSOR_UNKNOWN,
 887     CPU_XSAVEOPT_FLAGS, 0 },
 888   { STRING_COMMA_LEN (".xsavec"), PROCESSOR_UNKNOWN,
 889     CPU_XSAVEC_FLAGS, 0 },
 890   { STRING_COMMA_LEN (".xsaves"), PROCESSOR_UNKNOWN,
 891     CPU_XSAVES_FLAGS, 0 },
 892   { STRING_COMMA_LEN (".aes"), PROCESSOR_UNKNOWN,
 893     CPU_AES_FLAGS, 0 },
 894   { STRING_COMMA_LEN (".pclmul"), PROCESSOR_UNKNOWN,
 895     CPU_PCLMUL_FLAGS, 0 },
 896   { STRING_COMMA_LEN (".clmul"), PROCESSOR_UNKNOWN,
 897     CPU_PCLMUL_FLAGS, 1 },
 898   { STRING_COMMA_LEN (".fsgsbase"), PROCESSOR_UNKNOWN,
 899     CPU_FSGSBASE_FLAGS, 0 },
 900   { STRING_COMMA_LEN (".rdrnd"), PROCESSOR_UNKNOWN,
 901     CPU_RDRND_FLAGS, 0 },
 902   { STRING_COMMA_LEN (".f16c"), PROCESSOR_UNKNOWN,
 903     CPU_F16C_FLAGS, 0 },
 904   { STRING_COMMA_LEN (".bmi2"), PROCESSOR_UNKNOWN,
 905     CPU_BMI2_FLAGS, 0 },
 906   { STRING_COMMA_LEN (".fma"), PROCESSOR_UNKNOWN,
 907     CPU_FMA_FLAGS, 0 },
 908   { STRING_COMMA_LEN (".fma4"), PROCESSOR_UNKNOWN,
 909     CPU_FMA4_FLAGS, 0 },
 910   { STRING_COMMA_LEN (".xop"), PROCESSOR_UNKNOWN,
 911     CPU_XOP_FLAGS, 0 },
 912   { STRING_COMMA_LEN (".lwp"), PROCESSOR_UNKNOWN,
 913     CPU_LWP_FLAGS, 0 },
 914   { STRING_COMMA_LEN (".movbe"), PROCESSOR_UNKNOWN,
 915     CPU_MOVBE_FLAGS, 0 },
 916   { STRING_COMMA_LEN (".cx16"), PROCESSOR_UNKNOWN,
 917     CPU_CX16_FLAGS, 0 },
 918   { STRING_COMMA_LEN (".ept"), PROCESSOR_UNKNOWN,
 919     CPU_EPT_FLAGS, 0 },
 920   { STRING_COMMA_LEN (".lzcnt"), PROCESSOR_UNKNOWN,
 921     CPU_LZCNT_FLAGS, 0 },
 922   { STRING_COMMA_LEN (".hle"), PROCESSOR_UNKNOWN,
 923     CPU_HLE_FLAGS, 0 },
 924   { STRING_COMMA_LEN (".rtm"), PROCESSOR_UNKNOWN,
 925     CPU_RTM_FLAGS, 0 },
 926   { STRING_COMMA_LEN (".invpcid"), PROCESSOR_UNKNOWN,
 927     CPU_INVPCID_FLAGS, 0 },
 928   { STRING_COMMA_LEN (".clflush"), PROCESSOR_UNKNOWN,
 929     CPU_CLFLUSH_FLAGS, 0 },
 930   { STRING_COMMA_LEN (".nop"), PROCESSOR_UNKNOWN,
 931     CPU_NOP_FLAGS, 0 },
 932   { STRING_COMMA_LEN (".syscall"), PROCESSOR_UNKNOWN,
 933     CPU_SYSCALL_FLAGS, 0 },
 934   { STRING_COMMA_LEN (".rdtscp"), PROCESSOR_UNKNOWN,
 935     CPU_RDTSCP_FLAGS, 0 },
 936   { STRING_COMMA_LEN (".3dnow"), PROCESSOR_UNKNOWN,
 937     CPU_3DNOW_FLAGS, 0 },
 938   { STRING_COMMA_LEN (".3dnowa"), PROCESSOR_UNKNOWN,
 939     CPU_3DNOWA_FLAGS, 0 },
 940   { STRING_COMMA_LEN (".padlock"), PROCESSOR_UNKNOWN,
 941     CPU_PADLOCK_FLAGS, 0 },
 942   { STRING_COMMA_LEN (".pacifica"), PROCESSOR_UNKNOWN,
 943     CPU_SVME_FLAGS, 1 },
 944   { STRING_COMMA_LEN (".svme"), PROCESSOR_UNKNOWN,
 945     CPU_SVME_FLAGS, 0 },
 946   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
 947     CPU_SSE4A_FLAGS, 0 },
 948   { STRING_COMMA_LEN (".abm"), PROCESSOR_UNKNOWN,
 949     CPU_ABM_FLAGS, 0 },
 950   { STRING_COMMA_LEN (".bmi"), PROCESSOR_UNKNOWN,
 951     CPU_BMI_FLAGS, 0 },
 952   { STRING_COMMA_LEN (".tbm"), PROCESSOR_UNKNOWN,
 953     CPU_TBM_FLAGS, 0 },
 954   { STRING_COMMA_LEN (".adx"), PROCESSOR_UNKNOWN,
 955     CPU_ADX_FLAGS, 0 },
 956   { STRING_COMMA_LEN (".rdseed"), PROCESSOR_UNKNOWN,
 957     CPU_RDSEED_FLAGS, 0 },
 958   { STRING_COMMA_LEN (".prfchw"), PROCESSOR_UNKNOWN,
 959     CPU_PRFCHW_FLAGS, 0 },
 960   { STRING_COMMA_LEN (".smap"), PROCESSOR_UNKNOWN,
 961     CPU_SMAP_FLAGS, 0 },
 962   { STRING_COMMA_LEN (".mpx"), PROCESSOR_UNKNOWN,
 963     CPU_MPX_FLAGS, 0 },
 964   { STRING_COMMA_LEN (".sha"), PROCESSOR_UNKNOWN,
 965     CPU_SHA_FLAGS, 0 },
 966   { STRING_COMMA_LEN (".clflushopt"), PROCESSOR_UNKNOWN,
 967     CPU_CLFLUSHOPT_FLAGS, 0 },
 968   { STRING_COMMA_LEN (".prefetchwt1"), PROCESSOR_UNKNOWN,
 969     CPU_PREFETCHWT1_FLAGS, 0 },
 970   { STRING_COMMA_LEN (".se1"), PROCESSOR_UNKNOWN,
 971     CPU_SE1_FLAGS, 0 },
 972   { STRING_COMMA_LEN (".clwb"), PROCESSOR_UNKNOWN,
 973     CPU_CLWB_FLAGS, 0 },
 974   { STRING_COMMA_LEN (".avx512ifma"), PROCESSOR_UNKNOWN,
 975     CPU_AVX512IFMA_FLAGS, 0 },
 976   { STRING_COMMA_LEN (".avx512vbmi"), PROCESSOR_UNKNOWN,
 977     CPU_AVX512VBMI_FLAGS, 0 },
 978   { STRING_COMMA_LEN (".avx512_4fmaps"), PROCESSOR_UNKNOWN,
 979     CPU_AVX512_4FMAPS_FLAGS, 0 },
 980   { STRING_COMMA_LEN (".avx512_4vnniw"), PROCESSOR_UNKNOWN,
 981     CPU_AVX512_4VNNIW_FLAGS, 0 },
 982   { STRING_COMMA_LEN (".avx512_vpopcntdq"), PROCESSOR_UNKNOWN,
 983     CPU_AVX512_VPOPCNTDQ_FLAGS, 0 },
 984   { STRING_COMMA_LEN (".avx512_vbmi2"), PROCESSOR_UNKNOWN,
 985     CPU_AVX512_VBMI2_FLAGS, 0 },
 986   { STRING_COMMA_LEN (".avx512_vnni"), PROCESSOR_UNKNOWN,
 987     CPU_AVX512_VNNI_FLAGS, 0 },
 988   { STRING_COMMA_LEN (".avx512_bitalg"), PROCESSOR_UNKNOWN,
 989     CPU_AVX512_BITALG_FLAGS, 0 },
 990   { STRING_COMMA_LEN (".clzero"), PROCESSOR_UNKNOWN,
 991     CPU_CLZERO_FLAGS, 0 },
 992   { STRING_COMMA_LEN (".mwaitx"), PROCESSOR_UNKNOWN,
 993     CPU_MWAITX_FLAGS, 0 },
 994   { STRING_COMMA_LEN (".ospke"), PROCESSOR_UNKNOWN,
 995     CPU_OSPKE_FLAGS, 0 },
 996   { STRING_COMMA_LEN (".rdpid"), PROCESSOR_UNKNOWN,
 997     CPU_RDPID_FLAGS, 0 },
 998   { STRING_COMMA_LEN (".ptwrite"), PROCESSOR_UNKNOWN,
 999     CPU_PTWRITE_FLAGS, 0 },
1000   { STRING_COMMA_LEN (".ibt"), PROCESSOR_UNKNOWN,
1001     CPU_IBT_FLAGS, 0 },
1002   { STRING_COMMA_LEN (".shstk"), PROCESSOR_UNKNOWN,
1003     CPU_SHSTK_FLAGS, 0 },
1004   { STRING_COMMA_LEN (".gfni"), PROCESSOR_UNKNOWN,
1005     CPU_GFNI_FLAGS, 0 },
1006   { STRING_COMMA_LEN (".vaes"), PROCESSOR_UNKNOWN,
1007     CPU_VAES_FLAGS, 0 },
1008   { STRING_COMMA_LEN (".vpclmulqdq"), PROCESSOR_UNKNOWN,
1009     CPU_VPCLMULQDQ_FLAGS, 0 },
1010   { STRING_COMMA_LEN (".wbnoinvd"), PROCESSOR_UNKNOWN,
1011     CPU_WBNOINVD_FLAGS, 0 },
1012   { STRING_COMMA_LEN (".pconfig"), PROCESSOR_UNKNOWN,
1013     CPU_PCONFIG_FLAGS, 0 },
1014 };
1015
1016 static const noarch_entry cpu_noarch[] =
1017 {
1018   { STRING_COMMA_LEN ("no87"),  CPU_ANY_X87_FLAGS },
1019   { STRING_COMMA_LEN ("no287"),  CPU_ANY_287_FLAGS },
1020   { STRING_COMMA_LEN ("no387"),  CPU_ANY_387_FLAGS },
1021   { STRING_COMMA_LEN ("no687"),  CPU_ANY_687_FLAGS },
1022   { STRING_COMMA_LEN ("nommx"),  CPU_ANY_MMX_FLAGS },
1023   { STRING_COMMA_LEN ("nosse"),  CPU_ANY_SSE_FLAGS },
1024   { STRING_COMMA_LEN ("nosse2"),  CPU_ANY_SSE2_FLAGS },
1025   { STRING_COMMA_LEN ("nosse3"),  CPU_ANY_SSE3_FLAGS },
1026   { STRING_COMMA_LEN ("nossse3"),  CPU_ANY_SSSE3_FLAGS },
1027   { STRING_COMMA_LEN ("nosse4.1"),  CPU_ANY_SSE4_1_FLAGS },
1028   { STRING_COMMA_LEN ("nosse4.2"),  CPU_ANY_SSE4_2_FLAGS },
1029   { STRING_COMMA_LEN ("nosse4"),  CPU_ANY_SSE4_1_FLAGS },
1030   { STRING_COMMA_LEN ("noavx"),  CPU_ANY_AVX_FLAGS },
1031   { STRING_COMMA_LEN ("noavx2"),  CPU_ANY_AVX2_FLAGS },
1032   { STRING_COMMA_LEN ("noavx512f"), CPU_ANY_AVX512F_FLAGS },
1033   { STRING_COMMA_LEN ("noavx512cd"), CPU_ANY_AVX512CD_FLAGS },
1034   { STRING_COMMA_LEN ("noavx512er"), CPU_ANY_AVX512ER_FLAGS },
1035   { STRING_COMMA_LEN ("noavx512pf"), CPU_ANY_AVX512PF_FLAGS },
1036   { STRING_COMMA_LEN ("noavx512dq"), CPU_ANY_AVX512DQ_FLAGS },
1037   { STRING_COMMA_LEN ("noavx512bw"), CPU_ANY_AVX512BW_FLAGS },
1038   { STRING_COMMA_LEN ("noavx512vl"), CPU_ANY_AVX512VL_FLAGS },
1039   { STRING_COMMA_LEN ("noavx512ifma"), CPU_ANY_AVX512IFMA_FLAGS },
1040   { STRING_COMMA_LEN ("noavx512vbmi"), CPU_ANY_AVX512VBMI_FLAGS },
1041   { STRING_COMMA_LEN ("noavx512_4fmaps"), CPU_ANY_AVX512_4FMAPS_FLAGS },
1042   { STRING_COMMA_LEN ("noavx512_4vnniw"), CPU_ANY_AVX512_4VNNIW_FLAGS },
1043   { STRING_COMMA_LEN ("noavx512_vpopcntdq"), CPU_ANY_AVX512_VPOPCNTDQ_FLAGS },
1044   { STRING_COMMA_LEN ("noavx512_vbmi2"), CPU_ANY_AVX512_VBMI2_FLAGS },
1045   { STRING_COMMA_LEN ("noavx512_vnni"), CPU_ANY_AVX512_VNNI_FLAGS },
1046   { STRING_COMMA_LEN ("noavx512_bitalg"), CPU_ANY_AVX512_BITALG_FLAGS },
1047   { STRING_COMMA_LEN ("noibt"), CPU_ANY_IBT_FLAGS },
1048   { STRING_COMMA_LEN ("noshstk"), CPU_ANY_SHSTK_FLAGS },
1049 };
1050
1051 #ifdef I386COFF
1052 /* Like s_lcomm_internal in gas/read.c but the alignment string
1053    is allowed to be optional.  */
1054
1055 static symbolS *
1056 pe_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
1057 {
1058   addressT align = 0;
1059
1060   SKIP_WHITESPACE ();
1061
1062   if (needs_align
1063       && *input_line_pointer == ',')
1064     {
1065       align = parse_align (needs_align - 1);
1066
1067       if (align == (addressT) -1)
1068         return NULL;
1069     }
1070   else
1071     {
1072       if (size >= 8)
1073         align = 3;
1074       else if (size >= 4)
1075         align = 2;
1076       else if (size >= 2)
1077         align = 1;
1078       else
1079         align = 0;
1080     }
1081
1082   bss_alloc (symbolP, size, align);
1083   return symbolP;
1084 }
1085
1086 static void
1087 pe_lcomm (int needs_align)
1088 {
1089   s_comm_internal (needs_align * 2, pe_lcomm_internal);
1090 }
1091 #endif
1092
1093 const pseudo_typeS md_pseudo_table[] =
1094 {
1095 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
1096   {"align", s_align_bytes, 0},
1097 #else
1098   {"align", s_align_ptwo, 0},
1099 #endif
1100   {"arch", set_cpu_arch, 0},
1101 #ifndef I386COFF
1102   {"bss", s_bss, 0},
1103 #else
1104   {"lcomm", pe_lcomm, 1},
1105 #endif
1106   {"ffloat", float_cons, 'f'},
1107   {"dfloat", float_cons, 'd'},
1108   {"tfloat", float_cons, 'x'},
1109   {"value", cons, 2},
1110   {"slong", signed_cons, 4},
1111   {"noopt", s_ignore, 0},
1112   {"optim", s_ignore, 0},
1113   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
1114   {"code16", set_code_flag, CODE_16BIT},
1115   {"code32", set_code_flag, CODE_32BIT},
1116 #ifdef BFD64
1117   {"code64", set_code_flag, CODE_64BIT},
1118 #endif
1119   {"intel_syntax", set_intel_syntax, 1},
1120   {"att_syntax", set_intel_syntax, 0},
1121   {"intel_mnemonic", set_intel_mnemonic, 1},
1122   {"att_mnemonic", set_intel_mnemonic, 0},
1123   {"allow_index_reg", set_allow_index_reg, 1},
1124   {"disallow_index_reg", set_allow_index_reg, 0},
1125   {"sse_check", set_check, 0},
1126   {"operand_check", set_check, 1},
1127 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1128   {"largecomm", handle_large_common, 0},
1129 #else
1130   {"file", dwarf2_directive_file, 0},
1131   {"loc", dwarf2_directive_loc, 0},
1132   {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
1133 #endif
1134 #ifdef TE_PE
1135   {"secrel32", pe_directive_secrel, 0},
1136 #endif
1137   {0, 0, 0}
1138 };
1139
1140 /* For interface with expression ().  */
1141 extern char *input_line_pointer;
1142
1143 /* Hash table for instruction mnemonic lookup.  */
1144 static struct hash_control *op_hash;
1145
1146 /* Hash table for register lookup.  */
1147 static struct hash_control *reg_hash;
1148 \f
1149 void
1150 i386_align_code (fragS *fragP, int count)
1151 {
1152   /* Various efficient no-op patterns for aligning code labels.
1153      Note: Don't try to assemble the instructions in the comments.
1154      0L and 0w are not legal.  */
1155   static const unsigned char f32_1[] =
1156     {0x90};                                     /* nop                  */
1157   static const unsigned char f32_2[] =
1158     {0x66,0x90};                                /* xchg %ax,%ax */
1159   static const unsigned char f32_3[] =
1160     {0x8d,0x76,0x00};                           /* leal 0(%esi),%esi    */
1161   static const unsigned char f32_4[] =
1162     {0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
1163   static const unsigned char f32_5[] =
1164     {0x90,                                      /* nop                  */
1165      0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
1166   static const unsigned char f32_6[] =
1167     {0x8d,0xb6,0x00,0x00,0x00,0x00};            /* leal 0L(%esi),%esi   */
1168   static const unsigned char f32_7[] =
1169     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
1170   static const unsigned char f32_8[] =
1171     {0x90,                                      /* nop                  */
1172      0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
1173   static const unsigned char f32_9[] =
1174     {0x89,0xf6,                                 /* movl %esi,%esi       */
1175      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
1176   static const unsigned char f32_10[] =
1177     {0x8d,0x76,0x00,                            /* leal 0(%esi),%esi    */
1178      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
1179   static const unsigned char f32_11[] =
1180     {0x8d,0x74,0x26,0x00,                       /* leal 0(%esi,1),%esi  */
1181      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
1182   static const unsigned char f32_12[] =
1183     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
1184      0x8d,0xbf,0x00,0x00,0x00,0x00};            /* leal 0L(%edi),%edi   */
1185   static const unsigned char f32_13[] =
1186     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
1187      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
1188   static const unsigned char f32_14[] =
1189     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00,        /* leal 0L(%esi,1),%esi */
1190      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
1191   static const unsigned char f16_3[] =
1192     {0x8d,0x74,0x00};                           /* lea 0(%esi),%esi     */
1193   static const unsigned char f16_4[] =
1194     {0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
1195   static const unsigned char f16_5[] =
1196     {0x90,                                      /* nop                  */
1197      0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
1198   static const unsigned char f16_6[] =
1199     {0x89,0xf6,                                 /* mov %si,%si          */
1200      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
1201   static const unsigned char f16_7[] =
1202     {0x8d,0x74,0x00,                            /* lea 0(%si),%si       */
1203      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
1204   static const unsigned char f16_8[] =
1205     {0x8d,0xb4,0x00,0x00,                       /* lea 0w(%si),%si      */
1206      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
1207   static const unsigned char jump_31[] =
1208     {0xeb,0x1d,0x90,0x90,0x90,0x90,0x90,        /* jmp .+31; lotsa nops */
1209      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
1210      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
1211      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
1212   static const unsigned char *const f32_patt[] = {
1213     f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
1214     f32_9, f32_10, f32_11, f32_12, f32_13, f32_14
1215   };
1216   static const unsigned char *const f16_patt[] = {
1217     f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8
1218   };
1219   /* nopl (%[re]ax) */
1220   static const unsigned char alt_3[] =
1221     {0x0f,0x1f,0x00};
1222   /* nopl 0(%[re]ax) */
1223   static const unsigned char alt_4[] =
1224     {0x0f,0x1f,0x40,0x00};
1225   /* nopl 0(%[re]ax,%[re]ax,1) */
1226   static const unsigned char alt_5[] =
1227     {0x0f,0x1f,0x44,0x00,0x00};
1228   /* nopw 0(%[re]ax,%[re]ax,1) */
1229   static const unsigned char alt_6[] =
1230     {0x66,0x0f,0x1f,0x44,0x00,0x00};
1231   /* nopl 0L(%[re]ax) */
1232   static const unsigned char alt_7[] =
1233     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
1234   /* nopl 0L(%[re]ax,%[re]ax,1) */
1235   static const unsigned char alt_8[] =
1236     {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1237   /* nopw 0L(%[re]ax,%[re]ax,1) */
1238   static const unsigned char alt_9[] =
1239     {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1240   /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
1241   static const unsigned char alt_10[] =
1242     {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1243   static const unsigned char *const alt_patt[] = {
1244     f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
1245     alt_9, alt_10
1246   };
1247
1248   /* Only align for at least a positive non-zero boundary. */
1249   if (count <= 0 || count > MAX_MEM_FOR_RS_ALIGN_CODE)
1250     return;
1251
1252   /* We need to decide which NOP sequence to use for 32bit and
1253      64bit. When -mtune= is used:
1254
1255      1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
1256      PROCESSOR_GENERIC32, f32_patt will be used.
1257      2. For the rest, alt_patt will be used.
1258
1259      When -mtune= isn't used, alt_patt will be used if
1260      cpu_arch_isa_flags has CpuNop.  Otherwise, f32_patt will
1261      be used.
1262
1263      When -march= or .arch is used, we can't use anything beyond
1264      cpu_arch_isa_flags.   */
1265
1266   if (flag_code == CODE_16BIT)
1267     {
1268       if (count > 8)
1269         {
1270           memcpy (fragP->fr_literal + fragP->fr_fix,
1271                   jump_31, count);
1272           /* Adjust jump offset.  */
1273           fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
1274         }
1275       else
1276         memcpy (fragP->fr_literal + fragP->fr_fix,
1277                 f16_patt[count - 1], count);
1278     }
1279   else
1280     {
1281       const unsigned char *const *patt = NULL;
1282
1283       if (fragP->tc_frag_data.isa == PROCESSOR_UNKNOWN)
1284         {
1285           /* PROCESSOR_UNKNOWN means that all ISAs may be used.  */
1286           switch (cpu_arch_tune)
1287             {
1288             case PROCESSOR_UNKNOWN:
1289               /* We use cpu_arch_isa_flags to check if we SHOULD
1290                  optimize with nops.  */
1291               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1292                 patt = alt_patt;
1293               else
1294                 patt = f32_patt;
1295               break;
1296             case PROCESSOR_PENTIUM4:
1297             case PROCESSOR_NOCONA:
1298             case PROCESSOR_CORE:
1299             case PROCESSOR_CORE2:
1300             case PROCESSOR_COREI7:
1301             case PROCESSOR_L1OM:
1302             case PROCESSOR_K1OM:
1303             case PROCESSOR_GENERIC64:
1304             case PROCESSOR_K6:
1305             case PROCESSOR_ATHLON:
1306             case PROCESSOR_K8:
1307             case PROCESSOR_AMDFAM10:
1308             case PROCESSOR_BD:
1309             case PROCESSOR_ZNVER:
1310             case PROCESSOR_BT:
1311               patt = alt_patt;
1312               break;
1313             case PROCESSOR_I386:
1314             case PROCESSOR_I486:
1315             case PROCESSOR_PENTIUM:
1316             case PROCESSOR_PENTIUMPRO:
1317             case PROCESSOR_IAMCU:
1318             case PROCESSOR_GENERIC32:
1319               patt = f32_patt;
1320               break;
1321             }
1322         }
1323       else
1324         {
1325           switch (fragP->tc_frag_data.tune)
1326             {
1327             case PROCESSOR_UNKNOWN:
1328               /* When cpu_arch_isa is set, cpu_arch_tune shouldn't be
1329                  PROCESSOR_UNKNOWN.  */
1330               abort ();
1331               break;
1332
1333             case PROCESSOR_I386:
1334             case PROCESSOR_I486:
1335             case PROCESSOR_PENTIUM:
1336             case PROCESSOR_IAMCU:
1337             case PROCESSOR_K6:
1338             case PROCESSOR_ATHLON:
1339             case PROCESSOR_K8:
1340             case PROCESSOR_AMDFAM10:
1341             case PROCESSOR_BD:
1342             case PROCESSOR_ZNVER:
1343             case PROCESSOR_BT:
1344             case PROCESSOR_GENERIC32:
1345               /* We use cpu_arch_isa_flags to check if we CAN optimize
1346                  with nops.  */
1347               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1348                 patt = alt_patt;
1349               else
1350                 patt = f32_patt;
1351               break;
1352             case PROCESSOR_PENTIUMPRO:
1353             case PROCESSOR_PENTIUM4:
1354             case PROCESSOR_NOCONA:
1355             case PROCESSOR_CORE:
1356             case PROCESSOR_CORE2:
1357             case PROCESSOR_COREI7:
1358             case PROCESSOR_L1OM:
1359             case PROCESSOR_K1OM:
1360               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1361                 patt = alt_patt;
1362               else
1363                 patt = f32_patt;
1364               break;
1365             case PROCESSOR_GENERIC64:
1366               patt = alt_patt;
1367               break;
1368             }
1369         }
1370
1371       if (patt == f32_patt)
1372         {
1373           /* If the padding is less than 15 bytes, we use the normal
1374              ones.  Otherwise, we use a jump instruction and adjust
1375              its offset.   */
1376           int limit;
1377
1378           /* For 64bit, the limit is 3 bytes.  */
1379           if (flag_code == CODE_64BIT
1380               && fragP->tc_frag_data.isa_flags.bitfield.cpulm)
1381             limit = 3;
1382           else
1383             limit = 15;
1384           if (count < limit)
1385             memcpy (fragP->fr_literal + fragP->fr_fix,
1386                     patt[count - 1], count);
1387           else
1388             {
1389               memcpy (fragP->fr_literal + fragP->fr_fix,
1390                       jump_31, count);
1391               /* Adjust jump offset.  */
1392               fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
1393             }
1394         }
1395       else
1396         {
1397           /* Maximum length of an instruction is 10 byte.  If the
1398              padding is greater than 10 bytes and we don't use jump,
1399              we have to break it into smaller pieces.  */
1400           int padding = count;
1401           while (padding > 10)
1402             {
1403               padding -= 10;
1404               memcpy (fragP->fr_literal + fragP->fr_fix + padding,
1405                       patt [9], 10);
1406             }
1407
1408           if (padding)
1409             memcpy (fragP->fr_literal + fragP->fr_fix,
1410                     patt [padding - 1], padding);
1411         }
1412     }
1413   fragP->fr_var = count;
1414 }
1415
1416 static INLINE int
1417 operand_type_all_zero (const union i386_operand_type *x)
1418 {
1419   switch (ARRAY_SIZE(x->array))
1420     {
1421     case 3:
1422       if (x->array[2])
1423         return 0;
1424       /* Fall through.  */
1425     case 2:
1426       if (x->array[1])
1427         return 0;
1428       /* Fall through.  */
1429     case 1:
1430       return !x->array[0];
1431     default:
1432       abort ();
1433     }
1434 }
1435
1436 static INLINE void
1437 operand_type_set (union i386_operand_type *x, unsigned int v)
1438 {
1439   switch (ARRAY_SIZE(x->array))
1440     {
1441     case 3:
1442       x->array[2] = v;
1443       /* Fall through.  */
1444     case 2:
1445       x->array[1] = v;
1446       /* Fall through.  */
1447     case 1:
1448       x->array[0] = v;
1449       /* Fall through.  */
1450       break;
1451     default:
1452       abort ();
1453     }
1454 }
1455
1456 static INLINE int
1457 operand_type_equal (const union i386_operand_type *x,
1458                     const union i386_operand_type *y)
1459 {
1460   switch (ARRAY_SIZE(x->array))
1461     {
1462     case 3:
1463       if (x->array[2] != y->array[2])
1464         return 0;
1465       /* Fall through.  */
1466     case 2:
1467       if (x->array[1] != y->array[1])
1468         return 0;
1469       /* Fall through.  */
1470     case 1:
1471       return x->array[0] == y->array[0];
1472       break;
1473     default:
1474       abort ();
1475     }
1476 }
1477
1478 static INLINE int
1479 cpu_flags_all_zero (const union i386_cpu_flags *x)
1480 {
1481   switch (ARRAY_SIZE(x->array))
1482     {
1483     case 4:
1484       if (x->array[3])
1485         return 0;
1486       /* Fall through.  */
1487     case 3:
1488       if (x->array[2])
1489         return 0;
1490       /* Fall through.  */
1491     case 2:
1492       if (x->array[1])
1493         return 0;
1494       /* Fall through.  */
1495     case 1:
1496       return !x->array[0];
1497     default:
1498       abort ();
1499     }
1500 }
1501
1502 static INLINE int
1503 cpu_flags_equal (const union i386_cpu_flags *x,
1504                  const union i386_cpu_flags *y)
1505 {
1506   switch (ARRAY_SIZE(x->array))
1507     {
1508     case 4:
1509       if (x->array[3] != y->array[3])
1510         return 0;
1511       /* Fall through.  */
1512     case 3:
1513       if (x->array[2] != y->array[2])
1514         return 0;
1515       /* Fall through.  */
1516     case 2:
1517       if (x->array[1] != y->array[1])
1518         return 0;
1519       /* Fall through.  */
1520     case 1:
1521       return x->array[0] == y->array[0];
1522       break;
1523     default:
1524       abort ();
1525     }
1526 }
1527
1528 static INLINE int
1529 cpu_flags_check_cpu64 (i386_cpu_flags f)
1530 {
1531   return !((flag_code == CODE_64BIT && f.bitfield.cpuno64)
1532            || (flag_code != CODE_64BIT && f.bitfield.cpu64));
1533 }
1534
1535 static INLINE i386_cpu_flags
1536 cpu_flags_and (i386_cpu_flags x, i386_cpu_flags y)
1537 {
1538   switch (ARRAY_SIZE (x.array))
1539     {
1540     case 4:
1541       x.array [3] &= y.array [3];
1542       /* Fall through.  */
1543     case 3:
1544       x.array [2] &= y.array [2];
1545       /* Fall through.  */
1546     case 2:
1547       x.array [1] &= y.array [1];
1548       /* Fall through.  */
1549     case 1:
1550       x.array [0] &= y.array [0];
1551       break;
1552     default:
1553       abort ();
1554     }
1555   return x;
1556 }
1557
1558 static INLINE i386_cpu_flags
1559 cpu_flags_or (i386_cpu_flags x, i386_cpu_flags y)
1560 {
1561   switch (ARRAY_SIZE (x.array))
1562     {
1563     case 4:
1564       x.array [3] |= y.array [3];
1565       /* Fall through.  */
1566     case 3:
1567       x.array [2] |= y.array [2];
1568       /* Fall through.  */
1569     case 2:
1570       x.array [1] |= y.array [1];
1571       /* Fall through.  */
1572     case 1:
1573       x.array [0] |= y.array [0];
1574       break;
1575     default:
1576       abort ();
1577     }
1578   return x;
1579 }
1580
1581 static INLINE i386_cpu_flags
1582 cpu_flags_and_not (i386_cpu_flags x, i386_cpu_flags y)
1583 {
1584   switch (ARRAY_SIZE (x.array))
1585     {
1586     case 4:
1587       x.array [3] &= ~y.array [3];
1588       /* Fall through.  */
1589     case 3:
1590       x.array [2] &= ~y.array [2];
1591       /* Fall through.  */
1592     case 2:
1593       x.array [1] &= ~y.array [1];
1594       /* Fall through.  */
1595     case 1:
1596       x.array [0] &= ~y.array [0];
1597       break;
1598     default:
1599       abort ();
1600     }
1601   return x;
1602 }
1603
1604 #define CPU_FLAGS_ARCH_MATCH            0x1
1605 #define CPU_FLAGS_64BIT_MATCH           0x2
1606 #define CPU_FLAGS_AES_MATCH             0x4
1607 #define CPU_FLAGS_PCLMUL_MATCH          0x8
1608 #define CPU_FLAGS_AVX_MATCH            0x10
1609
1610 #define CPU_FLAGS_32BIT_MATCH \
1611   (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_AES_MATCH \
1612    | CPU_FLAGS_PCLMUL_MATCH | CPU_FLAGS_AVX_MATCH)
1613 #define CPU_FLAGS_PERFECT_MATCH \
1614   (CPU_FLAGS_32BIT_MATCH | CPU_FLAGS_64BIT_MATCH)
1615
1616 /* Return CPU flags match bits. */
1617
1618 static int
1619 cpu_flags_match (const insn_template *t)
1620 {
1621   i386_cpu_flags x = t->cpu_flags;
1622   int match = cpu_flags_check_cpu64 (x) ? CPU_FLAGS_64BIT_MATCH : 0;
1623
1624   x.bitfield.cpu64 = 0;
1625   x.bitfield.cpuno64 = 0;
1626
1627   if (cpu_flags_all_zero (&x))
1628     {
1629       /* This instruction is available on all archs.  */
1630       match |= CPU_FLAGS_32BIT_MATCH;
1631     }
1632   else
1633     {
1634       /* This instruction is available only on some archs.  */
1635       i386_cpu_flags cpu = cpu_arch_flags;
1636
1637       cpu = cpu_flags_and (x, cpu);
1638       if (!cpu_flags_all_zero (&cpu))
1639         {
1640           if (x.bitfield.cpuavx)
1641             {
1642               /* We only need to check AES/PCLMUL/SSE2AVX with AVX.  */
1643               if (cpu.bitfield.cpuavx)
1644                 {
1645                   /* Check SSE2AVX.  */
1646                   if (!t->opcode_modifier.sse2avx|| sse2avx)
1647                     {
1648                       match |= (CPU_FLAGS_ARCH_MATCH
1649                                 | CPU_FLAGS_AVX_MATCH);
1650                       /* Check AES.  */
1651                       if (!x.bitfield.cpuaes || cpu.bitfield.cpuaes)
1652                         match |= CPU_FLAGS_AES_MATCH;
1653                       /* Check PCLMUL.  */
1654                       if (!x.bitfield.cpupclmul
1655                           || cpu.bitfield.cpupclmul)
1656                         match |= CPU_FLAGS_PCLMUL_MATCH;
1657                     }
1658                 }
1659               else
1660                 match |= CPU_FLAGS_ARCH_MATCH;
1661             }
1662           else if (x.bitfield.cpuavx512vl)
1663             {
1664               /* Match AVX512VL.  */
1665               if (cpu.bitfield.cpuavx512vl)
1666                 {
1667                   /* Need another match.  */
1668                   cpu.bitfield.cpuavx512vl = 0;
1669                   if (!cpu_flags_all_zero (&cpu))
1670                     match |= CPU_FLAGS_32BIT_MATCH;
1671                   else
1672                     match |= CPU_FLAGS_ARCH_MATCH;
1673                 }
1674               else
1675                 match |= CPU_FLAGS_ARCH_MATCH;
1676             }
1677           else
1678             match |= CPU_FLAGS_32BIT_MATCH;
1679         }
1680     }
1681   return match;
1682 }
1683
1684 static INLINE i386_operand_type
1685 operand_type_and (i386_operand_type x, i386_operand_type y)
1686 {
1687   switch (ARRAY_SIZE (x.array))
1688     {
1689     case 3:
1690       x.array [2] &= y.array [2];
1691       /* Fall through.  */
1692     case 2:
1693       x.array [1] &= y.array [1];
1694       /* Fall through.  */
1695     case 1:
1696       x.array [0] &= y.array [0];
1697       break;
1698     default:
1699       abort ();
1700     }
1701   return x;
1702 }
1703
1704 static INLINE i386_operand_type
1705 operand_type_or (i386_operand_type x, i386_operand_type y)
1706 {
1707   switch (ARRAY_SIZE (x.array))
1708     {
1709     case 3:
1710       x.array [2] |= y.array [2];
1711       /* Fall through.  */
1712     case 2:
1713       x.array [1] |= y.array [1];
1714       /* Fall through.  */
1715     case 1:
1716       x.array [0] |= y.array [0];
1717       break;
1718     default:
1719       abort ();
1720     }
1721   return x;
1722 }
1723
1724 static INLINE i386_operand_type
1725 operand_type_xor (i386_operand_type x, i386_operand_type y)
1726 {
1727   switch (ARRAY_SIZE (x.array))
1728     {
1729     case 3:
1730       x.array [2] ^= y.array [2];
1731       /* Fall through.  */
1732     case 2:
1733       x.array [1] ^= y.array [1];
1734       /* Fall through.  */
1735     case 1:
1736       x.array [0] ^= y.array [0];
1737       break;
1738     default:
1739       abort ();
1740     }
1741   return x;
1742 }
1743
1744 static const i386_operand_type acc32 = OPERAND_TYPE_ACC32;
1745 static const i386_operand_type acc64 = OPERAND_TYPE_ACC64;
1746 static const i386_operand_type control = OPERAND_TYPE_CONTROL;
1747 static const i386_operand_type inoutportreg
1748   = OPERAND_TYPE_INOUTPORTREG;
1749 static const i386_operand_type reg16_inoutportreg
1750   = OPERAND_TYPE_REG16_INOUTPORTREG;
1751 static const i386_operand_type disp16 = OPERAND_TYPE_DISP16;
1752 static const i386_operand_type disp32 = OPERAND_TYPE_DISP32;
1753 static const i386_operand_type disp32s = OPERAND_TYPE_DISP32S;
1754 static const i386_operand_type disp16_32 = OPERAND_TYPE_DISP16_32;
1755 static const i386_operand_type anydisp
1756   = OPERAND_TYPE_ANYDISP;
1757 static const i386_operand_type regxmm = OPERAND_TYPE_REGXMM;
1758 static const i386_operand_type regmask = OPERAND_TYPE_REGMASK;
1759 static const i386_operand_type imm8 = OPERAND_TYPE_IMM8;
1760 static const i386_operand_type imm8s = OPERAND_TYPE_IMM8S;
1761 static const i386_operand_type imm16 = OPERAND_TYPE_IMM16;
1762 static const i386_operand_type imm32 = OPERAND_TYPE_IMM32;
1763 static const i386_operand_type imm32s = OPERAND_TYPE_IMM32S;
1764 static const i386_operand_type imm64 = OPERAND_TYPE_IMM64;
1765 static const i386_operand_type imm16_32 = OPERAND_TYPE_IMM16_32;
1766 static const i386_operand_type imm16_32s = OPERAND_TYPE_IMM16_32S;
1767 static const i386_operand_type imm16_32_32s = OPERAND_TYPE_IMM16_32_32S;
1768 static const i386_operand_type vec_imm4 = OPERAND_TYPE_VEC_IMM4;
1769
1770 enum operand_type
1771 {
1772   reg,
1773   imm,
1774   disp,
1775   anymem
1776 };
1777
1778 static INLINE int
1779 operand_type_check (i386_operand_type t, enum operand_type c)
1780 {
1781   switch (c)
1782     {
1783     case reg:
1784       return t.bitfield.reg;
1785
1786     case imm:
1787       return (t.bitfield.imm8
1788               || t.bitfield.imm8s
1789               || t.bitfield.imm16
1790               || t.bitfield.imm32
1791               || t.bitfield.imm32s
1792               || t.bitfield.imm64);
1793
1794     case disp:
1795       return (t.bitfield.disp8
1796               || t.bitfield.disp16
1797               || t.bitfield.disp32
1798               || t.bitfield.disp32s
1799               || t.bitfield.disp64);
1800
1801     case anymem:
1802       return (t.bitfield.disp8
1803               || t.bitfield.disp16
1804               || t.bitfield.disp32
1805               || t.bitfield.disp32s
1806               || t.bitfield.disp64
1807               || t.bitfield.baseindex);
1808
1809     default:
1810       abort ();
1811     }
1812
1813   return 0;
1814 }
1815
1816 /* Return 1 if there is no conflict in 8bit/16bit/32bit/64bit/80bit on
1817    operand J for instruction template T.  */
1818
1819 static INLINE int
1820 match_reg_size (const insn_template *t, unsigned int j)
1821 {
1822   return !((i.types[j].bitfield.byte
1823             && !t->operand_types[j].bitfield.byte)
1824            || (i.types[j].bitfield.word
1825                && !t->operand_types[j].bitfield.word)
1826            || (i.types[j].bitfield.dword
1827                && !t->operand_types[j].bitfield.dword)
1828            || (i.types[j].bitfield.qword
1829                && !t->operand_types[j].bitfield.qword)
1830            || (i.types[j].bitfield.tbyte
1831                && !t->operand_types[j].bitfield.tbyte));
1832 }
1833
1834 /* Return 1 if there is no conflict in SIMD register on
1835    operand J for instruction template T.  */
1836
1837 static INLINE int
1838 match_simd_size (const insn_template *t, unsigned int j)
1839 {
1840   return !((i.types[j].bitfield.xmmword
1841             && !t->operand_types[j].bitfield.xmmword)
1842            || (i.types[j].bitfield.ymmword
1843                && !t->operand_types[j].bitfield.ymmword)
1844            || (i.types[j].bitfield.zmmword
1845                && !t->operand_types[j].bitfield.zmmword));
1846 }
1847
1848 /* Return 1 if there is no conflict in any size on operand J for
1849    instruction template T.  */
1850
1851 static INLINE int
1852 match_mem_size (const insn_template *t, unsigned int j)
1853 {
1854   return (match_reg_size (t, j)
1855           && !((i.types[j].bitfield.unspecified
1856                 && !i.broadcast
1857                 && !t->operand_types[j].bitfield.unspecified)
1858                || (i.types[j].bitfield.fword
1859                    && !t->operand_types[j].bitfield.fword)
1860                /* For scalar opcode templates to allow register and memory
1861                   operands at the same time, some special casing is needed
1862                   here.  */
1863                || ((t->operand_types[j].bitfield.regsimd
1864                     && !t->opcode_modifier.broadcast
1865                     && (t->operand_types[j].bitfield.dword
1866                         || t->operand_types[j].bitfield.qword))
1867                    ? (i.types[j].bitfield.xmmword
1868                       || i.types[j].bitfield.ymmword
1869                       || i.types[j].bitfield.zmmword)
1870                    : !match_simd_size(t, j))));
1871 }
1872
1873 /* Return 1 if there is no size conflict on any operands for
1874    instruction template T.  */
1875
1876 static INLINE int
1877 operand_size_match (const insn_template *t)
1878 {
1879   unsigned int j;
1880   int match = 1;
1881
1882   /* Don't check jump instructions.  */
1883   if (t->opcode_modifier.jump
1884       || t->opcode_modifier.jumpbyte
1885       || t->opcode_modifier.jumpdword
1886       || t->opcode_modifier.jumpintersegment)
1887     return match;
1888
1889   /* Check memory and accumulator operand size.  */
1890   for (j = 0; j < i.operands; j++)
1891     {
1892       if (!i.types[j].bitfield.reg && !i.types[j].bitfield.regsimd
1893           && t->operand_types[j].bitfield.anysize)
1894         continue;
1895
1896       if (t->operand_types[j].bitfield.reg
1897           && !match_reg_size (t, j))
1898         {
1899           match = 0;
1900           break;
1901         }
1902
1903       if (t->operand_types[j].bitfield.regsimd
1904           && !match_simd_size (t, j))
1905         {
1906           match = 0;
1907           break;
1908         }
1909
1910       if (t->operand_types[j].bitfield.acc
1911           && (!match_reg_size (t, j) || !match_simd_size (t, j)))
1912         {
1913           match = 0;
1914           break;
1915         }
1916
1917       if (i.types[j].bitfield.mem && !match_mem_size (t, j))
1918         {
1919           match = 0;
1920           break;
1921         }
1922     }
1923
1924   if (match)
1925     return match;
1926   else if (!t->opcode_modifier.d && !t->opcode_modifier.floatd)
1927     {
1928 mismatch:
1929       i.error = operand_size_mismatch;
1930       return 0;
1931     }
1932
1933   /* Check reverse.  */
1934   gas_assert (i.operands == 2);
1935
1936   match = 1;
1937   for (j = 0; j < 2; j++)
1938     {
1939       if ((t->operand_types[j].bitfield.reg
1940            || t->operand_types[j].bitfield.acc)
1941           && !match_reg_size (t, j ? 0 : 1))
1942         goto mismatch;
1943
1944       if (i.types[j].bitfield.mem
1945           && !match_mem_size (t, j ? 0 : 1))
1946         goto mismatch;
1947     }
1948
1949   return match;
1950 }
1951
1952 static INLINE int
1953 operand_type_match (i386_operand_type overlap,
1954                     i386_operand_type given)
1955 {
1956   i386_operand_type temp = overlap;
1957
1958   temp.bitfield.jumpabsolute = 0;
1959   temp.bitfield.unspecified = 0;
1960   temp.bitfield.byte = 0;
1961   temp.bitfield.word = 0;
1962   temp.bitfield.dword = 0;
1963   temp.bitfield.fword = 0;
1964   temp.bitfield.qword = 0;
1965   temp.bitfield.tbyte = 0;
1966   temp.bitfield.xmmword = 0;
1967   temp.bitfield.ymmword = 0;
1968   temp.bitfield.zmmword = 0;
1969   if (operand_type_all_zero (&temp))
1970     goto mismatch;
1971
1972   if (given.bitfield.baseindex == overlap.bitfield.baseindex
1973       && given.bitfield.jumpabsolute == overlap.bitfield.jumpabsolute)
1974     return 1;
1975
1976 mismatch:
1977   i.error = operand_type_mismatch;
1978   return 0;
1979 }
1980
1981 /* If given types g0 and g1 are registers they must be of the same type
1982    unless the expected operand type register overlap is null.
1983    Memory operand size of certain SIMD instructions is also being checked
1984    here.  */
1985
1986 static INLINE int
1987 operand_type_register_match (i386_operand_type g0,
1988                              i386_operand_type t0,
1989                              i386_operand_type g1,
1990                              i386_operand_type t1)
1991 {
1992   if (!g0.bitfield.reg
1993       && !g0.bitfield.regsimd
1994       && (!operand_type_check (g0, anymem)
1995           || g0.bitfield.unspecified
1996           || !t0.bitfield.regsimd))
1997     return 1;
1998
1999   if (!g1.bitfield.reg
2000       && !g1.bitfield.regsimd
2001       && (!operand_type_check (g1, anymem)
2002           || g1.bitfield.unspecified
2003           || !t1.bitfield.regsimd))
2004     return 1;
2005
2006   if (g0.bitfield.byte == g1.bitfield.byte
2007       && g0.bitfield.word == g1.bitfield.word
2008       && g0.bitfield.dword == g1.bitfield.dword
2009       && g0.bitfield.qword == g1.bitfield.qword
2010       && g0.bitfield.xmmword == g1.bitfield.xmmword
2011       && g0.bitfield.ymmword == g1.bitfield.ymmword
2012       && g0.bitfield.zmmword == g1.bitfield.zmmword)
2013     return 1;
2014
2015   if (!(t0.bitfield.byte & t1.bitfield.byte)
2016       && !(t0.bitfield.word & t1.bitfield.word)
2017       && !(t0.bitfield.dword & t1.bitfield.dword)
2018       && !(t0.bitfield.qword & t1.bitfield.qword)
2019       && !(t0.bitfield.xmmword & t1.bitfield.xmmword)
2020       && !(t0.bitfield.ymmword & t1.bitfield.ymmword)
2021       && !(t0.bitfield.zmmword & t1.bitfield.zmmword))
2022     return 1;
2023
2024   i.error = register_type_mismatch;
2025
2026   return 0;
2027 }
2028
2029 static INLINE unsigned int
2030 register_number (const reg_entry *r)
2031 {
2032   unsigned int nr = r->reg_num;
2033
2034   if (r->reg_flags & RegRex)
2035     nr += 8;
2036
2037   if (r->reg_flags & RegVRex)
2038     nr += 16;
2039
2040   return nr;
2041 }
2042
2043 static INLINE unsigned int
2044 mode_from_disp_size (i386_operand_type t)
2045 {
2046   if (t.bitfield.disp8)
2047     return 1;
2048   else if (t.bitfield.disp16
2049            || t.bitfield.disp32
2050            || t.bitfield.disp32s)
2051     return 2;
2052   else
2053     return 0;
2054 }
2055
2056 static INLINE int
2057 fits_in_signed_byte (addressT num)
2058 {
2059   return num + 0x80 <= 0xff;
2060 }
2061
2062 static INLINE int
2063 fits_in_unsigned_byte (addressT num)
2064 {
2065   return num <= 0xff;
2066 }
2067
2068 static INLINE int
2069 fits_in_unsigned_word (addressT num)
2070 {
2071   return num <= 0xffff;
2072 }
2073
2074 static INLINE int
2075 fits_in_signed_word (addressT num)
2076 {
2077   return num + 0x8000 <= 0xffff;
2078 }
2079
2080 static INLINE int
2081 fits_in_signed_long (addressT num ATTRIBUTE_UNUSED)
2082 {
2083 #ifndef BFD64
2084   return 1;
2085 #else
2086   return num + 0x80000000 <= 0xffffffff;
2087 #endif
2088 }                               /* fits_in_signed_long() */
2089
2090 static INLINE int
2091 fits_in_unsigned_long (addressT num ATTRIBUTE_UNUSED)
2092 {
2093 #ifndef BFD64
2094   return 1;
2095 #else
2096   return num <= 0xffffffff;
2097 #endif
2098 }                               /* fits_in_unsigned_long() */
2099
2100 static INLINE int
2101 fits_in_disp8 (offsetT num)
2102 {
2103   int shift = i.memshift;
2104   unsigned int mask;
2105
2106   if (shift == -1)
2107     abort ();
2108
2109   mask = (1 << shift) - 1;
2110
2111   /* Return 0 if NUM isn't properly aligned.  */
2112   if ((num & mask))
2113     return 0;
2114
2115   /* Check if NUM will fit in 8bit after shift.  */
2116   return fits_in_signed_byte (num >> shift);
2117 }
2118
2119 static INLINE int
2120 fits_in_imm4 (offsetT num)
2121 {
2122   return (num & 0xf) == num;
2123 }
2124
2125 static i386_operand_type
2126 smallest_imm_type (offsetT num)
2127 {
2128   i386_operand_type t;
2129
2130   operand_type_set (&t, 0);
2131   t.bitfield.imm64 = 1;
2132
2133   if (cpu_arch_tune != PROCESSOR_I486 && num == 1)
2134     {
2135       /* This code is disabled on the 486 because all the Imm1 forms
2136          in the opcode table are slower on the i486.  They're the
2137          versions with the implicitly specified single-position
2138          displacement, which has another syntax if you really want to
2139          use that form.  */
2140       t.bitfield.imm1 = 1;
2141       t.bitfield.imm8 = 1;
2142       t.bitfield.imm8s = 1;
2143       t.bitfield.imm16 = 1;
2144       t.bitfield.imm32 = 1;
2145       t.bitfield.imm32s = 1;
2146     }
2147   else if (fits_in_signed_byte (num))
2148     {
2149       t.bitfield.imm8 = 1;
2150       t.bitfield.imm8s = 1;
2151       t.bitfield.imm16 = 1;
2152       t.bitfield.imm32 = 1;
2153       t.bitfield.imm32s = 1;
2154     }
2155   else if (fits_in_unsigned_byte (num))
2156     {
2157       t.bitfield.imm8 = 1;
2158       t.bitfield.imm16 = 1;
2159       t.bitfield.imm32 = 1;
2160       t.bitfield.imm32s = 1;
2161     }
2162   else if (fits_in_signed_word (num) || fits_in_unsigned_word (num))
2163     {
2164       t.bitfield.imm16 = 1;
2165       t.bitfield.imm32 = 1;
2166       t.bitfield.imm32s = 1;
2167     }
2168   else if (fits_in_signed_long (num))
2169     {
2170       t.bitfield.imm32 = 1;
2171       t.bitfield.imm32s = 1;
2172     }
2173   else if (fits_in_unsigned_long (num))
2174     t.bitfield.imm32 = 1;
2175
2176   return t;
2177 }
2178
2179 static offsetT
2180 offset_in_range (offsetT val, int size)
2181 {
2182   addressT mask;
2183
2184   switch (size)
2185     {
2186     case 1: mask = ((addressT) 1 <<  8) - 1; break;
2187     case 2: mask = ((addressT) 1 << 16) - 1; break;
2188     case 4: mask = ((addressT) 2 << 31) - 1; break;
2189 #ifdef BFD64
2190     case 8: mask = ((addressT) 2 << 63) - 1; break;
2191 #endif
2192     default: abort ();
2193     }
2194
2195 #ifdef BFD64
2196   /* If BFD64, sign extend val for 32bit address mode.  */
2197   if (flag_code != CODE_64BIT
2198       || i.prefix[ADDR_PREFIX])
2199     if ((val & ~(((addressT) 2 << 31) - 1)) == 0)
2200       val = (val ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
2201 #endif
2202
2203   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
2204     {
2205       char buf1[40], buf2[40];
2206
2207       sprint_value (buf1, val);
2208       sprint_value (buf2, val & mask);
2209       as_warn (_("%s shortened to %s"), buf1, buf2);
2210     }
2211   return val & mask;
2212 }
2213
2214 enum PREFIX_GROUP
2215 {
2216   PREFIX_EXIST = 0,
2217   PREFIX_LOCK,
2218   PREFIX_REP,
2219   PREFIX_DS,
2220   PREFIX_OTHER
2221 };
2222
2223 /* Returns
2224    a. PREFIX_EXIST if attempting to add a prefix where one from the
2225    same class already exists.
2226    b. PREFIX_LOCK if lock prefix is added.
2227    c. PREFIX_REP if rep/repne prefix is added.
2228    d. PREFIX_DS if ds prefix is added.
2229    e. PREFIX_OTHER if other prefix is added.
2230  */
2231
2232 static enum PREFIX_GROUP
2233 add_prefix (unsigned int prefix)
2234 {
2235   enum PREFIX_GROUP ret = PREFIX_OTHER;
2236   unsigned int q;
2237
2238   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
2239       && flag_code == CODE_64BIT)
2240     {
2241       if ((i.prefix[REX_PREFIX] & prefix & REX_W)
2242           || ((i.prefix[REX_PREFIX] & (REX_R | REX_X | REX_B))
2243               && (prefix & (REX_R | REX_X | REX_B))))
2244         ret = PREFIX_EXIST;
2245       q = REX_PREFIX;
2246     }
2247   else
2248     {
2249       switch (prefix)
2250         {
2251         default:
2252           abort ();
2253
2254         case DS_PREFIX_OPCODE:
2255           ret = PREFIX_DS;
2256           /* Fall through.  */
2257         case CS_PREFIX_OPCODE:
2258         case ES_PREFIX_OPCODE:
2259         case FS_PREFIX_OPCODE:
2260         case GS_PREFIX_OPCODE:
2261         case SS_PREFIX_OPCODE:
2262           q = SEG_PREFIX;
2263           break;
2264
2265         case REPNE_PREFIX_OPCODE:
2266         case REPE_PREFIX_OPCODE:
2267           q = REP_PREFIX;
2268           ret = PREFIX_REP;
2269           break;
2270
2271         case LOCK_PREFIX_OPCODE:
2272           q = LOCK_PREFIX;
2273           ret = PREFIX_LOCK;
2274           break;
2275
2276         case FWAIT_OPCODE:
2277           q = WAIT_PREFIX;
2278           break;
2279
2280         case ADDR_PREFIX_OPCODE:
2281           q = ADDR_PREFIX;
2282           break;
2283
2284         case DATA_PREFIX_OPCODE:
2285           q = DATA_PREFIX;
2286           break;
2287         }
2288       if (i.prefix[q] != 0)
2289         ret = PREFIX_EXIST;
2290     }
2291
2292   if (ret)
2293     {
2294       if (!i.prefix[q])
2295         ++i.prefixes;
2296       i.prefix[q] |= prefix;
2297     }
2298   else
2299     as_bad (_("same type of prefix used twice"));
2300
2301   return ret;
2302 }
2303
2304 static void
2305 update_code_flag (int value, int check)
2306 {
2307   PRINTF_LIKE ((*as_error));
2308
2309   flag_code = (enum flag_code) value;
2310   if (flag_code == CODE_64BIT)
2311     {
2312       cpu_arch_flags.bitfield.cpu64 = 1;
2313       cpu_arch_flags.bitfield.cpuno64 = 0;
2314     }
2315   else
2316     {
2317       cpu_arch_flags.bitfield.cpu64 = 0;
2318       cpu_arch_flags.bitfield.cpuno64 = 1;
2319     }
2320   if (value == CODE_64BIT && !cpu_arch_flags.bitfield.cpulm )
2321     {
2322       if (check)
2323         as_error = as_fatal;
2324       else
2325         as_error = as_bad;
2326       (*as_error) (_("64bit mode not supported on `%s'."),
2327                    cpu_arch_name ? cpu_arch_name : default_arch);
2328     }
2329   if (value == CODE_32BIT && !cpu_arch_flags.bitfield.cpui386)
2330     {
2331       if (check)
2332         as_error = as_fatal;
2333       else
2334         as_error = as_bad;
2335       (*as_error) (_("32bit mode not supported on `%s'."),
2336                    cpu_arch_name ? cpu_arch_name : default_arch);
2337     }
2338   stackop_size = '\0';
2339 }
2340
2341 static void
2342 set_code_flag (int value)
2343 {
2344   update_code_flag (value, 0);
2345 }
2346
2347 static void
2348 set_16bit_gcc_code_flag (int new_code_flag)
2349 {
2350   flag_code = (enum flag_code) new_code_flag;
2351   if (flag_code != CODE_16BIT)
2352     abort ();
2353   cpu_arch_flags.bitfield.cpu64 = 0;
2354   cpu_arch_flags.bitfield.cpuno64 = 1;
2355   stackop_size = LONG_MNEM_SUFFIX;
2356 }
2357
2358 static void
2359 set_intel_syntax (int syntax_flag)
2360 {
2361   /* Find out if register prefixing is specified.  */
2362   int ask_naked_reg = 0;
2363
2364   SKIP_WHITESPACE ();
2365   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2366     {
2367       char *string;
2368       int e = get_symbol_name (&string);
2369
2370       if (strcmp (string, "prefix") == 0)
2371         ask_naked_reg = 1;
2372       else if (strcmp (string, "noprefix") == 0)
2373         ask_naked_reg = -1;
2374       else
2375         as_bad (_("bad argument to syntax directive."));
2376       (void) restore_line_pointer (e);
2377     }
2378   demand_empty_rest_of_line ();
2379
2380   intel_syntax = syntax_flag;
2381
2382   if (ask_naked_reg == 0)
2383     allow_naked_reg = (intel_syntax
2384                        && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
2385   else
2386     allow_naked_reg = (ask_naked_reg < 0);
2387
2388   expr_set_rank (O_full_ptr, syntax_flag ? 10 : 0);
2389
2390   identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
2391   identifier_chars['$'] = intel_syntax ? '$' : 0;
2392   register_prefix = allow_naked_reg ? "" : "%";
2393 }
2394
2395 static void
2396 set_intel_mnemonic (int mnemonic_flag)
2397 {
2398   intel_mnemonic = mnemonic_flag;
2399 }
2400
2401 static void
2402 set_allow_index_reg (int flag)
2403 {
2404   allow_index_reg = flag;
2405 }
2406
2407 static void
2408 set_check (int what)
2409 {
2410   enum check_kind *kind;
2411   const char *str;
2412
2413   if (what)
2414     {
2415       kind = &operand_check;
2416       str = "operand";
2417     }
2418   else
2419     {
2420       kind = &sse_check;
2421       str = "sse";
2422     }
2423
2424   SKIP_WHITESPACE ();
2425
2426   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2427     {
2428       char *string;
2429       int e = get_symbol_name (&string);
2430
2431       if (strcmp (string, "none") == 0)
2432         *kind = check_none;
2433       else if (strcmp (string, "warning") == 0)
2434         *kind = check_warning;
2435       else if (strcmp (string, "error") == 0)
2436         *kind = check_error;
2437       else
2438         as_bad (_("bad argument to %s_check directive."), str);
2439       (void) restore_line_pointer (e);
2440     }
2441   else
2442     as_bad (_("missing argument for %s_check directive"), str);
2443
2444   demand_empty_rest_of_line ();
2445 }
2446
2447 static void
2448 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED,
2449                            i386_cpu_flags new_flag ATTRIBUTE_UNUSED)
2450 {
2451 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2452   static const char *arch;
2453
2454   /* Intel LIOM is only supported on ELF.  */
2455   if (!IS_ELF)
2456     return;
2457
2458   if (!arch)
2459     {
2460       /* Use cpu_arch_name if it is set in md_parse_option.  Otherwise
2461          use default_arch.  */
2462       arch = cpu_arch_name;
2463       if (!arch)
2464         arch = default_arch;
2465     }
2466
2467   /* If we are targeting Intel MCU, we must enable it.  */
2468   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_IAMCU
2469       || new_flag.bitfield.cpuiamcu)
2470     return;
2471
2472   /* If we are targeting Intel L1OM, we must enable it.  */
2473   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_L1OM
2474       || new_flag.bitfield.cpul1om)
2475     return;
2476
2477   /* If we are targeting Intel K1OM, we must enable it.  */
2478   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_K1OM
2479       || new_flag.bitfield.cpuk1om)
2480     return;
2481
2482   as_bad (_("`%s' is not supported on `%s'"), name, arch);
2483 #endif
2484 }
2485
2486 static void
2487 set_cpu_arch (int dummy ATTRIBUTE_UNUSED)
2488 {
2489   SKIP_WHITESPACE ();
2490
2491   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2492     {
2493       char *string;
2494       int e = get_symbol_name (&string);
2495       unsigned int j;
2496       i386_cpu_flags flags;
2497
2498       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
2499         {
2500           if (strcmp (string, cpu_arch[j].name) == 0)
2501             {
2502               check_cpu_arch_compatible (string, cpu_arch[j].flags);
2503
2504               if (*string != '.')
2505                 {
2506                   cpu_arch_name = cpu_arch[j].name;
2507                   cpu_sub_arch_name = NULL;
2508                   cpu_arch_flags = cpu_arch[j].flags;
2509                   if (flag_code == CODE_64BIT)
2510                     {
2511                       cpu_arch_flags.bitfield.cpu64 = 1;
2512                       cpu_arch_flags.bitfield.cpuno64 = 0;
2513                     }
2514                   else
2515                     {
2516                       cpu_arch_flags.bitfield.cpu64 = 0;
2517                       cpu_arch_flags.bitfield.cpuno64 = 1;
2518                     }
2519                   cpu_arch_isa = cpu_arch[j].type;
2520                   cpu_arch_isa_flags = cpu_arch[j].flags;
2521                   if (!cpu_arch_tune_set)
2522                     {
2523                       cpu_arch_tune = cpu_arch_isa;
2524                       cpu_arch_tune_flags = cpu_arch_isa_flags;
2525                     }
2526                   break;
2527                 }
2528
2529               flags = cpu_flags_or (cpu_arch_flags,
2530                                     cpu_arch[j].flags);
2531
2532               if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2533                 {
2534                   if (cpu_sub_arch_name)
2535                     {
2536                       char *name = cpu_sub_arch_name;
2537                       cpu_sub_arch_name = concat (name,
2538                                                   cpu_arch[j].name,
2539                                                   (const char *) NULL);
2540                       free (name);
2541                     }
2542                   else
2543                     cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
2544                   cpu_arch_flags = flags;
2545                   cpu_arch_isa_flags = flags;
2546                 }
2547               (void) restore_line_pointer (e);
2548               demand_empty_rest_of_line ();
2549               return;
2550             }
2551         }
2552
2553       if (*string == '.' && j >= ARRAY_SIZE (cpu_arch))
2554         {
2555           /* Disable an ISA extension.  */
2556           for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
2557             if (strcmp (string + 1, cpu_noarch [j].name) == 0)
2558               {
2559                 flags = cpu_flags_and_not (cpu_arch_flags,
2560                                            cpu_noarch[j].flags);
2561                 if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2562                   {
2563                     if (cpu_sub_arch_name)
2564                       {
2565                         char *name = cpu_sub_arch_name;
2566                         cpu_sub_arch_name = concat (name, string,
2567                                                     (const char *) NULL);
2568                         free (name);
2569                       }
2570                     else
2571                       cpu_sub_arch_name = xstrdup (string);
2572                     cpu_arch_flags = flags;
2573                     cpu_arch_isa_flags = flags;
2574                   }
2575                 (void) restore_line_pointer (e);
2576                 demand_empty_rest_of_line ();
2577                 return;
2578               }
2579
2580           j = ARRAY_SIZE (cpu_arch);
2581         }
2582
2583       if (j >= ARRAY_SIZE (cpu_arch))
2584         as_bad (_("no such architecture: `%s'"), string);
2585
2586       *input_line_pointer = e;
2587     }
2588   else
2589     as_bad (_("missing cpu architecture"));
2590
2591   no_cond_jump_promotion = 0;
2592   if (*input_line_pointer == ','
2593       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
2594     {
2595       char *string;
2596       char e;
2597
2598       ++input_line_pointer;
2599       e = get_symbol_name (&string);
2600
2601       if (strcmp (string, "nojumps") == 0)
2602         no_cond_jump_promotion = 1;
2603       else if (strcmp (string, "jumps") == 0)
2604         ;
2605       else
2606         as_bad (_("no such architecture modifier: `%s'"), string);
2607
2608       (void) restore_line_pointer (e);
2609     }
2610
2611   demand_empty_rest_of_line ();
2612 }
2613
2614 enum bfd_architecture
2615 i386_arch (void)
2616 {
2617   if (cpu_arch_isa == PROCESSOR_L1OM)
2618     {
2619       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2620           || flag_code != CODE_64BIT)
2621         as_fatal (_("Intel L1OM is 64bit ELF only"));
2622       return bfd_arch_l1om;
2623     }
2624   else if (cpu_arch_isa == PROCESSOR_K1OM)
2625     {
2626       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2627           || flag_code != CODE_64BIT)
2628         as_fatal (_("Intel K1OM is 64bit ELF only"));
2629       return bfd_arch_k1om;
2630     }
2631   else if (cpu_arch_isa == PROCESSOR_IAMCU)
2632     {
2633       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2634           || flag_code == CODE_64BIT)
2635         as_fatal (_("Intel MCU is 32bit ELF only"));
2636       return bfd_arch_iamcu;
2637     }
2638   else
2639     return bfd_arch_i386;
2640 }
2641
2642 unsigned long
2643 i386_mach (void)
2644 {
2645   if (!strncmp (default_arch, "x86_64", 6))
2646     {
2647       if (cpu_arch_isa == PROCESSOR_L1OM)
2648         {
2649           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2650               || default_arch[6] != '\0')
2651             as_fatal (_("Intel L1OM is 64bit ELF only"));
2652           return bfd_mach_l1om;
2653         }
2654       else if (cpu_arch_isa == PROCESSOR_K1OM)
2655         {
2656           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2657               || default_arch[6] != '\0')
2658             as_fatal (_("Intel K1OM is 64bit ELF only"));
2659           return bfd_mach_k1om;
2660         }
2661       else if (default_arch[6] == '\0')
2662         return bfd_mach_x86_64;
2663       else
2664         return bfd_mach_x64_32;
2665     }
2666   else if (!strcmp (default_arch, "i386")
2667            || !strcmp (default_arch, "iamcu"))
2668     {
2669       if (cpu_arch_isa == PROCESSOR_IAMCU)
2670         {
2671           if (OUTPUT_FLAVOR != bfd_target_elf_flavour)
2672             as_fatal (_("Intel MCU is 32bit ELF only"));
2673           return bfd_mach_i386_iamcu;
2674         }
2675       else
2676         return bfd_mach_i386_i386;
2677     }
2678   else
2679     as_fatal (_("unknown architecture"));
2680 }
2681 \f
2682 void
2683 md_begin (void)
2684 {
2685   const char *hash_err;
2686
2687   /* Support pseudo prefixes like {disp32}.  */
2688   lex_type ['{'] = LEX_BEGIN_NAME;
2689
2690   /* Initialize op_hash hash table.  */
2691   op_hash = hash_new ();
2692
2693   {
2694     const insn_template *optab;
2695     templates *core_optab;
2696
2697     /* Setup for loop.  */
2698     optab = i386_optab;
2699     core_optab = XNEW (templates);
2700     core_optab->start = optab;
2701
2702     while (1)
2703       {
2704         ++optab;
2705         if (optab->name == NULL
2706             || strcmp (optab->name, (optab - 1)->name) != 0)
2707           {
2708             /* different name --> ship out current template list;
2709                add to hash table; & begin anew.  */
2710             core_optab->end = optab;
2711             hash_err = hash_insert (op_hash,
2712                                     (optab - 1)->name,
2713                                     (void *) core_optab);
2714             if (hash_err)
2715               {
2716                 as_fatal (_("can't hash %s: %s"),
2717                           (optab - 1)->name,
2718                           hash_err);
2719               }
2720             if (optab->name == NULL)
2721               break;
2722             core_optab = XNEW (templates);
2723             core_optab->start = optab;
2724           }
2725       }
2726   }
2727
2728   /* Initialize reg_hash hash table.  */
2729   reg_hash = hash_new ();
2730   {
2731     const reg_entry *regtab;
2732     unsigned int regtab_size = i386_regtab_size;
2733
2734     for (regtab = i386_regtab; regtab_size--; regtab++)
2735       {
2736         hash_err = hash_insert (reg_hash, regtab->reg_name, (void *) regtab);
2737         if (hash_err)
2738           as_fatal (_("can't hash %s: %s"),
2739                     regtab->reg_name,
2740                     hash_err);
2741       }
2742   }
2743
2744   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
2745   {
2746     int c;
2747     char *p;
2748
2749     for (c = 0; c < 256; c++)
2750       {
2751         if (ISDIGIT (c))
2752           {
2753             digit_chars[c] = c;
2754             mnemonic_chars[c] = c;
2755             register_chars[c] = c;
2756             operand_chars[c] = c;
2757           }
2758         else if (ISLOWER (c))
2759           {
2760             mnemonic_chars[c] = c;
2761             register_chars[c] = c;
2762             operand_chars[c] = c;
2763           }
2764         else if (ISUPPER (c))
2765           {
2766             mnemonic_chars[c] = TOLOWER (c);
2767             register_chars[c] = mnemonic_chars[c];
2768             operand_chars[c] = c;
2769           }
2770         else if (c == '{' || c == '}')
2771           {
2772             mnemonic_chars[c] = c;
2773             operand_chars[c] = c;
2774           }
2775
2776         if (ISALPHA (c) || ISDIGIT (c))
2777           identifier_chars[c] = c;
2778         else if (c >= 128)
2779           {
2780             identifier_chars[c] = c;
2781             operand_chars[c] = c;
2782           }
2783       }
2784
2785 #ifdef LEX_AT
2786     identifier_chars['@'] = '@';
2787 #endif
2788 #ifdef LEX_QM
2789     identifier_chars['?'] = '?';
2790     operand_chars['?'] = '?';
2791 #endif
2792     digit_chars['-'] = '-';
2793     mnemonic_chars['_'] = '_';
2794     mnemonic_chars['-'] = '-';
2795     mnemonic_chars['.'] = '.';
2796     identifier_chars['_'] = '_';
2797     identifier_chars['.'] = '.';
2798
2799     for (p = operand_special_chars; *p != '\0'; p++)
2800       operand_chars[(unsigned char) *p] = *p;
2801   }
2802
2803   if (flag_code == CODE_64BIT)
2804     {
2805 #if defined (OBJ_COFF) && defined (TE_PE)
2806       x86_dwarf2_return_column = (OUTPUT_FLAVOR == bfd_target_coff_flavour
2807                                   ? 32 : 16);
2808 #else
2809       x86_dwarf2_return_column = 16;
2810 #endif
2811       x86_cie_data_alignment = -8;
2812     }
2813   else
2814     {
2815       x86_dwarf2_return_column = 8;
2816       x86_cie_data_alignment = -4;
2817     }
2818 }
2819
2820 void
2821 i386_print_statistics (FILE *file)
2822 {
2823   hash_print_statistics (file, "i386 opcode", op_hash);
2824   hash_print_statistics (file, "i386 register", reg_hash);
2825 }
2826 \f
2827 #ifdef DEBUG386
2828
2829 /* Debugging routines for md_assemble.  */
2830 static void pte (insn_template *);
2831 static void pt (i386_operand_type);
2832 static void pe (expressionS *);
2833 static void ps (symbolS *);
2834
2835 static void
2836 pi (char *line, i386_insn *x)
2837 {
2838   unsigned int j;
2839
2840   fprintf (stdout, "%s: template ", line);
2841   pte (&x->tm);
2842   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
2843            x->base_reg ? x->base_reg->reg_name : "none",
2844            x->index_reg ? x->index_reg->reg_name : "none",
2845            x->log2_scale_factor);
2846   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
2847            x->rm.mode, x->rm.reg, x->rm.regmem);
2848   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
2849            x->sib.base, x->sib.index, x->sib.scale);
2850   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
2851            (x->rex & REX_W) != 0,
2852            (x->rex & REX_R) != 0,
2853            (x->rex & REX_X) != 0,
2854            (x->rex & REX_B) != 0);
2855   for (j = 0; j < x->operands; j++)
2856     {
2857       fprintf (stdout, "    #%d:  ", j + 1);
2858       pt (x->types[j]);
2859       fprintf (stdout, "\n");
2860       if (x->types[j].bitfield.reg
2861           || x->types[j].bitfield.regmmx
2862           || x->types[j].bitfield.regsimd
2863           || x->types[j].bitfield.sreg2
2864           || x->types[j].bitfield.sreg3
2865           || x->types[j].bitfield.control
2866           || x->types[j].bitfield.debug
2867           || x->types[j].bitfield.test)
2868         fprintf (stdout, "%s\n", x->op[j].regs->reg_name);
2869       if (operand_type_check (x->types[j], imm))
2870         pe (x->op[j].imms);
2871       if (operand_type_check (x->types[j], disp))
2872         pe (x->op[j].disps);
2873     }
2874 }
2875
2876 static void
2877 pte (insn_template *t)
2878 {
2879   unsigned int j;
2880   fprintf (stdout, " %d operands ", t->operands);
2881   fprintf (stdout, "opcode %x ", t->base_opcode);
2882   if (t->extension_opcode != None)
2883     fprintf (stdout, "ext %x ", t->extension_opcode);
2884   if (t->opcode_modifier.d)
2885     fprintf (stdout, "D");
2886   if (t->opcode_modifier.w)
2887     fprintf (stdout, "W");
2888   fprintf (stdout, "\n");
2889   for (j = 0; j < t->operands; j++)
2890     {
2891       fprintf (stdout, "    #%d type ", j + 1);
2892       pt (t->operand_types[j]);
2893       fprintf (stdout, "\n");
2894     }
2895 }
2896
2897 static void
2898 pe (expressionS *e)
2899 {
2900   fprintf (stdout, "    operation     %d\n", e->X_op);
2901   fprintf (stdout, "    add_number    %ld (%lx)\n",
2902            (long) e->X_add_number, (long) e->X_add_number);
2903   if (e->X_add_symbol)
2904     {
2905       fprintf (stdout, "    add_symbol    ");
2906       ps (e->X_add_symbol);
2907       fprintf (stdout, "\n");
2908     }
2909   if (e->X_op_symbol)
2910     {
2911       fprintf (stdout, "    op_symbol    ");
2912       ps (e->X_op_symbol);
2913       fprintf (stdout, "\n");
2914     }
2915 }
2916
2917 static void
2918 ps (symbolS *s)
2919 {
2920   fprintf (stdout, "%s type %s%s",
2921            S_GET_NAME (s),
2922            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
2923            segment_name (S_GET_SEGMENT (s)));
2924 }
2925
2926 static struct type_name
2927   {
2928     i386_operand_type mask;
2929     const char *name;
2930   }
2931 const type_names[] =
2932 {
2933   { OPERAND_TYPE_REG8, "r8" },
2934   { OPERAND_TYPE_REG16, "r16" },
2935   { OPERAND_TYPE_REG32, "r32" },
2936   { OPERAND_TYPE_REG64, "r64" },
2937   { OPERAND_TYPE_IMM8, "i8" },
2938   { OPERAND_TYPE_IMM8, "i8s" },
2939   { OPERAND_TYPE_IMM16, "i16" },
2940   { OPERAND_TYPE_IMM32, "i32" },
2941   { OPERAND_TYPE_IMM32S, "i32s" },
2942   { OPERAND_TYPE_IMM64, "i64" },
2943   { OPERAND_TYPE_IMM1, "i1" },
2944   { OPERAND_TYPE_BASEINDEX, "BaseIndex" },
2945   { OPERAND_TYPE_DISP8, "d8" },
2946   { OPERAND_TYPE_DISP16, "d16" },
2947   { OPERAND_TYPE_DISP32, "d32" },
2948   { OPERAND_TYPE_DISP32S, "d32s" },
2949   { OPERAND_TYPE_DISP64, "d64" },
2950   { OPERAND_TYPE_INOUTPORTREG, "InOutPortReg" },
2951   { OPERAND_TYPE_SHIFTCOUNT, "ShiftCount" },
2952   { OPERAND_TYPE_CONTROL, "control reg" },
2953   { OPERAND_TYPE_TEST, "test reg" },
2954   { OPERAND_TYPE_DEBUG, "debug reg" },
2955   { OPERAND_TYPE_FLOATREG, "FReg" },
2956   { OPERAND_TYPE_FLOATACC, "FAcc" },
2957   { OPERAND_TYPE_SREG2, "SReg2" },
2958   { OPERAND_TYPE_SREG3, "SReg3" },
2959   { OPERAND_TYPE_ACC, "Acc" },
2960   { OPERAND_TYPE_JUMPABSOLUTE, "Jump Absolute" },
2961   { OPERAND_TYPE_REGMMX, "rMMX" },
2962   { OPERAND_TYPE_REGXMM, "rXMM" },
2963   { OPERAND_TYPE_REGYMM, "rYMM" },
2964   { OPERAND_TYPE_REGZMM, "rZMM" },
2965   { OPERAND_TYPE_REGMASK, "Mask reg" },
2966   { OPERAND_TYPE_ESSEG, "es" },
2967 };
2968
2969 static void
2970 pt (i386_operand_type t)
2971 {
2972   unsigned int j;
2973   i386_operand_type a;
2974
2975   for (j = 0; j < ARRAY_SIZE (type_names); j++)
2976     {
2977       a = operand_type_and (t, type_names[j].mask);
2978       if (!operand_type_all_zero (&a))
2979         fprintf (stdout, "%s, ",  type_names[j].name);
2980     }
2981   fflush (stdout);
2982 }
2983
2984 #endif /* DEBUG386 */
2985 \f
2986 static bfd_reloc_code_real_type
2987 reloc (unsigned int size,
2988        int pcrel,
2989        int sign,
2990        bfd_reloc_code_real_type other)
2991 {
2992   if (other != NO_RELOC)
2993     {
2994       reloc_howto_type *rel;
2995
2996       if (size == 8)
2997         switch (other)
2998           {
2999           case BFD_RELOC_X86_64_GOT32:
3000             return BFD_RELOC_X86_64_GOT64;
3001             break;
3002           case BFD_RELOC_X86_64_GOTPLT64:
3003             return BFD_RELOC_X86_64_GOTPLT64;
3004             break;
3005           case BFD_RELOC_X86_64_PLTOFF64:
3006             return BFD_RELOC_X86_64_PLTOFF64;
3007             break;
3008           case BFD_RELOC_X86_64_GOTPC32:
3009             other = BFD_RELOC_X86_64_GOTPC64;
3010             break;
3011           case BFD_RELOC_X86_64_GOTPCREL:
3012             other = BFD_RELOC_X86_64_GOTPCREL64;
3013             break;
3014           case BFD_RELOC_X86_64_TPOFF32:
3015             other = BFD_RELOC_X86_64_TPOFF64;
3016             break;
3017           case BFD_RELOC_X86_64_DTPOFF32:
3018             other = BFD_RELOC_X86_64_DTPOFF64;
3019             break;
3020           default:
3021             break;
3022           }
3023
3024 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3025       if (other == BFD_RELOC_SIZE32)
3026         {
3027           if (size == 8)
3028             other = BFD_RELOC_SIZE64;
3029           if (pcrel)
3030             {
3031               as_bad (_("there are no pc-relative size relocations"));
3032               return NO_RELOC;
3033             }
3034         }
3035 #endif
3036
3037       /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless.  */
3038       if (size == 4 && (flag_code != CODE_64BIT || disallow_64bit_reloc))
3039         sign = -1;
3040
3041       rel = bfd_reloc_type_lookup (stdoutput, other);
3042       if (!rel)
3043         as_bad (_("unknown relocation (%u)"), other);
3044       else if (size != bfd_get_reloc_size (rel))
3045         as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
3046                 bfd_get_reloc_size (rel),
3047                 size);
3048       else if (pcrel && !rel->pc_relative)
3049         as_bad (_("non-pc-relative relocation for pc-relative field"));
3050       else if ((rel->complain_on_overflow == complain_overflow_signed
3051                 && !sign)
3052                || (rel->complain_on_overflow == complain_overflow_unsigned
3053                    && sign > 0))
3054         as_bad (_("relocated field and relocation type differ in signedness"));
3055       else
3056         return other;
3057       return NO_RELOC;
3058     }
3059
3060   if (pcrel)
3061     {
3062       if (!sign)
3063         as_bad (_("there are no unsigned pc-relative relocations"));
3064       switch (size)
3065         {
3066         case 1: return BFD_RELOC_8_PCREL;
3067         case 2: return BFD_RELOC_16_PCREL;
3068         case 4: return BFD_RELOC_32_PCREL;
3069         case 8: return BFD_RELOC_64_PCREL;
3070         }
3071       as_bad (_("cannot do %u byte pc-relative relocation"), size);
3072     }
3073   else
3074     {
3075       if (sign > 0)
3076         switch (size)
3077           {
3078           case 4: return BFD_RELOC_X86_64_32S;
3079           }
3080       else
3081         switch (size)
3082           {
3083           case 1: return BFD_RELOC_8;
3084           case 2: return BFD_RELOC_16;
3085           case 4: return BFD_RELOC_32;
3086           case 8: return BFD_RELOC_64;
3087           }
3088       as_bad (_("cannot do %s %u byte relocation"),
3089               sign > 0 ? "signed" : "unsigned", size);
3090     }
3091
3092   return NO_RELOC;
3093 }
3094
3095 /* Here we decide which fixups can be adjusted to make them relative to
3096    the beginning of the section instead of the symbol.  Basically we need
3097    to make sure that the dynamic relocations are done correctly, so in
3098    some cases we force the original symbol to be used.  */
3099
3100 int
3101 tc_i386_fix_adjustable (fixS *fixP ATTRIBUTE_UNUSED)
3102 {
3103 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3104   if (!IS_ELF)
3105     return 1;
3106
3107   /* Don't adjust pc-relative references to merge sections in 64-bit
3108      mode.  */
3109   if (use_rela_relocations
3110       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
3111       && fixP->fx_pcrel)
3112     return 0;
3113
3114   /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
3115      and changed later by validate_fix.  */
3116   if (GOT_symbol && fixP->fx_subsy == GOT_symbol
3117       && fixP->fx_r_type == BFD_RELOC_32_PCREL)
3118     return 0;
3119
3120   /* Adjust_reloc_syms doesn't know about the GOT.  Need to keep symbol
3121      for size relocations.  */
3122   if (fixP->fx_r_type == BFD_RELOC_SIZE32
3123       || fixP->fx_r_type == BFD_RELOC_SIZE64
3124       || fixP->fx_r_type == BFD_RELOC_386_GOTOFF
3125       || fixP->fx_r_type == BFD_RELOC_386_PLT32
3126       || fixP->fx_r_type == BFD_RELOC_386_GOT32
3127       || fixP->fx_r_type == BFD_RELOC_386_GOT32X
3128       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
3129       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
3130       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
3131       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
3132       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
3133       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
3134       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
3135       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
3136       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
3137       || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
3138       || fixP->fx_r_type == BFD_RELOC_X86_64_PLT32
3139       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
3140       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
3141       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCRELX
3142       || fixP->fx_r_type == BFD_RELOC_X86_64_REX_GOTPCRELX
3143       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
3144       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
3145       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
3146       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
3147       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
3148       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
3149       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
3150       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
3151       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
3152       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
3153       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3154       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3155     return 0;
3156 #endif
3157   return 1;
3158 }
3159
3160 static int
3161 intel_float_operand (const char *mnemonic)
3162 {
3163   /* Note that the value returned is meaningful only for opcodes with (memory)
3164      operands, hence the code here is free to improperly handle opcodes that
3165      have no operands (for better performance and smaller code). */
3166
3167   if (mnemonic[0] != 'f')
3168     return 0; /* non-math */
3169
3170   switch (mnemonic[1])
3171     {
3172     /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
3173        the fs segment override prefix not currently handled because no
3174        call path can make opcodes without operands get here */
3175     case 'i':
3176       return 2 /* integer op */;
3177     case 'l':
3178       if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
3179         return 3; /* fldcw/fldenv */
3180       break;
3181     case 'n':
3182       if (mnemonic[2] != 'o' /* fnop */)
3183         return 3; /* non-waiting control op */
3184       break;
3185     case 'r':
3186       if (mnemonic[2] == 's')
3187         return 3; /* frstor/frstpm */
3188       break;
3189     case 's':
3190       if (mnemonic[2] == 'a')
3191         return 3; /* fsave */
3192       if (mnemonic[2] == 't')
3193         {
3194           switch (mnemonic[3])
3195             {
3196             case 'c': /* fstcw */
3197             case 'd': /* fstdw */
3198             case 'e': /* fstenv */
3199             case 's': /* fsts[gw] */
3200               return 3;
3201             }
3202         }
3203       break;
3204     case 'x':
3205       if (mnemonic[2] == 'r' || mnemonic[2] == 's')
3206         return 0; /* fxsave/fxrstor are not really math ops */
3207       break;
3208     }
3209
3210   return 1;
3211 }
3212
3213 /* Build the VEX prefix.  */
3214
3215 static void
3216 build_vex_prefix (const insn_template *t)
3217 {
3218   unsigned int register_specifier;
3219   unsigned int implied_prefix;
3220   unsigned int vector_length;
3221
3222   /* Check register specifier.  */
3223   if (i.vex.register_specifier)
3224     {
3225       register_specifier =
3226         ~register_number (i.vex.register_specifier) & 0xf;
3227       gas_assert ((i.vex.register_specifier->reg_flags & RegVRex) == 0);
3228     }
3229   else
3230     register_specifier = 0xf;
3231
3232   /* Use 2-byte VEX prefix by swapping destination and source
3233      operand.  */
3234   if (i.vec_encoding != vex_encoding_vex3
3235       && i.dir_encoding == dir_encoding_default
3236       && i.operands == i.reg_operands
3237       && i.tm.opcode_modifier.vexopcode == VEX0F
3238       && i.tm.opcode_modifier.load
3239       && i.rex == REX_B)
3240     {
3241       unsigned int xchg = i.operands - 1;
3242       union i386_op temp_op;
3243       i386_operand_type temp_type;
3244
3245       temp_type = i.types[xchg];
3246       i.types[xchg] = i.types[0];
3247       i.types[0] = temp_type;
3248       temp_op = i.op[xchg];
3249       i.op[xchg] = i.op[0];
3250       i.op[0] = temp_op;
3251
3252       gas_assert (i.rm.mode == 3);
3253
3254       i.rex = REX_R;
3255       xchg = i.rm.regmem;
3256       i.rm.regmem = i.rm.reg;
3257       i.rm.reg = xchg;
3258
3259       /* Use the next insn.  */
3260       i.tm = t[1];
3261     }
3262
3263   if (i.tm.opcode_modifier.vex == VEXScalar)
3264     vector_length = avxscalar;
3265   else if (i.tm.opcode_modifier.vex == VEX256)
3266     vector_length = 1;
3267   else
3268     {
3269       unsigned int op;
3270
3271       vector_length = 0;
3272       for (op = 0; op < t->operands; ++op)
3273         if (t->operand_types[op].bitfield.xmmword
3274             && t->operand_types[op].bitfield.ymmword
3275             && i.types[op].bitfield.ymmword)
3276           {
3277             vector_length = 1;
3278             break;
3279           }
3280     }
3281
3282   switch ((i.tm.base_opcode >> 8) & 0xff)
3283     {
3284     case 0:
3285       implied_prefix = 0;
3286       break;
3287     case DATA_PREFIX_OPCODE:
3288       implied_prefix = 1;
3289       break;
3290     case REPE_PREFIX_OPCODE:
3291       implied_prefix = 2;
3292       break;
3293     case REPNE_PREFIX_OPCODE:
3294       implied_prefix = 3;
3295       break;
3296     default:
3297       abort ();
3298     }
3299
3300   /* Use 2-byte VEX prefix if possible.  */
3301   if (i.vec_encoding != vex_encoding_vex3
3302       && i.tm.opcode_modifier.vexopcode == VEX0F
3303       && i.tm.opcode_modifier.vexw != VEXW1
3304       && (i.rex & (REX_W | REX_X | REX_B)) == 0)
3305     {
3306       /* 2-byte VEX prefix.  */
3307       unsigned int r;
3308
3309       i.vex.length = 2;
3310       i.vex.bytes[0] = 0xc5;
3311
3312       /* Check the REX.R bit.  */
3313       r = (i.rex & REX_R) ? 0 : 1;
3314       i.vex.bytes[1] = (r << 7
3315                         | register_specifier << 3
3316                         | vector_length << 2
3317                         | implied_prefix);
3318     }
3319   else
3320     {
3321       /* 3-byte VEX prefix.  */
3322       unsigned int m, w;
3323
3324       i.vex.length = 3;
3325
3326       switch (i.tm.opcode_modifier.vexopcode)
3327         {
3328         case VEX0F:
3329           m = 0x1;
3330           i.vex.bytes[0] = 0xc4;
3331           break;
3332         case VEX0F38:
3333           m = 0x2;
3334           i.vex.bytes[0] = 0xc4;
3335           break;
3336         case VEX0F3A:
3337           m = 0x3;
3338           i.vex.bytes[0] = 0xc4;
3339           break;
3340         case XOP08:
3341           m = 0x8;
3342           i.vex.bytes[0] = 0x8f;
3343           break;
3344         case XOP09:
3345           m = 0x9;
3346           i.vex.bytes[0] = 0x8f;
3347           break;
3348         case XOP0A:
3349           m = 0xa;
3350           i.vex.bytes[0] = 0x8f;
3351           break;
3352         default:
3353           abort ();
3354         }
3355
3356       /* The high 3 bits of the second VEX byte are 1's compliment
3357          of RXB bits from REX.  */
3358       i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3359
3360       /* Check the REX.W bit.  */
3361       w = (i.rex & REX_W) ? 1 : 0;
3362       if (i.tm.opcode_modifier.vexw == VEXW1)
3363         w = 1;
3364
3365       i.vex.bytes[2] = (w << 7
3366                         | register_specifier << 3
3367                         | vector_length << 2
3368                         | implied_prefix);
3369     }
3370 }
3371
3372 /* Build the EVEX prefix.  */
3373
3374 static void
3375 build_evex_prefix (void)
3376 {
3377   unsigned int register_specifier;
3378   unsigned int implied_prefix;
3379   unsigned int m, w;
3380   rex_byte vrex_used = 0;
3381
3382   /* Check register specifier.  */
3383   if (i.vex.register_specifier)
3384     {
3385       gas_assert ((i.vrex & REX_X) == 0);
3386
3387       register_specifier = i.vex.register_specifier->reg_num;
3388       if ((i.vex.register_specifier->reg_flags & RegRex))
3389         register_specifier += 8;
3390       /* The upper 16 registers are encoded in the fourth byte of the
3391          EVEX prefix.  */
3392       if (!(i.vex.register_specifier->reg_flags & RegVRex))
3393         i.vex.bytes[3] = 0x8;
3394       register_specifier = ~register_specifier & 0xf;
3395     }
3396   else
3397     {
3398       register_specifier = 0xf;
3399
3400       /* Encode upper 16 vector index register in the fourth byte of
3401          the EVEX prefix.  */
3402       if (!(i.vrex & REX_X))
3403         i.vex.bytes[3] = 0x8;
3404       else
3405         vrex_used |= REX_X;
3406     }
3407
3408   switch ((i.tm.base_opcode >> 8) & 0xff)
3409     {
3410     case 0:
3411       implied_prefix = 0;
3412       break;
3413     case DATA_PREFIX_OPCODE:
3414       implied_prefix = 1;
3415       break;
3416     case REPE_PREFIX_OPCODE:
3417       implied_prefix = 2;
3418       break;
3419     case REPNE_PREFIX_OPCODE:
3420       implied_prefix = 3;
3421       break;
3422     default:
3423       abort ();
3424     }
3425
3426   /* 4 byte EVEX prefix.  */
3427   i.vex.length = 4;
3428   i.vex.bytes[0] = 0x62;
3429
3430   /* mmmm bits.  */
3431   switch (i.tm.opcode_modifier.vexopcode)
3432     {
3433     case VEX0F:
3434       m = 1;
3435       break;
3436     case VEX0F38:
3437       m = 2;
3438       break;
3439     case VEX0F3A:
3440       m = 3;
3441       break;
3442     default:
3443       abort ();
3444       break;
3445     }
3446
3447   /* The high 3 bits of the second EVEX byte are 1's compliment of RXB
3448      bits from REX.  */
3449   i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3450
3451   /* The fifth bit of the second EVEX byte is 1's compliment of the
3452      REX_R bit in VREX.  */
3453   if (!(i.vrex & REX_R))
3454     i.vex.bytes[1] |= 0x10;
3455   else
3456     vrex_used |= REX_R;
3457
3458   if ((i.reg_operands + i.imm_operands) == i.operands)
3459     {
3460       /* When all operands are registers, the REX_X bit in REX is not
3461          used.  We reuse it to encode the upper 16 registers, which is
3462          indicated by the REX_B bit in VREX.  The REX_X bit is encoded
3463          as 1's compliment.  */
3464       if ((i.vrex & REX_B))
3465         {
3466           vrex_used |= REX_B;
3467           i.vex.bytes[1] &= ~0x40;
3468         }
3469     }
3470
3471   /* EVEX instructions shouldn't need the REX prefix.  */
3472   i.vrex &= ~vrex_used;
3473   gas_assert (i.vrex == 0);
3474
3475   /* Check the REX.W bit.  */
3476   w = (i.rex & REX_W) ? 1 : 0;
3477   if (i.tm.opcode_modifier.vexw)
3478     {
3479       if (i.tm.opcode_modifier.vexw == VEXW1)
3480         w = 1;
3481     }
3482   /* If w is not set it means we are dealing with WIG instruction.  */
3483   else if (!w)
3484     {
3485       if (evexwig == evexw1)
3486         w = 1;
3487     }
3488
3489   /* Encode the U bit.  */
3490   implied_prefix |= 0x4;
3491
3492   /* The third byte of the EVEX prefix.  */
3493   i.vex.bytes[2] = (w << 7 | register_specifier << 3 | implied_prefix);
3494
3495   /* The fourth byte of the EVEX prefix.  */
3496   /* The zeroing-masking bit.  */
3497   if (i.mask && i.mask->zeroing)
3498     i.vex.bytes[3] |= 0x80;
3499
3500   /* Don't always set the broadcast bit if there is no RC.  */
3501   if (!i.rounding)
3502     {
3503       /* Encode the vector length.  */
3504       unsigned int vec_length;
3505
3506       switch (i.tm.opcode_modifier.evex)
3507         {
3508         case EVEXLIG: /* LL' is ignored */
3509           vec_length = evexlig << 5;
3510           break;
3511         case EVEX128:
3512           vec_length = 0 << 5;
3513           break;
3514         case EVEX256:
3515           vec_length = 1 << 5;
3516           break;
3517         case EVEX512:
3518           vec_length = 2 << 5;
3519           break;
3520         default:
3521           abort ();
3522           break;
3523         }
3524       i.vex.bytes[3] |= vec_length;
3525       /* Encode the broadcast bit.  */
3526       if (i.broadcast)
3527         i.vex.bytes[3] |= 0x10;
3528     }
3529   else
3530     {
3531       if (i.rounding->type != saeonly)
3532         i.vex.bytes[3] |= 0x10 | (i.rounding->type << 5);
3533       else
3534         i.vex.bytes[3] |= 0x10 | (evexrcig << 5);
3535     }
3536
3537   if (i.mask && i.mask->mask)
3538     i.vex.bytes[3] |= i.mask->mask->reg_num;
3539 }
3540
3541 static void
3542 process_immext (void)
3543 {
3544   expressionS *exp;
3545
3546   if ((i.tm.cpu_flags.bitfield.cpusse3 || i.tm.cpu_flags.bitfield.cpusvme)
3547       && i.operands > 0)
3548     {
3549       /* MONITOR/MWAIT as well as SVME instructions have fixed operands
3550          with an opcode suffix which is coded in the same place as an
3551          8-bit immediate field would be.
3552          Here we check those operands and remove them afterwards.  */
3553       unsigned int x;
3554
3555       for (x = 0; x < i.operands; x++)
3556         if (register_number (i.op[x].regs) != x)
3557           as_bad (_("can't use register '%s%s' as operand %d in '%s'."),
3558                   register_prefix, i.op[x].regs->reg_name, x + 1,
3559                   i.tm.name);
3560
3561       i.operands = 0;
3562     }
3563
3564   if (i.tm.cpu_flags.bitfield.cpumwaitx && i.operands > 0)
3565     {
3566       /* MONITORX/MWAITX instructions have fixed operands with an opcode
3567          suffix which is coded in the same place as an 8-bit immediate
3568          field would be.
3569          Here we check those operands and remove them afterwards.  */
3570       unsigned int x;
3571
3572       if (i.operands != 3)
3573         abort();
3574
3575       for (x = 0; x < 2; x++)
3576         if (register_number (i.op[x].regs) != x)
3577           goto bad_register_operand;
3578
3579       /* Check for third operand for mwaitx/monitorx insn.  */
3580       if (register_number (i.op[x].regs)
3581           != (x + (i.tm.extension_opcode == 0xfb)))
3582         {
3583 bad_register_operand:
3584           as_bad (_("can't use register '%s%s' as operand %d in '%s'."),
3585                   register_prefix, i.op[x].regs->reg_name, x+1,
3586                   i.tm.name);
3587         }
3588
3589       i.operands = 0;
3590     }
3591
3592   /* These AMD 3DNow! and SSE2 instructions have an opcode suffix
3593      which is coded in the same place as an 8-bit immediate field
3594      would be.  Here we fake an 8-bit immediate operand from the
3595      opcode suffix stored in tm.extension_opcode.
3596
3597      AVX instructions also use this encoding, for some of
3598      3 argument instructions.  */
3599
3600   gas_assert (i.imm_operands <= 1
3601               && (i.operands <= 2
3602                   || ((i.tm.opcode_modifier.vex
3603                        || i.tm.opcode_modifier.evex)
3604                       && i.operands <= 4)));
3605
3606   exp = &im_expressions[i.imm_operands++];
3607   i.op[i.operands].imms = exp;
3608   i.types[i.operands] = imm8;
3609   i.operands++;
3610   exp->X_op = O_constant;
3611   exp->X_add_number = i.tm.extension_opcode;
3612   i.tm.extension_opcode = None;
3613 }
3614
3615
3616 static int
3617 check_hle (void)
3618 {
3619   switch (i.tm.opcode_modifier.hleprefixok)
3620     {
3621     default:
3622       abort ();
3623     case HLEPrefixNone:
3624       as_bad (_("invalid instruction `%s' after `%s'"),
3625               i.tm.name, i.hle_prefix);
3626       return 0;
3627     case HLEPrefixLock:
3628       if (i.prefix[LOCK_PREFIX])
3629         return 1;
3630       as_bad (_("missing `lock' with `%s'"), i.hle_prefix);
3631       return 0;
3632     case HLEPrefixAny:
3633       return 1;
3634     case HLEPrefixRelease:
3635       if (i.prefix[HLE_PREFIX] != XRELEASE_PREFIX_OPCODE)
3636         {
3637           as_bad (_("instruction `%s' after `xacquire' not allowed"),
3638                   i.tm.name);
3639           return 0;
3640         }
3641       if (i.mem_operands == 0
3642           || !operand_type_check (i.types[i.operands - 1], anymem))
3643         {
3644           as_bad (_("memory destination needed for instruction `%s'"
3645                     " after `xrelease'"), i.tm.name);
3646           return 0;
3647         }
3648       return 1;
3649     }
3650 }
3651
3652 /* This is the guts of the machine-dependent assembler.  LINE points to a
3653    machine dependent instruction.  This function is supposed to emit
3654    the frags/bytes it assembles to.  */
3655
3656 void
3657 md_assemble (char *line)
3658 {
3659   unsigned int j;
3660   char mnemonic[MAX_MNEM_SIZE], mnem_suffix;
3661   const insn_template *t;
3662
3663   /* Initialize globals.  */
3664   memset (&i, '\0', sizeof (i));
3665   for (j = 0; j < MAX_OPERANDS; j++)
3666     i.reloc[j] = NO_RELOC;
3667   memset (disp_expressions, '\0', sizeof (disp_expressions));
3668   memset (im_expressions, '\0', sizeof (im_expressions));
3669   save_stack_p = save_stack;
3670
3671   /* First parse an instruction mnemonic & call i386_operand for the operands.
3672      We assume that the scrubber has arranged it so that line[0] is the valid
3673      start of a (possibly prefixed) mnemonic.  */
3674
3675   line = parse_insn (line, mnemonic);
3676   if (line == NULL)
3677     return;
3678   mnem_suffix = i.suffix;
3679
3680   line = parse_operands (line, mnemonic);
3681   this_operand = -1;
3682   xfree (i.memop1_string);
3683   i.memop1_string = NULL;
3684   if (line == NULL)
3685     return;
3686
3687   /* Now we've parsed the mnemonic into a set of templates, and have the
3688      operands at hand.  */
3689
3690   /* All intel opcodes have reversed operands except for "bound" and
3691      "enter".  We also don't reverse intersegment "jmp" and "call"
3692      instructions with 2 immediate operands so that the immediate segment
3693      precedes the offset, as it does when in AT&T mode. */
3694   if (intel_syntax
3695       && i.operands > 1
3696       && (strcmp (mnemonic, "bound") != 0)
3697       && (strcmp (mnemonic, "invlpga") != 0)
3698       && !(operand_type_check (i.types[0], imm)
3699            && operand_type_check (i.types[1], imm)))
3700     swap_operands ();
3701
3702   /* The order of the immediates should be reversed
3703      for 2 immediates extrq and insertq instructions */
3704   if (i.imm_operands == 2
3705       && (strcmp (mnemonic, "extrq") == 0
3706           || strcmp (mnemonic, "insertq") == 0))
3707       swap_2_operands (0, 1);
3708
3709   if (i.imm_operands)
3710     optimize_imm ();
3711
3712   /* Don't optimize displacement for movabs since it only takes 64bit
3713      displacement.  */
3714   if (i.disp_operands
3715       && i.disp_encoding != disp_encoding_32bit
3716       && (flag_code != CODE_64BIT
3717           || strcmp (mnemonic, "movabs") != 0))
3718     optimize_disp ();
3719
3720   /* Next, we find a template that matches the given insn,
3721      making sure the overlap of the given operands types is consistent
3722      with the template operand types.  */
3723
3724   if (!(t = match_template (mnem_suffix)))
3725     return;
3726
3727   if (sse_check != check_none
3728       && !i.tm.opcode_modifier.noavx
3729       && (i.tm.cpu_flags.bitfield.cpusse
3730           || i.tm.cpu_flags.bitfield.cpusse2
3731           || i.tm.cpu_flags.bitfield.cpusse3
3732           || i.tm.cpu_flags.bitfield.cpussse3
3733           || i.tm.cpu_flags.bitfield.cpusse4_1
3734           || i.tm.cpu_flags.bitfield.cpusse4_2))
3735     {
3736       (sse_check == check_warning
3737        ? as_warn
3738        : as_bad) (_("SSE instruction `%s' is used"), i.tm.name);
3739     }
3740
3741   /* Zap movzx and movsx suffix.  The suffix has been set from
3742      "word ptr" or "byte ptr" on the source operand in Intel syntax
3743      or extracted from mnemonic in AT&T syntax.  But we'll use
3744      the destination register to choose the suffix for encoding.  */
3745   if ((i.tm.base_opcode & ~9) == 0x0fb6)
3746     {
3747       /* In Intel syntax, there must be a suffix.  In AT&T syntax, if
3748          there is no suffix, the default will be byte extension.  */
3749       if (i.reg_operands != 2
3750           && !i.suffix
3751           && intel_syntax)
3752         as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
3753
3754       i.suffix = 0;
3755     }
3756
3757   if (i.tm.opcode_modifier.fwait)
3758     if (!add_prefix (FWAIT_OPCODE))
3759       return;
3760
3761   /* Check if REP prefix is OK.  */
3762   if (i.rep_prefix && !i.tm.opcode_modifier.repprefixok)
3763     {
3764       as_bad (_("invalid instruction `%s' after `%s'"),
3765                 i.tm.name, i.rep_prefix);
3766       return;
3767     }
3768
3769   /* Check for lock without a lockable instruction.  Destination operand
3770      must be memory unless it is xchg (0x86).  */
3771   if (i.prefix[LOCK_PREFIX]
3772       && (!i.tm.opcode_modifier.islockable
3773           || i.mem_operands == 0
3774           || (i.tm.base_opcode != 0x86
3775               && !operand_type_check (i.types[i.operands - 1], anymem))))
3776     {
3777       as_bad (_("expecting lockable instruction after `lock'"));
3778       return;
3779     }
3780
3781   /* Check if HLE prefix is OK.  */
3782   if (i.hle_prefix && !check_hle ())
3783     return;
3784
3785   /* Check BND prefix.  */
3786   if (i.bnd_prefix && !i.tm.opcode_modifier.bndprefixok)
3787     as_bad (_("expecting valid branch instruction after `bnd'"));
3788
3789   /* Check NOTRACK prefix.  */
3790   if (i.notrack_prefix && !i.tm.opcode_modifier.notrackprefixok)
3791     as_bad (_("expecting indirect branch instruction after `notrack'"));
3792
3793   if (i.tm.cpu_flags.bitfield.cpumpx)
3794     {
3795       if (flag_code == CODE_64BIT && i.prefix[ADDR_PREFIX])
3796         as_bad (_("32-bit address isn't allowed in 64-bit MPX instructions."));
3797       else if (flag_code != CODE_16BIT
3798                ? i.prefix[ADDR_PREFIX]
3799                : i.mem_operands && !i.prefix[ADDR_PREFIX])
3800         as_bad (_("16-bit address isn't allowed in MPX instructions"));
3801     }
3802
3803   /* Insert BND prefix.  */
3804   if (add_bnd_prefix
3805       && i.tm.opcode_modifier.bndprefixok
3806       && !i.prefix[BND_PREFIX])
3807     add_prefix (BND_PREFIX_OPCODE);
3808
3809   /* Check string instruction segment overrides.  */
3810   if (i.tm.opcode_modifier.isstring && i.mem_operands != 0)
3811     {
3812       if (!check_string ())
3813         return;
3814       i.disp_operands = 0;
3815     }
3816
3817   if (!process_suffix ())
3818     return;
3819
3820   /* Update operand types.  */
3821   for (j = 0; j < i.operands; j++)
3822     i.types[j] = operand_type_and (i.types[j], i.tm.operand_types[j]);
3823
3824   /* Make still unresolved immediate matches conform to size of immediate
3825      given in i.suffix.  */
3826   if (!finalize_imm ())
3827     return;
3828
3829   if (i.types[0].bitfield.imm1)
3830     i.imm_operands = 0; /* kludge for shift insns.  */
3831
3832   /* We only need to check those implicit registers for instructions
3833      with 3 operands or less.  */
3834   if (i.operands <= 3)
3835     for (j = 0; j < i.operands; j++)
3836       if (i.types[j].bitfield.inoutportreg
3837           || i.types[j].bitfield.shiftcount
3838           || (i.types[j].bitfield.acc && !i.types[j].bitfield.xmmword))
3839         i.reg_operands--;
3840
3841   /* ImmExt should be processed after SSE2AVX.  */
3842   if (!i.tm.opcode_modifier.sse2avx
3843       && i.tm.opcode_modifier.immext)
3844     process_immext ();
3845
3846   /* For insns with operands there are more diddles to do to the opcode.  */
3847   if (i.operands)
3848     {
3849       if (!process_operands ())
3850         return;
3851     }
3852   else if (!quiet_warnings && i.tm.opcode_modifier.ugh)
3853     {
3854       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
3855       as_warn (_("translating to `%sp'"), i.tm.name);
3856     }
3857
3858   if (i.tm.opcode_modifier.vex || i.tm.opcode_modifier.evex)
3859     {
3860       if (flag_code == CODE_16BIT)
3861         {
3862           as_bad (_("instruction `%s' isn't supported in 16-bit mode."),
3863                   i.tm.name);
3864           return;
3865         }
3866
3867       if (i.tm.opcode_modifier.vex)
3868         build_vex_prefix (t);
3869       else
3870         build_evex_prefix ();
3871     }
3872
3873   /* Handle conversion of 'int $3' --> special int3 insn.  XOP or FMA4
3874      instructions may define INT_OPCODE as well, so avoid this corner
3875      case for those instructions that use MODRM.  */
3876   if (i.tm.base_opcode == INT_OPCODE
3877       && !i.tm.opcode_modifier.modrm
3878       && i.op[0].imms->X_add_number == 3)
3879     {
3880       i.tm.base_opcode = INT3_OPCODE;
3881       i.imm_operands = 0;
3882     }
3883
3884   if ((i.tm.opcode_modifier.jump
3885        || i.tm.opcode_modifier.jumpbyte
3886        || i.tm.opcode_modifier.jumpdword)
3887       && i.op[0].disps->X_op == O_constant)
3888     {
3889       /* Convert "jmp constant" (and "call constant") to a jump (call) to
3890          the absolute address given by the constant.  Since ix86 jumps and
3891          calls are pc relative, we need to generate a reloc.  */
3892       i.op[0].disps->X_add_symbol = &abs_symbol;
3893       i.op[0].disps->X_op = O_symbol;
3894     }
3895
3896   if (i.tm.opcode_modifier.rex64)
3897     i.rex |= REX_W;
3898
3899   /* For 8 bit registers we need an empty rex prefix.  Also if the
3900      instruction already has a prefix, we need to convert old
3901      registers to new ones.  */
3902
3903   if ((i.types[0].bitfield.reg && i.types[0].bitfield.byte
3904        && (i.op[0].regs->reg_flags & RegRex64) != 0)
3905       || (i.types[1].bitfield.reg && i.types[1].bitfield.byte
3906           && (i.op[1].regs->reg_flags & RegRex64) != 0)
3907       || (((i.types[0].bitfield.reg && i.types[0].bitfield.byte)
3908            || (i.types[1].bitfield.reg && i.types[1].bitfield.byte))
3909           && i.rex != 0))
3910     {
3911       int x;
3912
3913       i.rex |= REX_OPCODE;
3914       for (x = 0; x < 2; x++)
3915         {
3916           /* Look for 8 bit operand that uses old registers.  */
3917           if (i.types[x].bitfield.reg && i.types[x].bitfield.byte
3918               && (i.op[x].regs->reg_flags & RegRex64) == 0)
3919             {
3920               /* In case it is "hi" register, give up.  */
3921               if (i.op[x].regs->reg_num > 3)
3922                 as_bad (_("can't encode register '%s%s' in an "
3923                           "instruction requiring REX prefix."),
3924                         register_prefix, i.op[x].regs->reg_name);
3925
3926               /* Otherwise it is equivalent to the extended register.
3927                  Since the encoding doesn't change this is merely
3928                  cosmetic cleanup for debug output.  */
3929
3930               i.op[x].regs = i.op[x].regs + 8;
3931             }
3932         }
3933     }
3934
3935   if (i.rex != 0)
3936     add_prefix (REX_OPCODE | i.rex);
3937
3938   /* We are ready to output the insn.  */
3939   output_insn ();
3940 }
3941
3942 static char *
3943 parse_insn (char *line, char *mnemonic)
3944 {
3945   char *l = line;
3946   char *token_start = l;
3947   char *mnem_p;
3948   int supported;
3949   const insn_template *t;
3950   char *dot_p = NULL;
3951
3952   while (1)
3953     {
3954       mnem_p = mnemonic;
3955       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
3956         {
3957           if (*mnem_p == '.')
3958             dot_p = mnem_p;
3959           mnem_p++;
3960           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
3961             {
3962               as_bad (_("no such instruction: `%s'"), token_start);
3963               return NULL;
3964             }
3965           l++;
3966         }
3967       if (!is_space_char (*l)
3968           && *l != END_OF_INSN
3969           && (intel_syntax
3970               || (*l != PREFIX_SEPARATOR
3971                   && *l != ',')))
3972         {
3973           as_bad (_("invalid character %s in mnemonic"),
3974                   output_invalid (*l));
3975           return NULL;
3976         }
3977       if (token_start == l)
3978         {
3979           if (!intel_syntax && *l == PREFIX_SEPARATOR)
3980             as_bad (_("expecting prefix; got nothing"));
3981           else
3982             as_bad (_("expecting mnemonic; got nothing"));
3983           return NULL;
3984         }
3985
3986       /* Look up instruction (or prefix) via hash table.  */
3987       current_templates = (const templates *) hash_find (op_hash, mnemonic);
3988
3989       if (*l != END_OF_INSN
3990           && (!is_space_char (*l) || l[1] != END_OF_INSN)
3991           && current_templates
3992           && current_templates->start->opcode_modifier.isprefix)
3993         {
3994           if (!cpu_flags_check_cpu64 (current_templates->start->cpu_flags))
3995             {
3996               as_bad ((flag_code != CODE_64BIT
3997                        ? _("`%s' is only supported in 64-bit mode")
3998                        : _("`%s' is not supported in 64-bit mode")),
3999                       current_templates->start->name);
4000               return NULL;
4001             }
4002           /* If we are in 16-bit mode, do not allow addr16 or data16.
4003              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
4004           if ((current_templates->start->opcode_modifier.size16
4005                || current_templates->start->opcode_modifier.size32)
4006               && flag_code != CODE_64BIT
4007               && (current_templates->start->opcode_modifier.size32
4008                   ^ (flag_code == CODE_16BIT)))
4009             {
4010               as_bad (_("redundant %s prefix"),
4011                       current_templates->start->name);
4012               return NULL;
4013             }
4014           if (current_templates->start->opcode_length == 0)
4015             {
4016               /* Handle pseudo prefixes.  */
4017               switch (current_templates->start->base_opcode)
4018                 {
4019                 case 0x0:
4020                   /* {disp8} */
4021                   i.disp_encoding = disp_encoding_8bit;
4022                   break;
4023                 case 0x1:
4024                   /* {disp32} */
4025                   i.disp_encoding = disp_encoding_32bit;
4026                   break;
4027                 case 0x2:
4028                   /* {load} */
4029                   i.dir_encoding = dir_encoding_load;
4030                   break;
4031                 case 0x3:
4032                   /* {store} */
4033                   i.dir_encoding = dir_encoding_store;
4034                   break;
4035                 case 0x4:
4036                   /* {vex2} */
4037                   i.vec_encoding = vex_encoding_vex2;
4038                   break;
4039                 case 0x5:
4040                   /* {vex3} */
4041                   i.vec_encoding = vex_encoding_vex3;
4042                   break;
4043                 case 0x6:
4044                   /* {evex} */
4045                   i.vec_encoding = vex_encoding_evex;
4046                   break;
4047                 default:
4048                   abort ();
4049                 }
4050             }
4051           else
4052             {
4053               /* Add prefix, checking for repeated prefixes.  */
4054               switch (add_prefix (current_templates->start->base_opcode))
4055                 {
4056                 case PREFIX_EXIST:
4057                   return NULL;
4058                 case PREFIX_DS:
4059                   if (current_templates->start->cpu_flags.bitfield.cpuibt)
4060                     i.notrack_prefix = current_templates->start->name;
4061                   break;
4062                 case PREFIX_REP:
4063                   if (current_templates->start->cpu_flags.bitfield.cpuhle)
4064                     i.hle_prefix = current_templates->start->name;
4065                   else if (current_templates->start->cpu_flags.bitfield.cpumpx)
4066                     i.bnd_prefix = current_templates->start->name;
4067                   else
4068                     i.rep_prefix = current_templates->start->name;
4069                   break;
4070                 default:
4071                   break;
4072                 }
4073             }
4074           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
4075           token_start = ++l;
4076         }
4077       else
4078         break;
4079     }
4080
4081   if (!current_templates)
4082     {
4083       /* Check if we should swap operand or force 32bit displacement in
4084          encoding.  */
4085       if (mnem_p - 2 == dot_p && dot_p[1] == 's')
4086         i.dir_encoding = dir_encoding_store;
4087       else if (mnem_p - 3 == dot_p
4088                && dot_p[1] == 'd'
4089                && dot_p[2] == '8')
4090         i.disp_encoding = disp_encoding_8bit;
4091       else if (mnem_p - 4 == dot_p
4092                && dot_p[1] == 'd'
4093                && dot_p[2] == '3'
4094                && dot_p[3] == '2')
4095         i.disp_encoding = disp_encoding_32bit;
4096       else
4097         goto check_suffix;
4098       mnem_p = dot_p;
4099       *dot_p = '\0';
4100       current_templates = (const templates *) hash_find (op_hash, mnemonic);
4101     }
4102
4103   if (!current_templates)
4104     {
4105 check_suffix:
4106       /* See if we can get a match by trimming off a suffix.  */
4107       switch (mnem_p[-1])
4108         {
4109         case WORD_MNEM_SUFFIX:
4110           if (intel_syntax && (intel_float_operand (mnemonic) & 2))
4111             i.suffix = SHORT_MNEM_SUFFIX;
4112           else
4113             /* Fall through.  */
4114         case BYTE_MNEM_SUFFIX:
4115         case QWORD_MNEM_SUFFIX:
4116           i.suffix = mnem_p[-1];
4117           mnem_p[-1] = '\0';
4118           current_templates = (const templates *) hash_find (op_hash,
4119                                                              mnemonic);
4120           break;
4121         case SHORT_MNEM_SUFFIX:
4122         case LONG_MNEM_SUFFIX:
4123           if (!intel_syntax)
4124             {
4125               i.suffix = mnem_p[-1];
4126               mnem_p[-1] = '\0';
4127               current_templates = (const templates *) hash_find (op_hash,
4128                                                                  mnemonic);
4129             }
4130           break;
4131
4132           /* Intel Syntax.  */
4133         case 'd':
4134           if (intel_syntax)
4135             {
4136               if (intel_float_operand (mnemonic) == 1)
4137                 i.suffix = SHORT_MNEM_SUFFIX;
4138               else
4139                 i.suffix = LONG_MNEM_SUFFIX;
4140               mnem_p[-1] = '\0';
4141               current_templates = (const templates *) hash_find (op_hash,
4142                                                                  mnemonic);
4143             }
4144           break;
4145         }
4146       if (!current_templates)
4147         {
4148           as_bad (_("no such instruction: `%s'"), token_start);
4149           return NULL;
4150         }
4151     }
4152
4153   if (current_templates->start->opcode_modifier.jump
4154       || current_templates->start->opcode_modifier.jumpbyte)
4155     {
4156       /* Check for a branch hint.  We allow ",pt" and ",pn" for
4157          predict taken and predict not taken respectively.
4158          I'm not sure that branch hints actually do anything on loop
4159          and jcxz insns (JumpByte) for current Pentium4 chips.  They
4160          may work in the future and it doesn't hurt to accept them
4161          now.  */
4162       if (l[0] == ',' && l[1] == 'p')
4163         {
4164           if (l[2] == 't')
4165             {
4166               if (!add_prefix (DS_PREFIX_OPCODE))
4167                 return NULL;
4168               l += 3;
4169             }
4170           else if (l[2] == 'n')
4171             {
4172               if (!add_prefix (CS_PREFIX_OPCODE))
4173                 return NULL;
4174               l += 3;
4175             }
4176         }
4177     }
4178   /* Any other comma loses.  */
4179   if (*l == ',')
4180     {
4181       as_bad (_("invalid character %s in mnemonic"),
4182               output_invalid (*l));
4183       return NULL;
4184     }
4185
4186   /* Check if instruction is supported on specified architecture.  */
4187   supported = 0;
4188   for (t = current_templates->start; t < current_templates->end; ++t)
4189     {
4190       supported |= cpu_flags_match (t);
4191       if (supported == CPU_FLAGS_PERFECT_MATCH)
4192         goto skip;
4193     }
4194
4195   if (!(supported & CPU_FLAGS_64BIT_MATCH))
4196     {
4197       as_bad (flag_code == CODE_64BIT
4198               ? _("`%s' is not supported in 64-bit mode")
4199               : _("`%s' is only supported in 64-bit mode"),
4200               current_templates->start->name);
4201       return NULL;
4202     }
4203   if (supported != CPU_FLAGS_PERFECT_MATCH)
4204     {
4205       as_bad (_("`%s' is not supported on `%s%s'"),
4206               current_templates->start->name,
4207               cpu_arch_name ? cpu_arch_name : default_arch,
4208               cpu_sub_arch_name ? cpu_sub_arch_name : "");
4209       return NULL;
4210     }
4211
4212 skip:
4213   if (!cpu_arch_flags.bitfield.cpui386
4214            && (flag_code != CODE_16BIT))
4215     {
4216       as_warn (_("use .code16 to ensure correct addressing mode"));
4217     }
4218
4219   return l;
4220 }
4221
4222 static char *
4223 parse_operands (char *l, const char *mnemonic)
4224 {
4225   char *token_start;
4226
4227   /* 1 if operand is pending after ','.  */
4228   unsigned int expecting_operand = 0;
4229
4230   /* Non-zero if operand parens not balanced.  */
4231   unsigned int paren_not_balanced;
4232
4233   while (*l != END_OF_INSN)
4234     {
4235       /* Skip optional white space before operand.  */
4236       if (is_space_char (*l))
4237         ++l;
4238       if (!is_operand_char (*l) && *l != END_OF_INSN && *l != '"')
4239         {
4240           as_bad (_("invalid character %s before operand %d"),
4241                   output_invalid (*l),
4242                   i.operands + 1);
4243           return NULL;
4244         }
4245       token_start = l;  /* After white space.  */
4246       paren_not_balanced = 0;
4247       while (paren_not_balanced || *l != ',')
4248         {
4249           if (*l == END_OF_INSN)
4250             {
4251               if (paren_not_balanced)
4252                 {
4253                   if (!intel_syntax)
4254                     as_bad (_("unbalanced parenthesis in operand %d."),
4255                             i.operands + 1);
4256                   else
4257                     as_bad (_("unbalanced brackets in operand %d."),
4258                             i.operands + 1);
4259                   return NULL;
4260                 }
4261               else
4262                 break;  /* we are done */
4263             }
4264           else if (!is_operand_char (*l) && !is_space_char (*l) && *l != '"')
4265             {
4266               as_bad (_("invalid character %s in operand %d"),
4267                       output_invalid (*l),
4268                       i.operands + 1);
4269               return NULL;
4270             }
4271           if (!intel_syntax)
4272             {
4273               if (*l == '(')
4274                 ++paren_not_balanced;
4275               if (*l == ')')
4276                 --paren_not_balanced;
4277             }
4278           else
4279             {
4280               if (*l == '[')
4281                 ++paren_not_balanced;
4282               if (*l == ']')
4283                 --paren_not_balanced;
4284             }
4285           l++;
4286         }
4287       if (l != token_start)
4288         {                       /* Yes, we've read in another operand.  */
4289           unsigned int operand_ok;
4290           this_operand = i.operands++;
4291           if (i.operands > MAX_OPERANDS)
4292             {
4293               as_bad (_("spurious operands; (%d operands/instruction max)"),
4294                       MAX_OPERANDS);
4295               return NULL;
4296             }
4297           i.types[this_operand].bitfield.unspecified = 1;
4298           /* Now parse operand adding info to 'i' as we go along.  */
4299           END_STRING_AND_SAVE (l);
4300
4301           if (intel_syntax)
4302             operand_ok =
4303               i386_intel_operand (token_start,
4304                                   intel_float_operand (mnemonic));
4305           else
4306             operand_ok = i386_att_operand (token_start);
4307
4308           RESTORE_END_STRING (l);
4309           if (!operand_ok)
4310             return NULL;
4311         }
4312       else
4313         {
4314           if (expecting_operand)
4315             {
4316             expecting_operand_after_comma:
4317               as_bad (_("expecting operand after ','; got nothing"));
4318               return NULL;
4319             }
4320           if (*l == ',')
4321             {
4322               as_bad (_("expecting operand before ','; got nothing"));
4323               return NULL;
4324             }
4325         }
4326
4327       /* Now *l must be either ',' or END_OF_INSN.  */
4328       if (*l == ',')
4329         {
4330           if (*++l == END_OF_INSN)
4331             {
4332               /* Just skip it, if it's \n complain.  */
4333               goto expecting_operand_after_comma;
4334             }
4335           expecting_operand = 1;
4336         }
4337     }
4338   return l;
4339 }
4340
4341 static void
4342 swap_2_operands (int xchg1, int xchg2)
4343 {
4344   union i386_op temp_op;
4345   i386_operand_type temp_type;
4346   enum bfd_reloc_code_real temp_reloc;
4347
4348   temp_type = i.types[xchg2];
4349   i.types[xchg2] = i.types[xchg1];
4350   i.types[xchg1] = temp_type;
4351   temp_op = i.op[xchg2];
4352   i.op[xchg2] = i.op[xchg1];
4353   i.op[xchg1] = temp_op;
4354   temp_reloc = i.reloc[xchg2];
4355   i.reloc[xchg2] = i.reloc[xchg1];
4356   i.reloc[xchg1] = temp_reloc;
4357
4358   if (i.mask)
4359     {
4360       if (i.mask->operand == xchg1)
4361         i.mask->operand = xchg2;
4362       else if (i.mask->operand == xchg2)
4363         i.mask->operand = xchg1;
4364     }
4365   if (i.broadcast)
4366     {
4367       if (i.broadcast->operand == xchg1)
4368         i.broadcast->operand = xchg2;
4369       else if (i.broadcast->operand == xchg2)
4370         i.broadcast->operand = xchg1;
4371     }
4372   if (i.rounding)
4373     {
4374       if (i.rounding->operand == xchg1)
4375         i.rounding->operand = xchg2;
4376       else if (i.rounding->operand == xchg2)
4377         i.rounding->operand = xchg1;
4378     }
4379 }
4380
4381 static void
4382 swap_operands (void)
4383 {
4384   switch (i.operands)
4385     {
4386     case 5:
4387     case 4:
4388       swap_2_operands (1, i.operands - 2);
4389       /* Fall through.  */
4390     case 3:
4391     case 2:
4392       swap_2_operands (0, i.operands - 1);
4393       break;
4394     default:
4395       abort ();
4396     }
4397
4398   if (i.mem_operands == 2)
4399     {
4400       const seg_entry *temp_seg;
4401       temp_seg = i.seg[0];
4402       i.seg[0] = i.seg[1];
4403       i.seg[1] = temp_seg;
4404     }
4405 }
4406
4407 /* Try to ensure constant immediates are represented in the smallest
4408    opcode possible.  */
4409 static void
4410 optimize_imm (void)
4411 {
4412   char guess_suffix = 0;
4413   int op;
4414
4415   if (i.suffix)
4416     guess_suffix = i.suffix;
4417   else if (i.reg_operands)
4418     {
4419       /* Figure out a suffix from the last register operand specified.
4420          We can't do this properly yet, ie. excluding InOutPortReg,
4421          but the following works for instructions with immediates.
4422          In any case, we can't set i.suffix yet.  */
4423       for (op = i.operands; --op >= 0;)
4424         if (i.types[op].bitfield.reg && i.types[op].bitfield.byte)
4425           {
4426             guess_suffix = BYTE_MNEM_SUFFIX;
4427             break;
4428           }
4429         else if (i.types[op].bitfield.reg && i.types[op].bitfield.word)
4430           {
4431             guess_suffix = WORD_MNEM_SUFFIX;
4432             break;
4433           }
4434         else if (i.types[op].bitfield.reg && i.types[op].bitfield.dword)
4435           {
4436             guess_suffix = LONG_MNEM_SUFFIX;
4437             break;
4438           }
4439         else if (i.types[op].bitfield.reg && i.types[op].bitfield.qword)
4440           {
4441             guess_suffix = QWORD_MNEM_SUFFIX;
4442             break;
4443           }
4444     }
4445   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
4446     guess_suffix = WORD_MNEM_SUFFIX;
4447
4448   for (op = i.operands; --op >= 0;)
4449     if (operand_type_check (i.types[op], imm))
4450       {
4451         switch (i.op[op].imms->X_op)
4452           {
4453           case O_constant:
4454             /* If a suffix is given, this operand may be shortened.  */
4455             switch (guess_suffix)
4456               {
4457               case LONG_MNEM_SUFFIX:
4458                 i.types[op].bitfield.imm32 = 1;
4459                 i.types[op].bitfield.imm64 = 1;
4460                 break;
4461               case WORD_MNEM_SUFFIX:
4462                 i.types[op].bitfield.imm16 = 1;
4463                 i.types[op].bitfield.imm32 = 1;
4464                 i.types[op].bitfield.imm32s = 1;
4465                 i.types[op].bitfield.imm64 = 1;
4466                 break;
4467               case BYTE_MNEM_SUFFIX:
4468                 i.types[op].bitfield.imm8 = 1;
4469                 i.types[op].bitfield.imm8s = 1;
4470                 i.types[op].bitfield.imm16 = 1;
4471                 i.types[op].bitfield.imm32 = 1;
4472                 i.types[op].bitfield.imm32s = 1;
4473                 i.types[op].bitfield.imm64 = 1;
4474                 break;
4475               }
4476
4477             /* If this operand is at most 16 bits, convert it
4478                to a signed 16 bit number before trying to see
4479                whether it will fit in an even smaller size.
4480                This allows a 16-bit operand such as $0xffe0 to
4481                be recognised as within Imm8S range.  */
4482             if ((i.types[op].bitfield.imm16)
4483                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
4484               {
4485                 i.op[op].imms->X_add_number =
4486                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
4487               }
4488 #ifdef BFD64
4489             /* Store 32-bit immediate in 64-bit for 64-bit BFD.  */
4490             if ((i.types[op].bitfield.imm32)
4491                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
4492                     == 0))
4493               {
4494                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
4495                                                 ^ ((offsetT) 1 << 31))
4496                                                - ((offsetT) 1 << 31));
4497               }
4498 #endif
4499             i.types[op]
4500               = operand_type_or (i.types[op],
4501                                  smallest_imm_type (i.op[op].imms->X_add_number));
4502
4503             /* We must avoid matching of Imm32 templates when 64bit
4504                only immediate is available.  */
4505             if (guess_suffix == QWORD_MNEM_SUFFIX)
4506               i.types[op].bitfield.imm32 = 0;
4507             break;
4508
4509           case O_absent:
4510           case O_register:
4511             abort ();
4512
4513             /* Symbols and expressions.  */
4514           default:
4515             /* Convert symbolic operand to proper sizes for matching, but don't
4516                prevent matching a set of insns that only supports sizes other
4517                than those matching the insn suffix.  */
4518             {
4519               i386_operand_type mask, allowed;
4520               const insn_template *t;
4521
4522               operand_type_set (&mask, 0);
4523               operand_type_set (&allowed, 0);
4524
4525               for (t = current_templates->start;
4526                    t < current_templates->end;
4527                    ++t)
4528                 allowed = operand_type_or (allowed,
4529                                            t->operand_types[op]);
4530               switch (guess_suffix)
4531                 {
4532                 case QWORD_MNEM_SUFFIX:
4533                   mask.bitfield.imm64 = 1;
4534                   mask.bitfield.imm32s = 1;
4535                   break;
4536                 case LONG_MNEM_SUFFIX:
4537                   mask.bitfield.imm32 = 1;
4538                   break;
4539                 case WORD_MNEM_SUFFIX:
4540                   mask.bitfield.imm16 = 1;
4541                   break;
4542                 case BYTE_MNEM_SUFFIX:
4543                   mask.bitfield.imm8 = 1;
4544                   break;
4545                 default:
4546                   break;
4547                 }
4548               allowed = operand_type_and (mask, allowed);
4549               if (!operand_type_all_zero (&allowed))
4550                 i.types[op] = operand_type_and (i.types[op], mask);
4551             }
4552             break;
4553           }
4554       }
4555 }
4556
4557 /* Try to use the smallest displacement type too.  */
4558 static void
4559 optimize_disp (void)
4560 {
4561   int op;
4562
4563   for (op = i.operands; --op >= 0;)
4564     if (operand_type_check (i.types[op], disp))
4565       {
4566         if (i.op[op].disps->X_op == O_constant)
4567           {
4568             offsetT op_disp = i.op[op].disps->X_add_number;
4569
4570             if (i.types[op].bitfield.disp16
4571                 && (op_disp & ~(offsetT) 0xffff) == 0)
4572               {
4573                 /* If this operand is at most 16 bits, convert
4574                    to a signed 16 bit number and don't use 64bit
4575                    displacement.  */
4576                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
4577                 i.types[op].bitfield.disp64 = 0;
4578               }
4579 #ifdef BFD64
4580             /* Optimize 64-bit displacement to 32-bit for 64-bit BFD.  */
4581             if (i.types[op].bitfield.disp32
4582                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
4583               {
4584                 /* If this operand is at most 32 bits, convert
4585                    to a signed 32 bit number and don't use 64bit
4586                    displacement.  */
4587                 op_disp &= (((offsetT) 2 << 31) - 1);
4588                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
4589                 i.types[op].bitfield.disp64 = 0;
4590               }
4591 #endif
4592             if (!op_disp && i.types[op].bitfield.baseindex)
4593               {
4594                 i.types[op].bitfield.disp8 = 0;
4595                 i.types[op].bitfield.disp16 = 0;
4596                 i.types[op].bitfield.disp32 = 0;
4597                 i.types[op].bitfield.disp32s = 0;
4598                 i.types[op].bitfield.disp64 = 0;
4599                 i.op[op].disps = 0;
4600                 i.disp_operands--;
4601               }
4602             else if (flag_code == CODE_64BIT)
4603               {
4604                 if (fits_in_signed_long (op_disp))
4605                   {
4606                     i.types[op].bitfield.disp64 = 0;
4607                     i.types[op].bitfield.disp32s = 1;
4608                   }
4609                 if (i.prefix[ADDR_PREFIX]
4610                     && fits_in_unsigned_long (op_disp))
4611                   i.types[op].bitfield.disp32 = 1;
4612               }
4613             if ((i.types[op].bitfield.disp32
4614                  || i.types[op].bitfield.disp32s
4615                  || i.types[op].bitfield.disp16)
4616                 && fits_in_disp8 (op_disp))
4617               i.types[op].bitfield.disp8 = 1;
4618           }
4619         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
4620                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
4621           {
4622             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
4623                          i.op[op].disps, 0, i.reloc[op]);
4624             i.types[op].bitfield.disp8 = 0;
4625             i.types[op].bitfield.disp16 = 0;
4626             i.types[op].bitfield.disp32 = 0;
4627             i.types[op].bitfield.disp32s = 0;
4628             i.types[op].bitfield.disp64 = 0;
4629           }
4630         else
4631           /* We only support 64bit displacement on constants.  */
4632           i.types[op].bitfield.disp64 = 0;
4633       }
4634 }
4635
4636 /* Check if operands are valid for the instruction.  */
4637
4638 static int
4639 check_VecOperands (const insn_template *t)
4640 {
4641   unsigned int op;
4642
4643   /* Without VSIB byte, we can't have a vector register for index.  */
4644   if (!t->opcode_modifier.vecsib
4645       && i.index_reg
4646       && (i.index_reg->reg_type.bitfield.xmmword
4647           || i.index_reg->reg_type.bitfield.ymmword
4648           || i.index_reg->reg_type.bitfield.zmmword))
4649     {
4650       i.error = unsupported_vector_index_register;
4651       return 1;
4652     }
4653
4654   /* Check if default mask is allowed.  */
4655   if (t->opcode_modifier.nodefmask
4656       && (!i.mask || i.mask->mask->reg_num == 0))
4657     {
4658       i.error = no_default_mask;
4659       return 1;
4660     }
4661
4662   /* For VSIB byte, we need a vector register for index, and all vector
4663      registers must be distinct.  */
4664   if (t->opcode_modifier.vecsib)
4665     {
4666       if (!i.index_reg
4667           || !((t->opcode_modifier.vecsib == VecSIB128
4668                 && i.index_reg->reg_type.bitfield.xmmword)
4669                || (t->opcode_modifier.vecsib == VecSIB256
4670                    && i.index_reg->reg_type.bitfield.ymmword)
4671                || (t->opcode_modifier.vecsib == VecSIB512
4672                    && i.index_reg->reg_type.bitfield.zmmword)))
4673       {
4674         i.error = invalid_vsib_address;
4675         return 1;
4676       }
4677
4678       gas_assert (i.reg_operands == 2 || i.mask);
4679       if (i.reg_operands == 2 && !i.mask)
4680         {
4681           gas_assert (i.types[0].bitfield.regsimd);
4682           gas_assert (i.types[0].bitfield.xmmword
4683                       || i.types[0].bitfield.ymmword);
4684           gas_assert (i.types[2].bitfield.regsimd);
4685           gas_assert (i.types[2].bitfield.xmmword
4686                       || i.types[2].bitfield.ymmword);
4687           if (operand_check == check_none)
4688             return 0;
4689           if (register_number (i.op[0].regs)
4690               != register_number (i.index_reg)
4691               && register_number (i.op[2].regs)
4692                  != register_number (i.index_reg)
4693               && register_number (i.op[0].regs)
4694                  != register_number (i.op[2].regs))
4695             return 0;
4696           if (operand_check == check_error)
4697             {
4698               i.error = invalid_vector_register_set;
4699               return 1;
4700             }
4701           as_warn (_("mask, index, and destination registers should be distinct"));
4702         }
4703       else if (i.reg_operands == 1 && i.mask)
4704         {
4705           if (i.types[1].bitfield.regsimd
4706               && (i.types[1].bitfield.xmmword
4707                   || i.types[1].bitfield.ymmword
4708                   || i.types[1].bitfield.zmmword)
4709               && (register_number (i.op[1].regs)
4710                   == register_number (i.index_reg)))
4711             {
4712               if (operand_check == check_error)
4713                 {
4714                   i.error = invalid_vector_register_set;
4715                   return 1;
4716                 }
4717               if (operand_check != check_none)
4718                 as_warn (_("index and destination registers should be distinct"));
4719             }
4720         }
4721     }
4722
4723   /* Check if broadcast is supported by the instruction and is applied
4724      to the memory operand.  */
4725   if (i.broadcast)
4726     {
4727       int broadcasted_opnd_size;
4728
4729       /* Check if specified broadcast is supported in this instruction,
4730          and it's applied to memory operand of DWORD or QWORD type,
4731          depending on VecESize.  */
4732       if (i.broadcast->type != t->opcode_modifier.broadcast
4733           || !i.types[i.broadcast->operand].bitfield.mem
4734           || (t->opcode_modifier.vecesize == 0
4735               && !i.types[i.broadcast->operand].bitfield.dword
4736               && !i.types[i.broadcast->operand].bitfield.unspecified)
4737           || (t->opcode_modifier.vecesize == 1
4738               && !i.types[i.broadcast->operand].bitfield.qword
4739               && !i.types[i.broadcast->operand].bitfield.unspecified))
4740         goto bad_broadcast;
4741
4742       broadcasted_opnd_size = t->opcode_modifier.vecesize ? 64 : 32;
4743       if (i.broadcast->type == BROADCAST_1TO16)
4744         broadcasted_opnd_size <<= 4; /* Broadcast 1to16.  */
4745       else if (i.broadcast->type == BROADCAST_1TO8)
4746         broadcasted_opnd_size <<= 3; /* Broadcast 1to8.  */
4747       else if (i.broadcast->type == BROADCAST_1TO4)
4748         broadcasted_opnd_size <<= 2; /* Broadcast 1to4.  */
4749       else if (i.broadcast->type == BROADCAST_1TO2)
4750         broadcasted_opnd_size <<= 1; /* Broadcast 1to2.  */
4751       else
4752         goto bad_broadcast;
4753
4754       if ((broadcasted_opnd_size == 256
4755            && !t->operand_types[i.broadcast->operand].bitfield.ymmword)
4756           || (broadcasted_opnd_size == 512
4757               && !t->operand_types[i.broadcast->operand].bitfield.zmmword))
4758         {
4759         bad_broadcast:
4760           i.error = unsupported_broadcast;
4761           return 1;
4762         }
4763     }
4764   /* If broadcast is supported in this instruction, we need to check if
4765      operand of one-element size isn't specified without broadcast.  */
4766   else if (t->opcode_modifier.broadcast && i.mem_operands)
4767     {
4768       /* Find memory operand.  */
4769       for (op = 0; op < i.operands; op++)
4770         if (operand_type_check (i.types[op], anymem))
4771           break;
4772       gas_assert (op < i.operands);
4773       /* Check size of the memory operand.  */
4774       if ((t->opcode_modifier.vecesize == 0
4775            && i.types[op].bitfield.dword)
4776           || (t->opcode_modifier.vecesize == 1
4777               && i.types[op].bitfield.qword))
4778         {
4779           i.error = broadcast_needed;
4780           return 1;
4781         }
4782     }
4783
4784   /* Check if requested masking is supported.  */
4785   if (i.mask
4786       && (!t->opcode_modifier.masking
4787           || (i.mask->zeroing
4788               && t->opcode_modifier.masking == MERGING_MASKING)))
4789     {
4790       i.error = unsupported_masking;
4791       return 1;
4792     }
4793
4794   /* Check if masking is applied to dest operand.  */
4795   if (i.mask && (i.mask->operand != (int) (i.operands - 1)))
4796     {
4797       i.error = mask_not_on_destination;
4798       return 1;
4799     }
4800
4801   /* Check RC/SAE.  */
4802   if (i.rounding)
4803     {
4804       if ((i.rounding->type != saeonly
4805            && !t->opcode_modifier.staticrounding)
4806           || (i.rounding->type == saeonly
4807               && (t->opcode_modifier.staticrounding
4808                   || !t->opcode_modifier.sae)))
4809         {
4810           i.error = unsupported_rc_sae;
4811           return 1;
4812         }
4813       /* If the instruction has several immediate operands and one of
4814          them is rounding, the rounding operand should be the last
4815          immediate operand.  */
4816       if (i.imm_operands > 1
4817           && i.rounding->operand != (int) (i.imm_operands - 1))
4818         {
4819           i.error = rc_sae_operand_not_last_imm;
4820           return 1;
4821         }
4822     }
4823
4824   /* Check vector Disp8 operand.  */
4825   if (t->opcode_modifier.disp8memshift
4826       && i.disp_encoding != disp_encoding_32bit)
4827     {
4828       if (i.broadcast)
4829         i.memshift = t->opcode_modifier.vecesize ? 3 : 2;
4830       else
4831         i.memshift = t->opcode_modifier.disp8memshift;
4832
4833       for (op = 0; op < i.operands; op++)
4834         if (operand_type_check (i.types[op], disp)
4835             && i.op[op].disps->X_op == O_constant)
4836           {
4837             if (fits_in_disp8 (i.op[op].disps->X_add_number))
4838               {
4839                 i.types[op].bitfield.disp8 = 1;
4840                 return 0;
4841               }
4842             i.types[op].bitfield.disp8 = 0;
4843           }
4844     }
4845
4846   i.memshift = 0;
4847
4848   return 0;
4849 }
4850
4851 /* Check if operands are valid for the instruction.  Update VEX
4852    operand types.  */
4853
4854 static int
4855 VEX_check_operands (const insn_template *t)
4856 {
4857   if (i.vec_encoding == vex_encoding_evex)
4858     {
4859       /* This instruction must be encoded with EVEX prefix.  */
4860       if (!t->opcode_modifier.evex)
4861         {
4862           i.error = unsupported;
4863           return 1;
4864         }
4865       return 0;
4866     }
4867
4868   if (!t->opcode_modifier.vex)
4869     {
4870       /* This instruction template doesn't have VEX prefix.  */
4871       if (i.vec_encoding != vex_encoding_default)
4872         {
4873           i.error = unsupported;
4874           return 1;
4875         }
4876       return 0;
4877     }
4878
4879   /* Only check VEX_Imm4, which must be the first operand.  */
4880   if (t->operand_types[0].bitfield.vec_imm4)
4881     {
4882       if (i.op[0].imms->X_op != O_constant
4883           || !fits_in_imm4 (i.op[0].imms->X_add_number))
4884         {
4885           i.error = bad_imm4;
4886           return 1;
4887         }
4888
4889       /* Turn off Imm8 so that update_imm won't complain.  */
4890       i.types[0] = vec_imm4;
4891     }
4892
4893   return 0;
4894 }
4895
4896 static const insn_template *
4897 match_template (char mnem_suffix)
4898 {
4899   /* Points to template once we've found it.  */
4900   const insn_template *t;
4901   i386_operand_type overlap0, overlap1, overlap2, overlap3;
4902   i386_operand_type overlap4;
4903   unsigned int found_reverse_match;
4904   i386_opcode_modifier suffix_check, mnemsuf_check;
4905   i386_operand_type operand_types [MAX_OPERANDS];
4906   int addr_prefix_disp;
4907   unsigned int j;
4908   unsigned int found_cpu_match;
4909   unsigned int check_register;
4910   enum i386_error specific_error = 0;
4911
4912 #if MAX_OPERANDS != 5
4913 # error "MAX_OPERANDS must be 5."
4914 #endif
4915
4916   found_reverse_match = 0;
4917   addr_prefix_disp = -1;
4918
4919   memset (&suffix_check, 0, sizeof (suffix_check));
4920   if (i.suffix == BYTE_MNEM_SUFFIX)
4921     suffix_check.no_bsuf = 1;
4922   else if (i.suffix == WORD_MNEM_SUFFIX)
4923     suffix_check.no_wsuf = 1;
4924   else if (i.suffix == SHORT_MNEM_SUFFIX)
4925     suffix_check.no_ssuf = 1;
4926   else if (i.suffix == LONG_MNEM_SUFFIX)
4927     suffix_check.no_lsuf = 1;
4928   else if (i.suffix == QWORD_MNEM_SUFFIX)
4929     suffix_check.no_qsuf = 1;
4930   else if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
4931     suffix_check.no_ldsuf = 1;
4932
4933   memset (&mnemsuf_check, 0, sizeof (mnemsuf_check));
4934   if (intel_syntax)
4935     {
4936       switch (mnem_suffix)
4937         {
4938         case BYTE_MNEM_SUFFIX:  mnemsuf_check.no_bsuf = 1; break;
4939         case WORD_MNEM_SUFFIX:  mnemsuf_check.no_wsuf = 1; break;
4940         case SHORT_MNEM_SUFFIX: mnemsuf_check.no_ssuf = 1; break;
4941         case LONG_MNEM_SUFFIX:  mnemsuf_check.no_lsuf = 1; break;
4942         case QWORD_MNEM_SUFFIX: mnemsuf_check.no_qsuf = 1; break;
4943         }
4944     }
4945
4946   /* Must have right number of operands.  */
4947   i.error = number_of_operands_mismatch;
4948
4949   for (t = current_templates->start; t < current_templates->end; t++)
4950     {
4951       addr_prefix_disp = -1;
4952
4953       if (i.operands != t->operands)
4954         continue;
4955
4956       /* Check processor support.  */
4957       i.error = unsupported;
4958       found_cpu_match = (cpu_flags_match (t)
4959                          == CPU_FLAGS_PERFECT_MATCH);
4960       if (!found_cpu_match)
4961         continue;
4962
4963       /* Check old gcc support. */
4964       i.error = old_gcc_only;
4965       if (!old_gcc && t->opcode_modifier.oldgcc)
4966         continue;
4967
4968       /* Check AT&T mnemonic.   */
4969       i.error = unsupported_with_intel_mnemonic;
4970       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
4971         continue;
4972
4973       /* Check AT&T/Intel syntax and Intel64/AMD64 ISA.   */
4974       i.error = unsupported_syntax;
4975       if ((intel_syntax && t->opcode_modifier.attsyntax)
4976           || (!intel_syntax && t->opcode_modifier.intelsyntax)
4977           || (intel64 && t->opcode_modifier.amd64)
4978           || (!intel64 && t->opcode_modifier.intel64))
4979         continue;
4980
4981       /* Check the suffix, except for some instructions in intel mode.  */
4982       i.error = invalid_instruction_suffix;
4983       if ((!intel_syntax || !t->opcode_modifier.ignoresize)
4984           && ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
4985               || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
4986               || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
4987               || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
4988               || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
4989               || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf)))
4990         continue;
4991       /* In Intel mode all mnemonic suffixes must be explicitly allowed.  */
4992       if ((t->opcode_modifier.no_bsuf && mnemsuf_check.no_bsuf)
4993           || (t->opcode_modifier.no_wsuf && mnemsuf_check.no_wsuf)
4994           || (t->opcode_modifier.no_lsuf && mnemsuf_check.no_lsuf)
4995           || (t->opcode_modifier.no_ssuf && mnemsuf_check.no_ssuf)
4996           || (t->opcode_modifier.no_qsuf && mnemsuf_check.no_qsuf)
4997           || (t->opcode_modifier.no_ldsuf && mnemsuf_check.no_ldsuf))
4998         continue;
4999
5000       if (!operand_size_match (t))
5001         continue;
5002
5003       for (j = 0; j < MAX_OPERANDS; j++)
5004         operand_types[j] = t->operand_types[j];
5005
5006       /* In general, don't allow 64-bit operands in 32-bit mode.  */
5007       if (i.suffix == QWORD_MNEM_SUFFIX
5008           && flag_code != CODE_64BIT
5009           && (intel_syntax
5010               ? (!t->opcode_modifier.ignoresize
5011                  && !intel_float_operand (t->name))
5012               : intel_float_operand (t->name) != 2)
5013           && ((!operand_types[0].bitfield.regmmx
5014                && !operand_types[0].bitfield.regsimd)
5015               || (!operand_types[t->operands > 1].bitfield.regmmx
5016                   && !operand_types[t->operands > 1].bitfield.regsimd))
5017           && (t->base_opcode != 0x0fc7
5018               || t->extension_opcode != 1 /* cmpxchg8b */))
5019         continue;
5020
5021       /* In general, don't allow 32-bit operands on pre-386.  */
5022       else if (i.suffix == LONG_MNEM_SUFFIX
5023                && !cpu_arch_flags.bitfield.cpui386
5024                && (intel_syntax
5025                    ? (!t->opcode_modifier.ignoresize
5026                       && !intel_float_operand (t->name))
5027                    : intel_float_operand (t->name) != 2)
5028                && ((!operand_types[0].bitfield.regmmx
5029                     && !operand_types[0].bitfield.regsimd)
5030                    || (!operand_types[t->operands > 1].bitfield.regmmx
5031                        && !operand_types[t->operands > 1].bitfield.regsimd)))
5032         continue;
5033
5034       /* Do not verify operands when there are none.  */
5035       else
5036         {
5037           if (!t->operands)
5038             /* We've found a match; break out of loop.  */
5039             break;
5040         }
5041
5042       /* Address size prefix will turn Disp64/Disp32/Disp16 operand
5043          into Disp32/Disp16/Disp32 operand.  */
5044       if (i.prefix[ADDR_PREFIX] != 0)
5045           {
5046             /* There should be only one Disp operand.  */
5047             switch (flag_code)
5048             {
5049             case CODE_16BIT:
5050               for (j = 0; j < MAX_OPERANDS; j++)
5051                 {
5052                   if (operand_types[j].bitfield.disp16)
5053                     {
5054                       addr_prefix_disp = j;
5055                       operand_types[j].bitfield.disp32 = 1;
5056                       operand_types[j].bitfield.disp16 = 0;
5057                       break;
5058                     }
5059                 }
5060               break;
5061             case CODE_32BIT:
5062               for (j = 0; j < MAX_OPERANDS; j++)
5063                 {
5064                   if (operand_types[j].bitfield.disp32)
5065                     {
5066                       addr_prefix_disp = j;
5067                       operand_types[j].bitfield.disp32 = 0;
5068                       operand_types[j].bitfield.disp16 = 1;
5069                       break;
5070                     }
5071                 }
5072               break;
5073             case CODE_64BIT:
5074               for (j = 0; j < MAX_OPERANDS; j++)
5075                 {
5076                   if (operand_types[j].bitfield.disp64)
5077                     {
5078                       addr_prefix_disp = j;
5079                       operand_types[j].bitfield.disp64 = 0;
5080                       operand_types[j].bitfield.disp32 = 1;
5081                       break;
5082                     }
5083                 }
5084               break;
5085             }
5086           }
5087
5088       /* Force 0x8b encoding for "mov foo@GOT, %eax".  */
5089       if (i.reloc[0] == BFD_RELOC_386_GOT32 && t->base_opcode == 0xa0)
5090         continue;
5091
5092       /* We check register size if needed.  */
5093       check_register = t->opcode_modifier.checkregsize;
5094       overlap0 = operand_type_and (i.types[0], operand_types[0]);
5095       switch (t->operands)
5096         {
5097         case 1:
5098           if (!operand_type_match (overlap0, i.types[0]))
5099             continue;
5100           break;
5101         case 2:
5102           /* xchg %eax, %eax is a special case. It is an alias for nop
5103              only in 32bit mode and we can use opcode 0x90.  In 64bit
5104              mode, we can't use 0x90 for xchg %eax, %eax since it should
5105              zero-extend %eax to %rax.  */
5106           if (flag_code == CODE_64BIT
5107               && t->base_opcode == 0x90
5108               && operand_type_equal (&i.types [0], &acc32)
5109               && operand_type_equal (&i.types [1], &acc32))
5110             continue;
5111           /* If we want store form, we reverse direction of operands.  */
5112           if (i.dir_encoding == dir_encoding_store
5113               && t->opcode_modifier.d)
5114             goto check_reverse;
5115           /* Fall through.  */
5116
5117         case 3:
5118           /* If we want store form, we skip the current load.  */
5119           if (i.dir_encoding == dir_encoding_store
5120               && i.mem_operands == 0
5121               && t->opcode_modifier.load)
5122             continue;
5123           /* Fall through.  */
5124         case 4:
5125         case 5:
5126           overlap1 = operand_type_and (i.types[1], operand_types[1]);
5127           if (!operand_type_match (overlap0, i.types[0])
5128               || !operand_type_match (overlap1, i.types[1])
5129               || (check_register
5130                   && !operand_type_register_match (i.types[0],
5131                                                    operand_types[0],
5132                                                    i.types[1],
5133                                                    operand_types[1])))
5134             {
5135               /* Check if other direction is valid ...  */
5136               if (!t->opcode_modifier.d && !t->opcode_modifier.floatd)
5137                 continue;
5138
5139 check_reverse:
5140               /* Try reversing direction of operands.  */
5141               overlap0 = operand_type_and (i.types[0], operand_types[1]);
5142               overlap1 = operand_type_and (i.types[1], operand_types[0]);
5143               if (!operand_type_match (overlap0, i.types[0])
5144                   || !operand_type_match (overlap1, i.types[1])
5145                   || (check_register
5146                       && !operand_type_register_match (i.types[0],
5147                                                        operand_types[1],
5148                                                        i.types[1],
5149                                                        operand_types[0])))
5150                 {
5151                   /* Does not match either direction.  */
5152                   continue;
5153                 }
5154               /* found_reverse_match holds which of D or FloatDR
5155                  we've found.  */
5156               if (t->opcode_modifier.d)
5157                 found_reverse_match = Opcode_D;
5158               else if (t->opcode_modifier.floatd)
5159                 found_reverse_match = Opcode_FloatD;
5160               else
5161                 found_reverse_match = 0;
5162               if (t->opcode_modifier.floatr)
5163                 found_reverse_match |= Opcode_FloatR;
5164             }
5165           else
5166             {
5167               /* Found a forward 2 operand match here.  */
5168               switch (t->operands)
5169                 {
5170                 case 5:
5171                   overlap4 = operand_type_and (i.types[4],
5172                                                operand_types[4]);
5173                   /* Fall through.  */
5174                 case 4:
5175                   overlap3 = operand_type_and (i.types[3],
5176                                                operand_types[3]);
5177                   /* Fall through.  */
5178                 case 3:
5179                   overlap2 = operand_type_and (i.types[2],
5180                                                operand_types[2]);
5181                   break;
5182                 }
5183
5184               switch (t->operands)
5185                 {
5186                 case 5:
5187                   if (!operand_type_match (overlap4, i.types[4])
5188                       || !operand_type_register_match (i.types[3],
5189                                                        operand_types[3],
5190                                                        i.types[4],
5191                                                        operand_types[4]))
5192                     continue;
5193                   /* Fall through.  */
5194                 case 4:
5195                   if (!operand_type_match (overlap3, i.types[3])
5196                       || (check_register
5197                           && !operand_type_register_match (i.types[2],
5198                                                            operand_types[2],
5199                                                            i.types[3],
5200                                                            operand_types[3])))
5201                     continue;
5202                   /* Fall through.  */
5203                 case 3:
5204                   /* Here we make use of the fact that there are no
5205                      reverse match 3 operand instructions, and all 3
5206                      operand instructions only need to be checked for
5207                      register consistency between operands 2 and 3.  */
5208                   if (!operand_type_match (overlap2, i.types[2])
5209                       || (check_register
5210                           && !operand_type_register_match (i.types[1],
5211                                                            operand_types[1],
5212                                                            i.types[2],
5213                                                            operand_types[2])))
5214                     continue;
5215                   break;
5216                 }
5217             }
5218           /* Found either forward/reverse 2, 3 or 4 operand match here:
5219              slip through to break.  */
5220         }
5221       if (!found_cpu_match)
5222         {
5223           found_reverse_match = 0;
5224           continue;
5225         }
5226
5227       /* Check if vector and VEX operands are valid.  */
5228       if (check_VecOperands (t) || VEX_check_operands (t))
5229         {
5230           specific_error = i.error;
5231           continue;
5232         }
5233
5234       /* We've found a match; break out of loop.  */
5235       break;
5236     }
5237
5238   if (t == current_templates->end)
5239     {
5240       /* We found no match.  */
5241       const char *err_msg;
5242       switch (specific_error ? specific_error : i.error)
5243         {
5244         default:
5245           abort ();
5246         case operand_size_mismatch:
5247           err_msg = _("operand size mismatch");
5248           break;
5249         case operand_type_mismatch:
5250           err_msg = _("operand type mismatch");
5251           break;
5252         case register_type_mismatch:
5253           err_msg = _("register type mismatch");
5254           break;
5255         case number_of_operands_mismatch:
5256           err_msg = _("number of operands mismatch");
5257           break;
5258         case invalid_instruction_suffix:
5259           err_msg = _("invalid instruction suffix");
5260           break;
5261         case bad_imm4:
5262           err_msg = _("constant doesn't fit in 4 bits");
5263           break;
5264         case old_gcc_only:
5265           err_msg = _("only supported with old gcc");
5266           break;
5267         case unsupported_with_intel_mnemonic:
5268           err_msg = _("unsupported with Intel mnemonic");
5269           break;
5270         case unsupported_syntax:
5271           err_msg = _("unsupported syntax");
5272           break;
5273         case unsupported:
5274           as_bad (_("unsupported instruction `%s'"),
5275                   current_templates->start->name);
5276           return NULL;
5277         case invalid_vsib_address:
5278           err_msg = _("invalid VSIB address");
5279           break;
5280         case invalid_vector_register_set:
5281           err_msg = _("mask, index, and destination registers must be distinct");
5282           break;
5283         case unsupported_vector_index_register:
5284           err_msg = _("unsupported vector index register");
5285           break;
5286         case unsupported_broadcast:
5287           err_msg = _("unsupported broadcast");
5288           break;
5289         case broadcast_not_on_src_operand:
5290           err_msg = _("broadcast not on source memory operand");
5291           break;
5292         case broadcast_needed:
5293           err_msg = _("broadcast is needed for operand of such type");
5294           break;
5295         case unsupported_masking:
5296           err_msg = _("unsupported masking");
5297           break;
5298         case mask_not_on_destination:
5299           err_msg = _("mask not on destination operand");
5300           break;
5301         case no_default_mask:
5302           err_msg = _("default mask isn't allowed");
5303           break;
5304         case unsupported_rc_sae:
5305           err_msg = _("unsupported static rounding/sae");
5306           break;
5307         case rc_sae_operand_not_last_imm:
5308           if (intel_syntax)
5309             err_msg = _("RC/SAE operand must precede immediate operands");
5310           else
5311             err_msg = _("RC/SAE operand must follow immediate operands");
5312           break;
5313         case invalid_register_operand:
5314           err_msg = _("invalid register operand");
5315           break;
5316         }
5317       as_bad (_("%s for `%s'"), err_msg,
5318               current_templates->start->name);
5319       return NULL;
5320     }
5321
5322   if (!quiet_warnings)
5323     {
5324       if (!intel_syntax
5325           && (i.types[0].bitfield.jumpabsolute
5326               != operand_types[0].bitfield.jumpabsolute))
5327         {
5328           as_warn (_("indirect %s without `*'"), t->name);
5329         }
5330
5331       if (t->opcode_modifier.isprefix
5332           && t->opcode_modifier.ignoresize)
5333         {
5334           /* Warn them that a data or address size prefix doesn't
5335              affect assembly of the next line of code.  */
5336           as_warn (_("stand-alone `%s' prefix"), t->name);
5337         }
5338     }
5339
5340   /* Copy the template we found.  */
5341   i.tm = *t;
5342
5343   if (addr_prefix_disp != -1)
5344     i.tm.operand_types[addr_prefix_disp]
5345       = operand_types[addr_prefix_disp];
5346
5347   if (found_reverse_match)
5348     {
5349       /* If we found a reverse match we must alter the opcode
5350          direction bit.  found_reverse_match holds bits to change
5351          (different for int & float insns).  */
5352
5353       i.tm.base_opcode ^= found_reverse_match;
5354
5355       i.tm.operand_types[0] = operand_types[1];
5356       i.tm.operand_types[1] = operand_types[0];
5357     }
5358
5359   return t;
5360 }
5361
5362 static int
5363 check_string (void)
5364 {
5365   int mem_op = operand_type_check (i.types[0], anymem) ? 0 : 1;
5366   if (i.tm.operand_types[mem_op].bitfield.esseg)
5367     {
5368       if (i.seg[0] != NULL && i.seg[0] != &es)
5369         {
5370           as_bad (_("`%s' operand %d must use `%ses' segment"),
5371                   i.tm.name,
5372                   mem_op + 1,
5373                   register_prefix);
5374           return 0;
5375         }
5376       /* There's only ever one segment override allowed per instruction.
5377          This instruction possibly has a legal segment override on the
5378          second operand, so copy the segment to where non-string
5379          instructions store it, allowing common code.  */
5380       i.seg[0] = i.seg[1];
5381     }
5382   else if (i.tm.operand_types[mem_op + 1].bitfield.esseg)
5383     {
5384       if (i.seg[1] != NULL && i.seg[1] != &es)
5385         {
5386           as_bad (_("`%s' operand %d must use `%ses' segment"),
5387                   i.tm.name,
5388                   mem_op + 2,
5389                   register_prefix);
5390           return 0;
5391         }
5392     }
5393   return 1;
5394 }
5395
5396 static int
5397 process_suffix (void)
5398 {
5399   /* If matched instruction specifies an explicit instruction mnemonic
5400      suffix, use it.  */
5401   if (i.tm.opcode_modifier.size16)
5402     i.suffix = WORD_MNEM_SUFFIX;
5403   else if (i.tm.opcode_modifier.size32)
5404     i.suffix = LONG_MNEM_SUFFIX;
5405   else if (i.tm.opcode_modifier.size64)
5406     i.suffix = QWORD_MNEM_SUFFIX;
5407   else if (i.reg_operands)
5408     {
5409       /* If there's no instruction mnemonic suffix we try to invent one
5410          based on register operands.  */
5411       if (!i.suffix)
5412         {
5413           /* We take i.suffix from the last register operand specified,
5414              Destination register type is more significant than source
5415              register type.  crc32 in SSE4.2 prefers source register
5416              type. */
5417           if (i.tm.base_opcode == 0xf20f38f1)
5418             {
5419               if (i.types[0].bitfield.reg && i.types[0].bitfield.word)
5420                 i.suffix = WORD_MNEM_SUFFIX;
5421               else if (i.types[0].bitfield.reg && i.types[0].bitfield.dword)
5422                 i.suffix = LONG_MNEM_SUFFIX;
5423               else if (i.types[0].bitfield.reg && i.types[0].bitfield.qword)
5424                 i.suffix = QWORD_MNEM_SUFFIX;
5425             }
5426           else if (i.tm.base_opcode == 0xf20f38f0)
5427             {
5428               if (i.types[0].bitfield.reg && i.types[0].bitfield.byte)
5429                 i.suffix = BYTE_MNEM_SUFFIX;
5430             }
5431
5432           if (!i.suffix)
5433             {
5434               int op;
5435
5436               if (i.tm.base_opcode == 0xf20f38f1
5437                   || i.tm.base_opcode == 0xf20f38f0)
5438                 {
5439                   /* We have to know the operand size for crc32.  */
5440                   as_bad (_("ambiguous memory operand size for `%s`"),
5441                           i.tm.name);
5442                   return 0;
5443                 }
5444
5445               for (op = i.operands; --op >= 0;)
5446                 if (!i.tm.operand_types[op].bitfield.inoutportreg
5447                     && !i.tm.operand_types[op].bitfield.shiftcount)
5448                   {
5449                     if (i.types[op].bitfield.reg && i.types[op].bitfield.byte)
5450                       {
5451                         i.suffix = BYTE_MNEM_SUFFIX;
5452                         break;
5453                       }
5454                     if (i.types[op].bitfield.reg && i.types[op].bitfield.word)
5455                       {
5456                         i.suffix = WORD_MNEM_SUFFIX;
5457                         break;
5458                       }
5459                     if (i.types[op].bitfield.reg && i.types[op].bitfield.dword)
5460                       {
5461                         i.suffix = LONG_MNEM_SUFFIX;
5462                         break;
5463                       }
5464                     if (i.types[op].bitfield.reg && i.types[op].bitfield.qword)
5465                       {
5466                         i.suffix = QWORD_MNEM_SUFFIX;
5467                         break;
5468                       }
5469                   }
5470             }
5471         }
5472       else if (i.suffix == BYTE_MNEM_SUFFIX)
5473         {
5474           if (intel_syntax
5475               && i.tm.opcode_modifier.ignoresize
5476               && i.tm.opcode_modifier.no_bsuf)
5477             i.suffix = 0;
5478           else if (!check_byte_reg ())
5479             return 0;
5480         }
5481       else if (i.suffix == LONG_MNEM_SUFFIX)
5482         {
5483           if (intel_syntax
5484               && i.tm.opcode_modifier.ignoresize
5485               && i.tm.opcode_modifier.no_lsuf)
5486             i.suffix = 0;
5487           else if (!check_long_reg ())
5488             return 0;
5489         }
5490       else if (i.suffix == QWORD_MNEM_SUFFIX)
5491         {
5492           if (intel_syntax
5493               && i.tm.opcode_modifier.ignoresize
5494               && i.tm.opcode_modifier.no_qsuf)
5495             i.suffix = 0;
5496           else if (!check_qword_reg ())
5497             return 0;
5498         }
5499       else if (i.suffix == WORD_MNEM_SUFFIX)
5500         {
5501           if (intel_syntax
5502               && i.tm.opcode_modifier.ignoresize
5503               && i.tm.opcode_modifier.no_wsuf)
5504             i.suffix = 0;
5505           else if (!check_word_reg ())
5506             return 0;
5507         }
5508       else if (i.suffix == XMMWORD_MNEM_SUFFIX
5509                || i.suffix == YMMWORD_MNEM_SUFFIX
5510                || i.suffix == ZMMWORD_MNEM_SUFFIX)
5511         {
5512           /* Skip if the instruction has x/y/z suffix.  match_template
5513              should check if it is a valid suffix.  */
5514         }
5515       else if (intel_syntax && i.tm.opcode_modifier.ignoresize)
5516         /* Do nothing if the instruction is going to ignore the prefix.  */
5517         ;
5518       else
5519         abort ();
5520     }
5521   else if (i.tm.opcode_modifier.defaultsize
5522            && !i.suffix
5523            /* exclude fldenv/frstor/fsave/fstenv */
5524            && i.tm.opcode_modifier.no_ssuf)
5525     {
5526       i.suffix = stackop_size;
5527     }
5528   else if (intel_syntax
5529            && !i.suffix
5530            && (i.tm.operand_types[0].bitfield.jumpabsolute
5531                || i.tm.opcode_modifier.jumpbyte
5532                || i.tm.opcode_modifier.jumpintersegment
5533                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
5534                    && i.tm.extension_opcode <= 3)))
5535     {
5536       switch (flag_code)
5537         {
5538         case CODE_64BIT:
5539           if (!i.tm.opcode_modifier.no_qsuf)
5540             {
5541               i.suffix = QWORD_MNEM_SUFFIX;
5542               break;
5543             }
5544           /* Fall through.  */
5545         case CODE_32BIT:
5546           if (!i.tm.opcode_modifier.no_lsuf)
5547             i.suffix = LONG_MNEM_SUFFIX;
5548           break;
5549         case CODE_16BIT:
5550           if (!i.tm.opcode_modifier.no_wsuf)
5551             i.suffix = WORD_MNEM_SUFFIX;
5552           break;
5553         }
5554     }
5555
5556   if (!i.suffix)
5557     {
5558       if (!intel_syntax)
5559         {
5560           if (i.tm.opcode_modifier.w)
5561             {
5562               as_bad (_("no instruction mnemonic suffix given and "
5563                         "no register operands; can't size instruction"));
5564               return 0;
5565             }
5566         }
5567       else
5568         {
5569           unsigned int suffixes;
5570
5571           suffixes = !i.tm.opcode_modifier.no_bsuf;
5572           if (!i.tm.opcode_modifier.no_wsuf)
5573             suffixes |= 1 << 1;
5574           if (!i.tm.opcode_modifier.no_lsuf)
5575             suffixes |= 1 << 2;
5576           if (!i.tm.opcode_modifier.no_ldsuf)
5577             suffixes |= 1 << 3;
5578           if (!i.tm.opcode_modifier.no_ssuf)
5579             suffixes |= 1 << 4;
5580           if (flag_code == CODE_64BIT && !i.tm.opcode_modifier.no_qsuf)
5581             suffixes |= 1 << 5;
5582
5583           /* There are more than suffix matches.  */
5584           if (i.tm.opcode_modifier.w
5585               || ((suffixes & (suffixes - 1))
5586                   && !i.tm.opcode_modifier.defaultsize
5587                   && !i.tm.opcode_modifier.ignoresize))
5588             {
5589               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
5590               return 0;
5591             }
5592         }
5593     }
5594
5595   /* Change the opcode based on the operand size given by i.suffix;
5596      We don't need to change things for byte insns.  */
5597
5598   if (i.suffix
5599       && i.suffix != BYTE_MNEM_SUFFIX
5600       && i.suffix != XMMWORD_MNEM_SUFFIX
5601       && i.suffix != YMMWORD_MNEM_SUFFIX
5602       && i.suffix != ZMMWORD_MNEM_SUFFIX)
5603     {
5604       /* It's not a byte, select word/dword operation.  */
5605       if (i.tm.opcode_modifier.w)
5606         {
5607           if (i.tm.opcode_modifier.shortform)
5608             i.tm.base_opcode |= 8;
5609           else
5610             i.tm.base_opcode |= 1;
5611         }
5612
5613       /* Now select between word & dword operations via the operand
5614          size prefix, except for instructions that will ignore this
5615          prefix anyway.  */
5616       if (i.tm.opcode_modifier.addrprefixop0)
5617         {
5618           /* The address size override prefix changes the size of the
5619              first operand.  */
5620           if ((flag_code == CODE_32BIT
5621                && i.op->regs[0].reg_type.bitfield.word)
5622               || (flag_code != CODE_32BIT
5623                   && i.op->regs[0].reg_type.bitfield.dword))
5624             if (!add_prefix (ADDR_PREFIX_OPCODE))
5625               return 0;
5626         }
5627       else if (i.suffix != QWORD_MNEM_SUFFIX
5628                && i.suffix != LONG_DOUBLE_MNEM_SUFFIX
5629                && !i.tm.opcode_modifier.ignoresize
5630                && !i.tm.opcode_modifier.floatmf
5631                && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
5632                    || (flag_code == CODE_64BIT
5633                        && i.tm.opcode_modifier.jumpbyte)))
5634         {
5635           unsigned int prefix = DATA_PREFIX_OPCODE;
5636
5637           if (i.tm.opcode_modifier.jumpbyte) /* jcxz, loop */
5638             prefix = ADDR_PREFIX_OPCODE;
5639
5640           if (!add_prefix (prefix))
5641             return 0;
5642         }
5643
5644       /* Set mode64 for an operand.  */
5645       if (i.suffix == QWORD_MNEM_SUFFIX
5646           && flag_code == CODE_64BIT
5647           && !i.tm.opcode_modifier.norex64)
5648         {
5649           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
5650              need rex64.  cmpxchg8b is also a special case. */
5651           if (! (i.operands == 2
5652                  && i.tm.base_opcode == 0x90
5653                  && i.tm.extension_opcode == None
5654                  && operand_type_equal (&i.types [0], &acc64)
5655                  && operand_type_equal (&i.types [1], &acc64))
5656               && ! (i.operands == 1
5657                     && i.tm.base_opcode == 0xfc7
5658                     && i.tm.extension_opcode == 1
5659                     && !operand_type_check (i.types [0], reg)
5660                     && operand_type_check (i.types [0], anymem)))
5661             i.rex |= REX_W;
5662         }
5663
5664       /* Size floating point instruction.  */
5665       if (i.suffix == LONG_MNEM_SUFFIX)
5666         if (i.tm.opcode_modifier.floatmf)
5667           i.tm.base_opcode ^= 4;
5668     }
5669
5670   return 1;
5671 }
5672
5673 static int
5674 check_byte_reg (void)
5675 {
5676   int op;
5677
5678   for (op = i.operands; --op >= 0;)
5679     {
5680       /* Skip non-register operands. */
5681       if (!i.types[op].bitfield.reg)
5682         continue;
5683
5684       /* If this is an eight bit register, it's OK.  If it's the 16 or
5685          32 bit version of an eight bit register, we will just use the
5686          low portion, and that's OK too.  */
5687       if (i.types[op].bitfield.byte)
5688         continue;
5689
5690       /* I/O port address operands are OK too.  */
5691       if (i.tm.operand_types[op].bitfield.inoutportreg)
5692         continue;
5693
5694       /* crc32 doesn't generate this warning.  */
5695       if (i.tm.base_opcode == 0xf20f38f0)
5696         continue;
5697
5698       if ((i.types[op].bitfield.word
5699            || i.types[op].bitfield.dword
5700            || i.types[op].bitfield.qword)
5701           && i.op[op].regs->reg_num < 4
5702           /* Prohibit these changes in 64bit mode, since the lowering
5703              would be more complicated.  */
5704           && flag_code != CODE_64BIT)
5705         {
5706 #if REGISTER_WARNINGS
5707           if (!quiet_warnings)
5708             as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
5709                      register_prefix,
5710                      (i.op[op].regs + (i.types[op].bitfield.word
5711                                        ? REGNAM_AL - REGNAM_AX
5712                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
5713                      register_prefix,
5714                      i.op[op].regs->reg_name,
5715                      i.suffix);
5716 #endif
5717           continue;
5718         }
5719       /* Any other register is bad.  */
5720       if (i.types[op].bitfield.reg
5721           || i.types[op].bitfield.regmmx
5722           || i.types[op].bitfield.regsimd
5723           || i.types[op].bitfield.sreg2
5724           || i.types[op].bitfield.sreg3
5725           || i.types[op].bitfield.control
5726           || i.types[op].bitfield.debug
5727           || i.types[op].bitfield.test)
5728         {
5729           as_bad (_("`%s%s' not allowed with `%s%c'"),
5730                   register_prefix,
5731                   i.op[op].regs->reg_name,
5732                   i.tm.name,
5733                   i.suffix);
5734           return 0;
5735         }
5736     }
5737   return 1;
5738 }
5739
5740 static int
5741 check_long_reg (void)
5742 {
5743   int op;
5744
5745   for (op = i.operands; --op >= 0;)
5746     /* Skip non-register operands. */
5747     if (!i.types[op].bitfield.reg)
5748       continue;
5749     /* Reject eight bit registers, except where the template requires
5750        them. (eg. movzb)  */
5751     else if (i.types[op].bitfield.byte
5752              && (i.tm.operand_types[op].bitfield.reg
5753                  || i.tm.operand_types[op].bitfield.acc)
5754              && (i.tm.operand_types[op].bitfield.word
5755                  || i.tm.operand_types[op].bitfield.dword))
5756       {
5757         as_bad (_("`%s%s' not allowed with `%s%c'"),
5758                 register_prefix,
5759                 i.op[op].regs->reg_name,
5760                 i.tm.name,
5761                 i.suffix);
5762         return 0;
5763       }
5764     /* Warn if the e prefix on a general reg is missing.  */
5765     else if ((!quiet_warnings || flag_code == CODE_64BIT)
5766              && i.types[op].bitfield.word
5767              && (i.tm.operand_types[op].bitfield.reg
5768                  || i.tm.operand_types[op].bitfield.acc)
5769              && i.tm.operand_types[op].bitfield.dword)
5770       {
5771         /* Prohibit these changes in the 64bit mode, since the
5772            lowering is more complicated.  */
5773         if (flag_code == CODE_64BIT)
5774           {
5775             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
5776                     register_prefix, i.op[op].regs->reg_name,
5777                     i.suffix);
5778             return 0;
5779           }
5780 #if REGISTER_WARNINGS
5781         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
5782                  register_prefix,
5783                  (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
5784                  register_prefix, i.op[op].regs->reg_name, i.suffix);
5785 #endif
5786       }
5787     /* Warn if the r prefix on a general reg is present.  */
5788     else if (i.types[op].bitfield.qword
5789              && (i.tm.operand_types[op].bitfield.reg
5790                  || i.tm.operand_types[op].bitfield.acc)
5791              && i.tm.operand_types[op].bitfield.dword)
5792       {
5793         if (intel_syntax
5794             && i.tm.opcode_modifier.toqword
5795             && !i.types[0].bitfield.regsimd)
5796           {
5797             /* Convert to QWORD.  We want REX byte. */
5798             i.suffix = QWORD_MNEM_SUFFIX;
5799           }
5800         else
5801           {
5802             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
5803                     register_prefix, i.op[op].regs->reg_name,
5804                     i.suffix);
5805             return 0;
5806           }
5807       }
5808   return 1;
5809 }
5810
5811 static int
5812 check_qword_reg (void)
5813 {
5814   int op;
5815
5816   for (op = i.operands; --op >= 0; )
5817     /* Skip non-register operands. */
5818     if (!i.types[op].bitfield.reg)
5819       continue;
5820     /* Reject eight bit registers, except where the template requires
5821        them. (eg. movzb)  */
5822     else if (i.types[op].bitfield.byte
5823              && (i.tm.operand_types[op].bitfield.reg
5824                  || i.tm.operand_types[op].bitfield.acc)
5825              && (i.tm.operand_types[op].bitfield.word
5826                  || i.tm.operand_types[op].bitfield.dword))
5827       {
5828         as_bad (_("`%s%s' not allowed with `%s%c'"),
5829                 register_prefix,
5830                 i.op[op].regs->reg_name,
5831                 i.tm.name,
5832                 i.suffix);
5833         return 0;
5834       }
5835     /* Warn if the r prefix on a general reg is missing.  */
5836     else if ((i.types[op].bitfield.word
5837               || i.types[op].bitfield.dword)
5838              && (i.tm.operand_types[op].bitfield.reg
5839                  || i.tm.operand_types[op].bitfield.acc)
5840              && i.tm.operand_types[op].bitfield.qword)
5841       {
5842         /* Prohibit these changes in the 64bit mode, since the
5843            lowering is more complicated.  */
5844         if (intel_syntax
5845             && i.tm.opcode_modifier.todword
5846             && !i.types[0].bitfield.regsimd)
5847           {
5848             /* Convert to DWORD.  We don't want REX byte. */
5849             i.suffix = LONG_MNEM_SUFFIX;
5850           }
5851         else
5852           {
5853             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
5854                     register_prefix, i.op[op].regs->reg_name,
5855                     i.suffix);
5856             return 0;
5857           }
5858       }
5859   return 1;
5860 }
5861
5862 static int
5863 check_word_reg (void)
5864 {
5865   int op;
5866   for (op = i.operands; --op >= 0;)
5867     /* Skip non-register operands. */
5868     if (!i.types[op].bitfield.reg)
5869       continue;
5870     /* Reject eight bit registers, except where the template requires
5871        them. (eg. movzb)  */
5872     else if (i.types[op].bitfield.byte
5873              && (i.tm.operand_types[op].bitfield.reg
5874                  || i.tm.operand_types[op].bitfield.acc)
5875              && (i.tm.operand_types[op].bitfield.word
5876                  || i.tm.operand_types[op].bitfield.dword))
5877       {
5878         as_bad (_("`%s%s' not allowed with `%s%c'"),
5879                 register_prefix,
5880                 i.op[op].regs->reg_name,
5881                 i.tm.name,
5882                 i.suffix);
5883         return 0;
5884       }
5885     /* Warn if the e or r prefix on a general reg is present.  */
5886     else if ((!quiet_warnings || flag_code == CODE_64BIT)
5887              && (i.types[op].bitfield.dword
5888                  || i.types[op].bitfield.qword)
5889              && (i.tm.operand_types[op].bitfield.reg
5890                  || i.tm.operand_types[op].bitfield.acc)
5891              && i.tm.operand_types[op].bitfield.word)
5892       {
5893         /* Prohibit these changes in the 64bit mode, since the
5894            lowering is more complicated.  */
5895         if (flag_code == CODE_64BIT)
5896           {
5897             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
5898                     register_prefix, i.op[op].regs->reg_name,
5899                     i.suffix);
5900             return 0;
5901           }
5902 #if REGISTER_WARNINGS
5903         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
5904                  register_prefix,
5905                  (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
5906                  register_prefix, i.op[op].regs->reg_name, i.suffix);
5907 #endif
5908       }
5909   return 1;
5910 }
5911
5912 static int
5913 update_imm (unsigned int j)
5914 {
5915   i386_operand_type overlap = i.types[j];
5916   if ((overlap.bitfield.imm8
5917        || overlap.bitfield.imm8s
5918        || overlap.bitfield.imm16
5919        || overlap.bitfield.imm32
5920        || overlap.bitfield.imm32s
5921        || overlap.bitfield.imm64)
5922       && !operand_type_equal (&overlap, &imm8)
5923       && !operand_type_equal (&overlap, &imm8s)
5924       && !operand_type_equal (&overlap, &imm16)
5925       && !operand_type_equal (&overlap, &imm32)
5926       && !operand_type_equal (&overlap, &imm32s)
5927       && !operand_type_equal (&overlap, &imm64))
5928     {
5929       if (i.suffix)
5930         {
5931           i386_operand_type temp;
5932
5933           operand_type_set (&temp, 0);
5934           if (i.suffix == BYTE_MNEM_SUFFIX)
5935             {
5936               temp.bitfield.imm8 = overlap.bitfield.imm8;
5937               temp.bitfield.imm8s = overlap.bitfield.imm8s;
5938             }
5939           else if (i.suffix == WORD_MNEM_SUFFIX)
5940             temp.bitfield.imm16 = overlap.bitfield.imm16;
5941           else if (i.suffix == QWORD_MNEM_SUFFIX)
5942             {
5943               temp.bitfield.imm64 = overlap.bitfield.imm64;
5944               temp.bitfield.imm32s = overlap.bitfield.imm32s;
5945             }
5946           else
5947             temp.bitfield.imm32 = overlap.bitfield.imm32;
5948           overlap = temp;
5949         }
5950       else if (operand_type_equal (&overlap, &imm16_32_32s)
5951                || operand_type_equal (&overlap, &imm16_32)
5952                || operand_type_equal (&overlap, &imm16_32s))
5953         {
5954           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
5955             overlap = imm16;
5956           else
5957             overlap = imm32s;
5958         }
5959       if (!operand_type_equal (&overlap, &imm8)
5960           && !operand_type_equal (&overlap, &imm8s)
5961           && !operand_type_equal (&overlap, &imm16)
5962           && !operand_type_equal (&overlap, &imm32)
5963           && !operand_type_equal (&overlap, &imm32s)
5964           && !operand_type_equal (&overlap, &imm64))
5965         {
5966           as_bad (_("no instruction mnemonic suffix given; "
5967                     "can't determine immediate size"));
5968           return 0;
5969         }
5970     }
5971   i.types[j] = overlap;
5972
5973   return 1;
5974 }
5975
5976 static int
5977 finalize_imm (void)
5978 {
5979   unsigned int j, n;
5980
5981   /* Update the first 2 immediate operands.  */
5982   n = i.operands > 2 ? 2 : i.operands;
5983   if (n)
5984     {
5985       for (j = 0; j < n; j++)
5986         if (update_imm (j) == 0)
5987           return 0;
5988
5989       /* The 3rd operand can't be immediate operand.  */
5990       gas_assert (operand_type_check (i.types[2], imm) == 0);
5991     }
5992
5993   return 1;
5994 }
5995
5996 static int
5997 process_operands (void)
5998 {
5999   /* Default segment register this instruction will use for memory
6000      accesses.  0 means unknown.  This is only for optimizing out
6001      unnecessary segment overrides.  */
6002   const seg_entry *default_seg = 0;
6003
6004   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
6005     {
6006       unsigned int dupl = i.operands;
6007       unsigned int dest = dupl - 1;
6008       unsigned int j;
6009
6010       /* The destination must be an xmm register.  */
6011       gas_assert (i.reg_operands
6012                   && MAX_OPERANDS > dupl
6013                   && operand_type_equal (&i.types[dest], &regxmm));
6014
6015       if (i.tm.operand_types[0].bitfield.acc
6016           && i.tm.operand_types[0].bitfield.xmmword)
6017         {
6018           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
6019             {
6020               /* Keep xmm0 for instructions with VEX prefix and 3
6021                  sources.  */
6022               i.tm.operand_types[0].bitfield.acc = 0;
6023               i.tm.operand_types[0].bitfield.regsimd = 1;
6024               goto duplicate;
6025             }
6026           else
6027             {
6028               /* We remove the first xmm0 and keep the number of
6029                  operands unchanged, which in fact duplicates the
6030                  destination.  */
6031               for (j = 1; j < i.operands; j++)
6032                 {
6033                   i.op[j - 1] = i.op[j];
6034                   i.types[j - 1] = i.types[j];
6035                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
6036                 }
6037             }
6038         }
6039       else if (i.tm.opcode_modifier.implicit1stxmm0)
6040         {
6041           gas_assert ((MAX_OPERANDS - 1) > dupl
6042                       && (i.tm.opcode_modifier.vexsources
6043                           == VEX3SOURCES));
6044
6045           /* Add the implicit xmm0 for instructions with VEX prefix
6046              and 3 sources.  */
6047           for (j = i.operands; j > 0; j--)
6048             {
6049               i.op[j] = i.op[j - 1];
6050               i.types[j] = i.types[j - 1];
6051               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
6052             }
6053           i.op[0].regs
6054             = (const reg_entry *) hash_find (reg_hash, "xmm0");
6055           i.types[0] = regxmm;
6056           i.tm.operand_types[0] = regxmm;
6057
6058           i.operands += 2;
6059           i.reg_operands += 2;
6060           i.tm.operands += 2;
6061
6062           dupl++;
6063           dest++;
6064           i.op[dupl] = i.op[dest];
6065           i.types[dupl] = i.types[dest];
6066           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6067         }
6068       else
6069         {
6070 duplicate:
6071           i.operands++;
6072           i.reg_operands++;
6073           i.tm.operands++;
6074
6075           i.op[dupl] = i.op[dest];
6076           i.types[dupl] = i.types[dest];
6077           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6078         }
6079
6080        if (i.tm.opcode_modifier.immext)
6081          process_immext ();
6082     }
6083   else if (i.tm.operand_types[0].bitfield.acc
6084            && i.tm.operand_types[0].bitfield.xmmword)
6085     {
6086       unsigned int j;
6087
6088       for (j = 1; j < i.operands; j++)
6089         {
6090           i.op[j - 1] = i.op[j];
6091           i.types[j - 1] = i.types[j];
6092
6093           /* We need to adjust fields in i.tm since they are used by
6094              build_modrm_byte.  */
6095           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
6096         }
6097
6098       i.operands--;
6099       i.reg_operands--;
6100       i.tm.operands--;
6101     }
6102   else if (i.tm.opcode_modifier.implicitquadgroup)
6103     {
6104       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
6105       gas_assert (i.operands >= 2 && i.types[1].bitfield.regsimd);
6106       unsigned int regnum = register_number (i.op[1].regs);
6107       unsigned int first_reg_in_group = regnum & ~3;
6108       unsigned int last_reg_in_group = first_reg_in_group + 3;
6109       if (regnum != first_reg_in_group) {
6110         as_warn (_("the second source register `%s%s' implicitly denotes"
6111             " `%s%.3s%d' to `%s%.3s%d' source group in `%s'"),
6112             register_prefix, i.op[1].regs->reg_name,
6113             register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
6114             register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
6115             i.tm.name);
6116       }
6117         }
6118   else if (i.tm.opcode_modifier.regkludge)
6119     {
6120       /* The imul $imm, %reg instruction is converted into
6121          imul $imm, %reg, %reg, and the clr %reg instruction
6122          is converted into xor %reg, %reg.  */
6123
6124       unsigned int first_reg_op;
6125
6126       if (operand_type_check (i.types[0], reg))
6127         first_reg_op = 0;
6128       else
6129         first_reg_op = 1;
6130       /* Pretend we saw the extra register operand.  */
6131       gas_assert (i.reg_operands == 1
6132                   && i.op[first_reg_op + 1].regs == 0);
6133       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
6134       i.types[first_reg_op + 1] = i.types[first_reg_op];
6135       i.operands++;
6136       i.reg_operands++;
6137     }
6138
6139   if (i.tm.opcode_modifier.shortform)
6140     {
6141       if (i.types[0].bitfield.sreg2
6142           || i.types[0].bitfield.sreg3)
6143         {
6144           if (i.tm.base_opcode == POP_SEG_SHORT
6145               && i.op[0].regs->reg_num == 1)
6146             {
6147               as_bad (_("you can't `pop %scs'"), register_prefix);
6148               return 0;
6149             }
6150           i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
6151           if ((i.op[0].regs->reg_flags & RegRex) != 0)
6152             i.rex |= REX_B;
6153         }
6154       else
6155         {
6156           /* The register or float register operand is in operand
6157              0 or 1.  */
6158           unsigned int op;
6159
6160           if ((i.types[0].bitfield.reg && i.types[0].bitfield.tbyte)
6161               || operand_type_check (i.types[0], reg))
6162             op = 0;
6163           else
6164             op = 1;
6165           /* Register goes in low 3 bits of opcode.  */
6166           i.tm.base_opcode |= i.op[op].regs->reg_num;
6167           if ((i.op[op].regs->reg_flags & RegRex) != 0)
6168             i.rex |= REX_B;
6169           if (!quiet_warnings && i.tm.opcode_modifier.ugh)
6170             {
6171               /* Warn about some common errors, but press on regardless.
6172                  The first case can be generated by gcc (<= 2.8.1).  */
6173               if (i.operands == 2)
6174                 {
6175                   /* Reversed arguments on faddp, fsubp, etc.  */
6176                   as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
6177                            register_prefix, i.op[!intel_syntax].regs->reg_name,
6178                            register_prefix, i.op[intel_syntax].regs->reg_name);
6179                 }
6180               else
6181                 {
6182                   /* Extraneous `l' suffix on fp insn.  */
6183                   as_warn (_("translating to `%s %s%s'"), i.tm.name,
6184                            register_prefix, i.op[0].regs->reg_name);
6185                 }
6186             }
6187         }
6188     }
6189   else if (i.tm.opcode_modifier.modrm)
6190     {
6191       /* The opcode is completed (modulo i.tm.extension_opcode which
6192          must be put into the modrm byte).  Now, we make the modrm and
6193          index base bytes based on all the info we've collected.  */
6194
6195       default_seg = build_modrm_byte ();
6196     }
6197   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
6198     {
6199       default_seg = &ds;
6200     }
6201   else if (i.tm.opcode_modifier.isstring)
6202     {
6203       /* For the string instructions that allow a segment override
6204          on one of their operands, the default segment is ds.  */
6205       default_seg = &ds;
6206     }
6207
6208   if (i.tm.base_opcode == 0x8d /* lea */
6209       && i.seg[0]
6210       && !quiet_warnings)
6211     as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
6212
6213   /* If a segment was explicitly specified, and the specified segment
6214      is not the default, use an opcode prefix to select it.  If we
6215      never figured out what the default segment is, then default_seg
6216      will be zero at this point, and the specified segment prefix will
6217      always be used.  */
6218   if ((i.seg[0]) && (i.seg[0] != default_seg))
6219     {
6220       if (!add_prefix (i.seg[0]->seg_prefix))
6221         return 0;
6222     }
6223   return 1;
6224 }
6225
6226 static const seg_entry *
6227 build_modrm_byte (void)
6228 {
6229   const seg_entry *default_seg = 0;
6230   unsigned int source, dest;
6231   int vex_3_sources;
6232
6233   /* The first operand of instructions with VEX prefix and 3 sources
6234      must be VEX_Imm4.  */
6235   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
6236   if (vex_3_sources)
6237     {
6238       unsigned int nds, reg_slot;
6239       expressionS *exp;
6240
6241       if (i.tm.opcode_modifier.veximmext
6242           && i.tm.opcode_modifier.immext)
6243         {
6244           dest = i.operands - 2;
6245           gas_assert (dest == 3);
6246         }
6247       else
6248         dest = i.operands - 1;
6249       nds = dest - 1;
6250
6251       /* There are 2 kinds of instructions:
6252          1. 5 operands: 4 register operands or 3 register operands
6253          plus 1 memory operand plus one Vec_Imm4 operand, VexXDS, and
6254          VexW0 or VexW1.  The destination must be either XMM, YMM or
6255          ZMM register.
6256          2. 4 operands: 4 register operands or 3 register operands
6257          plus 1 memory operand, VexXDS, and VexImmExt  */
6258       gas_assert ((i.reg_operands == 4
6259                    || (i.reg_operands == 3 && i.mem_operands == 1))
6260                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
6261                   && (i.tm.opcode_modifier.veximmext
6262                       || (i.imm_operands == 1
6263                           && i.types[0].bitfield.vec_imm4
6264                           && (i.tm.opcode_modifier.vexw == VEXW0
6265                               || i.tm.opcode_modifier.vexw == VEXW1)
6266                           && i.tm.operand_types[dest].bitfield.regsimd)));
6267
6268       if (i.imm_operands == 0)
6269         {
6270           /* When there is no immediate operand, generate an 8bit
6271              immediate operand to encode the first operand.  */
6272           exp = &im_expressions[i.imm_operands++];
6273           i.op[i.operands].imms = exp;
6274           i.types[i.operands] = imm8;
6275           i.operands++;
6276           /* If VexW1 is set, the first operand is the source and
6277              the second operand is encoded in the immediate operand.  */
6278           if (i.tm.opcode_modifier.vexw == VEXW1)
6279             {
6280               source = 0;
6281               reg_slot = 1;
6282             }
6283           else
6284             {
6285               source = 1;
6286               reg_slot = 0;
6287             }
6288
6289           /* FMA swaps REG and NDS.  */
6290           if (i.tm.cpu_flags.bitfield.cpufma)
6291             {
6292               unsigned int tmp;
6293               tmp = reg_slot;
6294               reg_slot = nds;
6295               nds = tmp;
6296             }
6297
6298           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
6299           exp->X_op = O_constant;
6300           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
6301           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
6302         }
6303       else
6304         {
6305           unsigned int imm_slot;
6306
6307           if (i.tm.opcode_modifier.vexw == VEXW0)
6308             {
6309               /* If VexW0 is set, the third operand is the source and
6310                  the second operand is encoded in the immediate
6311                  operand.  */
6312               source = 2;
6313               reg_slot = 1;
6314             }
6315           else
6316             {
6317               /* VexW1 is set, the second operand is the source and
6318                  the third operand is encoded in the immediate
6319                  operand.  */
6320               source = 1;
6321               reg_slot = 2;
6322             }
6323
6324           if (i.tm.opcode_modifier.immext)
6325             {
6326               /* When ImmExt is set, the immediate byte is the last
6327                  operand.  */
6328               imm_slot = i.operands - 1;
6329               source--;
6330               reg_slot--;
6331             }
6332           else
6333             {
6334               imm_slot = 0;
6335
6336               /* Turn on Imm8 so that output_imm will generate it.  */
6337               i.types[imm_slot].bitfield.imm8 = 1;
6338             }
6339
6340           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
6341           i.op[imm_slot].imms->X_add_number
6342               |= register_number (i.op[reg_slot].regs) << 4;
6343           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
6344         }
6345
6346       gas_assert (i.tm.operand_types[nds].bitfield.regsimd);
6347       i.vex.register_specifier = i.op[nds].regs;
6348     }
6349   else
6350     source = dest = 0;
6351
6352   /* i.reg_operands MUST be the number of real register operands;
6353      implicit registers do not count.  If there are 3 register
6354      operands, it must be a instruction with VexNDS.  For a
6355      instruction with VexNDD, the destination register is encoded
6356      in VEX prefix.  If there are 4 register operands, it must be
6357      a instruction with VEX prefix and 3 sources.  */
6358   if (i.mem_operands == 0
6359       && ((i.reg_operands == 2
6360            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
6361           || (i.reg_operands == 3
6362               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
6363           || (i.reg_operands == 4 && vex_3_sources)))
6364     {
6365       switch (i.operands)
6366         {
6367         case 2:
6368           source = 0;
6369           break;
6370         case 3:
6371           /* When there are 3 operands, one of them may be immediate,
6372              which may be the first or the last operand.  Otherwise,
6373              the first operand must be shift count register (cl) or it
6374              is an instruction with VexNDS. */
6375           gas_assert (i.imm_operands == 1
6376                       || (i.imm_operands == 0
6377                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
6378                               || i.types[0].bitfield.shiftcount)));
6379           if (operand_type_check (i.types[0], imm)
6380               || i.types[0].bitfield.shiftcount)
6381             source = 1;
6382           else
6383             source = 0;
6384           break;
6385         case 4:
6386           /* When there are 4 operands, the first two must be 8bit
6387              immediate operands. The source operand will be the 3rd
6388              one.
6389
6390              For instructions with VexNDS, if the first operand
6391              an imm8, the source operand is the 2nd one.  If the last
6392              operand is imm8, the source operand is the first one.  */
6393           gas_assert ((i.imm_operands == 2
6394                        && i.types[0].bitfield.imm8
6395                        && i.types[1].bitfield.imm8)
6396                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
6397                           && i.imm_operands == 1
6398                           && (i.types[0].bitfield.imm8
6399                               || i.types[i.operands - 1].bitfield.imm8
6400                               || i.rounding)));
6401           if (i.imm_operands == 2)
6402             source = 2;
6403           else
6404             {
6405               if (i.types[0].bitfield.imm8)
6406                 source = 1;
6407               else
6408                 source = 0;
6409             }
6410           break;
6411         case 5:
6412           if (i.tm.opcode_modifier.evex)
6413             {
6414               /* For EVEX instructions, when there are 5 operands, the
6415                  first one must be immediate operand.  If the second one
6416                  is immediate operand, the source operand is the 3th
6417                  one.  If the last one is immediate operand, the source
6418                  operand is the 2nd one.  */
6419               gas_assert (i.imm_operands == 2
6420                           && i.tm.opcode_modifier.sae
6421                           && operand_type_check (i.types[0], imm));
6422               if (operand_type_check (i.types[1], imm))
6423                 source = 2;
6424               else if (operand_type_check (i.types[4], imm))
6425                 source = 1;
6426               else
6427                 abort ();
6428             }
6429           break;
6430         default:
6431           abort ();
6432         }
6433
6434       if (!vex_3_sources)
6435         {
6436           dest = source + 1;
6437
6438           /* RC/SAE operand could be between DEST and SRC.  That happens
6439              when one operand is GPR and the other one is XMM/YMM/ZMM
6440              register.  */
6441           if (i.rounding && i.rounding->operand == (int) dest)
6442             dest++;
6443
6444           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
6445             {
6446               /* For instructions with VexNDS, the register-only source
6447                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
6448                  register.  It is encoded in VEX prefix.  We need to
6449                  clear RegMem bit before calling operand_type_equal.  */
6450
6451               i386_operand_type op;
6452               unsigned int vvvv;
6453
6454               /* Check register-only source operand when two source
6455                  operands are swapped.  */
6456               if (!i.tm.operand_types[source].bitfield.baseindex
6457                   && i.tm.operand_types[dest].bitfield.baseindex)
6458                 {
6459                   vvvv = source;
6460                   source = dest;
6461                 }
6462               else
6463                 vvvv = dest;
6464
6465               op = i.tm.operand_types[vvvv];
6466               op.bitfield.regmem = 0;
6467               if ((dest + 1) >= i.operands
6468                   || ((!op.bitfield.reg
6469                        || (!op.bitfield.dword && !op.bitfield.qword))
6470                       && !op.bitfield.regsimd
6471                       && !operand_type_equal (&op, &regmask)))
6472                 abort ();
6473               i.vex.register_specifier = i.op[vvvv].regs;
6474               dest++;
6475             }
6476         }
6477
6478       i.rm.mode = 3;
6479       /* One of the register operands will be encoded in the i.tm.reg
6480          field, the other in the combined i.tm.mode and i.tm.regmem
6481          fields.  If no form of this instruction supports a memory
6482          destination operand, then we assume the source operand may
6483          sometimes be a memory operand and so we need to store the
6484          destination in the i.rm.reg field.  */
6485       if (!i.tm.operand_types[dest].bitfield.regmem
6486           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
6487         {
6488           i.rm.reg = i.op[dest].regs->reg_num;
6489           i.rm.regmem = i.op[source].regs->reg_num;
6490           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
6491             i.rex |= REX_R;
6492           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
6493             i.vrex |= REX_R;
6494           if ((i.op[source].regs->reg_flags & RegRex) != 0)
6495             i.rex |= REX_B;
6496           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
6497             i.vrex |= REX_B;
6498         }
6499       else
6500         {
6501           i.rm.reg = i.op[source].regs->reg_num;
6502           i.rm.regmem = i.op[dest].regs->reg_num;
6503           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
6504             i.rex |= REX_B;
6505           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
6506             i.vrex |= REX_B;
6507           if ((i.op[source].regs->reg_flags & RegRex) != 0)
6508             i.rex |= REX_R;
6509           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
6510             i.vrex |= REX_R;
6511         }
6512       if (flag_code != CODE_64BIT && (i.rex & (REX_R | REX_B)))
6513         {
6514           if (!i.types[0].bitfield.control
6515               && !i.types[1].bitfield.control)
6516             abort ();
6517           i.rex &= ~(REX_R | REX_B);
6518           add_prefix (LOCK_PREFIX_OPCODE);
6519         }
6520     }
6521   else
6522     {                   /* If it's not 2 reg operands...  */
6523       unsigned int mem;
6524
6525       if (i.mem_operands)
6526         {
6527           unsigned int fake_zero_displacement = 0;
6528           unsigned int op;
6529
6530           for (op = 0; op < i.operands; op++)
6531             if (operand_type_check (i.types[op], anymem))
6532               break;
6533           gas_assert (op < i.operands);
6534
6535           if (i.tm.opcode_modifier.vecsib)
6536             {
6537               if (i.index_reg->reg_num == RegEiz
6538                   || i.index_reg->reg_num == RegRiz)
6539                 abort ();
6540
6541               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
6542               if (!i.base_reg)
6543                 {
6544                   i.sib.base = NO_BASE_REGISTER;
6545                   i.sib.scale = i.log2_scale_factor;
6546                   i.types[op].bitfield.disp8 = 0;
6547                   i.types[op].bitfield.disp16 = 0;
6548                   i.types[op].bitfield.disp64 = 0;
6549                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
6550                     {
6551                       /* Must be 32 bit */
6552                       i.types[op].bitfield.disp32 = 1;
6553                       i.types[op].bitfield.disp32s = 0;
6554                     }
6555                   else
6556                     {
6557                       i.types[op].bitfield.disp32 = 0;
6558                       i.types[op].bitfield.disp32s = 1;
6559                     }
6560                 }
6561               i.sib.index = i.index_reg->reg_num;
6562               if ((i.index_reg->reg_flags & RegRex) != 0)
6563                 i.rex |= REX_X;
6564               if ((i.index_reg->reg_flags & RegVRex) != 0)
6565                 i.vrex |= REX_X;
6566             }
6567
6568           default_seg = &ds;
6569
6570           if (i.base_reg == 0)
6571             {
6572               i.rm.mode = 0;
6573               if (!i.disp_operands)
6574                 fake_zero_displacement = 1;
6575               if (i.index_reg == 0)
6576                 {
6577                   gas_assert (!i.tm.opcode_modifier.vecsib);
6578                   /* Operand is just <disp>  */
6579                   if (flag_code == CODE_64BIT)
6580                     {
6581                       /* 64bit mode overwrites the 32bit absolute
6582                          addressing by RIP relative addressing and
6583                          absolute addressing is encoded by one of the
6584                          redundant SIB forms.  */
6585                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
6586                       i.sib.base = NO_BASE_REGISTER;
6587                       i.sib.index = NO_INDEX_REGISTER;
6588                       i.types[op] = ((i.prefix[ADDR_PREFIX] == 0)
6589                                      ? disp32s : disp32);
6590                     }
6591                   else if ((flag_code == CODE_16BIT)
6592                            ^ (i.prefix[ADDR_PREFIX] != 0))
6593                     {
6594                       i.rm.regmem = NO_BASE_REGISTER_16;
6595                       i.types[op] = disp16;
6596                     }
6597                   else
6598                     {
6599                       i.rm.regmem = NO_BASE_REGISTER;
6600                       i.types[op] = disp32;
6601                     }
6602                 }
6603               else if (!i.tm.opcode_modifier.vecsib)
6604                 {
6605                   /* !i.base_reg && i.index_reg  */
6606                   if (i.index_reg->reg_num == RegEiz
6607                       || i.index_reg->reg_num == RegRiz)
6608                     i.sib.index = NO_INDEX_REGISTER;
6609                   else
6610                     i.sib.index = i.index_reg->reg_num;
6611                   i.sib.base = NO_BASE_REGISTER;
6612                   i.sib.scale = i.log2_scale_factor;
6613                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
6614                   i.types[op].bitfield.disp8 = 0;
6615                   i.types[op].bitfield.disp16 = 0;
6616                   i.types[op].bitfield.disp64 = 0;
6617                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
6618                     {
6619                       /* Must be 32 bit */
6620                       i.types[op].bitfield.disp32 = 1;
6621                       i.types[op].bitfield.disp32s = 0;
6622                     }
6623                   else
6624                     {
6625                       i.types[op].bitfield.disp32 = 0;
6626                       i.types[op].bitfield.disp32s = 1;
6627                     }
6628                   if ((i.index_reg->reg_flags & RegRex) != 0)
6629                     i.rex |= REX_X;
6630                 }
6631             }
6632           /* RIP addressing for 64bit mode.  */
6633           else if (i.base_reg->reg_num == RegRip ||
6634                    i.base_reg->reg_num == RegEip)
6635             {
6636               gas_assert (!i.tm.opcode_modifier.vecsib);
6637               i.rm.regmem = NO_BASE_REGISTER;
6638               i.types[op].bitfield.disp8 = 0;
6639               i.types[op].bitfield.disp16 = 0;
6640               i.types[op].bitfield.disp32 = 0;
6641               i.types[op].bitfield.disp32s = 1;
6642               i.types[op].bitfield.disp64 = 0;
6643               i.flags[op] |= Operand_PCrel;
6644               if (! i.disp_operands)
6645                 fake_zero_displacement = 1;
6646             }
6647           else if (i.base_reg->reg_type.bitfield.word)
6648             {
6649               gas_assert (!i.tm.opcode_modifier.vecsib);
6650               switch (i.base_reg->reg_num)
6651                 {
6652                 case 3: /* (%bx)  */
6653                   if (i.index_reg == 0)
6654                     i.rm.regmem = 7;
6655                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
6656                     i.rm.regmem = i.index_reg->reg_num - 6;
6657                   break;
6658                 case 5: /* (%bp)  */
6659                   default_seg = &ss;
6660                   if (i.index_reg == 0)
6661                     {
6662                       i.rm.regmem = 6;
6663                       if (operand_type_check (i.types[op], disp) == 0)
6664                         {
6665                           /* fake (%bp) into 0(%bp)  */
6666                           i.types[op].bitfield.disp8 = 1;
6667                           fake_zero_displacement = 1;
6668                         }
6669                     }
6670                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
6671                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
6672                   break;
6673                 default: /* (%si) -> 4 or (%di) -> 5  */
6674                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
6675                 }
6676               i.rm.mode = mode_from_disp_size (i.types[op]);
6677             }
6678           else /* i.base_reg and 32/64 bit mode  */
6679             {
6680               if (flag_code == CODE_64BIT
6681                   && operand_type_check (i.types[op], disp))
6682                 {
6683                   i386_operand_type temp;
6684                   operand_type_set (&temp, 0);
6685                   temp.bitfield.disp8 = i.types[op].bitfield.disp8;
6686                   i.types[op] = temp;
6687                   if (i.prefix[ADDR_PREFIX] == 0)
6688                     i.types[op].bitfield.disp32s = 1;
6689                   else
6690                     i.types[op].bitfield.disp32 = 1;
6691                 }
6692
6693               if (!i.tm.opcode_modifier.vecsib)
6694                 i.rm.regmem = i.base_reg->reg_num;
6695               if ((i.base_reg->reg_flags & RegRex) != 0)
6696                 i.rex |= REX_B;
6697               i.sib.base = i.base_reg->reg_num;
6698               /* x86-64 ignores REX prefix bit here to avoid decoder
6699                  complications.  */
6700               if (!(i.base_reg->reg_flags & RegRex)
6701                   && (i.base_reg->reg_num == EBP_REG_NUM
6702                    || i.base_reg->reg_num == ESP_REG_NUM))
6703                   default_seg = &ss;
6704               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
6705                 {
6706                   fake_zero_displacement = 1;
6707                   i.types[op].bitfield.disp8 = 1;
6708                 }
6709               i.sib.scale = i.log2_scale_factor;
6710               if (i.index_reg == 0)
6711                 {
6712                   gas_assert (!i.tm.opcode_modifier.vecsib);
6713                   /* <disp>(%esp) becomes two byte modrm with no index
6714                      register.  We've already stored the code for esp
6715                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
6716                      Any base register besides %esp will not use the
6717                      extra modrm byte.  */
6718                   i.sib.index = NO_INDEX_REGISTER;
6719                 }
6720               else if (!i.tm.opcode_modifier.vecsib)
6721                 {
6722                   if (i.index_reg->reg_num == RegEiz
6723                       || i.index_reg->reg_num == RegRiz)
6724                     i.sib.index = NO_INDEX_REGISTER;
6725                   else
6726                     i.sib.index = i.index_reg->reg_num;
6727                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
6728                   if ((i.index_reg->reg_flags & RegRex) != 0)
6729                     i.rex |= REX_X;
6730                 }
6731
6732               if (i.disp_operands
6733                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
6734                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
6735                 i.rm.mode = 0;
6736               else
6737                 {
6738                   if (!fake_zero_displacement
6739                       && !i.disp_operands
6740                       && i.disp_encoding)
6741                     {
6742                       fake_zero_displacement = 1;
6743                       if (i.disp_encoding == disp_encoding_8bit)
6744                         i.types[op].bitfield.disp8 = 1;
6745                       else
6746                         i.types[op].bitfield.disp32 = 1;
6747                     }
6748                   i.rm.mode = mode_from_disp_size (i.types[op]);
6749                 }
6750             }
6751
6752           if (fake_zero_displacement)
6753             {
6754               /* Fakes a zero displacement assuming that i.types[op]
6755                  holds the correct displacement size.  */
6756               expressionS *exp;
6757
6758               gas_assert (i.op[op].disps == 0);
6759               exp = &disp_expressions[i.disp_operands++];
6760               i.op[op].disps = exp;
6761               exp->X_op = O_constant;
6762               exp->X_add_number = 0;
6763               exp->X_add_symbol = (symbolS *) 0;
6764               exp->X_op_symbol = (symbolS *) 0;
6765             }
6766
6767           mem = op;
6768         }
6769       else
6770         mem = ~0;
6771
6772       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
6773         {
6774           if (operand_type_check (i.types[0], imm))
6775             i.vex.register_specifier = NULL;
6776           else
6777             {
6778               /* VEX.vvvv encodes one of the sources when the first
6779                  operand is not an immediate.  */
6780               if (i.tm.opcode_modifier.vexw == VEXW0)
6781                 i.vex.register_specifier = i.op[0].regs;
6782               else
6783                 i.vex.register_specifier = i.op[1].regs;
6784             }
6785
6786           /* Destination is a XMM register encoded in the ModRM.reg
6787              and VEX.R bit.  */
6788           i.rm.reg = i.op[2].regs->reg_num;
6789           if ((i.op[2].regs->reg_flags & RegRex) != 0)
6790             i.rex |= REX_R;
6791
6792           /* ModRM.rm and VEX.B encodes the other source.  */
6793           if (!i.mem_operands)
6794             {
6795               i.rm.mode = 3;
6796
6797               if (i.tm.opcode_modifier.vexw == VEXW0)
6798                 i.rm.regmem = i.op[1].regs->reg_num;
6799               else
6800                 i.rm.regmem = i.op[0].regs->reg_num;
6801
6802               if ((i.op[1].regs->reg_flags & RegRex) != 0)
6803                 i.rex |= REX_B;
6804             }
6805         }
6806       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
6807         {
6808           i.vex.register_specifier = i.op[2].regs;
6809           if (!i.mem_operands)
6810             {
6811               i.rm.mode = 3;
6812               i.rm.regmem = i.op[1].regs->reg_num;
6813               if ((i.op[1].regs->reg_flags & RegRex) != 0)
6814                 i.rex |= REX_B;
6815             }
6816         }
6817       /* Fill in i.rm.reg or i.rm.regmem field with register operand
6818          (if any) based on i.tm.extension_opcode.  Again, we must be
6819          careful to make sure that segment/control/debug/test/MMX
6820          registers are coded into the i.rm.reg field.  */
6821       else if (i.reg_operands)
6822         {
6823           unsigned int op;
6824           unsigned int vex_reg = ~0;
6825
6826           for (op = 0; op < i.operands; op++)
6827             if (i.types[op].bitfield.reg
6828                 || i.types[op].bitfield.regmmx
6829                 || i.types[op].bitfield.regsimd
6830                 || i.types[op].bitfield.regbnd
6831                 || i.types[op].bitfield.regmask
6832                 || i.types[op].bitfield.sreg2
6833                 || i.types[op].bitfield.sreg3
6834                 || i.types[op].bitfield.control
6835                 || i.types[op].bitfield.debug
6836                 || i.types[op].bitfield.test)
6837               break;
6838
6839           if (vex_3_sources)
6840             op = dest;
6841           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
6842             {
6843               /* For instructions with VexNDS, the register-only
6844                  source operand is encoded in VEX prefix. */
6845               gas_assert (mem != (unsigned int) ~0);
6846
6847               if (op > mem)
6848                 {
6849                   vex_reg = op++;
6850                   gas_assert (op < i.operands);
6851                 }
6852               else
6853                 {
6854                   /* Check register-only source operand when two source
6855                      operands are swapped.  */
6856                   if (!i.tm.operand_types[op].bitfield.baseindex
6857                       && i.tm.operand_types[op + 1].bitfield.baseindex)
6858                     {
6859                       vex_reg = op;
6860                       op += 2;
6861                       gas_assert (mem == (vex_reg + 1)
6862                                   && op < i.operands);
6863                     }
6864                   else
6865                     {
6866                       vex_reg = op + 1;
6867                       gas_assert (vex_reg < i.operands);
6868                     }
6869                 }
6870             }
6871           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
6872             {
6873               /* For instructions with VexNDD, the register destination
6874                  is encoded in VEX prefix.  */
6875               if (i.mem_operands == 0)
6876                 {
6877                   /* There is no memory operand.  */
6878                   gas_assert ((op + 2) == i.operands);
6879                   vex_reg = op + 1;
6880                 }
6881               else
6882                 {
6883                   /* There are only 2 operands.  */
6884                   gas_assert (op < 2 && i.operands == 2);
6885                   vex_reg = 1;
6886                 }
6887             }
6888           else
6889             gas_assert (op < i.operands);
6890
6891           if (vex_reg != (unsigned int) ~0)
6892             {
6893               i386_operand_type *type = &i.tm.operand_types[vex_reg];
6894
6895               if ((!type->bitfield.reg
6896                    || (!type->bitfield.dword && !type->bitfield.qword))
6897                   && !type->bitfield.regsimd
6898                   && !operand_type_equal (type, &regmask))
6899                 abort ();
6900
6901               i.vex.register_specifier = i.op[vex_reg].regs;
6902             }
6903
6904           /* Don't set OP operand twice.  */
6905           if (vex_reg != op)
6906             {
6907               /* If there is an extension opcode to put here, the
6908                  register number must be put into the regmem field.  */
6909               if (i.tm.extension_opcode != None)
6910                 {
6911                   i.rm.regmem = i.op[op].regs->reg_num;
6912                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
6913                     i.rex |= REX_B;
6914                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
6915                     i.vrex |= REX_B;
6916                 }
6917               else
6918                 {
6919                   i.rm.reg = i.op[op].regs->reg_num;
6920                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
6921                     i.rex |= REX_R;
6922                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
6923                     i.vrex |= REX_R;
6924                 }
6925             }
6926
6927           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
6928              must set it to 3 to indicate this is a register operand
6929              in the regmem field.  */
6930           if (!i.mem_operands)
6931             i.rm.mode = 3;
6932         }
6933
6934       /* Fill in i.rm.reg field with extension opcode (if any).  */
6935       if (i.tm.extension_opcode != None)
6936         i.rm.reg = i.tm.extension_opcode;
6937     }
6938   return default_seg;
6939 }
6940
6941 static void
6942 output_branch (void)
6943 {
6944   char *p;
6945   int size;
6946   int code16;
6947   int prefix;
6948   relax_substateT subtype;
6949   symbolS *sym;
6950   offsetT off;
6951
6952   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
6953   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
6954
6955   prefix = 0;
6956   if (i.prefix[DATA_PREFIX] != 0)
6957     {
6958       prefix = 1;
6959       i.prefixes -= 1;
6960       code16 ^= CODE16;
6961     }
6962   /* Pentium4 branch hints.  */
6963   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
6964       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
6965     {
6966       prefix++;
6967       i.prefixes--;
6968     }
6969   if (i.prefix[REX_PREFIX] != 0)
6970     {
6971       prefix++;
6972       i.prefixes--;
6973     }
6974
6975   /* BND prefixed jump.  */
6976   if (i.prefix[BND_PREFIX] != 0)
6977     {
6978       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
6979       i.prefixes -= 1;
6980     }
6981
6982   if (i.prefixes != 0 && !intel_syntax)
6983     as_warn (_("skipping prefixes on this instruction"));
6984
6985   /* It's always a symbol;  End frag & setup for relax.
6986      Make sure there is enough room in this frag for the largest
6987      instruction we may generate in md_convert_frag.  This is 2
6988      bytes for the opcode and room for the prefix and largest
6989      displacement.  */
6990   frag_grow (prefix + 2 + 4);
6991   /* Prefix and 1 opcode byte go in fr_fix.  */
6992   p = frag_more (prefix + 1);
6993   if (i.prefix[DATA_PREFIX] != 0)
6994     *p++ = DATA_PREFIX_OPCODE;
6995   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
6996       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
6997     *p++ = i.prefix[SEG_PREFIX];
6998   if (i.prefix[REX_PREFIX] != 0)
6999     *p++ = i.prefix[REX_PREFIX];
7000   *p = i.tm.base_opcode;
7001
7002   if ((unsigned char) *p == JUMP_PC_RELATIVE)
7003     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
7004   else if (cpu_arch_flags.bitfield.cpui386)
7005     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
7006   else
7007     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
7008   subtype |= code16;
7009
7010   sym = i.op[0].disps->X_add_symbol;
7011   off = i.op[0].disps->X_add_number;
7012
7013   if (i.op[0].disps->X_op != O_constant
7014       && i.op[0].disps->X_op != O_symbol)
7015     {
7016       /* Handle complex expressions.  */
7017       sym = make_expr_symbol (i.op[0].disps);
7018       off = 0;
7019     }
7020
7021   /* 1 possible extra opcode + 4 byte displacement go in var part.
7022      Pass reloc in fr_var.  */
7023   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
7024 }
7025
7026 static void
7027 output_jump (void)
7028 {
7029   char *p;
7030   int size;
7031   fixS *fixP;
7032
7033   if (i.tm.opcode_modifier.jumpbyte)
7034     {
7035       /* This is a loop or jecxz type instruction.  */
7036       size = 1;
7037       if (i.prefix[ADDR_PREFIX] != 0)
7038         {
7039           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
7040           i.prefixes -= 1;
7041         }
7042       /* Pentium4 branch hints.  */
7043       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7044           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7045         {
7046           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
7047           i.prefixes--;
7048         }
7049     }
7050   else
7051     {
7052       int code16;
7053
7054       code16 = 0;
7055       if (flag_code == CODE_16BIT)
7056         code16 = CODE16;
7057
7058       if (i.prefix[DATA_PREFIX] != 0)
7059         {
7060           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
7061           i.prefixes -= 1;
7062           code16 ^= CODE16;
7063         }
7064
7065       size = 4;
7066       if (code16)
7067         size = 2;
7068     }
7069
7070   if (i.prefix[REX_PREFIX] != 0)
7071     {
7072       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
7073       i.prefixes -= 1;
7074     }
7075
7076   /* BND prefixed jump.  */
7077   if (i.prefix[BND_PREFIX] != 0)
7078     {
7079       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7080       i.prefixes -= 1;
7081     }
7082
7083   if (i.prefixes != 0 && !intel_syntax)
7084     as_warn (_("skipping prefixes on this instruction"));
7085
7086   p = frag_more (i.tm.opcode_length + size);
7087   switch (i.tm.opcode_length)
7088     {
7089     case 2:
7090       *p++ = i.tm.base_opcode >> 8;
7091       /* Fall through.  */
7092     case 1:
7093       *p++ = i.tm.base_opcode;
7094       break;
7095     default:
7096       abort ();
7097     }
7098
7099   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7100                       i.op[0].disps, 1, reloc (size, 1, 1, i.reloc[0]));
7101
7102   /* All jumps handled here are signed, but don't use a signed limit
7103      check for 32 and 16 bit jumps as we want to allow wrap around at
7104      4G and 64k respectively.  */
7105   if (size == 1)
7106     fixP->fx_signed = 1;
7107 }
7108
7109 static void
7110 output_interseg_jump (void)
7111 {
7112   char *p;
7113   int size;
7114   int prefix;
7115   int code16;
7116
7117   code16 = 0;
7118   if (flag_code == CODE_16BIT)
7119     code16 = CODE16;
7120
7121   prefix = 0;
7122   if (i.prefix[DATA_PREFIX] != 0)
7123     {
7124       prefix = 1;
7125       i.prefixes -= 1;
7126       code16 ^= CODE16;
7127     }
7128   if (i.prefix[REX_PREFIX] != 0)
7129     {
7130       prefix++;
7131       i.prefixes -= 1;
7132     }
7133
7134   size = 4;
7135   if (code16)
7136     size = 2;
7137
7138   if (i.prefixes != 0 && !intel_syntax)
7139     as_warn (_("skipping prefixes on this instruction"));
7140
7141   /* 1 opcode; 2 segment; offset  */
7142   p = frag_more (prefix + 1 + 2 + size);
7143
7144   if (i.prefix[DATA_PREFIX] != 0)
7145     *p++ = DATA_PREFIX_OPCODE;
7146
7147   if (i.prefix[REX_PREFIX] != 0)
7148     *p++ = i.prefix[REX_PREFIX];
7149
7150   *p++ = i.tm.base_opcode;
7151   if (i.op[1].imms->X_op == O_constant)
7152     {
7153       offsetT n = i.op[1].imms->X_add_number;
7154
7155       if (size == 2
7156           && !fits_in_unsigned_word (n)
7157           && !fits_in_signed_word (n))
7158         {
7159           as_bad (_("16-bit jump out of range"));
7160           return;
7161         }
7162       md_number_to_chars (p, n, size);
7163     }
7164   else
7165     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7166                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
7167   if (i.op[0].imms->X_op != O_constant)
7168     as_bad (_("can't handle non absolute segment in `%s'"),
7169             i.tm.name);
7170   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
7171 }
7172
7173 static void
7174 output_insn (void)
7175 {
7176   fragS *insn_start_frag;
7177   offsetT insn_start_off;
7178
7179   /* Tie dwarf2 debug info to the address at the start of the insn.
7180      We can't do this after the insn has been output as the current
7181      frag may have been closed off.  eg. by frag_var.  */
7182   dwarf2_emit_insn (0);
7183
7184   insn_start_frag = frag_now;
7185   insn_start_off = frag_now_fix ();
7186
7187   /* Output jumps.  */
7188   if (i.tm.opcode_modifier.jump)
7189     output_branch ();
7190   else if (i.tm.opcode_modifier.jumpbyte
7191            || i.tm.opcode_modifier.jumpdword)
7192     output_jump ();
7193   else if (i.tm.opcode_modifier.jumpintersegment)
7194     output_interseg_jump ();
7195   else
7196     {
7197       /* Output normal instructions here.  */
7198       char *p;
7199       unsigned char *q;
7200       unsigned int j;
7201       unsigned int prefix;
7202
7203       if (avoid_fence
7204          && i.tm.base_opcode == 0xfae
7205          && i.operands == 1
7206          && i.imm_operands == 1
7207          && (i.op[0].imms->X_add_number == 0xe8
7208              || i.op[0].imms->X_add_number == 0xf0
7209              || i.op[0].imms->X_add_number == 0xf8))
7210         {
7211           /* Encode lfence, mfence, and sfence as
7212              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
7213           offsetT val = 0x240483f0ULL;
7214           p = frag_more (5);
7215           md_number_to_chars (p, val, 5);
7216           return;
7217         }
7218
7219       /* Some processors fail on LOCK prefix. This options makes
7220          assembler ignore LOCK prefix and serves as a workaround.  */
7221       if (omit_lock_prefix)
7222         {
7223           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
7224             return;
7225           i.prefix[LOCK_PREFIX] = 0;
7226         }
7227
7228       /* Since the VEX/EVEX prefix contains the implicit prefix, we
7229          don't need the explicit prefix.  */
7230       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
7231         {
7232           switch (i.tm.opcode_length)
7233             {
7234             case 3:
7235               if (i.tm.base_opcode & 0xff000000)
7236                 {
7237                   prefix = (i.tm.base_opcode >> 24) & 0xff;
7238                   goto check_prefix;
7239                 }
7240               break;
7241             case 2:
7242               if ((i.tm.base_opcode & 0xff0000) != 0)
7243                 {
7244                   prefix = (i.tm.base_opcode >> 16) & 0xff;
7245                   if (i.tm.cpu_flags.bitfield.cpupadlock)
7246                     {
7247 check_prefix:
7248                       if (prefix != REPE_PREFIX_OPCODE
7249                           || (i.prefix[REP_PREFIX]
7250                               != REPE_PREFIX_OPCODE))
7251                         add_prefix (prefix);
7252                     }
7253                   else
7254                     add_prefix (prefix);
7255                 }
7256               break;
7257             case 1:
7258               break;
7259             case 0:
7260               /* Check for pseudo prefixes.  */
7261               as_bad_where (insn_start_frag->fr_file,
7262                             insn_start_frag->fr_line,
7263                              _("pseudo prefix without instruction"));
7264               return;
7265             default:
7266               abort ();
7267             }
7268
7269 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
7270           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
7271              R_X86_64_GOTTPOFF relocation so that linker can safely
7272              perform IE->LE optimization.  */
7273           if (x86_elf_abi == X86_64_X32_ABI
7274               && i.operands == 2
7275               && i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
7276               && i.prefix[REX_PREFIX] == 0)
7277             add_prefix (REX_OPCODE);
7278 #endif
7279
7280           /* The prefix bytes.  */
7281           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
7282             if (*q)
7283               FRAG_APPEND_1_CHAR (*q);
7284         }
7285       else
7286         {
7287           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
7288             if (*q)
7289               switch (j)
7290                 {
7291                 case REX_PREFIX:
7292                   /* REX byte is encoded in VEX prefix.  */
7293                   break;
7294                 case SEG_PREFIX:
7295                 case ADDR_PREFIX:
7296                   FRAG_APPEND_1_CHAR (*q);
7297                   break;
7298                 default:
7299                   /* There should be no other prefixes for instructions
7300                      with VEX prefix.  */
7301                   abort ();
7302                 }
7303
7304           /* For EVEX instructions i.vrex should become 0 after
7305              build_evex_prefix.  For VEX instructions upper 16 registers
7306              aren't available, so VREX should be 0.  */
7307           if (i.vrex)
7308             abort ();
7309           /* Now the VEX prefix.  */
7310           p = frag_more (i.vex.length);
7311           for (j = 0; j < i.vex.length; j++)
7312             p[j] = i.vex.bytes[j];
7313         }
7314
7315       /* Now the opcode; be careful about word order here!  */
7316       if (i.tm.opcode_length == 1)
7317         {
7318           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
7319         }
7320       else
7321         {
7322           switch (i.tm.opcode_length)
7323             {
7324             case 4:
7325               p = frag_more (4);
7326               *p++ = (i.tm.base_opcode >> 24) & 0xff;
7327               *p++ = (i.tm.base_opcode >> 16) & 0xff;
7328               break;
7329             case 3:
7330               p = frag_more (3);
7331               *p++ = (i.tm.base_opcode >> 16) & 0xff;
7332               break;
7333             case 2:
7334               p = frag_more (2);
7335               break;
7336             default:
7337               abort ();
7338               break;
7339             }
7340
7341           /* Put out high byte first: can't use md_number_to_chars!  */
7342           *p++ = (i.tm.base_opcode >> 8) & 0xff;
7343           *p = i.tm.base_opcode & 0xff;
7344         }
7345
7346       /* Now the modrm byte and sib byte (if present).  */
7347       if (i.tm.opcode_modifier.modrm)
7348         {
7349           FRAG_APPEND_1_CHAR ((i.rm.regmem << 0
7350                                | i.rm.reg << 3
7351                                | i.rm.mode << 6));
7352           /* If i.rm.regmem == ESP (4)
7353              && i.rm.mode != (Register mode)
7354              && not 16 bit
7355              ==> need second modrm byte.  */
7356           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
7357               && i.rm.mode != 3
7358               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
7359             FRAG_APPEND_1_CHAR ((i.sib.base << 0
7360                                  | i.sib.index << 3
7361                                  | i.sib.scale << 6));
7362         }
7363
7364       if (i.disp_operands)
7365         output_disp (insn_start_frag, insn_start_off);
7366
7367       if (i.imm_operands)
7368         output_imm (insn_start_frag, insn_start_off);
7369     }
7370
7371 #ifdef DEBUG386
7372   if (flag_debug)
7373     {
7374       pi ("" /*line*/, &i);
7375     }
7376 #endif /* DEBUG386  */
7377 }
7378
7379 /* Return the size of the displacement operand N.  */
7380
7381 static int
7382 disp_size (unsigned int n)
7383 {
7384   int size = 4;
7385
7386   if (i.types[n].bitfield.disp64)
7387     size = 8;
7388   else if (i.types[n].bitfield.disp8)
7389     size = 1;
7390   else if (i.types[n].bitfield.disp16)
7391     size = 2;
7392   return size;
7393 }
7394
7395 /* Return the size of the immediate operand N.  */
7396
7397 static int
7398 imm_size (unsigned int n)
7399 {
7400   int size = 4;
7401   if (i.types[n].bitfield.imm64)
7402     size = 8;
7403   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
7404     size = 1;
7405   else if (i.types[n].bitfield.imm16)
7406     size = 2;
7407   return size;
7408 }
7409
7410 static void
7411 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
7412 {
7413   char *p;
7414   unsigned int n;
7415
7416   for (n = 0; n < i.operands; n++)
7417     {
7418       if (operand_type_check (i.types[n], disp))
7419         {
7420           if (i.op[n].disps->X_op == O_constant)
7421             {
7422               int size = disp_size (n);
7423               offsetT val = i.op[n].disps->X_add_number;
7424
7425               val = offset_in_range (val >> i.memshift, size);
7426               p = frag_more (size);
7427               md_number_to_chars (p, val, size);
7428             }
7429           else
7430             {
7431               enum bfd_reloc_code_real reloc_type;
7432               int size = disp_size (n);
7433               int sign = i.types[n].bitfield.disp32s;
7434               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
7435               fixS *fixP;
7436
7437               /* We can't have 8 bit displacement here.  */
7438               gas_assert (!i.types[n].bitfield.disp8);
7439
7440               /* The PC relative address is computed relative
7441                  to the instruction boundary, so in case immediate
7442                  fields follows, we need to adjust the value.  */
7443               if (pcrel && i.imm_operands)
7444                 {
7445                   unsigned int n1;
7446                   int sz = 0;
7447
7448                   for (n1 = 0; n1 < i.operands; n1++)
7449                     if (operand_type_check (i.types[n1], imm))
7450                       {
7451                         /* Only one immediate is allowed for PC
7452                            relative address.  */
7453                         gas_assert (sz == 0);
7454                         sz = imm_size (n1);
7455                         i.op[n].disps->X_add_number -= sz;
7456                       }
7457                   /* We should find the immediate.  */
7458                   gas_assert (sz != 0);
7459                 }
7460
7461               p = frag_more (size);
7462               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
7463               if (GOT_symbol
7464                   && GOT_symbol == i.op[n].disps->X_add_symbol
7465                   && (((reloc_type == BFD_RELOC_32
7466                         || reloc_type == BFD_RELOC_X86_64_32S
7467                         || (reloc_type == BFD_RELOC_64
7468                             && object_64bit))
7469                        && (i.op[n].disps->X_op == O_symbol
7470                            || (i.op[n].disps->X_op == O_add
7471                                && ((symbol_get_value_expression
7472                                     (i.op[n].disps->X_op_symbol)->X_op)
7473                                    == O_subtract))))
7474                       || reloc_type == BFD_RELOC_32_PCREL))
7475                 {
7476                   offsetT add;
7477
7478                   if (insn_start_frag == frag_now)
7479                     add = (p - frag_now->fr_literal) - insn_start_off;
7480                   else
7481                     {
7482                       fragS *fr;
7483
7484                       add = insn_start_frag->fr_fix - insn_start_off;
7485                       for (fr = insn_start_frag->fr_next;
7486                            fr && fr != frag_now; fr = fr->fr_next)
7487                         add += fr->fr_fix;
7488                       add += p - frag_now->fr_literal;
7489                     }
7490
7491                   if (!object_64bit)
7492                     {
7493                       reloc_type = BFD_RELOC_386_GOTPC;
7494                       i.op[n].imms->X_add_number += add;
7495                     }
7496                   else if (reloc_type == BFD_RELOC_64)
7497                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
7498                   else
7499                     /* Don't do the adjustment for x86-64, as there
7500                        the pcrel addressing is relative to the _next_
7501                        insn, and that is taken care of in other code.  */
7502                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
7503                 }
7504               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
7505                                   size, i.op[n].disps, pcrel,
7506                                   reloc_type);
7507               /* Check for "call/jmp *mem", "mov mem, %reg",
7508                  "test %reg, mem" and "binop mem, %reg" where binop
7509                  is one of adc, add, and, cmp, or, sbb, sub, xor
7510                  instructions.  Always generate R_386_GOT32X for
7511                  "sym*GOT" operand in 32-bit mode.  */
7512               if ((generate_relax_relocations
7513                    || (!object_64bit
7514                        && i.rm.mode == 0
7515                        && i.rm.regmem == 5))
7516                   && (i.rm.mode == 2
7517                       || (i.rm.mode == 0 && i.rm.regmem == 5))
7518                   && ((i.operands == 1
7519                        && i.tm.base_opcode == 0xff
7520                        && (i.rm.reg == 2 || i.rm.reg == 4))
7521                       || (i.operands == 2
7522                           && (i.tm.base_opcode == 0x8b
7523                               || i.tm.base_opcode == 0x85
7524                               || (i.tm.base_opcode & 0xc7) == 0x03))))
7525                 {
7526                   if (object_64bit)
7527                     {
7528                       fixP->fx_tcbit = i.rex != 0;
7529                       if (i.base_reg
7530                           && (i.base_reg->reg_num == RegRip
7531                               || i.base_reg->reg_num == RegEip))
7532                       fixP->fx_tcbit2 = 1;
7533                     }
7534                   else
7535                     fixP->fx_tcbit2 = 1;
7536                 }
7537             }
7538         }
7539     }
7540 }
7541
7542 static void
7543 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
7544 {
7545   char *p;
7546   unsigned int n;
7547
7548   for (n = 0; n < i.operands; n++)
7549     {
7550       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
7551       if (i.rounding && (int) n == i.rounding->operand)
7552         continue;
7553
7554       if (operand_type_check (i.types[n], imm))
7555         {
7556           if (i.op[n].imms->X_op == O_constant)
7557             {
7558               int size = imm_size (n);
7559               offsetT val;
7560
7561               val = offset_in_range (i.op[n].imms->X_add_number,
7562                                      size);
7563               p = frag_more (size);
7564               md_number_to_chars (p, val, size);
7565             }
7566           else
7567             {
7568               /* Not absolute_section.
7569                  Need a 32-bit fixup (don't support 8bit
7570                  non-absolute imms).  Try to support other
7571                  sizes ...  */
7572               enum bfd_reloc_code_real reloc_type;
7573               int size = imm_size (n);
7574               int sign;
7575
7576               if (i.types[n].bitfield.imm32s
7577                   && (i.suffix == QWORD_MNEM_SUFFIX
7578                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
7579                 sign = 1;
7580               else
7581                 sign = 0;
7582
7583               p = frag_more (size);
7584               reloc_type = reloc (size, 0, sign, i.reloc[n]);
7585
7586               /*   This is tough to explain.  We end up with this one if we
7587                * have operands that look like
7588                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
7589                * obtain the absolute address of the GOT, and it is strongly
7590                * preferable from a performance point of view to avoid using
7591                * a runtime relocation for this.  The actual sequence of
7592                * instructions often look something like:
7593                *
7594                *        call    .L66
7595                * .L66:
7596                *        popl    %ebx
7597                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
7598                *
7599                *   The call and pop essentially return the absolute address
7600                * of the label .L66 and store it in %ebx.  The linker itself
7601                * will ultimately change the first operand of the addl so
7602                * that %ebx points to the GOT, but to keep things simple, the
7603                * .o file must have this operand set so that it generates not
7604                * the absolute address of .L66, but the absolute address of
7605                * itself.  This allows the linker itself simply treat a GOTPC
7606                * relocation as asking for a pcrel offset to the GOT to be
7607                * added in, and the addend of the relocation is stored in the
7608                * operand field for the instruction itself.
7609                *
7610                *   Our job here is to fix the operand so that it would add
7611                * the correct offset so that %ebx would point to itself.  The
7612                * thing that is tricky is that .-.L66 will point to the
7613                * beginning of the instruction, so we need to further modify
7614                * the operand so that it will point to itself.  There are
7615                * other cases where you have something like:
7616                *
7617                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
7618                *
7619                * and here no correction would be required.  Internally in
7620                * the assembler we treat operands of this form as not being
7621                * pcrel since the '.' is explicitly mentioned, and I wonder
7622                * whether it would simplify matters to do it this way.  Who
7623                * knows.  In earlier versions of the PIC patches, the
7624                * pcrel_adjust field was used to store the correction, but
7625                * since the expression is not pcrel, I felt it would be
7626                * confusing to do it this way.  */
7627
7628               if ((reloc_type == BFD_RELOC_32
7629                    || reloc_type == BFD_RELOC_X86_64_32S
7630                    || reloc_type == BFD_RELOC_64)
7631                   && GOT_symbol
7632                   && GOT_symbol == i.op[n].imms->X_add_symbol
7633                   && (i.op[n].imms->X_op == O_symbol
7634                       || (i.op[n].imms->X_op == O_add
7635                           && ((symbol_get_value_expression
7636                                (i.op[n].imms->X_op_symbol)->X_op)
7637                               == O_subtract))))
7638                 {
7639                   offsetT add;
7640
7641                   if (insn_start_frag == frag_now)
7642                     add = (p - frag_now->fr_literal) - insn_start_off;
7643                   else
7644                     {
7645                       fragS *fr;
7646
7647                       add = insn_start_frag->fr_fix - insn_start_off;
7648                       for (fr = insn_start_frag->fr_next;
7649                            fr && fr != frag_now; fr = fr->fr_next)
7650                         add += fr->fr_fix;
7651                       add += p - frag_now->fr_literal;
7652                     }
7653
7654                   if (!object_64bit)
7655                     reloc_type = BFD_RELOC_386_GOTPC;
7656                   else if (size == 4)
7657                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
7658                   else if (size == 8)
7659                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
7660                   i.op[n].imms->X_add_number += add;
7661                 }
7662               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7663                            i.op[n].imms, 0, reloc_type);
7664             }
7665         }
7666     }
7667 }
7668 \f
7669 /* x86_cons_fix_new is called via the expression parsing code when a
7670    reloc is needed.  We use this hook to get the correct .got reloc.  */
7671 static int cons_sign = -1;
7672
7673 void
7674 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
7675                   expressionS *exp, bfd_reloc_code_real_type r)
7676 {
7677   r = reloc (len, 0, cons_sign, r);
7678
7679 #ifdef TE_PE
7680   if (exp->X_op == O_secrel)
7681     {
7682       exp->X_op = O_symbol;
7683       r = BFD_RELOC_32_SECREL;
7684     }
7685 #endif
7686
7687   fix_new_exp (frag, off, len, exp, 0, r);
7688 }
7689
7690 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
7691    purpose of the `.dc.a' internal pseudo-op.  */
7692
7693 int
7694 x86_address_bytes (void)
7695 {
7696   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
7697     return 4;
7698   return stdoutput->arch_info->bits_per_address / 8;
7699 }
7700
7701 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
7702     || defined (LEX_AT)
7703 # define lex_got(reloc, adjust, types) NULL
7704 #else
7705 /* Parse operands of the form
7706    <symbol>@GOTOFF+<nnn>
7707    and similar .plt or .got references.
7708
7709    If we find one, set up the correct relocation in RELOC and copy the
7710    input string, minus the `@GOTOFF' into a malloc'd buffer for
7711    parsing by the calling routine.  Return this buffer, and if ADJUST
7712    is non-null set it to the length of the string we removed from the
7713    input line.  Otherwise return NULL.  */
7714 static char *
7715 lex_got (enum bfd_reloc_code_real *rel,
7716          int *adjust,
7717          i386_operand_type *types)
7718 {
7719   /* Some of the relocations depend on the size of what field is to
7720      be relocated.  But in our callers i386_immediate and i386_displacement
7721      we don't yet know the operand size (this will be set by insn
7722      matching).  Hence we record the word32 relocation here,
7723      and adjust the reloc according to the real size in reloc().  */
7724   static const struct {
7725     const char *str;
7726     int len;
7727     const enum bfd_reloc_code_real rel[2];
7728     const i386_operand_type types64;
7729   } gotrel[] = {
7730 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7731     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
7732                                         BFD_RELOC_SIZE32 },
7733       OPERAND_TYPE_IMM32_64 },
7734 #endif
7735     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
7736                                        BFD_RELOC_X86_64_PLTOFF64 },
7737       OPERAND_TYPE_IMM64 },
7738     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
7739                                        BFD_RELOC_X86_64_PLT32    },
7740       OPERAND_TYPE_IMM32_32S_DISP32 },
7741     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
7742                                        BFD_RELOC_X86_64_GOTPLT64 },
7743       OPERAND_TYPE_IMM64_DISP64 },
7744     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
7745                                        BFD_RELOC_X86_64_GOTOFF64 },
7746       OPERAND_TYPE_IMM64_DISP64 },
7747     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
7748                                        BFD_RELOC_X86_64_GOTPCREL },
7749       OPERAND_TYPE_IMM32_32S_DISP32 },
7750     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
7751                                        BFD_RELOC_X86_64_TLSGD    },
7752       OPERAND_TYPE_IMM32_32S_DISP32 },
7753     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
7754                                        _dummy_first_bfd_reloc_code_real },
7755       OPERAND_TYPE_NONE },
7756     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
7757                                        BFD_RELOC_X86_64_TLSLD    },
7758       OPERAND_TYPE_IMM32_32S_DISP32 },
7759     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
7760                                        BFD_RELOC_X86_64_GOTTPOFF },
7761       OPERAND_TYPE_IMM32_32S_DISP32 },
7762     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
7763                                        BFD_RELOC_X86_64_TPOFF32  },
7764       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
7765     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
7766                                        _dummy_first_bfd_reloc_code_real },
7767       OPERAND_TYPE_NONE },
7768     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
7769                                        BFD_RELOC_X86_64_DTPOFF32 },
7770       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
7771     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
7772                                        _dummy_first_bfd_reloc_code_real },
7773       OPERAND_TYPE_NONE },
7774     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
7775                                        _dummy_first_bfd_reloc_code_real },
7776       OPERAND_TYPE_NONE },
7777     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
7778                                        BFD_RELOC_X86_64_GOT32    },
7779       OPERAND_TYPE_IMM32_32S_64_DISP32 },
7780     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
7781                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
7782       OPERAND_TYPE_IMM32_32S_DISP32 },
7783     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
7784                                        BFD_RELOC_X86_64_TLSDESC_CALL },
7785       OPERAND_TYPE_IMM32_32S_DISP32 },
7786   };
7787   char *cp;
7788   unsigned int j;
7789
7790 #if defined (OBJ_MAYBE_ELF)
7791   if (!IS_ELF)
7792     return NULL;
7793 #endif
7794
7795   for (cp = input_line_pointer; *cp != '@'; cp++)
7796     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
7797       return NULL;
7798
7799   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
7800     {
7801       int len = gotrel[j].len;
7802       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
7803         {
7804           if (gotrel[j].rel[object_64bit] != 0)
7805             {
7806               int first, second;
7807               char *tmpbuf, *past_reloc;
7808
7809               *rel = gotrel[j].rel[object_64bit];
7810
7811               if (types)
7812                 {
7813                   if (flag_code != CODE_64BIT)
7814                     {
7815                       types->bitfield.imm32 = 1;
7816                       types->bitfield.disp32 = 1;
7817                     }
7818                   else
7819                     *types = gotrel[j].types64;
7820                 }
7821
7822               if (j != 0 && GOT_symbol == NULL)
7823                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
7824
7825               /* The length of the first part of our input line.  */
7826               first = cp - input_line_pointer;
7827
7828               /* The second part goes from after the reloc token until
7829                  (and including) an end_of_line char or comma.  */
7830               past_reloc = cp + 1 + len;
7831               cp = past_reloc;
7832               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
7833                 ++cp;
7834               second = cp + 1 - past_reloc;
7835
7836               /* Allocate and copy string.  The trailing NUL shouldn't
7837                  be necessary, but be safe.  */
7838               tmpbuf = XNEWVEC (char, first + second + 2);
7839               memcpy (tmpbuf, input_line_pointer, first);
7840               if (second != 0 && *past_reloc != ' ')
7841                 /* Replace the relocation token with ' ', so that
7842                    errors like foo@GOTOFF1 will be detected.  */
7843                 tmpbuf[first++] = ' ';
7844               else
7845                 /* Increment length by 1 if the relocation token is
7846                    removed.  */
7847                 len++;
7848               if (adjust)
7849                 *adjust = len;
7850               memcpy (tmpbuf + first, past_reloc, second);
7851               tmpbuf[first + second] = '\0';
7852               return tmpbuf;
7853             }
7854
7855           as_bad (_("@%s reloc is not supported with %d-bit output format"),
7856                   gotrel[j].str, 1 << (5 + object_64bit));
7857           return NULL;
7858         }
7859     }
7860
7861   /* Might be a symbol version string.  Don't as_bad here.  */
7862   return NULL;
7863 }
7864 #endif
7865
7866 #ifdef TE_PE
7867 #ifdef lex_got
7868 #undef lex_got
7869 #endif
7870 /* Parse operands of the form
7871    <symbol>@SECREL32+<nnn>
7872
7873    If we find one, set up the correct relocation in RELOC and copy the
7874    input string, minus the `@SECREL32' into a malloc'd buffer for
7875    parsing by the calling routine.  Return this buffer, and if ADJUST
7876    is non-null set it to the length of the string we removed from the
7877    input line.  Otherwise return NULL.
7878
7879    This function is copied from the ELF version above adjusted for PE targets.  */
7880
7881 static char *
7882 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
7883          int *adjust ATTRIBUTE_UNUSED,
7884          i386_operand_type *types)
7885 {
7886   static const struct
7887   {
7888     const char *str;
7889     int len;
7890     const enum bfd_reloc_code_real rel[2];
7891     const i386_operand_type types64;
7892   }
7893   gotrel[] =
7894   {
7895     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
7896                                           BFD_RELOC_32_SECREL },
7897       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
7898   };
7899
7900   char *cp;
7901   unsigned j;
7902
7903   for (cp = input_line_pointer; *cp != '@'; cp++)
7904     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
7905       return NULL;
7906
7907   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
7908     {
7909       int len = gotrel[j].len;
7910
7911       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
7912         {
7913           if (gotrel[j].rel[object_64bit] != 0)
7914             {
7915               int first, second;
7916               char *tmpbuf, *past_reloc;
7917
7918               *rel = gotrel[j].rel[object_64bit];
7919               if (adjust)
7920                 *adjust = len;
7921
7922               if (types)
7923                 {
7924                   if (flag_code != CODE_64BIT)
7925                     {
7926                       types->bitfield.imm32 = 1;
7927                       types->bitfield.disp32 = 1;
7928                     }
7929                   else
7930                     *types = gotrel[j].types64;
7931                 }
7932
7933               /* The length of the first part of our input line.  */
7934               first = cp - input_line_pointer;
7935
7936               /* The second part goes from after the reloc token until
7937                  (and including) an end_of_line char or comma.  */
7938               past_reloc = cp + 1 + len;
7939               cp = past_reloc;
7940               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
7941                 ++cp;
7942               second = cp + 1 - past_reloc;
7943
7944               /* Allocate and copy string.  The trailing NUL shouldn't
7945                  be necessary, but be safe.  */
7946               tmpbuf = XNEWVEC (char, first + second + 2);
7947               memcpy (tmpbuf, input_line_pointer, first);
7948               if (second != 0 && *past_reloc != ' ')
7949                 /* Replace the relocation token with ' ', so that
7950                    errors like foo@SECLREL321 will be detected.  */
7951                 tmpbuf[first++] = ' ';
7952               memcpy (tmpbuf + first, past_reloc, second);
7953               tmpbuf[first + second] = '\0';
7954               return tmpbuf;
7955             }
7956
7957           as_bad (_("@%s reloc is not supported with %d-bit output format"),
7958                   gotrel[j].str, 1 << (5 + object_64bit));
7959           return NULL;
7960         }
7961     }
7962
7963   /* Might be a symbol version string.  Don't as_bad here.  */
7964   return NULL;
7965 }
7966
7967 #endif /* TE_PE */
7968
7969 bfd_reloc_code_real_type
7970 x86_cons (expressionS *exp, int size)
7971 {
7972   bfd_reloc_code_real_type got_reloc = NO_RELOC;
7973
7974   intel_syntax = -intel_syntax;
7975
7976   exp->X_md = 0;
7977   if (size == 4 || (object_64bit && size == 8))
7978     {
7979       /* Handle @GOTOFF and the like in an expression.  */
7980       char *save;
7981       char *gotfree_input_line;
7982       int adjust = 0;
7983
7984       save = input_line_pointer;
7985       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
7986       if (gotfree_input_line)
7987         input_line_pointer = gotfree_input_line;
7988
7989       expression (exp);
7990
7991       if (gotfree_input_line)
7992         {
7993           /* expression () has merrily parsed up to the end of line,
7994              or a comma - in the wrong buffer.  Transfer how far
7995              input_line_pointer has moved to the right buffer.  */
7996           input_line_pointer = (save
7997                                 + (input_line_pointer - gotfree_input_line)
7998                                 + adjust);
7999           free (gotfree_input_line);
8000           if (exp->X_op == O_constant
8001               || exp->X_op == O_absent
8002               || exp->X_op == O_illegal
8003               || exp->X_op == O_register
8004               || exp->X_op == O_big)
8005             {
8006               char c = *input_line_pointer;
8007               *input_line_pointer = 0;
8008               as_bad (_("missing or invalid expression `%s'"), save);
8009               *input_line_pointer = c;
8010             }
8011         }
8012     }
8013   else
8014     expression (exp);
8015
8016   intel_syntax = -intel_syntax;
8017
8018   if (intel_syntax)
8019     i386_intel_simplify (exp);
8020
8021   return got_reloc;
8022 }
8023
8024 static void
8025 signed_cons (int size)
8026 {
8027   if (flag_code == CODE_64BIT)
8028     cons_sign = 1;
8029   cons (size);
8030   cons_sign = -1;
8031 }
8032
8033 #ifdef TE_PE
8034 static void
8035 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
8036 {
8037   expressionS exp;
8038
8039   do
8040     {
8041       expression (&exp);
8042       if (exp.X_op == O_symbol)
8043         exp.X_op = O_secrel;
8044
8045       emit_expr (&exp, 4);
8046     }
8047   while (*input_line_pointer++ == ',');
8048
8049   input_line_pointer--;
8050   demand_empty_rest_of_line ();
8051 }
8052 #endif
8053
8054 /* Handle Vector operations.  */
8055
8056 static char *
8057 check_VecOperations (char *op_string, char *op_end)
8058 {
8059   const reg_entry *mask;
8060   const char *saved;
8061   char *end_op;
8062
8063   while (*op_string
8064          && (op_end == NULL || op_string < op_end))
8065     {
8066       saved = op_string;
8067       if (*op_string == '{')
8068         {
8069           op_string++;
8070
8071           /* Check broadcasts.  */
8072           if (strncmp (op_string, "1to", 3) == 0)
8073             {
8074               int bcst_type;
8075
8076               if (i.broadcast)
8077                 goto duplicated_vec_op;
8078
8079               op_string += 3;
8080               if (*op_string == '8')
8081                 bcst_type = BROADCAST_1TO8;
8082               else if (*op_string == '4')
8083                 bcst_type = BROADCAST_1TO4;
8084               else if (*op_string == '2')
8085                 bcst_type = BROADCAST_1TO2;
8086               else if (*op_string == '1'
8087                        && *(op_string+1) == '6')
8088                 {
8089                   bcst_type = BROADCAST_1TO16;
8090                   op_string++;
8091                 }
8092               else
8093                 {
8094                   as_bad (_("Unsupported broadcast: `%s'"), saved);
8095                   return NULL;
8096                 }
8097               op_string++;
8098
8099               broadcast_op.type = bcst_type;
8100               broadcast_op.operand = this_operand;
8101               i.broadcast = &broadcast_op;
8102             }
8103           /* Check masking operation.  */
8104           else if ((mask = parse_register (op_string, &end_op)) != NULL)
8105             {
8106               /* k0 can't be used for write mask.  */
8107               if (!mask->reg_type.bitfield.regmask || mask->reg_num == 0)
8108                 {
8109                   as_bad (_("`%s%s' can't be used for write mask"),
8110                           register_prefix, mask->reg_name);
8111                   return NULL;
8112                 }
8113
8114               if (!i.mask)
8115                 {
8116                   mask_op.mask = mask;
8117                   mask_op.zeroing = 0;
8118                   mask_op.operand = this_operand;
8119                   i.mask = &mask_op;
8120                 }
8121               else
8122                 {
8123                   if (i.mask->mask)
8124                     goto duplicated_vec_op;
8125
8126                   i.mask->mask = mask;
8127
8128                   /* Only "{z}" is allowed here.  No need to check
8129                      zeroing mask explicitly.  */
8130                   if (i.mask->operand != this_operand)
8131                     {
8132                       as_bad (_("invalid write mask `%s'"), saved);
8133                       return NULL;
8134                     }
8135                 }
8136
8137               op_string = end_op;
8138             }
8139           /* Check zeroing-flag for masking operation.  */
8140           else if (*op_string == 'z')
8141             {
8142               if (!i.mask)
8143                 {
8144                   mask_op.mask = NULL;
8145                   mask_op.zeroing = 1;
8146                   mask_op.operand = this_operand;
8147                   i.mask = &mask_op;
8148                 }
8149               else
8150                 {
8151                   if (i.mask->zeroing)
8152                     {
8153                     duplicated_vec_op:
8154                       as_bad (_("duplicated `%s'"), saved);
8155                       return NULL;
8156                     }
8157
8158                   i.mask->zeroing = 1;
8159
8160                   /* Only "{%k}" is allowed here.  No need to check mask
8161                      register explicitly.  */
8162                   if (i.mask->operand != this_operand)
8163                     {
8164                       as_bad (_("invalid zeroing-masking `%s'"),
8165                               saved);
8166                       return NULL;
8167                     }
8168                 }
8169
8170               op_string++;
8171             }
8172           else
8173             goto unknown_vec_op;
8174
8175           if (*op_string != '}')
8176             {
8177               as_bad (_("missing `}' in `%s'"), saved);
8178               return NULL;
8179             }
8180           op_string++;
8181           continue;
8182         }
8183     unknown_vec_op:
8184       /* We don't know this one.  */
8185       as_bad (_("unknown vector operation: `%s'"), saved);
8186       return NULL;
8187     }
8188
8189   if (i.mask && i.mask->zeroing && !i.mask->mask)
8190     {
8191       as_bad (_("zeroing-masking only allowed with write mask"));
8192       return NULL;
8193     }
8194
8195   return op_string;
8196 }
8197
8198 static int
8199 i386_immediate (char *imm_start)
8200 {
8201   char *save_input_line_pointer;
8202   char *gotfree_input_line;
8203   segT exp_seg = 0;
8204   expressionS *exp;
8205   i386_operand_type types;
8206
8207   operand_type_set (&types, ~0);
8208
8209   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
8210     {
8211       as_bad (_("at most %d immediate operands are allowed"),
8212               MAX_IMMEDIATE_OPERANDS);
8213       return 0;
8214     }
8215
8216   exp = &im_expressions[i.imm_operands++];
8217   i.op[this_operand].imms = exp;
8218
8219   if (is_space_char (*imm_start))
8220     ++imm_start;
8221
8222   save_input_line_pointer = input_line_pointer;
8223   input_line_pointer = imm_start;
8224
8225   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
8226   if (gotfree_input_line)
8227     input_line_pointer = gotfree_input_line;
8228
8229   exp_seg = expression (exp);
8230
8231   SKIP_WHITESPACE ();
8232
8233   /* Handle vector operations.  */
8234   if (*input_line_pointer == '{')
8235     {
8236       input_line_pointer = check_VecOperations (input_line_pointer,
8237                                                 NULL);
8238       if (input_line_pointer == NULL)
8239         return 0;
8240     }
8241
8242   if (*input_line_pointer)
8243     as_bad (_("junk `%s' after expression"), input_line_pointer);
8244
8245   input_line_pointer = save_input_line_pointer;
8246   if (gotfree_input_line)
8247     {
8248       free (gotfree_input_line);
8249
8250       if (exp->X_op == O_constant || exp->X_op == O_register)
8251         exp->X_op = O_illegal;
8252     }
8253
8254   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
8255 }
8256
8257 static int
8258 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
8259                          i386_operand_type types, const char *imm_start)
8260 {
8261   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
8262     {
8263       if (imm_start)
8264         as_bad (_("missing or invalid immediate expression `%s'"),
8265                 imm_start);
8266       return 0;
8267     }
8268   else if (exp->X_op == O_constant)
8269     {
8270       /* Size it properly later.  */
8271       i.types[this_operand].bitfield.imm64 = 1;
8272       /* If not 64bit, sign extend val.  */
8273       if (flag_code != CODE_64BIT
8274           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
8275         exp->X_add_number
8276           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
8277     }
8278 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
8279   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
8280            && exp_seg != absolute_section
8281            && exp_seg != text_section
8282            && exp_seg != data_section
8283            && exp_seg != bss_section
8284            && exp_seg != undefined_section
8285            && !bfd_is_com_section (exp_seg))
8286     {
8287       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
8288       return 0;
8289     }
8290 #endif
8291   else if (!intel_syntax && exp_seg == reg_section)
8292     {
8293       if (imm_start)
8294         as_bad (_("illegal immediate register operand %s"), imm_start);
8295       return 0;
8296     }
8297   else
8298     {
8299       /* This is an address.  The size of the address will be
8300          determined later, depending on destination register,
8301          suffix, or the default for the section.  */
8302       i.types[this_operand].bitfield.imm8 = 1;
8303       i.types[this_operand].bitfield.imm16 = 1;
8304       i.types[this_operand].bitfield.imm32 = 1;
8305       i.types[this_operand].bitfield.imm32s = 1;
8306       i.types[this_operand].bitfield.imm64 = 1;
8307       i.types[this_operand] = operand_type_and (i.types[this_operand],
8308                                                 types);
8309     }
8310
8311   return 1;
8312 }
8313
8314 static char *
8315 i386_scale (char *scale)
8316 {
8317   offsetT val;
8318   char *save = input_line_pointer;
8319
8320   input_line_pointer = scale;
8321   val = get_absolute_expression ();
8322
8323   switch (val)
8324     {
8325     case 1:
8326       i.log2_scale_factor = 0;
8327       break;
8328     case 2:
8329       i.log2_scale_factor = 1;
8330       break;
8331     case 4:
8332       i.log2_scale_factor = 2;
8333       break;
8334     case 8:
8335       i.log2_scale_factor = 3;
8336       break;
8337     default:
8338       {
8339         char sep = *input_line_pointer;
8340
8341         *input_line_pointer = '\0';
8342         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
8343                 scale);
8344         *input_line_pointer = sep;
8345         input_line_pointer = save;
8346         return NULL;
8347       }
8348     }
8349   if (i.log2_scale_factor != 0 && i.index_reg == 0)
8350     {
8351       as_warn (_("scale factor of %d without an index register"),
8352                1 << i.log2_scale_factor);
8353       i.log2_scale_factor = 0;
8354     }
8355   scale = input_line_pointer;
8356   input_line_pointer = save;
8357   return scale;
8358 }
8359
8360 static int
8361 i386_displacement (char *disp_start, char *disp_end)
8362 {
8363   expressionS *exp;
8364   segT exp_seg = 0;
8365   char *save_input_line_pointer;
8366   char *gotfree_input_line;
8367   int override;
8368   i386_operand_type bigdisp, types = anydisp;
8369   int ret;
8370
8371   if (i.disp_operands == MAX_MEMORY_OPERANDS)
8372     {
8373       as_bad (_("at most %d displacement operands are allowed"),
8374               MAX_MEMORY_OPERANDS);
8375       return 0;
8376     }
8377
8378   operand_type_set (&bigdisp, 0);
8379   if ((i.types[this_operand].bitfield.jumpabsolute)
8380       || (!current_templates->start->opcode_modifier.jump
8381           && !current_templates->start->opcode_modifier.jumpdword))
8382     {
8383       bigdisp.bitfield.disp32 = 1;
8384       override = (i.prefix[ADDR_PREFIX] != 0);
8385       if (flag_code == CODE_64BIT)
8386         {
8387           if (!override)
8388             {
8389               bigdisp.bitfield.disp32s = 1;
8390               bigdisp.bitfield.disp64 = 1;
8391             }
8392         }
8393       else if ((flag_code == CODE_16BIT) ^ override)
8394         {
8395           bigdisp.bitfield.disp32 = 0;
8396           bigdisp.bitfield.disp16 = 1;
8397         }
8398     }
8399   else
8400     {
8401       /* For PC-relative branches, the width of the displacement
8402          is dependent upon data size, not address size.  */
8403       override = (i.prefix[DATA_PREFIX] != 0);
8404       if (flag_code == CODE_64BIT)
8405         {
8406           if (override || i.suffix == WORD_MNEM_SUFFIX)
8407             bigdisp.bitfield.disp16 = 1;
8408           else
8409             {
8410               bigdisp.bitfield.disp32 = 1;
8411               bigdisp.bitfield.disp32s = 1;
8412             }
8413         }
8414       else
8415         {
8416           if (!override)
8417             override = (i.suffix == (flag_code != CODE_16BIT
8418                                      ? WORD_MNEM_SUFFIX
8419                                      : LONG_MNEM_SUFFIX));
8420           bigdisp.bitfield.disp32 = 1;
8421           if ((flag_code == CODE_16BIT) ^ override)
8422             {
8423               bigdisp.bitfield.disp32 = 0;
8424               bigdisp.bitfield.disp16 = 1;
8425             }
8426         }
8427     }
8428   i.types[this_operand] = operand_type_or (i.types[this_operand],
8429                                            bigdisp);
8430
8431   exp = &disp_expressions[i.disp_operands];
8432   i.op[this_operand].disps = exp;
8433   i.disp_operands++;
8434   save_input_line_pointer = input_line_pointer;
8435   input_line_pointer = disp_start;
8436   END_STRING_AND_SAVE (disp_end);
8437
8438 #ifndef GCC_ASM_O_HACK
8439 #define GCC_ASM_O_HACK 0
8440 #endif
8441 #if GCC_ASM_O_HACK
8442   END_STRING_AND_SAVE (disp_end + 1);
8443   if (i.types[this_operand].bitfield.baseIndex
8444       && displacement_string_end[-1] == '+')
8445     {
8446       /* This hack is to avoid a warning when using the "o"
8447          constraint within gcc asm statements.
8448          For instance:
8449
8450          #define _set_tssldt_desc(n,addr,limit,type) \
8451          __asm__ __volatile__ ( \
8452          "movw %w2,%0\n\t" \
8453          "movw %w1,2+%0\n\t" \
8454          "rorl $16,%1\n\t" \
8455          "movb %b1,4+%0\n\t" \
8456          "movb %4,5+%0\n\t" \
8457          "movb $0,6+%0\n\t" \
8458          "movb %h1,7+%0\n\t" \
8459          "rorl $16,%1" \
8460          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
8461
8462          This works great except that the output assembler ends
8463          up looking a bit weird if it turns out that there is
8464          no offset.  You end up producing code that looks like:
8465
8466          #APP
8467          movw $235,(%eax)
8468          movw %dx,2+(%eax)
8469          rorl $16,%edx
8470          movb %dl,4+(%eax)
8471          movb $137,5+(%eax)
8472          movb $0,6+(%eax)
8473          movb %dh,7+(%eax)
8474          rorl $16,%edx
8475          #NO_APP
8476
8477          So here we provide the missing zero.  */
8478
8479       *displacement_string_end = '0';
8480     }
8481 #endif
8482   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
8483   if (gotfree_input_line)
8484     input_line_pointer = gotfree_input_line;
8485
8486   exp_seg = expression (exp);
8487
8488   SKIP_WHITESPACE ();
8489   if (*input_line_pointer)
8490     as_bad (_("junk `%s' after expression"), input_line_pointer);
8491 #if GCC_ASM_O_HACK
8492   RESTORE_END_STRING (disp_end + 1);
8493 #endif
8494   input_line_pointer = save_input_line_pointer;
8495   if (gotfree_input_line)
8496     {
8497       free (gotfree_input_line);
8498
8499       if (exp->X_op == O_constant || exp->X_op == O_register)
8500         exp->X_op = O_illegal;
8501     }
8502
8503   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
8504
8505   RESTORE_END_STRING (disp_end);
8506
8507   return ret;
8508 }
8509
8510 static int
8511 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
8512                             i386_operand_type types, const char *disp_start)
8513 {
8514   i386_operand_type bigdisp;
8515   int ret = 1;
8516
8517   /* We do this to make sure that the section symbol is in
8518      the symbol table.  We will ultimately change the relocation
8519      to be relative to the beginning of the section.  */
8520   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
8521       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
8522       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
8523     {
8524       if (exp->X_op != O_symbol)
8525         goto inv_disp;
8526
8527       if (S_IS_LOCAL (exp->X_add_symbol)
8528           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
8529           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
8530         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
8531       exp->X_op = O_subtract;
8532       exp->X_op_symbol = GOT_symbol;
8533       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
8534         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
8535       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
8536         i.reloc[this_operand] = BFD_RELOC_64;
8537       else
8538         i.reloc[this_operand] = BFD_RELOC_32;
8539     }
8540
8541   else if (exp->X_op == O_absent
8542            || exp->X_op == O_illegal
8543            || exp->X_op == O_big)
8544     {
8545     inv_disp:
8546       as_bad (_("missing or invalid displacement expression `%s'"),
8547               disp_start);
8548       ret = 0;
8549     }
8550
8551   else if (flag_code == CODE_64BIT
8552            && !i.prefix[ADDR_PREFIX]
8553            && exp->X_op == O_constant)
8554     {
8555       /* Since displacement is signed extended to 64bit, don't allow
8556          disp32 and turn off disp32s if they are out of range.  */
8557       i.types[this_operand].bitfield.disp32 = 0;
8558       if (!fits_in_signed_long (exp->X_add_number))
8559         {
8560           i.types[this_operand].bitfield.disp32s = 0;
8561           if (i.types[this_operand].bitfield.baseindex)
8562             {
8563               as_bad (_("0x%lx out range of signed 32bit displacement"),
8564                       (long) exp->X_add_number);
8565               ret = 0;
8566             }
8567         }
8568     }
8569
8570 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
8571   else if (exp->X_op != O_constant
8572            && OUTPUT_FLAVOR == bfd_target_aout_flavour
8573            && exp_seg != absolute_section
8574            && exp_seg != text_section
8575            && exp_seg != data_section
8576            && exp_seg != bss_section
8577            && exp_seg != undefined_section
8578            && !bfd_is_com_section (exp_seg))
8579     {
8580       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
8581       ret = 0;
8582     }
8583 #endif
8584
8585   /* Check if this is a displacement only operand.  */
8586   bigdisp = i.types[this_operand];
8587   bigdisp.bitfield.disp8 = 0;
8588   bigdisp.bitfield.disp16 = 0;
8589   bigdisp.bitfield.disp32 = 0;
8590   bigdisp.bitfield.disp32s = 0;
8591   bigdisp.bitfield.disp64 = 0;
8592   if (operand_type_all_zero (&bigdisp))
8593     i.types[this_operand] = operand_type_and (i.types[this_operand],
8594                                               types);
8595
8596   return ret;
8597 }
8598
8599 /* Return the active addressing mode, taking address override and
8600    registers forming the address into consideration.  Update the
8601    address override prefix if necessary.  */
8602
8603 static enum flag_code
8604 i386_addressing_mode (void)
8605 {
8606   enum flag_code addr_mode;
8607
8608   if (i.prefix[ADDR_PREFIX])
8609     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
8610   else
8611     {
8612       addr_mode = flag_code;
8613
8614 #if INFER_ADDR_PREFIX
8615       if (i.mem_operands == 0)
8616         {
8617           /* Infer address prefix from the first memory operand.  */
8618           const reg_entry *addr_reg = i.base_reg;
8619
8620           if (addr_reg == NULL)
8621             addr_reg = i.index_reg;
8622
8623           if (addr_reg)
8624             {
8625               if (addr_reg->reg_num == RegEip
8626                   || addr_reg->reg_num == RegEiz
8627                   || addr_reg->reg_type.bitfield.dword)
8628                 addr_mode = CODE_32BIT;
8629               else if (flag_code != CODE_64BIT
8630                        && addr_reg->reg_type.bitfield.word)
8631                 addr_mode = CODE_16BIT;
8632
8633               if (addr_mode != flag_code)
8634                 {
8635                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
8636                   i.prefixes += 1;
8637                   /* Change the size of any displacement too.  At most one
8638                      of Disp16 or Disp32 is set.
8639                      FIXME.  There doesn't seem to be any real need for
8640                      separate Disp16 and Disp32 flags.  The same goes for
8641                      Imm16 and Imm32.  Removing them would probably clean
8642                      up the code quite a lot.  */
8643                   if (flag_code != CODE_64BIT
8644                       && (i.types[this_operand].bitfield.disp16
8645                           || i.types[this_operand].bitfield.disp32))
8646                     i.types[this_operand]
8647                       = operand_type_xor (i.types[this_operand], disp16_32);
8648                 }
8649             }
8650         }
8651 #endif
8652     }
8653
8654   return addr_mode;
8655 }
8656
8657 /* Make sure the memory operand we've been dealt is valid.
8658    Return 1 on success, 0 on a failure.  */
8659
8660 static int
8661 i386_index_check (const char *operand_string)
8662 {
8663   const char *kind = "base/index";
8664   enum flag_code addr_mode = i386_addressing_mode ();
8665
8666   if (current_templates->start->opcode_modifier.isstring
8667       && !current_templates->start->opcode_modifier.immext
8668       && (current_templates->end[-1].opcode_modifier.isstring
8669           || i.mem_operands))
8670     {
8671       /* Memory operands of string insns are special in that they only allow
8672          a single register (rDI, rSI, or rBX) as their memory address.  */
8673       const reg_entry *expected_reg;
8674       static const char *di_si[][2] =
8675         {
8676           { "esi", "edi" },
8677           { "si", "di" },
8678           { "rsi", "rdi" }
8679         };
8680       static const char *bx[] = { "ebx", "bx", "rbx" };
8681
8682       kind = "string address";
8683
8684       if (current_templates->start->opcode_modifier.repprefixok)
8685         {
8686           i386_operand_type type = current_templates->end[-1].operand_types[0];
8687
8688           if (!type.bitfield.baseindex
8689               || ((!i.mem_operands != !intel_syntax)
8690                   && current_templates->end[-1].operand_types[1]
8691                      .bitfield.baseindex))
8692             type = current_templates->end[-1].operand_types[1];
8693           expected_reg = hash_find (reg_hash,
8694                                     di_si[addr_mode][type.bitfield.esseg]);
8695
8696         }
8697       else
8698         expected_reg = hash_find (reg_hash, bx[addr_mode]);
8699
8700       if (i.base_reg != expected_reg
8701           || i.index_reg
8702           || operand_type_check (i.types[this_operand], disp))
8703         {
8704           /* The second memory operand must have the same size as
8705              the first one.  */
8706           if (i.mem_operands
8707               && i.base_reg
8708               && !((addr_mode == CODE_64BIT
8709                     && i.base_reg->reg_type.bitfield.qword)
8710                    || (addr_mode == CODE_32BIT
8711                        ? i.base_reg->reg_type.bitfield.dword
8712                        : i.base_reg->reg_type.bitfield.word)))
8713             goto bad_address;
8714
8715           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
8716                    operand_string,
8717                    intel_syntax ? '[' : '(',
8718                    register_prefix,
8719                    expected_reg->reg_name,
8720                    intel_syntax ? ']' : ')');
8721           return 1;
8722         }
8723       else
8724         return 1;
8725
8726 bad_address:
8727       as_bad (_("`%s' is not a valid %s expression"),
8728               operand_string, kind);
8729       return 0;
8730     }
8731   else
8732     {
8733       if (addr_mode != CODE_16BIT)
8734         {
8735           /* 32-bit/64-bit checks.  */
8736           if ((i.base_reg
8737                && (addr_mode == CODE_64BIT
8738                    ? !i.base_reg->reg_type.bitfield.qword
8739                    : !i.base_reg->reg_type.bitfield.dword)
8740                && (i.index_reg
8741                    || (i.base_reg->reg_num
8742                        != (addr_mode == CODE_64BIT ? RegRip : RegEip))))
8743               || (i.index_reg
8744                   && !i.index_reg->reg_type.bitfield.xmmword
8745                   && !i.index_reg->reg_type.bitfield.ymmword
8746                   && !i.index_reg->reg_type.bitfield.zmmword
8747                   && ((addr_mode == CODE_64BIT
8748                        ? !(i.index_reg->reg_type.bitfield.qword
8749                            || i.index_reg->reg_num == RegRiz)
8750                        : !(i.index_reg->reg_type.bitfield.dword
8751                            || i.index_reg->reg_num == RegEiz))
8752                       || !i.index_reg->reg_type.bitfield.baseindex)))
8753             goto bad_address;
8754
8755           /* bndmk, bndldx, and bndstx have special restrictions. */
8756           if (current_templates->start->base_opcode == 0xf30f1b
8757               || (current_templates->start->base_opcode & ~1) == 0x0f1a)
8758             {
8759               /* They cannot use RIP-relative addressing. */
8760               if (i.base_reg && i.base_reg->reg_num == RegRip)
8761                 {
8762                   as_bad (_("`%s' cannot be used here"), operand_string);
8763                   return 0;
8764                 }
8765
8766               /* bndldx and bndstx ignore their scale factor. */
8767               if (current_templates->start->base_opcode != 0xf30f1b
8768                   && i.log2_scale_factor)
8769                 as_warn (_("register scaling is being ignored here"));
8770             }
8771         }
8772       else
8773         {
8774           /* 16-bit checks.  */
8775           if ((i.base_reg
8776                && (!i.base_reg->reg_type.bitfield.word
8777                    || !i.base_reg->reg_type.bitfield.baseindex))
8778               || (i.index_reg
8779                   && (!i.index_reg->reg_type.bitfield.word
8780                       || !i.index_reg->reg_type.bitfield.baseindex
8781                       || !(i.base_reg
8782                            && i.base_reg->reg_num < 6
8783                            && i.index_reg->reg_num >= 6
8784                            && i.log2_scale_factor == 0))))
8785             goto bad_address;
8786         }
8787     }
8788   return 1;
8789 }
8790
8791 /* Handle vector immediates.  */
8792
8793 static int
8794 RC_SAE_immediate (const char *imm_start)
8795 {
8796   unsigned int match_found, j;
8797   const char *pstr = imm_start;
8798   expressionS *exp;
8799
8800   if (*pstr != '{')
8801     return 0;
8802
8803   pstr++;
8804   match_found = 0;
8805   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
8806     {
8807       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
8808         {
8809           if (!i.rounding)
8810             {
8811               rc_op.type = RC_NamesTable[j].type;
8812               rc_op.operand = this_operand;
8813               i.rounding = &rc_op;
8814             }
8815           else
8816             {
8817               as_bad (_("duplicated `%s'"), imm_start);
8818               return 0;
8819             }
8820           pstr += RC_NamesTable[j].len;
8821           match_found = 1;
8822           break;
8823         }
8824     }
8825   if (!match_found)
8826     return 0;
8827
8828   if (*pstr++ != '}')
8829     {
8830       as_bad (_("Missing '}': '%s'"), imm_start);
8831       return 0;
8832     }
8833   /* RC/SAE immediate string should contain nothing more.  */;
8834   if (*pstr != 0)
8835     {
8836       as_bad (_("Junk after '}': '%s'"), imm_start);
8837       return 0;
8838     }
8839
8840   exp = &im_expressions[i.imm_operands++];
8841   i.op[this_operand].imms = exp;
8842
8843   exp->X_op = O_constant;
8844   exp->X_add_number = 0;
8845   exp->X_add_symbol = (symbolS *) 0;
8846   exp->X_op_symbol = (symbolS *) 0;
8847
8848   i.types[this_operand].bitfield.imm8 = 1;
8849   return 1;
8850 }
8851
8852 /* Only string instructions can have a second memory operand, so
8853    reduce current_templates to just those if it contains any.  */
8854 static int
8855 maybe_adjust_templates (void)
8856 {
8857   const insn_template *t;
8858
8859   gas_assert (i.mem_operands == 1);
8860
8861   for (t = current_templates->start; t < current_templates->end; ++t)
8862     if (t->opcode_modifier.isstring)
8863       break;
8864
8865   if (t < current_templates->end)
8866     {
8867       static templates aux_templates;
8868       bfd_boolean recheck;
8869
8870       aux_templates.start = t;
8871       for (; t < current_templates->end; ++t)
8872         if (!t->opcode_modifier.isstring)
8873           break;
8874       aux_templates.end = t;
8875
8876       /* Determine whether to re-check the first memory operand.  */
8877       recheck = (aux_templates.start != current_templates->start
8878                  || t != current_templates->end);
8879
8880       current_templates = &aux_templates;
8881
8882       if (recheck)
8883         {
8884           i.mem_operands = 0;
8885           if (i.memop1_string != NULL
8886               && i386_index_check (i.memop1_string) == 0)
8887             return 0;
8888           i.mem_operands = 1;
8889         }
8890     }
8891
8892   return 1;
8893 }
8894
8895 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
8896    on error.  */
8897
8898 static int
8899 i386_att_operand (char *operand_string)
8900 {
8901   const reg_entry *r;
8902   char *end_op;
8903   char *op_string = operand_string;
8904
8905   if (is_space_char (*op_string))
8906     ++op_string;
8907
8908   /* We check for an absolute prefix (differentiating,
8909      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
8910   if (*op_string == ABSOLUTE_PREFIX)
8911     {
8912       ++op_string;
8913       if (is_space_char (*op_string))
8914         ++op_string;
8915       i.types[this_operand].bitfield.jumpabsolute = 1;
8916     }
8917
8918   /* Check if operand is a register.  */
8919   if ((r = parse_register (op_string, &end_op)) != NULL)
8920     {
8921       i386_operand_type temp;
8922
8923       /* Check for a segment override by searching for ':' after a
8924          segment register.  */
8925       op_string = end_op;
8926       if (is_space_char (*op_string))
8927         ++op_string;
8928       if (*op_string == ':'
8929           && (r->reg_type.bitfield.sreg2
8930               || r->reg_type.bitfield.sreg3))
8931         {
8932           switch (r->reg_num)
8933             {
8934             case 0:
8935               i.seg[i.mem_operands] = &es;
8936               break;
8937             case 1:
8938               i.seg[i.mem_operands] = &cs;
8939               break;
8940             case 2:
8941               i.seg[i.mem_operands] = &ss;
8942               break;
8943             case 3:
8944               i.seg[i.mem_operands] = &ds;
8945               break;
8946             case 4:
8947               i.seg[i.mem_operands] = &fs;
8948               break;
8949             case 5:
8950               i.seg[i.mem_operands] = &gs;
8951               break;
8952             }
8953
8954           /* Skip the ':' and whitespace.  */
8955           ++op_string;
8956           if (is_space_char (*op_string))
8957             ++op_string;
8958
8959           if (!is_digit_char (*op_string)
8960               && !is_identifier_char (*op_string)
8961               && *op_string != '('
8962               && *op_string != ABSOLUTE_PREFIX)
8963             {
8964               as_bad (_("bad memory operand `%s'"), op_string);
8965               return 0;
8966             }
8967           /* Handle case of %es:*foo.  */
8968           if (*op_string == ABSOLUTE_PREFIX)
8969             {
8970               ++op_string;
8971               if (is_space_char (*op_string))
8972                 ++op_string;
8973               i.types[this_operand].bitfield.jumpabsolute = 1;
8974             }
8975           goto do_memory_reference;
8976         }
8977
8978       /* Handle vector operations.  */
8979       if (*op_string == '{')
8980         {
8981           op_string = check_VecOperations (op_string, NULL);
8982           if (op_string == NULL)
8983             return 0;
8984         }
8985
8986       if (*op_string)
8987         {
8988           as_bad (_("junk `%s' after register"), op_string);
8989           return 0;
8990         }
8991       temp = r->reg_type;
8992       temp.bitfield.baseindex = 0;
8993       i.types[this_operand] = operand_type_or (i.types[this_operand],
8994                                                temp);
8995       i.types[this_operand].bitfield.unspecified = 0;
8996       i.op[this_operand].regs = r;
8997       i.reg_operands++;
8998     }
8999   else if (*op_string == REGISTER_PREFIX)
9000     {
9001       as_bad (_("bad register name `%s'"), op_string);
9002       return 0;
9003     }
9004   else if (*op_string == IMMEDIATE_PREFIX)
9005     {
9006       ++op_string;
9007       if (i.types[this_operand].bitfield.jumpabsolute)
9008         {
9009           as_bad (_("immediate operand illegal with absolute jump"));
9010           return 0;
9011         }
9012       if (!i386_immediate (op_string))
9013         return 0;
9014     }
9015   else if (RC_SAE_immediate (operand_string))
9016     {
9017       /* If it is a RC or SAE immediate, do nothing.  */
9018       ;
9019     }
9020   else if (is_digit_char (*op_string)
9021            || is_identifier_char (*op_string)
9022            || *op_string == '"'
9023            || *op_string == '(')
9024     {
9025       /* This is a memory reference of some sort.  */
9026       char *base_string;
9027
9028       /* Start and end of displacement string expression (if found).  */
9029       char *displacement_string_start;
9030       char *displacement_string_end;
9031       char *vop_start;
9032
9033     do_memory_reference:
9034       if (i.mem_operands == 1 && !maybe_adjust_templates ())
9035         return 0;
9036       if ((i.mem_operands == 1
9037            && !current_templates->start->opcode_modifier.isstring)
9038           || i.mem_operands == 2)
9039         {
9040           as_bad (_("too many memory references for `%s'"),
9041                   current_templates->start->name);
9042           return 0;
9043         }
9044
9045       /* Check for base index form.  We detect the base index form by
9046          looking for an ')' at the end of the operand, searching
9047          for the '(' matching it, and finding a REGISTER_PREFIX or ','
9048          after the '('.  */
9049       base_string = op_string + strlen (op_string);
9050
9051       /* Handle vector operations.  */
9052       vop_start = strchr (op_string, '{');
9053       if (vop_start && vop_start < base_string)
9054         {
9055           if (check_VecOperations (vop_start, base_string) == NULL)
9056             return 0;
9057           base_string = vop_start;
9058         }
9059
9060       --base_string;
9061       if (is_space_char (*base_string))
9062         --base_string;
9063
9064       /* If we only have a displacement, set-up for it to be parsed later.  */
9065       displacement_string_start = op_string;
9066       displacement_string_end = base_string + 1;
9067
9068       if (*base_string == ')')
9069         {
9070           char *temp_string;
9071           unsigned int parens_balanced = 1;
9072           /* We've already checked that the number of left & right ()'s are
9073              equal, so this loop will not be infinite.  */
9074           do
9075             {
9076               base_string--;
9077               if (*base_string == ')')
9078                 parens_balanced++;
9079               if (*base_string == '(')
9080                 parens_balanced--;
9081             }
9082           while (parens_balanced);
9083
9084           temp_string = base_string;
9085
9086           /* Skip past '(' and whitespace.  */
9087           ++base_string;
9088           if (is_space_char (*base_string))
9089             ++base_string;
9090
9091           if (*base_string == ','
9092               || ((i.base_reg = parse_register (base_string, &end_op))
9093                   != NULL))
9094             {
9095               displacement_string_end = temp_string;
9096
9097               i.types[this_operand].bitfield.baseindex = 1;
9098
9099               if (i.base_reg)
9100                 {
9101                   base_string = end_op;
9102                   if (is_space_char (*base_string))
9103                     ++base_string;
9104                 }
9105
9106               /* There may be an index reg or scale factor here.  */
9107               if (*base_string == ',')
9108                 {
9109                   ++base_string;
9110                   if (is_space_char (*base_string))
9111                     ++base_string;
9112
9113                   if ((i.index_reg = parse_register (base_string, &end_op))
9114                       != NULL)
9115                     {
9116                       base_string = end_op;
9117                       if (is_space_char (*base_string))
9118                         ++base_string;
9119                       if (*base_string == ',')
9120                         {
9121                           ++base_string;
9122                           if (is_space_char (*base_string))
9123                             ++base_string;
9124                         }
9125                       else if (*base_string != ')')
9126                         {
9127                           as_bad (_("expecting `,' or `)' "
9128                                     "after index register in `%s'"),
9129                                   operand_string);
9130                           return 0;
9131                         }
9132                     }
9133                   else if (*base_string == REGISTER_PREFIX)
9134                     {
9135                       end_op = strchr (base_string, ',');
9136                       if (end_op)
9137                         *end_op = '\0';
9138                       as_bad (_("bad register name `%s'"), base_string);
9139                       return 0;
9140                     }
9141
9142                   /* Check for scale factor.  */
9143                   if (*base_string != ')')
9144                     {
9145                       char *end_scale = i386_scale (base_string);
9146
9147                       if (!end_scale)
9148                         return 0;
9149
9150                       base_string = end_scale;
9151                       if (is_space_char (*base_string))
9152                         ++base_string;
9153                       if (*base_string != ')')
9154                         {
9155                           as_bad (_("expecting `)' "
9156                                     "after scale factor in `%s'"),
9157                                   operand_string);
9158                           return 0;
9159                         }
9160                     }
9161                   else if (!i.index_reg)
9162                     {
9163                       as_bad (_("expecting index register or scale factor "
9164                                 "after `,'; got '%c'"),
9165                               *base_string);
9166                       return 0;
9167                     }
9168                 }
9169               else if (*base_string != ')')
9170                 {
9171                   as_bad (_("expecting `,' or `)' "
9172                             "after base register in `%s'"),
9173                           operand_string);
9174                   return 0;
9175                 }
9176             }
9177           else if (*base_string == REGISTER_PREFIX)
9178             {
9179               end_op = strchr (base_string, ',');
9180               if (end_op)
9181                 *end_op = '\0';
9182               as_bad (_("bad register name `%s'"), base_string);
9183               return 0;
9184             }
9185         }
9186
9187       /* If there's an expression beginning the operand, parse it,
9188          assuming displacement_string_start and
9189          displacement_string_end are meaningful.  */
9190       if (displacement_string_start != displacement_string_end)
9191         {
9192           if (!i386_displacement (displacement_string_start,
9193                                   displacement_string_end))
9194             return 0;
9195         }
9196
9197       /* Special case for (%dx) while doing input/output op.  */
9198       if (i.base_reg
9199           && operand_type_equal (&i.base_reg->reg_type,
9200                                  &reg16_inoutportreg)
9201           && i.index_reg == 0
9202           && i.log2_scale_factor == 0
9203           && i.seg[i.mem_operands] == 0
9204           && !operand_type_check (i.types[this_operand], disp))
9205         {
9206           i.types[this_operand] = inoutportreg;
9207           return 1;
9208         }
9209
9210       if (i386_index_check (operand_string) == 0)
9211         return 0;
9212       i.types[this_operand].bitfield.mem = 1;
9213       if (i.mem_operands == 0)
9214         i.memop1_string = xstrdup (operand_string);
9215       i.mem_operands++;
9216     }
9217   else
9218     {
9219       /* It's not a memory operand; argh!  */
9220       as_bad (_("invalid char %s beginning operand %d `%s'"),
9221               output_invalid (*op_string),
9222               this_operand + 1,
9223               op_string);
9224       return 0;
9225     }
9226   return 1;                     /* Normal return.  */
9227 }
9228 \f
9229 /* Calculate the maximum variable size (i.e., excluding fr_fix)
9230    that an rs_machine_dependent frag may reach.  */
9231
9232 unsigned int
9233 i386_frag_max_var (fragS *frag)
9234 {
9235   /* The only relaxable frags are for jumps.
9236      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
9237   gas_assert (frag->fr_type == rs_machine_dependent);
9238   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
9239 }
9240
9241 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9242 static int
9243 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
9244 {
9245   /* STT_GNU_IFUNC symbol must go through PLT.  */
9246   if ((symbol_get_bfdsym (fr_symbol)->flags
9247        & BSF_GNU_INDIRECT_FUNCTION) != 0)
9248     return 0;
9249
9250   if (!S_IS_EXTERNAL (fr_symbol))
9251     /* Symbol may be weak or local.  */
9252     return !S_IS_WEAK (fr_symbol);
9253
9254   /* Global symbols with non-default visibility can't be preempted. */
9255   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
9256     return 1;
9257
9258   if (fr_var != NO_RELOC)
9259     switch ((enum bfd_reloc_code_real) fr_var)
9260       {
9261       case BFD_RELOC_386_PLT32:
9262       case BFD_RELOC_X86_64_PLT32:
9263         /* Symbol with PLT relocation may be preempted. */
9264         return 0;
9265       default:
9266         abort ();
9267       }
9268
9269   /* Global symbols with default visibility in a shared library may be
9270      preempted by another definition.  */
9271   return !shared;
9272 }
9273 #endif
9274
9275 /* md_estimate_size_before_relax()
9276
9277    Called just before relax() for rs_machine_dependent frags.  The x86
9278    assembler uses these frags to handle variable size jump
9279    instructions.
9280
9281    Any symbol that is now undefined will not become defined.
9282    Return the correct fr_subtype in the frag.
9283    Return the initial "guess for variable size of frag" to caller.
9284    The guess is actually the growth beyond the fixed part.  Whatever
9285    we do to grow the fixed or variable part contributes to our
9286    returned value.  */
9287
9288 int
9289 md_estimate_size_before_relax (fragS *fragP, segT segment)
9290 {
9291   /* We've already got fragP->fr_subtype right;  all we have to do is
9292      check for un-relaxable symbols.  On an ELF system, we can't relax
9293      an externally visible symbol, because it may be overridden by a
9294      shared library.  */
9295   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
9296 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9297       || (IS_ELF
9298           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
9299                                                 fragP->fr_var))
9300 #endif
9301 #if defined (OBJ_COFF) && defined (TE_PE)
9302       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
9303           && S_IS_WEAK (fragP->fr_symbol))
9304 #endif
9305       )
9306     {
9307       /* Symbol is undefined in this segment, or we need to keep a
9308          reloc so that weak symbols can be overridden.  */
9309       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
9310       enum bfd_reloc_code_real reloc_type;
9311       unsigned char *opcode;
9312       int old_fr_fix;
9313
9314       if (fragP->fr_var != NO_RELOC)
9315         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
9316       else if (size == 2)
9317         reloc_type = BFD_RELOC_16_PCREL;
9318       else
9319         reloc_type = BFD_RELOC_32_PCREL;
9320
9321       old_fr_fix = fragP->fr_fix;
9322       opcode = (unsigned char *) fragP->fr_opcode;
9323
9324       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
9325         {
9326         case UNCOND_JUMP:
9327           /* Make jmp (0xeb) a (d)word displacement jump.  */
9328           opcode[0] = 0xe9;
9329           fragP->fr_fix += size;
9330           fix_new (fragP, old_fr_fix, size,
9331                    fragP->fr_symbol,
9332                    fragP->fr_offset, 1,
9333                    reloc_type);
9334           break;
9335
9336         case COND_JUMP86:
9337           if (size == 2
9338               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
9339             {
9340               /* Negate the condition, and branch past an
9341                  unconditional jump.  */
9342               opcode[0] ^= 1;
9343               opcode[1] = 3;
9344               /* Insert an unconditional jump.  */
9345               opcode[2] = 0xe9;
9346               /* We added two extra opcode bytes, and have a two byte
9347                  offset.  */
9348               fragP->fr_fix += 2 + 2;
9349               fix_new (fragP, old_fr_fix + 2, 2,
9350                        fragP->fr_symbol,
9351                        fragP->fr_offset, 1,
9352                        reloc_type);
9353               break;
9354             }
9355           /* Fall through.  */
9356
9357         case COND_JUMP:
9358           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
9359             {
9360               fixS *fixP;
9361
9362               fragP->fr_fix += 1;
9363               fixP = fix_new (fragP, old_fr_fix, 1,
9364                               fragP->fr_symbol,
9365                               fragP->fr_offset, 1,
9366                               BFD_RELOC_8_PCREL);
9367               fixP->fx_signed = 1;
9368               break;
9369             }
9370
9371           /* This changes the byte-displacement jump 0x7N
9372              to the (d)word-displacement jump 0x0f,0x8N.  */
9373           opcode[1] = opcode[0] + 0x10;
9374           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
9375           /* We've added an opcode byte.  */
9376           fragP->fr_fix += 1 + size;
9377           fix_new (fragP, old_fr_fix + 1, size,
9378                    fragP->fr_symbol,
9379                    fragP->fr_offset, 1,
9380                    reloc_type);
9381           break;
9382
9383         default:
9384           BAD_CASE (fragP->fr_subtype);
9385           break;
9386         }
9387       frag_wane (fragP);
9388       return fragP->fr_fix - old_fr_fix;
9389     }
9390
9391   /* Guess size depending on current relax state.  Initially the relax
9392      state will correspond to a short jump and we return 1, because
9393      the variable part of the frag (the branch offset) is one byte
9394      long.  However, we can relax a section more than once and in that
9395      case we must either set fr_subtype back to the unrelaxed state,
9396      or return the value for the appropriate branch.  */
9397   return md_relax_table[fragP->fr_subtype].rlx_length;
9398 }
9399
9400 /* Called after relax() is finished.
9401
9402    In:  Address of frag.
9403         fr_type == rs_machine_dependent.
9404         fr_subtype is what the address relaxed to.
9405
9406    Out: Any fixSs and constants are set up.
9407         Caller will turn frag into a ".space 0".  */
9408
9409 void
9410 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
9411                  fragS *fragP)
9412 {
9413   unsigned char *opcode;
9414   unsigned char *where_to_put_displacement = NULL;
9415   offsetT target_address;
9416   offsetT opcode_address;
9417   unsigned int extension = 0;
9418   offsetT displacement_from_opcode_start;
9419
9420   opcode = (unsigned char *) fragP->fr_opcode;
9421
9422   /* Address we want to reach in file space.  */
9423   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
9424
9425   /* Address opcode resides at in file space.  */
9426   opcode_address = fragP->fr_address + fragP->fr_fix;
9427
9428   /* Displacement from opcode start to fill into instruction.  */
9429   displacement_from_opcode_start = target_address - opcode_address;
9430
9431   if ((fragP->fr_subtype & BIG) == 0)
9432     {
9433       /* Don't have to change opcode.  */
9434       extension = 1;            /* 1 opcode + 1 displacement  */
9435       where_to_put_displacement = &opcode[1];
9436     }
9437   else
9438     {
9439       if (no_cond_jump_promotion
9440           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
9441         as_warn_where (fragP->fr_file, fragP->fr_line,
9442                        _("long jump required"));
9443
9444       switch (fragP->fr_subtype)
9445         {
9446         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
9447           extension = 4;                /* 1 opcode + 4 displacement  */
9448           opcode[0] = 0xe9;
9449           where_to_put_displacement = &opcode[1];
9450           break;
9451
9452         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
9453           extension = 2;                /* 1 opcode + 2 displacement  */
9454           opcode[0] = 0xe9;
9455           where_to_put_displacement = &opcode[1];
9456           break;
9457
9458         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
9459         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
9460           extension = 5;                /* 2 opcode + 4 displacement  */
9461           opcode[1] = opcode[0] + 0x10;
9462           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
9463           where_to_put_displacement = &opcode[2];
9464           break;
9465
9466         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
9467           extension = 3;                /* 2 opcode + 2 displacement  */
9468           opcode[1] = opcode[0] + 0x10;
9469           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
9470           where_to_put_displacement = &opcode[2];
9471           break;
9472
9473         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
9474           extension = 4;
9475           opcode[0] ^= 1;
9476           opcode[1] = 3;
9477           opcode[2] = 0xe9;
9478           where_to_put_displacement = &opcode[3];
9479           break;
9480
9481         default:
9482           BAD_CASE (fragP->fr_subtype);
9483           break;
9484         }
9485     }
9486
9487   /* If size if less then four we are sure that the operand fits,
9488      but if it's 4, then it could be that the displacement is larger
9489      then -/+ 2GB.  */
9490   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
9491       && object_64bit
9492       && ((addressT) (displacement_from_opcode_start - extension
9493                       + ((addressT) 1 << 31))
9494           > (((addressT) 2 << 31) - 1)))
9495     {
9496       as_bad_where (fragP->fr_file, fragP->fr_line,
9497                     _("jump target out of range"));
9498       /* Make us emit 0.  */
9499       displacement_from_opcode_start = extension;
9500     }
9501   /* Now put displacement after opcode.  */
9502   md_number_to_chars ((char *) where_to_put_displacement,
9503                       (valueT) (displacement_from_opcode_start - extension),
9504                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
9505   fragP->fr_fix += extension;
9506 }
9507 \f
9508 /* Apply a fixup (fixP) to segment data, once it has been determined
9509    by our caller that we have all the info we need to fix it up.
9510
9511    Parameter valP is the pointer to the value of the bits.
9512
9513    On the 386, immediates, displacements, and data pointers are all in
9514    the same (little-endian) format, so we don't need to care about which
9515    we are handling.  */
9516
9517 void
9518 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
9519 {
9520   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
9521   valueT value = *valP;
9522
9523 #if !defined (TE_Mach)
9524   if (fixP->fx_pcrel)
9525     {
9526       switch (fixP->fx_r_type)
9527         {
9528         default:
9529           break;
9530
9531         case BFD_RELOC_64:
9532           fixP->fx_r_type = BFD_RELOC_64_PCREL;
9533           break;
9534         case BFD_RELOC_32:
9535         case BFD_RELOC_X86_64_32S:
9536           fixP->fx_r_type = BFD_RELOC_32_PCREL;
9537           break;
9538         case BFD_RELOC_16:
9539           fixP->fx_r_type = BFD_RELOC_16_PCREL;
9540           break;
9541         case BFD_RELOC_8:
9542           fixP->fx_r_type = BFD_RELOC_8_PCREL;
9543           break;
9544         }
9545     }
9546
9547   if (fixP->fx_addsy != NULL
9548       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
9549           || fixP->fx_r_type == BFD_RELOC_64_PCREL
9550           || fixP->fx_r_type == BFD_RELOC_16_PCREL
9551           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
9552       && !use_rela_relocations)
9553     {
9554       /* This is a hack.  There should be a better way to handle this.
9555          This covers for the fact that bfd_install_relocation will
9556          subtract the current location (for partial_inplace, PC relative
9557          relocations); see more below.  */
9558 #ifndef OBJ_AOUT
9559       if (IS_ELF
9560 #ifdef TE_PE
9561           || OUTPUT_FLAVOR == bfd_target_coff_flavour
9562 #endif
9563           )
9564         value += fixP->fx_where + fixP->fx_frag->fr_address;
9565 #endif
9566 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9567       if (IS_ELF)
9568         {
9569           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
9570
9571           if ((sym_seg == seg
9572                || (symbol_section_p (fixP->fx_addsy)
9573                    && sym_seg != absolute_section))
9574               && !generic_force_reloc (fixP))
9575             {
9576               /* Yes, we add the values in twice.  This is because
9577                  bfd_install_relocation subtracts them out again.  I think
9578                  bfd_install_relocation is broken, but I don't dare change
9579                  it.  FIXME.  */
9580               value += fixP->fx_where + fixP->fx_frag->fr_address;
9581             }
9582         }
9583 #endif
9584 #if defined (OBJ_COFF) && defined (TE_PE)
9585       /* For some reason, the PE format does not store a
9586          section address offset for a PC relative symbol.  */
9587       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
9588           || S_IS_WEAK (fixP->fx_addsy))
9589         value += md_pcrel_from (fixP);
9590 #endif
9591     }
9592 #if defined (OBJ_COFF) && defined (TE_PE)
9593   if (fixP->fx_addsy != NULL
9594       && S_IS_WEAK (fixP->fx_addsy)
9595       /* PR 16858: Do not modify weak function references.  */
9596       && ! fixP->fx_pcrel)
9597     {
9598 #if !defined (TE_PEP)
9599       /* For x86 PE weak function symbols are neither PC-relative
9600          nor do they set S_IS_FUNCTION.  So the only reliable way
9601          to detect them is to check the flags of their containing
9602          section.  */
9603       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
9604           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
9605         ;
9606       else
9607 #endif
9608       value -= S_GET_VALUE (fixP->fx_addsy);
9609     }
9610 #endif
9611
9612   /* Fix a few things - the dynamic linker expects certain values here,
9613      and we must not disappoint it.  */
9614 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9615   if (IS_ELF && fixP->fx_addsy)
9616     switch (fixP->fx_r_type)
9617       {
9618       case BFD_RELOC_386_PLT32:
9619       case BFD_RELOC_X86_64_PLT32:
9620         /* Make the jump instruction point to the address of the operand.  At
9621            runtime we merely add the offset to the actual PLT entry.  */
9622         value = -4;
9623         break;
9624
9625       case BFD_RELOC_386_TLS_GD:
9626       case BFD_RELOC_386_TLS_LDM:
9627       case BFD_RELOC_386_TLS_IE_32:
9628       case BFD_RELOC_386_TLS_IE:
9629       case BFD_RELOC_386_TLS_GOTIE:
9630       case BFD_RELOC_386_TLS_GOTDESC:
9631       case BFD_RELOC_X86_64_TLSGD:
9632       case BFD_RELOC_X86_64_TLSLD:
9633       case BFD_RELOC_X86_64_GOTTPOFF:
9634       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
9635         value = 0; /* Fully resolved at runtime.  No addend.  */
9636         /* Fallthrough */
9637       case BFD_RELOC_386_TLS_LE:
9638       case BFD_RELOC_386_TLS_LDO_32:
9639       case BFD_RELOC_386_TLS_LE_32:
9640       case BFD_RELOC_X86_64_DTPOFF32:
9641       case BFD_RELOC_X86_64_DTPOFF64:
9642       case BFD_RELOC_X86_64_TPOFF32:
9643       case BFD_RELOC_X86_64_TPOFF64:
9644         S_SET_THREAD_LOCAL (fixP->fx_addsy);
9645         break;
9646
9647       case BFD_RELOC_386_TLS_DESC_CALL:
9648       case BFD_RELOC_X86_64_TLSDESC_CALL:
9649         value = 0; /* Fully resolved at runtime.  No addend.  */
9650         S_SET_THREAD_LOCAL (fixP->fx_addsy);
9651         fixP->fx_done = 0;
9652         return;
9653
9654       case BFD_RELOC_VTABLE_INHERIT:
9655       case BFD_RELOC_VTABLE_ENTRY:
9656         fixP->fx_done = 0;
9657         return;
9658
9659       default:
9660         break;
9661       }
9662 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
9663   *valP = value;
9664 #endif /* !defined (TE_Mach)  */
9665
9666   /* Are we finished with this relocation now?  */
9667   if (fixP->fx_addsy == NULL)
9668     fixP->fx_done = 1;
9669 #if defined (OBJ_COFF) && defined (TE_PE)
9670   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
9671     {
9672       fixP->fx_done = 0;
9673       /* Remember value for tc_gen_reloc.  */
9674       fixP->fx_addnumber = value;
9675       /* Clear out the frag for now.  */
9676       value = 0;
9677     }
9678 #endif
9679   else if (use_rela_relocations)
9680     {
9681       fixP->fx_no_overflow = 1;
9682       /* Remember value for tc_gen_reloc.  */
9683       fixP->fx_addnumber = value;
9684       value = 0;
9685     }
9686
9687   md_number_to_chars (p, value, fixP->fx_size);
9688 }
9689 \f
9690 const char *
9691 md_atof (int type, char *litP, int *sizeP)
9692 {
9693   /* This outputs the LITTLENUMs in REVERSE order;
9694      in accord with the bigendian 386.  */
9695   return ieee_md_atof (type, litP, sizeP, FALSE);
9696 }
9697 \f
9698 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
9699
9700 static char *
9701 output_invalid (int c)
9702 {
9703   if (ISPRINT (c))
9704     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
9705               "'%c'", c);
9706   else
9707     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
9708               "(0x%x)", (unsigned char) c);
9709   return output_invalid_buf;
9710 }
9711
9712 /* REG_STRING starts *before* REGISTER_PREFIX.  */
9713
9714 static const reg_entry *
9715 parse_real_register (char *reg_string, char **end_op)
9716 {
9717   char *s = reg_string;
9718   char *p;
9719   char reg_name_given[MAX_REG_NAME_SIZE + 1];
9720   const reg_entry *r;
9721
9722   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
9723   if (*s == REGISTER_PREFIX)
9724     ++s;
9725
9726   if (is_space_char (*s))
9727     ++s;
9728
9729   p = reg_name_given;
9730   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
9731     {
9732       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
9733         return (const reg_entry *) NULL;
9734       s++;
9735     }
9736
9737   /* For naked regs, make sure that we are not dealing with an identifier.
9738      This prevents confusing an identifier like `eax_var' with register
9739      `eax'.  */
9740   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
9741     return (const reg_entry *) NULL;
9742
9743   *end_op = s;
9744
9745   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
9746
9747   /* Handle floating point regs, allowing spaces in the (i) part.  */
9748   if (r == i386_regtab /* %st is first entry of table  */)
9749     {
9750       if (is_space_char (*s))
9751         ++s;
9752       if (*s == '(')
9753         {
9754           ++s;
9755           if (is_space_char (*s))
9756             ++s;
9757           if (*s >= '0' && *s <= '7')
9758             {
9759               int fpr = *s - '0';
9760               ++s;
9761               if (is_space_char (*s))
9762                 ++s;
9763               if (*s == ')')
9764                 {
9765                   *end_op = s + 1;
9766                   r = (const reg_entry *) hash_find (reg_hash, "st(0)");
9767                   know (r);
9768                   return r + fpr;
9769                 }
9770             }
9771           /* We have "%st(" then garbage.  */
9772           return (const reg_entry *) NULL;
9773         }
9774     }
9775
9776   if (r == NULL || allow_pseudo_reg)
9777     return r;
9778
9779   if (operand_type_all_zero (&r->reg_type))
9780     return (const reg_entry *) NULL;
9781
9782   if ((r->reg_type.bitfield.dword
9783        || r->reg_type.bitfield.sreg3
9784        || r->reg_type.bitfield.control
9785        || r->reg_type.bitfield.debug
9786        || r->reg_type.bitfield.test)
9787       && !cpu_arch_flags.bitfield.cpui386)
9788     return (const reg_entry *) NULL;
9789
9790   if (r->reg_type.bitfield.tbyte
9791       && !cpu_arch_flags.bitfield.cpu8087
9792       && !cpu_arch_flags.bitfield.cpu287
9793       && !cpu_arch_flags.bitfield.cpu387)
9794     return (const reg_entry *) NULL;
9795
9796   if (r->reg_type.bitfield.regmmx && !cpu_arch_flags.bitfield.cpuregmmx)
9797     return (const reg_entry *) NULL;
9798
9799   if (r->reg_type.bitfield.xmmword && !cpu_arch_flags.bitfield.cpuregxmm)
9800     return (const reg_entry *) NULL;
9801
9802   if (r->reg_type.bitfield.ymmword && !cpu_arch_flags.bitfield.cpuregymm)
9803     return (const reg_entry *) NULL;
9804
9805   if (r->reg_type.bitfield.zmmword && !cpu_arch_flags.bitfield.cpuregzmm)
9806     return (const reg_entry *) NULL;
9807
9808   if (r->reg_type.bitfield.regmask
9809       && !cpu_arch_flags.bitfield.cpuregmask)
9810     return (const reg_entry *) NULL;
9811
9812   /* Don't allow fake index register unless allow_index_reg isn't 0. */
9813   if (!allow_index_reg
9814       && (r->reg_num == RegEiz || r->reg_num == RegRiz))
9815     return (const reg_entry *) NULL;
9816
9817   /* Upper 16 vector register is only available with VREX in 64bit
9818      mode.  */
9819   if ((r->reg_flags & RegVRex))
9820     {
9821       if (i.vec_encoding == vex_encoding_default)
9822         i.vec_encoding = vex_encoding_evex;
9823
9824       if (!cpu_arch_flags.bitfield.cpuvrex
9825           || i.vec_encoding != vex_encoding_evex
9826           || flag_code != CODE_64BIT)
9827         return (const reg_entry *) NULL;
9828     }
9829
9830   if (((r->reg_flags & (RegRex64 | RegRex))
9831        || r->reg_type.bitfield.qword)
9832       && (!cpu_arch_flags.bitfield.cpulm
9833           || !operand_type_equal (&r->reg_type, &control))
9834       && flag_code != CODE_64BIT)
9835     return (const reg_entry *) NULL;
9836
9837   if (r->reg_type.bitfield.sreg3 && r->reg_num == RegFlat && !intel_syntax)
9838     return (const reg_entry *) NULL;
9839
9840   return r;
9841 }
9842
9843 /* REG_STRING starts *before* REGISTER_PREFIX.  */
9844
9845 static const reg_entry *
9846 parse_register (char *reg_string, char **end_op)
9847 {
9848   const reg_entry *r;
9849
9850   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
9851     r = parse_real_register (reg_string, end_op);
9852   else
9853     r = NULL;
9854   if (!r)
9855     {
9856       char *save = input_line_pointer;
9857       char c;
9858       symbolS *symbolP;
9859
9860       input_line_pointer = reg_string;
9861       c = get_symbol_name (&reg_string);
9862       symbolP = symbol_find (reg_string);
9863       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
9864         {
9865           const expressionS *e = symbol_get_value_expression (symbolP);
9866
9867           know (e->X_op == O_register);
9868           know (e->X_add_number >= 0
9869                 && (valueT) e->X_add_number < i386_regtab_size);
9870           r = i386_regtab + e->X_add_number;
9871           if ((r->reg_flags & RegVRex))
9872             i.vec_encoding = vex_encoding_evex;
9873           *end_op = input_line_pointer;
9874         }
9875       *input_line_pointer = c;
9876       input_line_pointer = save;
9877     }
9878   return r;
9879 }
9880
9881 int
9882 i386_parse_name (char *name, expressionS *e, char *nextcharP)
9883 {
9884   const reg_entry *r;
9885   char *end = input_line_pointer;
9886
9887   *end = *nextcharP;
9888   r = parse_register (name, &input_line_pointer);
9889   if (r && end <= input_line_pointer)
9890     {
9891       *nextcharP = *input_line_pointer;
9892       *input_line_pointer = 0;
9893       e->X_op = O_register;
9894       e->X_add_number = r - i386_regtab;
9895       return 1;
9896     }
9897   input_line_pointer = end;
9898   *end = 0;
9899   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
9900 }
9901
9902 void
9903 md_operand (expressionS *e)
9904 {
9905   char *end;
9906   const reg_entry *r;
9907
9908   switch (*input_line_pointer)
9909     {
9910     case REGISTER_PREFIX:
9911       r = parse_real_register (input_line_pointer, &end);
9912       if (r)
9913         {
9914           e->X_op = O_register;
9915           e->X_add_number = r - i386_regtab;
9916           input_line_pointer = end;
9917         }
9918       break;
9919
9920     case '[':
9921       gas_assert (intel_syntax);
9922       end = input_line_pointer++;
9923       expression (e);
9924       if (*input_line_pointer == ']')
9925         {
9926           ++input_line_pointer;
9927           e->X_op_symbol = make_expr_symbol (e);
9928           e->X_add_symbol = NULL;
9929           e->X_add_number = 0;
9930           e->X_op = O_index;
9931         }
9932       else
9933         {
9934           e->X_op = O_absent;
9935           input_line_pointer = end;
9936         }
9937       break;
9938     }
9939 }
9940
9941 \f
9942 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9943 const char *md_shortopts = "kVQ:sqn";
9944 #else
9945 const char *md_shortopts = "qn";
9946 #endif
9947
9948 #define OPTION_32 (OPTION_MD_BASE + 0)
9949 #define OPTION_64 (OPTION_MD_BASE + 1)
9950 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
9951 #define OPTION_MARCH (OPTION_MD_BASE + 3)
9952 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
9953 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
9954 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
9955 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
9956 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
9957 #define OPTION_MOLD_GCC (OPTION_MD_BASE + 9)
9958 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
9959 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
9960 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
9961 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
9962 #define OPTION_X32 (OPTION_MD_BASE + 14)
9963 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
9964 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
9965 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
9966 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
9967 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
9968 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
9969 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
9970 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
9971 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
9972 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
9973 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 25)
9974
9975 struct option md_longopts[] =
9976 {
9977   {"32", no_argument, NULL, OPTION_32},
9978 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
9979      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
9980   {"64", no_argument, NULL, OPTION_64},
9981 #endif
9982 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9983   {"x32", no_argument, NULL, OPTION_X32},
9984   {"mshared", no_argument, NULL, OPTION_MSHARED},
9985 #endif
9986   {"divide", no_argument, NULL, OPTION_DIVIDE},
9987   {"march", required_argument, NULL, OPTION_MARCH},
9988   {"mtune", required_argument, NULL, OPTION_MTUNE},
9989   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
9990   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
9991   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
9992   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
9993   {"mold-gcc", no_argument, NULL, OPTION_MOLD_GCC},
9994   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
9995   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
9996   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
9997   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
9998   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
9999   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
10000   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
10001 # if defined (TE_PE) || defined (TE_PEP)
10002   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
10003 #endif
10004   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
10005   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
10006   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
10007   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
10008   {"mamd64", no_argument, NULL, OPTION_MAMD64},
10009   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
10010   {NULL, no_argument, NULL, 0}
10011 };
10012 size_t md_longopts_size = sizeof (md_longopts);
10013
10014 int
10015 md_parse_option (int c, const char *arg)
10016 {
10017   unsigned int j;
10018   char *arch, *next, *saved;
10019
10020   switch (c)
10021     {
10022     case 'n':
10023       optimize_align_code = 0;
10024       break;
10025
10026     case 'q':
10027       quiet_warnings = 1;
10028       break;
10029
10030 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10031       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
10032          should be emitted or not.  FIXME: Not implemented.  */
10033     case 'Q':
10034       break;
10035
10036       /* -V: SVR4 argument to print version ID.  */
10037     case 'V':
10038       print_version_id ();
10039       break;
10040
10041       /* -k: Ignore for FreeBSD compatibility.  */
10042     case 'k':
10043       break;
10044
10045     case 's':
10046       /* -s: On i386 Solaris, this tells the native assembler to use
10047          .stab instead of .stab.excl.  We always use .stab anyhow.  */
10048       break;
10049
10050     case OPTION_MSHARED:
10051       shared = 1;
10052       break;
10053 #endif
10054 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
10055      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
10056     case OPTION_64:
10057       {
10058         const char **list, **l;
10059
10060         list = bfd_target_list ();
10061         for (l = list; *l != NULL; l++)
10062           if (CONST_STRNEQ (*l, "elf64-x86-64")
10063               || strcmp (*l, "coff-x86-64") == 0
10064               || strcmp (*l, "pe-x86-64") == 0
10065               || strcmp (*l, "pei-x86-64") == 0
10066               || strcmp (*l, "mach-o-x86-64") == 0)
10067             {
10068               default_arch = "x86_64";
10069               break;
10070             }
10071         if (*l == NULL)
10072           as_fatal (_("no compiled in support for x86_64"));
10073         free (list);
10074       }
10075       break;
10076 #endif
10077
10078 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10079     case OPTION_X32:
10080       if (IS_ELF)
10081         {
10082           const char **list, **l;
10083
10084           list = bfd_target_list ();
10085           for (l = list; *l != NULL; l++)
10086             if (CONST_STRNEQ (*l, "elf32-x86-64"))
10087               {
10088                 default_arch = "x86_64:32";
10089                 break;
10090               }
10091           if (*l == NULL)
10092             as_fatal (_("no compiled in support for 32bit x86_64"));
10093           free (list);
10094         }
10095       else
10096         as_fatal (_("32bit x86_64 is only supported for ELF"));
10097       break;
10098 #endif
10099
10100     case OPTION_32:
10101       default_arch = "i386";
10102       break;
10103
10104     case OPTION_DIVIDE:
10105 #ifdef SVR4_COMMENT_CHARS
10106       {
10107         char *n, *t;
10108         const char *s;
10109
10110         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
10111         t = n;
10112         for (s = i386_comment_chars; *s != '\0'; s++)
10113           if (*s != '/')
10114             *t++ = *s;
10115         *t = '\0';
10116         i386_comment_chars = n;
10117       }
10118 #endif
10119       break;
10120
10121     case OPTION_MARCH:
10122       saved = xstrdup (arg);
10123       arch = saved;
10124       /* Allow -march=+nosse.  */
10125       if (*arch == '+')
10126         arch++;
10127       do
10128         {
10129           if (*arch == '.')
10130             as_fatal (_("invalid -march= option: `%s'"), arg);
10131           next = strchr (arch, '+');
10132           if (next)
10133             *next++ = '\0';
10134           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
10135             {
10136               if (strcmp (arch, cpu_arch [j].name) == 0)
10137                 {
10138                   /* Processor.  */
10139                   if (! cpu_arch[j].flags.bitfield.cpui386)
10140                     continue;
10141
10142                   cpu_arch_name = cpu_arch[j].name;
10143                   cpu_sub_arch_name = NULL;
10144                   cpu_arch_flags = cpu_arch[j].flags;
10145                   cpu_arch_isa = cpu_arch[j].type;
10146                   cpu_arch_isa_flags = cpu_arch[j].flags;
10147                   if (!cpu_arch_tune_set)
10148                     {
10149                       cpu_arch_tune = cpu_arch_isa;
10150                       cpu_arch_tune_flags = cpu_arch_isa_flags;
10151                     }
10152                   break;
10153                 }
10154               else if (*cpu_arch [j].name == '.'
10155                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
10156                 {
10157                   /* ISA extension.  */
10158                   i386_cpu_flags flags;
10159
10160                   flags = cpu_flags_or (cpu_arch_flags,
10161                                         cpu_arch[j].flags);
10162
10163                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
10164                     {
10165                       if (cpu_sub_arch_name)
10166                         {
10167                           char *name = cpu_sub_arch_name;
10168                           cpu_sub_arch_name = concat (name,
10169                                                       cpu_arch[j].name,
10170                                                       (const char *) NULL);
10171                           free (name);
10172                         }
10173                       else
10174                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
10175                       cpu_arch_flags = flags;
10176                       cpu_arch_isa_flags = flags;
10177                     }
10178                   break;
10179                 }
10180             }
10181
10182           if (j >= ARRAY_SIZE (cpu_arch))
10183             {
10184               /* Disable an ISA extension.  */
10185               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
10186                 if (strcmp (arch, cpu_noarch [j].name) == 0)
10187                   {
10188                     i386_cpu_flags flags;
10189
10190                     flags = cpu_flags_and_not (cpu_arch_flags,
10191                                                cpu_noarch[j].flags);
10192                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
10193                       {
10194                         if (cpu_sub_arch_name)
10195                           {
10196                             char *name = cpu_sub_arch_name;
10197                             cpu_sub_arch_name = concat (arch,
10198                                                         (const char *) NULL);
10199                             free (name);
10200                           }
10201                         else
10202                           cpu_sub_arch_name = xstrdup (arch);
10203                         cpu_arch_flags = flags;
10204                         cpu_arch_isa_flags = flags;
10205                       }
10206                     break;
10207                   }
10208
10209               if (j >= ARRAY_SIZE (cpu_noarch))
10210                 j = ARRAY_SIZE (cpu_arch);
10211             }
10212
10213           if (j >= ARRAY_SIZE (cpu_arch))
10214             as_fatal (_("invalid -march= option: `%s'"), arg);
10215
10216           arch = next;
10217         }
10218       while (next != NULL);
10219       free (saved);
10220       break;
10221
10222     case OPTION_MTUNE:
10223       if (*arg == '.')
10224         as_fatal (_("invalid -mtune= option: `%s'"), arg);
10225       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
10226         {
10227           if (strcmp (arg, cpu_arch [j].name) == 0)
10228             {
10229               cpu_arch_tune_set = 1;
10230               cpu_arch_tune = cpu_arch [j].type;
10231               cpu_arch_tune_flags = cpu_arch[j].flags;
10232               break;
10233             }
10234         }
10235       if (j >= ARRAY_SIZE (cpu_arch))
10236         as_fatal (_("invalid -mtune= option: `%s'"), arg);
10237       break;
10238
10239     case OPTION_MMNEMONIC:
10240       if (strcasecmp (arg, "att") == 0)
10241         intel_mnemonic = 0;
10242       else if (strcasecmp (arg, "intel") == 0)
10243         intel_mnemonic = 1;
10244       else
10245         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
10246       break;
10247
10248     case OPTION_MSYNTAX:
10249       if (strcasecmp (arg, "att") == 0)
10250         intel_syntax = 0;
10251       else if (strcasecmp (arg, "intel") == 0)
10252         intel_syntax = 1;
10253       else
10254         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
10255       break;
10256
10257     case OPTION_MINDEX_REG:
10258       allow_index_reg = 1;
10259       break;
10260
10261     case OPTION_MNAKED_REG:
10262       allow_naked_reg = 1;
10263       break;
10264
10265     case OPTION_MOLD_GCC:
10266       old_gcc = 1;
10267       break;
10268
10269     case OPTION_MSSE2AVX:
10270       sse2avx = 1;
10271       break;
10272
10273     case OPTION_MSSE_CHECK:
10274       if (strcasecmp (arg, "error") == 0)
10275         sse_check = check_error;
10276       else if (strcasecmp (arg, "warning") == 0)
10277         sse_check = check_warning;
10278       else if (strcasecmp (arg, "none") == 0)
10279         sse_check = check_none;
10280       else
10281         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
10282       break;
10283
10284     case OPTION_MOPERAND_CHECK:
10285       if (strcasecmp (arg, "error") == 0)
10286         operand_check = check_error;
10287       else if (strcasecmp (arg, "warning") == 0)
10288         operand_check = check_warning;
10289       else if (strcasecmp (arg, "none") == 0)
10290         operand_check = check_none;
10291       else
10292         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
10293       break;
10294
10295     case OPTION_MAVXSCALAR:
10296       if (strcasecmp (arg, "128") == 0)
10297         avxscalar = vex128;
10298       else if (strcasecmp (arg, "256") == 0)
10299         avxscalar = vex256;
10300       else
10301         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
10302       break;
10303
10304     case OPTION_MADD_BND_PREFIX:
10305       add_bnd_prefix = 1;
10306       break;
10307
10308     case OPTION_MEVEXLIG:
10309       if (strcmp (arg, "128") == 0)
10310         evexlig = evexl128;
10311       else if (strcmp (arg, "256") == 0)
10312         evexlig = evexl256;
10313       else  if (strcmp (arg, "512") == 0)
10314         evexlig = evexl512;
10315       else
10316         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
10317       break;
10318
10319     case OPTION_MEVEXRCIG:
10320       if (strcmp (arg, "rne") == 0)
10321         evexrcig = rne;
10322       else if (strcmp (arg, "rd") == 0)
10323         evexrcig = rd;
10324       else if (strcmp (arg, "ru") == 0)
10325         evexrcig = ru;
10326       else if (strcmp (arg, "rz") == 0)
10327         evexrcig = rz;
10328       else
10329         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
10330       break;
10331
10332     case OPTION_MEVEXWIG:
10333       if (strcmp (arg, "0") == 0)
10334         evexwig = evexw0;
10335       else if (strcmp (arg, "1") == 0)
10336         evexwig = evexw1;
10337       else
10338         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
10339       break;
10340
10341 # if defined (TE_PE) || defined (TE_PEP)
10342     case OPTION_MBIG_OBJ:
10343       use_big_obj = 1;
10344       break;
10345 #endif
10346
10347     case OPTION_MOMIT_LOCK_PREFIX:
10348       if (strcasecmp (arg, "yes") == 0)
10349         omit_lock_prefix = 1;
10350       else if (strcasecmp (arg, "no") == 0)
10351         omit_lock_prefix = 0;
10352       else
10353         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
10354       break;
10355
10356     case OPTION_MFENCE_AS_LOCK_ADD:
10357       if (strcasecmp (arg, "yes") == 0)
10358         avoid_fence = 1;
10359       else if (strcasecmp (arg, "no") == 0)
10360         avoid_fence = 0;
10361       else
10362         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
10363       break;
10364
10365     case OPTION_MRELAX_RELOCATIONS:
10366       if (strcasecmp (arg, "yes") == 0)
10367         generate_relax_relocations = 1;
10368       else if (strcasecmp (arg, "no") == 0)
10369         generate_relax_relocations = 0;
10370       else
10371         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
10372       break;
10373
10374     case OPTION_MAMD64:
10375       intel64 = 0;
10376       break;
10377
10378     case OPTION_MINTEL64:
10379       intel64 = 1;
10380       break;
10381
10382     default:
10383       return 0;
10384     }
10385   return 1;
10386 }
10387
10388 #define MESSAGE_TEMPLATE \
10389 "                                                                                "
10390
10391 static char *
10392 output_message (FILE *stream, char *p, char *message, char *start,
10393                 int *left_p, const char *name, int len)
10394 {
10395   int size = sizeof (MESSAGE_TEMPLATE);
10396   int left = *left_p;
10397
10398   /* Reserve 2 spaces for ", " or ",\0" */
10399   left -= len + 2;
10400
10401   /* Check if there is any room.  */
10402   if (left >= 0)
10403     {
10404       if (p != start)
10405         {
10406           *p++ = ',';
10407           *p++ = ' ';
10408         }
10409       p = mempcpy (p, name, len);
10410     }
10411   else
10412     {
10413       /* Output the current message now and start a new one.  */
10414       *p++ = ',';
10415       *p = '\0';
10416       fprintf (stream, "%s\n", message);
10417       p = start;
10418       left = size - (start - message) - len - 2;
10419
10420       gas_assert (left >= 0);
10421
10422       p = mempcpy (p, name, len);
10423     }
10424
10425   *left_p = left;
10426   return p;
10427 }
10428
10429 static void
10430 show_arch (FILE *stream, int ext, int check)
10431 {
10432   static char message[] = MESSAGE_TEMPLATE;
10433   char *start = message + 27;
10434   char *p;
10435   int size = sizeof (MESSAGE_TEMPLATE);
10436   int left;
10437   const char *name;
10438   int len;
10439   unsigned int j;
10440
10441   p = start;
10442   left = size - (start - message);
10443   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
10444     {
10445       /* Should it be skipped?  */
10446       if (cpu_arch [j].skip)
10447         continue;
10448
10449       name = cpu_arch [j].name;
10450       len = cpu_arch [j].len;
10451       if (*name == '.')
10452         {
10453           /* It is an extension.  Skip if we aren't asked to show it.  */
10454           if (ext)
10455             {
10456               name++;
10457               len--;
10458             }
10459           else
10460             continue;
10461         }
10462       else if (ext)
10463         {
10464           /* It is an processor.  Skip if we show only extension.  */
10465           continue;
10466         }
10467       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
10468         {
10469           /* It is an impossible processor - skip.  */
10470           continue;
10471         }
10472
10473       p = output_message (stream, p, message, start, &left, name, len);
10474     }
10475
10476   /* Display disabled extensions.  */
10477   if (ext)
10478     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
10479       {
10480         name = cpu_noarch [j].name;
10481         len = cpu_noarch [j].len;
10482         p = output_message (stream, p, message, start, &left, name,
10483                             len);
10484       }
10485
10486   *p = '\0';
10487   fprintf (stream, "%s\n", message);
10488 }
10489
10490 void
10491 md_show_usage (FILE *stream)
10492 {
10493 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10494   fprintf (stream, _("\
10495   -Q                      ignored\n\
10496   -V                      print assembler version number\n\
10497   -k                      ignored\n"));
10498 #endif
10499   fprintf (stream, _("\
10500   -n                      Do not optimize code alignment\n\
10501   -q                      quieten some warnings\n"));
10502 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10503   fprintf (stream, _("\
10504   -s                      ignored\n"));
10505 #endif
10506 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
10507      || defined (TE_PE) || defined (TE_PEP))
10508   fprintf (stream, _("\
10509   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
10510 #endif
10511 #ifdef SVR4_COMMENT_CHARS
10512   fprintf (stream, _("\
10513   --divide                do not treat `/' as a comment character\n"));
10514 #else
10515   fprintf (stream, _("\
10516   --divide                ignored\n"));
10517 #endif
10518   fprintf (stream, _("\
10519   -march=CPU[,+EXTENSION...]\n\
10520                           generate code for CPU and EXTENSION, CPU is one of:\n"));
10521   show_arch (stream, 0, 1);
10522   fprintf (stream, _("\
10523                           EXTENSION is combination of:\n"));
10524   show_arch (stream, 1, 0);
10525   fprintf (stream, _("\
10526   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
10527   show_arch (stream, 0, 0);
10528   fprintf (stream, _("\
10529   -msse2avx               encode SSE instructions with VEX prefix\n"));
10530   fprintf (stream, _("\
10531   -msse-check=[none|error|warning]\n\
10532                           check SSE instructions\n"));
10533   fprintf (stream, _("\
10534   -moperand-check=[none|error|warning]\n\
10535                           check operand combinations for validity\n"));
10536   fprintf (stream, _("\
10537   -mavxscalar=[128|256]   encode scalar AVX instructions with specific vector\n\
10538                            length\n"));
10539   fprintf (stream, _("\
10540   -mevexlig=[128|256|512] encode scalar EVEX instructions with specific vector\n\
10541                            length\n"));
10542   fprintf (stream, _("\
10543   -mevexwig=[0|1]         encode EVEX instructions with specific EVEX.W value\n\
10544                            for EVEX.W bit ignored instructions\n"));
10545   fprintf (stream, _("\
10546   -mevexrcig=[rne|rd|ru|rz]\n\
10547                           encode EVEX instructions with specific EVEX.RC value\n\
10548                            for SAE-only ignored instructions\n"));
10549   fprintf (stream, _("\
10550   -mmnemonic=[att|intel]  use AT&T/Intel mnemonic\n"));
10551   fprintf (stream, _("\
10552   -msyntax=[att|intel]    use AT&T/Intel syntax\n"));
10553   fprintf (stream, _("\
10554   -mindex-reg             support pseudo index registers\n"));
10555   fprintf (stream, _("\
10556   -mnaked-reg             don't require `%%' prefix for registers\n"));
10557   fprintf (stream, _("\
10558   -mold-gcc               support old (<= 2.8.1) versions of gcc\n"));
10559   fprintf (stream, _("\
10560   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
10561   fprintf (stream, _("\
10562   -mshared                disable branch optimization for shared code\n"));
10563 # if defined (TE_PE) || defined (TE_PEP)
10564   fprintf (stream, _("\
10565   -mbig-obj               generate big object files\n"));
10566 #endif
10567   fprintf (stream, _("\
10568   -momit-lock-prefix=[no|yes]\n\
10569                           strip all lock prefixes\n"));
10570   fprintf (stream, _("\
10571   -mfence-as-lock-add=[no|yes]\n\
10572                           encode lfence, mfence and sfence as\n\
10573                            lock addl $0x0, (%%{re}sp)\n"));
10574   fprintf (stream, _("\
10575   -mrelax-relocations=[no|yes]\n\
10576                           generate relax relocations\n"));
10577   fprintf (stream, _("\
10578   -mamd64                 accept only AMD64 ISA\n"));
10579   fprintf (stream, _("\
10580   -mintel64               accept only Intel64 ISA\n"));
10581 }
10582
10583 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
10584      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
10585      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
10586
10587 /* Pick the target format to use.  */
10588
10589 const char *
10590 i386_target_format (void)
10591 {
10592   if (!strncmp (default_arch, "x86_64", 6))
10593     {
10594       update_code_flag (CODE_64BIT, 1);
10595       if (default_arch[6] == '\0')
10596         x86_elf_abi = X86_64_ABI;
10597       else
10598         x86_elf_abi = X86_64_X32_ABI;
10599     }
10600   else if (!strcmp (default_arch, "i386"))
10601     update_code_flag (CODE_32BIT, 1);
10602   else if (!strcmp (default_arch, "iamcu"))
10603     {
10604       update_code_flag (CODE_32BIT, 1);
10605       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
10606         {
10607           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
10608           cpu_arch_name = "iamcu";
10609           cpu_sub_arch_name = NULL;
10610           cpu_arch_flags = iamcu_flags;
10611           cpu_arch_isa = PROCESSOR_IAMCU;
10612           cpu_arch_isa_flags = iamcu_flags;
10613           if (!cpu_arch_tune_set)
10614             {
10615               cpu_arch_tune = cpu_arch_isa;
10616               cpu_arch_tune_flags = cpu_arch_isa_flags;
10617             }
10618         }
10619       else if (cpu_arch_isa != PROCESSOR_IAMCU)
10620         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
10621                   cpu_arch_name);
10622     }
10623   else
10624     as_fatal (_("unknown architecture"));
10625
10626   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
10627     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
10628   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
10629     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
10630
10631   switch (OUTPUT_FLAVOR)
10632     {
10633 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
10634     case bfd_target_aout_flavour:
10635       return AOUT_TARGET_FORMAT;
10636 #endif
10637 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
10638 # if defined (TE_PE) || defined (TE_PEP)
10639     case bfd_target_coff_flavour:
10640       if (flag_code == CODE_64BIT)
10641         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
10642       else
10643         return "pe-i386";
10644 # elif defined (TE_GO32)
10645     case bfd_target_coff_flavour:
10646       return "coff-go32";
10647 # else
10648     case bfd_target_coff_flavour:
10649       return "coff-i386";
10650 # endif
10651 #endif
10652 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
10653     case bfd_target_elf_flavour:
10654       {
10655         const char *format;
10656
10657         switch (x86_elf_abi)
10658           {
10659           default:
10660             format = ELF_TARGET_FORMAT;
10661             break;
10662           case X86_64_ABI:
10663             use_rela_relocations = 1;
10664             object_64bit = 1;
10665             format = ELF_TARGET_FORMAT64;
10666             break;
10667           case X86_64_X32_ABI:
10668             use_rela_relocations = 1;
10669             object_64bit = 1;
10670             disallow_64bit_reloc = 1;
10671             format = ELF_TARGET_FORMAT32;
10672             break;
10673           }
10674         if (cpu_arch_isa == PROCESSOR_L1OM)
10675           {
10676             if (x86_elf_abi != X86_64_ABI)
10677               as_fatal (_("Intel L1OM is 64bit only"));
10678             return ELF_TARGET_L1OM_FORMAT;
10679           }
10680         else if (cpu_arch_isa == PROCESSOR_K1OM)
10681           {
10682             if (x86_elf_abi != X86_64_ABI)
10683               as_fatal (_("Intel K1OM is 64bit only"));
10684             return ELF_TARGET_K1OM_FORMAT;
10685           }
10686         else if (cpu_arch_isa == PROCESSOR_IAMCU)
10687           {
10688             if (x86_elf_abi != I386_ABI)
10689               as_fatal (_("Intel MCU is 32bit only"));
10690             return ELF_TARGET_IAMCU_FORMAT;
10691           }
10692         else
10693           return format;
10694       }
10695 #endif
10696 #if defined (OBJ_MACH_O)
10697     case bfd_target_mach_o_flavour:
10698       if (flag_code == CODE_64BIT)
10699         {
10700           use_rela_relocations = 1;
10701           object_64bit = 1;
10702           return "mach-o-x86-64";
10703         }
10704       else
10705         return "mach-o-i386";
10706 #endif
10707     default:
10708       abort ();
10709       return NULL;
10710     }
10711 }
10712
10713 #endif /* OBJ_MAYBE_ more than one  */
10714 \f
10715 symbolS *
10716 md_undefined_symbol (char *name)
10717 {
10718   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
10719       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
10720       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
10721       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
10722     {
10723       if (!GOT_symbol)
10724         {
10725           if (symbol_find (name))
10726             as_bad (_("GOT already in symbol table"));
10727           GOT_symbol = symbol_new (name, undefined_section,
10728                                    (valueT) 0, &zero_address_frag);
10729         };
10730       return GOT_symbol;
10731     }
10732   return 0;
10733 }
10734
10735 /* Round up a section size to the appropriate boundary.  */
10736
10737 valueT
10738 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
10739 {
10740 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10741   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
10742     {
10743       /* For a.out, force the section size to be aligned.  If we don't do
10744          this, BFD will align it for us, but it will not write out the
10745          final bytes of the section.  This may be a bug in BFD, but it is
10746          easier to fix it here since that is how the other a.out targets
10747          work.  */
10748       int align;
10749
10750       align = bfd_get_section_alignment (stdoutput, segment);
10751       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
10752     }
10753 #endif
10754
10755   return size;
10756 }
10757
10758 /* On the i386, PC-relative offsets are relative to the start of the
10759    next instruction.  That is, the address of the offset, plus its
10760    size, since the offset is always the last part of the insn.  */
10761
10762 long
10763 md_pcrel_from (fixS *fixP)
10764 {
10765   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
10766 }
10767
10768 #ifndef I386COFF
10769
10770 static void
10771 s_bss (int ignore ATTRIBUTE_UNUSED)
10772 {
10773   int temp;
10774
10775 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10776   if (IS_ELF)
10777     obj_elf_section_change_hook ();
10778 #endif
10779   temp = get_absolute_expression ();
10780   subseg_set (bss_section, (subsegT) temp);
10781   demand_empty_rest_of_line ();
10782 }
10783
10784 #endif
10785
10786 void
10787 i386_validate_fix (fixS *fixp)
10788 {
10789   if (fixp->fx_subsy)
10790     {
10791       if (fixp->fx_subsy == GOT_symbol)
10792         {
10793           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
10794             {
10795               if (!object_64bit)
10796                 abort ();
10797 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10798               if (fixp->fx_tcbit2)
10799                 fixp->fx_r_type = (fixp->fx_tcbit
10800                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
10801                                    : BFD_RELOC_X86_64_GOTPCRELX);
10802               else
10803 #endif
10804                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
10805             }
10806           else
10807             {
10808               if (!object_64bit)
10809                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
10810               else
10811                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
10812             }
10813           fixp->fx_subsy = 0;
10814         }
10815     }
10816 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10817   else if (!object_64bit)
10818     {
10819       if (fixp->fx_r_type == BFD_RELOC_386_GOT32
10820           && fixp->fx_tcbit2)
10821         fixp->fx_r_type = BFD_RELOC_386_GOT32X;
10822     }
10823 #endif
10824 }
10825
10826 arelent *
10827 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
10828 {
10829   arelent *rel;
10830   bfd_reloc_code_real_type code;
10831
10832   switch (fixp->fx_r_type)
10833     {
10834 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10835     case BFD_RELOC_SIZE32:
10836     case BFD_RELOC_SIZE64:
10837       if (S_IS_DEFINED (fixp->fx_addsy)
10838           && !S_IS_EXTERNAL (fixp->fx_addsy))
10839         {
10840           /* Resolve size relocation against local symbol to size of
10841              the symbol plus addend.  */
10842           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
10843           if (fixp->fx_r_type == BFD_RELOC_SIZE32
10844               && !fits_in_unsigned_long (value))
10845             as_bad_where (fixp->fx_file, fixp->fx_line,
10846                           _("symbol size computation overflow"));
10847           fixp->fx_addsy = NULL;
10848           fixp->fx_subsy = NULL;
10849           md_apply_fix (fixp, (valueT *) &value, NULL);
10850           return NULL;
10851         }
10852 #endif
10853       /* Fall through.  */
10854
10855     case BFD_RELOC_X86_64_PLT32:
10856     case BFD_RELOC_X86_64_GOT32:
10857     case BFD_RELOC_X86_64_GOTPCREL:
10858     case BFD_RELOC_X86_64_GOTPCRELX:
10859     case BFD_RELOC_X86_64_REX_GOTPCRELX:
10860     case BFD_RELOC_386_PLT32:
10861     case BFD_RELOC_386_GOT32:
10862     case BFD_RELOC_386_GOT32X:
10863     case BFD_RELOC_386_GOTOFF:
10864     case BFD_RELOC_386_GOTPC:
10865     case BFD_RELOC_386_TLS_GD:
10866     case BFD_RELOC_386_TLS_LDM:
10867     case BFD_RELOC_386_TLS_LDO_32:
10868     case BFD_RELOC_386_TLS_IE_32:
10869     case BFD_RELOC_386_TLS_IE:
10870     case BFD_RELOC_386_TLS_GOTIE:
10871     case BFD_RELOC_386_TLS_LE_32:
10872     case BFD_RELOC_386_TLS_LE:
10873     case BFD_RELOC_386_TLS_GOTDESC:
10874     case BFD_RELOC_386_TLS_DESC_CALL:
10875     case BFD_RELOC_X86_64_TLSGD:
10876     case BFD_RELOC_X86_64_TLSLD:
10877     case BFD_RELOC_X86_64_DTPOFF32:
10878     case BFD_RELOC_X86_64_DTPOFF64:
10879     case BFD_RELOC_X86_64_GOTTPOFF:
10880     case BFD_RELOC_X86_64_TPOFF32:
10881     case BFD_RELOC_X86_64_TPOFF64:
10882     case BFD_RELOC_X86_64_GOTOFF64:
10883     case BFD_RELOC_X86_64_GOTPC32:
10884     case BFD_RELOC_X86_64_GOT64:
10885     case BFD_RELOC_X86_64_GOTPCREL64:
10886     case BFD_RELOC_X86_64_GOTPC64:
10887     case BFD_RELOC_X86_64_GOTPLT64:
10888     case BFD_RELOC_X86_64_PLTOFF64:
10889     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
10890     case BFD_RELOC_X86_64_TLSDESC_CALL:
10891     case BFD_RELOC_RVA:
10892     case BFD_RELOC_VTABLE_ENTRY:
10893     case BFD_RELOC_VTABLE_INHERIT:
10894 #ifdef TE_PE
10895     case BFD_RELOC_32_SECREL:
10896 #endif
10897       code = fixp->fx_r_type;
10898       break;
10899     case BFD_RELOC_X86_64_32S:
10900       if (!fixp->fx_pcrel)
10901         {
10902           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
10903           code = fixp->fx_r_type;
10904           break;
10905         }
10906       /* Fall through.  */
10907     default:
10908       if (fixp->fx_pcrel)
10909         {
10910           switch (fixp->fx_size)
10911             {
10912             default:
10913               as_bad_where (fixp->fx_file, fixp->fx_line,
10914                             _("can not do %d byte pc-relative relocation"),
10915                             fixp->fx_size);
10916               code = BFD_RELOC_32_PCREL;
10917               break;
10918             case 1: code = BFD_RELOC_8_PCREL;  break;
10919             case 2: code = BFD_RELOC_16_PCREL; break;
10920             case 4: code = BFD_RELOC_32_PCREL; break;
10921 #ifdef BFD64
10922             case 8: code = BFD_RELOC_64_PCREL; break;
10923 #endif
10924             }
10925         }
10926       else
10927         {
10928           switch (fixp->fx_size)
10929             {
10930             default:
10931               as_bad_where (fixp->fx_file, fixp->fx_line,
10932                             _("can not do %d byte relocation"),
10933                             fixp->fx_size);
10934               code = BFD_RELOC_32;
10935               break;
10936             case 1: code = BFD_RELOC_8;  break;
10937             case 2: code = BFD_RELOC_16; break;
10938             case 4: code = BFD_RELOC_32; break;
10939 #ifdef BFD64
10940             case 8: code = BFD_RELOC_64; break;
10941 #endif
10942             }
10943         }
10944       break;
10945     }
10946
10947   if ((code == BFD_RELOC_32
10948        || code == BFD_RELOC_32_PCREL
10949        || code == BFD_RELOC_X86_64_32S)
10950       && GOT_symbol
10951       && fixp->fx_addsy == GOT_symbol)
10952     {
10953       if (!object_64bit)
10954         code = BFD_RELOC_386_GOTPC;
10955       else
10956         code = BFD_RELOC_X86_64_GOTPC32;
10957     }
10958   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
10959       && GOT_symbol
10960       && fixp->fx_addsy == GOT_symbol)
10961     {
10962       code = BFD_RELOC_X86_64_GOTPC64;
10963     }
10964
10965   rel = XNEW (arelent);
10966   rel->sym_ptr_ptr = XNEW (asymbol *);
10967   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
10968
10969   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
10970
10971   if (!use_rela_relocations)
10972     {
10973       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
10974          vtable entry to be used in the relocation's section offset.  */
10975       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
10976         rel->address = fixp->fx_offset;
10977 #if defined (OBJ_COFF) && defined (TE_PE)
10978       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
10979         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
10980       else
10981 #endif
10982       rel->addend = 0;
10983     }
10984   /* Use the rela in 64bit mode.  */
10985   else
10986     {
10987       if (disallow_64bit_reloc)
10988         switch (code)
10989           {
10990           case BFD_RELOC_X86_64_DTPOFF64:
10991           case BFD_RELOC_X86_64_TPOFF64:
10992           case BFD_RELOC_64_PCREL:
10993           case BFD_RELOC_X86_64_GOTOFF64:
10994           case BFD_RELOC_X86_64_GOT64:
10995           case BFD_RELOC_X86_64_GOTPCREL64:
10996           case BFD_RELOC_X86_64_GOTPC64:
10997           case BFD_RELOC_X86_64_GOTPLT64:
10998           case BFD_RELOC_X86_64_PLTOFF64:
10999             as_bad_where (fixp->fx_file, fixp->fx_line,
11000                           _("cannot represent relocation type %s in x32 mode"),
11001                           bfd_get_reloc_code_name (code));
11002             break;
11003           default:
11004             break;
11005           }
11006
11007       if (!fixp->fx_pcrel)
11008         rel->addend = fixp->fx_offset;
11009       else
11010         switch (code)
11011           {
11012           case BFD_RELOC_X86_64_PLT32:
11013           case BFD_RELOC_X86_64_GOT32:
11014           case BFD_RELOC_X86_64_GOTPCREL:
11015           case BFD_RELOC_X86_64_GOTPCRELX:
11016           case BFD_RELOC_X86_64_REX_GOTPCRELX:
11017           case BFD_RELOC_X86_64_TLSGD:
11018           case BFD_RELOC_X86_64_TLSLD:
11019           case BFD_RELOC_X86_64_GOTTPOFF:
11020           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
11021           case BFD_RELOC_X86_64_TLSDESC_CALL:
11022             rel->addend = fixp->fx_offset - fixp->fx_size;
11023             break;
11024           default:
11025             rel->addend = (section->vma
11026                            - fixp->fx_size
11027                            + fixp->fx_addnumber
11028                            + md_pcrel_from (fixp));
11029             break;
11030           }
11031     }
11032
11033   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
11034   if (rel->howto == NULL)
11035     {
11036       as_bad_where (fixp->fx_file, fixp->fx_line,
11037                     _("cannot represent relocation type %s"),
11038                     bfd_get_reloc_code_name (code));
11039       /* Set howto to a garbage value so that we can keep going.  */
11040       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
11041       gas_assert (rel->howto != NULL);
11042     }
11043
11044   return rel;
11045 }
11046
11047 #include "tc-i386-intel.c"
11048
11049 void
11050 tc_x86_parse_to_dw2regnum (expressionS *exp)
11051 {
11052   int saved_naked_reg;
11053   char saved_register_dot;
11054
11055   saved_naked_reg = allow_naked_reg;
11056   allow_naked_reg = 1;
11057   saved_register_dot = register_chars['.'];
11058   register_chars['.'] = '.';
11059   allow_pseudo_reg = 1;
11060   expression_and_evaluate (exp);
11061   allow_pseudo_reg = 0;
11062   register_chars['.'] = saved_register_dot;
11063   allow_naked_reg = saved_naked_reg;
11064
11065   if (exp->X_op == O_register && exp->X_add_number >= 0)
11066     {
11067       if ((addressT) exp->X_add_number < i386_regtab_size)
11068         {
11069           exp->X_op = O_constant;
11070           exp->X_add_number = i386_regtab[exp->X_add_number]
11071                               .dw2_regnum[flag_code >> 1];
11072         }
11073       else
11074         exp->X_op = O_illegal;
11075     }
11076 }
11077
11078 void
11079 tc_x86_frame_initial_instructions (void)
11080 {
11081   static unsigned int sp_regno[2];
11082
11083   if (!sp_regno[flag_code >> 1])
11084     {
11085       char *saved_input = input_line_pointer;
11086       char sp[][4] = {"esp", "rsp"};
11087       expressionS exp;
11088
11089       input_line_pointer = sp[flag_code >> 1];
11090       tc_x86_parse_to_dw2regnum (&exp);
11091       gas_assert (exp.X_op == O_constant);
11092       sp_regno[flag_code >> 1] = exp.X_add_number;
11093       input_line_pointer = saved_input;
11094     }
11095
11096   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
11097   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
11098 }
11099
11100 int
11101 x86_dwarf2_addr_size (void)
11102 {
11103 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
11104   if (x86_elf_abi == X86_64_X32_ABI)
11105     return 4;
11106 #endif
11107   return bfd_arch_bits_per_address (stdoutput) / 8;
11108 }
11109
11110 int
11111 i386_elf_section_type (const char *str, size_t len)
11112 {
11113   if (flag_code == CODE_64BIT
11114       && len == sizeof ("unwind") - 1
11115       && strncmp (str, "unwind", 6) == 0)
11116     return SHT_X86_64_UNWIND;
11117
11118   return -1;
11119 }
11120
11121 #ifdef TE_SOLARIS
11122 void
11123 i386_solaris_fix_up_eh_frame (segT sec)
11124 {
11125   if (flag_code == CODE_64BIT)
11126     elf_section_type (sec) = SHT_X86_64_UNWIND;
11127 }
11128 #endif
11129
11130 #ifdef TE_PE
11131 void
11132 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
11133 {
11134   expressionS exp;
11135
11136   exp.X_op = O_secrel;
11137   exp.X_add_symbol = symbol;
11138   exp.X_add_number = 0;
11139   emit_expr (&exp, size);
11140 }
11141 #endif
11142
11143 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11144 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
11145
11146 bfd_vma
11147 x86_64_section_letter (int letter, const char **ptr_msg)
11148 {
11149   if (flag_code == CODE_64BIT)
11150     {
11151       if (letter == 'l')
11152         return SHF_X86_64_LARGE;
11153
11154       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
11155     }
11156   else
11157     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
11158   return -1;
11159 }
11160
11161 bfd_vma
11162 x86_64_section_word (char *str, size_t len)
11163 {
11164   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
11165     return SHF_X86_64_LARGE;
11166
11167   return -1;
11168 }
11169
11170 static void
11171 handle_large_common (int small ATTRIBUTE_UNUSED)
11172 {
11173   if (flag_code != CODE_64BIT)
11174     {
11175       s_comm_internal (0, elf_common_parse);
11176       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
11177     }
11178   else
11179     {
11180       static segT lbss_section;
11181       asection *saved_com_section_ptr = elf_com_section_ptr;
11182       asection *saved_bss_section = bss_section;
11183
11184       if (lbss_section == NULL)
11185         {
11186           flagword applicable;
11187           segT seg = now_seg;
11188           subsegT subseg = now_subseg;
11189
11190           /* The .lbss section is for local .largecomm symbols.  */
11191           lbss_section = subseg_new (".lbss", 0);
11192           applicable = bfd_applicable_section_flags (stdoutput);
11193           bfd_set_section_flags (stdoutput, lbss_section,
11194                                  applicable & SEC_ALLOC);
11195           seg_info (lbss_section)->bss = 1;
11196
11197           subseg_set (seg, subseg);
11198         }
11199
11200       elf_com_section_ptr = &_bfd_elf_large_com_section;
11201       bss_section = lbss_section;
11202
11203       s_comm_internal (0, elf_common_parse);
11204
11205       elf_com_section_ptr = saved_com_section_ptr;
11206       bss_section = saved_bss_section;
11207     }
11208 }
11209 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */