gas/config/tc-i386.c

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