gas/config/tc-i386.c

   1 /* tc-i386.c -- Assemble code for the Intel 80386
   2    Copyright (C) 1989-2020 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 ([email protected]).
  23    x86_64 support by Jan Hubicka ([email protected])
  24    VIA PadLock support by Michal Ludvig ([email protected])
  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 INFER_ADDR_PREFIX
  48 #define INFER_ADDR_PREFIX 1
  49 #endif
  50
  51 #ifndef DEFAULT_ARCH
  52 #define DEFAULT_ARCH "i386"
  53 #endif
  54
  55 #ifndef INLINE
  56 #if __GNUC__ >= 2
  57 #define INLINE __inline__
  58 #else
  59 #define INLINE
  60 #endif
  61 #endif
  62
  63 /* Prefixes will be emitted in the order defined below.
  64    WAIT_PREFIX must be the first prefix since FWAIT is really is an
  65    instruction, and so must come before any prefixes.
  66    The preferred prefix order is SEG_PREFIX, ADDR_PREFIX, DATA_PREFIX,
  67    REP_PREFIX/HLE_PREFIX, LOCK_PREFIX.  */
  68 #define WAIT_PREFIX     0
  69 #define SEG_PREFIX      1
  70 #define ADDR_PREFIX     2
  71 #define DATA_PREFIX     3
  72 #define REP_PREFIX      4
  73 #define HLE_PREFIX      REP_PREFIX
  74 #define BND_PREFIX      REP_PREFIX
  75 #define LOCK_PREFIX     5
  76 #define REX_PREFIX      6       /* must come last.  */
  77 #define MAX_PREFIXES    7       /* max prefixes per opcode */
  78
  79 /* we define the syntax here (modulo base,index,scale syntax) */
  80 #define REGISTER_PREFIX '%'
  81 #define IMMEDIATE_PREFIX '$'
  82 #define ABSOLUTE_PREFIX '*'
  83
  84 /* these are the instruction mnemonic suffixes in AT&T syntax or
  85    memory operand size in Intel syntax.  */
  86 #define WORD_MNEM_SUFFIX  'w'
  87 #define BYTE_MNEM_SUFFIX  'b'
  88 #define SHORT_MNEM_SUFFIX 's'
  89 #define LONG_MNEM_SUFFIX  'l'
  90 #define QWORD_MNEM_SUFFIX  'q'
  91 /* Intel Syntax.  Use a non-ascii letter since since it never appears
  92    in instructions.  */
  93 #define LONG_DOUBLE_MNEM_SUFFIX '\1'
  94
  95 #define END_OF_INSN '\0'
  96
  97 /* This matches the C -> StaticRounding alias in the opcode table.  */
  98 #define commutative staticrounding
  99
 100 /*
 101   'templates' is for grouping together 'template' structures for opcodes
 102   of the same name.  This is only used for storing the insns in the grand
 103   ole hash table of insns.
 104   The templates themselves start at START and range up to (but not including)
 105   END.
 106   */
 107 typedef struct
 108 {
 109   const insn_template *start;
 110   const insn_template *end;
 111 }
 112 templates;
 113
 114 /* 386 operand encoding bytes:  see 386 book for details of this.  */
 115 typedef struct
 116 {
 117   unsigned int regmem;  /* codes register or memory operand */
 118   unsigned int reg;     /* codes register operand (or extended opcode) */
 119   unsigned int mode;    /* how to interpret regmem & reg */
 120 }
 121 modrm_byte;
 122
 123 /* x86-64 extension prefix.  */
 124 typedef int rex_byte;
 125
 126 /* 386 opcode byte to code indirect addressing.  */
 127 typedef struct
 128 {
 129   unsigned base;
 130   unsigned index;
 131   unsigned scale;
 132 }
 133 sib_byte;
 134
 135 /* x86 arch names, types and features */
 136 typedef struct
 137 {
 138   const char *name;             /* arch name */
 139   unsigned int len;             /* arch string length */
 140   enum processor_type type;     /* arch type */
 141   i386_cpu_flags flags;         /* cpu feature flags */
 142   unsigned int skip;            /* show_arch should skip this. */
 143 }
 144 arch_entry;
 145
 146 /* Used to turn off indicated flags.  */
 147 typedef struct
 148 {
 149   const char *name;             /* arch name */
 150   unsigned int len;             /* arch string length */
 151   i386_cpu_flags flags;         /* cpu feature flags */
 152 }
 153 noarch_entry;
 154
 155 static void update_code_flag (int, int);
 156 static void set_code_flag (int);
 157 static void set_16bit_gcc_code_flag (int);
 158 static void set_intel_syntax (int);
 159 static void set_intel_mnemonic (int);
 160 static void set_allow_index_reg (int);
 161 static void set_check (int);
 162 static void set_cpu_arch (int);
 163 #ifdef TE_PE
 164 static void pe_directive_secrel (int);
 165 #endif
 166 static void signed_cons (int);
 167 static char *output_invalid (int c);
 168 static int i386_finalize_immediate (segT, expressionS *, i386_operand_type,
 169                                     const char *);
 170 static int i386_finalize_displacement (segT, expressionS *, i386_operand_type,
 171                                        const char *);
 172 static int i386_att_operand (char *);
 173 static int i386_intel_operand (char *, int);
 174 static int i386_intel_simplify (expressionS *);
 175 static int i386_intel_parse_name (const char *, expressionS *);
 176 static const reg_entry *parse_register (char *, char **);
 177 static char *parse_insn (char *, char *);
 178 static char *parse_operands (char *, const char *);
 179 static void swap_operands (void);
 180 static void swap_2_operands (int, int);
 181 static enum flag_code i386_addressing_mode (void);
 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 /* parse_register() returns this when a register alias cannot be used.  */
 214 static const reg_entry bad_reg = { "<bad>", OPERAND_TYPE_NONE, 0, 0,
 215                                    { Dw2Inval, Dw2Inval } };
 216
 217 /* This struct describes rounding control and SAE in the instruction.  */
 218 struct RC_Operation
 219 {
 220   enum rc_type
 221     {
 222       rne = 0,
 223       rd,
 224       ru,
 225       rz,
 226       saeonly
 227     } type;
 228   int operand;
 229 };
 230
 231 static struct RC_Operation rc_op;
 232
 233 /* The struct describes masking, applied to OPERAND in the instruction.
 234    MASK is a pointer to the corresponding mask register.  ZEROING tells
 235    whether merging or zeroing mask is used.  */
 236 struct Mask_Operation
 237 {
 238   const reg_entry *mask;
 239   unsigned int zeroing;
 240   /* The operand where this operation is associated.  */
 241   int operand;
 242 };
 243
 244 static struct Mask_Operation mask_op;
 245
 246 /* The struct describes broadcasting, applied to OPERAND.  FACTOR is
 247    broadcast factor.  */
 248 struct Broadcast_Operation
 249 {
 250   /* Type of broadcast: {1to2}, {1to4}, {1to8}, or {1to16}.  */
 251   int type;
 252
 253   /* Index of broadcasted operand.  */
 254   int operand;
 255
 256   /* Number of bytes to broadcast.  */
 257   int bytes;
 258 };
 259
 260 static struct Broadcast_Operation broadcast_op;
 261
 262 /* VEX prefix.  */
 263 typedef struct
 264 {
 265   /* VEX prefix is either 2 byte or 3 byte.  EVEX is 4 byte.  */
 266   unsigned char bytes[4];
 267   unsigned int length;
 268   /* Destination or source register specifier.  */
 269   const reg_entry *register_specifier;
 270 } vex_prefix;
 271
 272 /* 'md_assemble ()' gathers together information and puts it into a
 273    i386_insn.  */
 274
 275 union i386_op
 276   {
 277     expressionS *disps;
 278     expressionS *imms;
 279     const reg_entry *regs;
 280   };
 281
 282 enum i386_error
 283   {
 284     operand_size_mismatch,
 285     operand_type_mismatch,
 286     register_type_mismatch,
 287     number_of_operands_mismatch,
 288     invalid_instruction_suffix,
 289     bad_imm4,
 290     unsupported_with_intel_mnemonic,
 291     unsupported_syntax,
 292     unsupported,
 293     invalid_sib_address,
 294     invalid_vsib_address,
 295     invalid_vector_register_set,
 296     invalid_tmm_register_set,
 297     unsupported_vector_index_register,
 298     unsupported_broadcast,
 299     broadcast_needed,
 300     unsupported_masking,
 301     mask_not_on_destination,
 302     no_default_mask,
 303     unsupported_rc_sae,
 304     rc_sae_operand_not_last_imm,
 305     invalid_register_operand,
 306   };
 307
 308 struct _i386_insn
 309   {
 310     /* TM holds the template for the insn were currently assembling.  */
 311     insn_template tm;
 312
 313     /* SUFFIX holds the instruction size suffix for byte, word, dword
 314        or qword, if given.  */
 315     char suffix;
 316
 317     /* OPERANDS gives the number of given operands.  */
 318     unsigned int operands;
 319
 320     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
 321        of given register, displacement, memory operands and immediate
 322        operands.  */
 323     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
 324
 325     /* TYPES [i] is the type (see above #defines) which tells us how to
 326        use OP[i] for the corresponding operand.  */
 327     i386_operand_type types[MAX_OPERANDS];
 328
 329     /* Displacement expression, immediate expression, or register for each
 330        operand.  */
 331     union i386_op op[MAX_OPERANDS];
 332
 333     /* Flags for operands.  */
 334     unsigned int flags[MAX_OPERANDS];
 335 #define Operand_PCrel 1
 336 #define Operand_Mem   2
 337
 338     /* Relocation type for operand */
 339     enum bfd_reloc_code_real reloc[MAX_OPERANDS];
 340
 341     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
 342        the base index byte below.  */
 343     const reg_entry *base_reg;
 344     const reg_entry *index_reg;
 345     unsigned int log2_scale_factor;
 346
 347     /* SEG gives the seg_entries of this insn.  They are zero unless
 348        explicit segment overrides are given.  */
 349     const seg_entry *seg[2];
 350
 351     /* Copied first memory operand string, for re-checking.  */
 352     char *memop1_string;
 353
 354     /* PREFIX holds all the given prefix opcodes (usually null).
 355        PREFIXES is the number of prefix opcodes.  */
 356     unsigned int prefixes;
 357     unsigned char prefix[MAX_PREFIXES];
 358
 359     /* Register is in low 3 bits of opcode.  */
 360     bfd_boolean short_form;
 361
 362     /* The operand to a branch insn indicates an absolute branch.  */
 363     bfd_boolean jumpabsolute;
 364
 365     /* Extended states.  */
 366     enum
 367       {
 368         /* Use MMX state.  */
 369         xstate_mmx = 1 << 0,
 370         /* Use XMM state.  */
 371         xstate_xmm = 1 << 1,
 372         /* Use YMM state.  */
 373         xstate_ymm = 1 << 2 | xstate_xmm,
 374         /* Use ZMM state.  */
 375         xstate_zmm = 1 << 3 | xstate_ymm,
 376         /* Use TMM state.  */
 377         xstate_tmm = 1 << 4
 378       } xstate;
 379
 380     /* Has GOTPC or TLS relocation.  */
 381     bfd_boolean has_gotpc_tls_reloc;
 382
 383     /* RM and SIB are the modrm byte and the sib byte where the
 384        addressing modes of this insn are encoded.  */
 385     modrm_byte rm;
 386     rex_byte rex;
 387     rex_byte vrex;
 388     sib_byte sib;
 389     vex_prefix vex;
 390
 391     /* Masking attributes.  */
 392     struct Mask_Operation *mask;
 393
 394     /* Rounding control and SAE attributes.  */
 395     struct RC_Operation *rounding;
 396
 397     /* Broadcasting attributes.  */
 398     struct Broadcast_Operation *broadcast;
 399
 400     /* Compressed disp8*N attribute.  */
 401     unsigned int memshift;
 402
 403     /* Prefer load or store in encoding.  */
 404     enum
 405       {
 406         dir_encoding_default = 0,
 407         dir_encoding_load,
 408         dir_encoding_store,
 409         dir_encoding_swap
 410       } dir_encoding;
 411
 412     /* Prefer 8bit, 16bit, 32bit displacement in encoding.  */
 413     enum
 414       {
 415         disp_encoding_default = 0,
 416         disp_encoding_8bit,
 417         disp_encoding_16bit,
 418         disp_encoding_32bit
 419       } disp_encoding;
 420
 421     /* Prefer the REX byte in encoding.  */
 422     bfd_boolean rex_encoding;
 423
 424     /* Disable instruction size optimization.  */
 425     bfd_boolean no_optimize;
 426
 427     /* How to encode vector instructions.  */
 428     enum
 429       {
 430         vex_encoding_default = 0,
 431         vex_encoding_vex,
 432         vex_encoding_vex3,
 433         vex_encoding_evex,
 434         vex_encoding_error
 435       } vec_encoding;
 436
 437     /* REP prefix.  */
 438     const char *rep_prefix;
 439
 440     /* HLE prefix.  */
 441     const char *hle_prefix;
 442
 443     /* Have BND prefix.  */
 444     const char *bnd_prefix;
 445
 446     /* Have NOTRACK prefix.  */
 447     const char *notrack_prefix;
 448
 449     /* Error message.  */
 450     enum i386_error error;
 451   };
 452
 453 typedef struct _i386_insn i386_insn;
 454
 455 /* Link RC type with corresponding string, that'll be looked for in
 456    asm.  */
 457 struct RC_name
 458 {
 459   enum rc_type type;
 460   const char *name;
 461   unsigned int len;
 462 };
 463
 464 static const struct RC_name RC_NamesTable[] =
 465 {
 466   {  rne, STRING_COMMA_LEN ("rn-sae") },
 467   {  rd,  STRING_COMMA_LEN ("rd-sae") },
 468   {  ru,  STRING_COMMA_LEN ("ru-sae") },
 469   {  rz,  STRING_COMMA_LEN ("rz-sae") },
 470   {  saeonly,  STRING_COMMA_LEN ("sae") },
 471 };
 472
 473 /* List of chars besides those in app.c:symbol_chars that can start an
 474    operand.  Used to prevent the scrubber eating vital white-space.  */
 475 const char extra_symbol_chars[] = "*%-([{}"
 476 #ifdef LEX_AT
 477         "@"
 478 #endif
 479 #ifdef LEX_QM
 480         "?"
 481 #endif
 482         ;
 483
 484 #if ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))     \
 485      && !defined (TE_GNU)                               \
 486      && !defined (TE_LINUX)                             \
 487      && !defined (TE_FreeBSD)                           \
 488      && !defined (TE_DragonFly)                         \
 489      && !defined (TE_NetBSD))
 490 /* This array holds the chars that always start a comment.  If the
 491    pre-processor is disabled, these aren't very useful.  The option
 492    --divide will remove '/' from this list.  */
 493 const char *i386_comment_chars = "#/";
 494 #define SVR4_COMMENT_CHARS 1
 495 #define PREFIX_SEPARATOR '\\'
 496
 497 #else
 498 const char *i386_comment_chars = "#";
 499 #define PREFIX_SEPARATOR '/'
 500 #endif
 501
 502 /* This array holds the chars that only start a comment at the beginning of
 503    a line.  If the line seems to have the form '# 123 filename'
 504    .line and .file directives will appear in the pre-processed output.
 505    Note that input_file.c hand checks for '#' at the beginning of the
 506    first line of the input file.  This is because the compiler outputs
 507    #NO_APP at the beginning of its output.
 508    Also note that comments started like this one will always work if
 509    '/' isn't otherwise defined.  */
 510 const char line_comment_chars[] = "#/";
 511
 512 const char line_separator_chars[] = ";";
 513
 514 /* Chars that can be used to separate mant from exp in floating point
 515    nums.  */
 516 const char EXP_CHARS[] = "eE";
 517
 518 /* Chars that mean this number is a floating point constant
 519    As in 0f12.456
 520    or    0d1.2345e12.  */
 521 const char FLT_CHARS[] = "fFdDxX";
 522
 523 /* Tables for lexical analysis.  */
 524 static char mnemonic_chars[256];
 525 static char register_chars[256];
 526 static char operand_chars[256];
 527 static char identifier_chars[256];
 528 static char digit_chars[256];
 529
 530 /* Lexical macros.  */
 531 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 532 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 533 #define is_register_char(x) (register_chars[(unsigned char) x])
 534 #define is_space_char(x) ((x) == ' ')
 535 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 536 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 537
 538 /* All non-digit non-letter characters that may occur in an operand.  */
 539 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 540
 541 /* md_assemble() always leaves the strings it's passed unaltered.  To
 542    effect this we maintain a stack of saved characters that we've smashed
 543    with '\0's (indicating end of strings for various sub-fields of the
 544    assembler instruction).  */
 545 static char save_stack[32];
 546 static char *save_stack_p;
 547 #define END_STRING_AND_SAVE(s) \
 548         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 549 #define RESTORE_END_STRING(s) \
 550         do { *(s) = *--save_stack_p; } while (0)
 551
 552 /* The instruction we're assembling.  */
 553 static i386_insn i;
 554
 555 /* Possible templates for current insn.  */
 556 static const templates *current_templates;
 557
 558 /* Per instruction expressionS buffers: max displacements & immediates.  */
 559 static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
 560 static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
 561
 562 /* Current operand we are working on.  */
 563 static int this_operand = -1;
 564
 565 /* We support four different modes.  FLAG_CODE variable is used to distinguish
 566    these.  */
 567
 568 enum flag_code {
 569         CODE_32BIT,
 570         CODE_16BIT,
 571         CODE_64BIT };
 572
 573 static enum flag_code flag_code;
 574 static unsigned int object_64bit;
 575 static unsigned int disallow_64bit_reloc;
 576 static int use_rela_relocations = 0;
 577 /* __tls_get_addr/___tls_get_addr symbol for TLS.  */
 578 static const char *tls_get_addr;
 579
 580 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
 581      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
 582      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
 583
 584 /* The ELF ABI to use.  */
 585 enum x86_elf_abi
 586 {
 587   I386_ABI,
 588   X86_64_ABI,
 589   X86_64_X32_ABI
 590 };
 591
 592 static enum x86_elf_abi x86_elf_abi = I386_ABI;
 593 #endif
 594
 595 #if defined (TE_PE) || defined (TE_PEP)
 596 /* Use big object file format.  */
 597 static int use_big_obj = 0;
 598 #endif
 599
 600 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 601 /* 1 if generating code for a shared library.  */
 602 static int shared = 0;
 603 #endif
 604
 605 /* 1 for intel syntax,
 606    0 if att syntax.  */
 607 static int intel_syntax = 0;
 608
 609 static enum x86_64_isa
 610 {
 611   amd64 = 1,    /* AMD64 ISA.  */
 612   intel64       /* Intel64 ISA.  */
 613 } isa64;
 614
 615 /* 1 for intel mnemonic,
 616    0 if att mnemonic.  */
 617 static int intel_mnemonic = !SYSV386_COMPAT;
 618
 619 /* 1 if pseudo registers are permitted.  */
 620 static int allow_pseudo_reg = 0;
 621
 622 /* 1 if register prefix % not required.  */
 623 static int allow_naked_reg = 0;
 624
 625 /* 1 if the assembler should add BND prefix for all control-transferring
 626    instructions supporting it, even if this prefix wasn't specified
 627    explicitly.  */
 628 static int add_bnd_prefix = 0;
 629
 630 /* 1 if pseudo index register, eiz/riz, is allowed .  */
 631 static int allow_index_reg = 0;
 632
 633 /* 1 if the assembler should ignore LOCK prefix, even if it was
 634    specified explicitly.  */
 635 static int omit_lock_prefix = 0;
 636
 637 /* 1 if the assembler should encode lfence, mfence, and sfence as
 638    "lock addl $0, (%{re}sp)".  */
 639 static int avoid_fence = 0;
 640
 641 /* 1 if lfence should be inserted after every load.  */
 642 static int lfence_after_load = 0;
 643
 644 /* Non-zero if lfence should be inserted before indirect branch.  */
 645 static enum lfence_before_indirect_branch_kind
 646   {
 647     lfence_branch_none = 0,
 648     lfence_branch_register,
 649     lfence_branch_memory,
 650     lfence_branch_all
 651   }
 652 lfence_before_indirect_branch;
 653
 654 /* Non-zero if lfence should be inserted before ret.  */
 655 static enum lfence_before_ret_kind
 656   {
 657     lfence_before_ret_none = 0,
 658     lfence_before_ret_not,
 659     lfence_before_ret_or,
 660     lfence_before_ret_shl
 661   }
 662 lfence_before_ret;
 663
 664 /* Types of previous instruction is .byte or prefix.  */
 665 static struct
 666   {
 667     segT seg;
 668     const char *file;
 669     const char *name;
 670     unsigned int line;
 671     enum last_insn_kind
 672       {
 673         last_insn_other = 0,
 674         last_insn_directive,
 675         last_insn_prefix
 676       } kind;
 677   } last_insn;
 678
 679 /* 1 if the assembler should generate relax relocations.  */
 680
 681 static int generate_relax_relocations
 682   = DEFAULT_GENERATE_X86_RELAX_RELOCATIONS;
 683
 684 static enum check_kind
 685   {
 686     check_none = 0,
 687     check_warning,
 688     check_error
 689   }
 690 sse_check, operand_check = check_warning;
 691
 692 /* Non-zero if branches should be aligned within power of 2 boundary.  */
 693 static int align_branch_power = 0;
 694
 695 /* Types of branches to align.  */
 696 enum align_branch_kind
 697   {
 698     align_branch_none = 0,
 699     align_branch_jcc = 1,
 700     align_branch_fused = 2,
 701     align_branch_jmp = 3,
 702     align_branch_call = 4,
 703     align_branch_indirect = 5,
 704     align_branch_ret = 6
 705   };
 706
 707 /* Type bits of branches to align.  */
 708 enum align_branch_bit
 709   {
 710     align_branch_jcc_bit = 1 << align_branch_jcc,
 711     align_branch_fused_bit = 1 << align_branch_fused,
 712     align_branch_jmp_bit = 1 << align_branch_jmp,
 713     align_branch_call_bit = 1 << align_branch_call,
 714     align_branch_indirect_bit = 1 << align_branch_indirect,
 715     align_branch_ret_bit = 1 << align_branch_ret
 716   };
 717
 718 static unsigned int align_branch = (align_branch_jcc_bit
 719                                     | align_branch_fused_bit
 720                                     | align_branch_jmp_bit);
 721
 722 /* Types of condition jump used by macro-fusion.  */
 723 enum mf_jcc_kind
 724   {
 725     mf_jcc_jo = 0,  /* base opcode 0x70  */
 726     mf_jcc_jc,      /* base opcode 0x72  */
 727     mf_jcc_je,      /* base opcode 0x74  */
 728     mf_jcc_jna,     /* base opcode 0x76  */
 729     mf_jcc_js,      /* base opcode 0x78  */
 730     mf_jcc_jp,      /* base opcode 0x7a  */
 731     mf_jcc_jl,      /* base opcode 0x7c  */
 732     mf_jcc_jle,     /* base opcode 0x7e  */
 733   };
 734
 735 /* Types of compare flag-modifying insntructions used by macro-fusion.  */
 736 enum mf_cmp_kind
 737   {
 738     mf_cmp_test_and,  /* test/cmp */
 739     mf_cmp_alu_cmp,  /* add/sub/cmp */
 740     mf_cmp_incdec  /* inc/dec */
 741   };
 742
 743 /* The maximum padding size for fused jcc.  CMP like instruction can
 744    be 9 bytes and jcc can be 6 bytes.  Leave room just in case for
 745    prefixes.   */
 746 #define MAX_FUSED_JCC_PADDING_SIZE 20
 747
 748 /* The maximum number of prefixes added for an instruction.  */
 749 static unsigned int align_branch_prefix_size = 5;
 750
 751 /* Optimization:
 752    1. Clear the REX_W bit with register operand if possible.
 753    2. Above plus use 128bit vector instruction to clear the full vector
 754       register.
 755  */
 756 static int optimize = 0;
 757
 758 /* Optimization:
 759    1. Clear the REX_W bit with register operand if possible.
 760    2. Above plus use 128bit vector instruction to clear the full vector
 761       register.
 762    3. Above plus optimize "test{q,l,w} $imm8,%r{64,32,16}" to
 763       "testb $imm7,%r8".
 764  */
 765 static int optimize_for_space = 0;
 766
 767 /* Register prefix used for error message.  */
 768 static const char *register_prefix = "%";
 769
 770 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
 771    leave, push, and pop instructions so that gcc has the same stack
 772    frame as in 32 bit mode.  */
 773 static char stackop_size = '\0';
 774
 775 /* Non-zero to optimize code alignment.  */
 776 int optimize_align_code = 1;
 777
 778 /* Non-zero to quieten some warnings.  */
 779 static int quiet_warnings = 0;
 780
 781 /* CPU name.  */
 782 static const char *cpu_arch_name = NULL;
 783 static char *cpu_sub_arch_name = NULL;
 784
 785 /* CPU feature flags.  */
 786 static i386_cpu_flags cpu_arch_flags = CPU_UNKNOWN_FLAGS;
 787
 788 /* If we have selected a cpu we are generating instructions for.  */
 789 static int cpu_arch_tune_set = 0;
 790
 791 /* Cpu we are generating instructions for.  */
 792 enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
 793
 794 /* CPU feature flags of cpu we are generating instructions for.  */
 795 static i386_cpu_flags cpu_arch_tune_flags;
 796
 797 /* CPU instruction set architecture used.  */
 798 enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
 799
 800 /* CPU feature flags of instruction set architecture used.  */
 801 i386_cpu_flags cpu_arch_isa_flags;
 802
 803 /* If set, conditional jumps are not automatically promoted to handle
 804    larger than a byte offset.  */
 805 static unsigned int no_cond_jump_promotion = 0;
 806
 807 /* Encode SSE instructions with VEX prefix.  */
 808 static unsigned int sse2avx;
 809
 810 /* Encode scalar AVX instructions with specific vector length.  */
 811 static enum
 812   {
 813     vex128 = 0,
 814     vex256
 815   } avxscalar;
 816
 817 /* Encode VEX WIG instructions with specific vex.w.  */
 818 static enum
 819   {
 820     vexw0 = 0,
 821     vexw1
 822   } vexwig;
 823
 824 /* Encode scalar EVEX LIG instructions with specific vector length.  */
 825 static enum
 826   {
 827     evexl128 = 0,
 828     evexl256,
 829     evexl512
 830   } evexlig;
 831
 832 /* Encode EVEX WIG instructions with specific evex.w.  */
 833 static enum
 834   {
 835     evexw0 = 0,
 836     evexw1
 837   } evexwig;
 838
 839 /* Value to encode in EVEX RC bits, for SAE-only instructions.  */
 840 static enum rc_type evexrcig = rne;
 841
 842 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 843 static symbolS *GOT_symbol;
 844
 845 /* The dwarf2 return column, adjusted for 32 or 64 bit.  */
 846 unsigned int x86_dwarf2_return_column;
 847
 848 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
 849 int x86_cie_data_alignment;
 850
 851 /* Interface to relax_segment.
 852    There are 3 major relax states for 386 jump insns because the
 853    different types of jumps add different sizes to frags when we're
 854    figuring out what sort of jump to choose to reach a given label.
 855
 856    BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING are used to align
 857    branches which are handled by md_estimate_size_before_relax() and
 858    i386_generic_table_relax_frag().  */
 859
 860 /* Types.  */
 861 #define UNCOND_JUMP 0
 862 #define COND_JUMP 1
 863 #define COND_JUMP86 2
 864 #define BRANCH_PADDING 3
 865 #define BRANCH_PREFIX 4
 866 #define FUSED_JCC_PADDING 5
 867
 868 /* Sizes.  */
 869 #define CODE16  1
 870 #define SMALL   0
 871 #define SMALL16 (SMALL | CODE16)
 872 #define BIG     2
 873 #define BIG16   (BIG | CODE16)
 874
 875 #ifndef INLINE
 876 #ifdef __GNUC__
 877 #define INLINE __inline__
 878 #else
 879 #define INLINE
 880 #endif
 881 #endif
 882
 883 #define ENCODE_RELAX_STATE(type, size) \
 884   ((relax_substateT) (((type) << 2) | (size)))
 885 #define TYPE_FROM_RELAX_STATE(s) \
 886   ((s) >> 2)
 887 #define DISP_SIZE_FROM_RELAX_STATE(s) \
 888     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
 889
 890 /* This table is used by relax_frag to promote short jumps to long
 891    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 892    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 893    don't allow a short jump in a 32 bit code segment to be promoted to
 894    a 16 bit offset jump because it's slower (requires data size
 895    prefix), and doesn't work, unless the destination is in the bottom
 896    64k of the code segment (The top 16 bits of eip are zeroed).  */
 897
 898 const relax_typeS md_relax_table[] =
 899 {
 900   /* The fields are:
 901      1) most positive reach of this state,
 902      2) most negative reach of this state,
 903      3) how many bytes this mode will have in the variable part of the frag
 904      4) which index into the table to try if we can't fit into this one.  */
 905
 906   /* UNCOND_JUMP states.  */
 907   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 908   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 909   /* dword jmp adds 4 bytes to frag:
 910      0 extra opcode bytes, 4 displacement bytes.  */
 911   {0, 0, 4, 0},
 912   /* word jmp adds 2 byte2 to frag:
 913      0 extra opcode bytes, 2 displacement bytes.  */
 914   {0, 0, 2, 0},
 915
 916   /* COND_JUMP states.  */
 917   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 918   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 919   /* dword conditionals adds 5 bytes to frag:
 920      1 extra opcode byte, 4 displacement bytes.  */
 921   {0, 0, 5, 0},
 922   /* word conditionals add 3 bytes to frag:
 923      1 extra opcode byte, 2 displacement bytes.  */
 924   {0, 0, 3, 0},
 925
 926   /* COND_JUMP86 states.  */
 927   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
 928   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
 929   /* dword conditionals adds 5 bytes to frag:
 930      1 extra opcode byte, 4 displacement bytes.  */
 931   {0, 0, 5, 0},
 932   /* word conditionals add 4 bytes to frag:
 933      1 displacement byte and a 3 byte long branch insn.  */
 934   {0, 0, 4, 0}
 935 };
 936
 937 static const arch_entry cpu_arch[] =
 938 {
 939   /* Do not replace the first two entries - i386_target_format()
 940      relies on them being there in this order.  */
 941   { STRING_COMMA_LEN ("generic32"), PROCESSOR_GENERIC32,
 942     CPU_GENERIC32_FLAGS, 0 },
 943   { STRING_COMMA_LEN ("generic64"), PROCESSOR_GENERIC64,
 944     CPU_GENERIC64_FLAGS, 0 },
 945   { STRING_COMMA_LEN ("i8086"), PROCESSOR_UNKNOWN,
 946     CPU_NONE_FLAGS, 0 },
 947   { STRING_COMMA_LEN ("i186"), PROCESSOR_UNKNOWN,
 948     CPU_I186_FLAGS, 0 },
 949   { STRING_COMMA_LEN ("i286"), PROCESSOR_UNKNOWN,
 950     CPU_I286_FLAGS, 0 },
 951   { STRING_COMMA_LEN ("i386"), PROCESSOR_I386,
 952     CPU_I386_FLAGS, 0 },
 953   { STRING_COMMA_LEN ("i486"), PROCESSOR_I486,
 954     CPU_I486_FLAGS, 0 },
 955   { STRING_COMMA_LEN ("i586"), PROCESSOR_PENTIUM,
 956     CPU_I586_FLAGS, 0 },
 957   { STRING_COMMA_LEN ("i686"), PROCESSOR_PENTIUMPRO,
 958     CPU_I686_FLAGS, 0 },
 959   { STRING_COMMA_LEN ("pentium"), PROCESSOR_PENTIUM,
 960     CPU_I586_FLAGS, 0 },
 961   { STRING_COMMA_LEN ("pentiumpro"), PROCESSOR_PENTIUMPRO,
 962     CPU_PENTIUMPRO_FLAGS, 0 },
 963   { STRING_COMMA_LEN ("pentiumii"), PROCESSOR_PENTIUMPRO,
 964     CPU_P2_FLAGS, 0 },
 965   { STRING_COMMA_LEN ("pentiumiii"),PROCESSOR_PENTIUMPRO,
 966     CPU_P3_FLAGS, 0 },
 967   { STRING_COMMA_LEN ("pentium4"), PROCESSOR_PENTIUM4,
 968     CPU_P4_FLAGS, 0 },
 969   { STRING_COMMA_LEN ("prescott"), PROCESSOR_NOCONA,
 970     CPU_CORE_FLAGS, 0 },
 971   { STRING_COMMA_LEN ("nocona"), PROCESSOR_NOCONA,
 972     CPU_NOCONA_FLAGS, 0 },
 973   { STRING_COMMA_LEN ("yonah"), PROCESSOR_CORE,
 974     CPU_CORE_FLAGS, 1 },
 975   { STRING_COMMA_LEN ("core"), PROCESSOR_CORE,
 976     CPU_CORE_FLAGS, 0 },
 977   { STRING_COMMA_LEN ("merom"), PROCESSOR_CORE2,
 978     CPU_CORE2_FLAGS, 1 },
 979   { STRING_COMMA_LEN ("core2"), PROCESSOR_CORE2,
 980     CPU_CORE2_FLAGS, 0 },
 981   { STRING_COMMA_LEN ("corei7"), PROCESSOR_COREI7,
 982     CPU_COREI7_FLAGS, 0 },
 983   { STRING_COMMA_LEN ("l1om"), PROCESSOR_L1OM,
 984     CPU_L1OM_FLAGS, 0 },
 985   { STRING_COMMA_LEN ("k1om"), PROCESSOR_K1OM,
 986     CPU_K1OM_FLAGS, 0 },
 987   { STRING_COMMA_LEN ("iamcu"), PROCESSOR_IAMCU,
 988     CPU_IAMCU_FLAGS, 0 },
 989   { STRING_COMMA_LEN ("k6"), PROCESSOR_K6,
 990     CPU_K6_FLAGS, 0 },
 991   { STRING_COMMA_LEN ("k6_2"), PROCESSOR_K6,
 992     CPU_K6_2_FLAGS, 0 },
 993   { STRING_COMMA_LEN ("athlon"), PROCESSOR_ATHLON,
 994     CPU_ATHLON_FLAGS, 0 },
 995   { STRING_COMMA_LEN ("sledgehammer"), PROCESSOR_K8,
 996     CPU_K8_FLAGS, 1 },
 997   { STRING_COMMA_LEN ("opteron"), PROCESSOR_K8,
 998     CPU_K8_FLAGS, 0 },
 999   { STRING_COMMA_LEN ("k8"), PROCESSOR_K8,
1000     CPU_K8_FLAGS, 0 },
1001   { STRING_COMMA_LEN ("amdfam10"), PROCESSOR_AMDFAM10,
1002     CPU_AMDFAM10_FLAGS, 0 },
1003   { STRING_COMMA_LEN ("bdver1"), PROCESSOR_BD,
1004     CPU_BDVER1_FLAGS, 0 },
1005   { STRING_COMMA_LEN ("bdver2"), PROCESSOR_BD,
1006     CPU_BDVER2_FLAGS, 0 },
1007   { STRING_COMMA_LEN ("bdver3"), PROCESSOR_BD,
1008     CPU_BDVER3_FLAGS, 0 },
1009   { STRING_COMMA_LEN ("bdver4"), PROCESSOR_BD,
1010     CPU_BDVER4_FLAGS, 0 },
1011   { STRING_COMMA_LEN ("znver1"), PROCESSOR_ZNVER,
1012     CPU_ZNVER1_FLAGS, 0 },
1013   { STRING_COMMA_LEN ("znver2"), PROCESSOR_ZNVER,
1014     CPU_ZNVER2_FLAGS, 0 },
1015   { STRING_COMMA_LEN ("btver1"), PROCESSOR_BT,
1016     CPU_BTVER1_FLAGS, 0 },
1017   { STRING_COMMA_LEN ("btver2"), PROCESSOR_BT,
1018     CPU_BTVER2_FLAGS, 0 },
1019   { STRING_COMMA_LEN (".8087"), PROCESSOR_UNKNOWN,
1020     CPU_8087_FLAGS, 0 },
1021   { STRING_COMMA_LEN (".287"), PROCESSOR_UNKNOWN,
1022     CPU_287_FLAGS, 0 },
1023   { STRING_COMMA_LEN (".387"), PROCESSOR_UNKNOWN,
1024     CPU_387_FLAGS, 0 },
1025   { STRING_COMMA_LEN (".687"), PROCESSOR_UNKNOWN,
1026     CPU_687_FLAGS, 0 },
1027   { STRING_COMMA_LEN (".cmov"), PROCESSOR_UNKNOWN,
1028     CPU_CMOV_FLAGS, 0 },
1029   { STRING_COMMA_LEN (".fxsr"), PROCESSOR_UNKNOWN,
1030     CPU_FXSR_FLAGS, 0 },
1031   { STRING_COMMA_LEN (".mmx"), PROCESSOR_UNKNOWN,
1032     CPU_MMX_FLAGS, 0 },
1033   { STRING_COMMA_LEN (".sse"), PROCESSOR_UNKNOWN,
1034     CPU_SSE_FLAGS, 0 },
1035   { STRING_COMMA_LEN (".sse2"), PROCESSOR_UNKNOWN,
1036     CPU_SSE2_FLAGS, 0 },
1037   { STRING_COMMA_LEN (".sse3"), PROCESSOR_UNKNOWN,
1038     CPU_SSE3_FLAGS, 0 },
1039   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
1040     CPU_SSE4A_FLAGS, 0 },
1041   { STRING_COMMA_LEN (".ssse3"), PROCESSOR_UNKNOWN,
1042     CPU_SSSE3_FLAGS, 0 },
1043   { STRING_COMMA_LEN (".sse4.1"), PROCESSOR_UNKNOWN,
1044     CPU_SSE4_1_FLAGS, 0 },
1045   { STRING_COMMA_LEN (".sse4.2"), PROCESSOR_UNKNOWN,
1046     CPU_SSE4_2_FLAGS, 0 },
1047   { STRING_COMMA_LEN (".sse4"), PROCESSOR_UNKNOWN,
1048     CPU_SSE4_2_FLAGS, 0 },
1049   { STRING_COMMA_LEN (".avx"), PROCESSOR_UNKNOWN,
1050     CPU_AVX_FLAGS, 0 },
1051   { STRING_COMMA_LEN (".avx2"), PROCESSOR_UNKNOWN,
1052     CPU_AVX2_FLAGS, 0 },
1053   { STRING_COMMA_LEN (".avx512f"), PROCESSOR_UNKNOWN,
1054     CPU_AVX512F_FLAGS, 0 },
1055   { STRING_COMMA_LEN (".avx512cd"), PROCESSOR_UNKNOWN,
1056     CPU_AVX512CD_FLAGS, 0 },
1057   { STRING_COMMA_LEN (".avx512er"), PROCESSOR_UNKNOWN,
1058     CPU_AVX512ER_FLAGS, 0 },
1059   { STRING_COMMA_LEN (".avx512pf"), PROCESSOR_UNKNOWN,
1060     CPU_AVX512PF_FLAGS, 0 },
1061   { STRING_COMMA_LEN (".avx512dq"), PROCESSOR_UNKNOWN,
1062     CPU_AVX512DQ_FLAGS, 0 },
1063   { STRING_COMMA_LEN (".avx512bw"), PROCESSOR_UNKNOWN,
1064     CPU_AVX512BW_FLAGS, 0 },
1065   { STRING_COMMA_LEN (".avx512vl"), PROCESSOR_UNKNOWN,
1066     CPU_AVX512VL_FLAGS, 0 },
1067   { STRING_COMMA_LEN (".vmx"), PROCESSOR_UNKNOWN,
1068     CPU_VMX_FLAGS, 0 },
1069   { STRING_COMMA_LEN (".vmfunc"), PROCESSOR_UNKNOWN,
1070     CPU_VMFUNC_FLAGS, 0 },
1071   { STRING_COMMA_LEN (".smx"), PROCESSOR_UNKNOWN,
1072     CPU_SMX_FLAGS, 0 },
1073   { STRING_COMMA_LEN (".xsave"), PROCESSOR_UNKNOWN,
1074     CPU_XSAVE_FLAGS, 0 },
1075   { STRING_COMMA_LEN (".xsaveopt"), PROCESSOR_UNKNOWN,
1076     CPU_XSAVEOPT_FLAGS, 0 },
1077   { STRING_COMMA_LEN (".xsavec"), PROCESSOR_UNKNOWN,
1078     CPU_XSAVEC_FLAGS, 0 },
1079   { STRING_COMMA_LEN (".xsaves"), PROCESSOR_UNKNOWN,
1080     CPU_XSAVES_FLAGS, 0 },
1081   { STRING_COMMA_LEN (".aes"), PROCESSOR_UNKNOWN,
1082     CPU_AES_FLAGS, 0 },
1083   { STRING_COMMA_LEN (".pclmul"), PROCESSOR_UNKNOWN,
1084     CPU_PCLMUL_FLAGS, 0 },
1085   { STRING_COMMA_LEN (".clmul"), PROCESSOR_UNKNOWN,
1086     CPU_PCLMUL_FLAGS, 1 },
1087   { STRING_COMMA_LEN (".fsgsbase"), PROCESSOR_UNKNOWN,
1088     CPU_FSGSBASE_FLAGS, 0 },
1089   { STRING_COMMA_LEN (".rdrnd"), PROCESSOR_UNKNOWN,
1090     CPU_RDRND_FLAGS, 0 },
1091   { STRING_COMMA_LEN (".f16c"), PROCESSOR_UNKNOWN,
1092     CPU_F16C_FLAGS, 0 },
1093   { STRING_COMMA_LEN (".bmi2"), PROCESSOR_UNKNOWN,
1094     CPU_BMI2_FLAGS, 0 },
1095   { STRING_COMMA_LEN (".fma"), PROCESSOR_UNKNOWN,
1096     CPU_FMA_FLAGS, 0 },
1097   { STRING_COMMA_LEN (".fma4"), PROCESSOR_UNKNOWN,
1098     CPU_FMA4_FLAGS, 0 },
1099   { STRING_COMMA_LEN (".xop"), PROCESSOR_UNKNOWN,
1100     CPU_XOP_FLAGS, 0 },
1101   { STRING_COMMA_LEN (".lwp"), PROCESSOR_UNKNOWN,
1102     CPU_LWP_FLAGS, 0 },
1103   { STRING_COMMA_LEN (".movbe"), PROCESSOR_UNKNOWN,
1104     CPU_MOVBE_FLAGS, 0 },
1105   { STRING_COMMA_LEN (".cx16"), PROCESSOR_UNKNOWN,
1106     CPU_CX16_FLAGS, 0 },
1107   { STRING_COMMA_LEN (".ept"), PROCESSOR_UNKNOWN,
1108     CPU_EPT_FLAGS, 0 },
1109   { STRING_COMMA_LEN (".lzcnt"), PROCESSOR_UNKNOWN,
1110     CPU_LZCNT_FLAGS, 0 },
1111   { STRING_COMMA_LEN (".popcnt"), PROCESSOR_UNKNOWN,
1112     CPU_POPCNT_FLAGS, 0 },
1113   { STRING_COMMA_LEN (".hle"), PROCESSOR_UNKNOWN,
1114     CPU_HLE_FLAGS, 0 },
1115   { STRING_COMMA_LEN (".rtm"), PROCESSOR_UNKNOWN,
1116     CPU_RTM_FLAGS, 0 },
1117   { STRING_COMMA_LEN (".invpcid"), PROCESSOR_UNKNOWN,
1118     CPU_INVPCID_FLAGS, 0 },
1119   { STRING_COMMA_LEN (".clflush"), PROCESSOR_UNKNOWN,
1120     CPU_CLFLUSH_FLAGS, 0 },
1121   { STRING_COMMA_LEN (".nop"), PROCESSOR_UNKNOWN,
1122     CPU_NOP_FLAGS, 0 },
1123   { STRING_COMMA_LEN (".syscall"), PROCESSOR_UNKNOWN,
1124     CPU_SYSCALL_FLAGS, 0 },
1125   { STRING_COMMA_LEN (".rdtscp"), PROCESSOR_UNKNOWN,
1126     CPU_RDTSCP_FLAGS, 0 },
1127   { STRING_COMMA_LEN (".3dnow"), PROCESSOR_UNKNOWN,
1128     CPU_3DNOW_FLAGS, 0 },
1129   { STRING_COMMA_LEN (".3dnowa"), PROCESSOR_UNKNOWN,
1130     CPU_3DNOWA_FLAGS, 0 },
1131   { STRING_COMMA_LEN (".padlock"), PROCESSOR_UNKNOWN,
1132     CPU_PADLOCK_FLAGS, 0 },
1133   { STRING_COMMA_LEN (".pacifica"), PROCESSOR_UNKNOWN,
1134     CPU_SVME_FLAGS, 1 },
1135   { STRING_COMMA_LEN (".svme"), PROCESSOR_UNKNOWN,
1136     CPU_SVME_FLAGS, 0 },
1137   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
1138     CPU_SSE4A_FLAGS, 0 },
1139   { STRING_COMMA_LEN (".abm"), PROCESSOR_UNKNOWN,
1140     CPU_ABM_FLAGS, 0 },
1141   { STRING_COMMA_LEN (".bmi"), PROCESSOR_UNKNOWN,
1142     CPU_BMI_FLAGS, 0 },
1143   { STRING_COMMA_LEN (".tbm"), PROCESSOR_UNKNOWN,
1144     CPU_TBM_FLAGS, 0 },
1145   { STRING_COMMA_LEN (".adx"), PROCESSOR_UNKNOWN,
1146     CPU_ADX_FLAGS, 0 },
1147   { STRING_COMMA_LEN (".rdseed"), PROCESSOR_UNKNOWN,
1148     CPU_RDSEED_FLAGS, 0 },
1149   { STRING_COMMA_LEN (".prfchw"), PROCESSOR_UNKNOWN,
1150     CPU_PRFCHW_FLAGS, 0 },
1151   { STRING_COMMA_LEN (".smap"), PROCESSOR_UNKNOWN,
1152     CPU_SMAP_FLAGS, 0 },
1153   { STRING_COMMA_LEN (".mpx"), PROCESSOR_UNKNOWN,
1154     CPU_MPX_FLAGS, 0 },
1155   { STRING_COMMA_LEN (".sha"), PROCESSOR_UNKNOWN,
1156     CPU_SHA_FLAGS, 0 },
1157   { STRING_COMMA_LEN (".clflushopt"), PROCESSOR_UNKNOWN,
1158     CPU_CLFLUSHOPT_FLAGS, 0 },
1159   { STRING_COMMA_LEN (".prefetchwt1"), PROCESSOR_UNKNOWN,
1160     CPU_PREFETCHWT1_FLAGS, 0 },
1161   { STRING_COMMA_LEN (".se1"), PROCESSOR_UNKNOWN,
1162     CPU_SE1_FLAGS, 0 },
1163   { STRING_COMMA_LEN (".clwb"), PROCESSOR_UNKNOWN,
1164     CPU_CLWB_FLAGS, 0 },
1165   { STRING_COMMA_LEN (".avx512ifma"), PROCESSOR_UNKNOWN,
1166     CPU_AVX512IFMA_FLAGS, 0 },
1167   { STRING_COMMA_LEN (".avx512vbmi"), PROCESSOR_UNKNOWN,
1168     CPU_AVX512VBMI_FLAGS, 0 },
1169   { STRING_COMMA_LEN (".avx512_4fmaps"), PROCESSOR_UNKNOWN,
1170     CPU_AVX512_4FMAPS_FLAGS, 0 },
1171   { STRING_COMMA_LEN (".avx512_4vnniw"), PROCESSOR_UNKNOWN,
1172     CPU_AVX512_4VNNIW_FLAGS, 0 },
1173   { STRING_COMMA_LEN (".avx512_vpopcntdq"), PROCESSOR_UNKNOWN,
1174     CPU_AVX512_VPOPCNTDQ_FLAGS, 0 },
1175   { STRING_COMMA_LEN (".avx512_vbmi2"), PROCESSOR_UNKNOWN,
1176     CPU_AVX512_VBMI2_FLAGS, 0 },
1177   { STRING_COMMA_LEN (".avx512_vnni"), PROCESSOR_UNKNOWN,
1178     CPU_AVX512_VNNI_FLAGS, 0 },
1179   { STRING_COMMA_LEN (".avx512_bitalg"), PROCESSOR_UNKNOWN,
1180     CPU_AVX512_BITALG_FLAGS, 0 },
1181   { STRING_COMMA_LEN (".clzero"), PROCESSOR_UNKNOWN,
1182     CPU_CLZERO_FLAGS, 0 },
1183   { STRING_COMMA_LEN (".mwaitx"), PROCESSOR_UNKNOWN,
1184     CPU_MWAITX_FLAGS, 0 },
1185   { STRING_COMMA_LEN (".ospke"), PROCESSOR_UNKNOWN,
1186     CPU_OSPKE_FLAGS, 0 },
1187   { STRING_COMMA_LEN (".rdpid"), PROCESSOR_UNKNOWN,
1188     CPU_RDPID_FLAGS, 0 },
1189   { STRING_COMMA_LEN (".ptwrite"), PROCESSOR_UNKNOWN,
1190     CPU_PTWRITE_FLAGS, 0 },
1191   { STRING_COMMA_LEN (".ibt"), PROCESSOR_UNKNOWN,
1192     CPU_IBT_FLAGS, 0 },
1193   { STRING_COMMA_LEN (".shstk"), PROCESSOR_UNKNOWN,
1194     CPU_SHSTK_FLAGS, 0 },
1195   { STRING_COMMA_LEN (".gfni"), PROCESSOR_UNKNOWN,
1196     CPU_GFNI_FLAGS, 0 },
1197   { STRING_COMMA_LEN (".vaes"), PROCESSOR_UNKNOWN,
1198     CPU_VAES_FLAGS, 0 },
1199   { STRING_COMMA_LEN (".vpclmulqdq"), PROCESSOR_UNKNOWN,
1200     CPU_VPCLMULQDQ_FLAGS, 0 },
1201   { STRING_COMMA_LEN (".wbnoinvd"), PROCESSOR_UNKNOWN,
1202     CPU_WBNOINVD_FLAGS, 0 },
1203   { STRING_COMMA_LEN (".pconfig"), PROCESSOR_UNKNOWN,
1204     CPU_PCONFIG_FLAGS, 0 },
1205   { STRING_COMMA_LEN (".waitpkg"), PROCESSOR_UNKNOWN,
1206     CPU_WAITPKG_FLAGS, 0 },
1207   { STRING_COMMA_LEN (".cldemote"), PROCESSOR_UNKNOWN,
1208     CPU_CLDEMOTE_FLAGS, 0 },
1209   { STRING_COMMA_LEN (".amx_int8"), PROCESSOR_UNKNOWN,
1210     CPU_AMX_INT8_FLAGS, 0 },
1211   { STRING_COMMA_LEN (".amx_bf16"), PROCESSOR_UNKNOWN,
1212     CPU_AMX_BF16_FLAGS, 0 },
1213   { STRING_COMMA_LEN (".amx_tile"), PROCESSOR_UNKNOWN,
1214     CPU_AMX_TILE_FLAGS, 0 },
1215   { STRING_COMMA_LEN (".movdiri"), PROCESSOR_UNKNOWN,
1216     CPU_MOVDIRI_FLAGS, 0 },
1217   { STRING_COMMA_LEN (".movdir64b"), PROCESSOR_UNKNOWN,
1218     CPU_MOVDIR64B_FLAGS, 0 },
1219   { STRING_COMMA_LEN (".avx512_bf16"), PROCESSOR_UNKNOWN,
1220     CPU_AVX512_BF16_FLAGS, 0 },
1221   { STRING_COMMA_LEN (".avx512_vp2intersect"), PROCESSOR_UNKNOWN,
1222     CPU_AVX512_VP2INTERSECT_FLAGS, 0 },
1223   { STRING_COMMA_LEN (".tdx"), PROCESSOR_UNKNOWN,
1224     CPU_TDX_FLAGS, 0 },
1225   { STRING_COMMA_LEN (".enqcmd"), PROCESSOR_UNKNOWN,
1226     CPU_ENQCMD_FLAGS, 0 },
1227   { STRING_COMMA_LEN (".serialize"), PROCESSOR_UNKNOWN,
1228     CPU_SERIALIZE_FLAGS, 0 },
1229   { STRING_COMMA_LEN (".rdpru"), PROCESSOR_UNKNOWN,
1230     CPU_RDPRU_FLAGS, 0 },
1231   { STRING_COMMA_LEN (".mcommit"), PROCESSOR_UNKNOWN,
1232     CPU_MCOMMIT_FLAGS, 0 },
1233   { STRING_COMMA_LEN (".sev_es"), PROCESSOR_UNKNOWN,
1234     CPU_SEV_ES_FLAGS, 0 },
1235   { STRING_COMMA_LEN (".tsxldtrk"), PROCESSOR_UNKNOWN,
1236     CPU_TSXLDTRK_FLAGS, 0 },
1237   { STRING_COMMA_LEN (".kl"), PROCESSOR_UNKNOWN,
1238     CPU_KL_FLAGS, 0 },
1239   { STRING_COMMA_LEN (".widekl"), PROCESSOR_UNKNOWN,
1240     CPU_WIDEKL_FLAGS, 0 },
1241 };
1242
1243 static const noarch_entry cpu_noarch[] =
1244 {
1245   { STRING_COMMA_LEN ("no87"),  CPU_ANY_X87_FLAGS },
1246   { STRING_COMMA_LEN ("no287"),  CPU_ANY_287_FLAGS },
1247   { STRING_COMMA_LEN ("no387"),  CPU_ANY_387_FLAGS },
1248   { STRING_COMMA_LEN ("no687"),  CPU_ANY_687_FLAGS },
1249   { STRING_COMMA_LEN ("nocmov"),  CPU_ANY_CMOV_FLAGS },
1250   { STRING_COMMA_LEN ("nofxsr"),  CPU_ANY_FXSR_FLAGS },
1251   { STRING_COMMA_LEN ("nommx"),  CPU_ANY_MMX_FLAGS },
1252   { STRING_COMMA_LEN ("nosse"),  CPU_ANY_SSE_FLAGS },
1253   { STRING_COMMA_LEN ("nosse2"),  CPU_ANY_SSE2_FLAGS },
1254   { STRING_COMMA_LEN ("nosse3"),  CPU_ANY_SSE3_FLAGS },
1255   { STRING_COMMA_LEN ("nosse4a"),  CPU_ANY_SSE4A_FLAGS },
1256   { STRING_COMMA_LEN ("nossse3"),  CPU_ANY_SSSE3_FLAGS },
1257   { STRING_COMMA_LEN ("nosse4.1"),  CPU_ANY_SSE4_1_FLAGS },
1258   { STRING_COMMA_LEN ("nosse4.2"),  CPU_ANY_SSE4_2_FLAGS },
1259   { STRING_COMMA_LEN ("nosse4"),  CPU_ANY_SSE4_1_FLAGS },
1260   { STRING_COMMA_LEN ("noavx"),  CPU_ANY_AVX_FLAGS },
1261   { STRING_COMMA_LEN ("noavx2"),  CPU_ANY_AVX2_FLAGS },
1262   { STRING_COMMA_LEN ("noavx512f"), CPU_ANY_AVX512F_FLAGS },
1263   { STRING_COMMA_LEN ("noavx512cd"), CPU_ANY_AVX512CD_FLAGS },
1264   { STRING_COMMA_LEN ("noavx512er"), CPU_ANY_AVX512ER_FLAGS },
1265   { STRING_COMMA_LEN ("noavx512pf"), CPU_ANY_AVX512PF_FLAGS },
1266   { STRING_COMMA_LEN ("noavx512dq"), CPU_ANY_AVX512DQ_FLAGS },
1267   { STRING_COMMA_LEN ("noavx512bw"), CPU_ANY_AVX512BW_FLAGS },
1268   { STRING_COMMA_LEN ("noavx512vl"), CPU_ANY_AVX512VL_FLAGS },
1269   { STRING_COMMA_LEN ("noavx512ifma"), CPU_ANY_AVX512IFMA_FLAGS },
1270   { STRING_COMMA_LEN ("noavx512vbmi"), CPU_ANY_AVX512VBMI_FLAGS },
1271   { STRING_COMMA_LEN ("noavx512_4fmaps"), CPU_ANY_AVX512_4FMAPS_FLAGS },
1272   { STRING_COMMA_LEN ("noavx512_4vnniw"), CPU_ANY_AVX512_4VNNIW_FLAGS },
1273   { STRING_COMMA_LEN ("noavx512_vpopcntdq"), CPU_ANY_AVX512_VPOPCNTDQ_FLAGS },
1274   { STRING_COMMA_LEN ("noavx512_vbmi2"), CPU_ANY_AVX512_VBMI2_FLAGS },
1275   { STRING_COMMA_LEN ("noavx512_vnni"), CPU_ANY_AVX512_VNNI_FLAGS },
1276   { STRING_COMMA_LEN ("noavx512_bitalg"), CPU_ANY_AVX512_BITALG_FLAGS },
1277   { STRING_COMMA_LEN ("noibt"), CPU_ANY_IBT_FLAGS },
1278   { STRING_COMMA_LEN ("noshstk"), CPU_ANY_SHSTK_FLAGS },
1279   { STRING_COMMA_LEN ("noamx_int8"), CPU_ANY_AMX_INT8_FLAGS },
1280   { STRING_COMMA_LEN ("noamx_bf16"), CPU_ANY_AMX_BF16_FLAGS },
1281   { STRING_COMMA_LEN ("noamx_tile"), CPU_ANY_AMX_TILE_FLAGS },
1282   { STRING_COMMA_LEN ("nomovdiri"), CPU_ANY_MOVDIRI_FLAGS },
1283   { STRING_COMMA_LEN ("nomovdir64b"), CPU_ANY_MOVDIR64B_FLAGS },
1284   { STRING_COMMA_LEN ("noavx512_bf16"), CPU_ANY_AVX512_BF16_FLAGS },
1285   { STRING_COMMA_LEN ("noavx512_vp2intersect"),
1286     CPU_ANY_AVX512_VP2INTERSECT_FLAGS },
1287   { STRING_COMMA_LEN ("notdx"), CPU_ANY_TDX_FLAGS },
1288   { STRING_COMMA_LEN ("noenqcmd"), CPU_ANY_ENQCMD_FLAGS },
1289   { STRING_COMMA_LEN ("noserialize"), CPU_ANY_SERIALIZE_FLAGS },
1290   { STRING_COMMA_LEN ("notsxldtrk"), CPU_ANY_TSXLDTRK_FLAGS },
1291   { STRING_COMMA_LEN ("nokl"), CPU_ANY_KL_FLAGS },
1292   { STRING_COMMA_LEN ("nowidekl"), CPU_ANY_WIDEKL_FLAGS },
1293 };
1294
1295 #ifdef I386COFF
1296 /* Like s_lcomm_internal in gas/read.c but the alignment string
1297    is allowed to be optional.  */
1298
1299 static symbolS *
1300 pe_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
1301 {
1302   addressT align = 0;
1303
1304   SKIP_WHITESPACE ();
1305
1306   if (needs_align
1307       && *input_line_pointer == ',')
1308     {
1309       align = parse_align (needs_align - 1);
1310
1311       if (align == (addressT) -1)
1312         return NULL;
1313     }
1314   else
1315     {
1316       if (size >= 8)
1317         align = 3;
1318       else if (size >= 4)
1319         align = 2;
1320       else if (size >= 2)
1321         align = 1;
1322       else
1323         align = 0;
1324     }
1325
1326   bss_alloc (symbolP, size, align);
1327   return symbolP;
1328 }
1329
1330 static void
1331 pe_lcomm (int needs_align)
1332 {
1333   s_comm_internal (needs_align * 2, pe_lcomm_internal);
1334 }
1335 #endif
1336
1337 const pseudo_typeS md_pseudo_table[] =
1338 {
1339 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
1340   {"align", s_align_bytes, 0},
1341 #else
1342   {"align", s_align_ptwo, 0},
1343 #endif
1344   {"arch", set_cpu_arch, 0},
1345 #ifndef I386COFF
1346   {"bss", s_bss, 0},
1347 #else
1348   {"lcomm", pe_lcomm, 1},
1349 #endif
1350   {"ffloat", float_cons, 'f'},
1351   {"dfloat", float_cons, 'd'},
1352   {"tfloat", float_cons, 'x'},
1353   {"value", cons, 2},
1354   {"slong", signed_cons, 4},
1355   {"noopt", s_ignore, 0},
1356   {"optim", s_ignore, 0},
1357   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
1358   {"code16", set_code_flag, CODE_16BIT},
1359   {"code32", set_code_flag, CODE_32BIT},
1360 #ifdef BFD64
1361   {"code64", set_code_flag, CODE_64BIT},
1362 #endif
1363   {"intel_syntax", set_intel_syntax, 1},
1364   {"att_syntax", set_intel_syntax, 0},
1365   {"intel_mnemonic", set_intel_mnemonic, 1},
1366   {"att_mnemonic", set_intel_mnemonic, 0},
1367   {"allow_index_reg", set_allow_index_reg, 1},
1368   {"disallow_index_reg", set_allow_index_reg, 0},
1369   {"sse_check", set_check, 0},
1370   {"operand_check", set_check, 1},
1371 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1372   {"largecomm", handle_large_common, 0},
1373 #else
1374   {"file", dwarf2_directive_file, 0},
1375   {"loc", dwarf2_directive_loc, 0},
1376   {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
1377 #endif
1378 #ifdef TE_PE
1379   {"secrel32", pe_directive_secrel, 0},
1380 #endif
1381   {0, 0, 0}
1382 };
1383
1384 /* For interface with expression ().  */
1385 extern char *input_line_pointer;
1386
1387 /* Hash table for instruction mnemonic lookup.  */
1388 static htab_t op_hash;
1389
1390 /* Hash table for register lookup.  */
1391 static htab_t reg_hash;
1392 \f
1393   /* Various efficient no-op patterns for aligning code labels.
1394      Note: Don't try to assemble the instructions in the comments.
1395      0L and 0w are not legal.  */
1396 static const unsigned char f32_1[] =
1397   {0x90};                               /* nop                  */
1398 static const unsigned char f32_2[] =
1399   {0x66,0x90};                          /* xchg %ax,%ax         */
1400 static const unsigned char f32_3[] =
1401   {0x8d,0x76,0x00};                     /* leal 0(%esi),%esi    */
1402 static const unsigned char f32_4[] =
1403   {0x8d,0x74,0x26,0x00};                /* leal 0(%esi,1),%esi  */
1404 static const unsigned char f32_6[] =
1405   {0x8d,0xb6,0x00,0x00,0x00,0x00};      /* leal 0L(%esi),%esi   */
1406 static const unsigned char f32_7[] =
1407   {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
1408 static const unsigned char f16_3[] =
1409   {0x8d,0x74,0x00};                     /* lea 0(%si),%si       */
1410 static const unsigned char f16_4[] =
1411   {0x8d,0xb4,0x00,0x00};                /* lea 0W(%si),%si      */
1412 static const unsigned char jump_disp8[] =
1413   {0xeb};                               /* jmp disp8           */
1414 static const unsigned char jump32_disp32[] =
1415   {0xe9};                               /* jmp disp32          */
1416 static const unsigned char jump16_disp32[] =
1417   {0x66,0xe9};                          /* jmp disp32          */
1418 /* 32-bit NOPs patterns.  */
1419 static const unsigned char *const f32_patt[] = {
1420   f32_1, f32_2, f32_3, f32_4, NULL, f32_6, f32_7
1421 };
1422 /* 16-bit NOPs patterns.  */
1423 static const unsigned char *const f16_patt[] = {
1424   f32_1, f32_2, f16_3, f16_4
1425 };
1426 /* nopl (%[re]ax) */
1427 static const unsigned char alt_3[] =
1428   {0x0f,0x1f,0x00};
1429 /* nopl 0(%[re]ax) */
1430 static const unsigned char alt_4[] =
1431   {0x0f,0x1f,0x40,0x00};
1432 /* nopl 0(%[re]ax,%[re]ax,1) */
1433 static const unsigned char alt_5[] =
1434   {0x0f,0x1f,0x44,0x00,0x00};
1435 /* nopw 0(%[re]ax,%[re]ax,1) */
1436 static const unsigned char alt_6[] =
1437   {0x66,0x0f,0x1f,0x44,0x00,0x00};
1438 /* nopl 0L(%[re]ax) */
1439 static const unsigned char alt_7[] =
1440   {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
1441 /* nopl 0L(%[re]ax,%[re]ax,1) */
1442 static const unsigned char alt_8[] =
1443   {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1444 /* nopw 0L(%[re]ax,%[re]ax,1) */
1445 static const unsigned char alt_9[] =
1446   {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1447 /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
1448 static const unsigned char alt_10[] =
1449   {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1450 /* data16 nopw %cs:0L(%eax,%eax,1) */
1451 static const unsigned char alt_11[] =
1452   {0x66,0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1453 /* 32-bit and 64-bit NOPs patterns.  */
1454 static const unsigned char *const alt_patt[] = {
1455   f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
1456   alt_9, alt_10, alt_11
1457 };
1458
1459 /* Genenerate COUNT bytes of NOPs to WHERE from PATT with the maximum
1460    size of a single NOP instruction MAX_SINGLE_NOP_SIZE.  */
1461
1462 static void
1463 i386_output_nops (char *where, const unsigned char *const *patt,
1464                   int count, int max_single_nop_size)
1465
1466 {
1467   /* Place the longer NOP first.  */
1468   int last;
1469   int offset;
1470   const unsigned char *nops;
1471
1472   if (max_single_nop_size < 1)
1473     {
1474       as_fatal (_("i386_output_nops called to generate nops of at most %d bytes!"),
1475                 max_single_nop_size);
1476       return;
1477     }
1478
1479   nops = patt[max_single_nop_size - 1];
1480
1481   /* Use the smaller one if the requsted one isn't available.  */
1482   if (nops == NULL)
1483     {
1484       max_single_nop_size--;
1485       nops = patt[max_single_nop_size - 1];
1486     }
1487
1488   last = count % max_single_nop_size;
1489
1490   count -= last;
1491   for (offset = 0; offset < count; offset += max_single_nop_size)
1492     memcpy (where + offset, nops, max_single_nop_size);
1493
1494   if (last)
1495     {
1496       nops = patt[last - 1];
1497       if (nops == NULL)
1498         {
1499           /* Use the smaller one plus one-byte NOP if the needed one
1500              isn't available.  */
1501           last--;
1502           nops = patt[last - 1];
1503           memcpy (where + offset, nops, last);
1504           where[offset + last] = *patt[0];
1505         }
1506       else
1507         memcpy (where + offset, nops, last);
1508     }
1509 }
1510
1511 static INLINE int
1512 fits_in_imm7 (offsetT num)
1513 {
1514   return (num & 0x7f) == num;
1515 }
1516
1517 static INLINE int
1518 fits_in_imm31 (offsetT num)
1519 {
1520   return (num & 0x7fffffff) == num;
1521 }
1522
1523 /* Genenerate COUNT bytes of NOPs to WHERE with the maximum size of a
1524    single NOP instruction LIMIT.  */
1525
1526 void
1527 i386_generate_nops (fragS *fragP, char *where, offsetT count, int limit)
1528 {
1529   const unsigned char *const *patt = NULL;
1530   int max_single_nop_size;
1531   /* Maximum number of NOPs before switching to jump over NOPs.  */
1532   int max_number_of_nops;
1533
1534   switch (fragP->fr_type)
1535     {
1536     case rs_fill_nop:
1537     case rs_align_code:
1538       break;
1539     case rs_machine_dependent:
1540       /* Allow NOP padding for jumps and calls.  */
1541       if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
1542           || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
1543         break;
1544       /* Fall through.  */
1545     default:
1546       return;
1547     }
1548
1549   /* We need to decide which NOP sequence to use for 32bit and
1550      64bit. When -mtune= is used:
1551
1552      1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
1553      PROCESSOR_GENERIC32, f32_patt will be used.
1554      2. For the rest, alt_patt will be used.
1555
1556      When -mtune= isn't used, alt_patt will be used if
1557      cpu_arch_isa_flags has CpuNop.  Otherwise, f32_patt will
1558      be used.
1559
1560      When -march= or .arch is used, we can't use anything beyond
1561      cpu_arch_isa_flags.   */
1562
1563   if (flag_code == CODE_16BIT)
1564     {
1565       patt = f16_patt;
1566       max_single_nop_size = sizeof (f16_patt) / sizeof (f16_patt[0]);
1567       /* Limit number of NOPs to 2 in 16-bit mode.  */
1568       max_number_of_nops = 2;
1569     }
1570   else
1571     {
1572       if (fragP->tc_frag_data.isa == PROCESSOR_UNKNOWN)
1573         {
1574           /* PROCESSOR_UNKNOWN means that all ISAs may be used.  */
1575           switch (cpu_arch_tune)
1576             {
1577             case PROCESSOR_UNKNOWN:
1578               /* We use cpu_arch_isa_flags to check if we SHOULD
1579                  optimize with nops.  */
1580               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1581                 patt = alt_patt;
1582               else
1583                 patt = f32_patt;
1584               break;
1585             case PROCESSOR_PENTIUM4:
1586             case PROCESSOR_NOCONA:
1587             case PROCESSOR_CORE:
1588             case PROCESSOR_CORE2:
1589             case PROCESSOR_COREI7:
1590             case PROCESSOR_L1OM:
1591             case PROCESSOR_K1OM:
1592             case PROCESSOR_GENERIC64:
1593             case PROCESSOR_K6:
1594             case PROCESSOR_ATHLON:
1595             case PROCESSOR_K8:
1596             case PROCESSOR_AMDFAM10:
1597             case PROCESSOR_BD:
1598             case PROCESSOR_ZNVER:
1599             case PROCESSOR_BT:
1600               patt = alt_patt;
1601               break;
1602             case PROCESSOR_I386:
1603             case PROCESSOR_I486:
1604             case PROCESSOR_PENTIUM:
1605             case PROCESSOR_PENTIUMPRO:
1606             case PROCESSOR_IAMCU:
1607             case PROCESSOR_GENERIC32:
1608               patt = f32_patt;
1609               break;
1610             }
1611         }
1612       else
1613         {
1614           switch (fragP->tc_frag_data.tune)
1615             {
1616             case PROCESSOR_UNKNOWN:
1617               /* When cpu_arch_isa is set, cpu_arch_tune shouldn't be
1618                  PROCESSOR_UNKNOWN.  */
1619               abort ();
1620               break;
1621
1622             case PROCESSOR_I386:
1623             case PROCESSOR_I486:
1624             case PROCESSOR_PENTIUM:
1625             case PROCESSOR_IAMCU:
1626             case PROCESSOR_K6:
1627             case PROCESSOR_ATHLON:
1628             case PROCESSOR_K8:
1629             case PROCESSOR_AMDFAM10:
1630             case PROCESSOR_BD:
1631             case PROCESSOR_ZNVER:
1632             case PROCESSOR_BT:
1633             case PROCESSOR_GENERIC32:
1634               /* We use cpu_arch_isa_flags to check if we CAN optimize
1635                  with nops.  */
1636               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1637                 patt = alt_patt;
1638               else
1639                 patt = f32_patt;
1640               break;
1641             case PROCESSOR_PENTIUMPRO:
1642             case PROCESSOR_PENTIUM4:
1643             case PROCESSOR_NOCONA:
1644             case PROCESSOR_CORE:
1645             case PROCESSOR_CORE2:
1646             case PROCESSOR_COREI7:
1647             case PROCESSOR_L1OM:
1648             case PROCESSOR_K1OM:
1649               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1650                 patt = alt_patt;
1651               else
1652                 patt = f32_patt;
1653               break;
1654             case PROCESSOR_GENERIC64:
1655               patt = alt_patt;
1656               break;
1657             }
1658         }
1659
1660       if (patt == f32_patt)
1661         {
1662           max_single_nop_size = sizeof (f32_patt) / sizeof (f32_patt[0]);
1663           /* Limit number of NOPs to 2 for older processors.  */
1664           max_number_of_nops = 2;
1665         }
1666       else
1667         {
1668           max_single_nop_size = sizeof (alt_patt) / sizeof (alt_patt[0]);
1669           /* Limit number of NOPs to 7 for newer processors.  */
1670           max_number_of_nops = 7;
1671         }
1672     }
1673
1674   if (limit == 0)
1675     limit = max_single_nop_size;
1676
1677   if (fragP->fr_type == rs_fill_nop)
1678     {
1679       /* Output NOPs for .nop directive.  */
1680       if (limit > max_single_nop_size)
1681         {
1682           as_bad_where (fragP->fr_file, fragP->fr_line,
1683                         _("invalid single nop size: %d "
1684                           "(expect within [0, %d])"),
1685                         limit, max_single_nop_size);
1686           return;
1687         }
1688     }
1689   else if (fragP->fr_type != rs_machine_dependent)
1690     fragP->fr_var = count;
1691
1692   if ((count / max_single_nop_size) > max_number_of_nops)
1693     {
1694       /* Generate jump over NOPs.  */
1695       offsetT disp = count - 2;
1696       if (fits_in_imm7 (disp))
1697         {
1698           /* Use "jmp disp8" if possible.  */
1699           count = disp;
1700           where[0] = jump_disp8[0];
1701           where[1] = count;
1702           where += 2;
1703         }
1704       else
1705         {
1706           unsigned int size_of_jump;
1707
1708           if (flag_code == CODE_16BIT)
1709             {
1710               where[0] = jump16_disp32[0];
1711               where[1] = jump16_disp32[1];
1712               size_of_jump = 2;
1713             }
1714           else
1715             {
1716               where[0] = jump32_disp32[0];
1717               size_of_jump = 1;
1718             }
1719
1720           count -= size_of_jump + 4;
1721           if (!fits_in_imm31 (count))
1722             {
1723               as_bad_where (fragP->fr_file, fragP->fr_line,
1724                             _("jump over nop padding out of range"));
1725               return;
1726             }
1727
1728           md_number_to_chars (where + size_of_jump, count, 4);
1729           where += size_of_jump + 4;
1730         }
1731     }
1732
1733   /* Generate multiple NOPs.  */
1734   i386_output_nops (where, patt, count, limit);
1735 }
1736
1737 static INLINE int
1738 operand_type_all_zero (const union i386_operand_type *x)
1739 {
1740   switch (ARRAY_SIZE(x->array))
1741     {
1742     case 3:
1743       if (x->array[2])
1744         return 0;
1745       /* Fall through.  */
1746     case 2:
1747       if (x->array[1])
1748         return 0;
1749       /* Fall through.  */
1750     case 1:
1751       return !x->array[0];
1752     default:
1753       abort ();
1754     }
1755 }
1756
1757 static INLINE void
1758 operand_type_set (union i386_operand_type *x, unsigned int v)
1759 {
1760   switch (ARRAY_SIZE(x->array))
1761     {
1762     case 3:
1763       x->array[2] = v;
1764       /* Fall through.  */
1765     case 2:
1766       x->array[1] = v;
1767       /* Fall through.  */
1768     case 1:
1769       x->array[0] = v;
1770       /* Fall through.  */
1771       break;
1772     default:
1773       abort ();
1774     }
1775
1776   x->bitfield.class = ClassNone;
1777   x->bitfield.instance = InstanceNone;
1778 }
1779
1780 static INLINE int
1781 operand_type_equal (const union i386_operand_type *x,
1782                     const union i386_operand_type *y)
1783 {
1784   switch (ARRAY_SIZE(x->array))
1785     {
1786     case 3:
1787       if (x->array[2] != y->array[2])
1788         return 0;
1789       /* Fall through.  */
1790     case 2:
1791       if (x->array[1] != y->array[1])
1792         return 0;
1793       /* Fall through.  */
1794     case 1:
1795       return x->array[0] == y->array[0];
1796       break;
1797     default:
1798       abort ();
1799     }
1800 }
1801
1802 static INLINE int
1803 cpu_flags_all_zero (const union i386_cpu_flags *x)
1804 {
1805   switch (ARRAY_SIZE(x->array))
1806     {
1807     case 4:
1808       if (x->array[3])
1809         return 0;
1810       /* Fall through.  */
1811     case 3:
1812       if (x->array[2])
1813         return 0;
1814       /* Fall through.  */
1815     case 2:
1816       if (x->array[1])
1817         return 0;
1818       /* Fall through.  */
1819     case 1:
1820       return !x->array[0];
1821     default:
1822       abort ();
1823     }
1824 }
1825
1826 static INLINE int
1827 cpu_flags_equal (const union i386_cpu_flags *x,
1828                  const union i386_cpu_flags *y)
1829 {
1830   switch (ARRAY_SIZE(x->array))
1831     {
1832     case 4:
1833       if (x->array[3] != y->array[3])
1834         return 0;
1835       /* Fall through.  */
1836     case 3:
1837       if (x->array[2] != y->array[2])
1838         return 0;
1839       /* Fall through.  */
1840     case 2:
1841       if (x->array[1] != y->array[1])
1842         return 0;
1843       /* Fall through.  */
1844     case 1:
1845       return x->array[0] == y->array[0];
1846       break;
1847     default:
1848       abort ();
1849     }
1850 }
1851
1852 static INLINE int
1853 cpu_flags_check_cpu64 (i386_cpu_flags f)
1854 {
1855   return !((flag_code == CODE_64BIT && f.bitfield.cpuno64)
1856            || (flag_code != CODE_64BIT && f.bitfield.cpu64));
1857 }
1858
1859 static INLINE i386_cpu_flags
1860 cpu_flags_and (i386_cpu_flags x, i386_cpu_flags y)
1861 {
1862   switch (ARRAY_SIZE (x.array))
1863     {
1864     case 4:
1865       x.array [3] &= y.array [3];
1866       /* Fall through.  */
1867     case 3:
1868       x.array [2] &= y.array [2];
1869       /* Fall through.  */
1870     case 2:
1871       x.array [1] &= y.array [1];
1872       /* Fall through.  */
1873     case 1:
1874       x.array [0] &= y.array [0];
1875       break;
1876     default:
1877       abort ();
1878     }
1879   return x;
1880 }
1881
1882 static INLINE i386_cpu_flags
1883 cpu_flags_or (i386_cpu_flags x, i386_cpu_flags y)
1884 {
1885   switch (ARRAY_SIZE (x.array))
1886     {
1887     case 4:
1888       x.array [3] |= y.array [3];
1889       /* Fall through.  */
1890     case 3:
1891       x.array [2] |= y.array [2];
1892       /* Fall through.  */
1893     case 2:
1894       x.array [1] |= y.array [1];
1895       /* Fall through.  */
1896     case 1:
1897       x.array [0] |= y.array [0];
1898       break;
1899     default:
1900       abort ();
1901     }
1902   return x;
1903 }
1904
1905 static INLINE i386_cpu_flags
1906 cpu_flags_and_not (i386_cpu_flags x, i386_cpu_flags y)
1907 {
1908   switch (ARRAY_SIZE (x.array))
1909     {
1910     case 4:
1911       x.array [3] &= ~y.array [3];
1912       /* Fall through.  */
1913     case 3:
1914       x.array [2] &= ~y.array [2];
1915       /* Fall through.  */
1916     case 2:
1917       x.array [1] &= ~y.array [1];
1918       /* Fall through.  */
1919     case 1:
1920       x.array [0] &= ~y.array [0];
1921       break;
1922     default:
1923       abort ();
1924     }
1925   return x;
1926 }
1927
1928 static const i386_cpu_flags avx512 = CPU_ANY_AVX512F_FLAGS;
1929
1930 #define CPU_FLAGS_ARCH_MATCH            0x1
1931 #define CPU_FLAGS_64BIT_MATCH           0x2
1932
1933 #define CPU_FLAGS_PERFECT_MATCH \
1934   (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_64BIT_MATCH)
1935
1936 /* Return CPU flags match bits. */
1937
1938 static int
1939 cpu_flags_match (const insn_template *t)
1940 {
1941   i386_cpu_flags x = t->cpu_flags;
1942   int match = cpu_flags_check_cpu64 (x) ? CPU_FLAGS_64BIT_MATCH : 0;
1943
1944   x.bitfield.cpu64 = 0;
1945   x.bitfield.cpuno64 = 0;
1946
1947   if (cpu_flags_all_zero (&x))
1948     {
1949       /* This instruction is available on all archs.  */
1950       match |= CPU_FLAGS_ARCH_MATCH;
1951     }
1952   else
1953     {
1954       /* This instruction is available only on some archs.  */
1955       i386_cpu_flags cpu = cpu_arch_flags;
1956
1957       /* AVX512VL is no standalone feature - match it and then strip it.  */
1958       if (x.bitfield.cpuavx512vl && !cpu.bitfield.cpuavx512vl)
1959         return match;
1960       x.bitfield.cpuavx512vl = 0;
1961
1962       cpu = cpu_flags_and (x, cpu);
1963       if (!cpu_flags_all_zero (&cpu))
1964         {
1965           if (x.bitfield.cpuavx)
1966             {
1967               /* We need to check a few extra flags with AVX.  */
1968               if (cpu.bitfield.cpuavx
1969                   && (!t->opcode_modifier.sse2avx
1970                       || (sse2avx && !i.prefix[DATA_PREFIX]))
1971                   && (!x.bitfield.cpuaes || cpu.bitfield.cpuaes)
1972                   && (!x.bitfield.cpugfni || cpu.bitfield.cpugfni)
1973                   && (!x.bitfield.cpupclmul || cpu.bitfield.cpupclmul))
1974                 match |= CPU_FLAGS_ARCH_MATCH;
1975             }
1976           else if (x.bitfield.cpuavx512f)
1977             {
1978               /* We need to check a few extra flags with AVX512F.  */
1979               if (cpu.bitfield.cpuavx512f
1980                   && (!x.bitfield.cpugfni || cpu.bitfield.cpugfni)
1981                   && (!x.bitfield.cpuvaes || cpu.bitfield.cpuvaes)
1982                   && (!x.bitfield.cpuvpclmulqdq || cpu.bitfield.cpuvpclmulqdq))
1983                 match |= CPU_FLAGS_ARCH_MATCH;
1984             }
1985           else
1986             match |= CPU_FLAGS_ARCH_MATCH;
1987         }
1988     }
1989   return match;
1990 }
1991
1992 static INLINE i386_operand_type
1993 operand_type_and (i386_operand_type x, i386_operand_type y)
1994 {
1995   if (x.bitfield.class != y.bitfield.class)
1996     x.bitfield.class = ClassNone;
1997   if (x.bitfield.instance != y.bitfield.instance)
1998     x.bitfield.instance = InstanceNone;
1999
2000   switch (ARRAY_SIZE (x.array))
2001     {
2002     case 3:
2003       x.array [2] &= y.array [2];
2004       /* Fall through.  */
2005     case 2:
2006       x.array [1] &= y.array [1];
2007       /* Fall through.  */
2008     case 1:
2009       x.array [0] &= y.array [0];
2010       break;
2011     default:
2012       abort ();
2013     }
2014   return x;
2015 }
2016
2017 static INLINE i386_operand_type
2018 operand_type_and_not (i386_operand_type x, i386_operand_type y)
2019 {
2020   gas_assert (y.bitfield.class == ClassNone);
2021   gas_assert (y.bitfield.instance == InstanceNone);
2022
2023   switch (ARRAY_SIZE (x.array))
2024     {
2025     case 3:
2026       x.array [2] &= ~y.array [2];
2027       /* Fall through.  */
2028     case 2:
2029       x.array [1] &= ~y.array [1];
2030       /* Fall through.  */
2031     case 1:
2032       x.array [0] &= ~y.array [0];
2033       break;
2034     default:
2035       abort ();
2036     }
2037   return x;
2038 }
2039
2040 static INLINE i386_operand_type
2041 operand_type_or (i386_operand_type x, i386_operand_type y)
2042 {
2043   gas_assert (x.bitfield.class == ClassNone ||
2044               y.bitfield.class == ClassNone ||
2045               x.bitfield.class == y.bitfield.class);
2046   gas_assert (x.bitfield.instance == InstanceNone ||
2047               y.bitfield.instance == InstanceNone ||
2048               x.bitfield.instance == y.bitfield.instance);
2049
2050   switch (ARRAY_SIZE (x.array))
2051     {
2052     case 3:
2053       x.array [2] |= y.array [2];
2054       /* Fall through.  */
2055     case 2:
2056       x.array [1] |= y.array [1];
2057       /* Fall through.  */
2058     case 1:
2059       x.array [0] |= y.array [0];
2060       break;
2061     default:
2062       abort ();
2063     }
2064   return x;
2065 }
2066
2067 static INLINE i386_operand_type
2068 operand_type_xor (i386_operand_type x, i386_operand_type y)
2069 {
2070   gas_assert (y.bitfield.class == ClassNone);
2071   gas_assert (y.bitfield.instance == InstanceNone);
2072
2073   switch (ARRAY_SIZE (x.array))
2074     {
2075     case 3:
2076       x.array [2] ^= y.array [2];
2077       /* Fall through.  */
2078     case 2:
2079       x.array [1] ^= y.array [1];
2080       /* Fall through.  */
2081     case 1:
2082       x.array [0] ^= y.array [0];
2083       break;
2084     default:
2085       abort ();
2086     }
2087   return x;
2088 }
2089
2090 static const i386_operand_type disp16 = OPERAND_TYPE_DISP16;
2091 static const i386_operand_type disp32 = OPERAND_TYPE_DISP32;
2092 static const i386_operand_type disp32s = OPERAND_TYPE_DISP32S;
2093 static const i386_operand_type disp16_32 = OPERAND_TYPE_DISP16_32;
2094 static const i386_operand_type anydisp = OPERAND_TYPE_ANYDISP;
2095 static const i386_operand_type anyimm = OPERAND_TYPE_ANYIMM;
2096 static const i386_operand_type regxmm = OPERAND_TYPE_REGXMM;
2097 static const i386_operand_type regmask = OPERAND_TYPE_REGMASK;
2098 static const i386_operand_type imm8 = OPERAND_TYPE_IMM8;
2099 static const i386_operand_type imm8s = OPERAND_TYPE_IMM8S;
2100 static const i386_operand_type imm16 = OPERAND_TYPE_IMM16;
2101 static const i386_operand_type imm32 = OPERAND_TYPE_IMM32;
2102 static const i386_operand_type imm32s = OPERAND_TYPE_IMM32S;
2103 static const i386_operand_type imm64 = OPERAND_TYPE_IMM64;
2104 static const i386_operand_type imm16_32 = OPERAND_TYPE_IMM16_32;
2105 static const i386_operand_type imm16_32s = OPERAND_TYPE_IMM16_32S;
2106 static const i386_operand_type imm16_32_32s = OPERAND_TYPE_IMM16_32_32S;
2107
2108 enum operand_type
2109 {
2110   reg,
2111   imm,
2112   disp,
2113   anymem
2114 };
2115
2116 static INLINE int
2117 operand_type_check (i386_operand_type t, enum operand_type c)
2118 {
2119   switch (c)
2120     {
2121     case reg:
2122       return t.bitfield.class == Reg;
2123
2124     case imm:
2125       return (t.bitfield.imm8
2126               || t.bitfield.imm8s
2127               || t.bitfield.imm16
2128               || t.bitfield.imm32
2129               || t.bitfield.imm32s
2130               || t.bitfield.imm64);
2131
2132     case disp:
2133       return (t.bitfield.disp8
2134               || t.bitfield.disp16
2135               || t.bitfield.disp32
2136               || t.bitfield.disp32s
2137               || t.bitfield.disp64);
2138
2139     case anymem:
2140       return (t.bitfield.disp8
2141               || t.bitfield.disp16
2142               || t.bitfield.disp32
2143               || t.bitfield.disp32s
2144               || t.bitfield.disp64
2145               || t.bitfield.baseindex);
2146
2147     default:
2148       abort ();
2149     }
2150
2151   return 0;
2152 }
2153
2154 /* Return 1 if there is no conflict in 8bit/16bit/32bit/64bit/80bit size
2155    between operand GIVEN and opeand WANTED for instruction template T.  */
2156
2157 static INLINE int
2158 match_operand_size (const insn_template *t, unsigned int wanted,
2159                     unsigned int given)
2160 {
2161   return !((i.types[given].bitfield.byte
2162             && !t->operand_types[wanted].bitfield.byte)
2163            || (i.types[given].bitfield.word
2164                && !t->operand_types[wanted].bitfield.word)
2165            || (i.types[given].bitfield.dword
2166                && !t->operand_types[wanted].bitfield.dword)
2167            || (i.types[given].bitfield.qword
2168                && !t->operand_types[wanted].bitfield.qword)
2169            || (i.types[given].bitfield.tbyte
2170                && !t->operand_types[wanted].bitfield.tbyte));
2171 }
2172
2173 /* Return 1 if there is no conflict in SIMD register between operand
2174    GIVEN and opeand WANTED for instruction template T.  */
2175
2176 static INLINE int
2177 match_simd_size (const insn_template *t, unsigned int wanted,
2178                  unsigned int given)
2179 {
2180   return !((i.types[given].bitfield.xmmword
2181             && !t->operand_types[wanted].bitfield.xmmword)
2182            || (i.types[given].bitfield.ymmword
2183                && !t->operand_types[wanted].bitfield.ymmword)
2184            || (i.types[given].bitfield.zmmword
2185                && !t->operand_types[wanted].bitfield.zmmword)
2186            || (i.types[given].bitfield.tmmword
2187                && !t->operand_types[wanted].bitfield.tmmword));
2188 }
2189
2190 /* Return 1 if there is no conflict in any size between operand GIVEN
2191    and opeand WANTED for instruction template T.  */
2192
2193 static INLINE int
2194 match_mem_size (const insn_template *t, unsigned int wanted,
2195                 unsigned int given)
2196 {
2197   return (match_operand_size (t, wanted, given)
2198           && !((i.types[given].bitfield.unspecified
2199                 && !i.broadcast
2200                 && !t->operand_types[wanted].bitfield.unspecified)
2201                || (i.types[given].bitfield.fword
2202                    && !t->operand_types[wanted].bitfield.fword)
2203                /* For scalar opcode templates to allow register and memory
2204                   operands at the same time, some special casing is needed
2205                   here.  Also for v{,p}broadcast*, {,v}pmov{s,z}*, and
2206                   down-conversion vpmov*.  */
2207                || ((t->operand_types[wanted].bitfield.class == RegSIMD
2208                     && t->operand_types[wanted].bitfield.byte
2209                        + t->operand_types[wanted].bitfield.word
2210                        + t->operand_types[wanted].bitfield.dword
2211                        + t->operand_types[wanted].bitfield.qword
2212                        > !!t->opcode_modifier.broadcast)
2213                    ? (i.types[given].bitfield.xmmword
2214                       || i.types[given].bitfield.ymmword
2215                       || i.types[given].bitfield.zmmword)
2216                    : !match_simd_size(t, wanted, given))));
2217 }
2218
2219 /* Return value has MATCH_STRAIGHT set if there is no size conflict on any
2220    operands for instruction template T, and it has MATCH_REVERSE set if there
2221    is no size conflict on any operands for the template with operands reversed
2222    (and the template allows for reversing in the first place).  */
2223
2224 #define MATCH_STRAIGHT 1
2225 #define MATCH_REVERSE  2
2226
2227 static INLINE unsigned int
2228 operand_size_match (const insn_template *t)
2229 {
2230   unsigned int j, match = MATCH_STRAIGHT;
2231
2232   /* Don't check non-absolute jump instructions.  */
2233   if (t->opcode_modifier.jump
2234       && t->opcode_modifier.jump != JUMP_ABSOLUTE)
2235     return match;
2236
2237   /* Check memory and accumulator operand size.  */
2238   for (j = 0; j < i.operands; j++)
2239     {
2240       if (i.types[j].bitfield.class != Reg
2241           && i.types[j].bitfield.class != RegSIMD
2242           && t->opcode_modifier.anysize)
2243         continue;
2244
2245       if (t->operand_types[j].bitfield.class == Reg
2246           && !match_operand_size (t, j, j))
2247         {
2248           match = 0;
2249           break;
2250         }
2251
2252       if (t->operand_types[j].bitfield.class == RegSIMD
2253           && !match_simd_size (t, j, j))
2254         {
2255           match = 0;
2256           break;
2257         }
2258
2259       if (t->operand_types[j].bitfield.instance == Accum
2260           && (!match_operand_size (t, j, j) || !match_simd_size (t, j, j)))
2261         {
2262           match = 0;
2263           break;
2264         }
2265
2266       if ((i.flags[j] & Operand_Mem) && !match_mem_size (t, j, j))
2267         {
2268           match = 0;
2269           break;
2270         }
2271     }
2272
2273   if (!t->opcode_modifier.d)
2274     {
2275     mismatch:
2276       if (!match)
2277         i.error = operand_size_mismatch;
2278       return match;
2279     }
2280
2281   /* Check reverse.  */
2282   gas_assert (i.operands >= 2 && i.operands <= 3);
2283
2284   for (j = 0; j < i.operands; j++)
2285     {
2286       unsigned int given = i.operands - j - 1;
2287
2288       if (t->operand_types[j].bitfield.class == Reg
2289           && !match_operand_size (t, j, given))
2290         goto mismatch;
2291
2292       if (t->operand_types[j].bitfield.class == RegSIMD
2293           && !match_simd_size (t, j, given))
2294         goto mismatch;
2295
2296       if (t->operand_types[j].bitfield.instance == Accum
2297           && (!match_operand_size (t, j, given)
2298               || !match_simd_size (t, j, given)))
2299         goto mismatch;
2300
2301       if ((i.flags[given] & Operand_Mem) && !match_mem_size (t, j, given))
2302         goto mismatch;
2303     }
2304
2305   return match | MATCH_REVERSE;
2306 }
2307
2308 static INLINE int
2309 operand_type_match (i386_operand_type overlap,
2310                     i386_operand_type given)
2311 {
2312   i386_operand_type temp = overlap;
2313
2314   temp.bitfield.unspecified = 0;
2315   temp.bitfield.byte = 0;
2316   temp.bitfield.word = 0;
2317   temp.bitfield.dword = 0;
2318   temp.bitfield.fword = 0;
2319   temp.bitfield.qword = 0;
2320   temp.bitfield.tbyte = 0;
2321   temp.bitfield.xmmword = 0;
2322   temp.bitfield.ymmword = 0;
2323   temp.bitfield.zmmword = 0;
2324   temp.bitfield.tmmword = 0;
2325   if (operand_type_all_zero (&temp))
2326     goto mismatch;
2327
2328   if (given.bitfield.baseindex == overlap.bitfield.baseindex)
2329     return 1;
2330
2331  mismatch:
2332   i.error = operand_type_mismatch;
2333   return 0;
2334 }
2335
2336 /* If given types g0 and g1 are registers they must be of the same type
2337    unless the expected operand type register overlap is null.
2338    Some Intel syntax memory operand size checking also happens here.  */
2339
2340 static INLINE int
2341 operand_type_register_match (i386_operand_type g0,
2342                              i386_operand_type t0,
2343                              i386_operand_type g1,
2344                              i386_operand_type t1)
2345 {
2346   if (g0.bitfield.class != Reg
2347       && g0.bitfield.class != RegSIMD
2348       && (!operand_type_check (g0, anymem)
2349           || g0.bitfield.unspecified
2350           || (t0.bitfield.class != Reg
2351               && t0.bitfield.class != RegSIMD)))
2352     return 1;
2353
2354   if (g1.bitfield.class != Reg
2355       && g1.bitfield.class != RegSIMD
2356       && (!operand_type_check (g1, anymem)
2357           || g1.bitfield.unspecified
2358           || (t1.bitfield.class != Reg
2359               && t1.bitfield.class != RegSIMD)))
2360     return 1;
2361
2362   if (g0.bitfield.byte == g1.bitfield.byte
2363       && g0.bitfield.word == g1.bitfield.word
2364       && g0.bitfield.dword == g1.bitfield.dword
2365       && g0.bitfield.qword == g1.bitfield.qword
2366       && g0.bitfield.xmmword == g1.bitfield.xmmword
2367       && g0.bitfield.ymmword == g1.bitfield.ymmword
2368       && g0.bitfield.zmmword == g1.bitfield.zmmword)
2369     return 1;
2370
2371   if (!(t0.bitfield.byte & t1.bitfield.byte)
2372       && !(t0.bitfield.word & t1.bitfield.word)
2373       && !(t0.bitfield.dword & t1.bitfield.dword)
2374       && !(t0.bitfield.qword & t1.bitfield.qword)
2375       && !(t0.bitfield.xmmword & t1.bitfield.xmmword)
2376       && !(t0.bitfield.ymmword & t1.bitfield.ymmword)
2377       && !(t0.bitfield.zmmword & t1.bitfield.zmmword))
2378     return 1;
2379
2380   i.error = register_type_mismatch;
2381
2382   return 0;
2383 }
2384
2385 static INLINE unsigned int
2386 register_number (const reg_entry *r)
2387 {
2388   unsigned int nr = r->reg_num;
2389
2390   if (r->reg_flags & RegRex)
2391     nr += 8;
2392
2393   if (r->reg_flags & RegVRex)
2394     nr += 16;
2395
2396   return nr;
2397 }
2398
2399 static INLINE unsigned int
2400 mode_from_disp_size (i386_operand_type t)
2401 {
2402   if (t.bitfield.disp8)
2403     return 1;
2404   else if (t.bitfield.disp16
2405            || t.bitfield.disp32
2406            || t.bitfield.disp32s)
2407     return 2;
2408   else
2409     return 0;
2410 }
2411
2412 static INLINE int
2413 fits_in_signed_byte (addressT num)
2414 {
2415   return num + 0x80 <= 0xff;
2416 }
2417
2418 static INLINE int
2419 fits_in_unsigned_byte (addressT num)
2420 {
2421   return num <= 0xff;
2422 }
2423
2424 static INLINE int
2425 fits_in_unsigned_word (addressT num)
2426 {
2427   return num <= 0xffff;
2428 }
2429
2430 static INLINE int
2431 fits_in_signed_word (addressT num)
2432 {
2433   return num + 0x8000 <= 0xffff;
2434 }
2435
2436 static INLINE int
2437 fits_in_signed_long (addressT num ATTRIBUTE_UNUSED)
2438 {
2439 #ifndef BFD64
2440   return 1;
2441 #else
2442   return num + 0x80000000 <= 0xffffffff;
2443 #endif
2444 }                               /* fits_in_signed_long() */
2445
2446 static INLINE int
2447 fits_in_unsigned_long (addressT num ATTRIBUTE_UNUSED)
2448 {
2449 #ifndef BFD64
2450   return 1;
2451 #else
2452   return num <= 0xffffffff;
2453 #endif
2454 }                               /* fits_in_unsigned_long() */
2455
2456 static INLINE int
2457 fits_in_disp8 (offsetT num)
2458 {
2459   int shift = i.memshift;
2460   unsigned int mask;
2461
2462   if (shift == -1)
2463     abort ();
2464
2465   mask = (1 << shift) - 1;
2466
2467   /* Return 0 if NUM isn't properly aligned.  */
2468   if ((num & mask))
2469     return 0;
2470
2471   /* Check if NUM will fit in 8bit after shift.  */
2472   return fits_in_signed_byte (num >> shift);
2473 }
2474
2475 static INLINE int
2476 fits_in_imm4 (offsetT num)
2477 {
2478   return (num & 0xf) == num;
2479 }
2480
2481 static i386_operand_type
2482 smallest_imm_type (offsetT num)
2483 {
2484   i386_operand_type t;
2485
2486   operand_type_set (&t, 0);
2487   t.bitfield.imm64 = 1;
2488
2489   if (cpu_arch_tune != PROCESSOR_I486 && num == 1)
2490     {
2491       /* This code is disabled on the 486 because all the Imm1 forms
2492          in the opcode table are slower on the i486.  They're the
2493          versions with the implicitly specified single-position
2494          displacement, which has another syntax if you really want to
2495          use that form.  */
2496       t.bitfield.imm1 = 1;
2497       t.bitfield.imm8 = 1;
2498       t.bitfield.imm8s = 1;
2499       t.bitfield.imm16 = 1;
2500       t.bitfield.imm32 = 1;
2501       t.bitfield.imm32s = 1;
2502     }
2503   else if (fits_in_signed_byte (num))
2504     {
2505       t.bitfield.imm8 = 1;
2506       t.bitfield.imm8s = 1;
2507       t.bitfield.imm16 = 1;
2508       t.bitfield.imm32 = 1;
2509       t.bitfield.imm32s = 1;
2510     }
2511   else if (fits_in_unsigned_byte (num))
2512     {
2513       t.bitfield.imm8 = 1;
2514       t.bitfield.imm16 = 1;
2515       t.bitfield.imm32 = 1;
2516       t.bitfield.imm32s = 1;
2517     }
2518   else if (fits_in_signed_word (num) || fits_in_unsigned_word (num))
2519     {
2520       t.bitfield.imm16 = 1;
2521       t.bitfield.imm32 = 1;
2522       t.bitfield.imm32s = 1;
2523     }
2524   else if (fits_in_signed_long (num))
2525     {
2526       t.bitfield.imm32 = 1;
2527       t.bitfield.imm32s = 1;
2528     }
2529   else if (fits_in_unsigned_long (num))
2530     t.bitfield.imm32 = 1;
2531
2532   return t;
2533 }
2534
2535 static offsetT
2536 offset_in_range (offsetT val, int size)
2537 {
2538   addressT mask;
2539
2540   switch (size)
2541     {
2542     case 1: mask = ((addressT) 1 <<  8) - 1; break;
2543     case 2: mask = ((addressT) 1 << 16) - 1; break;
2544     case 4: mask = ((addressT) 2 << 31) - 1; break;
2545 #ifdef BFD64
2546     case 8: mask = ((addressT) 2 << 63) - 1; break;
2547 #endif
2548     default: abort ();
2549     }
2550
2551   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
2552     {
2553       char buf1[40], buf2[40];
2554
2555       sprint_value (buf1, val);
2556       sprint_value (buf2, val & mask);
2557       as_warn (_("%s shortened to %s"), buf1, buf2);
2558     }
2559   return val & mask;
2560 }
2561
2562 enum PREFIX_GROUP
2563 {
2564   PREFIX_EXIST = 0,
2565   PREFIX_LOCK,
2566   PREFIX_REP,
2567   PREFIX_DS,
2568   PREFIX_OTHER
2569 };
2570
2571 /* Returns
2572    a. PREFIX_EXIST if attempting to add a prefix where one from the
2573    same class already exists.
2574    b. PREFIX_LOCK if lock prefix is added.
2575    c. PREFIX_REP if rep/repne prefix is added.
2576    d. PREFIX_DS if ds prefix is added.
2577    e. PREFIX_OTHER if other prefix is added.
2578  */
2579
2580 static enum PREFIX_GROUP
2581 add_prefix (unsigned int prefix)
2582 {
2583   enum PREFIX_GROUP ret = PREFIX_OTHER;
2584   unsigned int q;
2585
2586   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
2587       && flag_code == CODE_64BIT)
2588     {
2589       if ((i.prefix[REX_PREFIX] & prefix & REX_W)
2590           || (i.prefix[REX_PREFIX] & prefix & REX_R)
2591           || (i.prefix[REX_PREFIX] & prefix & REX_X)
2592           || (i.prefix[REX_PREFIX] & prefix & REX_B))
2593         ret = PREFIX_EXIST;
2594       q = REX_PREFIX;
2595     }
2596   else
2597     {
2598       switch (prefix)
2599         {
2600         default:
2601           abort ();
2602
2603         case DS_PREFIX_OPCODE:
2604           ret = PREFIX_DS;
2605           /* Fall through.  */
2606         case CS_PREFIX_OPCODE:
2607         case ES_PREFIX_OPCODE:
2608         case FS_PREFIX_OPCODE:
2609         case GS_PREFIX_OPCODE:
2610         case SS_PREFIX_OPCODE:
2611           q = SEG_PREFIX;
2612           break;
2613
2614         case REPNE_PREFIX_OPCODE:
2615         case REPE_PREFIX_OPCODE:
2616           q = REP_PREFIX;
2617           ret = PREFIX_REP;
2618           break;
2619
2620         case LOCK_PREFIX_OPCODE:
2621           q = LOCK_PREFIX;
2622           ret = PREFIX_LOCK;
2623           break;
2624
2625         case FWAIT_OPCODE:
2626           q = WAIT_PREFIX;
2627           break;
2628
2629         case ADDR_PREFIX_OPCODE:
2630           q = ADDR_PREFIX;
2631           break;
2632
2633         case DATA_PREFIX_OPCODE:
2634           q = DATA_PREFIX;
2635           break;
2636         }
2637       if (i.prefix[q] != 0)
2638         ret = PREFIX_EXIST;
2639     }
2640
2641   if (ret)
2642     {
2643       if (!i.prefix[q])
2644         ++i.prefixes;
2645       i.prefix[q] |= prefix;
2646     }
2647   else
2648     as_bad (_("same type of prefix used twice"));
2649
2650   return ret;
2651 }
2652
2653 static void
2654 update_code_flag (int value, int check)
2655 {
2656   PRINTF_LIKE ((*as_error));
2657
2658   flag_code = (enum flag_code) value;
2659   if (flag_code == CODE_64BIT)
2660     {
2661       cpu_arch_flags.bitfield.cpu64 = 1;
2662       cpu_arch_flags.bitfield.cpuno64 = 0;
2663     }
2664   else
2665     {
2666       cpu_arch_flags.bitfield.cpu64 = 0;
2667       cpu_arch_flags.bitfield.cpuno64 = 1;
2668     }
2669   if (value == CODE_64BIT && !cpu_arch_flags.bitfield.cpulm )
2670     {
2671       if (check)
2672         as_error = as_fatal;
2673       else
2674         as_error = as_bad;
2675       (*as_error) (_("64bit mode not supported on `%s'."),
2676                    cpu_arch_name ? cpu_arch_name : default_arch);
2677     }
2678   if (value == CODE_32BIT && !cpu_arch_flags.bitfield.cpui386)
2679     {
2680       if (check)
2681         as_error = as_fatal;
2682       else
2683         as_error = as_bad;
2684       (*as_error) (_("32bit mode not supported on `%s'."),
2685                    cpu_arch_name ? cpu_arch_name : default_arch);
2686     }
2687   stackop_size = '\0';
2688 }
2689
2690 static void
2691 set_code_flag (int value)
2692 {
2693   update_code_flag (value, 0);
2694 }
2695
2696 static void
2697 set_16bit_gcc_code_flag (int new_code_flag)
2698 {
2699   flag_code = (enum flag_code) new_code_flag;
2700   if (flag_code != CODE_16BIT)
2701     abort ();
2702   cpu_arch_flags.bitfield.cpu64 = 0;
2703   cpu_arch_flags.bitfield.cpuno64 = 1;
2704   stackop_size = LONG_MNEM_SUFFIX;
2705 }
2706
2707 static void
2708 set_intel_syntax (int syntax_flag)
2709 {
2710   /* Find out if register prefixing is specified.  */
2711   int ask_naked_reg = 0;
2712
2713   SKIP_WHITESPACE ();
2714   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2715     {
2716       char *string;
2717       int e = get_symbol_name (&string);
2718
2719       if (strcmp (string, "prefix") == 0)
2720         ask_naked_reg = 1;
2721       else if (strcmp (string, "noprefix") == 0)
2722         ask_naked_reg = -1;
2723       else
2724         as_bad (_("bad argument to syntax directive."));
2725       (void) restore_line_pointer (e);
2726     }
2727   demand_empty_rest_of_line ();
2728
2729   intel_syntax = syntax_flag;
2730
2731   if (ask_naked_reg == 0)
2732     allow_naked_reg = (intel_syntax
2733                        && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
2734   else
2735     allow_naked_reg = (ask_naked_reg < 0);
2736
2737   expr_set_rank (O_full_ptr, syntax_flag ? 10 : 0);
2738
2739   identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
2740   identifier_chars['$'] = intel_syntax ? '$' : 0;
2741   register_prefix = allow_naked_reg ? "" : "%";
2742 }
2743
2744 static void
2745 set_intel_mnemonic (int mnemonic_flag)
2746 {
2747   intel_mnemonic = mnemonic_flag;
2748 }
2749
2750 static void
2751 set_allow_index_reg (int flag)
2752 {
2753   allow_index_reg = flag;
2754 }
2755
2756 static void
2757 set_check (int what)
2758 {
2759   enum check_kind *kind;
2760   const char *str;
2761
2762   if (what)
2763     {
2764       kind = &operand_check;
2765       str = "operand";
2766     }
2767   else
2768     {
2769       kind = &sse_check;
2770       str = "sse";
2771     }
2772
2773   SKIP_WHITESPACE ();
2774
2775   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2776     {
2777       char *string;
2778       int e = get_symbol_name (&string);
2779
2780       if (strcmp (string, "none") == 0)
2781         *kind = check_none;
2782       else if (strcmp (string, "warning") == 0)
2783         *kind = check_warning;
2784       else if (strcmp (string, "error") == 0)
2785         *kind = check_error;
2786       else
2787         as_bad (_("bad argument to %s_check directive."), str);
2788       (void) restore_line_pointer (e);
2789     }
2790   else
2791     as_bad (_("missing argument for %s_check directive"), str);
2792
2793   demand_empty_rest_of_line ();
2794 }
2795
2796 static void
2797 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED,
2798                            i386_cpu_flags new_flag ATTRIBUTE_UNUSED)
2799 {
2800 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2801   static const char *arch;
2802
2803   /* Intel LIOM is only supported on ELF.  */
2804   if (!IS_ELF)
2805     return;
2806
2807   if (!arch)
2808     {
2809       /* Use cpu_arch_name if it is set in md_parse_option.  Otherwise
2810          use default_arch.  */
2811       arch = cpu_arch_name;
2812       if (!arch)
2813         arch = default_arch;
2814     }
2815
2816   /* If we are targeting Intel MCU, we must enable it.  */
2817   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_IAMCU
2818       || new_flag.bitfield.cpuiamcu)
2819     return;
2820
2821   /* If we are targeting Intel L1OM, we must enable it.  */
2822   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_L1OM
2823       || new_flag.bitfield.cpul1om)
2824     return;
2825
2826   /* If we are targeting Intel K1OM, we must enable it.  */
2827   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_K1OM
2828       || new_flag.bitfield.cpuk1om)
2829     return;
2830
2831   as_bad (_("`%s' is not supported on `%s'"), name, arch);
2832 #endif
2833 }
2834
2835 static void
2836 set_cpu_arch (int dummy ATTRIBUTE_UNUSED)
2837 {
2838   SKIP_WHITESPACE ();
2839
2840   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2841     {
2842       char *string;
2843       int e = get_symbol_name (&string);
2844       unsigned int j;
2845       i386_cpu_flags flags;
2846
2847       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
2848         {
2849           if (strcmp (string, cpu_arch[j].name) == 0)
2850             {
2851               check_cpu_arch_compatible (string, cpu_arch[j].flags);
2852
2853               if (*string != '.')
2854                 {
2855                   cpu_arch_name = cpu_arch[j].name;
2856                   cpu_sub_arch_name = NULL;
2857                   cpu_arch_flags = cpu_arch[j].flags;
2858                   if (flag_code == CODE_64BIT)
2859                     {
2860                       cpu_arch_flags.bitfield.cpu64 = 1;
2861                       cpu_arch_flags.bitfield.cpuno64 = 0;
2862                     }
2863                   else
2864                     {
2865                       cpu_arch_flags.bitfield.cpu64 = 0;
2866                       cpu_arch_flags.bitfield.cpuno64 = 1;
2867                     }
2868                   cpu_arch_isa = cpu_arch[j].type;
2869                   cpu_arch_isa_flags = cpu_arch[j].flags;
2870                   if (!cpu_arch_tune_set)
2871                     {
2872                       cpu_arch_tune = cpu_arch_isa;
2873                       cpu_arch_tune_flags = cpu_arch_isa_flags;
2874                     }
2875                   break;
2876                 }
2877
2878               flags = cpu_flags_or (cpu_arch_flags,
2879                                     cpu_arch[j].flags);
2880
2881               if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2882                 {
2883                   if (cpu_sub_arch_name)
2884                     {
2885                       char *name = cpu_sub_arch_name;
2886                       cpu_sub_arch_name = concat (name,
2887                                                   cpu_arch[j].name,
2888                                                   (const char *) NULL);
2889                       free (name);
2890                     }
2891                   else
2892                     cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
2893                   cpu_arch_flags = flags;
2894                   cpu_arch_isa_flags = flags;
2895                 }
2896               else
2897                 cpu_arch_isa_flags
2898                   = cpu_flags_or (cpu_arch_isa_flags,
2899                                   cpu_arch[j].flags);
2900               (void) restore_line_pointer (e);
2901               demand_empty_rest_of_line ();
2902               return;
2903             }
2904         }
2905
2906       if (*string == '.' && j >= ARRAY_SIZE (cpu_arch))
2907         {
2908           /* Disable an ISA extension.  */
2909           for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
2910             if (strcmp (string + 1, cpu_noarch [j].name) == 0)
2911               {
2912                 flags = cpu_flags_and_not (cpu_arch_flags,
2913                                            cpu_noarch[j].flags);
2914                 if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2915                   {
2916                     if (cpu_sub_arch_name)
2917                       {
2918                         char *name = cpu_sub_arch_name;
2919                         cpu_sub_arch_name = concat (name, string,
2920                                                     (const char *) NULL);
2921                         free (name);
2922                       }
2923                     else
2924                       cpu_sub_arch_name = xstrdup (string);
2925                     cpu_arch_flags = flags;
2926                     cpu_arch_isa_flags = flags;
2927                   }
2928                 (void) restore_line_pointer (e);
2929                 demand_empty_rest_of_line ();
2930                 return;
2931               }
2932
2933           j = ARRAY_SIZE (cpu_arch);
2934         }
2935
2936       if (j >= ARRAY_SIZE (cpu_arch))
2937         as_bad (_("no such architecture: `%s'"), string);
2938
2939       *input_line_pointer = e;
2940     }
2941   else
2942     as_bad (_("missing cpu architecture"));
2943
2944   no_cond_jump_promotion = 0;
2945   if (*input_line_pointer == ','
2946       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
2947     {
2948       char *string;
2949       char e;
2950
2951       ++input_line_pointer;
2952       e = get_symbol_name (&string);
2953
2954       if (strcmp (string, "nojumps") == 0)
2955         no_cond_jump_promotion = 1;
2956       else if (strcmp (string, "jumps") == 0)
2957         ;
2958       else
2959         as_bad (_("no such architecture modifier: `%s'"), string);
2960
2961       (void) restore_line_pointer (e);
2962     }
2963
2964   demand_empty_rest_of_line ();
2965 }
2966
2967 enum bfd_architecture
2968 i386_arch (void)
2969 {
2970   if (cpu_arch_isa == PROCESSOR_L1OM)
2971     {
2972       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2973           || flag_code != CODE_64BIT)
2974         as_fatal (_("Intel L1OM is 64bit ELF only"));
2975       return bfd_arch_l1om;
2976     }
2977   else if (cpu_arch_isa == PROCESSOR_K1OM)
2978     {
2979       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2980           || flag_code != CODE_64BIT)
2981         as_fatal (_("Intel K1OM is 64bit ELF only"));
2982       return bfd_arch_k1om;
2983     }
2984   else if (cpu_arch_isa == PROCESSOR_IAMCU)
2985     {
2986       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2987           || flag_code == CODE_64BIT)
2988         as_fatal (_("Intel MCU is 32bit ELF only"));
2989       return bfd_arch_iamcu;
2990     }
2991   else
2992     return bfd_arch_i386;
2993 }
2994
2995 unsigned long
2996 i386_mach (void)
2997 {
2998   if (!strncmp (default_arch, "x86_64", 6))
2999     {
3000       if (cpu_arch_isa == PROCESSOR_L1OM)
3001         {
3002           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
3003               || default_arch[6] != '\0')
3004             as_fatal (_("Intel L1OM is 64bit ELF only"));
3005           return bfd_mach_l1om;
3006         }
3007       else if (cpu_arch_isa == PROCESSOR_K1OM)
3008         {
3009           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
3010               || default_arch[6] != '\0')
3011             as_fatal (_("Intel K1OM is 64bit ELF only"));
3012           return bfd_mach_k1om;
3013         }
3014       else if (default_arch[6] == '\0')
3015         return bfd_mach_x86_64;
3016       else
3017         return bfd_mach_x64_32;
3018     }
3019   else if (!strcmp (default_arch, "i386")
3020            || !strcmp (default_arch, "iamcu"))
3021     {
3022       if (cpu_arch_isa == PROCESSOR_IAMCU)
3023         {
3024           if (OUTPUT_FLAVOR != bfd_target_elf_flavour)
3025             as_fatal (_("Intel MCU is 32bit ELF only"));
3026           return bfd_mach_i386_iamcu;
3027         }
3028       else
3029         return bfd_mach_i386_i386;
3030     }
3031   else
3032     as_fatal (_("unknown architecture"));
3033 }
3034 \f
3035 void
3036 md_begin (void)
3037 {
3038   /* Support pseudo prefixes like {disp32}.  */
3039   lex_type ['{'] = LEX_BEGIN_NAME;
3040
3041   /* Initialize op_hash hash table.  */
3042   op_hash = str_htab_create ();
3043
3044   {
3045     const insn_template *optab;
3046     templates *core_optab;
3047
3048     /* Setup for loop.  */
3049     optab = i386_optab;
3050     core_optab = XNEW (templates);
3051     core_optab->start = optab;
3052
3053     while (1)
3054       {
3055         ++optab;
3056         if (optab->name == NULL
3057             || strcmp (optab->name, (optab - 1)->name) != 0)
3058           {
3059             /* different name --> ship out current template list;
3060                add to hash table; & begin anew.  */
3061             core_optab->end = optab;
3062             if (str_hash_insert (op_hash, (optab - 1)->name, core_optab, 0))
3063               as_fatal (_("duplicate %s"), (optab - 1)->name);
3064
3065             if (optab->name == NULL)
3066               break;
3067             core_optab = XNEW (templates);
3068             core_optab->start = optab;
3069           }
3070       }
3071   }
3072
3073   /* Initialize reg_hash hash table.  */
3074   reg_hash = str_htab_create ();
3075   {
3076     const reg_entry *regtab;
3077     unsigned int regtab_size = i386_regtab_size;
3078
3079     for (regtab = i386_regtab; regtab_size--; regtab++)
3080       if (str_hash_insert (reg_hash, regtab->reg_name, regtab, 0) != NULL)
3081         as_fatal (_("duplicate %s"), regtab->reg_name);
3082   }
3083
3084   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
3085   {
3086     int c;
3087     char *p;
3088
3089     for (c = 0; c < 256; c++)
3090       {
3091         if (ISDIGIT (c))
3092           {
3093             digit_chars[c] = c;
3094             mnemonic_chars[c] = c;
3095             register_chars[c] = c;
3096             operand_chars[c] = c;
3097           }
3098         else if (ISLOWER (c))
3099           {
3100             mnemonic_chars[c] = c;
3101             register_chars[c] = c;
3102             operand_chars[c] = c;
3103           }
3104         else if (ISUPPER (c))
3105           {
3106             mnemonic_chars[c] = TOLOWER (c);
3107             register_chars[c] = mnemonic_chars[c];
3108             operand_chars[c] = c;
3109           }
3110         else if (c == '{' || c == '}')
3111           {
3112             mnemonic_chars[c] = c;
3113             operand_chars[c] = c;
3114           }
3115 #ifdef SVR4_COMMENT_CHARS
3116         else if (c == '\\' && strchr (i386_comment_chars, '/'))
3117           operand_chars[c] = c;
3118 #endif
3119
3120         if (ISALPHA (c) || ISDIGIT (c))
3121           identifier_chars[c] = c;
3122         else if (c >= 128)
3123           {
3124             identifier_chars[c] = c;
3125             operand_chars[c] = c;
3126           }
3127       }
3128
3129 #ifdef LEX_AT
3130     identifier_chars['@'] = '@';
3131 #endif
3132 #ifdef LEX_QM
3133     identifier_chars['?'] = '?';
3134     operand_chars['?'] = '?';
3135 #endif
3136     digit_chars['-'] = '-';
3137     mnemonic_chars['_'] = '_';
3138     mnemonic_chars['-'] = '-';
3139     mnemonic_chars['.'] = '.';
3140     identifier_chars['_'] = '_';
3141     identifier_chars['.'] = '.';
3142
3143     for (p = operand_special_chars; *p != '\0'; p++)
3144       operand_chars[(unsigned char) *p] = *p;
3145   }
3146
3147   if (flag_code == CODE_64BIT)
3148     {
3149 #if defined (OBJ_COFF) && defined (TE_PE)
3150       x86_dwarf2_return_column = (OUTPUT_FLAVOR == bfd_target_coff_flavour
3151                                   ? 32 : 16);
3152 #else
3153       x86_dwarf2_return_column = 16;
3154 #endif
3155       x86_cie_data_alignment = -8;
3156     }
3157   else
3158     {
3159       x86_dwarf2_return_column = 8;
3160       x86_cie_data_alignment = -4;
3161     }
3162
3163   /* NB: FUSED_JCC_PADDING frag must have sufficient room so that it
3164      can be turned into BRANCH_PREFIX frag.  */
3165   if (align_branch_prefix_size > MAX_FUSED_JCC_PADDING_SIZE)
3166     abort ();
3167 }
3168
3169 void
3170 i386_print_statistics (FILE *file)
3171 {
3172   htab_print_statistics (file, "i386 opcode", op_hash);
3173   htab_print_statistics (file, "i386 register", reg_hash);
3174 }
3175 \f
3176 #ifdef DEBUG386
3177
3178 /* Debugging routines for md_assemble.  */
3179 static void pte (insn_template *);
3180 static void pt (i386_operand_type);
3181 static void pe (expressionS *);
3182 static void ps (symbolS *);
3183
3184 static void
3185 pi (const char *line, i386_insn *x)
3186 {
3187   unsigned int j;
3188
3189   fprintf (stdout, "%s: template ", line);
3190   pte (&x->tm);
3191   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
3192            x->base_reg ? x->base_reg->reg_name : "none",
3193            x->index_reg ? x->index_reg->reg_name : "none",
3194            x->log2_scale_factor);
3195   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
3196            x->rm.mode, x->rm.reg, x->rm.regmem);
3197   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
3198            x->sib.base, x->sib.index, x->sib.scale);
3199   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
3200            (x->rex & REX_W) != 0,
3201            (x->rex & REX_R) != 0,
3202            (x->rex & REX_X) != 0,
3203            (x->rex & REX_B) != 0);
3204   for (j = 0; j < x->operands; j++)
3205     {
3206       fprintf (stdout, "    #%d:  ", j + 1);
3207       pt (x->types[j]);
3208       fprintf (stdout, "\n");
3209       if (x->types[j].bitfield.class == Reg
3210           || x->types[j].bitfield.class == RegMMX
3211           || x->types[j].bitfield.class == RegSIMD
3212           || x->types[j].bitfield.class == RegMask
3213           || x->types[j].bitfield.class == SReg
3214           || x->types[j].bitfield.class == RegCR
3215           || x->types[j].bitfield.class == RegDR
3216           || x->types[j].bitfield.class == RegTR
3217           || x->types[j].bitfield.class == RegBND)
3218         fprintf (stdout, "%s\n", x->op[j].regs->reg_name);
3219       if (operand_type_check (x->types[j], imm))
3220         pe (x->op[j].imms);
3221       if (operand_type_check (x->types[j], disp))
3222         pe (x->op[j].disps);
3223     }
3224 }
3225
3226 static void
3227 pte (insn_template *t)
3228 {
3229   unsigned int j;
3230   fprintf (stdout, " %d operands ", t->operands);
3231   fprintf (stdout, "opcode %x ", t->base_opcode);
3232   if (t->extension_opcode != None)
3233     fprintf (stdout, "ext %x ", t->extension_opcode);
3234   if (t->opcode_modifier.d)
3235     fprintf (stdout, "D");
3236   if (t->opcode_modifier.w)
3237     fprintf (stdout, "W");
3238   fprintf (stdout, "\n");
3239   for (j = 0; j < t->operands; j++)
3240     {
3241       fprintf (stdout, "    #%d type ", j + 1);
3242       pt (t->operand_types[j]);
3243       fprintf (stdout, "\n");
3244     }
3245 }
3246
3247 static void
3248 pe (expressionS *e)
3249 {
3250   fprintf (stdout, "    operation     %d\n", e->X_op);
3251   fprintf (stdout, "    add_number    %ld (%lx)\n",
3252            (long) e->X_add_number, (long) e->X_add_number);
3253   if (e->X_add_symbol)
3254     {
3255       fprintf (stdout, "    add_symbol    ");
3256       ps (e->X_add_symbol);
3257       fprintf (stdout, "\n");
3258     }
3259   if (e->X_op_symbol)
3260     {
3261       fprintf (stdout, "    op_symbol    ");
3262       ps (e->X_op_symbol);
3263       fprintf (stdout, "\n");
3264     }
3265 }
3266
3267 static void
3268 ps (symbolS *s)
3269 {
3270   fprintf (stdout, "%s type %s%s",
3271            S_GET_NAME (s),
3272            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
3273            segment_name (S_GET_SEGMENT (s)));
3274 }
3275
3276 static struct type_name
3277   {
3278     i386_operand_type mask;
3279     const char *name;
3280   }
3281 const type_names[] =
3282 {
3283   { OPERAND_TYPE_REG8, "r8" },
3284   { OPERAND_TYPE_REG16, "r16" },
3285   { OPERAND_TYPE_REG32, "r32" },
3286   { OPERAND_TYPE_REG64, "r64" },
3287   { OPERAND_TYPE_ACC8, "acc8" },
3288   { OPERAND_TYPE_ACC16, "acc16" },
3289   { OPERAND_TYPE_ACC32, "acc32" },
3290   { OPERAND_TYPE_ACC64, "acc64" },
3291   { OPERAND_TYPE_IMM8, "i8" },
3292   { OPERAND_TYPE_IMM8, "i8s" },
3293   { OPERAND_TYPE_IMM16, "i16" },
3294   { OPERAND_TYPE_IMM32, "i32" },
3295   { OPERAND_TYPE_IMM32S, "i32s" },
3296   { OPERAND_TYPE_IMM64, "i64" },
3297   { OPERAND_TYPE_IMM1, "i1" },
3298   { OPERAND_TYPE_BASEINDEX, "BaseIndex" },
3299   { OPERAND_TYPE_DISP8, "d8" },
3300   { OPERAND_TYPE_DISP16, "d16" },
3301   { OPERAND_TYPE_DISP32, "d32" },
3302   { OPERAND_TYPE_DISP32S, "d32s" },
3303   { OPERAND_TYPE_DISP64, "d64" },
3304   { OPERAND_TYPE_INOUTPORTREG, "InOutPortReg" },
3305   { OPERAND_TYPE_SHIFTCOUNT, "ShiftCount" },
3306   { OPERAND_TYPE_CONTROL, "control reg" },
3307   { OPERAND_TYPE_TEST, "test reg" },
3308   { OPERAND_TYPE_DEBUG, "debug reg" },
3309   { OPERAND_TYPE_FLOATREG, "FReg" },
3310   { OPERAND_TYPE_FLOATACC, "FAcc" },
3311   { OPERAND_TYPE_SREG, "SReg" },
3312   { OPERAND_TYPE_REGMMX, "rMMX" },
3313   { OPERAND_TYPE_REGXMM, "rXMM" },
3314   { OPERAND_TYPE_REGYMM, "rYMM" },
3315   { OPERAND_TYPE_REGZMM, "rZMM" },
3316   { OPERAND_TYPE_REGTMM, "rTMM" },
3317   { OPERAND_TYPE_REGMASK, "Mask reg" },
3318 };
3319
3320 static void
3321 pt (i386_operand_type t)
3322 {
3323   unsigned int j;
3324   i386_operand_type a;
3325
3326   for (j = 0; j < ARRAY_SIZE (type_names); j++)
3327     {
3328       a = operand_type_and (t, type_names[j].mask);
3329       if (operand_type_equal (&a, &type_names[j].mask))
3330         fprintf (stdout, "%s, ",  type_names[j].name);
3331     }
3332   fflush (stdout);
3333 }
3334
3335 #endif /* DEBUG386 */
3336 \f
3337 static bfd_reloc_code_real_type
3338 reloc (unsigned int size,
3339        int pcrel,
3340        int sign,
3341        bfd_reloc_code_real_type other)
3342 {
3343   if (other != NO_RELOC)
3344     {
3345       reloc_howto_type *rel;
3346
3347       if (size == 8)
3348         switch (other)
3349           {
3350           case BFD_RELOC_X86_64_GOT32:
3351             return BFD_RELOC_X86_64_GOT64;
3352             break;
3353           case BFD_RELOC_X86_64_GOTPLT64:
3354             return BFD_RELOC_X86_64_GOTPLT64;
3355             break;
3356           case BFD_RELOC_X86_64_PLTOFF64:
3357             return BFD_RELOC_X86_64_PLTOFF64;
3358             break;
3359           case BFD_RELOC_X86_64_GOTPC32:
3360             other = BFD_RELOC_X86_64_GOTPC64;
3361             break;
3362           case BFD_RELOC_X86_64_GOTPCREL:
3363             other = BFD_RELOC_X86_64_GOTPCREL64;
3364             break;
3365           case BFD_RELOC_X86_64_TPOFF32:
3366             other = BFD_RELOC_X86_64_TPOFF64;
3367             break;
3368           case BFD_RELOC_X86_64_DTPOFF32:
3369             other = BFD_RELOC_X86_64_DTPOFF64;
3370             break;
3371           default:
3372             break;
3373           }
3374
3375 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3376       if (other == BFD_RELOC_SIZE32)
3377         {
3378           if (size == 8)
3379             other = BFD_RELOC_SIZE64;
3380           if (pcrel)
3381             {
3382               as_bad (_("there are no pc-relative size relocations"));
3383               return NO_RELOC;
3384             }
3385         }
3386 #endif
3387
3388       /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless.  */
3389       if (size == 4 && (flag_code != CODE_64BIT || disallow_64bit_reloc))
3390         sign = -1;
3391
3392       rel = bfd_reloc_type_lookup (stdoutput, other);
3393       if (!rel)
3394         as_bad (_("unknown relocation (%u)"), other);
3395       else if (size != bfd_get_reloc_size (rel))
3396         as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
3397                 bfd_get_reloc_size (rel),
3398                 size);
3399       else if (pcrel && !rel->pc_relative)
3400         as_bad (_("non-pc-relative relocation for pc-relative field"));
3401       else if ((rel->complain_on_overflow == complain_overflow_signed
3402                 && !sign)
3403                || (rel->complain_on_overflow == complain_overflow_unsigned
3404                    && sign > 0))
3405         as_bad (_("relocated field and relocation type differ in signedness"));
3406       else
3407         return other;
3408       return NO_RELOC;
3409     }
3410
3411   if (pcrel)
3412     {
3413       if (!sign)
3414         as_bad (_("there are no unsigned pc-relative relocations"));
3415       switch (size)
3416         {
3417         case 1: return BFD_RELOC_8_PCREL;
3418         case 2: return BFD_RELOC_16_PCREL;
3419         case 4: return BFD_RELOC_32_PCREL;
3420         case 8: return BFD_RELOC_64_PCREL;
3421         }
3422       as_bad (_("cannot do %u byte pc-relative relocation"), size);
3423     }
3424   else
3425     {
3426       if (sign > 0)
3427         switch (size)
3428           {
3429           case 4: return BFD_RELOC_X86_64_32S;
3430           }
3431       else
3432         switch (size)
3433           {
3434           case 1: return BFD_RELOC_8;
3435           case 2: return BFD_RELOC_16;
3436           case 4: return BFD_RELOC_32;
3437           case 8: return BFD_RELOC_64;
3438           }
3439       as_bad (_("cannot do %s %u byte relocation"),
3440               sign > 0 ? "signed" : "unsigned", size);
3441     }
3442
3443   return NO_RELOC;
3444 }
3445
3446 /* Here we decide which fixups can be adjusted to make them relative to
3447    the beginning of the section instead of the symbol.  Basically we need
3448    to make sure that the dynamic relocations are done correctly, so in
3449    some cases we force the original symbol to be used.  */
3450
3451 int
3452 tc_i386_fix_adjustable (fixS *fixP ATTRIBUTE_UNUSED)
3453 {
3454 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3455   if (!IS_ELF)
3456     return 1;
3457
3458   /* Don't adjust pc-relative references to merge sections in 64-bit
3459      mode.  */
3460   if (use_rela_relocations
3461       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
3462       && fixP->fx_pcrel)
3463     return 0;
3464
3465   /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
3466      and changed later by validate_fix.  */
3467   if (GOT_symbol && fixP->fx_subsy == GOT_symbol
3468       && fixP->fx_r_type == BFD_RELOC_32_PCREL)
3469     return 0;
3470
3471   /* Adjust_reloc_syms doesn't know about the GOT.  Need to keep symbol
3472      for size relocations.  */
3473   if (fixP->fx_r_type == BFD_RELOC_SIZE32
3474       || fixP->fx_r_type == BFD_RELOC_SIZE64
3475       || fixP->fx_r_type == BFD_RELOC_386_GOTOFF
3476       || fixP->fx_r_type == BFD_RELOC_386_GOT32
3477       || fixP->fx_r_type == BFD_RELOC_386_GOT32X
3478       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
3479       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
3480       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
3481       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
3482       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
3483       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
3484       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
3485       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
3486       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
3487       || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
3488       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
3489       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
3490       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCRELX
3491       || fixP->fx_r_type == BFD_RELOC_X86_64_REX_GOTPCRELX
3492       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
3493       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
3494       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
3495       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
3496       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
3497       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
3498       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
3499       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
3500       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
3501       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
3502       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3503       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3504     return 0;
3505 #endif
3506   return 1;
3507 }
3508
3509 static int
3510 intel_float_operand (const char *mnemonic)
3511 {
3512   /* Note that the value returned is meaningful only for opcodes with (memory)
3513      operands, hence the code here is free to improperly handle opcodes that
3514      have no operands (for better performance and smaller code). */
3515
3516   if (mnemonic[0] != 'f')
3517     return 0; /* non-math */
3518
3519   switch (mnemonic[1])
3520     {
3521     /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
3522        the fs segment override prefix not currently handled because no
3523        call path can make opcodes without operands get here */
3524     case 'i':
3525       return 2 /* integer op */;
3526     case 'l':
3527       if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
3528         return 3; /* fldcw/fldenv */
3529       break;
3530     case 'n':
3531       if (mnemonic[2] != 'o' /* fnop */)
3532         return 3; /* non-waiting control op */
3533       break;
3534     case 'r':
3535       if (mnemonic[2] == 's')
3536         return 3; /* frstor/frstpm */
3537       break;
3538     case 's':
3539       if (mnemonic[2] == 'a')
3540         return 3; /* fsave */
3541       if (mnemonic[2] == 't')
3542         {
3543           switch (mnemonic[3])
3544             {
3545             case 'c': /* fstcw */
3546             case 'd': /* fstdw */
3547             case 'e': /* fstenv */
3548             case 's': /* fsts[gw] */
3549               return 3;
3550             }
3551         }
3552       break;
3553     case 'x':
3554       if (mnemonic[2] == 'r' || mnemonic[2] == 's')
3555         return 0; /* fxsave/fxrstor are not really math ops */
3556       break;
3557     }
3558
3559   return 1;
3560 }
3561
3562 /* Build the VEX prefix.  */
3563
3564 static void
3565 build_vex_prefix (const insn_template *t)
3566 {
3567   unsigned int register_specifier;
3568   unsigned int implied_prefix;
3569   unsigned int vector_length;
3570   unsigned int w;
3571
3572   /* Check register specifier.  */
3573   if (i.vex.register_specifier)
3574     {
3575       register_specifier =
3576         ~register_number (i.vex.register_specifier) & 0xf;
3577       gas_assert ((i.vex.register_specifier->reg_flags & RegVRex) == 0);
3578     }
3579   else
3580     register_specifier = 0xf;
3581
3582   /* Use 2-byte VEX prefix by swapping destination and source operand
3583      if there are more than 1 register operand.  */
3584   if (i.reg_operands > 1
3585       && i.vec_encoding != vex_encoding_vex3
3586       && i.dir_encoding == dir_encoding_default
3587       && i.operands == i.reg_operands
3588       && operand_type_equal (&i.types[0], &i.types[i.operands - 1])
3589       && i.tm.opcode_modifier.vexopcode == VEX0F
3590       && (i.tm.opcode_modifier.load || i.tm.opcode_modifier.d)
3591       && i.rex == REX_B)
3592     {
3593       unsigned int xchg = i.operands - 1;
3594       union i386_op temp_op;
3595       i386_operand_type temp_type;
3596
3597       temp_type = i.types[xchg];
3598       i.types[xchg] = i.types[0];
3599       i.types[0] = temp_type;
3600       temp_op = i.op[xchg];
3601       i.op[xchg] = i.op[0];
3602       i.op[0] = temp_op;
3603
3604       gas_assert (i.rm.mode == 3);
3605
3606       i.rex = REX_R;
3607       xchg = i.rm.regmem;
3608       i.rm.regmem = i.rm.reg;
3609       i.rm.reg = xchg;
3610
3611       if (i.tm.opcode_modifier.d)
3612         i.tm.base_opcode ^= (i.tm.base_opcode & 0xee) != 0x6e
3613                             ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
3614       else /* Use the next insn.  */
3615         i.tm = t[1];
3616     }
3617
3618   /* Use 2-byte VEX prefix by swapping commutative source operands if there
3619      are no memory operands and at least 3 register ones.  */
3620   if (i.reg_operands >= 3
3621       && i.vec_encoding != vex_encoding_vex3
3622       && i.reg_operands == i.operands - i.imm_operands
3623       && i.tm.opcode_modifier.vex
3624       && i.tm.opcode_modifier.commutative
3625       && (i.tm.opcode_modifier.sse2avx || optimize > 1)
3626       && i.rex == REX_B
3627       && i.vex.register_specifier
3628       && !(i.vex.register_specifier->reg_flags & RegRex))
3629     {
3630       unsigned int xchg = i.operands - i.reg_operands;
3631       union i386_op temp_op;
3632       i386_operand_type temp_type;
3633
3634       gas_assert (i.tm.opcode_modifier.vexopcode == VEX0F);
3635       gas_assert (!i.tm.opcode_modifier.sae);
3636       gas_assert (operand_type_equal (&i.types[i.operands - 2],
3637                                       &i.types[i.operands - 3]));
3638       gas_assert (i.rm.mode == 3);
3639
3640       temp_type = i.types[xchg];
3641       i.types[xchg] = i.types[xchg + 1];
3642       i.types[xchg + 1] = temp_type;
3643       temp_op = i.op[xchg];
3644       i.op[xchg] = i.op[xchg + 1];
3645       i.op[xchg + 1] = temp_op;
3646
3647       i.rex = 0;
3648       xchg = i.rm.regmem | 8;
3649       i.rm.regmem = ~register_specifier & 0xf;
3650       gas_assert (!(i.rm.regmem & 8));
3651       i.vex.register_specifier += xchg - i.rm.regmem;
3652       register_specifier = ~xchg & 0xf;
3653     }
3654
3655   if (i.tm.opcode_modifier.vex == VEXScalar)
3656     vector_length = avxscalar;
3657   else if (i.tm.opcode_modifier.vex == VEX256)
3658     vector_length = 1;
3659   else
3660     {
3661       unsigned int op;
3662
3663       /* Determine vector length from the last multi-length vector
3664          operand.  */
3665       vector_length = 0;
3666       for (op = t->operands; op--;)
3667         if (t->operand_types[op].bitfield.xmmword
3668             && t->operand_types[op].bitfield.ymmword
3669             && i.types[op].bitfield.ymmword)
3670           {
3671             vector_length = 1;
3672             break;
3673           }
3674     }
3675
3676   switch ((i.tm.base_opcode >> (i.tm.opcode_length << 3)) & 0xff)
3677     {
3678     case 0:
3679       implied_prefix = 0;
3680       break;
3681     case DATA_PREFIX_OPCODE:
3682       implied_prefix = 1;
3683       break;
3684     case REPE_PREFIX_OPCODE:
3685       implied_prefix = 2;
3686       break;
3687     case REPNE_PREFIX_OPCODE:
3688       implied_prefix = 3;
3689       break;
3690     default:
3691       abort ();
3692     }
3693
3694   /* Check the REX.W bit and VEXW.  */
3695   if (i.tm.opcode_modifier.vexw == VEXWIG)
3696     w = (vexwig == vexw1 || (i.rex & REX_W)) ? 1 : 0;
3697   else if (i.tm.opcode_modifier.vexw)
3698     w = i.tm.opcode_modifier.vexw == VEXW1 ? 1 : 0;
3699   else
3700     w = (flag_code == CODE_64BIT ? i.rex & REX_W : vexwig == vexw1) ? 1 : 0;
3701
3702   /* Use 2-byte VEX prefix if possible.  */
3703   if (w == 0
3704       && i.vec_encoding != vex_encoding_vex3
3705       && i.tm.opcode_modifier.vexopcode == VEX0F
3706       && (i.rex & (REX_W | REX_X | REX_B)) == 0)
3707     {
3708       /* 2-byte VEX prefix.  */
3709       unsigned int r;
3710
3711       i.vex.length = 2;
3712       i.vex.bytes[0] = 0xc5;
3713
3714       /* Check the REX.R bit.  */
3715       r = (i.rex & REX_R) ? 0 : 1;
3716       i.vex.bytes[1] = (r << 7
3717                         | register_specifier << 3
3718                         | vector_length << 2
3719                         | implied_prefix);
3720     }
3721   else
3722     {
3723       /* 3-byte VEX prefix.  */
3724       unsigned int m;
3725
3726       i.vex.length = 3;
3727
3728       switch (i.tm.opcode_modifier.vexopcode)
3729         {
3730         case VEX0F:
3731           m = 0x1;
3732           i.vex.bytes[0] = 0xc4;
3733           break;
3734         case VEX0F38:
3735           m = 0x2;
3736           i.vex.bytes[0] = 0xc4;
3737           break;
3738         case VEX0F3A:
3739           m = 0x3;
3740           i.vex.bytes[0] = 0xc4;
3741           break;
3742         case XOP08:
3743           m = 0x8;
3744           i.vex.bytes[0] = 0x8f;
3745           break;
3746         case XOP09:
3747           m = 0x9;
3748           i.vex.bytes[0] = 0x8f;
3749           break;
3750         case XOP0A:
3751           m = 0xa;
3752           i.vex.bytes[0] = 0x8f;
3753           break;
3754         default:
3755           abort ();
3756         }
3757
3758       /* The high 3 bits of the second VEX byte are 1's compliment
3759          of RXB bits from REX.  */
3760       i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3761
3762       i.vex.bytes[2] = (w << 7
3763                         | register_specifier << 3
3764                         | vector_length << 2
3765                         | implied_prefix);
3766     }
3767 }
3768
3769 static INLINE bfd_boolean
3770 is_evex_encoding (const insn_template *t)
3771 {
3772   return t->opcode_modifier.evex || t->opcode_modifier.disp8memshift
3773          || t->opcode_modifier.broadcast || t->opcode_modifier.masking
3774          || t->opcode_modifier.sae;
3775 }
3776
3777 static INLINE bfd_boolean
3778 is_any_vex_encoding (const insn_template *t)
3779 {
3780   return t->opcode_modifier.vex || t->opcode_modifier.vexopcode
3781          || is_evex_encoding (t);
3782 }
3783
3784 /* Build the EVEX prefix.  */
3785
3786 static void
3787 build_evex_prefix (void)
3788 {
3789   unsigned int register_specifier;
3790   unsigned int implied_prefix;
3791   unsigned int m, w;
3792   rex_byte vrex_used = 0;
3793
3794   /* Check register specifier.  */
3795   if (i.vex.register_specifier)
3796     {
3797       gas_assert ((i.vrex & REX_X) == 0);
3798
3799       register_specifier = i.vex.register_specifier->reg_num;
3800       if ((i.vex.register_specifier->reg_flags & RegRex))
3801         register_specifier += 8;
3802       /* The upper 16 registers are encoded in the fourth byte of the
3803          EVEX prefix.  */
3804       if (!(i.vex.register_specifier->reg_flags & RegVRex))
3805         i.vex.bytes[3] = 0x8;
3806       register_specifier = ~register_specifier & 0xf;
3807     }
3808   else
3809     {
3810       register_specifier = 0xf;
3811
3812       /* Encode upper 16 vector index register in the fourth byte of
3813          the EVEX prefix.  */
3814       if (!(i.vrex & REX_X))
3815         i.vex.bytes[3] = 0x8;
3816       else
3817         vrex_used |= REX_X;
3818     }
3819
3820   switch ((i.tm.base_opcode >> 8) & 0xff)
3821     {
3822     case 0:
3823       implied_prefix = 0;
3824       break;
3825     case DATA_PREFIX_OPCODE:
3826       implied_prefix = 1;
3827       break;
3828     case REPE_PREFIX_OPCODE:
3829       implied_prefix = 2;
3830       break;
3831     case REPNE_PREFIX_OPCODE:
3832       implied_prefix = 3;
3833       break;
3834     default:
3835       abort ();
3836     }
3837
3838   /* 4 byte EVEX prefix.  */
3839   i.vex.length = 4;
3840   i.vex.bytes[0] = 0x62;
3841
3842   /* mmmm bits.  */
3843   switch (i.tm.opcode_modifier.vexopcode)
3844     {
3845     case VEX0F:
3846       m = 1;
3847       break;
3848     case VEX0F38:
3849       m = 2;
3850       break;
3851     case VEX0F3A:
3852       m = 3;
3853       break;
3854     default:
3855       abort ();
3856       break;
3857     }
3858
3859   /* The high 3 bits of the second EVEX byte are 1's compliment of RXB
3860      bits from REX.  */
3861   i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3862
3863   /* The fifth bit of the second EVEX byte is 1's compliment of the
3864      REX_R bit in VREX.  */
3865   if (!(i.vrex & REX_R))
3866     i.vex.bytes[1] |= 0x10;
3867   else
3868     vrex_used |= REX_R;
3869
3870   if ((i.reg_operands + i.imm_operands) == i.operands)
3871     {
3872       /* When all operands are registers, the REX_X bit in REX is not
3873          used.  We reuse it to encode the upper 16 registers, which is
3874          indicated by the REX_B bit in VREX.  The REX_X bit is encoded
3875          as 1's compliment.  */
3876       if ((i.vrex & REX_B))
3877         {
3878           vrex_used |= REX_B;
3879           i.vex.bytes[1] &= ~0x40;
3880         }
3881     }
3882
3883   /* EVEX instructions shouldn't need the REX prefix.  */
3884   i.vrex &= ~vrex_used;
3885   gas_assert (i.vrex == 0);
3886
3887   /* Check the REX.W bit and VEXW.  */
3888   if (i.tm.opcode_modifier.vexw == VEXWIG)
3889     w = (evexwig == evexw1 || (i.rex & REX_W)) ? 1 : 0;
3890   else if (i.tm.opcode_modifier.vexw)
3891     w = i.tm.opcode_modifier.vexw == VEXW1 ? 1 : 0;
3892   else
3893     w = (flag_code == CODE_64BIT ? i.rex & REX_W : evexwig == evexw1) ? 1 : 0;
3894
3895   /* Encode the U bit.  */
3896   implied_prefix |= 0x4;
3897
3898   /* The third byte of the EVEX prefix.  */
3899   i.vex.bytes[2] = (w << 7 | register_specifier << 3 | implied_prefix);
3900
3901   /* The fourth byte of the EVEX prefix.  */
3902   /* The zeroing-masking bit.  */
3903   if (i.mask && i.mask->zeroing)
3904     i.vex.bytes[3] |= 0x80;
3905
3906   /* Don't always set the broadcast bit if there is no RC.  */
3907   if (!i.rounding)
3908     {
3909       /* Encode the vector length.  */
3910       unsigned int vec_length;
3911
3912       if (!i.tm.opcode_modifier.evex
3913           || i.tm.opcode_modifier.evex == EVEXDYN)
3914         {
3915           unsigned int op;
3916
3917           /* Determine vector length from the last multi-length vector
3918              operand.  */
3919           for (op = i.operands; op--;)
3920             if (i.tm.operand_types[op].bitfield.xmmword
3921                 + i.tm.operand_types[op].bitfield.ymmword
3922                 + i.tm.operand_types[op].bitfield.zmmword > 1)
3923               {
3924                 if (i.types[op].bitfield.zmmword)
3925                   {
3926                     i.tm.opcode_modifier.evex = EVEX512;
3927                     break;
3928                   }
3929                 else if (i.types[op].bitfield.ymmword)
3930                   {
3931                     i.tm.opcode_modifier.evex = EVEX256;
3932                     break;
3933                   }
3934                 else if (i.types[op].bitfield.xmmword)
3935                   {
3936                     i.tm.opcode_modifier.evex = EVEX128;
3937                     break;
3938                   }
3939                 else if (i.broadcast && (int) op == i.broadcast->operand)
3940                   {
3941                     switch (i.broadcast->bytes)
3942                       {
3943                         case 64:
3944                           i.tm.opcode_modifier.evex = EVEX512;
3945                           break;
3946                         case 32:
3947                           i.tm.opcode_modifier.evex = EVEX256;
3948                           break;
3949                         case 16:
3950                           i.tm.opcode_modifier.evex = EVEX128;
3951                           break;
3952                         default:
3953                           abort ();
3954                       }
3955                     break;
3956                   }
3957               }
3958
3959           if (op >= MAX_OPERANDS)
3960             abort ();
3961         }
3962
3963       switch (i.tm.opcode_modifier.evex)
3964         {
3965         case EVEXLIG: /* LL' is ignored */
3966           vec_length = evexlig << 5;
3967           break;
3968         case EVEX128:
3969           vec_length = 0 << 5;
3970           break;
3971         case EVEX256:
3972           vec_length = 1 << 5;
3973           break;
3974         case EVEX512:
3975           vec_length = 2 << 5;
3976           break;
3977         default:
3978           abort ();
3979           break;
3980         }
3981       i.vex.bytes[3] |= vec_length;
3982       /* Encode the broadcast bit.  */
3983       if (i.broadcast)
3984         i.vex.bytes[3] |= 0x10;
3985     }
3986   else
3987     {
3988       if (i.rounding->type != saeonly)
3989         i.vex.bytes[3] |= 0x10 | (i.rounding->type << 5);
3990       else
3991         i.vex.bytes[3] |= 0x10 | (evexrcig << 5);
3992     }
3993
3994   if (i.mask && i.mask->mask)
3995     i.vex.bytes[3] |= i.mask->mask->reg_num;
3996 }
3997
3998 static void
3999 process_immext (void)
4000 {
4001   expressionS *exp;
4002
4003   /* These AMD 3DNow! and SSE2 instructions have an opcode suffix
4004      which is coded in the same place as an 8-bit immediate field
4005      would be.  Here we fake an 8-bit immediate operand from the
4006      opcode suffix stored in tm.extension_opcode.
4007
4008      AVX instructions also use this encoding, for some of
4009      3 argument instructions.  */
4010
4011   gas_assert (i.imm_operands <= 1
4012               && (i.operands <= 2
4013                   || (is_any_vex_encoding (&i.tm)
4014                       && i.operands <= 4)));
4015
4016   exp = &im_expressions[i.imm_operands++];
4017   i.op[i.operands].imms = exp;
4018   i.types[i.operands] = imm8;
4019   i.operands++;
4020   exp->X_op = O_constant;
4021   exp->X_add_number = i.tm.extension_opcode;
4022   i.tm.extension_opcode = None;
4023 }
4024
4025
4026 static int
4027 check_hle (void)
4028 {
4029   switch (i.tm.opcode_modifier.hleprefixok)
4030     {
4031     default:
4032       abort ();
4033     case HLEPrefixNone:
4034       as_bad (_("invalid instruction `%s' after `%s'"),
4035               i.tm.name, i.hle_prefix);
4036       return 0;
4037     case HLEPrefixLock:
4038       if (i.prefix[LOCK_PREFIX])
4039         return 1;
4040       as_bad (_("missing `lock' with `%s'"), i.hle_prefix);
4041       return 0;
4042     case HLEPrefixAny:
4043       return 1;
4044     case HLEPrefixRelease:
4045       if (i.prefix[HLE_PREFIX] != XRELEASE_PREFIX_OPCODE)
4046         {
4047           as_bad (_("instruction `%s' after `xacquire' not allowed"),
4048                   i.tm.name);
4049           return 0;
4050         }
4051       if (i.mem_operands == 0 || !(i.flags[i.operands - 1] & Operand_Mem))
4052         {
4053           as_bad (_("memory destination needed for instruction `%s'"
4054                     " after `xrelease'"), i.tm.name);
4055           return 0;
4056         }
4057       return 1;
4058     }
4059 }
4060
4061 /* Try the shortest encoding by shortening operand size.  */
4062
4063 static void
4064 optimize_encoding (void)
4065 {
4066   unsigned int j;
4067
4068   if (optimize_for_space
4069       && !is_any_vex_encoding (&i.tm)
4070       && i.reg_operands == 1
4071       && i.imm_operands == 1
4072       && !i.types[1].bitfield.byte
4073       && i.op[0].imms->X_op == O_constant
4074       && fits_in_imm7 (i.op[0].imms->X_add_number)
4075       && (i.tm.base_opcode == 0xa8
4076           || (i.tm.base_opcode == 0xf6
4077               && i.tm.extension_opcode == 0x0)))
4078     {
4079       /* Optimize: -Os:
4080            test $imm7, %r64/%r32/%r16  -> test $imm7, %r8
4081        */
4082       unsigned int base_regnum = i.op[1].regs->reg_num;
4083       if (flag_code == CODE_64BIT || base_regnum < 4)
4084         {
4085           i.types[1].bitfield.byte = 1;
4086           /* Ignore the suffix.  */
4087           i.suffix = 0;
4088           /* Convert to byte registers.  */
4089           if (i.types[1].bitfield.word)
4090             j = 16;
4091           else if (i.types[1].bitfield.dword)
4092             j = 32;
4093           else
4094             j = 48;
4095           if (!(i.op[1].regs->reg_flags & RegRex) && base_regnum < 4)
4096             j += 8;
4097           i.op[1].regs -= j;
4098         }
4099     }
4100   else if (flag_code == CODE_64BIT
4101            && !is_any_vex_encoding (&i.tm)
4102            && ((i.types[1].bitfield.qword
4103                 && i.reg_operands == 1
4104                 && i.imm_operands == 1
4105                 && i.op[0].imms->X_op == O_constant
4106                 && ((i.tm.base_opcode == 0xb8
4107                      && i.tm.extension_opcode == None
4108                      && fits_in_unsigned_long (i.op[0].imms->X_add_number))
4109                     || (fits_in_imm31 (i.op[0].imms->X_add_number)
4110                         && ((i.tm.base_opcode == 0x24
4111                              || i.tm.base_opcode == 0xa8)
4112                             || (i.tm.base_opcode == 0x80
4113                                 && i.tm.extension_opcode == 0x4)
4114                             || ((i.tm.base_opcode == 0xf6
4115                                  || (i.tm.base_opcode | 1) == 0xc7)
4116                                 && i.tm.extension_opcode == 0x0)))
4117                     || (fits_in_imm7 (i.op[0].imms->X_add_number)
4118                         && i.tm.base_opcode == 0x83
4119                         && i.tm.extension_opcode == 0x4)))
4120                || (i.types[0].bitfield.qword
4121                    && ((i.reg_operands == 2
4122                         && i.op[0].regs == i.op[1].regs
4123                         && (i.tm.base_opcode == 0x30
4124                             || i.tm.base_opcode == 0x28))
4125                        || (i.reg_operands == 1
4126                            && i.operands == 1
4127                            && i.tm.base_opcode == 0x30)))))
4128     {
4129       /* Optimize: -O:
4130            andq $imm31, %r64   -> andl $imm31, %r32
4131            andq $imm7, %r64    -> andl $imm7, %r32
4132            testq $imm31, %r64  -> testl $imm31, %r32
4133            xorq %r64, %r64     -> xorl %r32, %r32
4134            subq %r64, %r64     -> subl %r32, %r32
4135            movq $imm31, %r64   -> movl $imm31, %r32
4136            movq $imm32, %r64   -> movl $imm32, %r32
4137         */
4138       i.tm.opcode_modifier.norex64 = 1;
4139       if (i.tm.base_opcode == 0xb8 || (i.tm.base_opcode | 1) == 0xc7)
4140         {
4141           /* Handle
4142                movq $imm31, %r64   -> movl $imm31, %r32
4143                movq $imm32, %r64   -> movl $imm32, %r32
4144            */
4145           i.tm.operand_types[0].bitfield.imm32 = 1;
4146           i.tm.operand_types[0].bitfield.imm32s = 0;
4147           i.tm.operand_types[0].bitfield.imm64 = 0;
4148           i.types[0].bitfield.imm32 = 1;
4149           i.types[0].bitfield.imm32s = 0;
4150           i.types[0].bitfield.imm64 = 0;
4151           i.types[1].bitfield.dword = 1;
4152           i.types[1].bitfield.qword = 0;
4153           if ((i.tm.base_opcode | 1) == 0xc7)
4154             {
4155               /* Handle
4156                    movq $imm31, %r64   -> movl $imm31, %r32
4157                */
4158               i.tm.base_opcode = 0xb8;
4159               i.tm.extension_opcode = None;
4160               i.tm.opcode_modifier.w = 0;
4161               i.tm.opcode_modifier.modrm = 0;
4162             }
4163         }
4164     }
4165   else if (optimize > 1
4166            && !optimize_for_space
4167            && !is_any_vex_encoding (&i.tm)
4168            && i.reg_operands == 2
4169            && i.op[0].regs == i.op[1].regs
4170            && ((i.tm.base_opcode & ~(Opcode_D | 1)) == 0x8
4171                || (i.tm.base_opcode & ~(Opcode_D | 1)) == 0x20)
4172            && (flag_code != CODE_64BIT || !i.types[0].bitfield.dword))
4173     {
4174       /* Optimize: -O2:
4175            andb %rN, %rN  -> testb %rN, %rN
4176            andw %rN, %rN  -> testw %rN, %rN
4177            andq %rN, %rN  -> testq %rN, %rN
4178            orb %rN, %rN   -> testb %rN, %rN
4179            orw %rN, %rN   -> testw %rN, %rN
4180            orq %rN, %rN   -> testq %rN, %rN
4181
4182            and outside of 64-bit mode
4183
4184            andl %rN, %rN  -> testl %rN, %rN
4185            orl %rN, %rN   -> testl %rN, %rN
4186        */
4187       i.tm.base_opcode = 0x84 | (i.tm.base_opcode & 1);
4188     }
4189   else if (i.reg_operands == 3
4190            && i.op[0].regs == i.op[1].regs
4191            && !i.types[2].bitfield.xmmword
4192            && (i.tm.opcode_modifier.vex
4193                || ((!i.mask || i.mask->zeroing)
4194                    && !i.rounding
4195                    && is_evex_encoding (&i.tm)
4196                    && (i.vec_encoding != vex_encoding_evex
4197                        || cpu_arch_isa_flags.bitfield.cpuavx512vl
4198                        || i.tm.cpu_flags.bitfield.cpuavx512vl
4199                        || (i.tm.operand_types[2].bitfield.zmmword
4200                            && i.types[2].bitfield.ymmword))))
4201            && ((i.tm.base_opcode == 0x55
4202                 || i.tm.base_opcode == 0x6655
4203                 || i.tm.base_opcode == 0x66df
4204                 || i.tm.base_opcode == 0x57
4205                 || i.tm.base_opcode == 0x6657
4206                 || i.tm.base_opcode == 0x66ef
4207                 || i.tm.base_opcode == 0x66f8
4208                 || i.tm.base_opcode == 0x66f9
4209                 || i.tm.base_opcode == 0x66fa
4210                 || i.tm.base_opcode == 0x66fb
4211                 || i.tm.base_opcode == 0x42
4212                 || i.tm.base_opcode == 0x6642
4213                 || i.tm.base_opcode == 0x47
4214                 || i.tm.base_opcode == 0x6647)
4215                && i.tm.extension_opcode == None))
4216     {
4217       /* Optimize: -O1:
4218            VOP, one of vandnps, vandnpd, vxorps, vxorpd, vpsubb, vpsubd,
4219            vpsubq and vpsubw:
4220              EVEX VOP %zmmM, %zmmM, %zmmN
4221                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4222                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4223              EVEX VOP %ymmM, %ymmM, %ymmN
4224                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4225                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4226              VEX VOP %ymmM, %ymmM, %ymmN
4227                -> VEX VOP %xmmM, %xmmM, %xmmN
4228            VOP, one of vpandn and vpxor:
4229              VEX VOP %ymmM, %ymmM, %ymmN
4230                -> VEX VOP %xmmM, %xmmM, %xmmN
4231            VOP, one of vpandnd and vpandnq:
4232              EVEX VOP %zmmM, %zmmM, %zmmN
4233                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4234                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4235              EVEX VOP %ymmM, %ymmM, %ymmN
4236                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4237                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4238            VOP, one of vpxord and vpxorq:
4239              EVEX VOP %zmmM, %zmmM, %zmmN
4240                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4241                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4242              EVEX VOP %ymmM, %ymmM, %ymmN
4243                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4244                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4245            VOP, one of kxord and kxorq:
4246              VEX VOP %kM, %kM, %kN
4247                -> VEX kxorw %kM, %kM, %kN
4248            VOP, one of kandnd and kandnq:
4249              VEX VOP %kM, %kM, %kN
4250                -> VEX kandnw %kM, %kM, %kN
4251        */
4252       if (is_evex_encoding (&i.tm))
4253         {
4254           if (i.vec_encoding != vex_encoding_evex)
4255             {
4256               i.tm.opcode_modifier.vex = VEX128;
4257               i.tm.opcode_modifier.vexw = VEXW0;
4258               i.tm.opcode_modifier.evex = 0;
4259             }
4260           else if (optimize > 1)
4261             i.tm.opcode_modifier.evex = EVEX128;
4262           else
4263             return;
4264         }
4265       else if (i.tm.operand_types[0].bitfield.class == RegMask)
4266         {
4267           i.tm.base_opcode &= 0xff;
4268           i.tm.opcode_modifier.vexw = VEXW0;
4269         }
4270       else
4271         i.tm.opcode_modifier.vex = VEX128;
4272
4273       if (i.tm.opcode_modifier.vex)
4274         for (j = 0; j < 3; j++)
4275           {
4276             i.types[j].bitfield.xmmword = 1;
4277             i.types[j].bitfield.ymmword = 0;
4278           }
4279     }
4280   else if (i.vec_encoding != vex_encoding_evex
4281            && !i.types[0].bitfield.zmmword
4282            && !i.types[1].bitfield.zmmword
4283            && !i.mask
4284            && !i.broadcast
4285            && is_evex_encoding (&i.tm)
4286            && ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0x666f
4287                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf36f
4288                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f
4289                || (i.tm.base_opcode & ~4) == 0x66db
4290                || (i.tm.base_opcode & ~4) == 0x66eb)
4291            && i.tm.extension_opcode == None)
4292     {
4293       /* Optimize: -O1:
4294            VOP, one of vmovdqa32, vmovdqa64, vmovdqu8, vmovdqu16,
4295            vmovdqu32 and vmovdqu64:
4296              EVEX VOP %xmmM, %xmmN
4297                -> VEX vmovdqa|vmovdqu %xmmM, %xmmN (M and N < 16)
4298              EVEX VOP %ymmM, %ymmN
4299                -> VEX vmovdqa|vmovdqu %ymmM, %ymmN (M and N < 16)
4300              EVEX VOP %xmmM, mem
4301                -> VEX vmovdqa|vmovdqu %xmmM, mem (M < 16)
4302              EVEX VOP %ymmM, mem
4303                -> VEX vmovdqa|vmovdqu %ymmM, mem (M < 16)
4304              EVEX VOP mem, %xmmN
4305                -> VEX mvmovdqa|vmovdquem, %xmmN (N < 16)
4306              EVEX VOP mem, %ymmN
4307                -> VEX vmovdqa|vmovdqu mem, %ymmN (N < 16)
4308            VOP, one of vpand, vpandn, vpor, vpxor:
4309              EVEX VOP{d,q} %xmmL, %xmmM, %xmmN
4310                -> VEX VOP %xmmL, %xmmM, %xmmN (L, M, and N < 16)
4311              EVEX VOP{d,q} %ymmL, %ymmM, %ymmN
4312                -> VEX VOP %ymmL, %ymmM, %ymmN (L, M, and N < 16)
4313              EVEX VOP{d,q} mem, %xmmM, %xmmN
4314                -> VEX VOP mem, %xmmM, %xmmN (M and N < 16)
4315              EVEX VOP{d,q} mem, %ymmM, %ymmN
4316                -> VEX VOP mem, %ymmM, %ymmN (M and N < 16)
4317        */
4318       for (j = 0; j < i.operands; j++)
4319         if (operand_type_check (i.types[j], disp)
4320             && i.op[j].disps->X_op == O_constant)
4321           {
4322             /* Since the VEX prefix has 2 or 3 bytes, the EVEX prefix
4323                has 4 bytes, EVEX Disp8 has 1 byte and VEX Disp32 has 4
4324                bytes, we choose EVEX Disp8 over VEX Disp32.  */
4325             int evex_disp8, vex_disp8;
4326             unsigned int memshift = i.memshift;
4327             offsetT n = i.op[j].disps->X_add_number;
4328
4329             evex_disp8 = fits_in_disp8 (n);
4330             i.memshift = 0;
4331             vex_disp8 = fits_in_disp8 (n);
4332             if (evex_disp8 != vex_disp8)
4333               {
4334                 i.memshift = memshift;
4335                 return;
4336               }
4337
4338             i.types[j].bitfield.disp8 = vex_disp8;
4339             break;
4340           }
4341       if ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f)
4342         i.tm.base_opcode ^= 0xf36f ^ 0xf26f;
4343       i.tm.opcode_modifier.vex
4344         = i.types[0].bitfield.ymmword ? VEX256 : VEX128;
4345       i.tm.opcode_modifier.vexw = VEXW0;
4346       /* VPAND, VPOR, and VPXOR are commutative.  */
4347       if (i.reg_operands == 3 && i.tm.base_opcode != 0x66df)
4348         i.tm.opcode_modifier.commutative = 1;
4349       i.tm.opcode_modifier.evex = 0;
4350       i.tm.opcode_modifier.masking = 0;
4351       i.tm.opcode_modifier.broadcast = 0;
4352       i.tm.opcode_modifier.disp8memshift = 0;
4353       i.memshift = 0;
4354       if (j < i.operands)
4355         i.types[j].bitfield.disp8
4356           = fits_in_disp8 (i.op[j].disps->X_add_number);
4357     }
4358 }
4359
4360 /* Return non-zero for load instruction.  */
4361
4362 static int
4363 load_insn_p (void)
4364 {
4365   unsigned int dest;
4366   int any_vex_p = is_any_vex_encoding (&i.tm);
4367   unsigned int base_opcode = i.tm.base_opcode | 1;
4368
4369   if (!any_vex_p)
4370     {
4371       /* Anysize insns: lea, invlpg, clflush, prefetchnta, prefetcht0,
4372          prefetcht1, prefetcht2, prefetchtw, bndmk, bndcl, bndcu, bndcn,
4373          bndstx, bndldx, prefetchwt1, clflushopt, clwb, cldemote.  */
4374       if (i.tm.opcode_modifier.anysize)
4375         return 0;
4376
4377       /* pop, popf, popa.   */
4378       if (strcmp (i.tm.name, "pop") == 0
4379           || i.tm.base_opcode == 0x9d
4380           || i.tm.base_opcode == 0x61)
4381         return 1;
4382
4383       /* movs, cmps, lods, scas.  */
4384       if ((i.tm.base_opcode | 0xb) == 0xaf)
4385         return 1;
4386
4387       /* outs, xlatb.  */
4388       if (base_opcode == 0x6f
4389           || i.tm.base_opcode == 0xd7)
4390         return 1;
4391       /* NB: For AMD-specific insns with implicit memory operands,
4392          they're intentionally not covered.  */
4393     }
4394
4395   /* No memory operand.  */
4396   if (!i.mem_operands)
4397     return 0;
4398
4399   if (any_vex_p)
4400     {
4401       /* vldmxcsr.  */
4402       if (i.tm.base_opcode == 0xae
4403           && i.tm.opcode_modifier.vex
4404           && i.tm.opcode_modifier.vexopcode == VEX0F
4405           && i.tm.extension_opcode == 2)
4406         return 1;
4407     }
4408   else
4409     {
4410       /* test, not, neg, mul, imul, div, idiv.  */
4411       if ((i.tm.base_opcode == 0xf6 || i.tm.base_opcode == 0xf7)
4412           && i.tm.extension_opcode != 1)
4413         return 1;
4414
4415       /* inc, dec.  */
4416       if (base_opcode == 0xff && i.tm.extension_opcode <= 1)
4417         return 1;
4418
4419       /* add, or, adc, sbb, and, sub, xor, cmp.  */
4420       if (i.tm.base_opcode >= 0x80 && i.tm.base_opcode <= 0x83)
4421         return 1;
4422
4423       /* bt, bts, btr, btc.  */
4424       if (i.tm.base_opcode == 0xfba
4425           && (i.tm.extension_opcode >= 4 && i.tm.extension_opcode <= 7))
4426         return 1;
4427
4428       /* rol, ror, rcl, rcr, shl/sal, shr, sar. */
4429       if ((base_opcode == 0xc1
4430            || (i.tm.base_opcode >= 0xd0 && i.tm.base_opcode <= 0xd3))
4431           && i.tm.extension_opcode != 6)
4432         return 1;
4433
4434       /* cmpxchg8b, cmpxchg16b, xrstors.  */
4435       if (i.tm.base_opcode == 0xfc7
4436           && (i.tm.extension_opcode == 1 || i.tm.extension_opcode == 3))
4437         return 1;
4438
4439       /* fxrstor, ldmxcsr, xrstor.  */
4440       if (i.tm.base_opcode == 0xfae
4441           && (i.tm.extension_opcode == 1
4442               || i.tm.extension_opcode == 2
4443               || i.tm.extension_opcode == 5))
4444         return 1;
4445
4446       /* lgdt, lidt, lmsw.  */
4447       if (i.tm.base_opcode == 0xf01
4448           && (i.tm.extension_opcode == 2
4449               || i.tm.extension_opcode == 3
4450               || i.tm.extension_opcode == 6))
4451         return 1;
4452
4453       /* vmptrld */
4454       if (i.tm.base_opcode == 0xfc7
4455           && i.tm.extension_opcode == 6)
4456         return 1;
4457
4458       /* Check for x87 instructions.  */
4459       if (i.tm.base_opcode >= 0xd8 && i.tm.base_opcode <= 0xdf)
4460         {
4461           /* Skip fst, fstp, fstenv, fstcw.  */
4462           if (i.tm.base_opcode == 0xd9
4463               && (i.tm.extension_opcode == 2
4464                   || i.tm.extension_opcode == 3
4465                   || i.tm.extension_opcode == 6
4466                   || i.tm.extension_opcode == 7))
4467             return 0;
4468
4469           /* Skip fisttp, fist, fistp, fstp.  */
4470           if (i.tm.base_opcode == 0xdb
4471               && (i.tm.extension_opcode == 1
4472                   || i.tm.extension_opcode == 2
4473                   || i.tm.extension_opcode == 3
4474                   || i.tm.extension_opcode == 7))
4475             return 0;
4476
4477           /* Skip fisttp, fst, fstp, fsave, fstsw.  */
4478           if (i.tm.base_opcode == 0xdd
4479               && (i.tm.extension_opcode == 1
4480                   || i.tm.extension_opcode == 2
4481                   || i.tm.extension_opcode == 3
4482                   || i.tm.extension_opcode == 6
4483                   || i.tm.extension_opcode == 7))
4484             return 0;
4485
4486           /* Skip fisttp, fist, fistp, fbstp, fistp.  */
4487           if (i.tm.base_opcode == 0xdf
4488               && (i.tm.extension_opcode == 1
4489                   || i.tm.extension_opcode == 2
4490                   || i.tm.extension_opcode == 3
4491                   || i.tm.extension_opcode == 6
4492                   || i.tm.extension_opcode == 7))
4493             return 0;
4494
4495           return 1;
4496         }
4497     }
4498
4499   dest = i.operands - 1;
4500
4501   /* Check fake imm8 operand and 3 source operands.  */
4502   if ((i.tm.opcode_modifier.immext
4503        || i.tm.opcode_modifier.vexsources == VEX3SOURCES)
4504       && i.types[dest].bitfield.imm8)
4505     dest--;
4506
4507   /* add, or, adc, sbb, and, sub, xor, cmp, test, xchg, xadd  */
4508   if (!any_vex_p
4509       && (base_opcode == 0x1
4510           || base_opcode == 0x9
4511           || base_opcode == 0x11
4512           || base_opcode == 0x19
4513           || base_opcode == 0x21
4514           || base_opcode == 0x29
4515           || base_opcode == 0x31
4516           || base_opcode == 0x39
4517           || (i.tm.base_opcode >= 0x84 && i.tm.base_opcode <= 0x87)
4518           || base_opcode == 0xfc1))
4519     return 1;
4520
4521   /* Check for load instruction.  */
4522   return (i.types[dest].bitfield.class != ClassNone
4523           || i.types[dest].bitfield.instance == Accum);
4524 }
4525
4526 /* Output lfence, 0xfaee8, after instruction.  */
4527
4528 static void
4529 insert_lfence_after (void)
4530 {
4531   if (lfence_after_load && load_insn_p ())
4532     {
4533       /* There are also two REP string instructions that require
4534          special treatment. Specifically, the compare string (CMPS)
4535          and scan string (SCAS) instructions set EFLAGS in a manner
4536          that depends on the data being compared/scanned. When used
4537          with a REP prefix, the number of iterations may therefore
4538          vary depending on this data. If the data is a program secret
4539          chosen by the adversary using an LVI method,
4540          then this data-dependent behavior may leak some aspect
4541          of the secret.  */
4542       if (((i.tm.base_opcode | 0x1) == 0xa7
4543            || (i.tm.base_opcode | 0x1) == 0xaf)
4544           && i.prefix[REP_PREFIX])
4545         {
4546             as_warn (_("`%s` changes flags which would affect control flow behavior"),
4547                      i.tm.name);
4548         }
4549       char *p = frag_more (3);
4550       *p++ = 0xf;
4551       *p++ = 0xae;
4552       *p = 0xe8;
4553     }
4554 }
4555
4556 /* Output lfence, 0xfaee8, before instruction.  */
4557
4558 static void
4559 insert_lfence_before (void)
4560 {
4561   char *p;
4562
4563   if (is_any_vex_encoding (&i.tm))
4564     return;
4565
4566   if (i.tm.base_opcode == 0xff
4567       && (i.tm.extension_opcode == 2 || i.tm.extension_opcode == 4))
4568     {
4569       /* Insert lfence before indirect branch if needed.  */
4570
4571       if (lfence_before_indirect_branch == lfence_branch_none)
4572         return;
4573
4574       if (i.operands != 1)
4575         abort ();
4576
4577       if (i.reg_operands == 1)
4578         {
4579           /* Indirect branch via register.  Don't insert lfence with
4580              -mlfence-after-load=yes.  */
4581           if (lfence_after_load
4582               || lfence_before_indirect_branch == lfence_branch_memory)
4583             return;
4584         }
4585       else if (i.mem_operands == 1
4586                && lfence_before_indirect_branch != lfence_branch_register)
4587         {
4588           as_warn (_("indirect `%s` with memory operand should be avoided"),
4589                    i.tm.name);
4590           return;
4591         }
4592       else
4593         return;
4594
4595       if (last_insn.kind != last_insn_other
4596           && last_insn.seg == now_seg)
4597         {
4598           as_warn_where (last_insn.file, last_insn.line,
4599                          _("`%s` skips -mlfence-before-indirect-branch on `%s`"),
4600                          last_insn.name, i.tm.name);
4601           return;
4602         }
4603
4604       p = frag_more (3);
4605       *p++ = 0xf;
4606       *p++ = 0xae;
4607       *p = 0xe8;
4608       return;
4609     }
4610
4611   /* Output or/not/shl and lfence before near ret.  */
4612   if (lfence_before_ret != lfence_before_ret_none
4613       && (i.tm.base_opcode == 0xc2
4614           || i.tm.base_opcode == 0xc3))
4615     {
4616       if (last_insn.kind != last_insn_other
4617           && last_insn.seg == now_seg)
4618         {
4619           as_warn_where (last_insn.file, last_insn.line,
4620                          _("`%s` skips -mlfence-before-ret on `%s`"),
4621                          last_insn.name, i.tm.name);
4622           return;
4623         }
4624
4625       /* Near ret ingore operand size override under CPU64.  */
4626       char prefix = flag_code == CODE_64BIT
4627                     ? 0x48
4628                     : i.prefix[DATA_PREFIX] ? 0x66 : 0x0;
4629
4630       if (lfence_before_ret == lfence_before_ret_not)
4631         {
4632           /* not: 0xf71424, may add prefix
4633              for operand size override or 64-bit code.  */
4634           p = frag_more ((prefix ? 2 : 0) + 6 + 3);
4635           if (prefix)
4636             *p++ = prefix;
4637           *p++ = 0xf7;
4638           *p++ = 0x14;
4639           *p++ = 0x24;
4640           if (prefix)
4641             *p++ = prefix;
4642           *p++ = 0xf7;
4643           *p++ = 0x14;
4644           *p++ = 0x24;
4645         }
4646       else
4647         {
4648           p = frag_more ((prefix ? 1 : 0) + 4 + 3);
4649           if (prefix)
4650             *p++ = prefix;
4651           if (lfence_before_ret == lfence_before_ret_or)
4652             {
4653               /* or: 0x830c2400, may add prefix
4654                  for operand size override or 64-bit code.  */
4655               *p++ = 0x83;
4656               *p++ = 0x0c;
4657             }
4658           else
4659             {
4660               /* shl: 0xc1242400, may add prefix
4661                  for operand size override or 64-bit code.  */
4662               *p++ = 0xc1;
4663               *p++ = 0x24;
4664             }
4665
4666           *p++ = 0x24;
4667           *p++ = 0x0;
4668         }
4669
4670       *p++ = 0xf;
4671       *p++ = 0xae;
4672       *p = 0xe8;
4673     }
4674 }
4675
4676 /* This is the guts of the machine-dependent assembler.  LINE points to a
4677    machine dependent instruction.  This function is supposed to emit
4678    the frags/bytes it assembles to.  */
4679
4680 void
4681 md_assemble (char *line)
4682 {
4683   unsigned int j;
4684   char mnemonic[MAX_MNEM_SIZE], mnem_suffix;
4685   const insn_template *t;
4686
4687   /* Initialize globals.  */
4688   memset (&i, '\0', sizeof (i));
4689   for (j = 0; j < MAX_OPERANDS; j++)
4690     i.reloc[j] = NO_RELOC;
4691   memset (disp_expressions, '\0', sizeof (disp_expressions));
4692   memset (im_expressions, '\0', sizeof (im_expressions));
4693   save_stack_p = save_stack;
4694
4695   /* First parse an instruction mnemonic & call i386_operand for the operands.
4696      We assume that the scrubber has arranged it so that line[0] is the valid
4697      start of a (possibly prefixed) mnemonic.  */
4698
4699   line = parse_insn (line, mnemonic);
4700   if (line == NULL)
4701     return;
4702   mnem_suffix = i.suffix;
4703
4704   line = parse_operands (line, mnemonic);
4705   this_operand = -1;
4706   xfree (i.memop1_string);
4707   i.memop1_string = NULL;
4708   if (line == NULL)
4709     return;
4710
4711   /* Now we've parsed the mnemonic into a set of templates, and have the
4712      operands at hand.  */
4713
4714   /* All Intel opcodes have reversed operands except for "bound", "enter",
4715      "monitor*", "mwait*", "tpause", and "umwait".  We also don't reverse
4716      intersegment "jmp" and "call" instructions with 2 immediate operands so
4717      that the immediate segment precedes the offset, as it does when in AT&T
4718      mode.  */
4719   if (intel_syntax
4720       && i.operands > 1
4721       && (strcmp (mnemonic, "bound") != 0)
4722       && (strcmp (mnemonic, "invlpga") != 0)
4723       && (strncmp (mnemonic, "monitor", 7) != 0)
4724       && (strncmp (mnemonic, "mwait", 5) != 0)
4725       && (strcmp (mnemonic, "tpause") != 0)
4726       && (strcmp (mnemonic, "umwait") != 0)
4727       && !(operand_type_check (i.types[0], imm)
4728            && operand_type_check (i.types[1], imm)))
4729     swap_operands ();
4730
4731   /* The order of the immediates should be reversed
4732      for 2 immediates extrq and insertq instructions */
4733   if (i.imm_operands == 2
4734       && (strcmp (mnemonic, "extrq") == 0
4735           || strcmp (mnemonic, "insertq") == 0))
4736       swap_2_operands (0, 1);
4737
4738   if (i.imm_operands)
4739     optimize_imm ();
4740
4741   /* Don't optimize displacement for movabs since it only takes 64bit
4742      displacement.  */
4743   if (i.disp_operands
4744       && i.disp_encoding != disp_encoding_32bit
4745       && (flag_code != CODE_64BIT
4746           || strcmp (mnemonic, "movabs") != 0))
4747     optimize_disp ();
4748
4749   /* Next, we find a template that matches the given insn,
4750      making sure the overlap of the given operands types is consistent
4751      with the template operand types.  */
4752
4753   if (!(t = match_template (mnem_suffix)))
4754     return;
4755
4756   if (sse_check != check_none
4757       && !i.tm.opcode_modifier.noavx
4758       && !i.tm.cpu_flags.bitfield.cpuavx
4759       && !i.tm.cpu_flags.bitfield.cpuavx512f
4760       && (i.tm.cpu_flags.bitfield.cpusse
4761           || i.tm.cpu_flags.bitfield.cpusse2
4762           || i.tm.cpu_flags.bitfield.cpusse3
4763           || i.tm.cpu_flags.bitfield.cpussse3
4764           || i.tm.cpu_flags.bitfield.cpusse4_1
4765           || i.tm.cpu_flags.bitfield.cpusse4_2
4766           || i.tm.cpu_flags.bitfield.cpupclmul
4767           || i.tm.cpu_flags.bitfield.cpuaes
4768           || i.tm.cpu_flags.bitfield.cpusha
4769           || i.tm.cpu_flags.bitfield.cpugfni))
4770     {
4771       (sse_check == check_warning
4772        ? as_warn
4773        : as_bad) (_("SSE instruction `%s' is used"), i.tm.name);
4774     }
4775
4776   if (i.tm.opcode_modifier.fwait)
4777     if (!add_prefix (FWAIT_OPCODE))
4778       return;
4779
4780   /* Check if REP prefix is OK.  */
4781   if (i.rep_prefix && !i.tm.opcode_modifier.repprefixok)
4782     {
4783       as_bad (_("invalid instruction `%s' after `%s'"),
4784                 i.tm.name, i.rep_prefix);
4785       return;
4786     }
4787
4788   /* Check for lock without a lockable instruction.  Destination operand
4789      must be memory unless it is xchg (0x86).  */
4790   if (i.prefix[LOCK_PREFIX]
4791       && (!i.tm.opcode_modifier.islockable
4792           || i.mem_operands == 0
4793           || (i.tm.base_opcode != 0x86
4794               && !(i.flags[i.operands - 1] & Operand_Mem))))
4795     {
4796       as_bad (_("expecting lockable instruction after `lock'"));
4797       return;
4798     }
4799
4800   /* Check for data size prefix on VEX/XOP/EVEX encoded and SIMD insns.  */
4801   if (i.prefix[DATA_PREFIX]
4802       && (is_any_vex_encoding (&i.tm)
4803           || i.tm.operand_types[i.imm_operands].bitfield.class >= RegMMX
4804           || i.tm.operand_types[i.imm_operands + 1].bitfield.class >= RegMMX))
4805     {
4806       as_bad (_("data size prefix invalid with `%s'"), i.tm.name);
4807       return;
4808     }
4809
4810   /* Check if HLE prefix is OK.  */
4811   if (i.hle_prefix && !check_hle ())
4812     return;
4813
4814   /* Check BND prefix.  */
4815   if (i.bnd_prefix && !i.tm.opcode_modifier.bndprefixok)
4816     as_bad (_("expecting valid branch instruction after `bnd'"));
4817
4818   /* Check NOTRACK prefix.  */
4819   if (i.notrack_prefix && !i.tm.opcode_modifier.notrackprefixok)
4820     as_bad (_("expecting indirect branch instruction after `notrack'"));
4821
4822   if (i.tm.cpu_flags.bitfield.cpumpx)
4823     {
4824       if (flag_code == CODE_64BIT && i.prefix[ADDR_PREFIX])
4825         as_bad (_("32-bit address isn't allowed in 64-bit MPX instructions."));
4826       else if (flag_code != CODE_16BIT
4827                ? i.prefix[ADDR_PREFIX]
4828                : i.mem_operands && !i.prefix[ADDR_PREFIX])
4829         as_bad (_("16-bit address isn't allowed in MPX instructions"));
4830     }
4831
4832   /* Insert BND prefix.  */
4833   if (add_bnd_prefix && i.tm.opcode_modifier.bndprefixok)
4834     {
4835       if (!i.prefix[BND_PREFIX])
4836         add_prefix (BND_PREFIX_OPCODE);
4837       else if (i.prefix[BND_PREFIX] != BND_PREFIX_OPCODE)
4838         {
4839           as_warn (_("replacing `rep'/`repe' prefix by `bnd'"));
4840           i.prefix[BND_PREFIX] = BND_PREFIX_OPCODE;
4841         }
4842     }
4843
4844   /* Check string instruction segment overrides.  */
4845   if (i.tm.opcode_modifier.isstring >= IS_STRING_ES_OP0)
4846     {
4847       gas_assert (i.mem_operands);
4848       if (!check_string ())
4849         return;
4850       i.disp_operands = 0;
4851     }
4852
4853   if (optimize && !i.no_optimize && i.tm.opcode_modifier.optimize)
4854     optimize_encoding ();
4855
4856   if (!process_suffix ())
4857     return;
4858
4859   /* Update operand types and check extended states.  */
4860   for (j = 0; j < i.operands; j++)
4861     {
4862       i.types[j] = operand_type_and (i.types[j], i.tm.operand_types[j]);
4863       switch (i.tm.operand_types[j].bitfield.class)
4864         {
4865         default:
4866           break;
4867         case RegMMX:
4868           i.xstate |= xstate_mmx;
4869           break;
4870         case RegMask:
4871           i.xstate |= xstate_zmm;
4872           break;
4873         case RegSIMD:
4874           if (i.tm.operand_types[j].bitfield.tmmword)
4875             i.xstate |= xstate_tmm;
4876           else if (i.tm.operand_types[j].bitfield.zmmword)
4877             i.xstate |= xstate_zmm;
4878           else if (i.tm.operand_types[j].bitfield.ymmword)
4879             i.xstate |= xstate_ymm;
4880           else if (i.tm.operand_types[j].bitfield.xmmword)
4881             i.xstate |= xstate_xmm;
4882           break;
4883         }
4884     }
4885
4886   /* Make still unresolved immediate matches conform to size of immediate
4887      given in i.suffix.  */
4888   if (!finalize_imm ())
4889     return;
4890
4891   if (i.types[0].bitfield.imm1)
4892     i.imm_operands = 0; /* kludge for shift insns.  */
4893
4894   /* We only need to check those implicit registers for instructions
4895      with 3 operands or less.  */
4896   if (i.operands <= 3)
4897     for (j = 0; j < i.operands; j++)
4898       if (i.types[j].bitfield.instance != InstanceNone
4899           && !i.types[j].bitfield.xmmword)
4900         i.reg_operands--;
4901
4902   /* For insns with operands there are more diddles to do to the opcode.  */
4903   if (i.operands)
4904     {
4905       if (!process_operands ())
4906         return;
4907     }
4908   else if (!quiet_warnings && i.tm.opcode_modifier.ugh)
4909     {
4910       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
4911       as_warn (_("translating to `%sp'"), i.tm.name);
4912     }
4913
4914   if (is_any_vex_encoding (&i.tm))
4915     {
4916       if (!cpu_arch_flags.bitfield.cpui286)
4917         {
4918           as_bad (_("instruction `%s' isn't supported outside of protected mode."),
4919                   i.tm.name);
4920           return;
4921         }
4922
4923       /* Check for explicit REX prefix.  */
4924       if (i.prefix[REX_PREFIX] || i.rex_encoding)
4925         {
4926           as_bad (_("REX prefix invalid with `%s'"), i.tm.name);
4927           return;
4928         }
4929
4930       if (i.tm.opcode_modifier.vex)
4931         build_vex_prefix (t);
4932       else
4933         build_evex_prefix ();
4934
4935       /* The individual REX.RXBW bits got consumed.  */
4936       i.rex &= REX_OPCODE;
4937     }
4938
4939   /* Handle conversion of 'int $3' --> special int3 insn.  XOP or FMA4
4940      instructions may define INT_OPCODE as well, so avoid this corner
4941      case for those instructions that use MODRM.  */
4942   if (i.tm.base_opcode == INT_OPCODE
4943       && !i.tm.opcode_modifier.modrm
4944       && i.op[0].imms->X_add_number == 3)
4945     {
4946       i.tm.base_opcode = INT3_OPCODE;
4947       i.imm_operands = 0;
4948     }
4949
4950   if ((i.tm.opcode_modifier.jump == JUMP
4951        || i.tm.opcode_modifier.jump == JUMP_BYTE
4952        || i.tm.opcode_modifier.jump == JUMP_DWORD)
4953       && i.op[0].disps->X_op == O_constant)
4954     {
4955       /* Convert "jmp constant" (and "call constant") to a jump (call) to
4956          the absolute address given by the constant.  Since ix86 jumps and
4957          calls are pc relative, we need to generate a reloc.  */
4958       i.op[0].disps->X_add_symbol = &abs_symbol;
4959       i.op[0].disps->X_op = O_symbol;
4960     }
4961
4962   /* For 8 bit registers we need an empty rex prefix.  Also if the
4963      instruction already has a prefix, we need to convert old
4964      registers to new ones.  */
4965
4966   if ((i.types[0].bitfield.class == Reg && i.types[0].bitfield.byte
4967        && (i.op[0].regs->reg_flags & RegRex64) != 0)
4968       || (i.types[1].bitfield.class == Reg && i.types[1].bitfield.byte
4969           && (i.op[1].regs->reg_flags & RegRex64) != 0)
4970       || (((i.types[0].bitfield.class == Reg && i.types[0].bitfield.byte)
4971            || (i.types[1].bitfield.class == Reg && i.types[1].bitfield.byte))
4972           && i.rex != 0))
4973     {
4974       int x;
4975
4976       i.rex |= REX_OPCODE;
4977       for (x = 0; x < 2; x++)
4978         {
4979           /* Look for 8 bit operand that uses old registers.  */
4980           if (i.types[x].bitfield.class == Reg && i.types[x].bitfield.byte
4981               && (i.op[x].regs->reg_flags & RegRex64) == 0)
4982             {
4983               gas_assert (!(i.op[x].regs->reg_flags & RegRex));
4984               /* In case it is "hi" register, give up.  */
4985               if (i.op[x].regs->reg_num > 3)
4986                 as_bad (_("can't encode register '%s%s' in an "
4987                           "instruction requiring REX prefix."),
4988                         register_prefix, i.op[x].regs->reg_name);
4989
4990               /* Otherwise it is equivalent to the extended register.
4991                  Since the encoding doesn't change this is merely
4992                  cosmetic cleanup for debug output.  */
4993
4994               i.op[x].regs = i.op[x].regs + 8;
4995             }
4996         }
4997     }
4998
4999   if (i.rex == 0 && i.rex_encoding)
5000     {
5001       /* Check if we can add a REX_OPCODE byte.  Look for 8 bit operand
5002          that uses legacy register.  If it is "hi" register, don't add
5003          the REX_OPCODE byte.  */
5004       int x;
5005       for (x = 0; x < 2; x++)
5006         if (i.types[x].bitfield.class == Reg
5007             && i.types[x].bitfield.byte
5008             && (i.op[x].regs->reg_flags & RegRex64) == 0
5009             && i.op[x].regs->reg_num > 3)
5010           {
5011             gas_assert (!(i.op[x].regs->reg_flags & RegRex));
5012             i.rex_encoding = FALSE;
5013             break;
5014           }
5015
5016       if (i.rex_encoding)
5017         i.rex = REX_OPCODE;
5018     }
5019
5020   if (i.rex != 0)
5021     add_prefix (REX_OPCODE | i.rex);
5022
5023   insert_lfence_before ();
5024
5025   /* We are ready to output the insn.  */
5026   output_insn ();
5027
5028   insert_lfence_after ();
5029
5030   last_insn.seg = now_seg;
5031
5032   if (i.tm.opcode_modifier.isprefix)
5033     {
5034       last_insn.kind = last_insn_prefix;
5035       last_insn.name = i.tm.name;
5036       last_insn.file = as_where (&last_insn.line);
5037     }
5038   else
5039     last_insn.kind = last_insn_other;
5040 }
5041
5042 static char *
5043 parse_insn (char *line, char *mnemonic)
5044 {
5045   char *l = line;
5046   char *token_start = l;
5047   char *mnem_p;
5048   int supported;
5049   const insn_template *t;
5050   char *dot_p = NULL;
5051
5052   while (1)
5053     {
5054       mnem_p = mnemonic;
5055       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
5056         {
5057           if (*mnem_p == '.')
5058             dot_p = mnem_p;
5059           mnem_p++;
5060           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
5061             {
5062               as_bad (_("no such instruction: `%s'"), token_start);
5063               return NULL;
5064             }
5065           l++;
5066         }
5067       if (!is_space_char (*l)
5068           && *l != END_OF_INSN
5069           && (intel_syntax
5070               || (*l != PREFIX_SEPARATOR
5071                   && *l != ',')))
5072         {
5073           as_bad (_("invalid character %s in mnemonic"),
5074                   output_invalid (*l));
5075           return NULL;
5076         }
5077       if (token_start == l)
5078         {
5079           if (!intel_syntax && *l == PREFIX_SEPARATOR)
5080             as_bad (_("expecting prefix; got nothing"));
5081           else
5082             as_bad (_("expecting mnemonic; got nothing"));
5083           return NULL;
5084         }
5085
5086       /* Look up instruction (or prefix) via hash table.  */
5087       current_templates = (const templates *) str_hash_find (op_hash, mnemonic);
5088
5089       if (*l != END_OF_INSN
5090           && (!is_space_char (*l) || l[1] != END_OF_INSN)
5091           && current_templates
5092           && current_templates->start->opcode_modifier.isprefix)
5093         {
5094           if (!cpu_flags_check_cpu64 (current_templates->start->cpu_flags))
5095             {
5096               as_bad ((flag_code != CODE_64BIT
5097                        ? _("`%s' is only supported in 64-bit mode")
5098                        : _("`%s' is not supported in 64-bit mode")),
5099                       current_templates->start->name);
5100               return NULL;
5101             }
5102           /* If we are in 16-bit mode, do not allow addr16 or data16.
5103              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
5104           if ((current_templates->start->opcode_modifier.size == SIZE16
5105                || current_templates->start->opcode_modifier.size == SIZE32)
5106               && flag_code != CODE_64BIT
5107               && ((current_templates->start->opcode_modifier.size == SIZE32)
5108                   ^ (flag_code == CODE_16BIT)))
5109             {
5110               as_bad (_("redundant %s prefix"),
5111                       current_templates->start->name);
5112               return NULL;
5113             }
5114           if (current_templates->start->opcode_length == 0)
5115             {
5116               /* Handle pseudo prefixes.  */
5117               switch (current_templates->start->base_opcode)
5118                 {
5119                 case Prefix_Disp8:
5120                   /* {disp8} */
5121                   i.disp_encoding = disp_encoding_8bit;
5122                   break;
5123                 case Prefix_Disp16:
5124                   /* {disp16} */
5125                   i.disp_encoding = disp_encoding_16bit;
5126                   break;
5127                 case Prefix_Disp32:
5128                   /* {disp32} */
5129                   i.disp_encoding = disp_encoding_32bit;
5130                   break;
5131                 case Prefix_Load:
5132                   /* {load} */
5133                   i.dir_encoding = dir_encoding_load;
5134                   break;
5135                 case Prefix_Store:
5136                   /* {store} */
5137                   i.dir_encoding = dir_encoding_store;
5138                   break;
5139                 case Prefix_VEX:
5140                   /* {vex} */
5141                   i.vec_encoding = vex_encoding_vex;
5142                   break;
5143                 case Prefix_VEX3:
5144                   /* {vex3} */
5145                   i.vec_encoding = vex_encoding_vex3;
5146                   break;
5147                 case Prefix_EVEX:
5148                   /* {evex} */
5149                   i.vec_encoding = vex_encoding_evex;
5150                   break;
5151                 case Prefix_REX:
5152                   /* {rex} */
5153                   i.rex_encoding = TRUE;
5154                   break;
5155                 case Prefix_NoOptimize:
5156                   /* {nooptimize} */
5157                   i.no_optimize = TRUE;
5158                   break;
5159                 default:
5160                   abort ();
5161                 }
5162             }
5163           else
5164             {
5165               /* Add prefix, checking for repeated prefixes.  */
5166               switch (add_prefix (current_templates->start->base_opcode))
5167                 {
5168                 case PREFIX_EXIST:
5169                   return NULL;
5170                 case PREFIX_DS:
5171                   if (current_templates->start->cpu_flags.bitfield.cpuibt)
5172                     i.notrack_prefix = current_templates->start->name;
5173                   break;
5174                 case PREFIX_REP:
5175                   if (current_templates->start->cpu_flags.bitfield.cpuhle)
5176                     i.hle_prefix = current_templates->start->name;
5177                   else if (current_templates->start->cpu_flags.bitfield.cpumpx)
5178                     i.bnd_prefix = current_templates->start->name;
5179                   else
5180                     i.rep_prefix = current_templates->start->name;
5181                   break;
5182                 default:
5183                   break;
5184                 }
5185             }
5186           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
5187           token_start = ++l;
5188         }
5189       else
5190         break;
5191     }
5192
5193   if (!current_templates)
5194     {
5195       /* Deprecated functionality (new code should use pseudo-prefixes instead):
5196          Check if we should swap operand or force 32bit displacement in
5197          encoding.  */
5198       if (mnem_p - 2 == dot_p && dot_p[1] == 's')
5199         i.dir_encoding = dir_encoding_swap;
5200       else if (mnem_p - 3 == dot_p
5201                && dot_p[1] == 'd'
5202                && dot_p[2] == '8')
5203         i.disp_encoding = disp_encoding_8bit;
5204       else if (mnem_p - 4 == dot_p
5205                && dot_p[1] == 'd'
5206                && dot_p[2] == '3'
5207                && dot_p[3] == '2')
5208         i.disp_encoding = disp_encoding_32bit;
5209       else
5210         goto check_suffix;
5211       mnem_p = dot_p;
5212       *dot_p = '\0';
5213       current_templates = (const templates *) str_hash_find (op_hash, mnemonic);
5214     }
5215
5216   if (!current_templates)
5217     {
5218     check_suffix:
5219       if (mnem_p > mnemonic)
5220         {
5221           /* See if we can get a match by trimming off a suffix.  */
5222           switch (mnem_p[-1])
5223             {
5224             case WORD_MNEM_SUFFIX:
5225               if (intel_syntax && (intel_float_operand (mnemonic) & 2))
5226                 i.suffix = SHORT_MNEM_SUFFIX;
5227               else
5228                 /* Fall through.  */
5229               case BYTE_MNEM_SUFFIX:
5230               case QWORD_MNEM_SUFFIX:
5231                 i.suffix = mnem_p[-1];
5232               mnem_p[-1] = '\0';
5233               current_templates
5234                 = (const templates *) str_hash_find (op_hash, mnemonic);
5235               break;
5236             case SHORT_MNEM_SUFFIX:
5237             case LONG_MNEM_SUFFIX:
5238               if (!intel_syntax)
5239                 {
5240                   i.suffix = mnem_p[-1];
5241                   mnem_p[-1] = '\0';
5242                   current_templates
5243                     = (const templates *) str_hash_find (op_hash, mnemonic);
5244                 }
5245               break;
5246
5247               /* Intel Syntax.  */
5248             case 'd':
5249               if (intel_syntax)
5250                 {
5251                   if (intel_float_operand (mnemonic) == 1)
5252                     i.suffix = SHORT_MNEM_SUFFIX;
5253                   else
5254                     i.suffix = LONG_MNEM_SUFFIX;
5255                   mnem_p[-1] = '\0';
5256                   current_templates
5257                     = (const templates *) str_hash_find (op_hash, mnemonic);
5258                 }
5259               break;
5260             }
5261         }
5262
5263       if (!current_templates)
5264         {
5265           as_bad (_("no such instruction: `%s'"), token_start);
5266           return NULL;
5267         }
5268     }
5269
5270   if (current_templates->start->opcode_modifier.jump == JUMP
5271       || current_templates->start->opcode_modifier.jump == JUMP_BYTE)
5272     {
5273       /* Check for a branch hint.  We allow ",pt" and ",pn" for
5274          predict taken and predict not taken respectively.
5275          I'm not sure that branch hints actually do anything on loop
5276          and jcxz insns (JumpByte) for current Pentium4 chips.  They
5277          may work in the future and it doesn't hurt to accept them
5278          now.  */
5279       if (l[0] == ',' && l[1] == 'p')
5280         {
5281           if (l[2] == 't')
5282             {
5283               if (!add_prefix (DS_PREFIX_OPCODE))
5284                 return NULL;
5285               l += 3;
5286             }
5287           else if (l[2] == 'n')
5288             {
5289               if (!add_prefix (CS_PREFIX_OPCODE))
5290                 return NULL;
5291               l += 3;
5292             }
5293         }
5294     }
5295   /* Any other comma loses.  */
5296   if (*l == ',')
5297     {
5298       as_bad (_("invalid character %s in mnemonic"),
5299               output_invalid (*l));
5300       return NULL;
5301     }
5302
5303   /* Check if instruction is supported on specified architecture.  */
5304   supported = 0;
5305   for (t = current_templates->start; t < current_templates->end; ++t)
5306     {
5307       supported |= cpu_flags_match (t);
5308       if (supported == CPU_FLAGS_PERFECT_MATCH)
5309         {
5310           if (!cpu_arch_flags.bitfield.cpui386 && (flag_code != CODE_16BIT))
5311             as_warn (_("use .code16 to ensure correct addressing mode"));
5312
5313           return l;
5314         }
5315     }
5316
5317   if (!(supported & CPU_FLAGS_64BIT_MATCH))
5318     as_bad (flag_code == CODE_64BIT
5319             ? _("`%s' is not supported in 64-bit mode")
5320             : _("`%s' is only supported in 64-bit mode"),
5321             current_templates->start->name);
5322   else
5323     as_bad (_("`%s' is not supported on `%s%s'"),
5324             current_templates->start->name,
5325             cpu_arch_name ? cpu_arch_name : default_arch,
5326             cpu_sub_arch_name ? cpu_sub_arch_name : "");
5327
5328   return NULL;
5329 }
5330
5331 static char *
5332 parse_operands (char *l, const char *mnemonic)
5333 {
5334   char *token_start;
5335
5336   /* 1 if operand is pending after ','.  */
5337   unsigned int expecting_operand = 0;
5338
5339   /* Non-zero if operand parens not balanced.  */
5340   unsigned int paren_not_balanced;
5341
5342   while (*l != END_OF_INSN)
5343     {
5344       /* Skip optional white space before operand.  */
5345       if (is_space_char (*l))
5346         ++l;
5347       if (!is_operand_char (*l) && *l != END_OF_INSN && *l != '"')
5348         {
5349           as_bad (_("invalid character %s before operand %d"),
5350                   output_invalid (*l),
5351                   i.operands + 1);
5352           return NULL;
5353         }
5354       token_start = l;  /* After white space.  */
5355       paren_not_balanced = 0;
5356       while (paren_not_balanced || *l != ',')
5357         {
5358           if (*l == END_OF_INSN)
5359             {
5360               if (paren_not_balanced)
5361                 {
5362                   if (!intel_syntax)
5363                     as_bad (_("unbalanced parenthesis in operand %d."),
5364                             i.operands + 1);
5365                   else
5366                     as_bad (_("unbalanced brackets in operand %d."),
5367                             i.operands + 1);
5368                   return NULL;
5369                 }
5370               else
5371                 break;  /* we are done */
5372             }
5373           else if (!is_operand_char (*l) && !is_space_char (*l) && *l != '"')
5374             {
5375               as_bad (_("invalid character %s in operand %d"),
5376                       output_invalid (*l),
5377                       i.operands + 1);
5378               return NULL;
5379             }
5380           if (!intel_syntax)
5381             {
5382               if (*l == '(')
5383                 ++paren_not_balanced;
5384               if (*l == ')')
5385                 --paren_not_balanced;
5386             }
5387           else
5388             {
5389               if (*l == '[')
5390                 ++paren_not_balanced;
5391               if (*l == ']')
5392                 --paren_not_balanced;
5393             }
5394           l++;
5395         }
5396       if (l != token_start)
5397         {                       /* Yes, we've read in another operand.  */
5398           unsigned int operand_ok;
5399           this_operand = i.operands++;
5400           if (i.operands > MAX_OPERANDS)
5401             {
5402               as_bad (_("spurious operands; (%d operands/instruction max)"),
5403                       MAX_OPERANDS);
5404               return NULL;
5405             }
5406           i.types[this_operand].bitfield.unspecified = 1;
5407           /* Now parse operand adding info to 'i' as we go along.  */
5408           END_STRING_AND_SAVE (l);
5409
5410           if (i.mem_operands > 1)
5411             {
5412               as_bad (_("too many memory references for `%s'"),
5413                       mnemonic);
5414               return 0;
5415             }
5416
5417           if (intel_syntax)
5418             operand_ok =
5419               i386_intel_operand (token_start,
5420                                   intel_float_operand (mnemonic));
5421           else
5422             operand_ok = i386_att_operand (token_start);
5423
5424           RESTORE_END_STRING (l);
5425           if (!operand_ok)
5426             return NULL;
5427         }
5428       else
5429         {
5430           if (expecting_operand)
5431             {
5432             expecting_operand_after_comma:
5433               as_bad (_("expecting operand after ','; got nothing"));
5434               return NULL;
5435             }
5436           if (*l == ',')
5437             {
5438               as_bad (_("expecting operand before ','; got nothing"));
5439               return NULL;
5440             }
5441         }
5442
5443       /* Now *l must be either ',' or END_OF_INSN.  */
5444       if (*l == ',')
5445         {
5446           if (*++l == END_OF_INSN)
5447             {
5448               /* Just skip it, if it's \n complain.  */
5449               goto expecting_operand_after_comma;
5450             }
5451           expecting_operand = 1;
5452         }
5453     }
5454   return l;
5455 }
5456
5457 static void
5458 swap_2_operands (int xchg1, int xchg2)
5459 {
5460   union i386_op temp_op;
5461   i386_operand_type temp_type;
5462   unsigned int temp_flags;
5463   enum bfd_reloc_code_real temp_reloc;
5464
5465   temp_type = i.types[xchg2];
5466   i.types[xchg2] = i.types[xchg1];
5467   i.types[xchg1] = temp_type;
5468
5469   temp_flags = i.flags[xchg2];
5470   i.flags[xchg2] = i.flags[xchg1];
5471   i.flags[xchg1] = temp_flags;
5472
5473   temp_op = i.op[xchg2];
5474   i.op[xchg2] = i.op[xchg1];
5475   i.op[xchg1] = temp_op;
5476
5477   temp_reloc = i.reloc[xchg2];
5478   i.reloc[xchg2] = i.reloc[xchg1];
5479   i.reloc[xchg1] = temp_reloc;
5480
5481   if (i.mask)
5482     {
5483       if (i.mask->operand == xchg1)
5484         i.mask->operand = xchg2;
5485       else if (i.mask->operand == xchg2)
5486         i.mask->operand = xchg1;
5487     }
5488   if (i.broadcast)
5489     {
5490       if (i.broadcast->operand == xchg1)
5491         i.broadcast->operand = xchg2;
5492       else if (i.broadcast->operand == xchg2)
5493         i.broadcast->operand = xchg1;
5494     }
5495   if (i.rounding)
5496     {
5497       if (i.rounding->operand == xchg1)
5498         i.rounding->operand = xchg2;
5499       else if (i.rounding->operand == xchg2)
5500         i.rounding->operand = xchg1;
5501     }
5502 }
5503
5504 static void
5505 swap_operands (void)
5506 {
5507   switch (i.operands)
5508     {
5509     case 5:
5510     case 4:
5511       swap_2_operands (1, i.operands - 2);
5512       /* Fall through.  */
5513     case 3:
5514     case 2:
5515       swap_2_operands (0, i.operands - 1);
5516       break;
5517     default:
5518       abort ();
5519     }
5520
5521   if (i.mem_operands == 2)
5522     {
5523       const seg_entry *temp_seg;
5524       temp_seg = i.seg[0];
5525       i.seg[0] = i.seg[1];
5526       i.seg[1] = temp_seg;
5527     }
5528 }
5529
5530 /* Try to ensure constant immediates are represented in the smallest
5531    opcode possible.  */
5532 static void
5533 optimize_imm (void)
5534 {
5535   char guess_suffix = 0;
5536   int op;
5537
5538   if (i.suffix)
5539     guess_suffix = i.suffix;
5540   else if (i.reg_operands)
5541     {
5542       /* Figure out a suffix from the last register operand specified.
5543          We can't do this properly yet, i.e. excluding special register
5544          instances, but the following works for instructions with
5545          immediates.  In any case, we can't set i.suffix yet.  */
5546       for (op = i.operands; --op >= 0;)
5547         if (i.types[op].bitfield.class != Reg)
5548           continue;
5549         else if (i.types[op].bitfield.byte)
5550           {
5551             guess_suffix = BYTE_MNEM_SUFFIX;
5552             break;
5553           }
5554         else if (i.types[op].bitfield.word)
5555           {
5556             guess_suffix = WORD_MNEM_SUFFIX;
5557             break;
5558           }
5559         else if (i.types[op].bitfield.dword)
5560           {
5561             guess_suffix = LONG_MNEM_SUFFIX;
5562             break;
5563           }
5564         else if (i.types[op].bitfield.qword)
5565           {
5566             guess_suffix = QWORD_MNEM_SUFFIX;
5567             break;
5568           }
5569     }
5570   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
5571     guess_suffix = WORD_MNEM_SUFFIX;
5572
5573   for (op = i.operands; --op >= 0;)
5574     if (operand_type_check (i.types[op], imm))
5575       {
5576         switch (i.op[op].imms->X_op)
5577           {
5578           case O_constant:
5579             /* If a suffix is given, this operand may be shortened.  */
5580             switch (guess_suffix)
5581               {
5582               case LONG_MNEM_SUFFIX:
5583                 i.types[op].bitfield.imm32 = 1;
5584                 i.types[op].bitfield.imm64 = 1;
5585                 break;
5586               case WORD_MNEM_SUFFIX:
5587                 i.types[op].bitfield.imm16 = 1;
5588                 i.types[op].bitfield.imm32 = 1;
5589                 i.types[op].bitfield.imm32s = 1;
5590                 i.types[op].bitfield.imm64 = 1;
5591                 break;
5592               case BYTE_MNEM_SUFFIX:
5593                 i.types[op].bitfield.imm8 = 1;
5594                 i.types[op].bitfield.imm8s = 1;
5595                 i.types[op].bitfield.imm16 = 1;
5596                 i.types[op].bitfield.imm32 = 1;
5597                 i.types[op].bitfield.imm32s = 1;
5598                 i.types[op].bitfield.imm64 = 1;
5599                 break;
5600               }
5601
5602             /* If this operand is at most 16 bits, convert it
5603                to a signed 16 bit number before trying to see
5604                whether it will fit in an even smaller size.
5605                This allows a 16-bit operand such as $0xffe0 to
5606                be recognised as within Imm8S range.  */
5607             if ((i.types[op].bitfield.imm16)
5608                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
5609               {
5610                 i.op[op].imms->X_add_number =
5611                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
5612               }
5613 #ifdef BFD64
5614             /* Store 32-bit immediate in 64-bit for 64-bit BFD.  */
5615             if ((i.types[op].bitfield.imm32)
5616                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
5617                     == 0))
5618               {
5619                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
5620                                                 ^ ((offsetT) 1 << 31))
5621                                                - ((offsetT) 1 << 31));
5622               }
5623 #endif
5624             i.types[op]
5625               = operand_type_or (i.types[op],
5626                                  smallest_imm_type (i.op[op].imms->X_add_number));
5627
5628             /* We must avoid matching of Imm32 templates when 64bit
5629                only immediate is available.  */
5630             if (guess_suffix == QWORD_MNEM_SUFFIX)
5631               i.types[op].bitfield.imm32 = 0;
5632             break;
5633
5634           case O_absent:
5635           case O_register:
5636             abort ();
5637
5638             /* Symbols and expressions.  */
5639           default:
5640             /* Convert symbolic operand to proper sizes for matching, but don't
5641                prevent matching a set of insns that only supports sizes other
5642                than those matching the insn suffix.  */
5643             {
5644               i386_operand_type mask, allowed;
5645               const insn_template *t;
5646
5647               operand_type_set (&mask, 0);
5648               operand_type_set (&allowed, 0);
5649
5650               for (t = current_templates->start;
5651                    t < current_templates->end;
5652                    ++t)
5653                 {
5654                   allowed = operand_type_or (allowed, t->operand_types[op]);
5655                   allowed = operand_type_and (allowed, anyimm);
5656                 }
5657               switch (guess_suffix)
5658                 {
5659                 case QWORD_MNEM_SUFFIX:
5660                   mask.bitfield.imm64 = 1;
5661                   mask.bitfield.imm32s = 1;
5662                   break;
5663                 case LONG_MNEM_SUFFIX:
5664                   mask.bitfield.imm32 = 1;
5665                   break;
5666                 case WORD_MNEM_SUFFIX:
5667                   mask.bitfield.imm16 = 1;
5668                   break;
5669                 case BYTE_MNEM_SUFFIX:
5670                   mask.bitfield.imm8 = 1;
5671                   break;
5672                 default:
5673                   break;
5674                 }
5675               allowed = operand_type_and (mask, allowed);
5676               if (!operand_type_all_zero (&allowed))
5677                 i.types[op] = operand_type_and (i.types[op], mask);
5678             }
5679             break;
5680           }
5681       }
5682 }
5683
5684 /* Try to use the smallest displacement type too.  */
5685 static void
5686 optimize_disp (void)
5687 {
5688   int op;
5689
5690   for (op = i.operands; --op >= 0;)
5691     if (operand_type_check (i.types[op], disp))
5692       {
5693         if (i.op[op].disps->X_op == O_constant)
5694           {
5695             offsetT op_disp = i.op[op].disps->X_add_number;
5696
5697             if (i.types[op].bitfield.disp16
5698                 && (op_disp & ~(offsetT) 0xffff) == 0)
5699               {
5700                 /* If this operand is at most 16 bits, convert
5701                    to a signed 16 bit number and don't use 64bit
5702                    displacement.  */
5703                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
5704                 i.types[op].bitfield.disp64 = 0;
5705               }
5706 #ifdef BFD64
5707             /* Optimize 64-bit displacement to 32-bit for 64-bit BFD.  */
5708             if (i.types[op].bitfield.disp32
5709                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
5710               {
5711                 /* If this operand is at most 32 bits, convert
5712                    to a signed 32 bit number and don't use 64bit
5713                    displacement.  */
5714                 op_disp &= (((offsetT) 2 << 31) - 1);
5715                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
5716                 i.types[op].bitfield.disp64 = 0;
5717               }
5718 #endif
5719             if (!op_disp && i.types[op].bitfield.baseindex)
5720               {
5721                 i.types[op].bitfield.disp8 = 0;
5722                 i.types[op].bitfield.disp16 = 0;
5723                 i.types[op].bitfield.disp32 = 0;
5724                 i.types[op].bitfield.disp32s = 0;
5725                 i.types[op].bitfield.disp64 = 0;
5726                 i.op[op].disps = 0;
5727                 i.disp_operands--;
5728               }
5729             else if (flag_code == CODE_64BIT)
5730               {
5731                 if (fits_in_signed_long (op_disp))
5732                   {
5733                     i.types[op].bitfield.disp64 = 0;
5734                     i.types[op].bitfield.disp32s = 1;
5735                   }
5736                 if (i.prefix[ADDR_PREFIX]
5737                     && fits_in_unsigned_long (op_disp))
5738                   i.types[op].bitfield.disp32 = 1;
5739               }
5740             if ((i.types[op].bitfield.disp32
5741                  || i.types[op].bitfield.disp32s
5742                  || i.types[op].bitfield.disp16)
5743                 && fits_in_disp8 (op_disp))
5744               i.types[op].bitfield.disp8 = 1;
5745           }
5746         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
5747                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
5748           {
5749             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
5750                          i.op[op].disps, 0, i.reloc[op]);
5751             i.types[op].bitfield.disp8 = 0;
5752             i.types[op].bitfield.disp16 = 0;
5753             i.types[op].bitfield.disp32 = 0;
5754             i.types[op].bitfield.disp32s = 0;
5755             i.types[op].bitfield.disp64 = 0;
5756           }
5757         else
5758           /* We only support 64bit displacement on constants.  */
5759           i.types[op].bitfield.disp64 = 0;
5760       }
5761 }
5762
5763 /* Return 1 if there is a match in broadcast bytes between operand
5764    GIVEN and instruction template T.   */
5765
5766 static INLINE int
5767 match_broadcast_size (const insn_template *t, unsigned int given)
5768 {
5769   return ((t->opcode_modifier.broadcast == BYTE_BROADCAST
5770            && i.types[given].bitfield.byte)
5771           || (t->opcode_modifier.broadcast == WORD_BROADCAST
5772               && i.types[given].bitfield.word)
5773           || (t->opcode_modifier.broadcast == DWORD_BROADCAST
5774               && i.types[given].bitfield.dword)
5775           || (t->opcode_modifier.broadcast == QWORD_BROADCAST
5776               && i.types[given].bitfield.qword));
5777 }
5778
5779 /* Check if operands are valid for the instruction.  */
5780
5781 static int
5782 check_VecOperands (const insn_template *t)
5783 {
5784   unsigned int op;
5785   i386_cpu_flags cpu;
5786
5787   /* Templates allowing for ZMMword as well as YMMword and/or XMMword for
5788      any one operand are implicity requiring AVX512VL support if the actual
5789      operand size is YMMword or XMMword.  Since this function runs after
5790      template matching, there's no need to check for YMMword/XMMword in
5791      the template.  */
5792   cpu = cpu_flags_and (t->cpu_flags, avx512);
5793   if (!cpu_flags_all_zero (&cpu)
5794       && !t->cpu_flags.bitfield.cpuavx512vl
5795       && !cpu_arch_flags.bitfield.cpuavx512vl)
5796     {
5797       for (op = 0; op < t->operands; ++op)
5798         {
5799           if (t->operand_types[op].bitfield.zmmword
5800               && (i.types[op].bitfield.ymmword
5801                   || i.types[op].bitfield.xmmword))
5802             {
5803               i.error = unsupported;
5804               return 1;
5805             }
5806         }
5807     }
5808
5809   /* Without VSIB byte, we can't have a vector register for index.  */
5810   if (!t->opcode_modifier.sib
5811       && i.index_reg
5812       && (i.index_reg->reg_type.bitfield.xmmword
5813           || i.index_reg->reg_type.bitfield.ymmword
5814           || i.index_reg->reg_type.bitfield.zmmword))
5815     {
5816       i.error = unsupported_vector_index_register;
5817       return 1;
5818     }
5819
5820   /* Check if default mask is allowed.  */
5821   if (t->opcode_modifier.nodefmask
5822       && (!i.mask || i.mask->mask->reg_num == 0))
5823     {
5824       i.error = no_default_mask;
5825       return 1;
5826     }
5827
5828   /* For VSIB byte, we need a vector register for index, and all vector
5829      registers must be distinct.  */
5830   if (t->opcode_modifier.sib && t->opcode_modifier.sib != SIBMEM)
5831     {
5832       if (!i.index_reg
5833           || !((t->opcode_modifier.sib == VECSIB128
5834                 && i.index_reg->reg_type.bitfield.xmmword)
5835                || (t->opcode_modifier.sib == VECSIB256
5836                    && i.index_reg->reg_type.bitfield.ymmword)
5837                || (t->opcode_modifier.sib == VECSIB512
5838                    && i.index_reg->reg_type.bitfield.zmmword)))
5839       {
5840         i.error = invalid_vsib_address;
5841         return 1;
5842       }
5843
5844       gas_assert (i.reg_operands == 2 || i.mask);
5845       if (i.reg_operands == 2 && !i.mask)
5846         {
5847           gas_assert (i.types[0].bitfield.class == RegSIMD);
5848           gas_assert (i.types[0].bitfield.xmmword
5849                       || i.types[0].bitfield.ymmword);
5850           gas_assert (i.types[2].bitfield.class == RegSIMD);
5851           gas_assert (i.types[2].bitfield.xmmword
5852                       || i.types[2].bitfield.ymmword);
5853           if (operand_check == check_none)
5854             return 0;
5855           if (register_number (i.op[0].regs)
5856               != register_number (i.index_reg)
5857               && register_number (i.op[2].regs)
5858                  != register_number (i.index_reg)
5859               && register_number (i.op[0].regs)
5860                  != register_number (i.op[2].regs))
5861             return 0;
5862           if (operand_check == check_error)
5863             {
5864               i.error = invalid_vector_register_set;
5865               return 1;
5866             }
5867           as_warn (_("mask, index, and destination registers should be distinct"));
5868         }
5869       else if (i.reg_operands == 1 && i.mask)
5870         {
5871           if (i.types[1].bitfield.class == RegSIMD
5872               && (i.types[1].bitfield.xmmword
5873                   || i.types[1].bitfield.ymmword
5874                   || i.types[1].bitfield.zmmword)
5875               && (register_number (i.op[1].regs)
5876                   == register_number (i.index_reg)))
5877             {
5878               if (operand_check == check_error)
5879                 {
5880                   i.error = invalid_vector_register_set;
5881                   return 1;
5882                 }
5883               if (operand_check != check_none)
5884                 as_warn (_("index and destination registers should be distinct"));
5885             }
5886         }
5887     }
5888
5889   /* For AMX instructions with three tmmword operands, all tmmword operand must be
5890      distinct */
5891   if (t->operand_types[0].bitfield.tmmword
5892       && i.reg_operands == 3)
5893     {
5894       if (register_number (i.op[0].regs)
5895           == register_number (i.op[1].regs)
5896           || register_number (i.op[0].regs)
5897              == register_number (i.op[2].regs)
5898           || register_number (i.op[1].regs)
5899              == register_number (i.op[2].regs))
5900         {
5901           i.error = invalid_tmm_register_set;
5902           return 1;
5903         }
5904     }
5905
5906   /* Check if broadcast is supported by the instruction and is applied
5907      to the memory operand.  */
5908   if (i.broadcast)
5909     {
5910       i386_operand_type type, overlap;
5911
5912       /* Check if specified broadcast is supported in this instruction,
5913          and its broadcast bytes match the memory operand.  */
5914       op = i.broadcast->operand;
5915       if (!t->opcode_modifier.broadcast
5916           || !(i.flags[op] & Operand_Mem)
5917           || (!i.types[op].bitfield.unspecified
5918               && !match_broadcast_size (t, op)))
5919         {
5920         bad_broadcast:
5921           i.error = unsupported_broadcast;
5922           return 1;
5923         }
5924
5925       i.broadcast->bytes = ((1 << (t->opcode_modifier.broadcast - 1))
5926                             * i.broadcast->type);
5927       operand_type_set (&type, 0);
5928       switch (i.broadcast->bytes)
5929         {
5930         case 2:
5931           type.bitfield.word = 1;
5932           break;
5933         case 4:
5934           type.bitfield.dword = 1;
5935           break;
5936         case 8:
5937           type.bitfield.qword = 1;
5938           break;
5939         case 16:
5940           type.bitfield.xmmword = 1;
5941           break;
5942         case 32:
5943           type.bitfield.ymmword = 1;
5944           break;
5945         case 64:
5946           type.bitfield.zmmword = 1;
5947           break;
5948         default:
5949           goto bad_broadcast;
5950         }
5951
5952       overlap = operand_type_and (type, t->operand_types[op]);
5953       if (t->operand_types[op].bitfield.class == RegSIMD
5954           && t->operand_types[op].bitfield.byte
5955              + t->operand_types[op].bitfield.word
5956              + t->operand_types[op].bitfield.dword
5957              + t->operand_types[op].bitfield.qword > 1)
5958         {
5959           overlap.bitfield.xmmword = 0;
5960           overlap.bitfield.ymmword = 0;
5961           overlap.bitfield.zmmword = 0;
5962         }
5963       if (operand_type_all_zero (&overlap))
5964           goto bad_broadcast;
5965
5966       if (t->opcode_modifier.checkregsize)
5967         {
5968           unsigned int j;
5969
5970           type.bitfield.baseindex = 1;
5971           for (j = 0; j < i.operands; ++j)
5972             {
5973               if (j != op
5974                   && !operand_type_register_match(i.types[j],
5975                                                   t->operand_types[j],
5976                                                   type,
5977                                                   t->operand_types[op]))
5978                 goto bad_broadcast;
5979             }
5980         }
5981     }
5982   /* If broadcast is supported in this instruction, we need to check if
5983      operand of one-element size isn't specified without broadcast.  */
5984   else if (t->opcode_modifier.broadcast && i.mem_operands)
5985     {
5986       /* Find memory operand.  */
5987       for (op = 0; op < i.operands; op++)
5988         if (i.flags[op] & Operand_Mem)
5989           break;
5990       gas_assert (op < i.operands);
5991       /* Check size of the memory operand.  */
5992       if (match_broadcast_size (t, op))
5993         {
5994           i.error = broadcast_needed;
5995           return 1;
5996         }
5997     }
5998   else
5999     op = MAX_OPERANDS - 1; /* Avoid uninitialized variable warning.  */
6000
6001   /* Check if requested masking is supported.  */
6002   if (i.mask)
6003     {
6004       switch (t->opcode_modifier.masking)
6005         {
6006         case BOTH_MASKING:
6007           break;
6008         case MERGING_MASKING:
6009           if (i.mask->zeroing)
6010             {
6011         case 0:
6012               i.error = unsupported_masking;
6013               return 1;
6014             }
6015           break;
6016         case DYNAMIC_MASKING:
6017           /* Memory destinations allow only merging masking.  */
6018           if (i.mask->zeroing && i.mem_operands)
6019             {
6020               /* Find memory operand.  */
6021               for (op = 0; op < i.operands; op++)
6022                 if (i.flags[op] & Operand_Mem)
6023                   break;
6024               gas_assert (op < i.operands);
6025               if (op == i.operands - 1)
6026                 {
6027                   i.error = unsupported_masking;
6028                   return 1;
6029                 }
6030             }
6031           break;
6032         default:
6033           abort ();
6034         }
6035     }
6036
6037   /* Check if masking is applied to dest operand.  */
6038   if (i.mask && (i.mask->operand != (int) (i.operands - 1)))
6039     {
6040       i.error = mask_not_on_destination;
6041       return 1;
6042     }
6043
6044   /* Check RC/SAE.  */
6045   if (i.rounding)
6046     {
6047       if (!t->opcode_modifier.sae
6048           || (i.rounding->type != saeonly && !t->opcode_modifier.staticrounding))
6049         {
6050           i.error = unsupported_rc_sae;
6051           return 1;
6052         }
6053       /* If the instruction has several immediate operands and one of
6054          them is rounding, the rounding operand should be the last
6055          immediate operand.  */
6056       if (i.imm_operands > 1
6057           && i.rounding->operand != (int) (i.imm_operands - 1))
6058         {
6059           i.error = rc_sae_operand_not_last_imm;
6060           return 1;
6061         }
6062     }
6063
6064   /* Check the special Imm4 cases; must be the first operand.  */
6065   if (t->cpu_flags.bitfield.cpuxop && t->operands == 5)
6066     {
6067       if (i.op[0].imms->X_op != O_constant
6068           || !fits_in_imm4 (i.op[0].imms->X_add_number))
6069         {
6070           i.error = bad_imm4;
6071           return 1;
6072         }
6073
6074       /* Turn off Imm<N> so that update_imm won't complain.  */
6075       operand_type_set (&i.types[0], 0);
6076     }
6077
6078   /* Check vector Disp8 operand.  */
6079   if (t->opcode_modifier.disp8memshift
6080       && i.disp_encoding != disp_encoding_32bit)
6081     {
6082       if (i.broadcast)
6083         i.memshift = t->opcode_modifier.broadcast - 1;
6084       else if (t->opcode_modifier.disp8memshift != DISP8_SHIFT_VL)
6085         i.memshift = t->opcode_modifier.disp8memshift;
6086       else
6087         {
6088           const i386_operand_type *type = NULL;
6089
6090           i.memshift = 0;
6091           for (op = 0; op < i.operands; op++)
6092             if (i.flags[op] & Operand_Mem)
6093               {
6094                 if (t->opcode_modifier.evex == EVEXLIG)
6095                   i.memshift = 2 + (i.suffix == QWORD_MNEM_SUFFIX);
6096                 else if (t->operand_types[op].bitfield.xmmword
6097                          + t->operand_types[op].bitfield.ymmword
6098                          + t->operand_types[op].bitfield.zmmword <= 1)
6099                   type = &t->operand_types[op];
6100                 else if (!i.types[op].bitfield.unspecified)
6101                   type = &i.types[op];
6102               }
6103             else if (i.types[op].bitfield.class == RegSIMD
6104                      && t->opcode_modifier.evex != EVEXLIG)
6105               {
6106                 if (i.types[op].bitfield.zmmword)
6107                   i.memshift = 6;
6108                 else if (i.types[op].bitfield.ymmword && i.memshift < 5)
6109                   i.memshift = 5;
6110                 else if (i.types[op].bitfield.xmmword && i.memshift < 4)
6111                   i.memshift = 4;
6112               }
6113
6114           if (type)
6115             {
6116               if (type->bitfield.zmmword)
6117                 i.memshift = 6;
6118               else if (type->bitfield.ymmword)
6119                 i.memshift = 5;
6120               else if (type->bitfield.xmmword)
6121                 i.memshift = 4;
6122             }
6123
6124           /* For the check in fits_in_disp8().  */
6125           if (i.memshift == 0)
6126             i.memshift = -1;
6127         }
6128
6129       for (op = 0; op < i.operands; op++)
6130         if (operand_type_check (i.types[op], disp)
6131             && i.op[op].disps->X_op == O_constant)
6132           {
6133             if (fits_in_disp8 (i.op[op].disps->X_add_number))
6134               {
6135                 i.types[op].bitfield.disp8 = 1;
6136                 return 0;
6137               }
6138             i.types[op].bitfield.disp8 = 0;
6139           }
6140     }
6141
6142   i.memshift = 0;
6143
6144   return 0;
6145 }
6146
6147 /* Check if encoding requirements are met by the instruction.  */
6148
6149 static int
6150 VEX_check_encoding (const insn_template *t)
6151 {
6152   if (i.vec_encoding == vex_encoding_error)
6153     {
6154       i.error = unsupported;
6155       return 1;
6156     }
6157
6158   if (i.vec_encoding == vex_encoding_evex)
6159     {
6160       /* This instruction must be encoded with EVEX prefix.  */
6161       if (!is_evex_encoding (t))
6162         {
6163           i.error = unsupported;
6164           return 1;
6165         }
6166       return 0;
6167     }
6168
6169   if (!t->opcode_modifier.vex)
6170     {
6171       /* This instruction template doesn't have VEX prefix.  */
6172       if (i.vec_encoding != vex_encoding_default)
6173         {
6174           i.error = unsupported;
6175           return 1;
6176         }
6177       return 0;
6178     }
6179
6180   return 0;
6181 }
6182
6183 static const insn_template *
6184 match_template (char mnem_suffix)
6185 {
6186   /* Points to template once we've found it.  */
6187   const insn_template *t;
6188   i386_operand_type overlap0, overlap1, overlap2, overlap3;
6189   i386_operand_type overlap4;
6190   unsigned int found_reverse_match;
6191   i386_opcode_modifier suffix_check;
6192   i386_operand_type operand_types [MAX_OPERANDS];
6193   int addr_prefix_disp;
6194   unsigned int j, size_match, check_register;
6195   enum i386_error specific_error = 0;
6196
6197 #if MAX_OPERANDS != 5
6198 # error "MAX_OPERANDS must be 5."
6199 #endif
6200
6201   found_reverse_match = 0;
6202   addr_prefix_disp = -1;
6203
6204   /* Prepare for mnemonic suffix check.  */
6205   memset (&suffix_check, 0, sizeof (suffix_check));
6206   switch (mnem_suffix)
6207     {
6208     case BYTE_MNEM_SUFFIX:
6209       suffix_check.no_bsuf = 1;
6210       break;
6211     case WORD_MNEM_SUFFIX:
6212       suffix_check.no_wsuf = 1;
6213       break;
6214     case SHORT_MNEM_SUFFIX:
6215       suffix_check.no_ssuf = 1;
6216       break;
6217     case LONG_MNEM_SUFFIX:
6218       suffix_check.no_lsuf = 1;
6219       break;
6220     case QWORD_MNEM_SUFFIX:
6221       suffix_check.no_qsuf = 1;
6222       break;
6223     default:
6224       /* NB: In Intel syntax, normally we can check for memory operand
6225          size when there is no mnemonic suffix.  But jmp and call have
6226          2 different encodings with Dword memory operand size, one with
6227          No_ldSuf and the other without.  i.suffix is set to
6228          LONG_DOUBLE_MNEM_SUFFIX to skip the one with No_ldSuf.  */
6229       if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
6230         suffix_check.no_ldsuf = 1;
6231     }
6232
6233   /* Must have right number of operands.  */
6234   i.error = number_of_operands_mismatch;
6235
6236   for (t = current_templates->start; t < current_templates->end; t++)
6237     {
6238       addr_prefix_disp = -1;
6239       found_reverse_match = 0;
6240
6241       if (i.operands != t->operands)
6242         continue;
6243
6244       /* Check processor support.  */
6245       i.error = unsupported;
6246       if (cpu_flags_match (t) != CPU_FLAGS_PERFECT_MATCH)
6247         continue;
6248
6249       /* Check AT&T mnemonic.   */
6250       i.error = unsupported_with_intel_mnemonic;
6251       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
6252         continue;
6253
6254       /* Check AT&T/Intel syntax.  */
6255       i.error = unsupported_syntax;
6256       if ((intel_syntax && t->opcode_modifier.attsyntax)
6257           || (!intel_syntax && t->opcode_modifier.intelsyntax))
6258         continue;
6259
6260       /* Check Intel64/AMD64 ISA.   */
6261       switch (isa64)
6262         {
6263         default:
6264           /* Default: Don't accept Intel64.  */
6265           if (t->opcode_modifier.isa64 == INTEL64)
6266             continue;
6267           break;
6268         case amd64:
6269           /* -mamd64: Don't accept Intel64 and Intel64 only.  */
6270           if (t->opcode_modifier.isa64 >= INTEL64)
6271             continue;
6272           break;
6273         case intel64:
6274           /* -mintel64: Don't accept AMD64.  */
6275           if (t->opcode_modifier.isa64 == AMD64 && flag_code == CODE_64BIT)
6276             continue;
6277           break;
6278         }
6279
6280       /* Check the suffix.  */
6281       i.error = invalid_instruction_suffix;
6282       if ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
6283           || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
6284           || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
6285           || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
6286           || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
6287           || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf))
6288         continue;
6289
6290       size_match = operand_size_match (t);
6291       if (!size_match)
6292         continue;
6293
6294       /* This is intentionally not
6295
6296          if (i.jumpabsolute != (t->opcode_modifier.jump == JUMP_ABSOLUTE))
6297
6298          as the case of a missing * on the operand is accepted (perhaps with
6299          a warning, issued further down).  */
6300       if (i.jumpabsolute && t->opcode_modifier.jump != JUMP_ABSOLUTE)
6301         {
6302           i.error = operand_type_mismatch;
6303           continue;
6304         }
6305
6306       for (j = 0; j < MAX_OPERANDS; j++)
6307         operand_types[j] = t->operand_types[j];
6308
6309       /* In general, don't allow
6310          - 64-bit operands outside of 64-bit mode,
6311          - 32-bit operands on pre-386.  */
6312       j = i.imm_operands + (t->operands > i.imm_operands + 1);
6313       if (((i.suffix == QWORD_MNEM_SUFFIX
6314             && flag_code != CODE_64BIT
6315             && (t->base_opcode != 0x0fc7
6316                 || t->extension_opcode != 1 /* cmpxchg8b */))
6317            || (i.suffix == LONG_MNEM_SUFFIX
6318                && !cpu_arch_flags.bitfield.cpui386))
6319           && (intel_syntax
6320               ? (t->opcode_modifier.mnemonicsize != IGNORESIZE
6321                  && !intel_float_operand (t->name))
6322               : intel_float_operand (t->name) != 2)
6323           && (t->operands == i.imm_operands
6324               || (operand_types[i.imm_operands].bitfield.class != RegMMX
6325                && operand_types[i.imm_operands].bitfield.class != RegSIMD
6326                && operand_types[i.imm_operands].bitfield.class != RegMask)
6327               || (operand_types[j].bitfield.class != RegMMX
6328                   && operand_types[j].bitfield.class != RegSIMD
6329                   && operand_types[j].bitfield.class != RegMask))
6330           && !t->opcode_modifier.sib)
6331         continue;
6332
6333       /* Do not verify operands when there are none.  */
6334       if (!t->operands)
6335         {
6336           if (VEX_check_encoding (t))
6337             {
6338               specific_error = i.error;
6339               continue;
6340             }
6341
6342           /* We've found a match; break out of loop.  */
6343           break;
6344         }
6345
6346       if (!t->opcode_modifier.jump
6347           || t->opcode_modifier.jump == JUMP_ABSOLUTE)
6348         {
6349           /* There should be only one Disp operand.  */
6350           for (j = 0; j < MAX_OPERANDS; j++)
6351             if (operand_type_check (operand_types[j], disp))
6352               break;
6353           if (j < MAX_OPERANDS)
6354             {
6355               bfd_boolean override = (i.prefix[ADDR_PREFIX] != 0);
6356
6357               addr_prefix_disp = j;
6358
6359               /* Address size prefix will turn Disp64/Disp32S/Disp32/Disp16
6360                  operand into Disp32/Disp32/Disp16/Disp32 operand.  */
6361               switch (flag_code)
6362                 {
6363                 case CODE_16BIT:
6364                   override = !override;
6365                   /* Fall through.  */
6366                 case CODE_32BIT:
6367                   if (operand_types[j].bitfield.disp32
6368                       && operand_types[j].bitfield.disp16)
6369                     {
6370                       operand_types[j].bitfield.disp16 = override;
6371                       operand_types[j].bitfield.disp32 = !override;
6372                     }
6373                   operand_types[j].bitfield.disp32s = 0;
6374                   operand_types[j].bitfield.disp64 = 0;
6375                   break;
6376
6377                 case CODE_64BIT:
6378                   if (operand_types[j].bitfield.disp32s
6379                       || operand_types[j].bitfield.disp64)
6380                     {
6381                       operand_types[j].bitfield.disp64 &= !override;
6382                       operand_types[j].bitfield.disp32s &= !override;
6383                       operand_types[j].bitfield.disp32 = override;
6384                     }
6385                   operand_types[j].bitfield.disp16 = 0;
6386                   break;
6387                 }
6388             }
6389         }
6390
6391       /* Force 0x8b encoding for "mov foo@GOT, %eax".  */
6392       if (i.reloc[0] == BFD_RELOC_386_GOT32 && t->base_opcode == 0xa0)
6393         continue;
6394
6395       /* We check register size if needed.  */
6396       if (t->opcode_modifier.checkregsize)
6397         {
6398           check_register = (1 << t->operands) - 1;
6399           if (i.broadcast)
6400             check_register &= ~(1 << i.broadcast->operand);
6401         }
6402       else
6403         check_register = 0;
6404
6405       overlap0 = operand_type_and (i.types[0], operand_types[0]);
6406       switch (t->operands)
6407         {
6408         case 1:
6409           if (!operand_type_match (overlap0, i.types[0]))
6410             continue;
6411           break;
6412         case 2:
6413           /* xchg %eax, %eax is a special case. It is an alias for nop
6414              only in 32bit mode and we can use opcode 0x90.  In 64bit
6415              mode, we can't use 0x90 for xchg %eax, %eax since it should
6416              zero-extend %eax to %rax.  */
6417           if (flag_code == CODE_64BIT
6418               && t->base_opcode == 0x90
6419               && i.types[0].bitfield.instance == Accum
6420               && i.types[0].bitfield.dword
6421               && i.types[1].bitfield.instance == Accum
6422               && i.types[1].bitfield.dword)
6423             continue;
6424           /* xrelease mov %eax, <disp> is another special case. It must not
6425              match the accumulator-only encoding of mov.  */
6426           if (flag_code != CODE_64BIT
6427               && i.hle_prefix
6428               && t->base_opcode == 0xa0
6429               && i.types[0].bitfield.instance == Accum
6430               && (i.flags[1] & Operand_Mem))
6431             continue;
6432           /* Fall through.  */
6433
6434         case 3:
6435           if (!(size_match & MATCH_STRAIGHT))
6436             goto check_reverse;
6437           /* Reverse direction of operands if swapping is possible in the first
6438              place (operands need to be symmetric) and
6439              - the load form is requested, and the template is a store form,
6440              - the store form is requested, and the template is a load form,
6441              - the non-default (swapped) form is requested.  */
6442           overlap1 = operand_type_and (operand_types[0], operand_types[1]);
6443           if (t->opcode_modifier.d && i.reg_operands == i.operands
6444               && !operand_type_all_zero (&overlap1))
6445             switch (i.dir_encoding)
6446               {
6447               case dir_encoding_load:
6448                 if (operand_type_check (operand_types[i.operands - 1], anymem)
6449                     || t->opcode_modifier.regmem)
6450                   goto check_reverse;
6451                 break;
6452
6453               case dir_encoding_store:
6454                 if (!operand_type_check (operand_types[i.operands - 1], anymem)
6455                     && !t->opcode_modifier.regmem)
6456                   goto check_reverse;
6457                 break;
6458
6459               case dir_encoding_swap:
6460                 goto check_reverse;
6461
6462               case dir_encoding_default:
6463                 break;
6464               }
6465           /* If we want store form, we skip the current load.  */
6466           if ((i.dir_encoding == dir_encoding_store
6467                || i.dir_encoding == dir_encoding_swap)
6468               && i.mem_operands == 0
6469               && t->opcode_modifier.load)
6470             continue;
6471           /* Fall through.  */
6472         case 4:
6473         case 5:
6474           overlap1 = operand_type_and (i.types[1], operand_types[1]);
6475           if (!operand_type_match (overlap0, i.types[0])
6476               || !operand_type_match (overlap1, i.types[1])
6477               || ((check_register & 3) == 3
6478                   && !operand_type_register_match (i.types[0],
6479                                                    operand_types[0],
6480                                                    i.types[1],
6481                                                    operand_types[1])))
6482             {
6483               /* Check if other direction is valid ...  */
6484               if (!t->opcode_modifier.d)
6485                 continue;
6486
6487             check_reverse:
6488               if (!(size_match & MATCH_REVERSE))
6489                 continue;
6490               /* Try reversing direction of operands.  */
6491               overlap0 = operand_type_and (i.types[0], operand_types[i.operands - 1]);
6492               overlap1 = operand_type_and (i.types[i.operands - 1], operand_types[0]);
6493               if (!operand_type_match (overlap0, i.types[0])
6494                   || !operand_type_match (overlap1, i.types[i.operands - 1])
6495                   || (check_register
6496                       && !operand_type_register_match (i.types[0],
6497                                                        operand_types[i.operands - 1],
6498                                                        i.types[i.operands - 1],
6499                                                        operand_types[0])))
6500                 {
6501                   /* Does not match either direction.  */
6502                   continue;
6503                 }
6504               /* found_reverse_match holds which of D or FloatR
6505                  we've found.  */
6506               if (!t->opcode_modifier.d)
6507                 found_reverse_match = 0;
6508               else if (operand_types[0].bitfield.tbyte)
6509                 found_reverse_match = Opcode_FloatD;
6510               else if (operand_types[0].bitfield.xmmword
6511                        || operand_types[i.operands - 1].bitfield.xmmword
6512                        || operand_types[0].bitfield.class == RegMMX
6513                        || operand_types[i.operands - 1].bitfield.class == RegMMX
6514                        || is_any_vex_encoding(t))
6515                 found_reverse_match = (t->base_opcode & 0xee) != 0x6e
6516                                       ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
6517               else
6518                 found_reverse_match = Opcode_D;
6519               if (t->opcode_modifier.floatr)
6520                 found_reverse_match |= Opcode_FloatR;
6521             }
6522           else
6523             {
6524               /* Found a forward 2 operand match here.  */
6525               switch (t->operands)
6526                 {
6527                 case 5:
6528                   overlap4 = operand_type_and (i.types[4],
6529                                                operand_types[4]);
6530                   /* Fall through.  */
6531                 case 4:
6532                   overlap3 = operand_type_and (i.types[3],
6533                                                operand_types[3]);
6534                   /* Fall through.  */
6535                 case 3:
6536                   overlap2 = operand_type_and (i.types[2],
6537                                                operand_types[2]);
6538                   break;
6539                 }
6540
6541               switch (t->operands)
6542                 {
6543                 case 5:
6544                   if (!operand_type_match (overlap4, i.types[4])
6545                       || !operand_type_register_match (i.types[3],
6546                                                        operand_types[3],
6547                                                        i.types[4],
6548                                                        operand_types[4]))
6549                     continue;
6550                   /* Fall through.  */
6551                 case 4:
6552                   if (!operand_type_match (overlap3, i.types[3])
6553                       || ((check_register & 0xa) == 0xa
6554                           && !operand_type_register_match (i.types[1],
6555                                                             operand_types[1],
6556                                                             i.types[3],
6557                                                             operand_types[3]))
6558                       || ((check_register & 0xc) == 0xc
6559                           && !operand_type_register_match (i.types[2],
6560                                                             operand_types[2],
6561                                                             i.types[3],
6562                                                             operand_types[3])))
6563                     continue;
6564                   /* Fall through.  */
6565                 case 3:
6566                   /* Here we make use of the fact that there are no
6567                      reverse match 3 operand instructions.  */
6568                   if (!operand_type_match (overlap2, i.types[2])
6569                       || ((check_register & 5) == 5
6570                           && !operand_type_register_match (i.types[0],
6571                                                             operand_types[0],
6572                                                             i.types[2],
6573                                                             operand_types[2]))
6574                       || ((check_register & 6) == 6
6575                           && !operand_type_register_match (i.types[1],
6576                                                             operand_types[1],
6577                                                             i.types[2],
6578                                                             operand_types[2])))
6579                     continue;
6580                   break;
6581                 }
6582             }
6583           /* Found either forward/reverse 2, 3 or 4 operand match here:
6584              slip through to break.  */
6585         }
6586
6587       /* Check if vector operands are valid.  */
6588       if (check_VecOperands (t))
6589         {
6590           specific_error = i.error;
6591           continue;
6592         }
6593
6594       /* Check if VEX/EVEX encoding requirements can be satisfied.  */
6595       if (VEX_check_encoding (t))
6596         {
6597           specific_error = i.error;
6598           continue;
6599         }
6600
6601       /* We've found a match; break out of loop.  */
6602       break;
6603     }
6604
6605   if (t == current_templates->end)
6606     {
6607       /* We found no match.  */
6608       const char *err_msg;
6609       switch (specific_error ? specific_error : i.error)
6610         {
6611         default:
6612           abort ();
6613         case operand_size_mismatch:
6614           err_msg = _("operand size mismatch");
6615           break;
6616         case operand_type_mismatch:
6617           err_msg = _("operand type mismatch");
6618           break;
6619         case register_type_mismatch:
6620           err_msg = _("register type mismatch");
6621           break;
6622         case number_of_operands_mismatch:
6623           err_msg = _("number of operands mismatch");
6624           break;
6625         case invalid_instruction_suffix:
6626           err_msg = _("invalid instruction suffix");
6627           break;
6628         case bad_imm4:
6629           err_msg = _("constant doesn't fit in 4 bits");
6630           break;
6631         case unsupported_with_intel_mnemonic:
6632           err_msg = _("unsupported with Intel mnemonic");
6633           break;
6634         case unsupported_syntax:
6635           err_msg = _("unsupported syntax");
6636           break;
6637         case unsupported:
6638           as_bad (_("unsupported instruction `%s'"),
6639                   current_templates->start->name);
6640           return NULL;
6641         case invalid_sib_address:
6642           err_msg = _("invalid SIB address");
6643           break;
6644         case invalid_vsib_address:
6645           err_msg = _("invalid VSIB address");
6646           break;
6647         case invalid_vector_register_set:
6648           err_msg = _("mask, index, and destination registers must be distinct");
6649           break;
6650         case invalid_tmm_register_set:
6651           err_msg = _("all tmm registers must be distinct");
6652           break;
6653         case unsupported_vector_index_register:
6654           err_msg = _("unsupported vector index register");
6655           break;
6656         case unsupported_broadcast:
6657           err_msg = _("unsupported broadcast");
6658           break;
6659         case broadcast_needed:
6660           err_msg = _("broadcast is needed for operand of such type");
6661           break;
6662         case unsupported_masking:
6663           err_msg = _("unsupported masking");
6664           break;
6665         case mask_not_on_destination:
6666           err_msg = _("mask not on destination operand");
6667           break;
6668         case no_default_mask:
6669           err_msg = _("default mask isn't allowed");
6670           break;
6671         case unsupported_rc_sae:
6672           err_msg = _("unsupported static rounding/sae");
6673           break;
6674         case rc_sae_operand_not_last_imm:
6675           if (intel_syntax)
6676             err_msg = _("RC/SAE operand must precede immediate operands");
6677           else
6678             err_msg = _("RC/SAE operand must follow immediate operands");
6679           break;
6680         case invalid_register_operand:
6681           err_msg = _("invalid register operand");
6682           break;
6683         }
6684       as_bad (_("%s for `%s'"), err_msg,
6685               current_templates->start->name);
6686       return NULL;
6687     }
6688
6689   if (!quiet_warnings)
6690     {
6691       if (!intel_syntax
6692           && (i.jumpabsolute != (t->opcode_modifier.jump == JUMP_ABSOLUTE)))
6693         as_warn (_("indirect %s without `*'"), t->name);
6694
6695       if (t->opcode_modifier.isprefix
6696           && t->opcode_modifier.mnemonicsize == IGNORESIZE)
6697         {
6698           /* Warn them that a data or address size prefix doesn't
6699              affect assembly of the next line of code.  */
6700           as_warn (_("stand-alone `%s' prefix"), t->name);
6701         }
6702     }
6703
6704   /* Copy the template we found.  */
6705   i.tm = *t;
6706
6707   if (addr_prefix_disp != -1)
6708     i.tm.operand_types[addr_prefix_disp]
6709       = operand_types[addr_prefix_disp];
6710
6711   if (found_reverse_match)
6712     {
6713       /* If we found a reverse match we must alter the opcode direction
6714          bit and clear/flip the regmem modifier one.  found_reverse_match
6715          holds bits to change (different for int & float insns).  */
6716
6717       i.tm.base_opcode ^= found_reverse_match;
6718
6719       i.tm.operand_types[0] = operand_types[i.operands - 1];
6720       i.tm.operand_types[i.operands - 1] = operand_types[0];
6721
6722       /* Certain SIMD insns have their load forms specified in the opcode
6723          table, and hence we need to _set_ RegMem instead of clearing it.
6724          We need to avoid setting the bit though on insns like KMOVW.  */
6725       i.tm.opcode_modifier.regmem
6726         = i.tm.opcode_modifier.modrm && i.tm.opcode_modifier.d
6727           && i.tm.operands > 2U - i.tm.opcode_modifier.sse2avx
6728           && !i.tm.opcode_modifier.regmem;
6729     }
6730
6731   return t;
6732 }
6733
6734 static int
6735 check_string (void)
6736 {
6737   unsigned int es_op = i.tm.opcode_modifier.isstring - IS_STRING_ES_OP0;
6738   unsigned int op = i.tm.operand_types[0].bitfield.baseindex ? es_op : 0;
6739
6740   if (i.seg[op] != NULL && i.seg[op] != &es)
6741     {
6742       as_bad (_("`%s' operand %u must use `%ses' segment"),
6743               i.tm.name,
6744               intel_syntax ? i.tm.operands - es_op : es_op + 1,
6745               register_prefix);
6746       return 0;
6747     }
6748
6749   /* There's only ever one segment override allowed per instruction.
6750      This instruction possibly has a legal segment override on the
6751      second operand, so copy the segment to where non-string
6752      instructions store it, allowing common code.  */
6753   i.seg[op] = i.seg[1];
6754
6755   return 1;
6756 }
6757
6758 static int
6759 process_suffix (void)
6760 {
6761   /* If matched instruction specifies an explicit instruction mnemonic
6762      suffix, use it.  */
6763   if (i.tm.opcode_modifier.size == SIZE16)
6764     i.suffix = WORD_MNEM_SUFFIX;
6765   else if (i.tm.opcode_modifier.size == SIZE32)
6766     i.suffix = LONG_MNEM_SUFFIX;
6767   else if (i.tm.opcode_modifier.size == SIZE64)
6768     i.suffix = QWORD_MNEM_SUFFIX;
6769   else if (i.reg_operands
6770            && (i.operands > 1 || i.types[0].bitfield.class == Reg)
6771            && !i.tm.opcode_modifier.addrprefixopreg)
6772     {
6773       unsigned int numop = i.operands;
6774
6775       /* movsx/movzx want only their source operand considered here, for the
6776          ambiguity checking below.  The suffix will be replaced afterwards
6777          to represent the destination (register).  */
6778       if (((i.tm.base_opcode | 8) == 0xfbe && i.tm.opcode_modifier.w)
6779           || (i.tm.base_opcode == 0x63 && i.tm.cpu_flags.bitfield.cpu64))
6780         --i.operands;
6781
6782       /* crc32 needs REX.W set regardless of suffix / source operand size.  */
6783       if (i.tm.base_opcode == 0xf20f38f0
6784           && i.tm.operand_types[1].bitfield.qword)
6785         i.rex |= REX_W;
6786
6787       /* If there's no instruction mnemonic suffix we try to invent one
6788          based on GPR operands.  */
6789       if (!i.suffix)
6790         {
6791           /* We take i.suffix from the last register operand specified,
6792              Destination register type is more significant than source
6793              register type.  crc32 in SSE4.2 prefers source register
6794              type. */
6795           unsigned int op = i.tm.base_opcode != 0xf20f38f0 ? i.operands : 1;
6796
6797           while (op--)
6798             if (i.tm.operand_types[op].bitfield.instance == InstanceNone
6799                 || i.tm.operand_types[op].bitfield.instance == Accum)
6800               {
6801                 if (i.types[op].bitfield.class != Reg)
6802                   continue;
6803                 if (i.types[op].bitfield.byte)
6804                   i.suffix = BYTE_MNEM_SUFFIX;
6805                 else if (i.types[op].bitfield.word)
6806                   i.suffix = WORD_MNEM_SUFFIX;
6807                 else if (i.types[op].bitfield.dword)
6808                   i.suffix = LONG_MNEM_SUFFIX;
6809                 else if (i.types[op].bitfield.qword)
6810                   i.suffix = QWORD_MNEM_SUFFIX;
6811                 else
6812                   continue;
6813                 break;
6814               }
6815
6816           /* As an exception, movsx/movzx silently default to a byte source
6817              in AT&T mode.  */
6818           if ((i.tm.base_opcode | 8) == 0xfbe && i.tm.opcode_modifier.w
6819               && !i.suffix && !intel_syntax)
6820             i.suffix = BYTE_MNEM_SUFFIX;
6821         }
6822       else if (i.suffix == BYTE_MNEM_SUFFIX)
6823         {
6824           if (intel_syntax
6825               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6826               && i.tm.opcode_modifier.no_bsuf)
6827             i.suffix = 0;
6828           else if (!check_byte_reg ())
6829             return 0;
6830         }
6831       else if (i.suffix == LONG_MNEM_SUFFIX)
6832         {
6833           if (intel_syntax
6834               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6835               && i.tm.opcode_modifier.no_lsuf
6836               && !i.tm.opcode_modifier.todword
6837               && !i.tm.opcode_modifier.toqword)
6838             i.suffix = 0;
6839           else if (!check_long_reg ())
6840             return 0;
6841         }
6842       else if (i.suffix == QWORD_MNEM_SUFFIX)
6843         {
6844           if (intel_syntax
6845               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6846               && i.tm.opcode_modifier.no_qsuf
6847               && !i.tm.opcode_modifier.todword
6848               && !i.tm.opcode_modifier.toqword)
6849             i.suffix = 0;
6850           else if (!check_qword_reg ())
6851             return 0;
6852         }
6853       else if (i.suffix == WORD_MNEM_SUFFIX)
6854         {
6855           if (intel_syntax
6856               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6857               && i.tm.opcode_modifier.no_wsuf)
6858             i.suffix = 0;
6859           else if (!check_word_reg ())
6860             return 0;
6861         }
6862       else if (intel_syntax
6863                && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE)
6864         /* Do nothing if the instruction is going to ignore the prefix.  */
6865         ;
6866       else
6867         abort ();
6868
6869       /* Undo the movsx/movzx change done above.  */
6870       i.operands = numop;
6871     }
6872   else if (i.tm.opcode_modifier.mnemonicsize == DEFAULTSIZE
6873            && !i.suffix)
6874     {
6875       i.suffix = stackop_size;
6876       if (stackop_size == LONG_MNEM_SUFFIX)
6877         {
6878           /* stackop_size is set to LONG_MNEM_SUFFIX for the
6879              .code16gcc directive to support 16-bit mode with
6880              32-bit address.  For IRET without a suffix, generate
6881              16-bit IRET (opcode 0xcf) to return from an interrupt
6882              handler.  */
6883           if (i.tm.base_opcode == 0xcf)
6884             {
6885               i.suffix = WORD_MNEM_SUFFIX;
6886               as_warn (_("generating 16-bit `iret' for .code16gcc directive"));
6887             }
6888           /* Warn about changed behavior for segment register push/pop.  */
6889           else if ((i.tm.base_opcode | 1) == 0x07)
6890             as_warn (_("generating 32-bit `%s', unlike earlier gas versions"),
6891                      i.tm.name);
6892         }
6893     }
6894   else if (!i.suffix
6895            && (i.tm.opcode_modifier.jump == JUMP_ABSOLUTE
6896                || i.tm.opcode_modifier.jump == JUMP_BYTE
6897                || i.tm.opcode_modifier.jump == JUMP_INTERSEGMENT
6898                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
6899                    && i.tm.extension_opcode <= 3)))
6900     {
6901       switch (flag_code)
6902         {
6903         case CODE_64BIT:
6904           if (!i.tm.opcode_modifier.no_qsuf)
6905             {
6906               if (i.tm.opcode_modifier.jump == JUMP_BYTE
6907                   || i.tm.opcode_modifier.no_lsuf)
6908                 i.suffix = QWORD_MNEM_SUFFIX;
6909               break;
6910             }
6911           /* Fall through.  */
6912         case CODE_32BIT:
6913           if (!i.tm.opcode_modifier.no_lsuf)
6914             i.suffix = LONG_MNEM_SUFFIX;
6915           break;
6916         case CODE_16BIT:
6917           if (!i.tm.opcode_modifier.no_wsuf)
6918             i.suffix = WORD_MNEM_SUFFIX;
6919           break;
6920         }
6921     }
6922
6923   if (!i.suffix
6924       && (i.tm.opcode_modifier.mnemonicsize != DEFAULTSIZE
6925           /* Also cover lret/retf/iret in 64-bit mode.  */
6926           || (flag_code == CODE_64BIT
6927               && !i.tm.opcode_modifier.no_lsuf
6928               && !i.tm.opcode_modifier.no_qsuf))
6929       && i.tm.opcode_modifier.mnemonicsize != IGNORESIZE
6930       /* Explicit sizing prefixes are assumed to disambiguate insns.  */
6931       && !i.prefix[DATA_PREFIX] && !(i.prefix[REX_PREFIX] & REX_W)
6932       /* Accept FLDENV et al without suffix.  */
6933       && (i.tm.opcode_modifier.no_ssuf || i.tm.opcode_modifier.floatmf))
6934     {
6935       unsigned int suffixes, evex = 0;
6936
6937       suffixes = !i.tm.opcode_modifier.no_bsuf;
6938       if (!i.tm.opcode_modifier.no_wsuf)
6939         suffixes |= 1 << 1;
6940       if (!i.tm.opcode_modifier.no_lsuf)
6941         suffixes |= 1 << 2;
6942       if (!i.tm.opcode_modifier.no_ldsuf)
6943         suffixes |= 1 << 3;
6944       if (!i.tm.opcode_modifier.no_ssuf)
6945         suffixes |= 1 << 4;
6946       if (flag_code == CODE_64BIT && !i.tm.opcode_modifier.no_qsuf)
6947         suffixes |= 1 << 5;
6948
6949       /* For [XYZ]MMWORD operands inspect operand sizes.  While generally
6950          also suitable for AT&T syntax mode, it was requested that this be
6951          restricted to just Intel syntax.  */
6952       if (intel_syntax && is_any_vex_encoding (&i.tm) && !i.broadcast)
6953         {
6954           unsigned int op;
6955
6956           for (op = 0; op < i.tm.operands; ++op)
6957             {
6958               if (is_evex_encoding (&i.tm)
6959                   && !cpu_arch_flags.bitfield.cpuavx512vl)
6960                 {
6961                   if (i.tm.operand_types[op].bitfield.ymmword)
6962                     i.tm.operand_types[op].bitfield.xmmword = 0;
6963                   if (i.tm.operand_types[op].bitfield.zmmword)
6964                     i.tm.operand_types[op].bitfield.ymmword = 0;
6965                   if (!i.tm.opcode_modifier.evex
6966                       || i.tm.opcode_modifier.evex == EVEXDYN)
6967                     i.tm.opcode_modifier.evex = EVEX512;
6968                 }
6969
6970               if (i.tm.operand_types[op].bitfield.xmmword
6971                   + i.tm.operand_types[op].bitfield.ymmword
6972                   + i.tm.operand_types[op].bitfield.zmmword < 2)
6973                 continue;
6974
6975               /* Any properly sized operand disambiguates the insn.  */
6976               if (i.types[op].bitfield.xmmword
6977                   || i.types[op].bitfield.ymmword
6978                   || i.types[op].bitfield.zmmword)
6979                 {
6980                   suffixes &= ~(7 << 6);
6981                   evex = 0;
6982                   break;
6983                 }
6984
6985               if ((i.flags[op] & Operand_Mem)
6986                   && i.tm.operand_types[op].bitfield.unspecified)
6987                 {
6988                   if (i.tm.operand_types[op].bitfield.xmmword)
6989                     suffixes |= 1 << 6;
6990                   if (i.tm.operand_types[op].bitfield.ymmword)
6991                     suffixes |= 1 << 7;
6992                   if (i.tm.operand_types[op].bitfield.zmmword)
6993                     suffixes |= 1 << 8;
6994                   if (is_evex_encoding (&i.tm))
6995                     evex = EVEX512;
6996                 }
6997             }
6998         }
6999
7000       /* Are multiple suffixes / operand sizes allowed?  */
7001       if (suffixes & (suffixes - 1))
7002         {
7003           if (intel_syntax
7004               && (i.tm.opcode_modifier.mnemonicsize != DEFAULTSIZE
7005                   || operand_check == check_error))
7006             {
7007               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
7008               return 0;
7009             }
7010           if (operand_check == check_error)
7011             {
7012               as_bad (_("no instruction mnemonic suffix given and "
7013                         "no register operands; can't size `%s'"), i.tm.name);
7014               return 0;
7015             }
7016           if (operand_check == check_warning)
7017             as_warn (_("%s; using default for `%s'"),
7018                        intel_syntax
7019                        ? _("ambiguous operand size")
7020                        : _("no instruction mnemonic suffix given and "
7021                            "no register operands"),
7022                        i.tm.name);
7023
7024           if (i.tm.opcode_modifier.floatmf)
7025             i.suffix = SHORT_MNEM_SUFFIX;
7026           else if ((i.tm.base_opcode | 8) == 0xfbe
7027                    || (i.tm.base_opcode == 0x63
7028                        && i.tm.cpu_flags.bitfield.cpu64))
7029             /* handled below */;
7030           else if (evex)
7031             i.tm.opcode_modifier.evex = evex;
7032           else if (flag_code == CODE_16BIT)
7033             i.suffix = WORD_MNEM_SUFFIX;
7034           else if (!i.tm.opcode_modifier.no_lsuf)
7035             i.suffix = LONG_MNEM_SUFFIX;
7036           else
7037             i.suffix = QWORD_MNEM_SUFFIX;
7038         }
7039     }
7040
7041   if ((i.tm.base_opcode | 8) == 0xfbe
7042       || (i.tm.base_opcode == 0x63 && i.tm.cpu_flags.bitfield.cpu64))
7043     {
7044       /* In Intel syntax, movsx/movzx must have a "suffix" (checked above).
7045          In AT&T syntax, if there is no suffix (warned about above), the default
7046          will be byte extension.  */
7047       if (i.tm.opcode_modifier.w && i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
7048         i.tm.base_opcode |= 1;
7049
7050       /* For further processing, the suffix should represent the destination
7051          (register).  This is already the case when one was used with
7052          mov[sz][bw]*, but we need to replace it for mov[sz]x, or if there was
7053          no suffix to begin with.  */
7054       if (i.tm.opcode_modifier.w || i.tm.base_opcode == 0x63 || !i.suffix)
7055         {
7056           if (i.types[1].bitfield.word)
7057             i.suffix = WORD_MNEM_SUFFIX;
7058           else if (i.types[1].bitfield.qword)
7059             i.suffix = QWORD_MNEM_SUFFIX;
7060           else
7061             i.suffix = LONG_MNEM_SUFFIX;
7062
7063           i.tm.opcode_modifier.w = 0;
7064         }
7065     }
7066
7067   if (!i.tm.opcode_modifier.modrm && i.reg_operands && i.tm.operands < 3)
7068     i.short_form = (i.tm.operand_types[0].bitfield.class == Reg)
7069                    != (i.tm.operand_types[1].bitfield.class == Reg);
7070
7071   /* Change the opcode based on the operand size given by i.suffix.  */
7072   switch (i.suffix)
7073     {
7074     /* Size floating point instruction.  */
7075     case LONG_MNEM_SUFFIX:
7076       if (i.tm.opcode_modifier.floatmf)
7077         {
7078           i.tm.base_opcode ^= 4;
7079           break;
7080         }
7081     /* fall through */
7082     case WORD_MNEM_SUFFIX:
7083     case QWORD_MNEM_SUFFIX:
7084       /* It's not a byte, select word/dword operation.  */
7085       if (i.tm.opcode_modifier.w)
7086         {
7087           if (i.short_form)
7088             i.tm.base_opcode |= 8;
7089           else
7090             i.tm.base_opcode |= 1;
7091         }
7092     /* fall through */
7093     case SHORT_MNEM_SUFFIX:
7094       /* Now select between word & dword operations via the operand
7095          size prefix, except for instructions that will ignore this
7096          prefix anyway.  */
7097       if (i.suffix != QWORD_MNEM_SUFFIX
7098           && i.tm.opcode_modifier.mnemonicsize != IGNORESIZE
7099           && !i.tm.opcode_modifier.floatmf
7100           && !is_any_vex_encoding (&i.tm)
7101           && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
7102               || (flag_code == CODE_64BIT
7103                   && i.tm.opcode_modifier.jump == JUMP_BYTE)))
7104         {
7105           unsigned int prefix = DATA_PREFIX_OPCODE;
7106
7107           if (i.tm.opcode_modifier.jump == JUMP_BYTE) /* jcxz, loop */
7108             prefix = ADDR_PREFIX_OPCODE;
7109
7110           if (!add_prefix (prefix))
7111             return 0;
7112         }
7113
7114       /* Set mode64 for an operand.  */
7115       if (i.suffix == QWORD_MNEM_SUFFIX
7116           && flag_code == CODE_64BIT
7117           && !i.tm.opcode_modifier.norex64
7118           && !i.tm.opcode_modifier.vexw
7119           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
7120              need rex64. */
7121           && ! (i.operands == 2
7122                 && i.tm.base_opcode == 0x90
7123                 && i.tm.extension_opcode == None
7124                 && i.types[0].bitfield.instance == Accum
7125                 && i.types[0].bitfield.qword
7126                 && i.types[1].bitfield.instance == Accum
7127                 && i.types[1].bitfield.qword))
7128         i.rex |= REX_W;
7129
7130       break;
7131
7132     case 0:
7133       /* Select word/dword/qword operation with explict data sizing prefix
7134          when there are no suitable register operands.  */
7135       if (i.tm.opcode_modifier.w
7136           && (i.prefix[DATA_PREFIX] || (i.prefix[REX_PREFIX] & REX_W))
7137           && (!i.reg_operands
7138               || (i.reg_operands == 1
7139                       /* ShiftCount */
7140                   && (i.tm.operand_types[0].bitfield.instance == RegC
7141                       /* InOutPortReg */
7142                       || i.tm.operand_types[0].bitfield.instance == RegD
7143                       || i.tm.operand_types[1].bitfield.instance == RegD
7144                       /* CRC32 */
7145                       || i.tm.base_opcode == 0xf20f38f0))))
7146         i.tm.base_opcode |= 1;
7147       break;
7148     }
7149
7150   if (i.tm.opcode_modifier.addrprefixopreg)
7151     {
7152       gas_assert (!i.suffix);
7153       gas_assert (i.reg_operands);
7154
7155       if (i.tm.operand_types[0].bitfield.instance == Accum
7156           || i.operands == 1)
7157         {
7158           /* The address size override prefix changes the size of the
7159              first operand.  */
7160           if (flag_code == CODE_64BIT
7161               && i.op[0].regs->reg_type.bitfield.word)
7162             {
7163               as_bad (_("16-bit addressing unavailable for `%s'"),
7164                       i.tm.name);
7165               return 0;
7166             }
7167
7168           if ((flag_code == CODE_32BIT
7169                ? i.op[0].regs->reg_type.bitfield.word
7170                : i.op[0].regs->reg_type.bitfield.dword)
7171               && !add_prefix (ADDR_PREFIX_OPCODE))
7172             return 0;
7173         }
7174       else
7175         {
7176           /* Check invalid register operand when the address size override
7177              prefix changes the size of register operands.  */
7178           unsigned int op;
7179           enum { need_word, need_dword, need_qword } need;
7180
7181           /* Check the register operand for the address size prefix if
7182              the memory operand has no real registers, like symbol, DISP
7183              or symbol(%rip).  */
7184           if (i.mem_operands == 1
7185               && i.reg_operands == 1
7186               && i.operands == 2
7187               && i.types[1].bitfield.class == Reg
7188               && (flag_code == CODE_32BIT
7189                   ? i.op[1].regs->reg_type.bitfield.word
7190                   : i.op[1].regs->reg_type.bitfield.dword)
7191               && ((i.base_reg == NULL && i.index_reg == NULL)
7192                   || (i.base_reg
7193                       && i.base_reg->reg_num == RegIP
7194                       && i.base_reg->reg_type.bitfield.qword))
7195               && !add_prefix (ADDR_PREFIX_OPCODE))
7196             return 0;
7197
7198           if (flag_code == CODE_32BIT)
7199             need = i.prefix[ADDR_PREFIX] ? need_word : need_dword;
7200           else if (i.prefix[ADDR_PREFIX])
7201             need = need_dword;
7202           else
7203             need = flag_code == CODE_64BIT ? need_qword : need_word;
7204
7205           for (op = 0; op < i.operands; op++)
7206             {
7207               if (i.types[op].bitfield.class != Reg)
7208                 continue;
7209
7210               switch (need)
7211                 {
7212                 case need_word:
7213                   if (i.op[op].regs->reg_type.bitfield.word)
7214                     continue;
7215                   break;
7216                 case need_dword:
7217                   if (i.op[op].regs->reg_type.bitfield.dword)
7218                     continue;
7219                   break;
7220                 case need_qword:
7221                   if (i.op[op].regs->reg_type.bitfield.qword)
7222                     continue;
7223                   break;
7224                 }
7225
7226               as_bad (_("invalid register operand size for `%s'"),
7227                       i.tm.name);
7228               return 0;
7229             }
7230         }
7231     }
7232
7233   return 1;
7234 }
7235
7236 static int
7237 check_byte_reg (void)
7238 {
7239   int op;
7240
7241   for (op = i.operands; --op >= 0;)
7242     {
7243       /* Skip non-register operands. */
7244       if (i.types[op].bitfield.class != Reg)
7245         continue;
7246
7247       /* If this is an eight bit register, it's OK.  If it's the 16 or
7248          32 bit version of an eight bit register, we will just use the
7249          low portion, and that's OK too.  */
7250       if (i.types[op].bitfield.byte)
7251         continue;
7252
7253       /* I/O port address operands are OK too.  */
7254       if (i.tm.operand_types[op].bitfield.instance == RegD
7255           && i.tm.operand_types[op].bitfield.word)
7256         continue;
7257
7258       /* crc32 only wants its source operand checked here.  */
7259       if (i.tm.base_opcode == 0xf20f38f0 && op)
7260         continue;
7261
7262       /* Any other register is bad.  */
7263       as_bad (_("`%s%s' not allowed with `%s%c'"),
7264               register_prefix, i.op[op].regs->reg_name,
7265               i.tm.name, i.suffix);
7266       return 0;
7267     }
7268   return 1;
7269 }
7270
7271 static int
7272 check_long_reg (void)
7273 {
7274   int op;
7275
7276   for (op = i.operands; --op >= 0;)
7277     /* Skip non-register operands. */
7278     if (i.types[op].bitfield.class != Reg)
7279       continue;
7280     /* Reject eight bit registers, except where the template requires
7281        them. (eg. movzb)  */
7282     else if (i.types[op].bitfield.byte
7283              && (i.tm.operand_types[op].bitfield.class == Reg
7284                  || i.tm.operand_types[op].bitfield.instance == Accum)
7285              && (i.tm.operand_types[op].bitfield.word
7286                  || i.tm.operand_types[op].bitfield.dword))
7287       {
7288         as_bad (_("`%s%s' not allowed with `%s%c'"),
7289                 register_prefix,
7290                 i.op[op].regs->reg_name,
7291                 i.tm.name,
7292                 i.suffix);
7293         return 0;
7294       }
7295     /* Error if the e prefix on a general reg is missing.  */
7296     else if (i.types[op].bitfield.word
7297              && (i.tm.operand_types[op].bitfield.class == Reg
7298                  || i.tm.operand_types[op].bitfield.instance == Accum)
7299              && i.tm.operand_types[op].bitfield.dword)
7300       {
7301         as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7302                 register_prefix, i.op[op].regs->reg_name,
7303                 i.suffix);
7304         return 0;
7305       }
7306     /* Warn if the r prefix on a general reg is present.  */
7307     else if (i.types[op].bitfield.qword
7308              && (i.tm.operand_types[op].bitfield.class == Reg
7309                  || i.tm.operand_types[op].bitfield.instance == Accum)
7310              && i.tm.operand_types[op].bitfield.dword)
7311       {
7312         if (intel_syntax
7313             && i.tm.opcode_modifier.toqword
7314             && i.types[0].bitfield.class != RegSIMD)
7315           {
7316             /* Convert to QWORD.  We want REX byte. */
7317             i.suffix = QWORD_MNEM_SUFFIX;
7318           }
7319         else
7320           {
7321             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7322                     register_prefix, i.op[op].regs->reg_name,
7323                     i.suffix);
7324             return 0;
7325           }
7326       }
7327   return 1;
7328 }
7329
7330 static int
7331 check_qword_reg (void)
7332 {
7333   int op;
7334
7335   for (op = i.operands; --op >= 0; )
7336     /* Skip non-register operands. */
7337     if (i.types[op].bitfield.class != Reg)
7338       continue;
7339     /* Reject eight bit registers, except where the template requires
7340        them. (eg. movzb)  */
7341     else if (i.types[op].bitfield.byte
7342              && (i.tm.operand_types[op].bitfield.class == Reg
7343                  || i.tm.operand_types[op].bitfield.instance == Accum)
7344              && (i.tm.operand_types[op].bitfield.word
7345                  || i.tm.operand_types[op].bitfield.dword))
7346       {
7347         as_bad (_("`%s%s' not allowed with `%s%c'"),
7348                 register_prefix,
7349                 i.op[op].regs->reg_name,
7350                 i.tm.name,
7351                 i.suffix);
7352         return 0;
7353       }
7354     /* Warn if the r prefix on a general reg is missing.  */
7355     else if ((i.types[op].bitfield.word
7356               || i.types[op].bitfield.dword)
7357              && (i.tm.operand_types[op].bitfield.class == Reg
7358                  || i.tm.operand_types[op].bitfield.instance == Accum)
7359              && i.tm.operand_types[op].bitfield.qword)
7360       {
7361         /* Prohibit these changes in the 64bit mode, since the
7362            lowering is more complicated.  */
7363         if (intel_syntax
7364             && i.tm.opcode_modifier.todword
7365             && i.types[0].bitfield.class != RegSIMD)
7366           {
7367             /* Convert to DWORD.  We don't want REX byte. */
7368             i.suffix = LONG_MNEM_SUFFIX;
7369           }
7370         else
7371           {
7372             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7373                     register_prefix, i.op[op].regs->reg_name,
7374                     i.suffix);
7375             return 0;
7376           }
7377       }
7378   return 1;
7379 }
7380
7381 static int
7382 check_word_reg (void)
7383 {
7384   int op;
7385   for (op = i.operands; --op >= 0;)
7386     /* Skip non-register operands. */
7387     if (i.types[op].bitfield.class != Reg)
7388       continue;
7389     /* Reject eight bit registers, except where the template requires
7390        them. (eg. movzb)  */
7391     else if (i.types[op].bitfield.byte
7392              && (i.tm.operand_types[op].bitfield.class == Reg
7393                  || i.tm.operand_types[op].bitfield.instance == Accum)
7394              && (i.tm.operand_types[op].bitfield.word
7395                  || i.tm.operand_types[op].bitfield.dword))
7396       {
7397         as_bad (_("`%s%s' not allowed with `%s%c'"),
7398                 register_prefix,
7399                 i.op[op].regs->reg_name,
7400                 i.tm.name,
7401                 i.suffix);
7402         return 0;
7403       }
7404     /* Error if the e or r prefix on a general reg is present.  */
7405     else if ((i.types[op].bitfield.dword
7406                  || i.types[op].bitfield.qword)
7407              && (i.tm.operand_types[op].bitfield.class == Reg
7408                  || i.tm.operand_types[op].bitfield.instance == Accum)
7409              && i.tm.operand_types[op].bitfield.word)
7410       {
7411         as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7412                 register_prefix, i.op[op].regs->reg_name,
7413                 i.suffix);
7414         return 0;
7415       }
7416   return 1;
7417 }
7418
7419 static int
7420 update_imm (unsigned int j)
7421 {
7422   i386_operand_type overlap = i.types[j];
7423   if ((overlap.bitfield.imm8
7424        || overlap.bitfield.imm8s
7425        || overlap.bitfield.imm16
7426        || overlap.bitfield.imm32
7427        || overlap.bitfield.imm32s
7428        || overlap.bitfield.imm64)
7429       && !operand_type_equal (&overlap, &imm8)
7430       && !operand_type_equal (&overlap, &imm8s)
7431       && !operand_type_equal (&overlap, &imm16)
7432       && !operand_type_equal (&overlap, &imm32)
7433       && !operand_type_equal (&overlap, &imm32s)
7434       && !operand_type_equal (&overlap, &imm64))
7435     {
7436       if (i.suffix)
7437         {
7438           i386_operand_type temp;
7439
7440           operand_type_set (&temp, 0);
7441           if (i.suffix == BYTE_MNEM_SUFFIX)
7442             {
7443               temp.bitfield.imm8 = overlap.bitfield.imm8;
7444               temp.bitfield.imm8s = overlap.bitfield.imm8s;
7445             }
7446           else if (i.suffix == WORD_MNEM_SUFFIX)
7447             temp.bitfield.imm16 = overlap.bitfield.imm16;
7448           else if (i.suffix == QWORD_MNEM_SUFFIX)
7449             {
7450               temp.bitfield.imm64 = overlap.bitfield.imm64;
7451               temp.bitfield.imm32s = overlap.bitfield.imm32s;
7452             }
7453           else
7454             temp.bitfield.imm32 = overlap.bitfield.imm32;
7455           overlap = temp;
7456         }
7457       else if (operand_type_equal (&overlap, &imm16_32_32s)
7458                || operand_type_equal (&overlap, &imm16_32)
7459                || operand_type_equal (&overlap, &imm16_32s))
7460         {
7461           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
7462             overlap = imm16;
7463           else
7464             overlap = imm32s;
7465         }
7466       else if (i.prefix[REX_PREFIX] & REX_W)
7467         overlap = operand_type_and (overlap, imm32s);
7468       else if (i.prefix[DATA_PREFIX])
7469         overlap = operand_type_and (overlap,
7470                                     flag_code != CODE_16BIT ? imm16 : imm32);
7471       if (!operand_type_equal (&overlap, &imm8)
7472           && !operand_type_equal (&overlap, &imm8s)
7473           && !operand_type_equal (&overlap, &imm16)
7474           && !operand_type_equal (&overlap, &imm32)
7475           && !operand_type_equal (&overlap, &imm32s)
7476           && !operand_type_equal (&overlap, &imm64))
7477         {
7478           as_bad (_("no instruction mnemonic suffix given; "
7479                     "can't determine immediate size"));
7480           return 0;
7481         }
7482     }
7483   i.types[j] = overlap;
7484
7485   return 1;
7486 }
7487
7488 static int
7489 finalize_imm (void)
7490 {
7491   unsigned int j, n;
7492
7493   /* Update the first 2 immediate operands.  */
7494   n = i.operands > 2 ? 2 : i.operands;
7495   if (n)
7496     {
7497       for (j = 0; j < n; j++)
7498         if (update_imm (j) == 0)
7499           return 0;
7500
7501       /* The 3rd operand can't be immediate operand.  */
7502       gas_assert (operand_type_check (i.types[2], imm) == 0);
7503     }
7504
7505   return 1;
7506 }
7507
7508 static int
7509 process_operands (void)
7510 {
7511   /* Default segment register this instruction will use for memory
7512      accesses.  0 means unknown.  This is only for optimizing out
7513      unnecessary segment overrides.  */
7514   const seg_entry *default_seg = 0;
7515
7516   if (i.tm.opcode_modifier.sse2avx)
7517     {
7518       /* Legacy encoded insns allow explicit REX prefixes, so these prefixes
7519          need converting.  */
7520       i.rex |= i.prefix[REX_PREFIX] & (REX_W | REX_R | REX_X | REX_B);
7521       i.prefix[REX_PREFIX] = 0;
7522       i.rex_encoding = 0;
7523     }
7524   /* ImmExt should be processed after SSE2AVX.  */
7525   else if (i.tm.opcode_modifier.immext)
7526     process_immext ();
7527
7528   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
7529     {
7530       unsigned int dupl = i.operands;
7531       unsigned int dest = dupl - 1;
7532       unsigned int j;
7533
7534       /* The destination must be an xmm register.  */
7535       gas_assert (i.reg_operands
7536                   && MAX_OPERANDS > dupl
7537                   && operand_type_equal (&i.types[dest], &regxmm));
7538
7539       if (i.tm.operand_types[0].bitfield.instance == Accum
7540           && i.tm.operand_types[0].bitfield.xmmword)
7541         {
7542           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
7543             {
7544               /* Keep xmm0 for instructions with VEX prefix and 3
7545                  sources.  */
7546               i.tm.operand_types[0].bitfield.instance = InstanceNone;
7547               i.tm.operand_types[0].bitfield.class = RegSIMD;
7548               goto duplicate;
7549             }
7550           else
7551             {
7552               /* We remove the first xmm0 and keep the number of
7553                  operands unchanged, which in fact duplicates the
7554                  destination.  */
7555               for (j = 1; j < i.operands; j++)
7556                 {
7557                   i.op[j - 1] = i.op[j];
7558                   i.types[j - 1] = i.types[j];
7559                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
7560                   i.flags[j - 1] = i.flags[j];
7561                 }
7562             }
7563         }
7564       else if (i.tm.opcode_modifier.implicit1stxmm0)
7565         {
7566           gas_assert ((MAX_OPERANDS - 1) > dupl
7567                       && (i.tm.opcode_modifier.vexsources
7568                           == VEX3SOURCES));
7569
7570           /* Add the implicit xmm0 for instructions with VEX prefix
7571              and 3 sources.  */
7572           for (j = i.operands; j > 0; j--)
7573             {
7574               i.op[j] = i.op[j - 1];
7575               i.types[j] = i.types[j - 1];
7576               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
7577               i.flags[j] = i.flags[j - 1];
7578             }
7579           i.op[0].regs
7580             = (const reg_entry *) str_hash_find (reg_hash, "xmm0");
7581           i.types[0] = regxmm;
7582           i.tm.operand_types[0] = regxmm;
7583
7584           i.operands += 2;
7585           i.reg_operands += 2;
7586           i.tm.operands += 2;
7587
7588           dupl++;
7589           dest++;
7590           i.op[dupl] = i.op[dest];
7591           i.types[dupl] = i.types[dest];
7592           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
7593           i.flags[dupl] = i.flags[dest];
7594         }
7595       else
7596         {
7597         duplicate:
7598           i.operands++;
7599           i.reg_operands++;
7600           i.tm.operands++;
7601
7602           i.op[dupl] = i.op[dest];
7603           i.types[dupl] = i.types[dest];
7604           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
7605           i.flags[dupl] = i.flags[dest];
7606         }
7607
7608        if (i.tm.opcode_modifier.immext)
7609          process_immext ();
7610     }
7611   else if (i.tm.operand_types[0].bitfield.instance == Accum
7612            && i.tm.operand_types[0].bitfield.xmmword)
7613     {
7614       unsigned int j;
7615
7616       for (j = 1; j < i.operands; j++)
7617         {
7618           i.op[j - 1] = i.op[j];
7619           i.types[j - 1] = i.types[j];
7620
7621           /* We need to adjust fields in i.tm since they are used by
7622              build_modrm_byte.  */
7623           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
7624
7625           i.flags[j - 1] = i.flags[j];
7626         }
7627
7628       i.operands--;
7629       i.reg_operands--;
7630       i.tm.operands--;
7631     }
7632   else if (i.tm.opcode_modifier.implicitquadgroup)
7633     {
7634       unsigned int regnum, first_reg_in_group, last_reg_in_group;
7635
7636       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
7637       gas_assert (i.operands >= 2 && i.types[1].bitfield.class == RegSIMD);
7638       regnum = register_number (i.op[1].regs);
7639       first_reg_in_group = regnum & ~3;
7640       last_reg_in_group = first_reg_in_group + 3;
7641       if (regnum != first_reg_in_group)
7642         as_warn (_("source register `%s%s' implicitly denotes"
7643                    " `%s%.3s%u' to `%s%.3s%u' source group in `%s'"),
7644                  register_prefix, i.op[1].regs->reg_name,
7645                  register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
7646                  register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
7647                  i.tm.name);
7648     }
7649   else if (i.tm.opcode_modifier.regkludge)
7650     {
7651       /* The imul $imm, %reg instruction is converted into
7652          imul $imm, %reg, %reg, and the clr %reg instruction
7653          is converted into xor %reg, %reg.  */
7654
7655       unsigned int first_reg_op;
7656
7657       if (operand_type_check (i.types[0], reg))
7658         first_reg_op = 0;
7659       else
7660         first_reg_op = 1;
7661       /* Pretend we saw the extra register operand.  */
7662       gas_assert (i.reg_operands == 1
7663                   && i.op[first_reg_op + 1].regs == 0);
7664       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
7665       i.types[first_reg_op + 1] = i.types[first_reg_op];
7666       i.operands++;
7667       i.reg_operands++;
7668     }
7669
7670   if (i.tm.opcode_modifier.modrm)
7671     {
7672       /* The opcode is completed (modulo i.tm.extension_opcode which
7673          must be put into the modrm byte).  Now, we make the modrm and
7674          index base bytes based on all the info we've collected.  */
7675
7676       default_seg = build_modrm_byte ();
7677     }
7678   else if (i.types[0].bitfield.class == SReg)
7679     {
7680       if (flag_code != CODE_64BIT
7681           ? i.tm.base_opcode == POP_SEG_SHORT
7682             && i.op[0].regs->reg_num == 1
7683           : (i.tm.base_opcode | 1) == POP_SEG386_SHORT
7684             && i.op[0].regs->reg_num < 4)
7685         {
7686           as_bad (_("you can't `%s %s%s'"),
7687                   i.tm.name, register_prefix, i.op[0].regs->reg_name);
7688           return 0;
7689         }
7690       if ( i.op[0].regs->reg_num > 3 && i.tm.opcode_length == 1 )
7691         {
7692           i.tm.base_opcode ^= POP_SEG_SHORT ^ POP_SEG386_SHORT;
7693           i.tm.opcode_length = 2;
7694         }
7695       i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
7696     }
7697   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
7698     {
7699       default_seg = &ds;
7700     }
7701   else if (i.tm.opcode_modifier.isstring)
7702     {
7703       /* For the string instructions that allow a segment override
7704          on one of their operands, the default segment is ds.  */
7705       default_seg = &ds;
7706     }
7707   else if (i.short_form)
7708     {
7709       /* The register or float register operand is in operand
7710          0 or 1.  */
7711       unsigned int op = i.tm.operand_types[0].bitfield.class != Reg;
7712
7713       /* Register goes in low 3 bits of opcode.  */
7714       i.tm.base_opcode |= i.op[op].regs->reg_num;
7715       if ((i.op[op].regs->reg_flags & RegRex) != 0)
7716         i.rex |= REX_B;
7717       if (!quiet_warnings && i.tm.opcode_modifier.ugh)
7718         {
7719           /* Warn about some common errors, but press on regardless.
7720              The first case can be generated by gcc (<= 2.8.1).  */
7721           if (i.operands == 2)
7722             {
7723               /* Reversed arguments on faddp, fsubp, etc.  */
7724               as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
7725                        register_prefix, i.op[!intel_syntax].regs->reg_name,
7726                        register_prefix, i.op[intel_syntax].regs->reg_name);
7727             }
7728           else
7729             {
7730               /* Extraneous `l' suffix on fp insn.  */
7731               as_warn (_("translating to `%s %s%s'"), i.tm.name,
7732                        register_prefix, i.op[0].regs->reg_name);
7733             }
7734         }
7735     }
7736
7737   if ((i.seg[0] || i.prefix[SEG_PREFIX])
7738       && i.tm.base_opcode == 0x8d /* lea */
7739       && !is_any_vex_encoding(&i.tm))
7740     {
7741       if (!quiet_warnings)
7742         as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
7743       if (optimize)
7744         {
7745           i.seg[0] = NULL;
7746           i.prefix[SEG_PREFIX] = 0;
7747         }
7748     }
7749
7750   /* If a segment was explicitly specified, and the specified segment
7751      is neither the default nor the one already recorded from a prefix,
7752      use an opcode prefix to select it.  If we never figured out what
7753      the default segment is, then default_seg will be zero at this
7754      point, and the specified segment prefix will always be used.  */
7755   if (i.seg[0]
7756       && i.seg[0] != default_seg
7757       && i.seg[0]->seg_prefix != i.prefix[SEG_PREFIX])
7758     {
7759       if (!add_prefix (i.seg[0]->seg_prefix))
7760         return 0;
7761     }
7762   return 1;
7763 }
7764
7765 static INLINE void set_rex_vrex (const reg_entry *r, unsigned int rex_bit,
7766                                  bfd_boolean do_sse2avx)
7767 {
7768   if (r->reg_flags & RegRex)
7769     {
7770       if (i.rex & rex_bit)
7771         as_bad (_("same type of prefix used twice"));
7772       i.rex |= rex_bit;
7773     }
7774   else if (do_sse2avx && (i.rex & rex_bit) && i.vex.register_specifier)
7775     {
7776       gas_assert (i.vex.register_specifier == r);
7777       i.vex.register_specifier += 8;
7778     }
7779
7780   if (r->reg_flags & RegVRex)
7781     i.vrex |= rex_bit;
7782 }
7783
7784 static const seg_entry *
7785 build_modrm_byte (void)
7786 {
7787   const seg_entry *default_seg = 0;
7788   unsigned int source, dest;
7789   int vex_3_sources;
7790
7791   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
7792   if (vex_3_sources)
7793     {
7794       unsigned int nds, reg_slot;
7795       expressionS *exp;
7796
7797       dest = i.operands - 1;
7798       nds = dest - 1;
7799
7800       /* There are 2 kinds of instructions:
7801          1. 5 operands: 4 register operands or 3 register operands
7802          plus 1 memory operand plus one Imm4 operand, VexXDS, and
7803          VexW0 or VexW1.  The destination must be either XMM, YMM or
7804          ZMM register.
7805          2. 4 operands: 4 register operands or 3 register operands
7806          plus 1 memory operand, with VexXDS.  */
7807       gas_assert ((i.reg_operands == 4
7808                    || (i.reg_operands == 3 && i.mem_operands == 1))
7809                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
7810                   && i.tm.opcode_modifier.vexw
7811                   && i.tm.operand_types[dest].bitfield.class == RegSIMD);
7812
7813       /* If VexW1 is set, the first non-immediate operand is the source and
7814          the second non-immediate one is encoded in the immediate operand.  */
7815       if (i.tm.opcode_modifier.vexw == VEXW1)
7816         {
7817           source = i.imm_operands;
7818           reg_slot = i.imm_operands + 1;
7819         }
7820       else
7821         {
7822           source = i.imm_operands + 1;
7823           reg_slot = i.imm_operands;
7824         }
7825
7826       if (i.imm_operands == 0)
7827         {
7828           /* When there is no immediate operand, generate an 8bit
7829              immediate operand to encode the first operand.  */
7830           exp = &im_expressions[i.imm_operands++];
7831           i.op[i.operands].imms = exp;
7832           i.types[i.operands] = imm8;
7833           i.operands++;
7834
7835           gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD);
7836           exp->X_op = O_constant;
7837           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
7838           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7839         }
7840       else
7841         {
7842           gas_assert (i.imm_operands == 1);
7843           gas_assert (fits_in_imm4 (i.op[0].imms->X_add_number));
7844           gas_assert (!i.tm.opcode_modifier.immext);
7845
7846           /* Turn on Imm8 again so that output_imm will generate it.  */
7847           i.types[0].bitfield.imm8 = 1;
7848
7849           gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD);
7850           i.op[0].imms->X_add_number
7851               |= register_number (i.op[reg_slot].regs) << 4;
7852           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7853         }
7854
7855       gas_assert (i.tm.operand_types[nds].bitfield.class == RegSIMD);
7856       i.vex.register_specifier = i.op[nds].regs;
7857     }
7858   else
7859     source = dest = 0;
7860
7861   /* i.reg_operands MUST be the number of real register operands;
7862      implicit registers do not count.  If there are 3 register
7863      operands, it must be a instruction with VexNDS.  For a
7864      instruction with VexNDD, the destination register is encoded
7865      in VEX prefix.  If there are 4 register operands, it must be
7866      a instruction with VEX prefix and 3 sources.  */
7867   if (i.mem_operands == 0
7868       && ((i.reg_operands == 2
7869            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
7870           || (i.reg_operands == 3
7871               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
7872           || (i.reg_operands == 4 && vex_3_sources)))
7873     {
7874       switch (i.operands)
7875         {
7876         case 2:
7877           source = 0;
7878           break;
7879         case 3:
7880           /* When there are 3 operands, one of them may be immediate,
7881              which may be the first or the last operand.  Otherwise,
7882              the first operand must be shift count register (cl) or it
7883              is an instruction with VexNDS. */
7884           gas_assert (i.imm_operands == 1
7885                       || (i.imm_operands == 0
7886                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
7887                               || (i.types[0].bitfield.instance == RegC
7888                                   && i.types[0].bitfield.byte))));
7889           if (operand_type_check (i.types[0], imm)
7890               || (i.types[0].bitfield.instance == RegC
7891                   && i.types[0].bitfield.byte))
7892             source = 1;
7893           else
7894             source = 0;
7895           break;
7896         case 4:
7897           /* When there are 4 operands, the first two must be 8bit
7898              immediate operands. The source operand will be the 3rd
7899              one.
7900
7901              For instructions with VexNDS, if the first operand
7902              an imm8, the source operand is the 2nd one.  If the last
7903              operand is imm8, the source operand is the first one.  */
7904           gas_assert ((i.imm_operands == 2
7905                        && i.types[0].bitfield.imm8
7906                        && i.types[1].bitfield.imm8)
7907                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
7908                           && i.imm_operands == 1
7909                           && (i.types[0].bitfield.imm8
7910                               || i.types[i.operands - 1].bitfield.imm8
7911                               || i.rounding)));
7912           if (i.imm_operands == 2)
7913             source = 2;
7914           else
7915             {
7916               if (i.types[0].bitfield.imm8)
7917                 source = 1;
7918               else
7919                 source = 0;
7920             }
7921           break;
7922         case 5:
7923           if (is_evex_encoding (&i.tm))
7924             {
7925               /* For EVEX instructions, when there are 5 operands, the
7926                  first one must be immediate operand.  If the second one
7927                  is immediate operand, the source operand is the 3th
7928                  one.  If the last one is immediate operand, the source
7929                  operand is the 2nd one.  */
7930               gas_assert (i.imm_operands == 2
7931                           && i.tm.opcode_modifier.sae
7932                           && operand_type_check (i.types[0], imm));
7933               if (operand_type_check (i.types[1], imm))
7934                 source = 2;
7935               else if (operand_type_check (i.types[4], imm))
7936                 source = 1;
7937               else
7938                 abort ();
7939             }
7940           break;
7941         default:
7942           abort ();
7943         }
7944
7945       if (!vex_3_sources)
7946         {
7947           dest = source + 1;
7948
7949           /* RC/SAE operand could be between DEST and SRC.  That happens
7950              when one operand is GPR and the other one is XMM/YMM/ZMM
7951              register.  */
7952           if (i.rounding && i.rounding->operand == (int) dest)
7953             dest++;
7954
7955           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7956             {
7957               /* For instructions with VexNDS, the register-only source
7958                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
7959                  register.  It is encoded in VEX prefix.  */
7960
7961               i386_operand_type op;
7962               unsigned int vvvv;
7963
7964               /* Swap two source operands if needed.  */
7965               if (i.tm.opcode_modifier.swapsources)
7966                 {
7967                   vvvv = source;
7968                   source = dest;
7969                 }
7970               else
7971                 vvvv = dest;
7972
7973               op = i.tm.operand_types[vvvv];
7974               if ((dest + 1) >= i.operands
7975                   || ((op.bitfield.class != Reg
7976                        || (!op.bitfield.dword && !op.bitfield.qword))
7977                       && op.bitfield.class != RegSIMD
7978                       && !operand_type_equal (&op, &regmask)))
7979                 abort ();
7980               i.vex.register_specifier = i.op[vvvv].regs;
7981               dest++;
7982             }
7983         }
7984
7985       i.rm.mode = 3;
7986       /* One of the register operands will be encoded in the i.rm.reg
7987          field, the other in the combined i.rm.mode and i.rm.regmem
7988          fields.  If no form of this instruction supports a memory
7989          destination operand, then we assume the source operand may
7990          sometimes be a memory operand and so we need to store the
7991          destination in the i.rm.reg field.  */
7992       if (!i.tm.opcode_modifier.regmem
7993           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
7994         {
7995           i.rm.reg = i.op[dest].regs->reg_num;
7996           i.rm.regmem = i.op[source].regs->reg_num;
7997           set_rex_vrex (i.op[dest].regs, REX_R, i.tm.opcode_modifier.sse2avx);
7998           set_rex_vrex (i.op[source].regs, REX_B, FALSE);
7999         }
8000       else
8001         {
8002           i.rm.reg = i.op[source].regs->reg_num;
8003           i.rm.regmem = i.op[dest].regs->reg_num;
8004           set_rex_vrex (i.op[dest].regs, REX_B, i.tm.opcode_modifier.sse2avx);
8005           set_rex_vrex (i.op[source].regs, REX_R, FALSE);
8006         }
8007       if (flag_code != CODE_64BIT && (i.rex & REX_R))
8008         {
8009           if (i.types[!i.tm.opcode_modifier.regmem].bitfield.class != RegCR)
8010             abort ();
8011           i.rex &= ~REX_R;
8012           add_prefix (LOCK_PREFIX_OPCODE);
8013         }
8014     }
8015   else
8016     {                   /* If it's not 2 reg operands...  */
8017       unsigned int mem;
8018
8019       if (i.mem_operands)
8020         {
8021           unsigned int fake_zero_displacement = 0;
8022           unsigned int op;
8023
8024           for (op = 0; op < i.operands; op++)
8025             if (i.flags[op] & Operand_Mem)
8026               break;
8027           gas_assert (op < i.operands);
8028
8029           if (i.tm.opcode_modifier.sib)
8030             {
8031               /* The index register of VSIB shouldn't be RegIZ.  */
8032               if (i.tm.opcode_modifier.sib != SIBMEM
8033                   && i.index_reg->reg_num == RegIZ)
8034                 abort ();
8035
8036               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8037               if (!i.base_reg)
8038                 {
8039                   i.sib.base = NO_BASE_REGISTER;
8040                   i.sib.scale = i.log2_scale_factor;
8041                   i.types[op].bitfield.disp8 = 0;
8042                   i.types[op].bitfield.disp16 = 0;
8043                   i.types[op].bitfield.disp64 = 0;
8044                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
8045                     {
8046                       /* Must be 32 bit */
8047                       i.types[op].bitfield.disp32 = 1;
8048                       i.types[op].bitfield.disp32s = 0;
8049                     }
8050                   else
8051                     {
8052                       i.types[op].bitfield.disp32 = 0;
8053                       i.types[op].bitfield.disp32s = 1;
8054                     }
8055                 }
8056
8057               /* Since the mandatory SIB always has index register, so
8058                  the code logic remains unchanged. The non-mandatory SIB
8059                  without index register is allowed and will be handled
8060                  later.  */
8061               if (i.index_reg)
8062                 {
8063                   if (i.index_reg->reg_num == RegIZ)
8064                     i.sib.index = NO_INDEX_REGISTER;
8065                   else
8066                     i.sib.index = i.index_reg->reg_num;
8067                   set_rex_vrex (i.index_reg, REX_X, FALSE);
8068                 }
8069             }
8070
8071           default_seg = &ds;
8072
8073           if (i.base_reg == 0)
8074             {
8075               i.rm.mode = 0;
8076               if (!i.disp_operands)
8077                 fake_zero_displacement = 1;
8078               if (i.index_reg == 0)
8079                 {
8080                   i386_operand_type newdisp;
8081
8082                   /* Both check for VSIB and mandatory non-vector SIB. */
8083                   gas_assert (!i.tm.opcode_modifier.sib
8084                               || i.tm.opcode_modifier.sib == SIBMEM);
8085                   /* Operand is just <disp>  */
8086                   if (flag_code == CODE_64BIT)
8087                     {
8088                       /* 64bit mode overwrites the 32bit absolute
8089                          addressing by RIP relative addressing and
8090                          absolute addressing is encoded by one of the
8091                          redundant SIB forms.  */
8092                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8093                       i.sib.base = NO_BASE_REGISTER;
8094                       i.sib.index = NO_INDEX_REGISTER;
8095                       newdisp = (!i.prefix[ADDR_PREFIX] ? disp32s : disp32);
8096                     }
8097                   else if ((flag_code == CODE_16BIT)
8098                            ^ (i.prefix[ADDR_PREFIX] != 0))
8099                     {
8100                       i.rm.regmem = NO_BASE_REGISTER_16;
8101                       newdisp = disp16;
8102                     }
8103                   else
8104                     {
8105                       i.rm.regmem = NO_BASE_REGISTER;
8106                       newdisp = disp32;
8107                     }
8108                   i.types[op] = operand_type_and_not (i.types[op], anydisp);
8109                   i.types[op] = operand_type_or (i.types[op], newdisp);
8110                 }
8111               else if (!i.tm.opcode_modifier.sib)
8112                 {
8113                   /* !i.base_reg && i.index_reg  */
8114                   if (i.index_reg->reg_num == RegIZ)
8115                     i.sib.index = NO_INDEX_REGISTER;
8116                   else
8117                     i.sib.index = i.index_reg->reg_num;
8118                   i.sib.base = NO_BASE_REGISTER;
8119                   i.sib.scale = i.log2_scale_factor;
8120                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8121                   i.types[op].bitfield.disp8 = 0;
8122                   i.types[op].bitfield.disp16 = 0;
8123                   i.types[op].bitfield.disp64 = 0;
8124                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
8125                     {
8126                       /* Must be 32 bit */
8127                       i.types[op].bitfield.disp32 = 1;
8128                       i.types[op].bitfield.disp32s = 0;
8129                     }
8130                   else
8131                     {
8132                       i.types[op].bitfield.disp32 = 0;
8133                       i.types[op].bitfield.disp32s = 1;
8134                     }
8135                   if ((i.index_reg->reg_flags & RegRex) != 0)
8136                     i.rex |= REX_X;
8137                 }
8138             }
8139           /* RIP addressing for 64bit mode.  */
8140           else if (i.base_reg->reg_num == RegIP)
8141             {
8142               gas_assert (!i.tm.opcode_modifier.sib);
8143               i.rm.regmem = NO_BASE_REGISTER;
8144               i.types[op].bitfield.disp8 = 0;
8145               i.types[op].bitfield.disp16 = 0;
8146               i.types[op].bitfield.disp32 = 0;
8147               i.types[op].bitfield.disp32s = 1;
8148               i.types[op].bitfield.disp64 = 0;
8149               i.flags[op] |= Operand_PCrel;
8150               if (! i.disp_operands)
8151                 fake_zero_displacement = 1;
8152             }
8153           else if (i.base_reg->reg_type.bitfield.word)
8154             {
8155               gas_assert (!i.tm.opcode_modifier.sib);
8156               switch (i.base_reg->reg_num)
8157                 {
8158                 case 3: /* (%bx)  */
8159                   if (i.index_reg == 0)
8160                     i.rm.regmem = 7;
8161                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
8162                     i.rm.regmem = i.index_reg->reg_num - 6;
8163                   break;
8164                 case 5: /* (%bp)  */
8165                   default_seg = &ss;
8166                   if (i.index_reg == 0)
8167                     {
8168                       i.rm.regmem = 6;
8169                       if (operand_type_check (i.types[op], disp) == 0)
8170                         {
8171                           /* fake (%bp) into 0(%bp)  */
8172                           if (i.disp_encoding == disp_encoding_16bit)
8173                             i.types[op].bitfield.disp16 = 1;
8174                           else
8175                             i.types[op].bitfield.disp8 = 1;
8176                           fake_zero_displacement = 1;
8177                         }
8178                     }
8179                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
8180                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
8181                   break;
8182                 default: /* (%si) -> 4 or (%di) -> 5  */
8183                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
8184                 }
8185               if (!fake_zero_displacement
8186                   && !i.disp_operands
8187                   && i.disp_encoding)
8188                 {
8189                   fake_zero_displacement = 1;
8190                   if (i.disp_encoding == disp_encoding_8bit)
8191                     i.types[op].bitfield.disp8 = 1;
8192                   else
8193                     i.types[op].bitfield.disp16 = 1;
8194                 }
8195               i.rm.mode = mode_from_disp_size (i.types[op]);
8196             }
8197           else /* i.base_reg and 32/64 bit mode  */
8198             {
8199               if (flag_code == CODE_64BIT
8200                   && operand_type_check (i.types[op], disp))
8201                 {
8202                   i.types[op].bitfield.disp16 = 0;
8203                   i.types[op].bitfield.disp64 = 0;
8204                   if (i.prefix[ADDR_PREFIX] == 0)
8205                     {
8206                       i.types[op].bitfield.disp32 = 0;
8207                       i.types[op].bitfield.disp32s = 1;
8208                     }
8209                   else
8210                     {
8211                       i.types[op].bitfield.disp32 = 1;
8212                       i.types[op].bitfield.disp32s = 0;
8213                     }
8214                 }
8215
8216               if (!i.tm.opcode_modifier.sib)
8217                 i.rm.regmem = i.base_reg->reg_num;
8218               if ((i.base_reg->reg_flags & RegRex) != 0)
8219                 i.rex |= REX_B;
8220               i.sib.base = i.base_reg->reg_num;
8221               /* x86-64 ignores REX prefix bit here to avoid decoder
8222                  complications.  */
8223               if (!(i.base_reg->reg_flags & RegRex)
8224                   && (i.base_reg->reg_num == EBP_REG_NUM
8225                    || i.base_reg->reg_num == ESP_REG_NUM))
8226                   default_seg = &ss;
8227               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
8228                 {
8229                   fake_zero_displacement = 1;
8230                   if (i.disp_encoding == disp_encoding_32bit)
8231                     i.types[op].bitfield.disp32 = 1;
8232                   else
8233                     i.types[op].bitfield.disp8 = 1;
8234                 }
8235               i.sib.scale = i.log2_scale_factor;
8236               if (i.index_reg == 0)
8237                 {
8238                   /* Only check for VSIB. */
8239                   gas_assert (i.tm.opcode_modifier.sib != VECSIB128
8240                               && i.tm.opcode_modifier.sib != VECSIB256
8241                               && i.tm.opcode_modifier.sib != VECSIB512);
8242
8243                   /* <disp>(%esp) becomes two byte modrm with no index
8244                      register.  We've already stored the code for esp
8245                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
8246                      Any base register besides %esp will not use the
8247                      extra modrm byte.  */
8248                   i.sib.index = NO_INDEX_REGISTER;
8249                 }
8250               else if (!i.tm.opcode_modifier.sib)
8251                 {
8252                   if (i.index_reg->reg_num == RegIZ)
8253                     i.sib.index = NO_INDEX_REGISTER;
8254                   else
8255                     i.sib.index = i.index_reg->reg_num;
8256                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8257                   if ((i.index_reg->reg_flags & RegRex) != 0)
8258                     i.rex |= REX_X;
8259                 }
8260
8261               if (i.disp_operands
8262                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
8263                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
8264                 i.rm.mode = 0;
8265               else
8266                 {
8267                   if (!fake_zero_displacement
8268                       && !i.disp_operands
8269                       && i.disp_encoding)
8270                     {
8271                       fake_zero_displacement = 1;
8272                       if (i.disp_encoding == disp_encoding_8bit)
8273                         i.types[op].bitfield.disp8 = 1;
8274                       else
8275                         i.types[op].bitfield.disp32 = 1;
8276                     }
8277                   i.rm.mode = mode_from_disp_size (i.types[op]);
8278                 }
8279             }
8280
8281           if (fake_zero_displacement)
8282             {
8283               /* Fakes a zero displacement assuming that i.types[op]
8284                  holds the correct displacement size.  */
8285               expressionS *exp;
8286
8287               gas_assert (i.op[op].disps == 0);
8288               exp = &disp_expressions[i.disp_operands++];
8289               i.op[op].disps = exp;
8290               exp->X_op = O_constant;
8291               exp->X_add_number = 0;
8292               exp->X_add_symbol = (symbolS *) 0;
8293               exp->X_op_symbol = (symbolS *) 0;
8294             }
8295
8296           mem = op;
8297         }
8298       else
8299         mem = ~0;
8300
8301       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
8302         {
8303           if (operand_type_check (i.types[0], imm))
8304             i.vex.register_specifier = NULL;
8305           else
8306             {
8307               /* VEX.vvvv encodes one of the sources when the first
8308                  operand is not an immediate.  */
8309               if (i.tm.opcode_modifier.vexw == VEXW0)
8310                 i.vex.register_specifier = i.op[0].regs;
8311               else
8312                 i.vex.register_specifier = i.op[1].regs;
8313             }
8314
8315           /* Destination is a XMM register encoded in the ModRM.reg
8316              and VEX.R bit.  */
8317           i.rm.reg = i.op[2].regs->reg_num;
8318           if ((i.op[2].regs->reg_flags & RegRex) != 0)
8319             i.rex |= REX_R;
8320
8321           /* ModRM.rm and VEX.B encodes the other source.  */
8322           if (!i.mem_operands)
8323             {
8324               i.rm.mode = 3;
8325
8326               if (i.tm.opcode_modifier.vexw == VEXW0)
8327                 i.rm.regmem = i.op[1].regs->reg_num;
8328               else
8329                 i.rm.regmem = i.op[0].regs->reg_num;
8330
8331               if ((i.op[1].regs->reg_flags & RegRex) != 0)
8332                 i.rex |= REX_B;
8333             }
8334         }
8335       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
8336         {
8337           i.vex.register_specifier = i.op[2].regs;
8338           if (!i.mem_operands)
8339             {
8340               i.rm.mode = 3;
8341               i.rm.regmem = i.op[1].regs->reg_num;
8342               if ((i.op[1].regs->reg_flags & RegRex) != 0)
8343                 i.rex |= REX_B;
8344             }
8345         }
8346       /* Fill in i.rm.reg or i.rm.regmem field with register operand
8347          (if any) based on i.tm.extension_opcode.  Again, we must be
8348          careful to make sure that segment/control/debug/test/MMX
8349          registers are coded into the i.rm.reg field.  */
8350       else if (i.reg_operands)
8351         {
8352           unsigned int op;
8353           unsigned int vex_reg = ~0;
8354
8355           for (op = 0; op < i.operands; op++)
8356             if (i.types[op].bitfield.class == Reg
8357                 || i.types[op].bitfield.class == RegBND
8358                 || i.types[op].bitfield.class == RegMask
8359                 || i.types[op].bitfield.class == SReg
8360                 || i.types[op].bitfield.class == RegCR
8361                 || i.types[op].bitfield.class == RegDR
8362                 || i.types[op].bitfield.class == RegTR
8363                 || i.types[op].bitfield.class == RegSIMD
8364                 || i.types[op].bitfield.class == RegMMX)
8365               break;
8366
8367           if (vex_3_sources)
8368             op = dest;
8369           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
8370             {
8371               /* For instructions with VexNDS, the register-only
8372                  source operand is encoded in VEX prefix. */
8373               gas_assert (mem != (unsigned int) ~0);
8374
8375               if (op > mem)
8376                 {
8377                   vex_reg = op++;
8378                   gas_assert (op < i.operands);
8379                 }
8380               else
8381                 {
8382                   /* Check register-only source operand when two source
8383                      operands are swapped.  */
8384                   if (!i.tm.operand_types[op].bitfield.baseindex
8385                       && i.tm.operand_types[op + 1].bitfield.baseindex)
8386                     {
8387                       vex_reg = op;
8388                       op += 2;
8389                       gas_assert (mem == (vex_reg + 1)
8390                                   && op < i.operands);
8391                     }
8392                   else
8393                     {
8394                       vex_reg = op + 1;
8395                       gas_assert (vex_reg < i.operands);
8396                     }
8397                 }
8398             }
8399           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
8400             {
8401               /* For instructions with VexNDD, the register destination
8402                  is encoded in VEX prefix.  */
8403               if (i.mem_operands == 0)
8404                 {
8405                   /* There is no memory operand.  */
8406                   gas_assert ((op + 2) == i.operands);
8407                   vex_reg = op + 1;
8408                 }
8409               else
8410                 {
8411                   /* There are only 2 non-immediate operands.  */
8412                   gas_assert (op < i.imm_operands + 2
8413                               && i.operands == i.imm_operands + 2);
8414                   vex_reg = i.imm_operands + 1;
8415                 }
8416             }
8417           else
8418             gas_assert (op < i.operands);
8419
8420           if (vex_reg != (unsigned int) ~0)
8421             {
8422               i386_operand_type *type = &i.tm.operand_types[vex_reg];
8423
8424               if ((type->bitfield.class != Reg
8425                    || (!type->bitfield.dword && !type->bitfield.qword))
8426                   && type->bitfield.class != RegSIMD
8427                   && !operand_type_equal (type, &regmask))
8428                 abort ();
8429
8430               i.vex.register_specifier = i.op[vex_reg].regs;
8431             }
8432
8433           /* Don't set OP operand twice.  */
8434           if (vex_reg != op)
8435             {
8436               /* If there is an extension opcode to put here, the
8437                  register number must be put into the regmem field.  */
8438               if (i.tm.extension_opcode != None)
8439                 {
8440                   i.rm.regmem = i.op[op].regs->reg_num;
8441                   set_rex_vrex (i.op[op].regs, REX_B,
8442                                 i.tm.opcode_modifier.sse2avx);
8443                 }
8444               else
8445                 {
8446                   i.rm.reg = i.op[op].regs->reg_num;
8447                   set_rex_vrex (i.op[op].regs, REX_R,
8448                                 i.tm.opcode_modifier.sse2avx);
8449                 }
8450             }
8451
8452           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
8453              must set it to 3 to indicate this is a register operand
8454              in the regmem field.  */
8455           if (!i.mem_operands)
8456             i.rm.mode = 3;
8457         }
8458
8459       /* Fill in i.rm.reg field with extension opcode (if any).  */
8460       if (i.tm.extension_opcode != None)
8461         i.rm.reg = i.tm.extension_opcode;
8462     }
8463   return default_seg;
8464 }
8465
8466 static INLINE void
8467 frag_opcode_byte (unsigned char byte)
8468 {
8469   if (now_seg != absolute_section)
8470     FRAG_APPEND_1_CHAR (byte);
8471   else
8472     ++abs_section_offset;
8473 }
8474
8475 static unsigned int
8476 flip_code16 (unsigned int code16)
8477 {
8478   gas_assert (i.tm.operands == 1);
8479
8480   return !(i.prefix[REX_PREFIX] & REX_W)
8481          && (code16 ? i.tm.operand_types[0].bitfield.disp32
8482                       || i.tm.operand_types[0].bitfield.disp32s
8483                     : i.tm.operand_types[0].bitfield.disp16)
8484          ? CODE16 : 0;
8485 }
8486
8487 static void
8488 output_branch (void)
8489 {
8490   char *p;
8491   int size;
8492   int code16;
8493   int prefix;
8494   relax_substateT subtype;
8495   symbolS *sym;
8496   offsetT off;
8497
8498   if (now_seg == absolute_section)
8499     {
8500       as_bad (_("relaxable branches not supported in absolute section"));
8501       return;
8502     }
8503
8504   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
8505   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
8506
8507   prefix = 0;
8508   if (i.prefix[DATA_PREFIX] != 0)
8509     {
8510       prefix = 1;
8511       i.prefixes -= 1;
8512       code16 ^= flip_code16(code16);
8513     }
8514   /* Pentium4 branch hints.  */
8515   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
8516       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
8517     {
8518       prefix++;
8519       i.prefixes--;
8520     }
8521   if (i.prefix[REX_PREFIX] != 0)
8522     {
8523       prefix++;
8524       i.prefixes--;
8525     }
8526
8527   /* BND prefixed jump.  */
8528   if (i.prefix[BND_PREFIX] != 0)
8529     {
8530       prefix++;
8531       i.prefixes--;
8532     }
8533
8534   if (i.prefixes != 0)
8535     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8536
8537   /* It's always a symbol;  End frag & setup for relax.
8538      Make sure there is enough room in this frag for the largest
8539      instruction we may generate in md_convert_frag.  This is 2
8540      bytes for the opcode and room for the prefix and largest
8541      displacement.  */
8542   frag_grow (prefix + 2 + 4);
8543   /* Prefix and 1 opcode byte go in fr_fix.  */
8544   p = frag_more (prefix + 1);
8545   if (i.prefix[DATA_PREFIX] != 0)
8546     *p++ = DATA_PREFIX_OPCODE;
8547   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
8548       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
8549     *p++ = i.prefix[SEG_PREFIX];
8550   if (i.prefix[BND_PREFIX] != 0)
8551     *p++ = BND_PREFIX_OPCODE;
8552   if (i.prefix[REX_PREFIX] != 0)
8553     *p++ = i.prefix[REX_PREFIX];
8554   *p = i.tm.base_opcode;
8555
8556   if ((unsigned char) *p == JUMP_PC_RELATIVE)
8557     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
8558   else if (cpu_arch_flags.bitfield.cpui386)
8559     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
8560   else
8561     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
8562   subtype |= code16;
8563
8564   sym = i.op[0].disps->X_add_symbol;
8565   off = i.op[0].disps->X_add_number;
8566
8567   if (i.op[0].disps->X_op != O_constant
8568       && i.op[0].disps->X_op != O_symbol)
8569     {
8570       /* Handle complex expressions.  */
8571       sym = make_expr_symbol (i.op[0].disps);
8572       off = 0;
8573     }
8574
8575   /* 1 possible extra opcode + 4 byte displacement go in var part.
8576      Pass reloc in fr_var.  */
8577   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
8578 }
8579
8580 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8581 /* Return TRUE iff PLT32 relocation should be used for branching to
8582    symbol S.  */
8583
8584 static bfd_boolean
8585 need_plt32_p (symbolS *s)
8586 {
8587   /* PLT32 relocation is ELF only.  */
8588   if (!IS_ELF)
8589     return FALSE;
8590
8591 #ifdef TE_SOLARIS
8592   /* Don't emit PLT32 relocation on Solaris: neither native linker nor
8593      krtld support it.  */
8594   return FALSE;
8595 #endif
8596
8597   /* Since there is no need to prepare for PLT branch on x86-64, we
8598      can generate R_X86_64_PLT32, instead of R_X86_64_PC32, which can
8599      be used as a marker for 32-bit PC-relative branches.  */
8600   if (!object_64bit)
8601     return FALSE;
8602
8603   /* Weak or undefined symbol need PLT32 relocation.  */
8604   if (S_IS_WEAK (s) || !S_IS_DEFINED (s))
8605     return TRUE;
8606
8607   /* Non-global symbol doesn't need PLT32 relocation.  */
8608   if (! S_IS_EXTERNAL (s))
8609     return FALSE;
8610
8611   /* Other global symbols need PLT32 relocation.  NB: Symbol with
8612      non-default visibilities are treated as normal global symbol
8613      so that PLT32 relocation can be used as a marker for 32-bit
8614      PC-relative branches.  It is useful for linker relaxation.  */
8615   return TRUE;
8616 }
8617 #endif
8618
8619 static void
8620 output_jump (void)
8621 {
8622   char *p;
8623   int size;
8624   fixS *fixP;
8625   bfd_reloc_code_real_type jump_reloc = i.reloc[0];
8626
8627   if (i.tm.opcode_modifier.jump == JUMP_BYTE)
8628     {
8629       /* This is a loop or jecxz type instruction.  */
8630       size = 1;
8631       if (i.prefix[ADDR_PREFIX] != 0)
8632         {
8633           frag_opcode_byte (ADDR_PREFIX_OPCODE);
8634           i.prefixes -= 1;
8635         }
8636       /* Pentium4 branch hints.  */
8637       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
8638           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
8639         {
8640           frag_opcode_byte (i.prefix[SEG_PREFIX]);
8641           i.prefixes--;
8642         }
8643     }
8644   else
8645     {
8646       int code16;
8647
8648       code16 = 0;
8649       if (flag_code == CODE_16BIT)
8650         code16 = CODE16;
8651
8652       if (i.prefix[DATA_PREFIX] != 0)
8653         {
8654           frag_opcode_byte (DATA_PREFIX_OPCODE);
8655           i.prefixes -= 1;
8656           code16 ^= flip_code16(code16);
8657         }
8658
8659       size = 4;
8660       if (code16)
8661         size = 2;
8662     }
8663
8664   /* BND prefixed jump.  */
8665   if (i.prefix[BND_PREFIX] != 0)
8666     {
8667       frag_opcode_byte (i.prefix[BND_PREFIX]);
8668       i.prefixes -= 1;
8669     }
8670
8671   if (i.prefix[REX_PREFIX] != 0)
8672     {
8673       frag_opcode_byte (i.prefix[REX_PREFIX]);
8674       i.prefixes -= 1;
8675     }
8676
8677   if (i.prefixes != 0)
8678     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8679
8680   if (now_seg == absolute_section)
8681     {
8682       abs_section_offset += i.tm.opcode_length + size;
8683       return;
8684     }
8685
8686   p = frag_more (i.tm.opcode_length + size);
8687   switch (i.tm.opcode_length)
8688     {
8689     case 2:
8690       *p++ = i.tm.base_opcode >> 8;
8691       /* Fall through.  */
8692     case 1:
8693       *p++ = i.tm.base_opcode;
8694       break;
8695     default:
8696       abort ();
8697     }
8698
8699 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8700   if (size == 4
8701       && jump_reloc == NO_RELOC
8702       && need_plt32_p (i.op[0].disps->X_add_symbol))
8703     jump_reloc = BFD_RELOC_X86_64_PLT32;
8704 #endif
8705
8706   jump_reloc = reloc (size, 1, 1, jump_reloc);
8707
8708   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8709                       i.op[0].disps, 1, jump_reloc);
8710
8711   /* All jumps handled here are signed, but don't use a signed limit
8712      check for 32 and 16 bit jumps as we want to allow wrap around at
8713      4G and 64k respectively.  */
8714   if (size == 1)
8715     fixP->fx_signed = 1;
8716 }
8717
8718 static void
8719 output_interseg_jump (void)
8720 {
8721   char *p;
8722   int size;
8723   int prefix;
8724   int code16;
8725
8726   code16 = 0;
8727   if (flag_code == CODE_16BIT)
8728     code16 = CODE16;
8729
8730   prefix = 0;
8731   if (i.prefix[DATA_PREFIX] != 0)
8732     {
8733       prefix = 1;
8734       i.prefixes -= 1;
8735       code16 ^= CODE16;
8736     }
8737
8738   gas_assert (!i.prefix[REX_PREFIX]);
8739
8740   size = 4;
8741   if (code16)
8742     size = 2;
8743
8744   if (i.prefixes != 0)
8745     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8746
8747   if (now_seg == absolute_section)
8748     {
8749       abs_section_offset += prefix + 1 + 2 + size;
8750       return;
8751     }
8752
8753   /* 1 opcode; 2 segment; offset  */
8754   p = frag_more (prefix + 1 + 2 + size);
8755
8756   if (i.prefix[DATA_PREFIX] != 0)
8757     *p++ = DATA_PREFIX_OPCODE;
8758
8759   if (i.prefix[REX_PREFIX] != 0)
8760     *p++ = i.prefix[REX_PREFIX];
8761
8762   *p++ = i.tm.base_opcode;
8763   if (i.op[1].imms->X_op == O_constant)
8764     {
8765       offsetT n = i.op[1].imms->X_add_number;
8766
8767       if (size == 2
8768           && !fits_in_unsigned_word (n)
8769           && !fits_in_signed_word (n))
8770         {
8771           as_bad (_("16-bit jump out of range"));
8772           return;
8773         }
8774       md_number_to_chars (p, n, size);
8775     }
8776   else
8777     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8778                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
8779   if (i.op[0].imms->X_op != O_constant)
8780     as_bad (_("can't handle non absolute segment in `%s'"),
8781             i.tm.name);
8782   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
8783 }
8784
8785 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8786 void
8787 x86_cleanup (void)
8788 {
8789   char *p;
8790   asection *seg = now_seg;
8791   subsegT subseg = now_subseg;
8792   asection *sec;
8793   unsigned int alignment, align_size_1;
8794   unsigned int isa_1_descsz, feature_2_descsz, descsz;
8795   unsigned int isa_1_descsz_raw, feature_2_descsz_raw;
8796   unsigned int padding;
8797
8798   if (!IS_ELF || !x86_used_note)
8799     return;
8800
8801   x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X86;
8802
8803   /* The .note.gnu.property section layout:
8804
8805      Field      Length          Contents
8806      ----       ----            ----
8807      n_namsz    4               4
8808      n_descsz   4               The note descriptor size
8809      n_type     4               NT_GNU_PROPERTY_TYPE_0
8810      n_name     4               "GNU"
8811      n_desc     n_descsz        The program property array
8812      ....       ....            ....
8813    */
8814
8815   /* Create the .note.gnu.property section.  */
8816   sec = subseg_new (NOTE_GNU_PROPERTY_SECTION_NAME, 0);
8817   bfd_set_section_flags (sec,
8818                          (SEC_ALLOC
8819                           | SEC_LOAD
8820                           | SEC_DATA
8821                           | SEC_HAS_CONTENTS
8822                           | SEC_READONLY));
8823
8824   if (get_elf_backend_data (stdoutput)->s->elfclass == ELFCLASS64)
8825     {
8826       align_size_1 = 7;
8827       alignment = 3;
8828     }
8829   else
8830     {
8831       align_size_1 = 3;
8832       alignment = 2;
8833     }
8834
8835   bfd_set_section_alignment (sec, alignment);
8836   elf_section_type (sec) = SHT_NOTE;
8837
8838   /* GNU_PROPERTY_X86_ISA_1_USED: 4-byte type + 4-byte data size
8839                                   + 4-byte data  */
8840   isa_1_descsz_raw = 4 + 4 + 4;
8841   /* Align GNU_PROPERTY_X86_ISA_1_USED.  */
8842   isa_1_descsz = (isa_1_descsz_raw + align_size_1) & ~align_size_1;
8843
8844   feature_2_descsz_raw = isa_1_descsz;
8845   /* GNU_PROPERTY_X86_FEATURE_2_USED: 4-byte type + 4-byte data size
8846                                       + 4-byte data  */
8847   feature_2_descsz_raw += 4 + 4 + 4;
8848   /* Align GNU_PROPERTY_X86_FEATURE_2_USED.  */
8849   feature_2_descsz = ((feature_2_descsz_raw + align_size_1)
8850                       & ~align_size_1);
8851
8852   descsz = feature_2_descsz;
8853   /* Section size: n_namsz + n_descsz + n_type + n_name + n_descsz.  */
8854   p = frag_more (4 + 4 + 4 + 4 + descsz);
8855
8856   /* Write n_namsz.  */
8857   md_number_to_chars (p, (valueT) 4, 4);
8858
8859   /* Write n_descsz.  */
8860   md_number_to_chars (p + 4, (valueT) descsz, 4);
8861
8862   /* Write n_type.  */
8863   md_number_to_chars (p + 4 * 2, (valueT) NT_GNU_PROPERTY_TYPE_0, 4);
8864
8865   /* Write n_name.  */
8866   memcpy (p + 4 * 3, "GNU", 4);
8867
8868   /* Write 4-byte type.  */
8869   md_number_to_chars (p + 4 * 4,
8870                       (valueT) GNU_PROPERTY_X86_ISA_1_USED, 4);
8871
8872   /* Write 4-byte data size.  */
8873   md_number_to_chars (p + 4 * 5, (valueT) 4, 4);
8874
8875   /* Write 4-byte data.  */
8876   md_number_to_chars (p + 4 * 6, (valueT) x86_isa_1_used, 4);
8877
8878   /* Zero out paddings.  */
8879   padding = isa_1_descsz - isa_1_descsz_raw;
8880   if (padding)
8881     memset (p + 4 * 7, 0, padding);
8882
8883   /* Write 4-byte type.  */
8884   md_number_to_chars (p + isa_1_descsz + 4 * 4,
8885                       (valueT) GNU_PROPERTY_X86_FEATURE_2_USED, 4);
8886
8887   /* Write 4-byte data size.  */
8888   md_number_to_chars (p + isa_1_descsz + 4 * 5, (valueT) 4, 4);
8889
8890   /* Write 4-byte data.  */
8891   md_number_to_chars (p + isa_1_descsz + 4 * 6,
8892                       (valueT) x86_feature_2_used, 4);
8893
8894   /* Zero out paddings.  */
8895   padding = feature_2_descsz - feature_2_descsz_raw;
8896   if (padding)
8897     memset (p + isa_1_descsz + 4 * 7, 0, padding);
8898
8899   /* We probably can't restore the current segment, for there likely
8900      isn't one yet...  */
8901   if (seg && subseg)
8902     subseg_set (seg, subseg);
8903 }
8904 #endif
8905
8906 static unsigned int
8907 encoding_length (const fragS *start_frag, offsetT start_off,
8908                  const char *frag_now_ptr)
8909 {
8910   unsigned int len = 0;
8911
8912   if (start_frag != frag_now)
8913     {
8914       const fragS *fr = start_frag;
8915
8916       do {
8917         len += fr->fr_fix;
8918         fr = fr->fr_next;
8919       } while (fr && fr != frag_now);
8920     }
8921
8922   return len - start_off + (frag_now_ptr - frag_now->fr_literal);
8923 }
8924
8925 /* Return 1 for test, and, cmp, add, sub, inc and dec which may
8926    be macro-fused with conditional jumps.
8927    NB: If TEST/AND/CMP/ADD/SUB/INC/DEC is of RIP relative address,
8928    or is one of the following format:
8929
8930     cmp m, imm
8931     add m, imm
8932     sub m, imm
8933    test m, imm
8934     and m, imm
8935     inc m
8936     dec m
8937
8938    it is unfusible.  */
8939
8940 static int
8941 maybe_fused_with_jcc_p (enum mf_cmp_kind* mf_cmp_p)
8942 {
8943   /* No RIP address.  */
8944   if (i.base_reg && i.base_reg->reg_num == RegIP)
8945     return 0;
8946
8947   /* No VEX/EVEX encoding.  */
8948   if (is_any_vex_encoding (&i.tm))
8949     return 0;
8950
8951   /* add, sub without add/sub m, imm.  */
8952   if (i.tm.base_opcode <= 5
8953       || (i.tm.base_opcode >= 0x28 && i.tm.base_opcode <= 0x2d)
8954       || ((i.tm.base_opcode | 3) == 0x83
8955           && (i.tm.extension_opcode == 0x5
8956               || i.tm.extension_opcode == 0x0)))
8957     {
8958       *mf_cmp_p = mf_cmp_alu_cmp;
8959       return !(i.mem_operands && i.imm_operands);
8960     }
8961
8962   /* and without and m, imm.  */
8963   if ((i.tm.base_opcode >= 0x20 && i.tm.base_opcode <= 0x25)
8964       || ((i.tm.base_opcode | 3) == 0x83
8965           && i.tm.extension_opcode == 0x4))
8966     {
8967       *mf_cmp_p = mf_cmp_test_and;
8968       return !(i.mem_operands && i.imm_operands);
8969     }
8970
8971   /* test without test m imm.  */
8972   if ((i.tm.base_opcode | 1) == 0x85
8973       || (i.tm.base_opcode | 1) == 0xa9
8974       || ((i.tm.base_opcode | 1) == 0xf7
8975           && i.tm.extension_opcode == 0))
8976     {
8977       *mf_cmp_p = mf_cmp_test_and;
8978       return !(i.mem_operands && i.imm_operands);
8979     }
8980
8981   /* cmp without cmp m, imm.  */
8982   if ((i.tm.base_opcode >= 0x38 && i.tm.base_opcode <= 0x3d)
8983       || ((i.tm.base_opcode | 3) == 0x83
8984           && (i.tm.extension_opcode == 0x7)))
8985     {
8986       *mf_cmp_p = mf_cmp_alu_cmp;
8987       return !(i.mem_operands && i.imm_operands);
8988     }
8989
8990   /* inc, dec without inc/dec m.   */
8991   if ((i.tm.cpu_flags.bitfield.cpuno64
8992        && (i.tm.base_opcode | 0xf) == 0x4f)
8993       || ((i.tm.base_opcode | 1) == 0xff
8994           && i.tm.extension_opcode <= 0x1))
8995     {
8996       *mf_cmp_p = mf_cmp_incdec;
8997       return !i.mem_operands;
8998     }
8999
9000   return 0;
9001 }
9002
9003 /* Return 1 if a FUSED_JCC_PADDING frag should be generated.  */
9004
9005 static int
9006 add_fused_jcc_padding_frag_p (enum mf_cmp_kind* mf_cmp_p)
9007 {
9008   /* NB: Don't work with COND_JUMP86 without i386.  */
9009   if (!align_branch_power
9010       || now_seg == absolute_section
9011       || !cpu_arch_flags.bitfield.cpui386
9012       || !(align_branch & align_branch_fused_bit))
9013     return 0;
9014
9015   if (maybe_fused_with_jcc_p (mf_cmp_p))
9016     {
9017       if (last_insn.kind == last_insn_other
9018           || last_insn.seg != now_seg)
9019         return 1;
9020       if (flag_debug)
9021         as_warn_where (last_insn.file, last_insn.line,
9022                        _("`%s` skips -malign-branch-boundary on `%s`"),
9023                        last_insn.name, i.tm.name);
9024     }
9025
9026   return 0;
9027 }
9028
9029 /* Return 1 if a BRANCH_PREFIX frag should be generated.  */
9030
9031 static int
9032 add_branch_prefix_frag_p (void)
9033 {
9034   /* NB: Don't work with COND_JUMP86 without i386.  Don't add prefix
9035      to PadLock instructions since they include prefixes in opcode.  */
9036   if (!align_branch_power
9037       || !align_branch_prefix_size
9038       || now_seg == absolute_section
9039       || i.tm.cpu_flags.bitfield.cpupadlock
9040       || !cpu_arch_flags.bitfield.cpui386)
9041     return 0;
9042
9043   /* Don't add prefix if it is a prefix or there is no operand in case
9044      that segment prefix is special.  */
9045   if (!i.operands || i.tm.opcode_modifier.isprefix)
9046     return 0;
9047
9048   if (last_insn.kind == last_insn_other
9049       || last_insn.seg != now_seg)
9050     return 1;
9051
9052   if (flag_debug)
9053     as_warn_where (last_insn.file, last_insn.line,
9054                    _("`%s` skips -malign-branch-boundary on `%s`"),
9055                    last_insn.name, i.tm.name);
9056
9057   return 0;
9058 }
9059
9060 /* Return 1 if a BRANCH_PADDING frag should be generated.  */
9061
9062 static int
9063 add_branch_padding_frag_p (enum align_branch_kind *branch_p,
9064                            enum mf_jcc_kind *mf_jcc_p)
9065 {
9066   int add_padding;
9067
9068   /* NB: Don't work with COND_JUMP86 without i386.  */
9069   if (!align_branch_power
9070       || now_seg == absolute_section
9071       || !cpu_arch_flags.bitfield.cpui386)
9072     return 0;
9073
9074   add_padding = 0;
9075
9076   /* Check for jcc and direct jmp.  */
9077   if (i.tm.opcode_modifier.jump == JUMP)
9078     {
9079       if (i.tm.base_opcode == JUMP_PC_RELATIVE)
9080         {
9081           *branch_p = align_branch_jmp;
9082           add_padding = align_branch & align_branch_jmp_bit;
9083         }
9084       else
9085         {
9086           /* Because J<cc> and JN<cc> share same group in macro-fusible table,
9087              igore the lowest bit.  */
9088           *mf_jcc_p = (i.tm.base_opcode & 0x0e) >> 1;
9089           *branch_p = align_branch_jcc;
9090           if ((align_branch & align_branch_jcc_bit))
9091             add_padding = 1;
9092         }
9093     }
9094   else if (is_any_vex_encoding (&i.tm))
9095     return 0;
9096   else if ((i.tm.base_opcode | 1) == 0xc3)
9097     {
9098       /* Near ret.  */
9099       *branch_p = align_branch_ret;
9100       if ((align_branch & align_branch_ret_bit))
9101         add_padding = 1;
9102     }
9103   else
9104     {
9105       /* Check for indirect jmp, direct and indirect calls.  */
9106       if (i.tm.base_opcode == 0xe8)
9107         {
9108           /* Direct call.  */
9109           *branch_p = align_branch_call;
9110           if ((align_branch & align_branch_call_bit))
9111             add_padding = 1;
9112         }
9113       else if (i.tm.base_opcode == 0xff
9114                && (i.tm.extension_opcode == 2
9115                    || i.tm.extension_opcode == 4))
9116         {
9117           /* Indirect call and jmp.  */
9118           *branch_p = align_branch_indirect;
9119           if ((align_branch & align_branch_indirect_bit))
9120             add_padding = 1;
9121         }
9122
9123       if (add_padding
9124           && i.disp_operands
9125           && tls_get_addr
9126           && (i.op[0].disps->X_op == O_symbol
9127               || (i.op[0].disps->X_op == O_subtract
9128                   && i.op[0].disps->X_op_symbol == GOT_symbol)))
9129         {
9130           symbolS *s = i.op[0].disps->X_add_symbol;
9131           /* No padding to call to global or undefined tls_get_addr.  */
9132           if ((S_IS_EXTERNAL (s) || !S_IS_DEFINED (s))
9133               && strcmp (S_GET_NAME (s), tls_get_addr) == 0)
9134             return 0;
9135         }
9136     }
9137
9138   if (add_padding
9139       && last_insn.kind != last_insn_other
9140       && last_insn.seg == now_seg)
9141     {
9142       if (flag_debug)
9143         as_warn_where (last_insn.file, last_insn.line,
9144                        _("`%s` skips -malign-branch-boundary on `%s`"),
9145                        last_insn.name, i.tm.name);
9146       return 0;
9147     }
9148
9149   return add_padding;
9150 }
9151
9152 static void
9153 output_insn (void)
9154 {
9155   fragS *insn_start_frag;
9156   offsetT insn_start_off;
9157   fragS *fragP = NULL;
9158   enum align_branch_kind branch = align_branch_none;
9159   /* The initializer is arbitrary just to avoid uninitialized error.
9160      it's actually either assigned in add_branch_padding_frag_p
9161      or never be used.  */
9162   enum mf_jcc_kind mf_jcc = mf_jcc_jo;
9163
9164 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9165   if (IS_ELF && x86_used_note && now_seg != absolute_section)
9166     {
9167       if (i.tm.cpu_flags.bitfield.cpucmov)
9168         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_CMOV;
9169       if (i.tm.cpu_flags.bitfield.cpusse)
9170         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE;
9171       if (i.tm.cpu_flags.bitfield.cpusse2)
9172         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE2;
9173       if (i.tm.cpu_flags.bitfield.cpusse3)
9174         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE3;
9175       if (i.tm.cpu_flags.bitfield.cpussse3)
9176         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSSE3;
9177       if (i.tm.cpu_flags.bitfield.cpusse4_1)
9178         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_1;
9179       if (i.tm.cpu_flags.bitfield.cpusse4_2)
9180         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_2;
9181       if (i.tm.cpu_flags.bitfield.cpuavx)
9182         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX;
9183       if (i.tm.cpu_flags.bitfield.cpuavx2)
9184         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX2;
9185       if (i.tm.cpu_flags.bitfield.cpufma)
9186         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_FMA;
9187       if (i.tm.cpu_flags.bitfield.cpuavx512f)
9188         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512F;
9189       if (i.tm.cpu_flags.bitfield.cpuavx512cd)
9190         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512CD;
9191       if (i.tm.cpu_flags.bitfield.cpuavx512er)
9192         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512ER;
9193       if (i.tm.cpu_flags.bitfield.cpuavx512pf)
9194         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512PF;
9195       if (i.tm.cpu_flags.bitfield.cpuavx512vl)
9196         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512VL;
9197       if (i.tm.cpu_flags.bitfield.cpuavx512dq)
9198         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512DQ;
9199       if (i.tm.cpu_flags.bitfield.cpuavx512bw)
9200         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512BW;
9201       if (i.tm.cpu_flags.bitfield.cpuavx512_4fmaps)
9202         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS;
9203       if (i.tm.cpu_flags.bitfield.cpuavx512_4vnniw)
9204         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW;
9205       if (i.tm.cpu_flags.bitfield.cpuavx512_bitalg)
9206         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BITALG;
9207       if (i.tm.cpu_flags.bitfield.cpuavx512ifma)
9208         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_IFMA;
9209       if (i.tm.cpu_flags.bitfield.cpuavx512vbmi)
9210         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI;
9211       if (i.tm.cpu_flags.bitfield.cpuavx512_vbmi2)
9212         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2;
9213       if (i.tm.cpu_flags.bitfield.cpuavx512_vnni)
9214         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VNNI;
9215       if (i.tm.cpu_flags.bitfield.cpuavx512_bf16)
9216         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BF16;
9217
9218       if (i.tm.cpu_flags.bitfield.cpu8087
9219           || i.tm.cpu_flags.bitfield.cpu287
9220           || i.tm.cpu_flags.bitfield.cpu387
9221           || i.tm.cpu_flags.bitfield.cpu687
9222           || i.tm.cpu_flags.bitfield.cpufisttp)
9223         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X87;
9224       if ((i.xstate & xstate_mmx)
9225           || i.tm.base_opcode == 0xf77 /* emms */
9226           || i.tm.base_opcode == 0xf0e /* femms */)
9227         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_MMX;
9228       if ((i.xstate & xstate_xmm)
9229           || i.tm.cpu_flags.bitfield.cpuwidekl
9230           || i.tm.cpu_flags.bitfield.cpukl)
9231         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XMM;
9232       if ((i.xstate & xstate_ymm) == xstate_ymm)
9233         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_YMM;
9234       if ((i.xstate & xstate_zmm) == xstate_zmm)
9235         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_ZMM;
9236       if (i.tm.cpu_flags.bitfield.cpufxsr)
9237         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_FXSR;
9238       if (i.tm.cpu_flags.bitfield.cpuxsave)
9239         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVE;
9240       if (i.tm.cpu_flags.bitfield.cpuxsaveopt)
9241         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT;
9242       if (i.tm.cpu_flags.bitfield.cpuxsavec)
9243         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEC;
9244
9245       if ((i.xstate & xstate_tmm) == xstate_tmm
9246           || i.tm.cpu_flags.bitfield.cpuamx_tile)
9247         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_TMM;
9248     }
9249 #endif
9250
9251   /* Tie dwarf2 debug info to the address at the start of the insn.
9252      We can't do this after the insn has been output as the current
9253      frag may have been closed off.  eg. by frag_var.  */
9254   dwarf2_emit_insn (0);
9255
9256   insn_start_frag = frag_now;
9257   insn_start_off = frag_now_fix ();
9258
9259   if (add_branch_padding_frag_p (&branch, &mf_jcc))
9260     {
9261       char *p;
9262       /* Branch can be 8 bytes.  Leave some room for prefixes.  */
9263       unsigned int max_branch_padding_size = 14;
9264
9265       /* Align section to boundary.  */
9266       record_alignment (now_seg, align_branch_power);
9267
9268       /* Make room for padding.  */
9269       frag_grow (max_branch_padding_size);
9270
9271       /* Start of the padding.  */
9272       p = frag_more (0);
9273
9274       fragP = frag_now;
9275
9276       frag_var (rs_machine_dependent, max_branch_padding_size, 0,
9277                 ENCODE_RELAX_STATE (BRANCH_PADDING, 0),
9278                 NULL, 0, p);
9279
9280       fragP->tc_frag_data.mf_type = mf_jcc;
9281       fragP->tc_frag_data.branch_type = branch;
9282       fragP->tc_frag_data.max_bytes = max_branch_padding_size;
9283     }
9284
9285   /* Output jumps.  */
9286   if (i.tm.opcode_modifier.jump == JUMP)
9287     output_branch ();
9288   else if (i.tm.opcode_modifier.jump == JUMP_BYTE
9289            || i.tm.opcode_modifier.jump == JUMP_DWORD)
9290     output_jump ();
9291   else if (i.tm.opcode_modifier.jump == JUMP_INTERSEGMENT)
9292     output_interseg_jump ();
9293   else
9294     {
9295       /* Output normal instructions here.  */
9296       char *p;
9297       unsigned char *q;
9298       unsigned int j;
9299       unsigned int prefix;
9300       enum mf_cmp_kind mf_cmp;
9301
9302       if (avoid_fence
9303           && (i.tm.base_opcode == 0xfaee8
9304               || i.tm.base_opcode == 0xfaef0
9305               || i.tm.base_opcode == 0xfaef8))
9306         {
9307           /* Encode lfence, mfence, and sfence as
9308              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
9309           if (now_seg != absolute_section)
9310             {
9311               offsetT val = 0x240483f0ULL;
9312
9313               p = frag_more (5);
9314               md_number_to_chars (p, val, 5);
9315             }
9316           else
9317             abs_section_offset += 5;
9318           return;
9319         }
9320
9321       /* Some processors fail on LOCK prefix. This options makes
9322          assembler ignore LOCK prefix and serves as a workaround.  */
9323       if (omit_lock_prefix)
9324         {
9325           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
9326             return;
9327           i.prefix[LOCK_PREFIX] = 0;
9328         }
9329
9330       if (branch)
9331         /* Skip if this is a branch.  */
9332         ;
9333       else if (add_fused_jcc_padding_frag_p (&mf_cmp))
9334         {
9335           /* Make room for padding.  */
9336           frag_grow (MAX_FUSED_JCC_PADDING_SIZE);
9337           p = frag_more (0);
9338
9339           fragP = frag_now;
9340
9341           frag_var (rs_machine_dependent, MAX_FUSED_JCC_PADDING_SIZE, 0,
9342                     ENCODE_RELAX_STATE (FUSED_JCC_PADDING, 0),
9343                     NULL, 0, p);
9344
9345           fragP->tc_frag_data.mf_type = mf_cmp;
9346           fragP->tc_frag_data.branch_type = align_branch_fused;
9347           fragP->tc_frag_data.max_bytes = MAX_FUSED_JCC_PADDING_SIZE;
9348         }
9349       else if (add_branch_prefix_frag_p ())
9350         {
9351           unsigned int max_prefix_size = align_branch_prefix_size;
9352
9353           /* Make room for padding.  */
9354           frag_grow (max_prefix_size);
9355           p = frag_more (0);
9356
9357           fragP = frag_now;
9358
9359           frag_var (rs_machine_dependent, max_prefix_size, 0,
9360                     ENCODE_RELAX_STATE (BRANCH_PREFIX, 0),
9361                     NULL, 0, p);
9362
9363           fragP->tc_frag_data.max_bytes = max_prefix_size;
9364         }
9365
9366       /* Since the VEX/EVEX prefix contains the implicit prefix, we
9367          don't need the explicit prefix.  */
9368       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
9369         {
9370           switch (i.tm.opcode_length)
9371             {
9372             case 3:
9373               if (i.tm.base_opcode & 0xff000000)
9374                 {
9375                   prefix = (i.tm.base_opcode >> 24) & 0xff;
9376                   if (!i.tm.cpu_flags.bitfield.cpupadlock
9377                       || prefix != REPE_PREFIX_OPCODE
9378                       || (i.prefix[REP_PREFIX] != REPE_PREFIX_OPCODE))
9379                     add_prefix (prefix);
9380                 }
9381               break;
9382             case 2:
9383               if ((i.tm.base_opcode & 0xff0000) != 0)
9384                 {
9385                   prefix = (i.tm.base_opcode >> 16) & 0xff;
9386                   add_prefix (prefix);
9387                 }
9388               break;
9389             case 1:
9390               break;
9391             case 0:
9392               /* Check for pseudo prefixes.  */
9393               as_bad_where (insn_start_frag->fr_file,
9394                             insn_start_frag->fr_line,
9395                              _("pseudo prefix without instruction"));
9396               return;
9397             default:
9398               abort ();
9399             }
9400
9401 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
9402           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
9403              R_X86_64_GOTTPOFF relocation so that linker can safely
9404              perform IE->LE optimization.  A dummy REX_OPCODE prefix
9405              is also needed for lea with R_X86_64_GOTPC32_TLSDESC
9406              relocation for GDesc -> IE/LE optimization.  */
9407           if (x86_elf_abi == X86_64_X32_ABI
9408               && i.operands == 2
9409               && (i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
9410                   || i.reloc[0] == BFD_RELOC_X86_64_GOTPC32_TLSDESC)
9411               && i.prefix[REX_PREFIX] == 0)
9412             add_prefix (REX_OPCODE);
9413 #endif
9414
9415           /* The prefix bytes.  */
9416           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
9417             if (*q)
9418               frag_opcode_byte (*q);
9419         }
9420       else
9421         {
9422           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
9423             if (*q)
9424               switch (j)
9425                 {
9426                 case SEG_PREFIX:
9427                 case ADDR_PREFIX:
9428                   frag_opcode_byte (*q);
9429                   break;
9430                 default:
9431                   /* There should be no other prefixes for instructions
9432                      with VEX prefix.  */
9433                   abort ();
9434                 }
9435
9436           /* For EVEX instructions i.vrex should become 0 after
9437              build_evex_prefix.  For VEX instructions upper 16 registers
9438              aren't available, so VREX should be 0.  */
9439           if (i.vrex)
9440             abort ();
9441           /* Now the VEX prefix.  */
9442           if (now_seg != absolute_section)
9443             {
9444               p = frag_more (i.vex.length);
9445               for (j = 0; j < i.vex.length; j++)
9446                 p[j] = i.vex.bytes[j];
9447             }
9448           else
9449             abs_section_offset += i.vex.length;
9450         }
9451
9452       /* Now the opcode; be careful about word order here!  */
9453       if (now_seg == absolute_section)
9454         abs_section_offset += i.tm.opcode_length;
9455       else if (i.tm.opcode_length == 1)
9456         {
9457           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
9458         }
9459       else
9460         {
9461           switch (i.tm.opcode_length)
9462             {
9463             case 4:
9464               p = frag_more (4);
9465               *p++ = (i.tm.base_opcode >> 24) & 0xff;
9466               *p++ = (i.tm.base_opcode >> 16) & 0xff;
9467               break;
9468             case 3:
9469               p = frag_more (3);
9470               *p++ = (i.tm.base_opcode >> 16) & 0xff;
9471               break;
9472             case 2:
9473               p = frag_more (2);
9474               break;
9475             default:
9476               abort ();
9477               break;
9478             }
9479
9480           /* Put out high byte first: can't use md_number_to_chars!  */
9481           *p++ = (i.tm.base_opcode >> 8) & 0xff;
9482           *p = i.tm.base_opcode & 0xff;
9483         }
9484
9485       /* Now the modrm byte and sib byte (if present).  */
9486       if (i.tm.opcode_modifier.modrm)
9487         {
9488           frag_opcode_byte ((i.rm.regmem << 0)
9489                              | (i.rm.reg << 3)
9490                              | (i.rm.mode << 6));
9491           /* If i.rm.regmem == ESP (4)
9492              && i.rm.mode != (Register mode)
9493              && not 16 bit
9494              ==> need second modrm byte.  */
9495           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
9496               && i.rm.mode != 3
9497               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
9498             frag_opcode_byte ((i.sib.base << 0)
9499                               | (i.sib.index << 3)
9500                               | (i.sib.scale << 6));
9501         }
9502
9503       if (i.disp_operands)
9504         output_disp (insn_start_frag, insn_start_off);
9505
9506       if (i.imm_operands)
9507         output_imm (insn_start_frag, insn_start_off);
9508
9509       /*
9510        * frag_now_fix () returning plain abs_section_offset when we're in the
9511        * absolute section, and abs_section_offset not getting updated as data
9512        * gets added to the frag breaks the logic below.
9513        */
9514       if (now_seg != absolute_section)
9515         {
9516           j = encoding_length (insn_start_frag, insn_start_off, frag_more (0));
9517           if (j > 15)
9518             as_warn (_("instruction length of %u bytes exceeds the limit of 15"),
9519                      j);
9520           else if (fragP)
9521             {
9522               /* NB: Don't add prefix with GOTPC relocation since
9523                  output_disp() above depends on the fixed encoding
9524                  length.  Can't add prefix with TLS relocation since
9525                  it breaks TLS linker optimization.  */
9526               unsigned int max = i.has_gotpc_tls_reloc ? 0 : 15 - j;
9527               /* Prefix count on the current instruction.  */
9528               unsigned int count = i.vex.length;
9529               unsigned int k;
9530               for (k = 0; k < ARRAY_SIZE (i.prefix); k++)
9531                 /* REX byte is encoded in VEX/EVEX prefix.  */
9532                 if (i.prefix[k] && (k != REX_PREFIX || !i.vex.length))
9533                   count++;
9534
9535               /* Count prefixes for extended opcode maps.  */
9536               if (!i.vex.length)
9537                 switch (i.tm.opcode_length)
9538                   {
9539                   case 3:
9540                     if (((i.tm.base_opcode >> 16) & 0xff) == 0xf)
9541                       {
9542                         count++;
9543                         switch ((i.tm.base_opcode >> 8) & 0xff)
9544                           {
9545                           case 0x38:
9546                           case 0x3a:
9547                             count++;
9548                             break;
9549                           default:
9550                             break;
9551                           }
9552                       }
9553                     break;
9554                   case 2:
9555                     if (((i.tm.base_opcode >> 8) & 0xff) == 0xf)
9556                       count++;
9557                     break;
9558                   case 1:
9559                     break;
9560                   default:
9561                     abort ();
9562                   }
9563
9564               if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
9565                   == BRANCH_PREFIX)
9566                 {
9567                   /* Set the maximum prefix size in BRANCH_PREFIX
9568                      frag.  */
9569                   if (fragP->tc_frag_data.max_bytes > max)
9570                     fragP->tc_frag_data.max_bytes = max;
9571                   if (fragP->tc_frag_data.max_bytes > count)
9572                     fragP->tc_frag_data.max_bytes -= count;
9573                   else
9574                     fragP->tc_frag_data.max_bytes = 0;
9575                 }
9576               else
9577                 {
9578                   /* Remember the maximum prefix size in FUSED_JCC_PADDING
9579                      frag.  */
9580                   unsigned int max_prefix_size;
9581                   if (align_branch_prefix_size > max)
9582                     max_prefix_size = max;
9583                   else
9584                     max_prefix_size = align_branch_prefix_size;
9585                   if (max_prefix_size > count)
9586                     fragP->tc_frag_data.max_prefix_length
9587                       = max_prefix_size - count;
9588                 }
9589
9590               /* Use existing segment prefix if possible.  Use CS
9591                  segment prefix in 64-bit mode.  In 32-bit mode, use SS
9592                  segment prefix with ESP/EBP base register and use DS
9593                  segment prefix without ESP/EBP base register.  */
9594               if (i.prefix[SEG_PREFIX])
9595                 fragP->tc_frag_data.default_prefix = i.prefix[SEG_PREFIX];
9596               else if (flag_code == CODE_64BIT)
9597                 fragP->tc_frag_data.default_prefix = CS_PREFIX_OPCODE;
9598               else if (i.base_reg
9599                        && (i.base_reg->reg_num == 4
9600                            || i.base_reg->reg_num == 5))
9601                 fragP->tc_frag_data.default_prefix = SS_PREFIX_OPCODE;
9602               else
9603                 fragP->tc_frag_data.default_prefix = DS_PREFIX_OPCODE;
9604             }
9605         }
9606     }
9607
9608   /* NB: Don't work with COND_JUMP86 without i386.  */
9609   if (align_branch_power
9610       && now_seg != absolute_section
9611       && cpu_arch_flags.bitfield.cpui386)
9612     {
9613       /* Terminate each frag so that we can add prefix and check for
9614          fused jcc.  */
9615       frag_wane (frag_now);
9616       frag_new (0);
9617     }
9618
9619 #ifdef DEBUG386
9620   if (flag_debug)
9621     {
9622       pi ("" /*line*/, &i);
9623     }
9624 #endif /* DEBUG386  */
9625 }
9626
9627 /* Return the size of the displacement operand N.  */
9628
9629 static int
9630 disp_size (unsigned int n)
9631 {
9632   int size = 4;
9633
9634   if (i.types[n].bitfield.disp64)
9635     size = 8;
9636   else if (i.types[n].bitfield.disp8)
9637     size = 1;
9638   else if (i.types[n].bitfield.disp16)
9639     size = 2;
9640   return size;
9641 }
9642
9643 /* Return the size of the immediate operand N.  */
9644
9645 static int
9646 imm_size (unsigned int n)
9647 {
9648   int size = 4;
9649   if (i.types[n].bitfield.imm64)
9650     size = 8;
9651   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
9652     size = 1;
9653   else if (i.types[n].bitfield.imm16)
9654     size = 2;
9655   return size;
9656 }
9657
9658 static void
9659 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
9660 {
9661   char *p;
9662   unsigned int n;
9663
9664   for (n = 0; n < i.operands; n++)
9665     {
9666       if (operand_type_check (i.types[n], disp))
9667         {
9668           int size = disp_size (n);
9669
9670           if (now_seg == absolute_section)
9671             abs_section_offset += size;
9672           else if (i.op[n].disps->X_op == O_constant)
9673             {
9674               offsetT val = i.op[n].disps->X_add_number;
9675
9676               val = offset_in_range (val >> (size == 1 ? i.memshift : 0),
9677                                      size);
9678               p = frag_more (size);
9679               md_number_to_chars (p, val, size);
9680             }
9681           else
9682             {
9683               enum bfd_reloc_code_real reloc_type;
9684               int sign = i.types[n].bitfield.disp32s;
9685               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
9686               fixS *fixP;
9687
9688               /* We can't have 8 bit displacement here.  */
9689               gas_assert (!i.types[n].bitfield.disp8);
9690
9691               /* The PC relative address is computed relative
9692                  to the instruction boundary, so in case immediate
9693                  fields follows, we need to adjust the value.  */
9694               if (pcrel && i.imm_operands)
9695                 {
9696                   unsigned int n1;
9697                   int sz = 0;
9698
9699                   for (n1 = 0; n1 < i.operands; n1++)
9700                     if (operand_type_check (i.types[n1], imm))
9701                       {
9702                         /* Only one immediate is allowed for PC
9703                            relative address.  */
9704                         gas_assert (sz == 0);
9705                         sz = imm_size (n1);
9706                         i.op[n].disps->X_add_number -= sz;
9707                       }
9708                   /* We should find the immediate.  */
9709                   gas_assert (sz != 0);
9710                 }
9711
9712               p = frag_more (size);
9713               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
9714               if (GOT_symbol
9715                   && GOT_symbol == i.op[n].disps->X_add_symbol
9716                   && (((reloc_type == BFD_RELOC_32
9717                         || reloc_type == BFD_RELOC_X86_64_32S
9718                         || (reloc_type == BFD_RELOC_64
9719                             && object_64bit))
9720                        && (i.op[n].disps->X_op == O_symbol
9721                            || (i.op[n].disps->X_op == O_add
9722                                && ((symbol_get_value_expression
9723                                     (i.op[n].disps->X_op_symbol)->X_op)
9724                                    == O_subtract))))
9725                       || reloc_type == BFD_RELOC_32_PCREL))
9726                 {
9727                   if (!object_64bit)
9728                     {
9729                       reloc_type = BFD_RELOC_386_GOTPC;
9730                       i.has_gotpc_tls_reloc = TRUE;
9731                       i.op[n].imms->X_add_number +=
9732                         encoding_length (insn_start_frag, insn_start_off, p);
9733                     }
9734                   else if (reloc_type == BFD_RELOC_64)
9735                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
9736                   else
9737                     /* Don't do the adjustment for x86-64, as there
9738                        the pcrel addressing is relative to the _next_
9739                        insn, and that is taken care of in other code.  */
9740                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
9741                 }
9742               else if (align_branch_power)
9743                 {
9744                   switch (reloc_type)
9745                     {
9746                     case BFD_RELOC_386_TLS_GD:
9747                     case BFD_RELOC_386_TLS_LDM:
9748                     case BFD_RELOC_386_TLS_IE:
9749                     case BFD_RELOC_386_TLS_IE_32:
9750                     case BFD_RELOC_386_TLS_GOTIE:
9751                     case BFD_RELOC_386_TLS_GOTDESC:
9752                     case BFD_RELOC_386_TLS_DESC_CALL:
9753                     case BFD_RELOC_X86_64_TLSGD:
9754                     case BFD_RELOC_X86_64_TLSLD:
9755                     case BFD_RELOC_X86_64_GOTTPOFF:
9756                     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
9757                     case BFD_RELOC_X86_64_TLSDESC_CALL:
9758                       i.has_gotpc_tls_reloc = TRUE;
9759                     default:
9760                       break;
9761                     }
9762                 }
9763               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
9764                                   size, i.op[n].disps, pcrel,
9765                                   reloc_type);
9766               /* Check for "call/jmp *mem", "mov mem, %reg",
9767                  "test %reg, mem" and "binop mem, %reg" where binop
9768                  is one of adc, add, and, cmp, or, sbb, sub, xor
9769                  instructions without data prefix.  Always generate
9770                  R_386_GOT32X for "sym*GOT" operand in 32-bit mode.  */
9771               if (i.prefix[DATA_PREFIX] == 0
9772                   && (generate_relax_relocations
9773                       || (!object_64bit
9774                           && i.rm.mode == 0
9775                           && i.rm.regmem == 5))
9776                   && (i.rm.mode == 2
9777                       || (i.rm.mode == 0 && i.rm.regmem == 5))
9778                   && !is_any_vex_encoding(&i.tm)
9779                   && ((i.operands == 1
9780                        && i.tm.base_opcode == 0xff
9781                        && (i.rm.reg == 2 || i.rm.reg == 4))
9782                       || (i.operands == 2
9783                           && (i.tm.base_opcode == 0x8b
9784                               || i.tm.base_opcode == 0x85
9785                               || (i.tm.base_opcode & ~0x38) == 0x03))))
9786                 {
9787                   if (object_64bit)
9788                     {
9789                       fixP->fx_tcbit = i.rex != 0;
9790                       if (i.base_reg
9791                           && (i.base_reg->reg_num == RegIP))
9792                       fixP->fx_tcbit2 = 1;
9793                     }
9794                   else
9795                     fixP->fx_tcbit2 = 1;
9796                 }
9797             }
9798         }
9799     }
9800 }
9801
9802 static void
9803 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
9804 {
9805   char *p;
9806   unsigned int n;
9807
9808   for (n = 0; n < i.operands; n++)
9809     {
9810       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
9811       if (i.rounding && (int) n == i.rounding->operand)
9812         continue;
9813
9814       if (operand_type_check (i.types[n], imm))
9815         {
9816           int size = imm_size (n);
9817
9818           if (now_seg == absolute_section)
9819             abs_section_offset += size;
9820           else if (i.op[n].imms->X_op == O_constant)
9821             {
9822               offsetT val;
9823
9824               val = offset_in_range (i.op[n].imms->X_add_number,
9825                                      size);
9826               p = frag_more (size);
9827               md_number_to_chars (p, val, size);
9828             }
9829           else
9830             {
9831               /* Not absolute_section.
9832                  Need a 32-bit fixup (don't support 8bit
9833                  non-absolute imms).  Try to support other
9834                  sizes ...  */
9835               enum bfd_reloc_code_real reloc_type;
9836               int sign;
9837
9838               if (i.types[n].bitfield.imm32s
9839                   && (i.suffix == QWORD_MNEM_SUFFIX
9840                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
9841                 sign = 1;
9842               else
9843                 sign = 0;
9844
9845               p = frag_more (size);
9846               reloc_type = reloc (size, 0, sign, i.reloc[n]);
9847
9848               /*   This is tough to explain.  We end up with this one if we
9849                * have operands that look like
9850                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
9851                * obtain the absolute address of the GOT, and it is strongly
9852                * preferable from a performance point of view to avoid using
9853                * a runtime relocation for this.  The actual sequence of
9854                * instructions often look something like:
9855                *
9856                *        call    .L66
9857                * .L66:
9858                *        popl    %ebx
9859                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
9860                *
9861                *   The call and pop essentially return the absolute address
9862                * of the label .L66 and store it in %ebx.  The linker itself
9863                * will ultimately change the first operand of the addl so
9864                * that %ebx points to the GOT, but to keep things simple, the
9865                * .o file must have this operand set so that it generates not
9866                * the absolute address of .L66, but the absolute address of
9867                * itself.  This allows the linker itself simply treat a GOTPC
9868                * relocation as asking for a pcrel offset to the GOT to be
9869                * added in, and the addend of the relocation is stored in the
9870                * operand field for the instruction itself.
9871                *
9872                *   Our job here is to fix the operand so that it would add
9873                * the correct offset so that %ebx would point to itself.  The
9874                * thing that is tricky is that .-.L66 will point to the
9875                * beginning of the instruction, so we need to further modify
9876                * the operand so that it will point to itself.  There are
9877                * other cases where you have something like:
9878                *
9879                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
9880                *
9881                * and here no correction would be required.  Internally in
9882                * the assembler we treat operands of this form as not being
9883                * pcrel since the '.' is explicitly mentioned, and I wonder
9884                * whether it would simplify matters to do it this way.  Who
9885                * knows.  In earlier versions of the PIC patches, the
9886                * pcrel_adjust field was used to store the correction, but
9887                * since the expression is not pcrel, I felt it would be
9888                * confusing to do it this way.  */
9889
9890               if ((reloc_type == BFD_RELOC_32
9891                    || reloc_type == BFD_RELOC_X86_64_32S
9892                    || reloc_type == BFD_RELOC_64)
9893                   && GOT_symbol
9894                   && GOT_symbol == i.op[n].imms->X_add_symbol
9895                   && (i.op[n].imms->X_op == O_symbol
9896                       || (i.op[n].imms->X_op == O_add
9897                           && ((symbol_get_value_expression
9898                                (i.op[n].imms->X_op_symbol)->X_op)
9899                               == O_subtract))))
9900                 {
9901                   if (!object_64bit)
9902                     reloc_type = BFD_RELOC_386_GOTPC;
9903                   else if (size == 4)
9904                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
9905                   else if (size == 8)
9906                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
9907                   i.has_gotpc_tls_reloc = TRUE;
9908                   i.op[n].imms->X_add_number +=
9909                     encoding_length (insn_start_frag, insn_start_off, p);
9910                 }
9911               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
9912                            i.op[n].imms, 0, reloc_type);
9913             }
9914         }
9915     }
9916 }
9917 \f
9918 /* x86_cons_fix_new is called via the expression parsing code when a
9919    reloc is needed.  We use this hook to get the correct .got reloc.  */
9920 static int cons_sign = -1;
9921
9922 void
9923 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
9924                   expressionS *exp, bfd_reloc_code_real_type r)
9925 {
9926   r = reloc (len, 0, cons_sign, r);
9927
9928 #ifdef TE_PE
9929   if (exp->X_op == O_secrel)
9930     {
9931       exp->X_op = O_symbol;
9932       r = BFD_RELOC_32_SECREL;
9933     }
9934 #endif
9935
9936   fix_new_exp (frag, off, len, exp, 0, r);
9937 }
9938
9939 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
9940    purpose of the `.dc.a' internal pseudo-op.  */
9941
9942 int
9943 x86_address_bytes (void)
9944 {
9945   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
9946     return 4;
9947   return stdoutput->arch_info->bits_per_address / 8;
9948 }
9949
9950 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
9951     || defined (LEX_AT)
9952 # define lex_got(reloc, adjust, types) NULL
9953 #else
9954 /* Parse operands of the form
9955    <symbol>@GOTOFF+<nnn>
9956    and similar .plt or .got references.
9957
9958    If we find one, set up the correct relocation in RELOC and copy the
9959    input string, minus the `@GOTOFF' into a malloc'd buffer for
9960    parsing by the calling routine.  Return this buffer, and if ADJUST
9961    is non-null set it to the length of the string we removed from the
9962    input line.  Otherwise return NULL.  */
9963 static char *
9964 lex_got (enum bfd_reloc_code_real *rel,
9965          int *adjust,
9966          i386_operand_type *types)
9967 {
9968   /* Some of the relocations depend on the size of what field is to
9969      be relocated.  But in our callers i386_immediate and i386_displacement
9970      we don't yet know the operand size (this will be set by insn
9971      matching).  Hence we record the word32 relocation here,
9972      and adjust the reloc according to the real size in reloc().  */
9973   static const struct {
9974     const char *str;
9975     int len;
9976     const enum bfd_reloc_code_real rel[2];
9977     const i386_operand_type types64;
9978   } gotrel[] = {
9979 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9980     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
9981                                         BFD_RELOC_SIZE32 },
9982       OPERAND_TYPE_IMM32_64 },
9983 #endif
9984     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
9985                                        BFD_RELOC_X86_64_PLTOFF64 },
9986       OPERAND_TYPE_IMM64 },
9987     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
9988                                        BFD_RELOC_X86_64_PLT32    },
9989       OPERAND_TYPE_IMM32_32S_DISP32 },
9990     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
9991                                        BFD_RELOC_X86_64_GOTPLT64 },
9992       OPERAND_TYPE_IMM64_DISP64 },
9993     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
9994                                        BFD_RELOC_X86_64_GOTOFF64 },
9995       OPERAND_TYPE_IMM64_DISP64 },
9996     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
9997                                        BFD_RELOC_X86_64_GOTPCREL },
9998       OPERAND_TYPE_IMM32_32S_DISP32 },
9999     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
10000                                        BFD_RELOC_X86_64_TLSGD    },
10001       OPERAND_TYPE_IMM32_32S_DISP32 },
10002     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
10003                                        _dummy_first_bfd_reloc_code_real },
10004       OPERAND_TYPE_NONE },
10005     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
10006                                        BFD_RELOC_X86_64_TLSLD    },
10007       OPERAND_TYPE_IMM32_32S_DISP32 },
10008     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
10009                                        BFD_RELOC_X86_64_GOTTPOFF },
10010       OPERAND_TYPE_IMM32_32S_DISP32 },
10011     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
10012                                        BFD_RELOC_X86_64_TPOFF32  },
10013       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10014     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
10015                                        _dummy_first_bfd_reloc_code_real },
10016       OPERAND_TYPE_NONE },
10017     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
10018                                        BFD_RELOC_X86_64_DTPOFF32 },
10019       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10020     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
10021                                        _dummy_first_bfd_reloc_code_real },
10022       OPERAND_TYPE_NONE },
10023     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
10024                                        _dummy_first_bfd_reloc_code_real },
10025       OPERAND_TYPE_NONE },
10026     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
10027                                        BFD_RELOC_X86_64_GOT32    },
10028       OPERAND_TYPE_IMM32_32S_64_DISP32 },
10029     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
10030                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
10031       OPERAND_TYPE_IMM32_32S_DISP32 },
10032     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
10033                                        BFD_RELOC_X86_64_TLSDESC_CALL },
10034       OPERAND_TYPE_IMM32_32S_DISP32 },
10035   };
10036   char *cp;
10037   unsigned int j;
10038
10039 #if defined (OBJ_MAYBE_ELF)
10040   if (!IS_ELF)
10041     return NULL;
10042 #endif
10043
10044   for (cp = input_line_pointer; *cp != '@'; cp++)
10045     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
10046       return NULL;
10047
10048   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
10049     {
10050       int len = gotrel[j].len;
10051       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
10052         {
10053           if (gotrel[j].rel[object_64bit] != 0)
10054             {
10055               int first, second;
10056               char *tmpbuf, *past_reloc;
10057
10058               *rel = gotrel[j].rel[object_64bit];
10059
10060               if (types)
10061                 {
10062                   if (flag_code != CODE_64BIT)
10063                     {
10064                       types->bitfield.imm32 = 1;
10065                       types->bitfield.disp32 = 1;
10066                     }
10067                   else
10068                     *types = gotrel[j].types64;
10069                 }
10070
10071               if (j != 0 && GOT_symbol == NULL)
10072                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
10073
10074               /* The length of the first part of our input line.  */
10075               first = cp - input_line_pointer;
10076
10077               /* The second part goes from after the reloc token until
10078                  (and including) an end_of_line char or comma.  */
10079               past_reloc = cp + 1 + len;
10080               cp = past_reloc;
10081               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
10082                 ++cp;
10083               second = cp + 1 - past_reloc;
10084
10085               /* Allocate and copy string.  The trailing NUL shouldn't
10086                  be necessary, but be safe.  */
10087               tmpbuf = XNEWVEC (char, first + second + 2);
10088               memcpy (tmpbuf, input_line_pointer, first);
10089               if (second != 0 && *past_reloc != ' ')
10090                 /* Replace the relocation token with ' ', so that
10091                    errors like foo@GOTOFF1 will be detected.  */
10092                 tmpbuf[first++] = ' ';
10093               else
10094                 /* Increment length by 1 if the relocation token is
10095                    removed.  */
10096                 len++;
10097               if (adjust)
10098                 *adjust = len;
10099               memcpy (tmpbuf + first, past_reloc, second);
10100               tmpbuf[first + second] = '\0';
10101               return tmpbuf;
10102             }
10103
10104           as_bad (_("@%s reloc is not supported with %d-bit output format"),
10105                   gotrel[j].str, 1 << (5 + object_64bit));
10106           return NULL;
10107         }
10108     }
10109
10110   /* Might be a symbol version string.  Don't as_bad here.  */
10111   return NULL;
10112 }
10113 #endif
10114
10115 #ifdef TE_PE
10116 #ifdef lex_got
10117 #undef lex_got
10118 #endif
10119 /* Parse operands of the form
10120    <symbol>@SECREL32+<nnn>
10121
10122    If we find one, set up the correct relocation in RELOC and copy the
10123    input string, minus the `@SECREL32' into a malloc'd buffer for
10124    parsing by the calling routine.  Return this buffer, and if ADJUST
10125    is non-null set it to the length of the string we removed from the
10126    input line.  Otherwise return NULL.
10127
10128    This function is copied from the ELF version above adjusted for PE targets.  */
10129
10130 static char *
10131 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
10132          int *adjust ATTRIBUTE_UNUSED,
10133          i386_operand_type *types)
10134 {
10135   static const struct
10136   {
10137     const char *str;
10138     int len;
10139     const enum bfd_reloc_code_real rel[2];
10140     const i386_operand_type types64;
10141   }
10142   gotrel[] =
10143   {
10144     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
10145                                           BFD_RELOC_32_SECREL },
10146       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10147   };
10148
10149   char *cp;
10150   unsigned j;
10151
10152   for (cp = input_line_pointer; *cp != '@'; cp++)
10153     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
10154       return NULL;
10155
10156   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
10157     {
10158       int len = gotrel[j].len;
10159
10160       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
10161         {
10162           if (gotrel[j].rel[object_64bit] != 0)
10163             {
10164               int first, second;
10165               char *tmpbuf, *past_reloc;
10166
10167               *rel = gotrel[j].rel[object_64bit];
10168               if (adjust)
10169                 *adjust = len;
10170
10171               if (types)
10172                 {
10173                   if (flag_code != CODE_64BIT)
10174                     {
10175                       types->bitfield.imm32 = 1;
10176                       types->bitfield.disp32 = 1;
10177                     }
10178                   else
10179                     *types = gotrel[j].types64;
10180                 }
10181
10182               /* The length of the first part of our input line.  */
10183               first = cp - input_line_pointer;
10184
10185               /* The second part goes from after the reloc token until
10186                  (and including) an end_of_line char or comma.  */
10187               past_reloc = cp + 1 + len;
10188               cp = past_reloc;
10189               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
10190                 ++cp;
10191               second = cp + 1 - past_reloc;
10192
10193               /* Allocate and copy string.  The trailing NUL shouldn't
10194                  be necessary, but be safe.  */
10195               tmpbuf = XNEWVEC (char, first + second + 2);
10196               memcpy (tmpbuf, input_line_pointer, first);
10197               if (second != 0 && *past_reloc != ' ')
10198                 /* Replace the relocation token with ' ', so that
10199                    errors like foo@SECLREL321 will be detected.  */
10200                 tmpbuf[first++] = ' ';
10201               memcpy (tmpbuf + first, past_reloc, second);
10202               tmpbuf[first + second] = '\0';
10203               return tmpbuf;
10204             }
10205
10206           as_bad (_("@%s reloc is not supported with %d-bit output format"),
10207                   gotrel[j].str, 1 << (5 + object_64bit));
10208           return NULL;
10209         }
10210     }
10211
10212   /* Might be a symbol version string.  Don't as_bad here.  */
10213   return NULL;
10214 }
10215
10216 #endif /* TE_PE */
10217
10218 bfd_reloc_code_real_type
10219 x86_cons (expressionS *exp, int size)
10220 {
10221   bfd_reloc_code_real_type got_reloc = NO_RELOC;
10222
10223   intel_syntax = -intel_syntax;
10224
10225   exp->X_md = 0;
10226   if (size == 4 || (object_64bit && size == 8))
10227     {
10228       /* Handle @GOTOFF and the like in an expression.  */
10229       char *save;
10230       char *gotfree_input_line;
10231       int adjust = 0;
10232
10233       save = input_line_pointer;
10234       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
10235       if (gotfree_input_line)
10236         input_line_pointer = gotfree_input_line;
10237
10238       expression (exp);
10239
10240       if (gotfree_input_line)
10241         {
10242           /* expression () has merrily parsed up to the end of line,
10243              or a comma - in the wrong buffer.  Transfer how far
10244              input_line_pointer has moved to the right buffer.  */
10245           input_line_pointer = (save
10246                                 + (input_line_pointer - gotfree_input_line)
10247                                 + adjust);
10248           free (gotfree_input_line);
10249           if (exp->X_op == O_constant
10250               || exp->X_op == O_absent
10251               || exp->X_op == O_illegal
10252               || exp->X_op == O_register
10253               || exp->X_op == O_big)
10254             {
10255               char c = *input_line_pointer;
10256               *input_line_pointer = 0;
10257               as_bad (_("missing or invalid expression `%s'"), save);
10258               *input_line_pointer = c;
10259             }
10260           else if ((got_reloc == BFD_RELOC_386_PLT32
10261                     || got_reloc == BFD_RELOC_X86_64_PLT32)
10262                    && exp->X_op != O_symbol)
10263             {
10264               char c = *input_line_pointer;
10265               *input_line_pointer = 0;
10266               as_bad (_("invalid PLT expression `%s'"), save);
10267               *input_line_pointer = c;
10268             }
10269         }
10270     }
10271   else
10272     expression (exp);
10273
10274   intel_syntax = -intel_syntax;
10275
10276   if (intel_syntax)
10277     i386_intel_simplify (exp);
10278
10279   return got_reloc;
10280 }
10281
10282 static void
10283 signed_cons (int size)
10284 {
10285   if (flag_code == CODE_64BIT)
10286     cons_sign = 1;
10287   cons (size);
10288   cons_sign = -1;
10289 }
10290
10291 #ifdef TE_PE
10292 static void
10293 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
10294 {
10295   expressionS exp;
10296
10297   do
10298     {
10299       expression (&exp);
10300       if (exp.X_op == O_symbol)
10301         exp.X_op = O_secrel;
10302
10303       emit_expr (&exp, 4);
10304     }
10305   while (*input_line_pointer++ == ',');
10306
10307   input_line_pointer--;
10308   demand_empty_rest_of_line ();
10309 }
10310 #endif
10311
10312 /* Handle Vector operations.  */
10313
10314 static char *
10315 check_VecOperations (char *op_string, char *op_end)
10316 {
10317   const reg_entry *mask;
10318   const char *saved;
10319   char *end_op;
10320
10321   while (*op_string
10322          && (op_end == NULL || op_string < op_end))
10323     {
10324       saved = op_string;
10325       if (*op_string == '{')
10326         {
10327           op_string++;
10328
10329           /* Check broadcasts.  */
10330           if (strncmp (op_string, "1to", 3) == 0)
10331             {
10332               int bcst_type;
10333
10334               if (i.broadcast)
10335                 goto duplicated_vec_op;
10336
10337               op_string += 3;
10338               if (*op_string == '8')
10339                 bcst_type = 8;
10340               else if (*op_string == '4')
10341                 bcst_type = 4;
10342               else if (*op_string == '2')
10343                 bcst_type = 2;
10344               else if (*op_string == '1'
10345                        && *(op_string+1) == '6')
10346                 {
10347                   bcst_type = 16;
10348                   op_string++;
10349                 }
10350               else
10351                 {
10352                   as_bad (_("Unsupported broadcast: `%s'"), saved);
10353                   return NULL;
10354                 }
10355               op_string++;
10356
10357               broadcast_op.type = bcst_type;
10358               broadcast_op.operand = this_operand;
10359               broadcast_op.bytes = 0;
10360               i.broadcast = &broadcast_op;
10361             }
10362           /* Check masking operation.  */
10363           else if ((mask = parse_register (op_string, &end_op)) != NULL)
10364             {
10365               if (mask == &bad_reg)
10366                 return NULL;
10367
10368               /* k0 can't be used for write mask.  */
10369               if (mask->reg_type.bitfield.class != RegMask || !mask->reg_num)
10370                 {
10371                   as_bad (_("`%s%s' can't be used for write mask"),
10372                           register_prefix, mask->reg_name);
10373                   return NULL;
10374                 }
10375
10376               if (!i.mask)
10377                 {
10378                   mask_op.mask = mask;
10379                   mask_op.zeroing = 0;
10380                   mask_op.operand = this_operand;
10381                   i.mask = &mask_op;
10382                 }
10383               else
10384                 {
10385                   if (i.mask->mask)
10386                     goto duplicated_vec_op;
10387
10388                   i.mask->mask = mask;
10389
10390                   /* Only "{z}" is allowed here.  No need to check
10391                      zeroing mask explicitly.  */
10392                   if (i.mask->operand != this_operand)
10393                     {
10394                       as_bad (_("invalid write mask `%s'"), saved);
10395                       return NULL;
10396                     }
10397                 }
10398
10399               op_string = end_op;
10400             }
10401           /* Check zeroing-flag for masking operation.  */
10402           else if (*op_string == 'z')
10403             {
10404               if (!i.mask)
10405                 {
10406                   mask_op.mask = NULL;
10407                   mask_op.zeroing = 1;
10408                   mask_op.operand = this_operand;
10409                   i.mask = &mask_op;
10410                 }
10411               else
10412                 {
10413                   if (i.mask->zeroing)
10414                     {
10415                     duplicated_vec_op:
10416                       as_bad (_("duplicated `%s'"), saved);
10417                       return NULL;
10418                     }
10419
10420                   i.mask->zeroing = 1;
10421
10422                   /* Only "{%k}" is allowed here.  No need to check mask
10423                      register explicitly.  */
10424                   if (i.mask->operand != this_operand)
10425                     {
10426                       as_bad (_("invalid zeroing-masking `%s'"),
10427                               saved);
10428                       return NULL;
10429                     }
10430                 }
10431
10432               op_string++;
10433             }
10434           else
10435             goto unknown_vec_op;
10436
10437           if (*op_string != '}')
10438             {
10439               as_bad (_("missing `}' in `%s'"), saved);
10440               return NULL;
10441             }
10442           op_string++;
10443
10444           /* Strip whitespace since the addition of pseudo prefixes
10445              changed how the scrubber treats '{'.  */
10446           if (is_space_char (*op_string))
10447             ++op_string;
10448
10449           continue;
10450         }
10451     unknown_vec_op:
10452       /* We don't know this one.  */
10453       as_bad (_("unknown vector operation: `%s'"), saved);
10454       return NULL;
10455     }
10456
10457   if (i.mask && i.mask->zeroing && !i.mask->mask)
10458     {
10459       as_bad (_("zeroing-masking only allowed with write mask"));
10460       return NULL;
10461     }
10462
10463   return op_string;
10464 }
10465
10466 static int
10467 i386_immediate (char *imm_start)
10468 {
10469   char *save_input_line_pointer;
10470   char *gotfree_input_line;
10471   segT exp_seg = 0;
10472   expressionS *exp;
10473   i386_operand_type types;
10474
10475   operand_type_set (&types, ~0);
10476
10477   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
10478     {
10479       as_bad (_("at most %d immediate operands are allowed"),
10480               MAX_IMMEDIATE_OPERANDS);
10481       return 0;
10482     }
10483
10484   exp = &im_expressions[i.imm_operands++];
10485   i.op[this_operand].imms = exp;
10486
10487   if (is_space_char (*imm_start))
10488     ++imm_start;
10489
10490   save_input_line_pointer = input_line_pointer;
10491   input_line_pointer = imm_start;
10492
10493   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
10494   if (gotfree_input_line)
10495     input_line_pointer = gotfree_input_line;
10496
10497   exp_seg = expression (exp);
10498
10499   SKIP_WHITESPACE ();
10500
10501   /* Handle vector operations.  */
10502   if (*input_line_pointer == '{')
10503     {
10504       input_line_pointer = check_VecOperations (input_line_pointer,
10505                                                 NULL);
10506       if (input_line_pointer == NULL)
10507         return 0;
10508     }
10509
10510   if (*input_line_pointer)
10511     as_bad (_("junk `%s' after expression"), input_line_pointer);
10512
10513   input_line_pointer = save_input_line_pointer;
10514   if (gotfree_input_line)
10515     {
10516       free (gotfree_input_line);
10517
10518       if (exp->X_op == O_constant || exp->X_op == O_register)
10519         exp->X_op = O_illegal;
10520     }
10521
10522   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
10523 }
10524
10525 static int
10526 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
10527                          i386_operand_type types, const char *imm_start)
10528 {
10529   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
10530     {
10531       if (imm_start)
10532         as_bad (_("missing or invalid immediate expression `%s'"),
10533                 imm_start);
10534       return 0;
10535     }
10536   else if (exp->X_op == O_constant)
10537     {
10538       /* Size it properly later.  */
10539       i.types[this_operand].bitfield.imm64 = 1;
10540       /* If not 64bit, sign extend val.  */
10541       if (flag_code != CODE_64BIT
10542           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
10543         exp->X_add_number
10544           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
10545     }
10546 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10547   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
10548            && exp_seg != absolute_section
10549            && exp_seg != text_section
10550            && exp_seg != data_section
10551            && exp_seg != bss_section
10552            && exp_seg != undefined_section
10553            && !bfd_is_com_section (exp_seg))
10554     {
10555       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
10556       return 0;
10557     }
10558 #endif
10559   else if (!intel_syntax && exp_seg == reg_section)
10560     {
10561       if (imm_start)
10562         as_bad (_("illegal immediate register operand %s"), imm_start);
10563       return 0;
10564     }
10565   else
10566     {
10567       /* This is an address.  The size of the address will be
10568          determined later, depending on destination register,
10569          suffix, or the default for the section.  */
10570       i.types[this_operand].bitfield.imm8 = 1;
10571       i.types[this_operand].bitfield.imm16 = 1;
10572       i.types[this_operand].bitfield.imm32 = 1;
10573       i.types[this_operand].bitfield.imm32s = 1;
10574       i.types[this_operand].bitfield.imm64 = 1;
10575       i.types[this_operand] = operand_type_and (i.types[this_operand],
10576                                                 types);
10577     }
10578
10579   return 1;
10580 }
10581
10582 static char *
10583 i386_scale (char *scale)
10584 {
10585   offsetT val;
10586   char *save = input_line_pointer;
10587
10588   input_line_pointer = scale;
10589   val = get_absolute_expression ();
10590
10591   switch (val)
10592     {
10593     case 1:
10594       i.log2_scale_factor = 0;
10595       break;
10596     case 2:
10597       i.log2_scale_factor = 1;
10598       break;
10599     case 4:
10600       i.log2_scale_factor = 2;
10601       break;
10602     case 8:
10603       i.log2_scale_factor = 3;
10604       break;
10605     default:
10606       {
10607         char sep = *input_line_pointer;
10608
10609         *input_line_pointer = '\0';
10610         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
10611                 scale);
10612         *input_line_pointer = sep;
10613         input_line_pointer = save;
10614         return NULL;
10615       }
10616     }
10617   if (i.log2_scale_factor != 0 && i.index_reg == 0)
10618     {
10619       as_warn (_("scale factor of %d without an index register"),
10620                1 << i.log2_scale_factor);
10621       i.log2_scale_factor = 0;
10622     }
10623   scale = input_line_pointer;
10624   input_line_pointer = save;
10625   return scale;
10626 }
10627
10628 static int
10629 i386_displacement (char *disp_start, char *disp_end)
10630 {
10631   expressionS *exp;
10632   segT exp_seg = 0;
10633   char *save_input_line_pointer;
10634   char *gotfree_input_line;
10635   int override;
10636   i386_operand_type bigdisp, types = anydisp;
10637   int ret;
10638
10639   if (i.disp_operands == MAX_MEMORY_OPERANDS)
10640     {
10641       as_bad (_("at most %d displacement operands are allowed"),
10642               MAX_MEMORY_OPERANDS);
10643       return 0;
10644     }
10645
10646   operand_type_set (&bigdisp, 0);
10647   if (i.jumpabsolute
10648       || i.types[this_operand].bitfield.baseindex
10649       || (current_templates->start->opcode_modifier.jump != JUMP
10650           && current_templates->start->opcode_modifier.jump != JUMP_DWORD))
10651     {
10652       i386_addressing_mode ();
10653       override = (i.prefix[ADDR_PREFIX] != 0);
10654       if (flag_code == CODE_64BIT)
10655         {
10656           if (!override)
10657             {
10658               bigdisp.bitfield.disp32s = 1;
10659               bigdisp.bitfield.disp64 = 1;
10660             }
10661           else
10662             bigdisp.bitfield.disp32 = 1;
10663         }
10664       else if ((flag_code == CODE_16BIT) ^ override)
10665           bigdisp.bitfield.disp16 = 1;
10666       else
10667           bigdisp.bitfield.disp32 = 1;
10668     }
10669   else
10670     {
10671       /* For PC-relative branches, the width of the displacement may be
10672          dependent upon data size, but is never dependent upon address size.
10673          Also make sure to not unintentionally match against a non-PC-relative
10674          branch template.  */
10675       static templates aux_templates;
10676       const insn_template *t = current_templates->start;
10677       bfd_boolean has_intel64 = FALSE;
10678
10679       aux_templates.start = t;
10680       while (++t < current_templates->end)
10681         {
10682           if (t->opcode_modifier.jump
10683               != current_templates->start->opcode_modifier.jump)
10684             break;
10685           if ((t->opcode_modifier.isa64 >= INTEL64))
10686             has_intel64 = TRUE;
10687         }
10688       if (t < current_templates->end)
10689         {
10690           aux_templates.end = t;
10691           current_templates = &aux_templates;
10692         }
10693
10694       override = (i.prefix[DATA_PREFIX] != 0);
10695       if (flag_code == CODE_64BIT)
10696         {
10697           if ((override || i.suffix == WORD_MNEM_SUFFIX)
10698               && (!intel64 || !has_intel64))
10699             bigdisp.bitfield.disp16 = 1;
10700           else
10701             bigdisp.bitfield.disp32s = 1;
10702         }
10703       else
10704         {
10705           if (!override)
10706             override = (i.suffix == (flag_code != CODE_16BIT
10707                                      ? WORD_MNEM_SUFFIX
10708                                      : LONG_MNEM_SUFFIX));
10709           bigdisp.bitfield.disp32 = 1;
10710           if ((flag_code == CODE_16BIT) ^ override)
10711             {
10712               bigdisp.bitfield.disp32 = 0;
10713               bigdisp.bitfield.disp16 = 1;
10714             }
10715         }
10716     }
10717   i.types[this_operand] = operand_type_or (i.types[this_operand],
10718                                            bigdisp);
10719
10720   exp = &disp_expressions[i.disp_operands];
10721   i.op[this_operand].disps = exp;
10722   i.disp_operands++;
10723   save_input_line_pointer = input_line_pointer;
10724   input_line_pointer = disp_start;
10725   END_STRING_AND_SAVE (disp_end);
10726
10727 #ifndef GCC_ASM_O_HACK
10728 #define GCC_ASM_O_HACK 0
10729 #endif
10730 #if GCC_ASM_O_HACK
10731   END_STRING_AND_SAVE (disp_end + 1);
10732   if (i.types[this_operand].bitfield.baseIndex
10733       && displacement_string_end[-1] == '+')
10734     {
10735       /* This hack is to avoid a warning when using the "o"
10736          constraint within gcc asm statements.
10737          For instance:
10738
10739          #define _set_tssldt_desc(n,addr,limit,type) \
10740          __asm__ __volatile__ ( \
10741          "movw %w2,%0\n\t" \
10742          "movw %w1,2+%0\n\t" \
10743          "rorl $16,%1\n\t" \
10744          "movb %b1,4+%0\n\t" \
10745          "movb %4,5+%0\n\t" \
10746          "movb $0,6+%0\n\t" \
10747          "movb %h1,7+%0\n\t" \
10748          "rorl $16,%1" \
10749          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
10750
10751          This works great except that the output assembler ends
10752          up looking a bit weird if it turns out that there is
10753          no offset.  You end up producing code that looks like:
10754
10755          #APP
10756          movw $235,(%eax)
10757          movw %dx,2+(%eax)
10758          rorl $16,%edx
10759          movb %dl,4+(%eax)
10760          movb $137,5+(%eax)
10761          movb $0,6+(%eax)
10762          movb %dh,7+(%eax)
10763          rorl $16,%edx
10764          #NO_APP
10765
10766          So here we provide the missing zero.  */
10767
10768       *displacement_string_end = '0';
10769     }
10770 #endif
10771   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
10772   if (gotfree_input_line)
10773     input_line_pointer = gotfree_input_line;
10774
10775   exp_seg = expression (exp);
10776
10777   SKIP_WHITESPACE ();
10778   if (*input_line_pointer)
10779     as_bad (_("junk `%s' after expression"), input_line_pointer);
10780 #if GCC_ASM_O_HACK
10781   RESTORE_END_STRING (disp_end + 1);
10782 #endif
10783   input_line_pointer = save_input_line_pointer;
10784   if (gotfree_input_line)
10785     {
10786       free (gotfree_input_line);
10787
10788       if (exp->X_op == O_constant || exp->X_op == O_register)
10789         exp->X_op = O_illegal;
10790     }
10791
10792   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
10793
10794   RESTORE_END_STRING (disp_end);
10795
10796   return ret;
10797 }
10798
10799 static int
10800 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
10801                             i386_operand_type types, const char *disp_start)
10802 {
10803   i386_operand_type bigdisp;
10804   int ret = 1;
10805
10806   /* We do this to make sure that the section symbol is in
10807      the symbol table.  We will ultimately change the relocation
10808      to be relative to the beginning of the section.  */
10809   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
10810       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
10811       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
10812     {
10813       if (exp->X_op != O_symbol)
10814         goto inv_disp;
10815
10816       if (S_IS_LOCAL (exp->X_add_symbol)
10817           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
10818           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
10819         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
10820       exp->X_op = O_subtract;
10821       exp->X_op_symbol = GOT_symbol;
10822       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
10823         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
10824       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
10825         i.reloc[this_operand] = BFD_RELOC_64;
10826       else
10827         i.reloc[this_operand] = BFD_RELOC_32;
10828     }
10829
10830   else if (exp->X_op == O_absent
10831            || exp->X_op == O_illegal
10832            || exp->X_op == O_big)
10833     {
10834     inv_disp:
10835       as_bad (_("missing or invalid displacement expression `%s'"),
10836               disp_start);
10837       ret = 0;
10838     }
10839
10840   else if (flag_code == CODE_64BIT
10841            && !i.prefix[ADDR_PREFIX]
10842            && exp->X_op == O_constant)
10843     {
10844       /* Since displacement is signed extended to 64bit, don't allow
10845          disp32 and turn off disp32s if they are out of range.  */
10846       i.types[this_operand].bitfield.disp32 = 0;
10847       if (!fits_in_signed_long (exp->X_add_number))
10848         {
10849           i.types[this_operand].bitfield.disp32s = 0;
10850           if (i.types[this_operand].bitfield.baseindex)
10851             {
10852               as_bad (_("0x%lx out range of signed 32bit displacement"),
10853                       (long) exp->X_add_number);
10854               ret = 0;
10855             }
10856         }
10857     }
10858
10859 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10860   else if (exp->X_op != O_constant
10861            && OUTPUT_FLAVOR == bfd_target_aout_flavour
10862            && exp_seg != absolute_section
10863            && exp_seg != text_section
10864            && exp_seg != data_section
10865            && exp_seg != bss_section
10866            && exp_seg != undefined_section
10867            && !bfd_is_com_section (exp_seg))
10868     {
10869       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
10870       ret = 0;
10871     }
10872 #endif
10873
10874   if (current_templates->start->opcode_modifier.jump == JUMP_BYTE
10875       /* Constants get taken care of by optimize_disp().  */
10876       && exp->X_op != O_constant)
10877     i.types[this_operand].bitfield.disp8 = 1;
10878
10879   /* Check if this is a displacement only operand.  */
10880   bigdisp = i.types[this_operand];
10881   bigdisp.bitfield.disp8 = 0;
10882   bigdisp.bitfield.disp16 = 0;
10883   bigdisp.bitfield.disp32 = 0;
10884   bigdisp.bitfield.disp32s = 0;
10885   bigdisp.bitfield.disp64 = 0;
10886   if (operand_type_all_zero (&bigdisp))
10887     i.types[this_operand] = operand_type_and (i.types[this_operand],
10888                                               types);
10889
10890   return ret;
10891 }
10892
10893 /* Return the active addressing mode, taking address override and
10894    registers forming the address into consideration.  Update the
10895    address override prefix if necessary.  */
10896
10897 static enum flag_code
10898 i386_addressing_mode (void)
10899 {
10900   enum flag_code addr_mode;
10901
10902   if (i.prefix[ADDR_PREFIX])
10903     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
10904   else if (flag_code == CODE_16BIT
10905            && current_templates->start->cpu_flags.bitfield.cpumpx
10906            /* Avoid replacing the "16-bit addressing not allowed" diagnostic
10907               from md_assemble() by "is not a valid base/index expression"
10908               when there is a base and/or index.  */
10909            && !i.types[this_operand].bitfield.baseindex)
10910     {
10911       /* MPX insn memory operands with neither base nor index must be forced
10912          to use 32-bit addressing in 16-bit mode.  */
10913       addr_mode = CODE_32BIT;
10914       i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
10915       ++i.prefixes;
10916       gas_assert (!i.types[this_operand].bitfield.disp16);
10917       gas_assert (!i.types[this_operand].bitfield.disp32);
10918     }
10919   else
10920     {
10921       addr_mode = flag_code;
10922
10923 #if INFER_ADDR_PREFIX
10924       if (i.mem_operands == 0)
10925         {
10926           /* Infer address prefix from the first memory operand.  */
10927           const reg_entry *addr_reg = i.base_reg;
10928
10929           if (addr_reg == NULL)
10930             addr_reg = i.index_reg;
10931
10932           if (addr_reg)
10933             {
10934               if (addr_reg->reg_type.bitfield.dword)
10935                 addr_mode = CODE_32BIT;
10936               else if (flag_code != CODE_64BIT
10937                        && addr_reg->reg_type.bitfield.word)
10938                 addr_mode = CODE_16BIT;
10939
10940               if (addr_mode != flag_code)
10941                 {
10942                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
10943                   i.prefixes += 1;
10944                   /* Change the size of any displacement too.  At most one
10945                      of Disp16 or Disp32 is set.
10946                      FIXME.  There doesn't seem to be any real need for
10947                      separate Disp16 and Disp32 flags.  The same goes for
10948                      Imm16 and Imm32.  Removing them would probably clean
10949                      up the code quite a lot.  */
10950                   if (flag_code != CODE_64BIT
10951                       && (i.types[this_operand].bitfield.disp16
10952                           || i.types[this_operand].bitfield.disp32))
10953                     i.types[this_operand]
10954                       = operand_type_xor (i.types[this_operand], disp16_32);
10955                 }
10956             }
10957         }
10958 #endif
10959     }
10960
10961   return addr_mode;
10962 }
10963
10964 /* Make sure the memory operand we've been dealt is valid.
10965    Return 1 on success, 0 on a failure.  */
10966
10967 static int
10968 i386_index_check (const char *operand_string)
10969 {
10970   const char *kind = "base/index";
10971   enum flag_code addr_mode = i386_addressing_mode ();
10972
10973   if (current_templates->start->opcode_modifier.isstring
10974       && !current_templates->start->cpu_flags.bitfield.cpupadlock
10975       && (current_templates->end[-1].opcode_modifier.isstring
10976           || i.mem_operands))
10977     {
10978       /* Memory operands of string insns are special in that they only allow
10979          a single register (rDI, rSI, or rBX) as their memory address.  */
10980       const reg_entry *expected_reg;
10981       static const char *di_si[][2] =
10982         {
10983           { "esi", "edi" },
10984           { "si", "di" },
10985           { "rsi", "rdi" }
10986         };
10987       static const char *bx[] = { "ebx", "bx", "rbx" };
10988
10989       kind = "string address";
10990
10991       if (current_templates->start->opcode_modifier.repprefixok)
10992         {
10993           int es_op = current_templates->end[-1].opcode_modifier.isstring
10994                       - IS_STRING_ES_OP0;
10995           int op = 0;
10996
10997           if (!current_templates->end[-1].operand_types[0].bitfield.baseindex
10998               || ((!i.mem_operands != !intel_syntax)
10999                   && current_templates->end[-1].operand_types[1]
11000                      .bitfield.baseindex))
11001             op = 1;
11002           expected_reg
11003             = (const reg_entry *) str_hash_find (reg_hash,
11004                                                  di_si[addr_mode][op == es_op]);
11005         }
11006       else
11007         expected_reg
11008           = (const reg_entry *)str_hash_find (reg_hash, bx[addr_mode]);
11009
11010       if (i.base_reg != expected_reg
11011           || i.index_reg
11012           || operand_type_check (i.types[this_operand], disp))
11013         {
11014           /* The second memory operand must have the same size as
11015              the first one.  */
11016           if (i.mem_operands
11017               && i.base_reg
11018               && !((addr_mode == CODE_64BIT
11019                     && i.base_reg->reg_type.bitfield.qword)
11020                    || (addr_mode == CODE_32BIT
11021                        ? i.base_reg->reg_type.bitfield.dword
11022                        : i.base_reg->reg_type.bitfield.word)))
11023             goto bad_address;
11024
11025           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
11026                    operand_string,
11027                    intel_syntax ? '[' : '(',
11028                    register_prefix,
11029                    expected_reg->reg_name,
11030                    intel_syntax ? ']' : ')');
11031           return 1;
11032         }
11033       else
11034         return 1;
11035
11036     bad_address:
11037       as_bad (_("`%s' is not a valid %s expression"),
11038               operand_string, kind);
11039       return 0;
11040     }
11041   else
11042     {
11043       if (addr_mode != CODE_16BIT)
11044         {
11045           /* 32-bit/64-bit checks.  */
11046           if (i.disp_encoding == disp_encoding_16bit)
11047             {
11048             bad_disp:
11049               as_bad (_("invalid `%s' prefix"),
11050                       addr_mode == CODE_16BIT ? "{disp32}" : "{disp16}");
11051               return 0;
11052             }
11053
11054           if ((i.base_reg
11055                && ((addr_mode == CODE_64BIT
11056                     ? !i.base_reg->reg_type.bitfield.qword
11057                     : !i.base_reg->reg_type.bitfield.dword)
11058                    || (i.index_reg && i.base_reg->reg_num == RegIP)
11059                    || i.base_reg->reg_num == RegIZ))
11060               || (i.index_reg
11061                   && !i.index_reg->reg_type.bitfield.xmmword
11062                   && !i.index_reg->reg_type.bitfield.ymmword
11063                   && !i.index_reg->reg_type.bitfield.zmmword
11064                   && ((addr_mode == CODE_64BIT
11065                        ? !i.index_reg->reg_type.bitfield.qword
11066                        : !i.index_reg->reg_type.bitfield.dword)
11067                       || !i.index_reg->reg_type.bitfield.baseindex)))
11068             goto bad_address;
11069
11070           /* bndmk, bndldx, bndstx and mandatory non-vector SIB have special restrictions. */
11071           if (current_templates->start->base_opcode == 0xf30f1b
11072               || (current_templates->start->base_opcode & ~1) == 0x0f1a
11073               || current_templates->start->opcode_modifier.sib == SIBMEM)
11074             {
11075               /* They cannot use RIP-relative addressing. */
11076               if (i.base_reg && i.base_reg->reg_num == RegIP)
11077                 {
11078                   as_bad (_("`%s' cannot be used here"), operand_string);
11079                   return 0;
11080                 }
11081
11082               /* bndldx and bndstx ignore their scale factor. */
11083               if ((current_templates->start->base_opcode & ~1) == 0x0f1a
11084                   && i.log2_scale_factor)
11085                 as_warn (_("register scaling is being ignored here"));
11086             }
11087         }
11088       else
11089         {
11090           /* 16-bit checks.  */
11091           if (i.disp_encoding == disp_encoding_32bit)
11092             goto bad_disp;
11093
11094           if ((i.base_reg
11095                && (!i.base_reg->reg_type.bitfield.word
11096                    || !i.base_reg->reg_type.bitfield.baseindex))
11097               || (i.index_reg
11098                   && (!i.index_reg->reg_type.bitfield.word
11099                       || !i.index_reg->reg_type.bitfield.baseindex
11100                       || !(i.base_reg
11101                            && i.base_reg->reg_num < 6
11102                            && i.index_reg->reg_num >= 6
11103                            && i.log2_scale_factor == 0))))
11104             goto bad_address;
11105         }
11106     }
11107   return 1;
11108 }
11109
11110 /* Handle vector immediates.  */
11111
11112 static int
11113 RC_SAE_immediate (const char *imm_start)
11114 {
11115   unsigned int match_found, j;
11116   const char *pstr = imm_start;
11117   expressionS *exp;
11118
11119   if (*pstr != '{')
11120     return 0;
11121
11122   pstr++;
11123   match_found = 0;
11124   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
11125     {
11126       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
11127         {
11128           if (!i.rounding)
11129             {
11130               rc_op.type = RC_NamesTable[j].type;
11131               rc_op.operand = this_operand;
11132               i.rounding = &rc_op;
11133             }
11134           else
11135             {
11136               as_bad (_("duplicated `%s'"), imm_start);
11137               return 0;
11138             }
11139           pstr += RC_NamesTable[j].len;
11140           match_found = 1;
11141           break;
11142         }
11143     }
11144   if (!match_found)
11145     return 0;
11146
11147   if (*pstr++ != '}')
11148     {
11149       as_bad (_("Missing '}': '%s'"), imm_start);
11150       return 0;
11151     }
11152   /* RC/SAE immediate string should contain nothing more.  */;
11153   if (*pstr != 0)
11154     {
11155       as_bad (_("Junk after '}': '%s'"), imm_start);
11156       return 0;
11157     }
11158
11159   exp = &im_expressions[i.imm_operands++];
11160   i.op[this_operand].imms = exp;
11161
11162   exp->X_op = O_constant;
11163   exp->X_add_number = 0;
11164   exp->X_add_symbol = (symbolS *) 0;
11165   exp->X_op_symbol = (symbolS *) 0;
11166
11167   i.types[this_operand].bitfield.imm8 = 1;
11168   return 1;
11169 }
11170
11171 /* Only string instructions can have a second memory operand, so
11172    reduce current_templates to just those if it contains any.  */
11173 static int
11174 maybe_adjust_templates (void)
11175 {
11176   const insn_template *t;
11177
11178   gas_assert (i.mem_operands == 1);
11179
11180   for (t = current_templates->start; t < current_templates->end; ++t)
11181     if (t->opcode_modifier.isstring)
11182       break;
11183
11184   if (t < current_templates->end)
11185     {
11186       static templates aux_templates;
11187       bfd_boolean recheck;
11188
11189       aux_templates.start = t;
11190       for (; t < current_templates->end; ++t)
11191         if (!t->opcode_modifier.isstring)
11192           break;
11193       aux_templates.end = t;
11194
11195       /* Determine whether to re-check the first memory operand.  */
11196       recheck = (aux_templates.start != current_templates->start
11197                  || t != current_templates->end);
11198
11199       current_templates = &aux_templates;
11200
11201       if (recheck)
11202         {
11203           i.mem_operands = 0;
11204           if (i.memop1_string != NULL
11205               && i386_index_check (i.memop1_string) == 0)
11206             return 0;
11207           i.mem_operands = 1;
11208         }
11209     }
11210
11211   return 1;
11212 }
11213
11214 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
11215    on error.  */
11216
11217 static int
11218 i386_att_operand (char *operand_string)
11219 {
11220   const reg_entry *r;
11221   char *end_op;
11222   char *op_string = operand_string;
11223
11224   if (is_space_char (*op_string))
11225     ++op_string;
11226
11227   /* We check for an absolute prefix (differentiating,
11228      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
11229   if (*op_string == ABSOLUTE_PREFIX)
11230     {
11231       ++op_string;
11232       if (is_space_char (*op_string))
11233         ++op_string;
11234       i.jumpabsolute = TRUE;
11235     }
11236
11237   /* Check if operand is a register.  */
11238   if ((r = parse_register (op_string, &end_op)) != NULL)
11239     {
11240       i386_operand_type temp;
11241
11242       if (r == &bad_reg)
11243         return 0;
11244
11245       /* Check for a segment override by searching for ':' after a
11246          segment register.  */
11247       op_string = end_op;
11248       if (is_space_char (*op_string))
11249         ++op_string;
11250       if (*op_string == ':' && r->reg_type.bitfield.class == SReg)
11251         {
11252           switch (r->reg_num)
11253             {
11254             case 0:
11255               i.seg[i.mem_operands] = &es;
11256               break;
11257             case 1:
11258               i.seg[i.mem_operands] = &cs;
11259               break;
11260             case 2:
11261               i.seg[i.mem_operands] = &ss;
11262               break;
11263             case 3:
11264               i.seg[i.mem_operands] = &ds;
11265               break;
11266             case 4:
11267               i.seg[i.mem_operands] = &fs;
11268               break;
11269             case 5:
11270               i.seg[i.mem_operands] = &gs;
11271               break;
11272             }
11273
11274           /* Skip the ':' and whitespace.  */
11275           ++op_string;
11276           if (is_space_char (*op_string))
11277             ++op_string;
11278
11279           if (!is_digit_char (*op_string)
11280               && !is_identifier_char (*op_string)
11281               && *op_string != '('
11282               && *op_string != ABSOLUTE_PREFIX)
11283             {
11284               as_bad (_("bad memory operand `%s'"), op_string);
11285               return 0;
11286             }
11287           /* Handle case of %es:*foo.  */
11288           if (*op_string == ABSOLUTE_PREFIX)
11289             {
11290               ++op_string;
11291               if (is_space_char (*op_string))
11292                 ++op_string;
11293               i.jumpabsolute = TRUE;
11294             }
11295           goto do_memory_reference;
11296         }
11297
11298       /* Handle vector operations.  */
11299       if (*op_string == '{')
11300         {
11301           op_string = check_VecOperations (op_string, NULL);
11302           if (op_string == NULL)
11303             return 0;
11304         }
11305
11306       if (*op_string)
11307         {
11308           as_bad (_("junk `%s' after register"), op_string);
11309           return 0;
11310         }
11311       temp = r->reg_type;
11312       temp.bitfield.baseindex = 0;
11313       i.types[this_operand] = operand_type_or (i.types[this_operand],
11314                                                temp);
11315       i.types[this_operand].bitfield.unspecified = 0;
11316       i.op[this_operand].regs = r;
11317       i.reg_operands++;
11318     }
11319   else if (*op_string == REGISTER_PREFIX)
11320     {
11321       as_bad (_("bad register name `%s'"), op_string);
11322       return 0;
11323     }
11324   else if (*op_string == IMMEDIATE_PREFIX)
11325     {
11326       ++op_string;
11327       if (i.jumpabsolute)
11328         {
11329           as_bad (_("immediate operand illegal with absolute jump"));
11330           return 0;
11331         }
11332       if (!i386_immediate (op_string))
11333         return 0;
11334     }
11335   else if (RC_SAE_immediate (operand_string))
11336     {
11337       /* If it is a RC or SAE immediate, do nothing.  */
11338       ;
11339     }
11340   else if (is_digit_char (*op_string)
11341            || is_identifier_char (*op_string)
11342            || *op_string == '"'
11343            || *op_string == '(')
11344     {
11345       /* This is a memory reference of some sort.  */
11346       char *base_string;
11347
11348       /* Start and end of displacement string expression (if found).  */
11349       char *displacement_string_start;
11350       char *displacement_string_end;
11351       char *vop_start;
11352
11353     do_memory_reference:
11354       if (i.mem_operands == 1 && !maybe_adjust_templates ())
11355         return 0;
11356       if ((i.mem_operands == 1
11357            && !current_templates->start->opcode_modifier.isstring)
11358           || i.mem_operands == 2)
11359         {
11360           as_bad (_("too many memory references for `%s'"),
11361                   current_templates->start->name);
11362           return 0;
11363         }
11364
11365       /* Check for base index form.  We detect the base index form by
11366          looking for an ')' at the end of the operand, searching
11367          for the '(' matching it, and finding a REGISTER_PREFIX or ','
11368          after the '('.  */
11369       base_string = op_string + strlen (op_string);
11370
11371       /* Handle vector operations.  */
11372       vop_start = strchr (op_string, '{');
11373       if (vop_start && vop_start < base_string)
11374         {
11375           if (check_VecOperations (vop_start, base_string) == NULL)
11376             return 0;
11377           base_string = vop_start;
11378         }
11379
11380       --base_string;
11381       if (is_space_char (*base_string))
11382         --base_string;
11383
11384       /* If we only have a displacement, set-up for it to be parsed later.  */
11385       displacement_string_start = op_string;
11386       displacement_string_end = base_string + 1;
11387
11388       if (*base_string == ')')
11389         {
11390           char *temp_string;
11391           unsigned int parens_balanced = 1;
11392           /* We've already checked that the number of left & right ()'s are
11393              equal, so this loop will not be infinite.  */
11394           do
11395             {
11396               base_string--;
11397               if (*base_string == ')')
11398                 parens_balanced++;
11399               if (*base_string == '(')
11400                 parens_balanced--;
11401             }
11402           while (parens_balanced);
11403
11404           temp_string = base_string;
11405
11406           /* Skip past '(' and whitespace.  */
11407           ++base_string;
11408           if (is_space_char (*base_string))
11409             ++base_string;
11410
11411           if (*base_string == ','
11412               || ((i.base_reg = parse_register (base_string, &end_op))
11413                   != NULL))
11414             {
11415               displacement_string_end = temp_string;
11416
11417               i.types[this_operand].bitfield.baseindex = 1;
11418
11419               if (i.base_reg)
11420                 {
11421                   if (i.base_reg == &bad_reg)
11422                     return 0;
11423                   base_string = end_op;
11424                   if (is_space_char (*base_string))
11425                     ++base_string;
11426                 }
11427
11428               /* There may be an index reg or scale factor here.  */
11429               if (*base_string == ',')
11430                 {
11431                   ++base_string;
11432                   if (is_space_char (*base_string))
11433                     ++base_string;
11434
11435                   if ((i.index_reg = parse_register (base_string, &end_op))
11436                       != NULL)
11437                     {
11438                       if (i.index_reg == &bad_reg)
11439                         return 0;
11440                       base_string = end_op;
11441                       if (is_space_char (*base_string))
11442                         ++base_string;
11443                       if (*base_string == ',')
11444                         {
11445                           ++base_string;
11446                           if (is_space_char (*base_string))
11447                             ++base_string;
11448                         }
11449                       else if (*base_string != ')')
11450                         {
11451                           as_bad (_("expecting `,' or `)' "
11452                                     "after index register in `%s'"),
11453                                   operand_string);
11454                           return 0;
11455                         }
11456                     }
11457                   else if (*base_string == REGISTER_PREFIX)
11458                     {
11459                       end_op = strchr (base_string, ',');
11460                       if (end_op)
11461                         *end_op = '\0';
11462                       as_bad (_("bad register name `%s'"), base_string);
11463                       return 0;
11464                     }
11465
11466                   /* Check for scale factor.  */
11467                   if (*base_string != ')')
11468                     {
11469                       char *end_scale = i386_scale (base_string);
11470
11471                       if (!end_scale)
11472                         return 0;
11473
11474                       base_string = end_scale;
11475                       if (is_space_char (*base_string))
11476                         ++base_string;
11477                       if (*base_string != ')')
11478                         {
11479                           as_bad (_("expecting `)' "
11480                                     "after scale factor in `%s'"),
11481                                   operand_string);
11482                           return 0;
11483                         }
11484                     }
11485                   else if (!i.index_reg)
11486                     {
11487                       as_bad (_("expecting index register or scale factor "
11488                                 "after `,'; got '%c'"),
11489                               *base_string);
11490                       return 0;
11491                     }
11492                 }
11493               else if (*base_string != ')')
11494                 {
11495                   as_bad (_("expecting `,' or `)' "
11496                             "after base register in `%s'"),
11497                           operand_string);
11498                   return 0;
11499                 }
11500             }
11501           else if (*base_string == REGISTER_PREFIX)
11502             {
11503               end_op = strchr (base_string, ',');
11504               if (end_op)
11505                 *end_op = '\0';
11506               as_bad (_("bad register name `%s'"), base_string);
11507               return 0;
11508             }
11509         }
11510
11511       /* If there's an expression beginning the operand, parse it,
11512          assuming displacement_string_start and
11513          displacement_string_end are meaningful.  */
11514       if (displacement_string_start != displacement_string_end)
11515         {
11516           if (!i386_displacement (displacement_string_start,
11517                                   displacement_string_end))
11518             return 0;
11519         }
11520
11521       /* Special case for (%dx) while doing input/output op.  */
11522       if (i.base_reg
11523           && i.base_reg->reg_type.bitfield.instance == RegD
11524           && i.base_reg->reg_type.bitfield.word
11525           && i.index_reg == 0
11526           && i.log2_scale_factor == 0
11527           && i.seg[i.mem_operands] == 0
11528           && !operand_type_check (i.types[this_operand], disp))
11529         {
11530           i.types[this_operand] = i.base_reg->reg_type;
11531           return 1;
11532         }
11533
11534       if (i386_index_check (operand_string) == 0)
11535         return 0;
11536       i.flags[this_operand] |= Operand_Mem;
11537       if (i.mem_operands == 0)
11538         i.memop1_string = xstrdup (operand_string);
11539       i.mem_operands++;
11540     }
11541   else
11542     {
11543       /* It's not a memory operand; argh!  */
11544       as_bad (_("invalid char %s beginning operand %d `%s'"),
11545               output_invalid (*op_string),
11546               this_operand + 1,
11547               op_string);
11548       return 0;
11549     }
11550   return 1;                     /* Normal return.  */
11551 }
11552 \f
11553 /* Calculate the maximum variable size (i.e., excluding fr_fix)
11554    that an rs_machine_dependent frag may reach.  */
11555
11556 unsigned int
11557 i386_frag_max_var (fragS *frag)
11558 {
11559   /* The only relaxable frags are for jumps.
11560      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
11561   gas_assert (frag->fr_type == rs_machine_dependent);
11562   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
11563 }
11564
11565 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11566 static int
11567 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
11568 {
11569   /* STT_GNU_IFUNC symbol must go through PLT.  */
11570   if ((symbol_get_bfdsym (fr_symbol)->flags
11571        & BSF_GNU_INDIRECT_FUNCTION) != 0)
11572     return 0;
11573
11574   if (!S_IS_EXTERNAL (fr_symbol))
11575     /* Symbol may be weak or local.  */
11576     return !S_IS_WEAK (fr_symbol);
11577
11578   /* Global symbols with non-default visibility can't be preempted. */
11579   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
11580     return 1;
11581
11582   if (fr_var != NO_RELOC)
11583     switch ((enum bfd_reloc_code_real) fr_var)
11584       {
11585       case BFD_RELOC_386_PLT32:
11586       case BFD_RELOC_X86_64_PLT32:
11587         /* Symbol with PLT relocation may be preempted. */
11588         return 0;
11589       default:
11590         abort ();
11591       }
11592
11593   /* Global symbols with default visibility in a shared library may be
11594      preempted by another definition.  */
11595   return !shared;
11596 }
11597 #endif
11598
11599 /* Table 3-2. Macro-Fusible Instructions in Haswell Microarchitecture
11600    Note also work for Skylake and Cascadelake.
11601 ---------------------------------------------------------------------
11602 |   JCC   | ADD/SUB/CMP | INC/DEC | TEST/AND |
11603 | ------  | ----------- | ------- | -------- |
11604 |   Jo    |      N      |    N    |     Y    |
11605 |   Jno   |      N      |    N    |     Y    |
11606 |  Jc/Jb  |      Y      |    N    |     Y    |
11607 | Jae/Jnb |      Y      |    N    |     Y    |
11608 |  Je/Jz  |      Y      |    Y    |     Y    |
11609 | Jne/Jnz |      Y      |    Y    |     Y    |
11610 | Jna/Jbe |      Y      |    N    |     Y    |
11611 | Ja/Jnbe |      Y      |    N    |     Y    |
11612 |   Js    |      N      |    N    |     Y    |
11613 |   Jns   |      N      |    N    |     Y    |
11614 |  Jp/Jpe |      N      |    N    |     Y    |
11615 | Jnp/Jpo |      N      |    N    |     Y    |
11616 | Jl/Jnge |      Y      |    Y    |     Y    |
11617 | Jge/Jnl |      Y      |    Y    |     Y    |
11618 | Jle/Jng |      Y      |    Y    |     Y    |
11619 | Jg/Jnle |      Y      |    Y    |     Y    |
11620 ---------------------------------------------------------------------  */
11621 static int
11622 i386_macro_fusible_p (enum mf_cmp_kind mf_cmp, enum mf_jcc_kind mf_jcc)
11623 {
11624   if (mf_cmp == mf_cmp_alu_cmp)
11625     return ((mf_jcc >= mf_jcc_jc && mf_jcc <= mf_jcc_jna)
11626             || mf_jcc == mf_jcc_jl || mf_jcc == mf_jcc_jle);
11627   if (mf_cmp == mf_cmp_incdec)
11628     return (mf_jcc == mf_jcc_je || mf_jcc == mf_jcc_jl
11629             || mf_jcc == mf_jcc_jle);
11630   if (mf_cmp == mf_cmp_test_and)
11631     return 1;
11632   return 0;
11633 }
11634
11635 /* Return the next non-empty frag.  */
11636
11637 static fragS *
11638 i386_next_non_empty_frag (fragS *fragP)
11639 {
11640   /* There may be a frag with a ".fill 0" when there is no room in
11641      the current frag for frag_grow in output_insn.  */
11642   for (fragP = fragP->fr_next;
11643        (fragP != NULL
11644         && fragP->fr_type == rs_fill
11645         && fragP->fr_fix == 0);
11646        fragP = fragP->fr_next)
11647     ;
11648   return fragP;
11649 }
11650
11651 /* Return the next jcc frag after BRANCH_PADDING.  */
11652
11653 static fragS *
11654 i386_next_fusible_jcc_frag (fragS *maybe_cmp_fragP, fragS *pad_fragP)
11655 {
11656   fragS *branch_fragP;
11657   if (!pad_fragP)
11658     return NULL;
11659
11660   if (pad_fragP->fr_type == rs_machine_dependent
11661       && (TYPE_FROM_RELAX_STATE (pad_fragP->fr_subtype)
11662           == BRANCH_PADDING))
11663     {
11664       branch_fragP = i386_next_non_empty_frag (pad_fragP);
11665       if (branch_fragP->fr_type != rs_machine_dependent)
11666         return NULL;
11667       if (TYPE_FROM_RELAX_STATE (branch_fragP->fr_subtype) == COND_JUMP
11668           && i386_macro_fusible_p (maybe_cmp_fragP->tc_frag_data.mf_type,
11669                                    pad_fragP->tc_frag_data.mf_type))
11670         return branch_fragP;
11671     }
11672
11673   return NULL;
11674 }
11675
11676 /* Classify BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING frags.  */
11677
11678 static void
11679 i386_classify_machine_dependent_frag (fragS *fragP)
11680 {
11681   fragS *cmp_fragP;
11682   fragS *pad_fragP;
11683   fragS *branch_fragP;
11684   fragS *next_fragP;
11685   unsigned int max_prefix_length;
11686
11687   if (fragP->tc_frag_data.classified)
11688     return;
11689
11690   /* First scan for BRANCH_PADDING and FUSED_JCC_PADDING.  Convert
11691      FUSED_JCC_PADDING and merge BRANCH_PADDING.  */
11692   for (next_fragP = fragP;
11693        next_fragP != NULL;
11694        next_fragP = next_fragP->fr_next)
11695     {
11696       next_fragP->tc_frag_data.classified = 1;
11697       if (next_fragP->fr_type == rs_machine_dependent)
11698         switch (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype))
11699           {
11700           case BRANCH_PADDING:
11701             /* The BRANCH_PADDING frag must be followed by a branch
11702                frag.  */
11703             branch_fragP = i386_next_non_empty_frag (next_fragP);
11704             next_fragP->tc_frag_data.u.branch_fragP = branch_fragP;
11705             break;
11706           case FUSED_JCC_PADDING:
11707             /* Check if this is a fused jcc:
11708                FUSED_JCC_PADDING
11709                CMP like instruction
11710                BRANCH_PADDING
11711                COND_JUMP
11712                */
11713             cmp_fragP = i386_next_non_empty_frag (next_fragP);
11714             pad_fragP = i386_next_non_empty_frag (cmp_fragP);
11715             branch_fragP = i386_next_fusible_jcc_frag (next_fragP, pad_fragP);
11716             if (branch_fragP)
11717               {
11718                 /* The BRANCH_PADDING frag is merged with the
11719                    FUSED_JCC_PADDING frag.  */
11720                 next_fragP->tc_frag_data.u.branch_fragP = branch_fragP;
11721                 /* CMP like instruction size.  */
11722                 next_fragP->tc_frag_data.cmp_size = cmp_fragP->fr_fix;
11723                 frag_wane (pad_fragP);
11724                 /* Skip to branch_fragP.  */
11725                 next_fragP = branch_fragP;
11726               }
11727             else if (next_fragP->tc_frag_data.max_prefix_length)
11728               {
11729                 /* Turn FUSED_JCC_PADDING into BRANCH_PREFIX if it isn't
11730                    a fused jcc.  */
11731                 next_fragP->fr_subtype
11732                   = ENCODE_RELAX_STATE (BRANCH_PREFIX, 0);
11733                 next_fragP->tc_frag_data.max_bytes
11734                   = next_fragP->tc_frag_data.max_prefix_length;
11735                 /* This will be updated in the BRANCH_PREFIX scan.  */
11736                 next_fragP->tc_frag_data.max_prefix_length = 0;
11737               }
11738             else
11739               frag_wane (next_fragP);
11740             break;
11741           }
11742     }
11743
11744   /* Stop if there is no BRANCH_PREFIX.  */
11745   if (!align_branch_prefix_size)
11746     return;
11747
11748   /* Scan for BRANCH_PREFIX.  */
11749   for (; fragP != NULL; fragP = fragP->fr_next)
11750     {
11751       if (fragP->fr_type != rs_machine_dependent
11752           || (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
11753               != BRANCH_PREFIX))
11754         continue;
11755
11756       /* Count all BRANCH_PREFIX frags before BRANCH_PADDING and
11757          COND_JUMP_PREFIX.  */
11758       max_prefix_length = 0;
11759       for (next_fragP = fragP;
11760            next_fragP != NULL;
11761            next_fragP = next_fragP->fr_next)
11762         {
11763           if (next_fragP->fr_type == rs_fill)
11764             /* Skip rs_fill frags.  */
11765             continue;
11766           else if (next_fragP->fr_type != rs_machine_dependent)
11767             /* Stop for all other frags.  */
11768             break;
11769
11770           /* rs_machine_dependent frags.  */
11771           if (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11772               == BRANCH_PREFIX)
11773             {
11774               /* Count BRANCH_PREFIX frags.  */
11775               if (max_prefix_length >= MAX_FUSED_JCC_PADDING_SIZE)
11776                 {
11777                   max_prefix_length = MAX_FUSED_JCC_PADDING_SIZE;
11778                   frag_wane (next_fragP);
11779                 }
11780               else
11781                 max_prefix_length
11782                   += next_fragP->tc_frag_data.max_bytes;
11783             }
11784           else if ((TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11785                     == BRANCH_PADDING)
11786                    || (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11787                        == FUSED_JCC_PADDING))
11788             {
11789               /* Stop at BRANCH_PADDING and FUSED_JCC_PADDING.  */
11790               fragP->tc_frag_data.u.padding_fragP = next_fragP;
11791               break;
11792             }
11793           else
11794             /* Stop for other rs_machine_dependent frags.  */
11795             break;
11796         }
11797
11798       fragP->tc_frag_data.max_prefix_length = max_prefix_length;
11799
11800       /* Skip to the next frag.  */
11801       fragP = next_fragP;
11802     }
11803 }
11804
11805 /* Compute padding size for
11806
11807         FUSED_JCC_PADDING
11808         CMP like instruction
11809         BRANCH_PADDING
11810         COND_JUMP/UNCOND_JUMP
11811
11812    or
11813
11814         BRANCH_PADDING
11815         COND_JUMP/UNCOND_JUMP
11816  */
11817
11818 static int
11819 i386_branch_padding_size (fragS *fragP, offsetT address)
11820 {
11821   unsigned int offset, size, padding_size;
11822   fragS *branch_fragP = fragP->tc_frag_data.u.branch_fragP;
11823
11824   /* The start address of the BRANCH_PADDING or FUSED_JCC_PADDING frag.  */
11825   if (!address)
11826     address = fragP->fr_address;
11827   address += fragP->fr_fix;
11828
11829   /* CMP like instrunction size.  */
11830   size = fragP->tc_frag_data.cmp_size;
11831
11832   /* The base size of the branch frag.  */
11833   size += branch_fragP->fr_fix;
11834
11835   /* Add opcode and displacement bytes for the rs_machine_dependent
11836      branch frag.  */
11837   if (branch_fragP->fr_type == rs_machine_dependent)
11838     size += md_relax_table[branch_fragP->fr_subtype].rlx_length;
11839
11840   /* Check if branch is within boundary and doesn't end at the last
11841      byte.  */
11842   offset = address & ((1U << align_branch_power) - 1);
11843   if ((offset + size) >= (1U << align_branch_power))
11844     /* Padding needed to avoid crossing boundary.  */
11845     padding_size = (1U << align_branch_power) - offset;
11846   else
11847     /* No padding needed.  */
11848     padding_size = 0;
11849
11850   /* The return value may be saved in tc_frag_data.length which is
11851      unsigned byte.  */
11852   if (!fits_in_unsigned_byte (padding_size))
11853     abort ();
11854
11855   return padding_size;
11856 }
11857
11858 /* i386_generic_table_relax_frag()
11859
11860    Handle BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING frags to
11861    grow/shrink padding to align branch frags.  Hand others to
11862    relax_frag().  */
11863
11864 long
11865 i386_generic_table_relax_frag (segT segment, fragS *fragP, long stretch)
11866 {
11867   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
11868       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
11869     {
11870       long padding_size = i386_branch_padding_size (fragP, 0);
11871       long grow = padding_size - fragP->tc_frag_data.length;
11872
11873       /* When the BRANCH_PREFIX frag is used, the computed address
11874          must match the actual address and there should be no padding.  */
11875       if (fragP->tc_frag_data.padding_address
11876           && (fragP->tc_frag_data.padding_address != fragP->fr_address
11877               || padding_size))
11878         abort ();
11879
11880       /* Update the padding size.  */
11881       if (grow)
11882         fragP->tc_frag_data.length = padding_size;
11883
11884       return grow;
11885     }
11886   else if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
11887     {
11888       fragS *padding_fragP, *next_fragP;
11889       long padding_size, left_size, last_size;
11890
11891       padding_fragP = fragP->tc_frag_data.u.padding_fragP;
11892       if (!padding_fragP)
11893         /* Use the padding set by the leading BRANCH_PREFIX frag.  */
11894         return (fragP->tc_frag_data.length
11895                 - fragP->tc_frag_data.last_length);
11896
11897       /* Compute the relative address of the padding frag in the very
11898         first time where the BRANCH_PREFIX frag sizes are zero.  */
11899       if (!fragP->tc_frag_data.padding_address)
11900         fragP->tc_frag_data.padding_address
11901           = padding_fragP->fr_address - (fragP->fr_address - stretch);
11902
11903       /* First update the last length from the previous interation.  */
11904       left_size = fragP->tc_frag_data.prefix_length;
11905       for (next_fragP = fragP;
11906            next_fragP != padding_fragP;
11907            next_fragP = next_fragP->fr_next)
11908         if (next_fragP->fr_type == rs_machine_dependent
11909             && (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11910                 == BRANCH_PREFIX))
11911           {
11912             if (left_size)
11913               {
11914                 int max = next_fragP->tc_frag_data.max_bytes;
11915                 if (max)
11916                   {
11917                     int size;
11918                     if (max > left_size)
11919                       size = left_size;
11920                     else
11921                       size = max;
11922                     left_size -= size;
11923                     next_fragP->tc_frag_data.last_length = size;
11924                   }
11925               }
11926             else
11927               next_fragP->tc_frag_data.last_length = 0;
11928           }
11929
11930       /* Check the padding size for the padding frag.  */
11931       padding_size = i386_branch_padding_size
11932         (padding_fragP, (fragP->fr_address
11933                          + fragP->tc_frag_data.padding_address));
11934
11935       last_size = fragP->tc_frag_data.prefix_length;
11936       /* Check if there is change from the last interation.  */
11937       if (padding_size == last_size)
11938         {
11939           /* Update the expected address of the padding frag.  */
11940           padding_fragP->tc_frag_data.padding_address
11941             = (fragP->fr_address + padding_size
11942                + fragP->tc_frag_data.padding_address);
11943           return 0;
11944         }
11945
11946       if (padding_size > fragP->tc_frag_data.max_prefix_length)
11947         {
11948           /* No padding if there is no sufficient room.  Clear the
11949              expected address of the padding frag.  */
11950           padding_fragP->tc_frag_data.padding_address = 0;
11951           padding_size = 0;
11952         }
11953       else
11954         /* Store the expected address of the padding frag.  */
11955         padding_fragP->tc_frag_data.padding_address
11956           = (fragP->fr_address + padding_size
11957              + fragP->tc_frag_data.padding_address);
11958
11959       fragP->tc_frag_data.prefix_length = padding_size;
11960
11961       /* Update the length for the current interation.  */
11962       left_size = padding_size;
11963       for (next_fragP = fragP;
11964            next_fragP != padding_fragP;
11965            next_fragP = next_fragP->fr_next)
11966         if (next_fragP->fr_type == rs_machine_dependent
11967             && (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11968                 == BRANCH_PREFIX))
11969           {
11970             if (left_size)
11971               {
11972                 int max = next_fragP->tc_frag_data.max_bytes;
11973                 if (max)
11974                   {
11975                     int size;
11976                     if (max > left_size)
11977                       size = left_size;
11978                     else
11979                       size = max;
11980                     left_size -= size;
11981                     next_fragP->tc_frag_data.length = size;
11982                   }
11983               }
11984             else
11985               next_fragP->tc_frag_data.length = 0;
11986           }
11987
11988       return (fragP->tc_frag_data.length
11989               - fragP->tc_frag_data.last_length);
11990     }
11991   return relax_frag (segment, fragP, stretch);
11992 }
11993
11994 /* md_estimate_size_before_relax()
11995
11996    Called just before relax() for rs_machine_dependent frags.  The x86
11997    assembler uses these frags to handle variable size jump
11998    instructions.
11999
12000    Any symbol that is now undefined will not become defined.
12001    Return the correct fr_subtype in the frag.
12002    Return the initial "guess for variable size of frag" to caller.
12003    The guess is actually the growth beyond the fixed part.  Whatever
12004    we do to grow the fixed or variable part contributes to our
12005    returned value.  */
12006
12007 int
12008 md_estimate_size_before_relax (fragS *fragP, segT segment)
12009 {
12010   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
12011       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX
12012       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
12013     {
12014       i386_classify_machine_dependent_frag (fragP);
12015       return fragP->tc_frag_data.length;
12016     }
12017
12018   /* We've already got fragP->fr_subtype right;  all we have to do is
12019      check for un-relaxable symbols.  On an ELF system, we can't relax
12020      an externally visible symbol, because it may be overridden by a
12021      shared library.  */
12022   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
12023 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12024       || (IS_ELF
12025           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
12026                                                 fragP->fr_var))
12027 #endif
12028 #if defined (OBJ_COFF) && defined (TE_PE)
12029       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
12030           && S_IS_WEAK (fragP->fr_symbol))
12031 #endif
12032       )
12033     {
12034       /* Symbol is undefined in this segment, or we need to keep a
12035          reloc so that weak symbols can be overridden.  */
12036       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
12037       enum bfd_reloc_code_real reloc_type;
12038       unsigned char *opcode;
12039       int old_fr_fix;
12040
12041       if (fragP->fr_var != NO_RELOC)
12042         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
12043       else if (size == 2)
12044         reloc_type = BFD_RELOC_16_PCREL;
12045 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12046       else if (need_plt32_p (fragP->fr_symbol))
12047         reloc_type = BFD_RELOC_X86_64_PLT32;
12048 #endif
12049       else
12050         reloc_type = BFD_RELOC_32_PCREL;
12051
12052       old_fr_fix = fragP->fr_fix;
12053       opcode = (unsigned char *) fragP->fr_opcode;
12054
12055       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
12056         {
12057         case UNCOND_JUMP:
12058           /* Make jmp (0xeb) a (d)word displacement jump.  */
12059           opcode[0] = 0xe9;
12060           fragP->fr_fix += size;
12061           fix_new (fragP, old_fr_fix, size,
12062                    fragP->fr_symbol,
12063                    fragP->fr_offset, 1,
12064                    reloc_type);
12065           break;
12066
12067         case COND_JUMP86:
12068           if (size == 2
12069               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
12070             {
12071               /* Negate the condition, and branch past an
12072                  unconditional jump.  */
12073               opcode[0] ^= 1;
12074               opcode[1] = 3;
12075               /* Insert an unconditional jump.  */
12076               opcode[2] = 0xe9;
12077               /* We added two extra opcode bytes, and have a two byte
12078                  offset.  */
12079               fragP->fr_fix += 2 + 2;
12080               fix_new (fragP, old_fr_fix + 2, 2,
12081                        fragP->fr_symbol,
12082                        fragP->fr_offset, 1,
12083                        reloc_type);
12084               break;
12085             }
12086           /* Fall through.  */
12087
12088         case COND_JUMP:
12089           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
12090             {
12091               fixS *fixP;
12092
12093               fragP->fr_fix += 1;
12094               fixP = fix_new (fragP, old_fr_fix, 1,
12095                               fragP->fr_symbol,
12096                               fragP->fr_offset, 1,
12097                               BFD_RELOC_8_PCREL);
12098               fixP->fx_signed = 1;
12099               break;
12100             }
12101
12102           /* This changes the byte-displacement jump 0x7N
12103              to the (d)word-displacement jump 0x0f,0x8N.  */
12104           opcode[1] = opcode[0] + 0x10;
12105           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12106           /* We've added an opcode byte.  */
12107           fragP->fr_fix += 1 + size;
12108           fix_new (fragP, old_fr_fix + 1, size,
12109                    fragP->fr_symbol,
12110                    fragP->fr_offset, 1,
12111                    reloc_type);
12112           break;
12113
12114         default:
12115           BAD_CASE (fragP->fr_subtype);
12116           break;
12117         }
12118       frag_wane (fragP);
12119       return fragP->fr_fix - old_fr_fix;
12120     }
12121
12122   /* Guess size depending on current relax state.  Initially the relax
12123      state will correspond to a short jump and we return 1, because
12124      the variable part of the frag (the branch offset) is one byte
12125      long.  However, we can relax a section more than once and in that
12126      case we must either set fr_subtype back to the unrelaxed state,
12127      or return the value for the appropriate branch.  */
12128   return md_relax_table[fragP->fr_subtype].rlx_length;
12129 }
12130
12131 /* Called after relax() is finished.
12132
12133    In:  Address of frag.
12134         fr_type == rs_machine_dependent.
12135         fr_subtype is what the address relaxed to.
12136
12137    Out: Any fixSs and constants are set up.
12138         Caller will turn frag into a ".space 0".  */
12139
12140 void
12141 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
12142                  fragS *fragP)
12143 {
12144   unsigned char *opcode;
12145   unsigned char *where_to_put_displacement = NULL;
12146   offsetT target_address;
12147   offsetT opcode_address;
12148   unsigned int extension = 0;
12149   offsetT displacement_from_opcode_start;
12150
12151   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
12152       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING
12153       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
12154     {
12155       /* Generate nop padding.  */
12156       unsigned int size = fragP->tc_frag_data.length;
12157       if (size)
12158         {
12159           if (size > fragP->tc_frag_data.max_bytes)
12160             abort ();
12161
12162           if (flag_debug)
12163             {
12164               const char *msg;
12165               const char *branch = "branch";
12166               const char *prefix = "";
12167               fragS *padding_fragP;
12168               if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
12169                   == BRANCH_PREFIX)
12170                 {
12171                   padding_fragP = fragP->tc_frag_data.u.padding_fragP;
12172                   switch (fragP->tc_frag_data.default_prefix)
12173                     {
12174                     default:
12175                       abort ();
12176                       break;
12177                     case CS_PREFIX_OPCODE:
12178                       prefix = " cs";
12179                       break;
12180                     case DS_PREFIX_OPCODE:
12181                       prefix = " ds";
12182                       break;
12183                     case ES_PREFIX_OPCODE:
12184                       prefix = " es";
12185                       break;
12186                     case FS_PREFIX_OPCODE:
12187                       prefix = " fs";
12188                       break;
12189                     case GS_PREFIX_OPCODE:
12190                       prefix = " gs";
12191                       break;
12192                     case SS_PREFIX_OPCODE:
12193                       prefix = " ss";
12194                       break;
12195                     }
12196                   if (padding_fragP)
12197                     msg = _("%s:%u: add %d%s at 0x%llx to align "
12198                             "%s within %d-byte boundary\n");
12199                   else
12200                     msg = _("%s:%u: add additional %d%s at 0x%llx to "
12201                             "align %s within %d-byte boundary\n");
12202                 }
12203               else
12204                 {
12205                   padding_fragP = fragP;
12206                   msg = _("%s:%u: add %d%s-byte nop at 0x%llx to align "
12207                           "%s within %d-byte boundary\n");
12208                 }
12209
12210               if (padding_fragP)
12211                 switch (padding_fragP->tc_frag_data.branch_type)
12212                   {
12213                   case align_branch_jcc:
12214                     branch = "jcc";
12215                     break;
12216                   case align_branch_fused:
12217                     branch = "fused jcc";
12218                     break;
12219                   case align_branch_jmp:
12220                     branch = "jmp";
12221                     break;
12222                   case align_branch_call:
12223                     branch = "call";
12224                     break;
12225                   case align_branch_indirect:
12226                     branch = "indiret branch";
12227                     break;
12228                   case align_branch_ret:
12229                     branch = "ret";
12230                     break;
12231                   default:
12232                     break;
12233                   }
12234
12235               fprintf (stdout, msg,
12236                        fragP->fr_file, fragP->fr_line, size, prefix,
12237                        (long long) fragP->fr_address, branch,
12238                        1 << align_branch_power);
12239             }
12240           if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
12241             memset (fragP->fr_opcode,
12242                     fragP->tc_frag_data.default_prefix, size);
12243           else
12244             i386_generate_nops (fragP, (char *) fragP->fr_opcode,
12245                                 size, 0);
12246           fragP->fr_fix += size;
12247         }
12248       return;
12249     }
12250
12251   opcode = (unsigned char *) fragP->fr_opcode;
12252
12253   /* Address we want to reach in file space.  */
12254   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
12255
12256   /* Address opcode resides at in file space.  */
12257   opcode_address = fragP->fr_address + fragP->fr_fix;
12258
12259   /* Displacement from opcode start to fill into instruction.  */
12260   displacement_from_opcode_start = target_address - opcode_address;
12261
12262   if ((fragP->fr_subtype & BIG) == 0)
12263     {
12264       /* Don't have to change opcode.  */
12265       extension = 1;            /* 1 opcode + 1 displacement  */
12266       where_to_put_displacement = &opcode[1];
12267     }
12268   else
12269     {
12270       if (no_cond_jump_promotion
12271           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
12272         as_warn_where (fragP->fr_file, fragP->fr_line,
12273                        _("long jump required"));
12274
12275       switch (fragP->fr_subtype)
12276         {
12277         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
12278           extension = 4;                /* 1 opcode + 4 displacement  */
12279           opcode[0] = 0xe9;
12280           where_to_put_displacement = &opcode[1];
12281           break;
12282
12283         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
12284           extension = 2;                /* 1 opcode + 2 displacement  */
12285           opcode[0] = 0xe9;
12286           where_to_put_displacement = &opcode[1];
12287           break;
12288
12289         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
12290         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
12291           extension = 5;                /* 2 opcode + 4 displacement  */
12292           opcode[1] = opcode[0] + 0x10;
12293           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12294           where_to_put_displacement = &opcode[2];
12295           break;
12296
12297         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
12298           extension = 3;                /* 2 opcode + 2 displacement  */
12299           opcode[1] = opcode[0] + 0x10;
12300           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12301           where_to_put_displacement = &opcode[2];
12302           break;
12303
12304         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
12305           extension = 4;
12306           opcode[0] ^= 1;
12307           opcode[1] = 3;
12308           opcode[2] = 0xe9;
12309           where_to_put_displacement = &opcode[3];
12310           break;
12311
12312         default:
12313           BAD_CASE (fragP->fr_subtype);
12314           break;
12315         }
12316     }
12317
12318   /* If size if less then four we are sure that the operand fits,
12319      but if it's 4, then it could be that the displacement is larger
12320      then -/+ 2GB.  */
12321   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
12322       && object_64bit
12323       && ((addressT) (displacement_from_opcode_start - extension
12324                       + ((addressT) 1 << 31))
12325           > (((addressT) 2 << 31) - 1)))
12326     {
12327       as_bad_where (fragP->fr_file, fragP->fr_line,
12328                     _("jump target out of range"));
12329       /* Make us emit 0.  */
12330       displacement_from_opcode_start = extension;
12331     }
12332   /* Now put displacement after opcode.  */
12333   md_number_to_chars ((char *) where_to_put_displacement,
12334                       (valueT) (displacement_from_opcode_start - extension),
12335                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
12336   fragP->fr_fix += extension;
12337 }
12338 \f
12339 /* Apply a fixup (fixP) to segment data, once it has been determined
12340    by our caller that we have all the info we need to fix it up.
12341
12342    Parameter valP is the pointer to the value of the bits.
12343
12344    On the 386, immediates, displacements, and data pointers are all in
12345    the same (little-endian) format, so we don't need to care about which
12346    we are handling.  */
12347
12348 void
12349 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
12350 {
12351   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
12352   valueT value = *valP;
12353
12354 #if !defined (TE_Mach)
12355   if (fixP->fx_pcrel)
12356     {
12357       switch (fixP->fx_r_type)
12358         {
12359         default:
12360           break;
12361
12362         case BFD_RELOC_64:
12363           fixP->fx_r_type = BFD_RELOC_64_PCREL;
12364           break;
12365         case BFD_RELOC_32:
12366         case BFD_RELOC_X86_64_32S:
12367           fixP->fx_r_type = BFD_RELOC_32_PCREL;
12368           break;
12369         case BFD_RELOC_16:
12370           fixP->fx_r_type = BFD_RELOC_16_PCREL;
12371           break;
12372         case BFD_RELOC_8:
12373           fixP->fx_r_type = BFD_RELOC_8_PCREL;
12374           break;
12375         }
12376     }
12377
12378   if (fixP->fx_addsy != NULL
12379       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
12380           || fixP->fx_r_type == BFD_RELOC_64_PCREL
12381           || fixP->fx_r_type == BFD_RELOC_16_PCREL
12382           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
12383       && !use_rela_relocations)
12384     {
12385       /* This is a hack.  There should be a better way to handle this.
12386          This covers for the fact that bfd_install_relocation will
12387          subtract the current location (for partial_inplace, PC relative
12388          relocations); see more below.  */
12389 #ifndef OBJ_AOUT
12390       if (IS_ELF
12391 #ifdef TE_PE
12392           || OUTPUT_FLAVOR == bfd_target_coff_flavour
12393 #endif
12394           )
12395         value += fixP->fx_where + fixP->fx_frag->fr_address;
12396 #endif
12397 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12398       if (IS_ELF)
12399         {
12400           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
12401
12402           if ((sym_seg == seg
12403                || (symbol_section_p (fixP->fx_addsy)
12404                    && sym_seg != absolute_section))
12405               && !generic_force_reloc (fixP))
12406             {
12407               /* Yes, we add the values in twice.  This is because
12408                  bfd_install_relocation subtracts them out again.  I think
12409                  bfd_install_relocation is broken, but I don't dare change
12410                  it.  FIXME.  */
12411               value += fixP->fx_where + fixP->fx_frag->fr_address;
12412             }
12413         }
12414 #endif
12415 #if defined (OBJ_COFF) && defined (TE_PE)
12416       /* For some reason, the PE format does not store a
12417          section address offset for a PC relative symbol.  */
12418       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
12419           || S_IS_WEAK (fixP->fx_addsy))
12420         value += md_pcrel_from (fixP);
12421 #endif
12422     }
12423 #if defined (OBJ_COFF) && defined (TE_PE)
12424   if (fixP->fx_addsy != NULL
12425       && S_IS_WEAK (fixP->fx_addsy)
12426       /* PR 16858: Do not modify weak function references.  */
12427       && ! fixP->fx_pcrel)
12428     {
12429 #if !defined (TE_PEP)
12430       /* For x86 PE weak function symbols are neither PC-relative
12431          nor do they set S_IS_FUNCTION.  So the only reliable way
12432          to detect them is to check the flags of their containing
12433          section.  */
12434       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
12435           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
12436         ;
12437       else
12438 #endif
12439       value -= S_GET_VALUE (fixP->fx_addsy);
12440     }
12441 #endif
12442
12443   /* Fix a few things - the dynamic linker expects certain values here,
12444      and we must not disappoint it.  */
12445 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12446   if (IS_ELF && fixP->fx_addsy)
12447     switch (fixP->fx_r_type)
12448       {
12449       case BFD_RELOC_386_PLT32:
12450       case BFD_RELOC_X86_64_PLT32:
12451         /* Make the jump instruction point to the address of the operand.
12452            At runtime we merely add the offset to the actual PLT entry.
12453            NB: Subtract the offset size only for jump instructions.  */
12454         if (fixP->fx_pcrel)
12455           value = -4;
12456         break;
12457
12458       case BFD_RELOC_386_TLS_GD:
12459       case BFD_RELOC_386_TLS_LDM:
12460       case BFD_RELOC_386_TLS_IE_32:
12461       case BFD_RELOC_386_TLS_IE:
12462       case BFD_RELOC_386_TLS_GOTIE:
12463       case BFD_RELOC_386_TLS_GOTDESC:
12464       case BFD_RELOC_X86_64_TLSGD:
12465       case BFD_RELOC_X86_64_TLSLD:
12466       case BFD_RELOC_X86_64_GOTTPOFF:
12467       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12468         value = 0; /* Fully resolved at runtime.  No addend.  */
12469         /* Fallthrough */
12470       case BFD_RELOC_386_TLS_LE:
12471       case BFD_RELOC_386_TLS_LDO_32:
12472       case BFD_RELOC_386_TLS_LE_32:
12473       case BFD_RELOC_X86_64_DTPOFF32:
12474       case BFD_RELOC_X86_64_DTPOFF64:
12475       case BFD_RELOC_X86_64_TPOFF32:
12476       case BFD_RELOC_X86_64_TPOFF64:
12477         S_SET_THREAD_LOCAL (fixP->fx_addsy);
12478         break;
12479
12480       case BFD_RELOC_386_TLS_DESC_CALL:
12481       case BFD_RELOC_X86_64_TLSDESC_CALL:
12482         value = 0; /* Fully resolved at runtime.  No addend.  */
12483         S_SET_THREAD_LOCAL (fixP->fx_addsy);
12484         fixP->fx_done = 0;
12485         return;
12486
12487       case BFD_RELOC_VTABLE_INHERIT:
12488       case BFD_RELOC_VTABLE_ENTRY:
12489         fixP->fx_done = 0;
12490         return;
12491
12492       default:
12493         break;
12494       }
12495 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
12496   *valP = value;
12497 #endif /* !defined (TE_Mach)  */
12498
12499   /* Are we finished with this relocation now?  */
12500   if (fixP->fx_addsy == NULL)
12501     fixP->fx_done = 1;
12502 #if defined (OBJ_COFF) && defined (TE_PE)
12503   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
12504     {
12505       fixP->fx_done = 0;
12506       /* Remember value for tc_gen_reloc.  */
12507       fixP->fx_addnumber = value;
12508       /* Clear out the frag for now.  */
12509       value = 0;
12510     }
12511 #endif
12512   else if (use_rela_relocations)
12513     {
12514       fixP->fx_no_overflow = 1;
12515       /* Remember value for tc_gen_reloc.  */
12516       fixP->fx_addnumber = value;
12517       value = 0;
12518     }
12519
12520   md_number_to_chars (p, value, fixP->fx_size);
12521 }
12522 \f
12523 const char *
12524 md_atof (int type, char *litP, int *sizeP)
12525 {
12526   /* This outputs the LITTLENUMs in REVERSE order;
12527      in accord with the bigendian 386.  */
12528   return ieee_md_atof (type, litP, sizeP, FALSE);
12529 }
12530 \f
12531 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
12532
12533 static char *
12534 output_invalid (int c)
12535 {
12536   if (ISPRINT (c))
12537     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
12538               "'%c'", c);
12539   else
12540     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
12541               "(0x%x)", (unsigned char) c);
12542   return output_invalid_buf;
12543 }
12544
12545 /* Verify that @r can be used in the current context.  */
12546
12547 static bfd_boolean check_register (const reg_entry *r)
12548 {
12549   if (allow_pseudo_reg)
12550     return TRUE;
12551
12552   if (operand_type_all_zero (&r->reg_type))
12553     return FALSE;
12554
12555   if ((r->reg_type.bitfield.dword
12556        || (r->reg_type.bitfield.class == SReg && r->reg_num > 3)
12557        || r->reg_type.bitfield.class == RegCR
12558        || r->reg_type.bitfield.class == RegDR)
12559       && !cpu_arch_flags.bitfield.cpui386)
12560     return FALSE;
12561
12562   if (r->reg_type.bitfield.class == RegTR
12563       && (flag_code == CODE_64BIT
12564           || !cpu_arch_flags.bitfield.cpui386
12565           || cpu_arch_isa_flags.bitfield.cpui586
12566           || cpu_arch_isa_flags.bitfield.cpui686))
12567     return FALSE;
12568
12569   if (r->reg_type.bitfield.class == RegMMX && !cpu_arch_flags.bitfield.cpummx)
12570     return FALSE;
12571
12572   if (!cpu_arch_flags.bitfield.cpuavx512f)
12573     {
12574       if (r->reg_type.bitfield.zmmword
12575           || r->reg_type.bitfield.class == RegMask)
12576         return FALSE;
12577
12578       if (!cpu_arch_flags.bitfield.cpuavx)
12579         {
12580           if (r->reg_type.bitfield.ymmword)
12581             return FALSE;
12582
12583           if (!cpu_arch_flags.bitfield.cpusse && r->reg_type.bitfield.xmmword)
12584             return FALSE;
12585         }
12586     }
12587
12588   if (r->reg_type.bitfield.tmmword
12589       && (!cpu_arch_flags.bitfield.cpuamx_tile
12590           || flag_code != CODE_64BIT))
12591     return FALSE;
12592
12593   if (r->reg_type.bitfield.class == RegBND && !cpu_arch_flags.bitfield.cpumpx)
12594     return FALSE;
12595
12596   /* Don't allow fake index register unless allow_index_reg isn't 0. */
12597   if (!allow_index_reg && r->reg_num == RegIZ)
12598     return FALSE;
12599
12600   /* Upper 16 vector registers are only available with VREX in 64bit
12601      mode, and require EVEX encoding.  */
12602   if (r->reg_flags & RegVRex)
12603     {
12604       if (!cpu_arch_flags.bitfield.cpuavx512f
12605           || flag_code != CODE_64BIT)
12606         return FALSE;
12607
12608       if (i.vec_encoding == vex_encoding_default)
12609         i.vec_encoding = vex_encoding_evex;
12610       else if (i.vec_encoding != vex_encoding_evex)
12611         i.vec_encoding = vex_encoding_error;
12612     }
12613
12614   if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword)
12615       && (!cpu_arch_flags.bitfield.cpulm || r->reg_type.bitfield.class != RegCR)
12616       && flag_code != CODE_64BIT)
12617     return FALSE;
12618
12619   if (r->reg_type.bitfield.class == SReg && r->reg_num == RegFlat
12620       && !intel_syntax)
12621     return FALSE;
12622
12623   return TRUE;
12624 }
12625
12626 /* REG_STRING starts *before* REGISTER_PREFIX.  */
12627
12628 static const reg_entry *
12629 parse_real_register (char *reg_string, char **end_op)
12630 {
12631   char *s = reg_string;
12632   char *p;
12633   char reg_name_given[MAX_REG_NAME_SIZE + 1];
12634   const reg_entry *r;
12635
12636   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
12637   if (*s == REGISTER_PREFIX)
12638     ++s;
12639
12640   if (is_space_char (*s))
12641     ++s;
12642
12643   p = reg_name_given;
12644   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
12645     {
12646       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
12647         return (const reg_entry *) NULL;
12648       s++;
12649     }
12650
12651   /* For naked regs, make sure that we are not dealing with an identifier.
12652      This prevents confusing an identifier like `eax_var' with register
12653      `eax'.  */
12654   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
12655     return (const reg_entry *) NULL;
12656
12657   *end_op = s;
12658
12659   r = (const reg_entry *) str_hash_find (reg_hash, reg_name_given);
12660
12661   /* Handle floating point regs, allowing spaces in the (i) part.  */
12662   if (r == i386_regtab /* %st is first entry of table  */)
12663     {
12664       if (!cpu_arch_flags.bitfield.cpu8087
12665           && !cpu_arch_flags.bitfield.cpu287
12666           && !cpu_arch_flags.bitfield.cpu387
12667           && !allow_pseudo_reg)
12668         return (const reg_entry *) NULL;
12669
12670       if (is_space_char (*s))
12671         ++s;
12672       if (*s == '(')
12673         {
12674           ++s;
12675           if (is_space_char (*s))
12676             ++s;
12677           if (*s >= '0' && *s <= '7')
12678             {
12679               int fpr = *s - '0';
12680               ++s;
12681               if (is_space_char (*s))
12682                 ++s;
12683               if (*s == ')')
12684                 {
12685                   *end_op = s + 1;
12686                   r = (const reg_entry *) str_hash_find (reg_hash, "st(0)");
12687                   know (r);
12688                   return r + fpr;
12689                 }
12690             }
12691           /* We have "%st(" then garbage.  */
12692           return (const reg_entry *) NULL;
12693         }
12694     }
12695
12696   return r && check_register (r) ? r : NULL;
12697 }
12698
12699 /* REG_STRING starts *before* REGISTER_PREFIX.  */
12700
12701 static const reg_entry *
12702 parse_register (char *reg_string, char **end_op)
12703 {
12704   const reg_entry *r;
12705
12706   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
12707     r = parse_real_register (reg_string, end_op);
12708   else
12709     r = NULL;
12710   if (!r)
12711     {
12712       char *save = input_line_pointer;
12713       char c;
12714       symbolS *symbolP;
12715
12716       input_line_pointer = reg_string;
12717       c = get_symbol_name (&reg_string);
12718       symbolP = symbol_find (reg_string);
12719       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
12720         {
12721           const expressionS *e = symbol_get_value_expression (symbolP);
12722
12723           know (e->X_op == O_register);
12724           know (e->X_add_number >= 0
12725                 && (valueT) e->X_add_number < i386_regtab_size);
12726           r = i386_regtab + e->X_add_number;
12727           if (!check_register (r))
12728             {
12729               as_bad (_("register '%s%s' cannot be used here"),
12730                       register_prefix, r->reg_name);
12731               r = &bad_reg;
12732             }
12733           *end_op = input_line_pointer;
12734         }
12735       *input_line_pointer = c;
12736       input_line_pointer = save;
12737     }
12738   return r;
12739 }
12740
12741 int
12742 i386_parse_name (char *name, expressionS *e, char *nextcharP)
12743 {
12744   const reg_entry *r;
12745   char *end = input_line_pointer;
12746
12747   *end = *nextcharP;
12748   r = parse_register (name, &input_line_pointer);
12749   if (r && end <= input_line_pointer)
12750     {
12751       *nextcharP = *input_line_pointer;
12752       *input_line_pointer = 0;
12753       if (r != &bad_reg)
12754         {
12755           e->X_op = O_register;
12756           e->X_add_number = r - i386_regtab;
12757         }
12758       else
12759           e->X_op = O_illegal;
12760       return 1;
12761     }
12762   input_line_pointer = end;
12763   *end = 0;
12764   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
12765 }
12766
12767 void
12768 md_operand (expressionS *e)
12769 {
12770   char *end;
12771   const reg_entry *r;
12772
12773   switch (*input_line_pointer)
12774     {
12775     case REGISTER_PREFIX:
12776       r = parse_real_register (input_line_pointer, &end);
12777       if (r)
12778         {
12779           e->X_op = O_register;
12780           e->X_add_number = r - i386_regtab;
12781           input_line_pointer = end;
12782         }
12783       break;
12784
12785     case '[':
12786       gas_assert (intel_syntax);
12787       end = input_line_pointer++;
12788       expression (e);
12789       if (*input_line_pointer == ']')
12790         {
12791           ++input_line_pointer;
12792           e->X_op_symbol = make_expr_symbol (e);
12793           e->X_add_symbol = NULL;
12794           e->X_add_number = 0;
12795           e->X_op = O_index;
12796         }
12797       else
12798         {
12799           e->X_op = O_absent;
12800           input_line_pointer = end;
12801         }
12802       break;
12803     }
12804 }
12805
12806 \f
12807 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12808 const char *md_shortopts = "kVQ:sqnO::";
12809 #else
12810 const char *md_shortopts = "qnO::";
12811 #endif
12812
12813 #define OPTION_32 (OPTION_MD_BASE + 0)
12814 #define OPTION_64 (OPTION_MD_BASE + 1)
12815 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
12816 #define OPTION_MARCH (OPTION_MD_BASE + 3)
12817 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
12818 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
12819 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
12820 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
12821 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
12822 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 9)
12823 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
12824 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
12825 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
12826 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
12827 #define OPTION_X32 (OPTION_MD_BASE + 14)
12828 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
12829 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
12830 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
12831 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
12832 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
12833 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
12834 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
12835 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
12836 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
12837 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
12838 #define OPTION_X86_USED_NOTE (OPTION_MD_BASE + 25)
12839 #define OPTION_MVEXWIG (OPTION_MD_BASE + 26)
12840 #define OPTION_MALIGN_BRANCH_BOUNDARY (OPTION_MD_BASE + 27)
12841 #define OPTION_MALIGN_BRANCH_PREFIX_SIZE (OPTION_MD_BASE + 28)
12842 #define OPTION_MALIGN_BRANCH (OPTION_MD_BASE + 29)
12843 #define OPTION_MBRANCHES_WITH_32B_BOUNDARIES (OPTION_MD_BASE + 30)
12844 #define OPTION_MLFENCE_AFTER_LOAD (OPTION_MD_BASE + 31)
12845 #define OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH (OPTION_MD_BASE + 32)
12846 #define OPTION_MLFENCE_BEFORE_RET (OPTION_MD_BASE + 33)
12847
12848 struct option md_longopts[] =
12849 {
12850   {"32", no_argument, NULL, OPTION_32},
12851 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
12852      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
12853   {"64", no_argument, NULL, OPTION_64},
12854 #endif
12855 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12856   {"x32", no_argument, NULL, OPTION_X32},
12857   {"mshared", no_argument, NULL, OPTION_MSHARED},
12858   {"mx86-used-note", required_argument, NULL, OPTION_X86_USED_NOTE},
12859 #endif
12860   {"divide", no_argument, NULL, OPTION_DIVIDE},
12861   {"march", required_argument, NULL, OPTION_MARCH},
12862   {"mtune", required_argument, NULL, OPTION_MTUNE},
12863   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
12864   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
12865   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
12866   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
12867   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
12868   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
12869   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
12870   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
12871   {"mvexwig", required_argument, NULL, OPTION_MVEXWIG},
12872   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
12873   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
12874   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
12875 # if defined (TE_PE) || defined (TE_PEP)
12876   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
12877 #endif
12878   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
12879   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
12880   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
12881   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
12882   {"malign-branch-boundary", required_argument, NULL, OPTION_MALIGN_BRANCH_BOUNDARY},
12883   {"malign-branch-prefix-size", required_argument, NULL, OPTION_MALIGN_BRANCH_PREFIX_SIZE},
12884   {"malign-branch", required_argument, NULL, OPTION_MALIGN_BRANCH},
12885   {"mbranches-within-32B-boundaries", no_argument, NULL, OPTION_MBRANCHES_WITH_32B_BOUNDARIES},
12886   {"mlfence-after-load", required_argument, NULL, OPTION_MLFENCE_AFTER_LOAD},
12887   {"mlfence-before-indirect-branch", required_argument, NULL,
12888    OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH},
12889   {"mlfence-before-ret", required_argument, NULL, OPTION_MLFENCE_BEFORE_RET},
12890   {"mamd64", no_argument, NULL, OPTION_MAMD64},
12891   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
12892   {NULL, no_argument, NULL, 0}
12893 };
12894 size_t md_longopts_size = sizeof (md_longopts);
12895
12896 int
12897 md_parse_option (int c, const char *arg)
12898 {
12899   unsigned int j;
12900   char *arch, *next, *saved, *type;
12901
12902   switch (c)
12903     {
12904     case 'n':
12905       optimize_align_code = 0;
12906       break;
12907
12908     case 'q':
12909       quiet_warnings = 1;
12910       break;
12911
12912 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12913       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
12914          should be emitted or not.  FIXME: Not implemented.  */
12915     case 'Q':
12916       if ((arg[0] != 'y' && arg[0] != 'n') || arg[1])
12917         return 0;
12918       break;
12919
12920       /* -V: SVR4 argument to print version ID.  */
12921     case 'V':
12922       print_version_id ();
12923       break;
12924
12925       /* -k: Ignore for FreeBSD compatibility.  */
12926     case 'k':
12927       break;
12928
12929     case 's':
12930       /* -s: On i386 Solaris, this tells the native assembler to use
12931          .stab instead of .stab.excl.  We always use .stab anyhow.  */
12932       break;
12933
12934     case OPTION_MSHARED:
12935       shared = 1;
12936       break;
12937
12938     case OPTION_X86_USED_NOTE:
12939       if (strcasecmp (arg, "yes") == 0)
12940         x86_used_note = 1;
12941       else if (strcasecmp (arg, "no") == 0)
12942         x86_used_note = 0;
12943       else
12944         as_fatal (_("invalid -mx86-used-note= option: `%s'"), arg);
12945       break;
12946
12947
12948 #endif
12949 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
12950      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
12951     case OPTION_64:
12952       {
12953         const char **list, **l;
12954
12955         list = bfd_target_list ();
12956         for (l = list; *l != NULL; l++)
12957           if (CONST_STRNEQ (*l, "elf64-x86-64")
12958               || strcmp (*l, "coff-x86-64") == 0
12959               || strcmp (*l, "pe-x86-64") == 0
12960               || strcmp (*l, "pei-x86-64") == 0
12961               || strcmp (*l, "mach-o-x86-64") == 0)
12962             {
12963               default_arch = "x86_64";
12964               break;
12965             }
12966         if (*l == NULL)
12967           as_fatal (_("no compiled in support for x86_64"));
12968         free (list);
12969       }
12970       break;
12971 #endif
12972
12973 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12974     case OPTION_X32:
12975       if (IS_ELF)
12976         {
12977           const char **list, **l;
12978
12979           list = bfd_target_list ();
12980           for (l = list; *l != NULL; l++)
12981             if (CONST_STRNEQ (*l, "elf32-x86-64"))
12982               {
12983                 default_arch = "x86_64:32";
12984                 break;
12985               }
12986           if (*l == NULL)
12987             as_fatal (_("no compiled in support for 32bit x86_64"));
12988           free (list);
12989         }
12990       else
12991         as_fatal (_("32bit x86_64 is only supported for ELF"));
12992       break;
12993 #endif
12994
12995     case OPTION_32:
12996       default_arch = "i386";
12997       break;
12998
12999     case OPTION_DIVIDE:
13000 #ifdef SVR4_COMMENT_CHARS
13001       {
13002         char *n, *t;
13003         const char *s;
13004
13005         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
13006         t = n;
13007         for (s = i386_comment_chars; *s != '\0'; s++)
13008           if (*s != '/')
13009             *t++ = *s;
13010         *t = '\0';
13011         i386_comment_chars = n;
13012       }
13013 #endif
13014       break;
13015
13016     case OPTION_MARCH:
13017       saved = xstrdup (arg);
13018       arch = saved;
13019       /* Allow -march=+nosse.  */
13020       if (*arch == '+')
13021         arch++;
13022       do
13023         {
13024           if (*arch == '.')
13025             as_fatal (_("invalid -march= option: `%s'"), arg);
13026           next = strchr (arch, '+');
13027           if (next)
13028             *next++ = '\0';
13029           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13030             {
13031               if (strcmp (arch, cpu_arch [j].name) == 0)
13032                 {
13033                   /* Processor.  */
13034                   if (! cpu_arch[j].flags.bitfield.cpui386)
13035                     continue;
13036
13037                   cpu_arch_name = cpu_arch[j].name;
13038                   cpu_sub_arch_name = NULL;
13039                   cpu_arch_flags = cpu_arch[j].flags;
13040                   cpu_arch_isa = cpu_arch[j].type;
13041                   cpu_arch_isa_flags = cpu_arch[j].flags;
13042                   if (!cpu_arch_tune_set)
13043                     {
13044                       cpu_arch_tune = cpu_arch_isa;
13045                       cpu_arch_tune_flags = cpu_arch_isa_flags;
13046                     }
13047                   break;
13048                 }
13049               else if (*cpu_arch [j].name == '.'
13050                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
13051                 {
13052                   /* ISA extension.  */
13053                   i386_cpu_flags flags;
13054
13055                   flags = cpu_flags_or (cpu_arch_flags,
13056                                         cpu_arch[j].flags);
13057
13058                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
13059                     {
13060                       if (cpu_sub_arch_name)
13061                         {
13062                           char *name = cpu_sub_arch_name;
13063                           cpu_sub_arch_name = concat (name,
13064                                                       cpu_arch[j].name,
13065                                                       (const char *) NULL);
13066                           free (name);
13067                         }
13068                       else
13069                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
13070                       cpu_arch_flags = flags;
13071                       cpu_arch_isa_flags = flags;
13072                     }
13073                   else
13074                     cpu_arch_isa_flags
13075                       = cpu_flags_or (cpu_arch_isa_flags,
13076                                       cpu_arch[j].flags);
13077                   break;
13078                 }
13079             }
13080
13081           if (j >= ARRAY_SIZE (cpu_arch))
13082             {
13083               /* Disable an ISA extension.  */
13084               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
13085                 if (strcmp (arch, cpu_noarch [j].name) == 0)
13086                   {
13087                     i386_cpu_flags flags;
13088
13089                     flags = cpu_flags_and_not (cpu_arch_flags,
13090                                                cpu_noarch[j].flags);
13091                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
13092                       {
13093                         if (cpu_sub_arch_name)
13094                           {
13095                             char *name = cpu_sub_arch_name;
13096                             cpu_sub_arch_name = concat (arch,
13097                                                         (const char *) NULL);
13098                             free (name);
13099                           }
13100                         else
13101                           cpu_sub_arch_name = xstrdup (arch);
13102                         cpu_arch_flags = flags;
13103                         cpu_arch_isa_flags = flags;
13104                       }
13105                     break;
13106                   }
13107
13108               if (j >= ARRAY_SIZE (cpu_noarch))
13109                 j = ARRAY_SIZE (cpu_arch);
13110             }
13111
13112           if (j >= ARRAY_SIZE (cpu_arch))
13113             as_fatal (_("invalid -march= option: `%s'"), arg);
13114
13115           arch = next;
13116         }
13117       while (next != NULL);
13118       free (saved);
13119       break;
13120
13121     case OPTION_MTUNE:
13122       if (*arg == '.')
13123         as_fatal (_("invalid -mtune= option: `%s'"), arg);
13124       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13125         {
13126           if (strcmp (arg, cpu_arch [j].name) == 0)
13127             {
13128               cpu_arch_tune_set = 1;
13129               cpu_arch_tune = cpu_arch [j].type;
13130               cpu_arch_tune_flags = cpu_arch[j].flags;
13131               break;
13132             }
13133         }
13134       if (j >= ARRAY_SIZE (cpu_arch))
13135         as_fatal (_("invalid -mtune= option: `%s'"), arg);
13136       break;
13137
13138     case OPTION_MMNEMONIC:
13139       if (strcasecmp (arg, "att") == 0)
13140         intel_mnemonic = 0;
13141       else if (strcasecmp (arg, "intel") == 0)
13142         intel_mnemonic = 1;
13143       else
13144         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
13145       break;
13146
13147     case OPTION_MSYNTAX:
13148       if (strcasecmp (arg, "att") == 0)
13149         intel_syntax = 0;
13150       else if (strcasecmp (arg, "intel") == 0)
13151         intel_syntax = 1;
13152       else
13153         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
13154       break;
13155
13156     case OPTION_MINDEX_REG:
13157       allow_index_reg = 1;
13158       break;
13159
13160     case OPTION_MNAKED_REG:
13161       allow_naked_reg = 1;
13162       break;
13163
13164     case OPTION_MSSE2AVX:
13165       sse2avx = 1;
13166       break;
13167
13168     case OPTION_MSSE_CHECK:
13169       if (strcasecmp (arg, "error") == 0)
13170         sse_check = check_error;
13171       else if (strcasecmp (arg, "warning") == 0)
13172         sse_check = check_warning;
13173       else if (strcasecmp (arg, "none") == 0)
13174         sse_check = check_none;
13175       else
13176         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
13177       break;
13178
13179     case OPTION_MOPERAND_CHECK:
13180       if (strcasecmp (arg, "error") == 0)
13181         operand_check = check_error;
13182       else if (strcasecmp (arg, "warning") == 0)
13183         operand_check = check_warning;
13184       else if (strcasecmp (arg, "none") == 0)
13185         operand_check = check_none;
13186       else
13187         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
13188       break;
13189
13190     case OPTION_MAVXSCALAR:
13191       if (strcasecmp (arg, "128") == 0)
13192         avxscalar = vex128;
13193       else if (strcasecmp (arg, "256") == 0)
13194         avxscalar = vex256;
13195       else
13196         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
13197       break;
13198
13199     case OPTION_MVEXWIG:
13200       if (strcmp (arg, "0") == 0)
13201         vexwig = vexw0;
13202       else if (strcmp (arg, "1") == 0)
13203         vexwig = vexw1;
13204       else
13205         as_fatal (_("invalid -mvexwig= option: `%s'"), arg);
13206       break;
13207
13208     case OPTION_MADD_BND_PREFIX:
13209       add_bnd_prefix = 1;
13210       break;
13211
13212     case OPTION_MEVEXLIG:
13213       if (strcmp (arg, "128") == 0)
13214         evexlig = evexl128;
13215       else if (strcmp (arg, "256") == 0)
13216         evexlig = evexl256;
13217       else  if (strcmp (arg, "512") == 0)
13218         evexlig = evexl512;
13219       else
13220         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
13221       break;
13222
13223     case OPTION_MEVEXRCIG:
13224       if (strcmp (arg, "rne") == 0)
13225         evexrcig = rne;
13226       else if (strcmp (arg, "rd") == 0)
13227         evexrcig = rd;
13228       else if (strcmp (arg, "ru") == 0)
13229         evexrcig = ru;
13230       else if (strcmp (arg, "rz") == 0)
13231         evexrcig = rz;
13232       else
13233         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
13234       break;
13235
13236     case OPTION_MEVEXWIG:
13237       if (strcmp (arg, "0") == 0)
13238         evexwig = evexw0;
13239       else if (strcmp (arg, "1") == 0)
13240         evexwig = evexw1;
13241       else
13242         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
13243       break;
13244
13245 # if defined (TE_PE) || defined (TE_PEP)
13246     case OPTION_MBIG_OBJ:
13247       use_big_obj = 1;
13248       break;
13249 #endif
13250
13251     case OPTION_MOMIT_LOCK_PREFIX:
13252       if (strcasecmp (arg, "yes") == 0)
13253         omit_lock_prefix = 1;
13254       else if (strcasecmp (arg, "no") == 0)
13255         omit_lock_prefix = 0;
13256       else
13257         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
13258       break;
13259
13260     case OPTION_MFENCE_AS_LOCK_ADD:
13261       if (strcasecmp (arg, "yes") == 0)
13262         avoid_fence = 1;
13263       else if (strcasecmp (arg, "no") == 0)
13264         avoid_fence = 0;
13265       else
13266         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
13267       break;
13268
13269     case OPTION_MLFENCE_AFTER_LOAD:
13270       if (strcasecmp (arg, "yes") == 0)
13271         lfence_after_load = 1;
13272       else if (strcasecmp (arg, "no") == 0)
13273         lfence_after_load = 0;
13274       else
13275         as_fatal (_("invalid -mlfence-after-load= option: `%s'"), arg);
13276       break;
13277
13278     case OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH:
13279       if (strcasecmp (arg, "all") == 0)
13280         {
13281           lfence_before_indirect_branch = lfence_branch_all;
13282           if (lfence_before_ret == lfence_before_ret_none)
13283             lfence_before_ret = lfence_before_ret_shl;
13284         }
13285       else if (strcasecmp (arg, "memory") == 0)
13286         lfence_before_indirect_branch = lfence_branch_memory;
13287       else if (strcasecmp (arg, "register") == 0)
13288         lfence_before_indirect_branch = lfence_branch_register;
13289       else if (strcasecmp (arg, "none") == 0)
13290         lfence_before_indirect_branch = lfence_branch_none;
13291       else
13292         as_fatal (_("invalid -mlfence-before-indirect-branch= option: `%s'"),
13293                   arg);
13294       break;
13295
13296     case OPTION_MLFENCE_BEFORE_RET:
13297       if (strcasecmp (arg, "or") == 0)
13298         lfence_before_ret = lfence_before_ret_or;
13299       else if (strcasecmp (arg, "not") == 0)
13300         lfence_before_ret = lfence_before_ret_not;
13301       else if (strcasecmp (arg, "shl") == 0 || strcasecmp (arg, "yes") == 0)
13302         lfence_before_ret = lfence_before_ret_shl;
13303       else if (strcasecmp (arg, "none") == 0)
13304         lfence_before_ret = lfence_before_ret_none;
13305       else
13306         as_fatal (_("invalid -mlfence-before-ret= option: `%s'"),
13307                   arg);
13308       break;
13309
13310     case OPTION_MRELAX_RELOCATIONS:
13311       if (strcasecmp (arg, "yes") == 0)
13312         generate_relax_relocations = 1;
13313       else if (strcasecmp (arg, "no") == 0)
13314         generate_relax_relocations = 0;
13315       else
13316         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
13317       break;
13318
13319     case OPTION_MALIGN_BRANCH_BOUNDARY:
13320       {
13321         char *end;
13322         long int align = strtoul (arg, &end, 0);
13323         if (*end == '\0')
13324           {
13325             if (align == 0)
13326               {
13327                 align_branch_power = 0;
13328                 break;
13329               }
13330             else if (align >= 16)
13331               {
13332                 int align_power;
13333                 for (align_power = 0;
13334                      (align & 1) == 0;
13335                      align >>= 1, align_power++)
13336                   continue;
13337                 /* Limit alignment power to 31.  */
13338                 if (align == 1 && align_power < 32)
13339                   {
13340                     align_branch_power = align_power;
13341                     break;
13342                   }
13343               }
13344           }
13345         as_fatal (_("invalid -malign-branch-boundary= value: %s"), arg);
13346       }
13347       break;
13348
13349     case OPTION_MALIGN_BRANCH_PREFIX_SIZE:
13350       {
13351         char *end;
13352         int align = strtoul (arg, &end, 0);
13353         /* Some processors only support 5 prefixes.  */
13354         if (*end == '\0' && align >= 0 && align < 6)
13355           {
13356             align_branch_prefix_size = align;
13357             break;
13358           }
13359         as_fatal (_("invalid -malign-branch-prefix-size= value: %s"),
13360                   arg);
13361       }
13362       break;
13363
13364     case OPTION_MALIGN_BRANCH:
13365       align_branch = 0;
13366       saved = xstrdup (arg);
13367       type = saved;
13368       do
13369         {
13370           next = strchr (type, '+');
13371           if (next)
13372             *next++ = '\0';
13373           if (strcasecmp (type, "jcc") == 0)
13374             align_branch |= align_branch_jcc_bit;
13375           else if (strcasecmp (type, "fused") == 0)
13376             align_branch |= align_branch_fused_bit;
13377           else if (strcasecmp (type, "jmp") == 0)
13378             align_branch |= align_branch_jmp_bit;
13379           else if (strcasecmp (type, "call") == 0)
13380             align_branch |= align_branch_call_bit;
13381           else if (strcasecmp (type, "ret") == 0)
13382             align_branch |= align_branch_ret_bit;
13383           else if (strcasecmp (type, "indirect") == 0)
13384             align_branch |= align_branch_indirect_bit;
13385           else
13386             as_fatal (_("invalid -malign-branch= option: `%s'"), arg);
13387           type = next;
13388         }
13389       while (next != NULL);
13390       free (saved);
13391       break;
13392
13393     case OPTION_MBRANCHES_WITH_32B_BOUNDARIES:
13394       align_branch_power = 5;
13395       align_branch_prefix_size = 5;
13396       align_branch = (align_branch_jcc_bit
13397                       | align_branch_fused_bit
13398                       | align_branch_jmp_bit);
13399       break;
13400
13401     case OPTION_MAMD64:
13402       isa64 = amd64;
13403       break;
13404
13405     case OPTION_MINTEL64:
13406       isa64 = intel64;
13407       break;
13408
13409     case 'O':
13410       if (arg == NULL)
13411         {
13412           optimize = 1;
13413           /* Turn off -Os.  */
13414           optimize_for_space = 0;
13415         }
13416       else if (*arg == 's')
13417         {
13418           optimize_for_space = 1;
13419           /* Turn on all encoding optimizations.  */
13420           optimize = INT_MAX;
13421         }
13422       else
13423         {
13424           optimize = atoi (arg);
13425           /* Turn off -Os.  */
13426           optimize_for_space = 0;
13427         }
13428       break;
13429
13430     default:
13431       return 0;
13432     }
13433   return 1;
13434 }
13435
13436 #define MESSAGE_TEMPLATE \
13437 "                                                                                "
13438
13439 static char *
13440 output_message (FILE *stream, char *p, char *message, char *start,
13441                 int *left_p, const char *name, int len)
13442 {
13443   int size = sizeof (MESSAGE_TEMPLATE);
13444   int left = *left_p;
13445
13446   /* Reserve 2 spaces for ", " or ",\0" */
13447   left -= len + 2;
13448
13449   /* Check if there is any room.  */
13450   if (left >= 0)
13451     {
13452       if (p != start)
13453         {
13454           *p++ = ',';
13455           *p++ = ' ';
13456         }
13457       p = mempcpy (p, name, len);
13458     }
13459   else
13460     {
13461       /* Output the current message now and start a new one.  */
13462       *p++ = ',';
13463       *p = '\0';
13464       fprintf (stream, "%s\n", message);
13465       p = start;
13466       left = size - (start - message) - len - 2;
13467
13468       gas_assert (left >= 0);
13469
13470       p = mempcpy (p, name, len);
13471     }
13472
13473   *left_p = left;
13474   return p;
13475 }
13476
13477 static void
13478 show_arch (FILE *stream, int ext, int check)
13479 {
13480   static char message[] = MESSAGE_TEMPLATE;
13481   char *start = message + 27;
13482   char *p;
13483   int size = sizeof (MESSAGE_TEMPLATE);
13484   int left;
13485   const char *name;
13486   int len;
13487   unsigned int j;
13488
13489   p = start;
13490   left = size - (start - message);
13491   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13492     {
13493       /* Should it be skipped?  */
13494       if (cpu_arch [j].skip)
13495         continue;
13496
13497       name = cpu_arch [j].name;
13498       len = cpu_arch [j].len;
13499       if (*name == '.')
13500         {
13501           /* It is an extension.  Skip if we aren't asked to show it.  */
13502           if (ext)
13503             {
13504               name++;
13505               len--;
13506             }
13507           else
13508             continue;
13509         }
13510       else if (ext)
13511         {
13512           /* It is an processor.  Skip if we show only extension.  */
13513           continue;
13514         }
13515       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
13516         {
13517           /* It is an impossible processor - skip.  */
13518           continue;
13519         }
13520
13521       p = output_message (stream, p, message, start, &left, name, len);
13522     }
13523
13524   /* Display disabled extensions.  */
13525   if (ext)
13526     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
13527       {
13528         name = cpu_noarch [j].name;
13529         len = cpu_noarch [j].len;
13530         p = output_message (stream, p, message, start, &left, name,
13531                             len);
13532       }
13533
13534   *p = '\0';
13535   fprintf (stream, "%s\n", message);
13536 }
13537
13538 void
13539 md_show_usage (FILE *stream)
13540 {
13541 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13542   fprintf (stream, _("\
13543   -Qy, -Qn                ignored\n\
13544   -V                      print assembler version number\n\
13545   -k                      ignored\n"));
13546 #endif
13547   fprintf (stream, _("\
13548   -n                      Do not optimize code alignment\n\
13549   -q                      quieten some warnings\n"));
13550 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13551   fprintf (stream, _("\
13552   -s                      ignored\n"));
13553 #endif
13554 #if defined BFD64 && (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
13555                       || defined (TE_PE) || defined (TE_PEP))
13556   fprintf (stream, _("\
13557   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
13558 #endif
13559 #ifdef SVR4_COMMENT_CHARS
13560   fprintf (stream, _("\
13561   --divide                do not treat `/' as a comment character\n"));
13562 #else
13563   fprintf (stream, _("\
13564   --divide                ignored\n"));
13565 #endif
13566   fprintf (stream, _("\
13567   -march=CPU[,+EXTENSION...]\n\
13568                           generate code for CPU and EXTENSION, CPU is one of:\n"));
13569   show_arch (stream, 0, 1);
13570   fprintf (stream, _("\
13571                           EXTENSION is combination of:\n"));
13572   show_arch (stream, 1, 0);
13573   fprintf (stream, _("\
13574   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
13575   show_arch (stream, 0, 0);
13576   fprintf (stream, _("\
13577   -msse2avx               encode SSE instructions with VEX prefix\n"));
13578   fprintf (stream, _("\
13579   -msse-check=[none|error|warning] (default: warning)\n\
13580                           check SSE instructions\n"));
13581   fprintf (stream, _("\
13582   -moperand-check=[none|error|warning] (default: warning)\n\
13583                           check operand combinations for validity\n"));
13584   fprintf (stream, _("\
13585   -mavxscalar=[128|256] (default: 128)\n\
13586                           encode scalar AVX instructions with specific vector\n\
13587                            length\n"));
13588   fprintf (stream, _("\
13589   -mvexwig=[0|1] (default: 0)\n\
13590                           encode VEX instructions with specific VEX.W value\n\
13591                            for VEX.W bit ignored instructions\n"));
13592   fprintf (stream, _("\
13593   -mevexlig=[128|256|512] (default: 128)\n\
13594                           encode scalar EVEX instructions with specific vector\n\
13595                            length\n"));
13596   fprintf (stream, _("\
13597   -mevexwig=[0|1] (default: 0)\n\
13598                           encode EVEX instructions with specific EVEX.W value\n\
13599                            for EVEX.W bit ignored instructions\n"));
13600   fprintf (stream, _("\
13601   -mevexrcig=[rne|rd|ru|rz] (default: rne)\n\
13602                           encode EVEX instructions with specific EVEX.RC value\n\
13603                            for SAE-only ignored instructions\n"));
13604   fprintf (stream, _("\
13605   -mmnemonic=[att|intel] "));
13606   if (SYSV386_COMPAT)
13607     fprintf (stream, _("(default: att)\n"));
13608   else
13609     fprintf (stream, _("(default: intel)\n"));
13610   fprintf (stream, _("\
13611                           use AT&T/Intel mnemonic\n"));
13612   fprintf (stream, _("\
13613   -msyntax=[att|intel] (default: att)\n\
13614                           use AT&T/Intel syntax\n"));
13615   fprintf (stream, _("\
13616   -mindex-reg             support pseudo index registers\n"));
13617   fprintf (stream, _("\
13618   -mnaked-reg             don't require `%%' prefix for registers\n"));
13619   fprintf (stream, _("\
13620   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
13621 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13622   fprintf (stream, _("\
13623   -mshared                disable branch optimization for shared code\n"));
13624   fprintf (stream, _("\
13625   -mx86-used-note=[no|yes] "));
13626   if (DEFAULT_X86_USED_NOTE)
13627     fprintf (stream, _("(default: yes)\n"));
13628   else
13629     fprintf (stream, _("(default: no)\n"));
13630   fprintf (stream, _("\
13631                           generate x86 used ISA and feature properties\n"));
13632 #endif
13633 #if defined (TE_PE) || defined (TE_PEP)
13634   fprintf (stream, _("\
13635   -mbig-obj               generate big object files\n"));
13636 #endif
13637   fprintf (stream, _("\
13638   -momit-lock-prefix=[no|yes] (default: no)\n\
13639                           strip all lock prefixes\n"));
13640   fprintf (stream, _("\
13641   -mfence-as-lock-add=[no|yes] (default: no)\n\
13642                           encode lfence, mfence and sfence as\n\
13643                            lock addl $0x0, (%%{re}sp)\n"));
13644   fprintf (stream, _("\
13645   -mrelax-relocations=[no|yes] "));
13646   if (DEFAULT_GENERATE_X86_RELAX_RELOCATIONS)
13647     fprintf (stream, _("(default: yes)\n"));
13648   else
13649     fprintf (stream, _("(default: no)\n"));
13650   fprintf (stream, _("\
13651                           generate relax relocations\n"));
13652   fprintf (stream, _("\
13653   -malign-branch-boundary=NUM (default: 0)\n\
13654                           align branches within NUM byte boundary\n"));
13655   fprintf (stream, _("\
13656   -malign-branch=TYPE[+TYPE...] (default: jcc+fused+jmp)\n\
13657                           TYPE is combination of jcc, fused, jmp, call, ret,\n\
13658                            indirect\n\
13659                           specify types of branches to align\n"));
13660   fprintf (stream, _("\
13661   -malign-branch-prefix-size=NUM (default: 5)\n\
13662                           align branches with NUM prefixes per instruction\n"));
13663   fprintf (stream, _("\
13664   -mbranches-within-32B-boundaries\n\
13665                           align branches within 32 byte boundary\n"));
13666   fprintf (stream, _("\
13667   -mlfence-after-load=[no|yes] (default: no)\n\
13668                           generate lfence after load\n"));
13669   fprintf (stream, _("\
13670   -mlfence-before-indirect-branch=[none|all|register|memory] (default: none)\n\
13671                           generate lfence before indirect near branch\n"));
13672   fprintf (stream, _("\
13673   -mlfence-before-ret=[none|or|not|shl|yes] (default: none)\n\
13674                           generate lfence before ret\n"));
13675   fprintf (stream, _("\
13676   -mamd64                 accept only AMD64 ISA [default]\n"));
13677   fprintf (stream, _("\
13678   -mintel64               accept only Intel64 ISA\n"));
13679 }
13680
13681 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
13682      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
13683      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
13684
13685 /* Pick the target format to use.  */
13686
13687 const char *
13688 i386_target_format (void)
13689 {
13690   if (!strncmp (default_arch, "x86_64", 6))
13691     {
13692       update_code_flag (CODE_64BIT, 1);
13693       if (default_arch[6] == '\0')
13694         x86_elf_abi = X86_64_ABI;
13695       else
13696         x86_elf_abi = X86_64_X32_ABI;
13697     }
13698   else if (!strcmp (default_arch, "i386"))
13699     update_code_flag (CODE_32BIT, 1);
13700   else if (!strcmp (default_arch, "iamcu"))
13701     {
13702       update_code_flag (CODE_32BIT, 1);
13703       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
13704         {
13705           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
13706           cpu_arch_name = "iamcu";
13707           cpu_sub_arch_name = NULL;
13708           cpu_arch_flags = iamcu_flags;
13709           cpu_arch_isa = PROCESSOR_IAMCU;
13710           cpu_arch_isa_flags = iamcu_flags;
13711           if (!cpu_arch_tune_set)
13712             {
13713               cpu_arch_tune = cpu_arch_isa;
13714               cpu_arch_tune_flags = cpu_arch_isa_flags;
13715             }
13716         }
13717       else if (cpu_arch_isa != PROCESSOR_IAMCU)
13718         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
13719                   cpu_arch_name);
13720     }
13721   else
13722     as_fatal (_("unknown architecture"));
13723
13724   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
13725     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
13726   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
13727     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
13728
13729   switch (OUTPUT_FLAVOR)
13730     {
13731 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
13732     case bfd_target_aout_flavour:
13733       return AOUT_TARGET_FORMAT;
13734 #endif
13735 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
13736 # if defined (TE_PE) || defined (TE_PEP)
13737     case bfd_target_coff_flavour:
13738       if (flag_code == CODE_64BIT)
13739         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
13740       else
13741         return use_big_obj ? "pe-bigobj-i386" : "pe-i386";
13742 # elif defined (TE_GO32)
13743     case bfd_target_coff_flavour:
13744       return "coff-go32";
13745 # else
13746     case bfd_target_coff_flavour:
13747       return "coff-i386";
13748 # endif
13749 #endif
13750 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
13751     case bfd_target_elf_flavour:
13752       {
13753         const char *format;
13754
13755         switch (x86_elf_abi)
13756           {
13757           default:
13758             format = ELF_TARGET_FORMAT;
13759 #ifndef TE_SOLARIS
13760             tls_get_addr = "___tls_get_addr";
13761 #endif
13762             break;
13763           case X86_64_ABI:
13764             use_rela_relocations = 1;
13765             object_64bit = 1;
13766 #ifndef TE_SOLARIS
13767             tls_get_addr = "__tls_get_addr";
13768 #endif
13769             format = ELF_TARGET_FORMAT64;
13770             break;
13771           case X86_64_X32_ABI:
13772             use_rela_relocations = 1;
13773             object_64bit = 1;
13774 #ifndef TE_SOLARIS
13775             tls_get_addr = "__tls_get_addr";
13776 #endif
13777             disallow_64bit_reloc = 1;
13778             format = ELF_TARGET_FORMAT32;
13779             break;
13780           }
13781         if (cpu_arch_isa == PROCESSOR_L1OM)
13782           {
13783             if (x86_elf_abi != X86_64_ABI)
13784               as_fatal (_("Intel L1OM is 64bit only"));
13785             return ELF_TARGET_L1OM_FORMAT;
13786           }
13787         else if (cpu_arch_isa == PROCESSOR_K1OM)
13788           {
13789             if (x86_elf_abi != X86_64_ABI)
13790               as_fatal (_("Intel K1OM is 64bit only"));
13791             return ELF_TARGET_K1OM_FORMAT;
13792           }
13793         else if (cpu_arch_isa == PROCESSOR_IAMCU)
13794           {
13795             if (x86_elf_abi != I386_ABI)
13796               as_fatal (_("Intel MCU is 32bit only"));
13797             return ELF_TARGET_IAMCU_FORMAT;
13798           }
13799         else
13800           return format;
13801       }
13802 #endif
13803 #if defined (OBJ_MACH_O)
13804     case bfd_target_mach_o_flavour:
13805       if (flag_code == CODE_64BIT)
13806         {
13807           use_rela_relocations = 1;
13808           object_64bit = 1;
13809           return "mach-o-x86-64";
13810         }
13811       else
13812         return "mach-o-i386";
13813 #endif
13814     default:
13815       abort ();
13816       return NULL;
13817     }
13818 }
13819
13820 #endif /* OBJ_MAYBE_ more than one  */
13821 \f
13822 symbolS *
13823 md_undefined_symbol (char *name)
13824 {
13825   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
13826       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
13827       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
13828       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
13829     {
13830       if (!GOT_symbol)
13831         {
13832           if (symbol_find (name))
13833             as_bad (_("GOT already in symbol table"));
13834           GOT_symbol = symbol_new (name, undefined_section,
13835                                    &zero_address_frag, 0);
13836         };
13837       return GOT_symbol;
13838     }
13839   return 0;
13840 }
13841
13842 /* Round up a section size to the appropriate boundary.  */
13843
13844 valueT
13845 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
13846 {
13847 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
13848   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
13849     {
13850       /* For a.out, force the section size to be aligned.  If we don't do
13851          this, BFD will align it for us, but it will not write out the
13852          final bytes of the section.  This may be a bug in BFD, but it is
13853          easier to fix it here since that is how the other a.out targets
13854          work.  */
13855       int align;
13856
13857       align = bfd_section_alignment (segment);
13858       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
13859     }
13860 #endif
13861
13862   return size;
13863 }
13864
13865 /* On the i386, PC-relative offsets are relative to the start of the
13866    next instruction.  That is, the address of the offset, plus its
13867    size, since the offset is always the last part of the insn.  */
13868
13869 long
13870 md_pcrel_from (fixS *fixP)
13871 {
13872   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
13873 }
13874
13875 #ifndef I386COFF
13876
13877 static void
13878 s_bss (int ignore ATTRIBUTE_UNUSED)
13879 {
13880   int temp;
13881
13882 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13883   if (IS_ELF)
13884     obj_elf_section_change_hook ();
13885 #endif
13886   temp = get_absolute_expression ();
13887   subseg_set (bss_section, (subsegT) temp);
13888   demand_empty_rest_of_line ();
13889 }
13890
13891 #endif
13892
13893 /* Remember constant directive.  */
13894
13895 void
13896 i386_cons_align (int ignore ATTRIBUTE_UNUSED)
13897 {
13898   if (last_insn.kind != last_insn_directive
13899       && (bfd_section_flags (now_seg) & SEC_CODE))
13900     {
13901       last_insn.seg = now_seg;
13902       last_insn.kind = last_insn_directive;
13903       last_insn.name = "constant directive";
13904       last_insn.file = as_where (&last_insn.line);
13905       if (lfence_before_ret != lfence_before_ret_none)
13906         {
13907           if (lfence_before_indirect_branch != lfence_branch_none)
13908             as_warn (_("constant directive skips -mlfence-before-ret "
13909                        "and -mlfence-before-indirect-branch"));
13910           else
13911             as_warn (_("constant directive skips -mlfence-before-ret"));
13912         }
13913       else if (lfence_before_indirect_branch != lfence_branch_none)
13914         as_warn (_("constant directive skips -mlfence-before-indirect-branch"));
13915     }
13916 }
13917
13918 void
13919 i386_validate_fix (fixS *fixp)
13920 {
13921   if (fixp->fx_subsy)
13922     {
13923       if (fixp->fx_subsy == GOT_symbol)
13924         {
13925           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
13926             {
13927               if (!object_64bit)
13928                 abort ();
13929 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13930               if (fixp->fx_tcbit2)
13931                 fixp->fx_r_type = (fixp->fx_tcbit
13932                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
13933                                    : BFD_RELOC_X86_64_GOTPCRELX);
13934               else
13935 #endif
13936                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
13937             }
13938           else
13939             {
13940               if (!object_64bit)
13941                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
13942               else
13943                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
13944             }
13945           fixp->fx_subsy = 0;
13946         }
13947     }
13948 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13949   else
13950     {
13951       /* NB: Commit 292676c1 resolved PLT32 reloc aganst local symbol
13952          to section.  Since PLT32 relocation must be against symbols,
13953          turn such PLT32 relocation into PC32 relocation.  */
13954       if (fixp->fx_addsy
13955           && (fixp->fx_r_type == BFD_RELOC_386_PLT32
13956               || fixp->fx_r_type == BFD_RELOC_X86_64_PLT32)
13957           && symbol_section_p (fixp->fx_addsy))
13958         fixp->fx_r_type = BFD_RELOC_32_PCREL;
13959       if (!object_64bit)
13960         {
13961           if (fixp->fx_r_type == BFD_RELOC_386_GOT32
13962               && fixp->fx_tcbit2)
13963             fixp->fx_r_type = BFD_RELOC_386_GOT32X;
13964         }
13965     }
13966 #endif
13967 }
13968
13969 arelent *
13970 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
13971 {
13972   arelent *rel;
13973   bfd_reloc_code_real_type code;
13974
13975   switch (fixp->fx_r_type)
13976     {
13977 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13978     case BFD_RELOC_SIZE32:
13979     case BFD_RELOC_SIZE64:
13980       if (S_IS_DEFINED (fixp->fx_addsy)
13981           && !S_IS_EXTERNAL (fixp->fx_addsy))
13982         {
13983           /* Resolve size relocation against local symbol to size of
13984              the symbol plus addend.  */
13985           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
13986           if (fixp->fx_r_type == BFD_RELOC_SIZE32
13987               && !fits_in_unsigned_long (value))
13988             as_bad_where (fixp->fx_file, fixp->fx_line,
13989                           _("symbol size computation overflow"));
13990           fixp->fx_addsy = NULL;
13991           fixp->fx_subsy = NULL;
13992           md_apply_fix (fixp, (valueT *) &value, NULL);
13993           return NULL;
13994         }
13995 #endif
13996       /* Fall through.  */
13997
13998     case BFD_RELOC_X86_64_PLT32:
13999     case BFD_RELOC_X86_64_GOT32:
14000     case BFD_RELOC_X86_64_GOTPCREL:
14001     case BFD_RELOC_X86_64_GOTPCRELX:
14002     case BFD_RELOC_X86_64_REX_GOTPCRELX:
14003     case BFD_RELOC_386_PLT32:
14004     case BFD_RELOC_386_GOT32:
14005     case BFD_RELOC_386_GOT32X:
14006     case BFD_RELOC_386_GOTOFF:
14007     case BFD_RELOC_386_GOTPC:
14008     case BFD_RELOC_386_TLS_GD:
14009     case BFD_RELOC_386_TLS_LDM:
14010     case BFD_RELOC_386_TLS_LDO_32:
14011     case BFD_RELOC_386_TLS_IE_32:
14012     case BFD_RELOC_386_TLS_IE:
14013     case BFD_RELOC_386_TLS_GOTIE:
14014     case BFD_RELOC_386_TLS_LE_32:
14015     case BFD_RELOC_386_TLS_LE:
14016     case BFD_RELOC_386_TLS_GOTDESC:
14017     case BFD_RELOC_386_TLS_DESC_CALL:
14018     case BFD_RELOC_X86_64_TLSGD:
14019     case BFD_RELOC_X86_64_TLSLD:
14020     case BFD_RELOC_X86_64_DTPOFF32:
14021     case BFD_RELOC_X86_64_DTPOFF64:
14022     case BFD_RELOC_X86_64_GOTTPOFF:
14023     case BFD_RELOC_X86_64_TPOFF32:
14024     case BFD_RELOC_X86_64_TPOFF64:
14025     case BFD_RELOC_X86_64_GOTOFF64:
14026     case BFD_RELOC_X86_64_GOTPC32:
14027     case BFD_RELOC_X86_64_GOT64:
14028     case BFD_RELOC_X86_64_GOTPCREL64:
14029     case BFD_RELOC_X86_64_GOTPC64:
14030     case BFD_RELOC_X86_64_GOTPLT64:
14031     case BFD_RELOC_X86_64_PLTOFF64:
14032     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
14033     case BFD_RELOC_X86_64_TLSDESC_CALL:
14034     case BFD_RELOC_RVA:
14035     case BFD_RELOC_VTABLE_ENTRY:
14036     case BFD_RELOC_VTABLE_INHERIT:
14037 #ifdef TE_PE
14038     case BFD_RELOC_32_SECREL:
14039 #endif
14040       code = fixp->fx_r_type;
14041       break;
14042     case BFD_RELOC_X86_64_32S:
14043       if (!fixp->fx_pcrel)
14044         {
14045           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
14046           code = fixp->fx_r_type;
14047           break;
14048         }
14049       /* Fall through.  */
14050     default:
14051       if (fixp->fx_pcrel)
14052         {
14053           switch (fixp->fx_size)
14054             {
14055             default:
14056               as_bad_where (fixp->fx_file, fixp->fx_line,
14057                             _("can not do %d byte pc-relative relocation"),
14058                             fixp->fx_size);
14059               code = BFD_RELOC_32_PCREL;
14060               break;
14061             case 1: code = BFD_RELOC_8_PCREL;  break;
14062             case 2: code = BFD_RELOC_16_PCREL; break;
14063             case 4: code = BFD_RELOC_32_PCREL; break;
14064 #ifdef BFD64
14065             case 8: code = BFD_RELOC_64_PCREL; break;
14066 #endif
14067             }
14068         }
14069       else
14070         {
14071           switch (fixp->fx_size)
14072             {
14073             default:
14074               as_bad_where (fixp->fx_file, fixp->fx_line,
14075                             _("can not do %d byte relocation"),
14076                             fixp->fx_size);
14077               code = BFD_RELOC_32;
14078               break;
14079             case 1: code = BFD_RELOC_8;  break;
14080             case 2: code = BFD_RELOC_16; break;
14081             case 4: code = BFD_RELOC_32; break;
14082 #ifdef BFD64
14083             case 8: code = BFD_RELOC_64; break;
14084 #endif
14085             }
14086         }
14087       break;
14088     }
14089
14090   if ((code == BFD_RELOC_32
14091        || code == BFD_RELOC_32_PCREL
14092        || code == BFD_RELOC_X86_64_32S)
14093       && GOT_symbol
14094       && fixp->fx_addsy == GOT_symbol)
14095     {
14096       if (!object_64bit)
14097         code = BFD_RELOC_386_GOTPC;
14098       else
14099         code = BFD_RELOC_X86_64_GOTPC32;
14100     }
14101   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
14102       && GOT_symbol
14103       && fixp->fx_addsy == GOT_symbol)
14104     {
14105       code = BFD_RELOC_X86_64_GOTPC64;
14106     }
14107
14108   rel = XNEW (arelent);
14109   rel->sym_ptr_ptr = XNEW (asymbol *);
14110   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
14111
14112   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
14113
14114   if (!use_rela_relocations)
14115     {
14116       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
14117          vtable entry to be used in the relocation's section offset.  */
14118       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
14119         rel->address = fixp->fx_offset;
14120 #if defined (OBJ_COFF) && defined (TE_PE)
14121       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
14122         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
14123       else
14124 #endif
14125       rel->addend = 0;
14126     }
14127   /* Use the rela in 64bit mode.  */
14128   else
14129     {
14130       if (disallow_64bit_reloc)
14131         switch (code)
14132           {
14133           case BFD_RELOC_X86_64_DTPOFF64:
14134           case BFD_RELOC_X86_64_TPOFF64:
14135           case BFD_RELOC_64_PCREL:
14136           case BFD_RELOC_X86_64_GOTOFF64:
14137           case BFD_RELOC_X86_64_GOT64:
14138           case BFD_RELOC_X86_64_GOTPCREL64:
14139           case BFD_RELOC_X86_64_GOTPC64:
14140           case BFD_RELOC_X86_64_GOTPLT64:
14141           case BFD_RELOC_X86_64_PLTOFF64:
14142             as_bad_where (fixp->fx_file, fixp->fx_line,
14143                           _("cannot represent relocation type %s in x32 mode"),
14144                           bfd_get_reloc_code_name (code));
14145             break;
14146           default:
14147             break;
14148           }
14149
14150       if (!fixp->fx_pcrel)
14151         rel->addend = fixp->fx_offset;
14152       else
14153         switch (code)
14154           {
14155           case BFD_RELOC_X86_64_PLT32:
14156           case BFD_RELOC_X86_64_GOT32:
14157           case BFD_RELOC_X86_64_GOTPCREL:
14158           case BFD_RELOC_X86_64_GOTPCRELX:
14159           case BFD_RELOC_X86_64_REX_GOTPCRELX:
14160           case BFD_RELOC_X86_64_TLSGD:
14161           case BFD_RELOC_X86_64_TLSLD:
14162           case BFD_RELOC_X86_64_GOTTPOFF:
14163           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
14164           case BFD_RELOC_X86_64_TLSDESC_CALL:
14165             rel->addend = fixp->fx_offset - fixp->fx_size;
14166             break;
14167           default:
14168             rel->addend = (section->vma
14169                            - fixp->fx_size
14170                            + fixp->fx_addnumber
14171                            + md_pcrel_from (fixp));
14172             break;
14173           }
14174     }
14175
14176   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
14177   if (rel->howto == NULL)
14178     {
14179       as_bad_where (fixp->fx_file, fixp->fx_line,
14180                     _("cannot represent relocation type %s"),
14181                     bfd_get_reloc_code_name (code));
14182       /* Set howto to a garbage value so that we can keep going.  */
14183       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
14184       gas_assert (rel->howto != NULL);
14185     }
14186
14187   return rel;
14188 }
14189
14190 #include "tc-i386-intel.c"
14191
14192 void
14193 tc_x86_parse_to_dw2regnum (expressionS *exp)
14194 {
14195   int saved_naked_reg;
14196   char saved_register_dot;
14197
14198   saved_naked_reg = allow_naked_reg;
14199   allow_naked_reg = 1;
14200   saved_register_dot = register_chars['.'];
14201   register_chars['.'] = '.';
14202   allow_pseudo_reg = 1;
14203   expression_and_evaluate (exp);
14204   allow_pseudo_reg = 0;
14205   register_chars['.'] = saved_register_dot;
14206   allow_naked_reg = saved_naked_reg;
14207
14208   if (exp->X_op == O_register && exp->X_add_number >= 0)
14209     {
14210       if ((addressT) exp->X_add_number < i386_regtab_size)
14211         {
14212           exp->X_op = O_constant;
14213           exp->X_add_number = i386_regtab[exp->X_add_number]
14214                               .dw2_regnum[flag_code >> 1];
14215         }
14216       else
14217         exp->X_op = O_illegal;
14218     }
14219 }
14220
14221 void
14222 tc_x86_frame_initial_instructions (void)
14223 {
14224   static unsigned int sp_regno[2];
14225
14226   if (!sp_regno[flag_code >> 1])
14227     {
14228       char *saved_input = input_line_pointer;
14229       char sp[][4] = {"esp", "rsp"};
14230       expressionS exp;
14231
14232       input_line_pointer = sp[flag_code >> 1];
14233       tc_x86_parse_to_dw2regnum (&exp);
14234       gas_assert (exp.X_op == O_constant);
14235       sp_regno[flag_code >> 1] = exp.X_add_number;
14236       input_line_pointer = saved_input;
14237     }
14238
14239   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
14240   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
14241 }
14242
14243 int
14244 x86_dwarf2_addr_size (void)
14245 {
14246 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
14247   if (x86_elf_abi == X86_64_X32_ABI)
14248     return 4;
14249 #endif
14250   return bfd_arch_bits_per_address (stdoutput) / 8;
14251 }
14252
14253 int
14254 i386_elf_section_type (const char *str, size_t len)
14255 {
14256   if (flag_code == CODE_64BIT
14257       && len == sizeof ("unwind") - 1
14258       && strncmp (str, "unwind", 6) == 0)
14259     return SHT_X86_64_UNWIND;
14260
14261   return -1;
14262 }
14263
14264 #ifdef TE_SOLARIS
14265 void
14266 i386_solaris_fix_up_eh_frame (segT sec)
14267 {
14268   if (flag_code == CODE_64BIT)
14269     elf_section_type (sec) = SHT_X86_64_UNWIND;
14270 }
14271 #endif
14272
14273 #ifdef TE_PE
14274 void
14275 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
14276 {
14277   expressionS exp;
14278
14279   exp.X_op = O_secrel;
14280   exp.X_add_symbol = symbol;
14281   exp.X_add_number = 0;
14282   emit_expr (&exp, size);
14283 }
14284 #endif
14285
14286 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
14287 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
14288
14289 bfd_vma
14290 x86_64_section_letter (int letter, const char **ptr_msg)
14291 {
14292   if (flag_code == CODE_64BIT)
14293     {
14294       if (letter == 'l')
14295         return SHF_X86_64_LARGE;
14296
14297       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
14298     }
14299   else
14300     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
14301   return -1;
14302 }
14303
14304 bfd_vma
14305 x86_64_section_word (char *str, size_t len)
14306 {
14307   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
14308     return SHF_X86_64_LARGE;
14309
14310   return -1;
14311 }
14312
14313 static void
14314 handle_large_common (int small ATTRIBUTE_UNUSED)
14315 {
14316   if (flag_code != CODE_64BIT)
14317     {
14318       s_comm_internal (0, elf_common_parse);
14319       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
14320     }
14321   else
14322     {
14323       static segT lbss_section;
14324       asection *saved_com_section_ptr = elf_com_section_ptr;
14325       asection *saved_bss_section = bss_section;
14326
14327       if (lbss_section == NULL)
14328         {
14329           flagword applicable;
14330           segT seg = now_seg;
14331           subsegT subseg = now_subseg;
14332
14333           /* The .lbss section is for local .largecomm symbols.  */
14334           lbss_section = subseg_new (".lbss", 0);
14335           applicable = bfd_applicable_section_flags (stdoutput);
14336           bfd_set_section_flags (lbss_section, applicable & SEC_ALLOC);
14337           seg_info (lbss_section)->bss = 1;
14338
14339           subseg_set (seg, subseg);
14340         }
14341
14342       elf_com_section_ptr = &_bfd_elf_large_com_section;
14343       bss_section = lbss_section;
14344
14345       s_comm_internal (0, elf_common_parse);
14346
14347       elf_com_section_ptr = saved_com_section_ptr;
14348       bss_section = saved_bss_section;
14349     }
14350 }
14351 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */