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 or 32bit displacement in encoding.  */
 413     enum
 414       {
 415         disp_encoding_default = 0,
 416         disp_encoding_8bit,
 417         disp_encoding_32bit
 418       } disp_encoding;
 419
 420     /* Prefer the REX byte in encoding.  */
 421     bfd_boolean rex_encoding;
 422
 423     /* Disable instruction size optimization.  */
 424     bfd_boolean no_optimize;
 425
 426     /* How to encode vector instructions.  */
 427     enum
 428       {
 429         vex_encoding_default = 0,
 430         vex_encoding_vex,
 431         vex_encoding_vex3,
 432         vex_encoding_evex,
 433         vex_encoding_error
 434       } vec_encoding;
 435
 436     /* REP prefix.  */
 437     const char *rep_prefix;
 438
 439     /* HLE prefix.  */
 440     const char *hle_prefix;
 441
 442     /* Have BND prefix.  */
 443     const char *bnd_prefix;
 444
 445     /* Have NOTRACK prefix.  */
 446     const char *notrack_prefix;
 447
 448     /* Error message.  */
 449     enum i386_error error;
 450   };
 451
 452 typedef struct _i386_insn i386_insn;
 453
 454 /* Link RC type with corresponding string, that'll be looked for in
 455    asm.  */
 456 struct RC_name
 457 {
 458   enum rc_type type;
 459   const char *name;
 460   unsigned int len;
 461 };
 462
 463 static const struct RC_name RC_NamesTable[] =
 464 {
 465   {  rne, STRING_COMMA_LEN ("rn-sae") },
 466   {  rd,  STRING_COMMA_LEN ("rd-sae") },
 467   {  ru,  STRING_COMMA_LEN ("ru-sae") },
 468   {  rz,  STRING_COMMA_LEN ("rz-sae") },
 469   {  saeonly,  STRING_COMMA_LEN ("sae") },
 470 };
 471
 472 /* List of chars besides those in app.c:symbol_chars that can start an
 473    operand.  Used to prevent the scrubber eating vital white-space.  */
 474 const char extra_symbol_chars[] = "*%-([{}"
 475 #ifdef LEX_AT
 476         "@"
 477 #endif
 478 #ifdef LEX_QM
 479         "?"
 480 #endif
 481         ;
 482
 483 #if ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))     \
 484      && !defined (TE_GNU)                               \
 485      && !defined (TE_LINUX)                             \
 486      && !defined (TE_FreeBSD)                           \
 487      && !defined (TE_DragonFly)                         \
 488      && !defined (TE_NetBSD))
 489 /* This array holds the chars that always start a comment.  If the
 490    pre-processor is disabled, these aren't very useful.  The option
 491    --divide will remove '/' from this list.  */
 492 const char *i386_comment_chars = "#/";
 493 #define SVR4_COMMENT_CHARS 1
 494 #define PREFIX_SEPARATOR '\\'
 495
 496 #else
 497 const char *i386_comment_chars = "#";
 498 #define PREFIX_SEPARATOR '/'
 499 #endif
 500
 501 /* This array holds the chars that only start a comment at the beginning of
 502    a line.  If the line seems to have the form '# 123 filename'
 503    .line and .file directives will appear in the pre-processed output.
 504    Note that input_file.c hand checks for '#' at the beginning of the
 505    first line of the input file.  This is because the compiler outputs
 506    #NO_APP at the beginning of its output.
 507    Also note that comments started like this one will always work if
 508    '/' isn't otherwise defined.  */
 509 const char line_comment_chars[] = "#/";
 510
 511 const char line_separator_chars[] = ";";
 512
 513 /* Chars that can be used to separate mant from exp in floating point
 514    nums.  */
 515 const char EXP_CHARS[] = "eE";
 516
 517 /* Chars that mean this number is a floating point constant
 518    As in 0f12.456
 519    or    0d1.2345e12.  */
 520 const char FLT_CHARS[] = "fFdDxX";
 521
 522 /* Tables for lexical analysis.  */
 523 static char mnemonic_chars[256];
 524 static char register_chars[256];
 525 static char operand_chars[256];
 526 static char identifier_chars[256];
 527 static char digit_chars[256];
 528
 529 /* Lexical macros.  */
 530 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 531 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 532 #define is_register_char(x) (register_chars[(unsigned char) x])
 533 #define is_space_char(x) ((x) == ' ')
 534 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 535 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 536
 537 /* All non-digit non-letter characters that may occur in an operand.  */
 538 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 539
 540 /* md_assemble() always leaves the strings it's passed unaltered.  To
 541    effect this we maintain a stack of saved characters that we've smashed
 542    with '\0's (indicating end of strings for various sub-fields of the
 543    assembler instruction).  */
 544 static char save_stack[32];
 545 static char *save_stack_p;
 546 #define END_STRING_AND_SAVE(s) \
 547         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 548 #define RESTORE_END_STRING(s) \
 549         do { *(s) = *--save_stack_p; } while (0)
 550
 551 /* The instruction we're assembling.  */
 552 static i386_insn i;
 553
 554 /* Possible templates for current insn.  */
 555 static const templates *current_templates;
 556
 557 /* Per instruction expressionS buffers: max displacements & immediates.  */
 558 static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
 559 static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
 560
 561 /* Current operand we are working on.  */
 562 static int this_operand = -1;
 563
 564 /* We support four different modes.  FLAG_CODE variable is used to distinguish
 565    these.  */
 566
 567 enum flag_code {
 568         CODE_32BIT,
 569         CODE_16BIT,
 570         CODE_64BIT };
 571
 572 static enum flag_code flag_code;
 573 static unsigned int object_64bit;
 574 static unsigned int disallow_64bit_reloc;
 575 static int use_rela_relocations = 0;
 576 /* __tls_get_addr/___tls_get_addr symbol for TLS.  */
 577 static const char *tls_get_addr;
 578
 579 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
 580      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
 581      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
 582
 583 /* The ELF ABI to use.  */
 584 enum x86_elf_abi
 585 {
 586   I386_ABI,
 587   X86_64_ABI,
 588   X86_64_X32_ABI
 589 };
 590
 591 static enum x86_elf_abi x86_elf_abi = I386_ABI;
 592 #endif
 593
 594 #if defined (TE_PE) || defined (TE_PEP)
 595 /* Use big object file format.  */
 596 static int use_big_obj = 0;
 597 #endif
 598
 599 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 600 /* 1 if generating code for a shared library.  */
 601 static int shared = 0;
 602 #endif
 603
 604 /* 1 for intel syntax,
 605    0 if att syntax.  */
 606 static int intel_syntax = 0;
 607
 608 static enum x86_64_isa
 609 {
 610   amd64 = 1,    /* AMD64 ISA.  */
 611   intel64       /* Intel64 ISA.  */
 612 } isa64;
 613
 614 /* 1 for intel mnemonic,
 615    0 if att mnemonic.  */
 616 static int intel_mnemonic = !SYSV386_COMPAT;
 617
 618 /* 1 if pseudo registers are permitted.  */
 619 static int allow_pseudo_reg = 0;
 620
 621 /* 1 if register prefix % not required.  */
 622 static int allow_naked_reg = 0;
 623
 624 /* 1 if the assembler should add BND prefix for all control-transferring
 625    instructions supporting it, even if this prefix wasn't specified
 626    explicitly.  */
 627 static int add_bnd_prefix = 0;
 628
 629 /* 1 if pseudo index register, eiz/riz, is allowed .  */
 630 static int allow_index_reg = 0;
 631
 632 /* 1 if the assembler should ignore LOCK prefix, even if it was
 633    specified explicitly.  */
 634 static int omit_lock_prefix = 0;
 635
 636 /* 1 if the assembler should encode lfence, mfence, and sfence as
 637    "lock addl $0, (%{re}sp)".  */
 638 static int avoid_fence = 0;
 639
 640 /* 1 if lfence should be inserted after every load.  */
 641 static int lfence_after_load = 0;
 642
 643 /* Non-zero if lfence should be inserted before indirect branch.  */
 644 static enum lfence_before_indirect_branch_kind
 645   {
 646     lfence_branch_none = 0,
 647     lfence_branch_register,
 648     lfence_branch_memory,
 649     lfence_branch_all
 650   }
 651 lfence_before_indirect_branch;
 652
 653 /* Non-zero if lfence should be inserted before ret.  */
 654 static enum lfence_before_ret_kind
 655   {
 656     lfence_before_ret_none = 0,
 657     lfence_before_ret_not,
 658     lfence_before_ret_or,
 659     lfence_before_ret_shl
 660   }
 661 lfence_before_ret;
 662
 663 /* Types of previous instruction is .byte or prefix.  */
 664 static struct
 665   {
 666     segT seg;
 667     const char *file;
 668     const char *name;
 669     unsigned int line;
 670     enum last_insn_kind
 671       {
 672         last_insn_other = 0,
 673         last_insn_directive,
 674         last_insn_prefix
 675       } kind;
 676   } last_insn;
 677
 678 /* 1 if the assembler should generate relax relocations.  */
 679
 680 static int generate_relax_relocations
 681   = DEFAULT_GENERATE_X86_RELAX_RELOCATIONS;
 682
 683 static enum check_kind
 684   {
 685     check_none = 0,
 686     check_warning,
 687     check_error
 688   }
 689 sse_check, operand_check = check_warning;
 690
 691 /* Non-zero if branches should be aligned within power of 2 boundary.  */
 692 static int align_branch_power = 0;
 693
 694 /* Types of branches to align.  */
 695 enum align_branch_kind
 696   {
 697     align_branch_none = 0,
 698     align_branch_jcc = 1,
 699     align_branch_fused = 2,
 700     align_branch_jmp = 3,
 701     align_branch_call = 4,
 702     align_branch_indirect = 5,
 703     align_branch_ret = 6
 704   };
 705
 706 /* Type bits of branches to align.  */
 707 enum align_branch_bit
 708   {
 709     align_branch_jcc_bit = 1 << align_branch_jcc,
 710     align_branch_fused_bit = 1 << align_branch_fused,
 711     align_branch_jmp_bit = 1 << align_branch_jmp,
 712     align_branch_call_bit = 1 << align_branch_call,
 713     align_branch_indirect_bit = 1 << align_branch_indirect,
 714     align_branch_ret_bit = 1 << align_branch_ret
 715   };
 716
 717 static unsigned int align_branch = (align_branch_jcc_bit
 718                                     | align_branch_fused_bit
 719                                     | align_branch_jmp_bit);
 720
 721 /* Types of condition jump used by macro-fusion.  */
 722 enum mf_jcc_kind
 723   {
 724     mf_jcc_jo = 0,  /* base opcode 0x70  */
 725     mf_jcc_jc,      /* base opcode 0x72  */
 726     mf_jcc_je,      /* base opcode 0x74  */
 727     mf_jcc_jna,     /* base opcode 0x76  */
 728     mf_jcc_js,      /* base opcode 0x78  */
 729     mf_jcc_jp,      /* base opcode 0x7a  */
 730     mf_jcc_jl,      /* base opcode 0x7c  */
 731     mf_jcc_jle,     /* base opcode 0x7e  */
 732   };
 733
 734 /* Types of compare flag-modifying insntructions used by macro-fusion.  */
 735 enum mf_cmp_kind
 736   {
 737     mf_cmp_test_and,  /* test/cmp */
 738     mf_cmp_alu_cmp,  /* add/sub/cmp */
 739     mf_cmp_incdec  /* inc/dec */
 740   };
 741
 742 /* The maximum padding size for fused jcc.  CMP like instruction can
 743    be 9 bytes and jcc can be 6 bytes.  Leave room just in case for
 744    prefixes.   */
 745 #define MAX_FUSED_JCC_PADDING_SIZE 20
 746
 747 /* The maximum number of prefixes added for an instruction.  */
 748 static unsigned int align_branch_prefix_size = 5;
 749
 750 /* Optimization:
 751    1. Clear the REX_W bit with register operand if possible.
 752    2. Above plus use 128bit vector instruction to clear the full vector
 753       register.
 754  */
 755 static int optimize = 0;
 756
 757 /* Optimization:
 758    1. Clear the REX_W bit with register operand if possible.
 759    2. Above plus use 128bit vector instruction to clear the full vector
 760       register.
 761    3. Above plus optimize "test{q,l,w} $imm8,%r{64,32,16}" to
 762       "testb $imm7,%r8".
 763  */
 764 static int optimize_for_space = 0;
 765
 766 /* Register prefix used for error message.  */
 767 static const char *register_prefix = "%";
 768
 769 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
 770    leave, push, and pop instructions so that gcc has the same stack
 771    frame as in 32 bit mode.  */
 772 static char stackop_size = '\0';
 773
 774 /* Non-zero to optimize code alignment.  */
 775 int optimize_align_code = 1;
 776
 777 /* Non-zero to quieten some warnings.  */
 778 static int quiet_warnings = 0;
 779
 780 /* CPU name.  */
 781 static const char *cpu_arch_name = NULL;
 782 static char *cpu_sub_arch_name = NULL;
 783
 784 /* CPU feature flags.  */
 785 static i386_cpu_flags cpu_arch_flags = CPU_UNKNOWN_FLAGS;
 786
 787 /* If we have selected a cpu we are generating instructions for.  */
 788 static int cpu_arch_tune_set = 0;
 789
 790 /* Cpu we are generating instructions for.  */
 791 enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
 792
 793 /* CPU feature flags of cpu we are generating instructions for.  */
 794 static i386_cpu_flags cpu_arch_tune_flags;
 795
 796 /* CPU instruction set architecture used.  */
 797 enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
 798
 799 /* CPU feature flags of instruction set architecture used.  */
 800 i386_cpu_flags cpu_arch_isa_flags;
 801
 802 /* If set, conditional jumps are not automatically promoted to handle
 803    larger than a byte offset.  */
 804 static unsigned int no_cond_jump_promotion = 0;
 805
 806 /* Encode SSE instructions with VEX prefix.  */
 807 static unsigned int sse2avx;
 808
 809 /* Encode scalar AVX instructions with specific vector length.  */
 810 static enum
 811   {
 812     vex128 = 0,
 813     vex256
 814   } avxscalar;
 815
 816 /* Encode VEX WIG instructions with specific vex.w.  */
 817 static enum
 818   {
 819     vexw0 = 0,
 820     vexw1
 821   } vexwig;
 822
 823 /* Encode scalar EVEX LIG instructions with specific vector length.  */
 824 static enum
 825   {
 826     evexl128 = 0,
 827     evexl256,
 828     evexl512
 829   } evexlig;
 830
 831 /* Encode EVEX WIG instructions with specific evex.w.  */
 832 static enum
 833   {
 834     evexw0 = 0,
 835     evexw1
 836   } evexwig;
 837
 838 /* Value to encode in EVEX RC bits, for SAE-only instructions.  */
 839 static enum rc_type evexrcig = rne;
 840
 841 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 842 static symbolS *GOT_symbol;
 843
 844 /* The dwarf2 return column, adjusted for 32 or 64 bit.  */
 845 unsigned int x86_dwarf2_return_column;
 846
 847 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
 848 int x86_cie_data_alignment;
 849
 850 /* Interface to relax_segment.
 851    There are 3 major relax states for 386 jump insns because the
 852    different types of jumps add different sizes to frags when we're
 853    figuring out what sort of jump to choose to reach a given label.
 854
 855    BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING are used to align
 856    branches which are handled by md_estimate_size_before_relax() and
 857    i386_generic_table_relax_frag().  */
 858
 859 /* Types.  */
 860 #define UNCOND_JUMP 0
 861 #define COND_JUMP 1
 862 #define COND_JUMP86 2
 863 #define BRANCH_PADDING 3
 864 #define BRANCH_PREFIX 4
 865 #define FUSED_JCC_PADDING 5
 866
 867 /* Sizes.  */
 868 #define CODE16  1
 869 #define SMALL   0
 870 #define SMALL16 (SMALL | CODE16)
 871 #define BIG     2
 872 #define BIG16   (BIG | CODE16)
 873
 874 #ifndef INLINE
 875 #ifdef __GNUC__
 876 #define INLINE __inline__
 877 #else
 878 #define INLINE
 879 #endif
 880 #endif
 881
 882 #define ENCODE_RELAX_STATE(type, size) \
 883   ((relax_substateT) (((type) << 2) | (size)))
 884 #define TYPE_FROM_RELAX_STATE(s) \
 885   ((s) >> 2)
 886 #define DISP_SIZE_FROM_RELAX_STATE(s) \
 887     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
 888
 889 /* This table is used by relax_frag to promote short jumps to long
 890    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 891    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 892    don't allow a short jump in a 32 bit code segment to be promoted to
 893    a 16 bit offset jump because it's slower (requires data size
 894    prefix), and doesn't work, unless the destination is in the bottom
 895    64k of the code segment (The top 16 bits of eip are zeroed).  */
 896
 897 const relax_typeS md_relax_table[] =
 898 {
 899   /* The fields are:
 900      1) most positive reach of this state,
 901      2) most negative reach of this state,
 902      3) how many bytes this mode will have in the variable part of the frag
 903      4) which index into the table to try if we can't fit into this one.  */
 904
 905   /* UNCOND_JUMP states.  */
 906   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 907   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 908   /* dword jmp adds 4 bytes to frag:
 909      0 extra opcode bytes, 4 displacement bytes.  */
 910   {0, 0, 4, 0},
 911   /* word jmp adds 2 byte2 to frag:
 912      0 extra opcode bytes, 2 displacement bytes.  */
 913   {0, 0, 2, 0},
 914
 915   /* COND_JUMP states.  */
 916   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 917   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 918   /* dword conditionals adds 5 bytes to frag:
 919      1 extra opcode byte, 4 displacement bytes.  */
 920   {0, 0, 5, 0},
 921   /* word conditionals add 3 bytes to frag:
 922      1 extra opcode byte, 2 displacement bytes.  */
 923   {0, 0, 3, 0},
 924
 925   /* COND_JUMP86 states.  */
 926   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
 927   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
 928   /* dword conditionals adds 5 bytes to frag:
 929      1 extra opcode byte, 4 displacement bytes.  */
 930   {0, 0, 5, 0},
 931   /* word conditionals add 4 bytes to frag:
 932      1 displacement byte and a 3 byte long branch insn.  */
 933   {0, 0, 4, 0}
 934 };
 935
 936 static const arch_entry cpu_arch[] =
 937 {
 938   /* Do not replace the first two entries - i386_target_format()
 939      relies on them being there in this order.  */
 940   { STRING_COMMA_LEN ("generic32"), PROCESSOR_GENERIC32,
 941     CPU_GENERIC32_FLAGS, 0 },
 942   { STRING_COMMA_LEN ("generic64"), PROCESSOR_GENERIC64,
 943     CPU_GENERIC64_FLAGS, 0 },
 944   { STRING_COMMA_LEN ("i8086"), PROCESSOR_UNKNOWN,
 945     CPU_NONE_FLAGS, 0 },
 946   { STRING_COMMA_LEN ("i186"), PROCESSOR_UNKNOWN,
 947     CPU_I186_FLAGS, 0 },
 948   { STRING_COMMA_LEN ("i286"), PROCESSOR_UNKNOWN,
 949     CPU_I286_FLAGS, 0 },
 950   { STRING_COMMA_LEN ("i386"), PROCESSOR_I386,
 951     CPU_I386_FLAGS, 0 },
 952   { STRING_COMMA_LEN ("i486"), PROCESSOR_I486,
 953     CPU_I486_FLAGS, 0 },
 954   { STRING_COMMA_LEN ("i586"), PROCESSOR_PENTIUM,
 955     CPU_I586_FLAGS, 0 },
 956   { STRING_COMMA_LEN ("i686"), PROCESSOR_PENTIUMPRO,
 957     CPU_I686_FLAGS, 0 },
 958   { STRING_COMMA_LEN ("pentium"), PROCESSOR_PENTIUM,
 959     CPU_I586_FLAGS, 0 },
 960   { STRING_COMMA_LEN ("pentiumpro"), PROCESSOR_PENTIUMPRO,
 961     CPU_PENTIUMPRO_FLAGS, 0 },
 962   { STRING_COMMA_LEN ("pentiumii"), PROCESSOR_PENTIUMPRO,
 963     CPU_P2_FLAGS, 0 },
 964   { STRING_COMMA_LEN ("pentiumiii"),PROCESSOR_PENTIUMPRO,
 965     CPU_P3_FLAGS, 0 },
 966   { STRING_COMMA_LEN ("pentium4"), PROCESSOR_PENTIUM4,
 967     CPU_P4_FLAGS, 0 },
 968   { STRING_COMMA_LEN ("prescott"), PROCESSOR_NOCONA,
 969     CPU_CORE_FLAGS, 0 },
 970   { STRING_COMMA_LEN ("nocona"), PROCESSOR_NOCONA,
 971     CPU_NOCONA_FLAGS, 0 },
 972   { STRING_COMMA_LEN ("yonah"), PROCESSOR_CORE,
 973     CPU_CORE_FLAGS, 1 },
 974   { STRING_COMMA_LEN ("core"), PROCESSOR_CORE,
 975     CPU_CORE_FLAGS, 0 },
 976   { STRING_COMMA_LEN ("merom"), PROCESSOR_CORE2,
 977     CPU_CORE2_FLAGS, 1 },
 978   { STRING_COMMA_LEN ("core2"), PROCESSOR_CORE2,
 979     CPU_CORE2_FLAGS, 0 },
 980   { STRING_COMMA_LEN ("corei7"), PROCESSOR_COREI7,
 981     CPU_COREI7_FLAGS, 0 },
 982   { STRING_COMMA_LEN ("l1om"), PROCESSOR_L1OM,
 983     CPU_L1OM_FLAGS, 0 },
 984   { STRING_COMMA_LEN ("k1om"), PROCESSOR_K1OM,
 985     CPU_K1OM_FLAGS, 0 },
 986   { STRING_COMMA_LEN ("iamcu"), PROCESSOR_IAMCU,
 987     CPU_IAMCU_FLAGS, 0 },
 988   { STRING_COMMA_LEN ("k6"), PROCESSOR_K6,
 989     CPU_K6_FLAGS, 0 },
 990   { STRING_COMMA_LEN ("k6_2"), PROCESSOR_K6,
 991     CPU_K6_2_FLAGS, 0 },
 992   { STRING_COMMA_LEN ("athlon"), PROCESSOR_ATHLON,
 993     CPU_ATHLON_FLAGS, 0 },
 994   { STRING_COMMA_LEN ("sledgehammer"), PROCESSOR_K8,
 995     CPU_K8_FLAGS, 1 },
 996   { STRING_COMMA_LEN ("opteron"), PROCESSOR_K8,
 997     CPU_K8_FLAGS, 0 },
 998   { STRING_COMMA_LEN ("k8"), PROCESSOR_K8,
 999     CPU_K8_FLAGS, 0 },
1000   { STRING_COMMA_LEN ("amdfam10"), PROCESSOR_AMDFAM10,
1001     CPU_AMDFAM10_FLAGS, 0 },
1002   { STRING_COMMA_LEN ("bdver1"), PROCESSOR_BD,
1003     CPU_BDVER1_FLAGS, 0 },
1004   { STRING_COMMA_LEN ("bdver2"), PROCESSOR_BD,
1005     CPU_BDVER2_FLAGS, 0 },
1006   { STRING_COMMA_LEN ("bdver3"), PROCESSOR_BD,
1007     CPU_BDVER3_FLAGS, 0 },
1008   { STRING_COMMA_LEN ("bdver4"), PROCESSOR_BD,
1009     CPU_BDVER4_FLAGS, 0 },
1010   { STRING_COMMA_LEN ("znver1"), PROCESSOR_ZNVER,
1011     CPU_ZNVER1_FLAGS, 0 },
1012   { STRING_COMMA_LEN ("znver2"), PROCESSOR_ZNVER,
1013     CPU_ZNVER2_FLAGS, 0 },
1014   { STRING_COMMA_LEN ("btver1"), PROCESSOR_BT,
1015     CPU_BTVER1_FLAGS, 0 },
1016   { STRING_COMMA_LEN ("btver2"), PROCESSOR_BT,
1017     CPU_BTVER2_FLAGS, 0 },
1018   { STRING_COMMA_LEN (".8087"), PROCESSOR_UNKNOWN,
1019     CPU_8087_FLAGS, 0 },
1020   { STRING_COMMA_LEN (".287"), PROCESSOR_UNKNOWN,
1021     CPU_287_FLAGS, 0 },
1022   { STRING_COMMA_LEN (".387"), PROCESSOR_UNKNOWN,
1023     CPU_387_FLAGS, 0 },
1024   { STRING_COMMA_LEN (".687"), PROCESSOR_UNKNOWN,
1025     CPU_687_FLAGS, 0 },
1026   { STRING_COMMA_LEN (".cmov"), PROCESSOR_UNKNOWN,
1027     CPU_CMOV_FLAGS, 0 },
1028   { STRING_COMMA_LEN (".fxsr"), PROCESSOR_UNKNOWN,
1029     CPU_FXSR_FLAGS, 0 },
1030   { STRING_COMMA_LEN (".mmx"), PROCESSOR_UNKNOWN,
1031     CPU_MMX_FLAGS, 0 },
1032   { STRING_COMMA_LEN (".sse"), PROCESSOR_UNKNOWN,
1033     CPU_SSE_FLAGS, 0 },
1034   { STRING_COMMA_LEN (".sse2"), PROCESSOR_UNKNOWN,
1035     CPU_SSE2_FLAGS, 0 },
1036   { STRING_COMMA_LEN (".sse3"), PROCESSOR_UNKNOWN,
1037     CPU_SSE3_FLAGS, 0 },
1038   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
1039     CPU_SSE4A_FLAGS, 0 },
1040   { STRING_COMMA_LEN (".ssse3"), PROCESSOR_UNKNOWN,
1041     CPU_SSSE3_FLAGS, 0 },
1042   { STRING_COMMA_LEN (".sse4.1"), PROCESSOR_UNKNOWN,
1043     CPU_SSE4_1_FLAGS, 0 },
1044   { STRING_COMMA_LEN (".sse4.2"), PROCESSOR_UNKNOWN,
1045     CPU_SSE4_2_FLAGS, 0 },
1046   { STRING_COMMA_LEN (".sse4"), PROCESSOR_UNKNOWN,
1047     CPU_SSE4_2_FLAGS, 0 },
1048   { STRING_COMMA_LEN (".avx"), PROCESSOR_UNKNOWN,
1049     CPU_AVX_FLAGS, 0 },
1050   { STRING_COMMA_LEN (".avx2"), PROCESSOR_UNKNOWN,
1051     CPU_AVX2_FLAGS, 0 },
1052   { STRING_COMMA_LEN (".avx512f"), PROCESSOR_UNKNOWN,
1053     CPU_AVX512F_FLAGS, 0 },
1054   { STRING_COMMA_LEN (".avx512cd"), PROCESSOR_UNKNOWN,
1055     CPU_AVX512CD_FLAGS, 0 },
1056   { STRING_COMMA_LEN (".avx512er"), PROCESSOR_UNKNOWN,
1057     CPU_AVX512ER_FLAGS, 0 },
1058   { STRING_COMMA_LEN (".avx512pf"), PROCESSOR_UNKNOWN,
1059     CPU_AVX512PF_FLAGS, 0 },
1060   { STRING_COMMA_LEN (".avx512dq"), PROCESSOR_UNKNOWN,
1061     CPU_AVX512DQ_FLAGS, 0 },
1062   { STRING_COMMA_LEN (".avx512bw"), PROCESSOR_UNKNOWN,
1063     CPU_AVX512BW_FLAGS, 0 },
1064   { STRING_COMMA_LEN (".avx512vl"), PROCESSOR_UNKNOWN,
1065     CPU_AVX512VL_FLAGS, 0 },
1066   { STRING_COMMA_LEN (".vmx"), PROCESSOR_UNKNOWN,
1067     CPU_VMX_FLAGS, 0 },
1068   { STRING_COMMA_LEN (".vmfunc"), PROCESSOR_UNKNOWN,
1069     CPU_VMFUNC_FLAGS, 0 },
1070   { STRING_COMMA_LEN (".smx"), PROCESSOR_UNKNOWN,
1071     CPU_SMX_FLAGS, 0 },
1072   { STRING_COMMA_LEN (".xsave"), PROCESSOR_UNKNOWN,
1073     CPU_XSAVE_FLAGS, 0 },
1074   { STRING_COMMA_LEN (".xsaveopt"), PROCESSOR_UNKNOWN,
1075     CPU_XSAVEOPT_FLAGS, 0 },
1076   { STRING_COMMA_LEN (".xsavec"), PROCESSOR_UNKNOWN,
1077     CPU_XSAVEC_FLAGS, 0 },
1078   { STRING_COMMA_LEN (".xsaves"), PROCESSOR_UNKNOWN,
1079     CPU_XSAVES_FLAGS, 0 },
1080   { STRING_COMMA_LEN (".aes"), PROCESSOR_UNKNOWN,
1081     CPU_AES_FLAGS, 0 },
1082   { STRING_COMMA_LEN (".pclmul"), PROCESSOR_UNKNOWN,
1083     CPU_PCLMUL_FLAGS, 0 },
1084   { STRING_COMMA_LEN (".clmul"), PROCESSOR_UNKNOWN,
1085     CPU_PCLMUL_FLAGS, 1 },
1086   { STRING_COMMA_LEN (".fsgsbase"), PROCESSOR_UNKNOWN,
1087     CPU_FSGSBASE_FLAGS, 0 },
1088   { STRING_COMMA_LEN (".rdrnd"), PROCESSOR_UNKNOWN,
1089     CPU_RDRND_FLAGS, 0 },
1090   { STRING_COMMA_LEN (".f16c"), PROCESSOR_UNKNOWN,
1091     CPU_F16C_FLAGS, 0 },
1092   { STRING_COMMA_LEN (".bmi2"), PROCESSOR_UNKNOWN,
1093     CPU_BMI2_FLAGS, 0 },
1094   { STRING_COMMA_LEN (".fma"), PROCESSOR_UNKNOWN,
1095     CPU_FMA_FLAGS, 0 },
1096   { STRING_COMMA_LEN (".fma4"), PROCESSOR_UNKNOWN,
1097     CPU_FMA4_FLAGS, 0 },
1098   { STRING_COMMA_LEN (".xop"), PROCESSOR_UNKNOWN,
1099     CPU_XOP_FLAGS, 0 },
1100   { STRING_COMMA_LEN (".lwp"), PROCESSOR_UNKNOWN,
1101     CPU_LWP_FLAGS, 0 },
1102   { STRING_COMMA_LEN (".movbe"), PROCESSOR_UNKNOWN,
1103     CPU_MOVBE_FLAGS, 0 },
1104   { STRING_COMMA_LEN (".cx16"), PROCESSOR_UNKNOWN,
1105     CPU_CX16_FLAGS, 0 },
1106   { STRING_COMMA_LEN (".ept"), PROCESSOR_UNKNOWN,
1107     CPU_EPT_FLAGS, 0 },
1108   { STRING_COMMA_LEN (".lzcnt"), PROCESSOR_UNKNOWN,
1109     CPU_LZCNT_FLAGS, 0 },
1110   { STRING_COMMA_LEN (".popcnt"), PROCESSOR_UNKNOWN,
1111     CPU_POPCNT_FLAGS, 0 },
1112   { STRING_COMMA_LEN (".hle"), PROCESSOR_UNKNOWN,
1113     CPU_HLE_FLAGS, 0 },
1114   { STRING_COMMA_LEN (".rtm"), PROCESSOR_UNKNOWN,
1115     CPU_RTM_FLAGS, 0 },
1116   { STRING_COMMA_LEN (".invpcid"), PROCESSOR_UNKNOWN,
1117     CPU_INVPCID_FLAGS, 0 },
1118   { STRING_COMMA_LEN (".clflush"), PROCESSOR_UNKNOWN,
1119     CPU_CLFLUSH_FLAGS, 0 },
1120   { STRING_COMMA_LEN (".nop"), PROCESSOR_UNKNOWN,
1121     CPU_NOP_FLAGS, 0 },
1122   { STRING_COMMA_LEN (".syscall"), PROCESSOR_UNKNOWN,
1123     CPU_SYSCALL_FLAGS, 0 },
1124   { STRING_COMMA_LEN (".rdtscp"), PROCESSOR_UNKNOWN,
1125     CPU_RDTSCP_FLAGS, 0 },
1126   { STRING_COMMA_LEN (".3dnow"), PROCESSOR_UNKNOWN,
1127     CPU_3DNOW_FLAGS, 0 },
1128   { STRING_COMMA_LEN (".3dnowa"), PROCESSOR_UNKNOWN,
1129     CPU_3DNOWA_FLAGS, 0 },
1130   { STRING_COMMA_LEN (".padlock"), PROCESSOR_UNKNOWN,
1131     CPU_PADLOCK_FLAGS, 0 },
1132   { STRING_COMMA_LEN (".pacifica"), PROCESSOR_UNKNOWN,
1133     CPU_SVME_FLAGS, 1 },
1134   { STRING_COMMA_LEN (".svme"), PROCESSOR_UNKNOWN,
1135     CPU_SVME_FLAGS, 0 },
1136   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
1137     CPU_SSE4A_FLAGS, 0 },
1138   { STRING_COMMA_LEN (".abm"), PROCESSOR_UNKNOWN,
1139     CPU_ABM_FLAGS, 0 },
1140   { STRING_COMMA_LEN (".bmi"), PROCESSOR_UNKNOWN,
1141     CPU_BMI_FLAGS, 0 },
1142   { STRING_COMMA_LEN (".tbm"), PROCESSOR_UNKNOWN,
1143     CPU_TBM_FLAGS, 0 },
1144   { STRING_COMMA_LEN (".adx"), PROCESSOR_UNKNOWN,
1145     CPU_ADX_FLAGS, 0 },
1146   { STRING_COMMA_LEN (".rdseed"), PROCESSOR_UNKNOWN,
1147     CPU_RDSEED_FLAGS, 0 },
1148   { STRING_COMMA_LEN (".prfchw"), PROCESSOR_UNKNOWN,
1149     CPU_PRFCHW_FLAGS, 0 },
1150   { STRING_COMMA_LEN (".smap"), PROCESSOR_UNKNOWN,
1151     CPU_SMAP_FLAGS, 0 },
1152   { STRING_COMMA_LEN (".mpx"), PROCESSOR_UNKNOWN,
1153     CPU_MPX_FLAGS, 0 },
1154   { STRING_COMMA_LEN (".sha"), PROCESSOR_UNKNOWN,
1155     CPU_SHA_FLAGS, 0 },
1156   { STRING_COMMA_LEN (".clflushopt"), PROCESSOR_UNKNOWN,
1157     CPU_CLFLUSHOPT_FLAGS, 0 },
1158   { STRING_COMMA_LEN (".prefetchwt1"), PROCESSOR_UNKNOWN,
1159     CPU_PREFETCHWT1_FLAGS, 0 },
1160   { STRING_COMMA_LEN (".se1"), PROCESSOR_UNKNOWN,
1161     CPU_SE1_FLAGS, 0 },
1162   { STRING_COMMA_LEN (".clwb"), PROCESSOR_UNKNOWN,
1163     CPU_CLWB_FLAGS, 0 },
1164   { STRING_COMMA_LEN (".avx512ifma"), PROCESSOR_UNKNOWN,
1165     CPU_AVX512IFMA_FLAGS, 0 },
1166   { STRING_COMMA_LEN (".avx512vbmi"), PROCESSOR_UNKNOWN,
1167     CPU_AVX512VBMI_FLAGS, 0 },
1168   { STRING_COMMA_LEN (".avx512_4fmaps"), PROCESSOR_UNKNOWN,
1169     CPU_AVX512_4FMAPS_FLAGS, 0 },
1170   { STRING_COMMA_LEN (".avx512_4vnniw"), PROCESSOR_UNKNOWN,
1171     CPU_AVX512_4VNNIW_FLAGS, 0 },
1172   { STRING_COMMA_LEN (".avx512_vpopcntdq"), PROCESSOR_UNKNOWN,
1173     CPU_AVX512_VPOPCNTDQ_FLAGS, 0 },
1174   { STRING_COMMA_LEN (".avx512_vbmi2"), PROCESSOR_UNKNOWN,
1175     CPU_AVX512_VBMI2_FLAGS, 0 },
1176   { STRING_COMMA_LEN (".avx512_vnni"), PROCESSOR_UNKNOWN,
1177     CPU_AVX512_VNNI_FLAGS, 0 },
1178   { STRING_COMMA_LEN (".avx512_bitalg"), PROCESSOR_UNKNOWN,
1179     CPU_AVX512_BITALG_FLAGS, 0 },
1180   { STRING_COMMA_LEN (".clzero"), PROCESSOR_UNKNOWN,
1181     CPU_CLZERO_FLAGS, 0 },
1182   { STRING_COMMA_LEN (".mwaitx"), PROCESSOR_UNKNOWN,
1183     CPU_MWAITX_FLAGS, 0 },
1184   { STRING_COMMA_LEN (".ospke"), PROCESSOR_UNKNOWN,
1185     CPU_OSPKE_FLAGS, 0 },
1186   { STRING_COMMA_LEN (".rdpid"), PROCESSOR_UNKNOWN,
1187     CPU_RDPID_FLAGS, 0 },
1188   { STRING_COMMA_LEN (".ptwrite"), PROCESSOR_UNKNOWN,
1189     CPU_PTWRITE_FLAGS, 0 },
1190   { STRING_COMMA_LEN (".ibt"), PROCESSOR_UNKNOWN,
1191     CPU_IBT_FLAGS, 0 },
1192   { STRING_COMMA_LEN (".shstk"), PROCESSOR_UNKNOWN,
1193     CPU_SHSTK_FLAGS, 0 },
1194   { STRING_COMMA_LEN (".gfni"), PROCESSOR_UNKNOWN,
1195     CPU_GFNI_FLAGS, 0 },
1196   { STRING_COMMA_LEN (".vaes"), PROCESSOR_UNKNOWN,
1197     CPU_VAES_FLAGS, 0 },
1198   { STRING_COMMA_LEN (".vpclmulqdq"), PROCESSOR_UNKNOWN,
1199     CPU_VPCLMULQDQ_FLAGS, 0 },
1200   { STRING_COMMA_LEN (".wbnoinvd"), PROCESSOR_UNKNOWN,
1201     CPU_WBNOINVD_FLAGS, 0 },
1202   { STRING_COMMA_LEN (".pconfig"), PROCESSOR_UNKNOWN,
1203     CPU_PCONFIG_FLAGS, 0 },
1204   { STRING_COMMA_LEN (".waitpkg"), PROCESSOR_UNKNOWN,
1205     CPU_WAITPKG_FLAGS, 0 },
1206   { STRING_COMMA_LEN (".cldemote"), PROCESSOR_UNKNOWN,
1207     CPU_CLDEMOTE_FLAGS, 0 },
1208   { STRING_COMMA_LEN (".amx_int8"), PROCESSOR_UNKNOWN,
1209     CPU_AMX_INT8_FLAGS, 0 },
1210   { STRING_COMMA_LEN (".amx_bf16"), PROCESSOR_UNKNOWN,
1211     CPU_AMX_BF16_FLAGS, 0 },
1212   { STRING_COMMA_LEN (".amx_tile"), PROCESSOR_UNKNOWN,
1213     CPU_AMX_TILE_FLAGS, 0 },
1214   { STRING_COMMA_LEN (".movdiri"), PROCESSOR_UNKNOWN,
1215     CPU_MOVDIRI_FLAGS, 0 },
1216   { STRING_COMMA_LEN (".movdir64b"), PROCESSOR_UNKNOWN,
1217     CPU_MOVDIR64B_FLAGS, 0 },
1218   { STRING_COMMA_LEN (".avx512_bf16"), PROCESSOR_UNKNOWN,
1219     CPU_AVX512_BF16_FLAGS, 0 },
1220   { STRING_COMMA_LEN (".avx512_vp2intersect"), PROCESSOR_UNKNOWN,
1221     CPU_AVX512_VP2INTERSECT_FLAGS, 0 },
1222   { STRING_COMMA_LEN (".enqcmd"), PROCESSOR_UNKNOWN,
1223     CPU_ENQCMD_FLAGS, 0 },
1224   { STRING_COMMA_LEN (".serialize"), PROCESSOR_UNKNOWN,
1225     CPU_SERIALIZE_FLAGS, 0 },
1226   { STRING_COMMA_LEN (".rdpru"), PROCESSOR_UNKNOWN,
1227     CPU_RDPRU_FLAGS, 0 },
1228   { STRING_COMMA_LEN (".mcommit"), PROCESSOR_UNKNOWN,
1229     CPU_MCOMMIT_FLAGS, 0 },
1230   { STRING_COMMA_LEN (".sev_es"), PROCESSOR_UNKNOWN,
1231     CPU_SEV_ES_FLAGS, 0 },
1232   { STRING_COMMA_LEN (".tsxldtrk"), PROCESSOR_UNKNOWN,
1233     CPU_TSXLDTRK_FLAGS, 0 },
1234 };
1235
1236 static const noarch_entry cpu_noarch[] =
1237 {
1238   { STRING_COMMA_LEN ("no87"),  CPU_ANY_X87_FLAGS },
1239   { STRING_COMMA_LEN ("no287"),  CPU_ANY_287_FLAGS },
1240   { STRING_COMMA_LEN ("no387"),  CPU_ANY_387_FLAGS },
1241   { STRING_COMMA_LEN ("no687"),  CPU_ANY_687_FLAGS },
1242   { STRING_COMMA_LEN ("nocmov"),  CPU_ANY_CMOV_FLAGS },
1243   { STRING_COMMA_LEN ("nofxsr"),  CPU_ANY_FXSR_FLAGS },
1244   { STRING_COMMA_LEN ("nommx"),  CPU_ANY_MMX_FLAGS },
1245   { STRING_COMMA_LEN ("nosse"),  CPU_ANY_SSE_FLAGS },
1246   { STRING_COMMA_LEN ("nosse2"),  CPU_ANY_SSE2_FLAGS },
1247   { STRING_COMMA_LEN ("nosse3"),  CPU_ANY_SSE3_FLAGS },
1248   { STRING_COMMA_LEN ("nosse4a"),  CPU_ANY_SSE4A_FLAGS },
1249   { STRING_COMMA_LEN ("nossse3"),  CPU_ANY_SSSE3_FLAGS },
1250   { STRING_COMMA_LEN ("nosse4.1"),  CPU_ANY_SSE4_1_FLAGS },
1251   { STRING_COMMA_LEN ("nosse4.2"),  CPU_ANY_SSE4_2_FLAGS },
1252   { STRING_COMMA_LEN ("nosse4"),  CPU_ANY_SSE4_1_FLAGS },
1253   { STRING_COMMA_LEN ("noavx"),  CPU_ANY_AVX_FLAGS },
1254   { STRING_COMMA_LEN ("noavx2"),  CPU_ANY_AVX2_FLAGS },
1255   { STRING_COMMA_LEN ("noavx512f"), CPU_ANY_AVX512F_FLAGS },
1256   { STRING_COMMA_LEN ("noavx512cd"), CPU_ANY_AVX512CD_FLAGS },
1257   { STRING_COMMA_LEN ("noavx512er"), CPU_ANY_AVX512ER_FLAGS },
1258   { STRING_COMMA_LEN ("noavx512pf"), CPU_ANY_AVX512PF_FLAGS },
1259   { STRING_COMMA_LEN ("noavx512dq"), CPU_ANY_AVX512DQ_FLAGS },
1260   { STRING_COMMA_LEN ("noavx512bw"), CPU_ANY_AVX512BW_FLAGS },
1261   { STRING_COMMA_LEN ("noavx512vl"), CPU_ANY_AVX512VL_FLAGS },
1262   { STRING_COMMA_LEN ("noavx512ifma"), CPU_ANY_AVX512IFMA_FLAGS },
1263   { STRING_COMMA_LEN ("noavx512vbmi"), CPU_ANY_AVX512VBMI_FLAGS },
1264   { STRING_COMMA_LEN ("noavx512_4fmaps"), CPU_ANY_AVX512_4FMAPS_FLAGS },
1265   { STRING_COMMA_LEN ("noavx512_4vnniw"), CPU_ANY_AVX512_4VNNIW_FLAGS },
1266   { STRING_COMMA_LEN ("noavx512_vpopcntdq"), CPU_ANY_AVX512_VPOPCNTDQ_FLAGS },
1267   { STRING_COMMA_LEN ("noavx512_vbmi2"), CPU_ANY_AVX512_VBMI2_FLAGS },
1268   { STRING_COMMA_LEN ("noavx512_vnni"), CPU_ANY_AVX512_VNNI_FLAGS },
1269   { STRING_COMMA_LEN ("noavx512_bitalg"), CPU_ANY_AVX512_BITALG_FLAGS },
1270   { STRING_COMMA_LEN ("noibt"), CPU_ANY_IBT_FLAGS },
1271   { STRING_COMMA_LEN ("noshstk"), CPU_ANY_SHSTK_FLAGS },
1272   { STRING_COMMA_LEN ("noamx_int8"), CPU_ANY_AMX_INT8_FLAGS },
1273   { STRING_COMMA_LEN ("noamx_bf16"), CPU_ANY_AMX_BF16_FLAGS },
1274   { STRING_COMMA_LEN ("noamx_tile"), CPU_ANY_AMX_TILE_FLAGS },
1275   { STRING_COMMA_LEN ("nomovdiri"), CPU_ANY_MOVDIRI_FLAGS },
1276   { STRING_COMMA_LEN ("nomovdir64b"), CPU_ANY_MOVDIR64B_FLAGS },
1277   { STRING_COMMA_LEN ("noavx512_bf16"), CPU_ANY_AVX512_BF16_FLAGS },
1278   { STRING_COMMA_LEN ("noavx512_vp2intersect"),
1279     CPU_ANY_AVX512_VP2INTERSECT_FLAGS },
1280   { STRING_COMMA_LEN ("noenqcmd"), CPU_ANY_ENQCMD_FLAGS },
1281   { STRING_COMMA_LEN ("noserialize"), CPU_ANY_SERIALIZE_FLAGS },
1282   { STRING_COMMA_LEN ("notsxldtrk"), CPU_ANY_TSXLDTRK_FLAGS },
1283 };
1284
1285 #ifdef I386COFF
1286 /* Like s_lcomm_internal in gas/read.c but the alignment string
1287    is allowed to be optional.  */
1288
1289 static symbolS *
1290 pe_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
1291 {
1292   addressT align = 0;
1293
1294   SKIP_WHITESPACE ();
1295
1296   if (needs_align
1297       && *input_line_pointer == ',')
1298     {
1299       align = parse_align (needs_align - 1);
1300
1301       if (align == (addressT) -1)
1302         return NULL;
1303     }
1304   else
1305     {
1306       if (size >= 8)
1307         align = 3;
1308       else if (size >= 4)
1309         align = 2;
1310       else if (size >= 2)
1311         align = 1;
1312       else
1313         align = 0;
1314     }
1315
1316   bss_alloc (symbolP, size, align);
1317   return symbolP;
1318 }
1319
1320 static void
1321 pe_lcomm (int needs_align)
1322 {
1323   s_comm_internal (needs_align * 2, pe_lcomm_internal);
1324 }
1325 #endif
1326
1327 const pseudo_typeS md_pseudo_table[] =
1328 {
1329 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
1330   {"align", s_align_bytes, 0},
1331 #else
1332   {"align", s_align_ptwo, 0},
1333 #endif
1334   {"arch", set_cpu_arch, 0},
1335 #ifndef I386COFF
1336   {"bss", s_bss, 0},
1337 #else
1338   {"lcomm", pe_lcomm, 1},
1339 #endif
1340   {"ffloat", float_cons, 'f'},
1341   {"dfloat", float_cons, 'd'},
1342   {"tfloat", float_cons, 'x'},
1343   {"value", cons, 2},
1344   {"slong", signed_cons, 4},
1345   {"noopt", s_ignore, 0},
1346   {"optim", s_ignore, 0},
1347   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
1348   {"code16", set_code_flag, CODE_16BIT},
1349   {"code32", set_code_flag, CODE_32BIT},
1350 #ifdef BFD64
1351   {"code64", set_code_flag, CODE_64BIT},
1352 #endif
1353   {"intel_syntax", set_intel_syntax, 1},
1354   {"att_syntax", set_intel_syntax, 0},
1355   {"intel_mnemonic", set_intel_mnemonic, 1},
1356   {"att_mnemonic", set_intel_mnemonic, 0},
1357   {"allow_index_reg", set_allow_index_reg, 1},
1358   {"disallow_index_reg", set_allow_index_reg, 0},
1359   {"sse_check", set_check, 0},
1360   {"operand_check", set_check, 1},
1361 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1362   {"largecomm", handle_large_common, 0},
1363 #else
1364   {"file", dwarf2_directive_file, 0},
1365   {"loc", dwarf2_directive_loc, 0},
1366   {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
1367 #endif
1368 #ifdef TE_PE
1369   {"secrel32", pe_directive_secrel, 0},
1370 #endif
1371   {0, 0, 0}
1372 };
1373
1374 /* For interface with expression ().  */
1375 extern char *input_line_pointer;
1376
1377 /* Hash table for instruction mnemonic lookup.  */
1378 static struct hash_control *op_hash;
1379
1380 /* Hash table for register lookup.  */
1381 static struct hash_control *reg_hash;
1382 \f
1383   /* Various efficient no-op patterns for aligning code labels.
1384      Note: Don't try to assemble the instructions in the comments.
1385      0L and 0w are not legal.  */
1386 static const unsigned char f32_1[] =
1387   {0x90};                               /* nop                  */
1388 static const unsigned char f32_2[] =
1389   {0x66,0x90};                          /* xchg %ax,%ax         */
1390 static const unsigned char f32_3[] =
1391   {0x8d,0x76,0x00};                     /* leal 0(%esi),%esi    */
1392 static const unsigned char f32_4[] =
1393   {0x8d,0x74,0x26,0x00};                /* leal 0(%esi,1),%esi  */
1394 static const unsigned char f32_6[] =
1395   {0x8d,0xb6,0x00,0x00,0x00,0x00};      /* leal 0L(%esi),%esi   */
1396 static const unsigned char f32_7[] =
1397   {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
1398 static const unsigned char f16_3[] =
1399   {0x8d,0x74,0x00};                     /* lea 0(%si),%si       */
1400 static const unsigned char f16_4[] =
1401   {0x8d,0xb4,0x00,0x00};                /* lea 0W(%si),%si      */
1402 static const unsigned char jump_disp8[] =
1403   {0xeb};                               /* jmp disp8           */
1404 static const unsigned char jump32_disp32[] =
1405   {0xe9};                               /* jmp disp32          */
1406 static const unsigned char jump16_disp32[] =
1407   {0x66,0xe9};                          /* jmp disp32          */
1408 /* 32-bit NOPs patterns.  */
1409 static const unsigned char *const f32_patt[] = {
1410   f32_1, f32_2, f32_3, f32_4, NULL, f32_6, f32_7
1411 };
1412 /* 16-bit NOPs patterns.  */
1413 static const unsigned char *const f16_patt[] = {
1414   f32_1, f32_2, f16_3, f16_4
1415 };
1416 /* nopl (%[re]ax) */
1417 static const unsigned char alt_3[] =
1418   {0x0f,0x1f,0x00};
1419 /* nopl 0(%[re]ax) */
1420 static const unsigned char alt_4[] =
1421   {0x0f,0x1f,0x40,0x00};
1422 /* nopl 0(%[re]ax,%[re]ax,1) */
1423 static const unsigned char alt_5[] =
1424   {0x0f,0x1f,0x44,0x00,0x00};
1425 /* nopw 0(%[re]ax,%[re]ax,1) */
1426 static const unsigned char alt_6[] =
1427   {0x66,0x0f,0x1f,0x44,0x00,0x00};
1428 /* nopl 0L(%[re]ax) */
1429 static const unsigned char alt_7[] =
1430   {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
1431 /* nopl 0L(%[re]ax,%[re]ax,1) */
1432 static const unsigned char alt_8[] =
1433   {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1434 /* nopw 0L(%[re]ax,%[re]ax,1) */
1435 static const unsigned char alt_9[] =
1436   {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1437 /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
1438 static const unsigned char alt_10[] =
1439   {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1440 /* data16 nopw %cs:0L(%eax,%eax,1) */
1441 static const unsigned char alt_11[] =
1442   {0x66,0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1443 /* 32-bit and 64-bit NOPs patterns.  */
1444 static const unsigned char *const alt_patt[] = {
1445   f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
1446   alt_9, alt_10, alt_11
1447 };
1448
1449 /* Genenerate COUNT bytes of NOPs to WHERE from PATT with the maximum
1450    size of a single NOP instruction MAX_SINGLE_NOP_SIZE.  */
1451
1452 static void
1453 i386_output_nops (char *where, const unsigned char *const *patt,
1454                   int count, int max_single_nop_size)
1455
1456 {
1457   /* Place the longer NOP first.  */
1458   int last;
1459   int offset;
1460   const unsigned char *nops;
1461
1462   if (max_single_nop_size < 1)
1463     {
1464       as_fatal (_("i386_output_nops called to generate nops of at most %d bytes!"),
1465                 max_single_nop_size);
1466       return;
1467     }
1468
1469   nops = patt[max_single_nop_size - 1];
1470
1471   /* Use the smaller one if the requsted one isn't available.  */
1472   if (nops == NULL)
1473     {
1474       max_single_nop_size--;
1475       nops = patt[max_single_nop_size - 1];
1476     }
1477
1478   last = count % max_single_nop_size;
1479
1480   count -= last;
1481   for (offset = 0; offset < count; offset += max_single_nop_size)
1482     memcpy (where + offset, nops, max_single_nop_size);
1483
1484   if (last)
1485     {
1486       nops = patt[last - 1];
1487       if (nops == NULL)
1488         {
1489           /* Use the smaller one plus one-byte NOP if the needed one
1490              isn't available.  */
1491           last--;
1492           nops = patt[last - 1];
1493           memcpy (where + offset, nops, last);
1494           where[offset + last] = *patt[0];
1495         }
1496       else
1497         memcpy (where + offset, nops, last);
1498     }
1499 }
1500
1501 static INLINE int
1502 fits_in_imm7 (offsetT num)
1503 {
1504   return (num & 0x7f) == num;
1505 }
1506
1507 static INLINE int
1508 fits_in_imm31 (offsetT num)
1509 {
1510   return (num & 0x7fffffff) == num;
1511 }
1512
1513 /* Genenerate COUNT bytes of NOPs to WHERE with the maximum size of a
1514    single NOP instruction LIMIT.  */
1515
1516 void
1517 i386_generate_nops (fragS *fragP, char *where, offsetT count, int limit)
1518 {
1519   const unsigned char *const *patt = NULL;
1520   int max_single_nop_size;
1521   /* Maximum number of NOPs before switching to jump over NOPs.  */
1522   int max_number_of_nops;
1523
1524   switch (fragP->fr_type)
1525     {
1526     case rs_fill_nop:
1527     case rs_align_code:
1528       break;
1529     case rs_machine_dependent:
1530       /* Allow NOP padding for jumps and calls.  */
1531       if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
1532           || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
1533         break;
1534       /* Fall through.  */
1535     default:
1536       return;
1537     }
1538
1539   /* We need to decide which NOP sequence to use for 32bit and
1540      64bit. When -mtune= is used:
1541
1542      1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
1543      PROCESSOR_GENERIC32, f32_patt will be used.
1544      2. For the rest, alt_patt will be used.
1545
1546      When -mtune= isn't used, alt_patt will be used if
1547      cpu_arch_isa_flags has CpuNop.  Otherwise, f32_patt will
1548      be used.
1549
1550      When -march= or .arch is used, we can't use anything beyond
1551      cpu_arch_isa_flags.   */
1552
1553   if (flag_code == CODE_16BIT)
1554     {
1555       patt = f16_patt;
1556       max_single_nop_size = sizeof (f16_patt) / sizeof (f16_patt[0]);
1557       /* Limit number of NOPs to 2 in 16-bit mode.  */
1558       max_number_of_nops = 2;
1559     }
1560   else
1561     {
1562       if (fragP->tc_frag_data.isa == PROCESSOR_UNKNOWN)
1563         {
1564           /* PROCESSOR_UNKNOWN means that all ISAs may be used.  */
1565           switch (cpu_arch_tune)
1566             {
1567             case PROCESSOR_UNKNOWN:
1568               /* We use cpu_arch_isa_flags to check if we SHOULD
1569                  optimize with nops.  */
1570               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1571                 patt = alt_patt;
1572               else
1573                 patt = f32_patt;
1574               break;
1575             case PROCESSOR_PENTIUM4:
1576             case PROCESSOR_NOCONA:
1577             case PROCESSOR_CORE:
1578             case PROCESSOR_CORE2:
1579             case PROCESSOR_COREI7:
1580             case PROCESSOR_L1OM:
1581             case PROCESSOR_K1OM:
1582             case PROCESSOR_GENERIC64:
1583             case PROCESSOR_K6:
1584             case PROCESSOR_ATHLON:
1585             case PROCESSOR_K8:
1586             case PROCESSOR_AMDFAM10:
1587             case PROCESSOR_BD:
1588             case PROCESSOR_ZNVER:
1589             case PROCESSOR_BT:
1590               patt = alt_patt;
1591               break;
1592             case PROCESSOR_I386:
1593             case PROCESSOR_I486:
1594             case PROCESSOR_PENTIUM:
1595             case PROCESSOR_PENTIUMPRO:
1596             case PROCESSOR_IAMCU:
1597             case PROCESSOR_GENERIC32:
1598               patt = f32_patt;
1599               break;
1600             }
1601         }
1602       else
1603         {
1604           switch (fragP->tc_frag_data.tune)
1605             {
1606             case PROCESSOR_UNKNOWN:
1607               /* When cpu_arch_isa is set, cpu_arch_tune shouldn't be
1608                  PROCESSOR_UNKNOWN.  */
1609               abort ();
1610               break;
1611
1612             case PROCESSOR_I386:
1613             case PROCESSOR_I486:
1614             case PROCESSOR_PENTIUM:
1615             case PROCESSOR_IAMCU:
1616             case PROCESSOR_K6:
1617             case PROCESSOR_ATHLON:
1618             case PROCESSOR_K8:
1619             case PROCESSOR_AMDFAM10:
1620             case PROCESSOR_BD:
1621             case PROCESSOR_ZNVER:
1622             case PROCESSOR_BT:
1623             case PROCESSOR_GENERIC32:
1624               /* We use cpu_arch_isa_flags to check if we CAN optimize
1625                  with nops.  */
1626               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1627                 patt = alt_patt;
1628               else
1629                 patt = f32_patt;
1630               break;
1631             case PROCESSOR_PENTIUMPRO:
1632             case PROCESSOR_PENTIUM4:
1633             case PROCESSOR_NOCONA:
1634             case PROCESSOR_CORE:
1635             case PROCESSOR_CORE2:
1636             case PROCESSOR_COREI7:
1637             case PROCESSOR_L1OM:
1638             case PROCESSOR_K1OM:
1639               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1640                 patt = alt_patt;
1641               else
1642                 patt = f32_patt;
1643               break;
1644             case PROCESSOR_GENERIC64:
1645               patt = alt_patt;
1646               break;
1647             }
1648         }
1649
1650       if (patt == f32_patt)
1651         {
1652           max_single_nop_size = sizeof (f32_patt) / sizeof (f32_patt[0]);
1653           /* Limit number of NOPs to 2 for older processors.  */
1654           max_number_of_nops = 2;
1655         }
1656       else
1657         {
1658           max_single_nop_size = sizeof (alt_patt) / sizeof (alt_patt[0]);
1659           /* Limit number of NOPs to 7 for newer processors.  */
1660           max_number_of_nops = 7;
1661         }
1662     }
1663
1664   if (limit == 0)
1665     limit = max_single_nop_size;
1666
1667   if (fragP->fr_type == rs_fill_nop)
1668     {
1669       /* Output NOPs for .nop directive.  */
1670       if (limit > max_single_nop_size)
1671         {
1672           as_bad_where (fragP->fr_file, fragP->fr_line,
1673                         _("invalid single nop size: %d "
1674                           "(expect within [0, %d])"),
1675                         limit, max_single_nop_size);
1676           return;
1677         }
1678     }
1679   else if (fragP->fr_type != rs_machine_dependent)
1680     fragP->fr_var = count;
1681
1682   if ((count / max_single_nop_size) > max_number_of_nops)
1683     {
1684       /* Generate jump over NOPs.  */
1685       offsetT disp = count - 2;
1686       if (fits_in_imm7 (disp))
1687         {
1688           /* Use "jmp disp8" if possible.  */
1689           count = disp;
1690           where[0] = jump_disp8[0];
1691           where[1] = count;
1692           where += 2;
1693         }
1694       else
1695         {
1696           unsigned int size_of_jump;
1697
1698           if (flag_code == CODE_16BIT)
1699             {
1700               where[0] = jump16_disp32[0];
1701               where[1] = jump16_disp32[1];
1702               size_of_jump = 2;
1703             }
1704           else
1705             {
1706               where[0] = jump32_disp32[0];
1707               size_of_jump = 1;
1708             }
1709
1710           count -= size_of_jump + 4;
1711           if (!fits_in_imm31 (count))
1712             {
1713               as_bad_where (fragP->fr_file, fragP->fr_line,
1714                             _("jump over nop padding out of range"));
1715               return;
1716             }
1717
1718           md_number_to_chars (where + size_of_jump, count, 4);
1719           where += size_of_jump + 4;
1720         }
1721     }
1722
1723   /* Generate multiple NOPs.  */
1724   i386_output_nops (where, patt, count, limit);
1725 }
1726
1727 static INLINE int
1728 operand_type_all_zero (const union i386_operand_type *x)
1729 {
1730   switch (ARRAY_SIZE(x->array))
1731     {
1732     case 3:
1733       if (x->array[2])
1734         return 0;
1735       /* Fall through.  */
1736     case 2:
1737       if (x->array[1])
1738         return 0;
1739       /* Fall through.  */
1740     case 1:
1741       return !x->array[0];
1742     default:
1743       abort ();
1744     }
1745 }
1746
1747 static INLINE void
1748 operand_type_set (union i386_operand_type *x, unsigned int v)
1749 {
1750   switch (ARRAY_SIZE(x->array))
1751     {
1752     case 3:
1753       x->array[2] = v;
1754       /* Fall through.  */
1755     case 2:
1756       x->array[1] = v;
1757       /* Fall through.  */
1758     case 1:
1759       x->array[0] = v;
1760       /* Fall through.  */
1761       break;
1762     default:
1763       abort ();
1764     }
1765
1766   x->bitfield.class = ClassNone;
1767   x->bitfield.instance = InstanceNone;
1768 }
1769
1770 static INLINE int
1771 operand_type_equal (const union i386_operand_type *x,
1772                     const union i386_operand_type *y)
1773 {
1774   switch (ARRAY_SIZE(x->array))
1775     {
1776     case 3:
1777       if (x->array[2] != y->array[2])
1778         return 0;
1779       /* Fall through.  */
1780     case 2:
1781       if (x->array[1] != y->array[1])
1782         return 0;
1783       /* Fall through.  */
1784     case 1:
1785       return x->array[0] == y->array[0];
1786       break;
1787     default:
1788       abort ();
1789     }
1790 }
1791
1792 static INLINE int
1793 cpu_flags_all_zero (const union i386_cpu_flags *x)
1794 {
1795   switch (ARRAY_SIZE(x->array))
1796     {
1797     case 4:
1798       if (x->array[3])
1799         return 0;
1800       /* Fall through.  */
1801     case 3:
1802       if (x->array[2])
1803         return 0;
1804       /* Fall through.  */
1805     case 2:
1806       if (x->array[1])
1807         return 0;
1808       /* Fall through.  */
1809     case 1:
1810       return !x->array[0];
1811     default:
1812       abort ();
1813     }
1814 }
1815
1816 static INLINE int
1817 cpu_flags_equal (const union i386_cpu_flags *x,
1818                  const union i386_cpu_flags *y)
1819 {
1820   switch (ARRAY_SIZE(x->array))
1821     {
1822     case 4:
1823       if (x->array[3] != y->array[3])
1824         return 0;
1825       /* Fall through.  */
1826     case 3:
1827       if (x->array[2] != y->array[2])
1828         return 0;
1829       /* Fall through.  */
1830     case 2:
1831       if (x->array[1] != y->array[1])
1832         return 0;
1833       /* Fall through.  */
1834     case 1:
1835       return x->array[0] == y->array[0];
1836       break;
1837     default:
1838       abort ();
1839     }
1840 }
1841
1842 static INLINE int
1843 cpu_flags_check_cpu64 (i386_cpu_flags f)
1844 {
1845   return !((flag_code == CODE_64BIT && f.bitfield.cpuno64)
1846            || (flag_code != CODE_64BIT && f.bitfield.cpu64));
1847 }
1848
1849 static INLINE i386_cpu_flags
1850 cpu_flags_and (i386_cpu_flags x, i386_cpu_flags y)
1851 {
1852   switch (ARRAY_SIZE (x.array))
1853     {
1854     case 4:
1855       x.array [3] &= y.array [3];
1856       /* Fall through.  */
1857     case 3:
1858       x.array [2] &= y.array [2];
1859       /* Fall through.  */
1860     case 2:
1861       x.array [1] &= y.array [1];
1862       /* Fall through.  */
1863     case 1:
1864       x.array [0] &= y.array [0];
1865       break;
1866     default:
1867       abort ();
1868     }
1869   return x;
1870 }
1871
1872 static INLINE i386_cpu_flags
1873 cpu_flags_or (i386_cpu_flags x, i386_cpu_flags y)
1874 {
1875   switch (ARRAY_SIZE (x.array))
1876     {
1877     case 4:
1878       x.array [3] |= y.array [3];
1879       /* Fall through.  */
1880     case 3:
1881       x.array [2] |= y.array [2];
1882       /* Fall through.  */
1883     case 2:
1884       x.array [1] |= y.array [1];
1885       /* Fall through.  */
1886     case 1:
1887       x.array [0] |= y.array [0];
1888       break;
1889     default:
1890       abort ();
1891     }
1892   return x;
1893 }
1894
1895 static INLINE i386_cpu_flags
1896 cpu_flags_and_not (i386_cpu_flags x, i386_cpu_flags y)
1897 {
1898   switch (ARRAY_SIZE (x.array))
1899     {
1900     case 4:
1901       x.array [3] &= ~y.array [3];
1902       /* Fall through.  */
1903     case 3:
1904       x.array [2] &= ~y.array [2];
1905       /* Fall through.  */
1906     case 2:
1907       x.array [1] &= ~y.array [1];
1908       /* Fall through.  */
1909     case 1:
1910       x.array [0] &= ~y.array [0];
1911       break;
1912     default:
1913       abort ();
1914     }
1915   return x;
1916 }
1917
1918 static const i386_cpu_flags avx512 = CPU_ANY_AVX512F_FLAGS;
1919
1920 #define CPU_FLAGS_ARCH_MATCH            0x1
1921 #define CPU_FLAGS_64BIT_MATCH           0x2
1922
1923 #define CPU_FLAGS_PERFECT_MATCH \
1924   (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_64BIT_MATCH)
1925
1926 /* Return CPU flags match bits. */
1927
1928 static int
1929 cpu_flags_match (const insn_template *t)
1930 {
1931   i386_cpu_flags x = t->cpu_flags;
1932   int match = cpu_flags_check_cpu64 (x) ? CPU_FLAGS_64BIT_MATCH : 0;
1933
1934   x.bitfield.cpu64 = 0;
1935   x.bitfield.cpuno64 = 0;
1936
1937   if (cpu_flags_all_zero (&x))
1938     {
1939       /* This instruction is available on all archs.  */
1940       match |= CPU_FLAGS_ARCH_MATCH;
1941     }
1942   else
1943     {
1944       /* This instruction is available only on some archs.  */
1945       i386_cpu_flags cpu = cpu_arch_flags;
1946
1947       /* AVX512VL is no standalone feature - match it and then strip it.  */
1948       if (x.bitfield.cpuavx512vl && !cpu.bitfield.cpuavx512vl)
1949         return match;
1950       x.bitfield.cpuavx512vl = 0;
1951
1952       cpu = cpu_flags_and (x, cpu);
1953       if (!cpu_flags_all_zero (&cpu))
1954         {
1955           if (x.bitfield.cpuavx)
1956             {
1957               /* We need to check a few extra flags with AVX.  */
1958               if (cpu.bitfield.cpuavx
1959                   && (!t->opcode_modifier.sse2avx
1960                       || (sse2avx && !i.prefix[DATA_PREFIX]))
1961                   && (!x.bitfield.cpuaes || cpu.bitfield.cpuaes)
1962                   && (!x.bitfield.cpugfni || cpu.bitfield.cpugfni)
1963                   && (!x.bitfield.cpupclmul || cpu.bitfield.cpupclmul))
1964                 match |= CPU_FLAGS_ARCH_MATCH;
1965             }
1966           else if (x.bitfield.cpuavx512f)
1967             {
1968               /* We need to check a few extra flags with AVX512F.  */
1969               if (cpu.bitfield.cpuavx512f
1970                   && (!x.bitfield.cpugfni || cpu.bitfield.cpugfni)
1971                   && (!x.bitfield.cpuvaes || cpu.bitfield.cpuvaes)
1972                   && (!x.bitfield.cpuvpclmulqdq || cpu.bitfield.cpuvpclmulqdq))
1973                 match |= CPU_FLAGS_ARCH_MATCH;
1974             }
1975           else
1976             match |= CPU_FLAGS_ARCH_MATCH;
1977         }
1978     }
1979   return match;
1980 }
1981
1982 static INLINE i386_operand_type
1983 operand_type_and (i386_operand_type x, i386_operand_type y)
1984 {
1985   if (x.bitfield.class != y.bitfield.class)
1986     x.bitfield.class = ClassNone;
1987   if (x.bitfield.instance != y.bitfield.instance)
1988     x.bitfield.instance = InstanceNone;
1989
1990   switch (ARRAY_SIZE (x.array))
1991     {
1992     case 3:
1993       x.array [2] &= y.array [2];
1994       /* Fall through.  */
1995     case 2:
1996       x.array [1] &= y.array [1];
1997       /* Fall through.  */
1998     case 1:
1999       x.array [0] &= y.array [0];
2000       break;
2001     default:
2002       abort ();
2003     }
2004   return x;
2005 }
2006
2007 static INLINE i386_operand_type
2008 operand_type_and_not (i386_operand_type x, i386_operand_type y)
2009 {
2010   gas_assert (y.bitfield.class == ClassNone);
2011   gas_assert (y.bitfield.instance == InstanceNone);
2012
2013   switch (ARRAY_SIZE (x.array))
2014     {
2015     case 3:
2016       x.array [2] &= ~y.array [2];
2017       /* Fall through.  */
2018     case 2:
2019       x.array [1] &= ~y.array [1];
2020       /* Fall through.  */
2021     case 1:
2022       x.array [0] &= ~y.array [0];
2023       break;
2024     default:
2025       abort ();
2026     }
2027   return x;
2028 }
2029
2030 static INLINE i386_operand_type
2031 operand_type_or (i386_operand_type x, i386_operand_type y)
2032 {
2033   gas_assert (x.bitfield.class == ClassNone ||
2034               y.bitfield.class == ClassNone ||
2035               x.bitfield.class == y.bitfield.class);
2036   gas_assert (x.bitfield.instance == InstanceNone ||
2037               y.bitfield.instance == InstanceNone ||
2038               x.bitfield.instance == y.bitfield.instance);
2039
2040   switch (ARRAY_SIZE (x.array))
2041     {
2042     case 3:
2043       x.array [2] |= y.array [2];
2044       /* Fall through.  */
2045     case 2:
2046       x.array [1] |= y.array [1];
2047       /* Fall through.  */
2048     case 1:
2049       x.array [0] |= y.array [0];
2050       break;
2051     default:
2052       abort ();
2053     }
2054   return x;
2055 }
2056
2057 static INLINE i386_operand_type
2058 operand_type_xor (i386_operand_type x, i386_operand_type y)
2059 {
2060   gas_assert (y.bitfield.class == ClassNone);
2061   gas_assert (y.bitfield.instance == InstanceNone);
2062
2063   switch (ARRAY_SIZE (x.array))
2064     {
2065     case 3:
2066       x.array [2] ^= y.array [2];
2067       /* Fall through.  */
2068     case 2:
2069       x.array [1] ^= y.array [1];
2070       /* Fall through.  */
2071     case 1:
2072       x.array [0] ^= y.array [0];
2073       break;
2074     default:
2075       abort ();
2076     }
2077   return x;
2078 }
2079
2080 static const i386_operand_type disp16 = OPERAND_TYPE_DISP16;
2081 static const i386_operand_type disp32 = OPERAND_TYPE_DISP32;
2082 static const i386_operand_type disp32s = OPERAND_TYPE_DISP32S;
2083 static const i386_operand_type disp16_32 = OPERAND_TYPE_DISP16_32;
2084 static const i386_operand_type anydisp = OPERAND_TYPE_ANYDISP;
2085 static const i386_operand_type anyimm = OPERAND_TYPE_ANYIMM;
2086 static const i386_operand_type regxmm = OPERAND_TYPE_REGXMM;
2087 static const i386_operand_type regmask = OPERAND_TYPE_REGMASK;
2088 static const i386_operand_type imm8 = OPERAND_TYPE_IMM8;
2089 static const i386_operand_type imm8s = OPERAND_TYPE_IMM8S;
2090 static const i386_operand_type imm16 = OPERAND_TYPE_IMM16;
2091 static const i386_operand_type imm32 = OPERAND_TYPE_IMM32;
2092 static const i386_operand_type imm32s = OPERAND_TYPE_IMM32S;
2093 static const i386_operand_type imm64 = OPERAND_TYPE_IMM64;
2094 static const i386_operand_type imm16_32 = OPERAND_TYPE_IMM16_32;
2095 static const i386_operand_type imm16_32s = OPERAND_TYPE_IMM16_32S;
2096 static const i386_operand_type imm16_32_32s = OPERAND_TYPE_IMM16_32_32S;
2097
2098 enum operand_type
2099 {
2100   reg,
2101   imm,
2102   disp,
2103   anymem
2104 };
2105
2106 static INLINE int
2107 operand_type_check (i386_operand_type t, enum operand_type c)
2108 {
2109   switch (c)
2110     {
2111     case reg:
2112       return t.bitfield.class == Reg;
2113
2114     case imm:
2115       return (t.bitfield.imm8
2116               || t.bitfield.imm8s
2117               || t.bitfield.imm16
2118               || t.bitfield.imm32
2119               || t.bitfield.imm32s
2120               || t.bitfield.imm64);
2121
2122     case disp:
2123       return (t.bitfield.disp8
2124               || t.bitfield.disp16
2125               || t.bitfield.disp32
2126               || t.bitfield.disp32s
2127               || t.bitfield.disp64);
2128
2129     case anymem:
2130       return (t.bitfield.disp8
2131               || t.bitfield.disp16
2132               || t.bitfield.disp32
2133               || t.bitfield.disp32s
2134               || t.bitfield.disp64
2135               || t.bitfield.baseindex);
2136
2137     default:
2138       abort ();
2139     }
2140
2141   return 0;
2142 }
2143
2144 /* Return 1 if there is no conflict in 8bit/16bit/32bit/64bit/80bit size
2145    between operand GIVEN and opeand WANTED for instruction template T.  */
2146
2147 static INLINE int
2148 match_operand_size (const insn_template *t, unsigned int wanted,
2149                     unsigned int given)
2150 {
2151   return !((i.types[given].bitfield.byte
2152             && !t->operand_types[wanted].bitfield.byte)
2153            || (i.types[given].bitfield.word
2154                && !t->operand_types[wanted].bitfield.word)
2155            || (i.types[given].bitfield.dword
2156                && !t->operand_types[wanted].bitfield.dword)
2157            || (i.types[given].bitfield.qword
2158                && !t->operand_types[wanted].bitfield.qword)
2159            || (i.types[given].bitfield.tbyte
2160                && !t->operand_types[wanted].bitfield.tbyte));
2161 }
2162
2163 /* Return 1 if there is no conflict in SIMD register between operand
2164    GIVEN and opeand WANTED for instruction template T.  */
2165
2166 static INLINE int
2167 match_simd_size (const insn_template *t, unsigned int wanted,
2168                  unsigned int given)
2169 {
2170   return !((i.types[given].bitfield.xmmword
2171             && !t->operand_types[wanted].bitfield.xmmword)
2172            || (i.types[given].bitfield.ymmword
2173                && !t->operand_types[wanted].bitfield.ymmword)
2174            || (i.types[given].bitfield.zmmword
2175                && !t->operand_types[wanted].bitfield.zmmword)
2176            || (i.types[given].bitfield.tmmword
2177                && !t->operand_types[wanted].bitfield.tmmword));
2178 }
2179
2180 /* Return 1 if there is no conflict in any size between operand GIVEN
2181    and opeand WANTED for instruction template T.  */
2182
2183 static INLINE int
2184 match_mem_size (const insn_template *t, unsigned int wanted,
2185                 unsigned int given)
2186 {
2187   return (match_operand_size (t, wanted, given)
2188           && !((i.types[given].bitfield.unspecified
2189                 && !i.broadcast
2190                 && !t->operand_types[wanted].bitfield.unspecified)
2191                || (i.types[given].bitfield.fword
2192                    && !t->operand_types[wanted].bitfield.fword)
2193                /* For scalar opcode templates to allow register and memory
2194                   operands at the same time, some special casing is needed
2195                   here.  Also for v{,p}broadcast*, {,v}pmov{s,z}*, and
2196                   down-conversion vpmov*.  */
2197                || ((t->operand_types[wanted].bitfield.class == RegSIMD
2198                     && t->operand_types[wanted].bitfield.byte
2199                        + t->operand_types[wanted].bitfield.word
2200                        + t->operand_types[wanted].bitfield.dword
2201                        + t->operand_types[wanted].bitfield.qword
2202                        > !!t->opcode_modifier.broadcast)
2203                    ? (i.types[given].bitfield.xmmword
2204                       || i.types[given].bitfield.ymmword
2205                       || i.types[given].bitfield.zmmword)
2206                    : !match_simd_size(t, wanted, given))));
2207 }
2208
2209 /* Return value has MATCH_STRAIGHT set if there is no size conflict on any
2210    operands for instruction template T, and it has MATCH_REVERSE set if there
2211    is no size conflict on any operands for the template with operands reversed
2212    (and the template allows for reversing in the first place).  */
2213
2214 #define MATCH_STRAIGHT 1
2215 #define MATCH_REVERSE  2
2216
2217 static INLINE unsigned int
2218 operand_size_match (const insn_template *t)
2219 {
2220   unsigned int j, match = MATCH_STRAIGHT;
2221
2222   /* Don't check non-absolute jump instructions.  */
2223   if (t->opcode_modifier.jump
2224       && t->opcode_modifier.jump != JUMP_ABSOLUTE)
2225     return match;
2226
2227   /* Check memory and accumulator operand size.  */
2228   for (j = 0; j < i.operands; j++)
2229     {
2230       if (i.types[j].bitfield.class != Reg
2231           && i.types[j].bitfield.class != RegSIMD
2232           && t->opcode_modifier.anysize)
2233         continue;
2234
2235       if (t->operand_types[j].bitfield.class == Reg
2236           && !match_operand_size (t, j, j))
2237         {
2238           match = 0;
2239           break;
2240         }
2241
2242       if (t->operand_types[j].bitfield.class == RegSIMD
2243           && !match_simd_size (t, j, j))
2244         {
2245           match = 0;
2246           break;
2247         }
2248
2249       if (t->operand_types[j].bitfield.instance == Accum
2250           && (!match_operand_size (t, j, j) || !match_simd_size (t, j, j)))
2251         {
2252           match = 0;
2253           break;
2254         }
2255
2256       if ((i.flags[j] & Operand_Mem) && !match_mem_size (t, j, j))
2257         {
2258           match = 0;
2259           break;
2260         }
2261     }
2262
2263   if (!t->opcode_modifier.d)
2264     {
2265     mismatch:
2266       if (!match)
2267         i.error = operand_size_mismatch;
2268       return match;
2269     }
2270
2271   /* Check reverse.  */
2272   gas_assert (i.operands >= 2 && i.operands <= 3);
2273
2274   for (j = 0; j < i.operands; j++)
2275     {
2276       unsigned int given = i.operands - j - 1;
2277
2278       if (t->operand_types[j].bitfield.class == Reg
2279           && !match_operand_size (t, j, given))
2280         goto mismatch;
2281
2282       if (t->operand_types[j].bitfield.class == RegSIMD
2283           && !match_simd_size (t, j, given))
2284         goto mismatch;
2285
2286       if (t->operand_types[j].bitfield.instance == Accum
2287           && (!match_operand_size (t, j, given)
2288               || !match_simd_size (t, j, given)))
2289         goto mismatch;
2290
2291       if ((i.flags[given] & Operand_Mem) && !match_mem_size (t, j, given))
2292         goto mismatch;
2293     }
2294
2295   return match | MATCH_REVERSE;
2296 }
2297
2298 static INLINE int
2299 operand_type_match (i386_operand_type overlap,
2300                     i386_operand_type given)
2301 {
2302   i386_operand_type temp = overlap;
2303
2304   temp.bitfield.unspecified = 0;
2305   temp.bitfield.byte = 0;
2306   temp.bitfield.word = 0;
2307   temp.bitfield.dword = 0;
2308   temp.bitfield.fword = 0;
2309   temp.bitfield.qword = 0;
2310   temp.bitfield.tbyte = 0;
2311   temp.bitfield.xmmword = 0;
2312   temp.bitfield.ymmword = 0;
2313   temp.bitfield.zmmword = 0;
2314   temp.bitfield.tmmword = 0;
2315   if (operand_type_all_zero (&temp))
2316     goto mismatch;
2317
2318   if (given.bitfield.baseindex == overlap.bitfield.baseindex)
2319     return 1;
2320
2321  mismatch:
2322   i.error = operand_type_mismatch;
2323   return 0;
2324 }
2325
2326 /* If given types g0 and g1 are registers they must be of the same type
2327    unless the expected operand type register overlap is null.
2328    Some Intel syntax memory operand size checking also happens here.  */
2329
2330 static INLINE int
2331 operand_type_register_match (i386_operand_type g0,
2332                              i386_operand_type t0,
2333                              i386_operand_type g1,
2334                              i386_operand_type t1)
2335 {
2336   if (g0.bitfield.class != Reg
2337       && g0.bitfield.class != RegSIMD
2338       && (!operand_type_check (g0, anymem)
2339           || g0.bitfield.unspecified
2340           || (t0.bitfield.class != Reg
2341               && t0.bitfield.class != RegSIMD)))
2342     return 1;
2343
2344   if (g1.bitfield.class != Reg
2345       && g1.bitfield.class != RegSIMD
2346       && (!operand_type_check (g1, anymem)
2347           || g1.bitfield.unspecified
2348           || (t1.bitfield.class != Reg
2349               && t1.bitfield.class != RegSIMD)))
2350     return 1;
2351
2352   if (g0.bitfield.byte == g1.bitfield.byte
2353       && g0.bitfield.word == g1.bitfield.word
2354       && g0.bitfield.dword == g1.bitfield.dword
2355       && g0.bitfield.qword == g1.bitfield.qword
2356       && g0.bitfield.xmmword == g1.bitfield.xmmword
2357       && g0.bitfield.ymmword == g1.bitfield.ymmword
2358       && g0.bitfield.zmmword == g1.bitfield.zmmword)
2359     return 1;
2360
2361   if (!(t0.bitfield.byte & t1.bitfield.byte)
2362       && !(t0.bitfield.word & t1.bitfield.word)
2363       && !(t0.bitfield.dword & t1.bitfield.dword)
2364       && !(t0.bitfield.qword & t1.bitfield.qword)
2365       && !(t0.bitfield.xmmword & t1.bitfield.xmmword)
2366       && !(t0.bitfield.ymmword & t1.bitfield.ymmword)
2367       && !(t0.bitfield.zmmword & t1.bitfield.zmmword))
2368     return 1;
2369
2370   i.error = register_type_mismatch;
2371
2372   return 0;
2373 }
2374
2375 static INLINE unsigned int
2376 register_number (const reg_entry *r)
2377 {
2378   unsigned int nr = r->reg_num;
2379
2380   if (r->reg_flags & RegRex)
2381     nr += 8;
2382
2383   if (r->reg_flags & RegVRex)
2384     nr += 16;
2385
2386   return nr;
2387 }
2388
2389 static INLINE unsigned int
2390 mode_from_disp_size (i386_operand_type t)
2391 {
2392   if (t.bitfield.disp8)
2393     return 1;
2394   else if (t.bitfield.disp16
2395            || t.bitfield.disp32
2396            || t.bitfield.disp32s)
2397     return 2;
2398   else
2399     return 0;
2400 }
2401
2402 static INLINE int
2403 fits_in_signed_byte (addressT num)
2404 {
2405   return num + 0x80 <= 0xff;
2406 }
2407
2408 static INLINE int
2409 fits_in_unsigned_byte (addressT num)
2410 {
2411   return num <= 0xff;
2412 }
2413
2414 static INLINE int
2415 fits_in_unsigned_word (addressT num)
2416 {
2417   return num <= 0xffff;
2418 }
2419
2420 static INLINE int
2421 fits_in_signed_word (addressT num)
2422 {
2423   return num + 0x8000 <= 0xffff;
2424 }
2425
2426 static INLINE int
2427 fits_in_signed_long (addressT num ATTRIBUTE_UNUSED)
2428 {
2429 #ifndef BFD64
2430   return 1;
2431 #else
2432   return num + 0x80000000 <= 0xffffffff;
2433 #endif
2434 }                               /* fits_in_signed_long() */
2435
2436 static INLINE int
2437 fits_in_unsigned_long (addressT num ATTRIBUTE_UNUSED)
2438 {
2439 #ifndef BFD64
2440   return 1;
2441 #else
2442   return num <= 0xffffffff;
2443 #endif
2444 }                               /* fits_in_unsigned_long() */
2445
2446 static INLINE int
2447 fits_in_disp8 (offsetT num)
2448 {
2449   int shift = i.memshift;
2450   unsigned int mask;
2451
2452   if (shift == -1)
2453     abort ();
2454
2455   mask = (1 << shift) - 1;
2456
2457   /* Return 0 if NUM isn't properly aligned.  */
2458   if ((num & mask))
2459     return 0;
2460
2461   /* Check if NUM will fit in 8bit after shift.  */
2462   return fits_in_signed_byte (num >> shift);
2463 }
2464
2465 static INLINE int
2466 fits_in_imm4 (offsetT num)
2467 {
2468   return (num & 0xf) == num;
2469 }
2470
2471 static i386_operand_type
2472 smallest_imm_type (offsetT num)
2473 {
2474   i386_operand_type t;
2475
2476   operand_type_set (&t, 0);
2477   t.bitfield.imm64 = 1;
2478
2479   if (cpu_arch_tune != PROCESSOR_I486 && num == 1)
2480     {
2481       /* This code is disabled on the 486 because all the Imm1 forms
2482          in the opcode table are slower on the i486.  They're the
2483          versions with the implicitly specified single-position
2484          displacement, which has another syntax if you really want to
2485          use that form.  */
2486       t.bitfield.imm1 = 1;
2487       t.bitfield.imm8 = 1;
2488       t.bitfield.imm8s = 1;
2489       t.bitfield.imm16 = 1;
2490       t.bitfield.imm32 = 1;
2491       t.bitfield.imm32s = 1;
2492     }
2493   else if (fits_in_signed_byte (num))
2494     {
2495       t.bitfield.imm8 = 1;
2496       t.bitfield.imm8s = 1;
2497       t.bitfield.imm16 = 1;
2498       t.bitfield.imm32 = 1;
2499       t.bitfield.imm32s = 1;
2500     }
2501   else if (fits_in_unsigned_byte (num))
2502     {
2503       t.bitfield.imm8 = 1;
2504       t.bitfield.imm16 = 1;
2505       t.bitfield.imm32 = 1;
2506       t.bitfield.imm32s = 1;
2507     }
2508   else if (fits_in_signed_word (num) || fits_in_unsigned_word (num))
2509     {
2510       t.bitfield.imm16 = 1;
2511       t.bitfield.imm32 = 1;
2512       t.bitfield.imm32s = 1;
2513     }
2514   else if (fits_in_signed_long (num))
2515     {
2516       t.bitfield.imm32 = 1;
2517       t.bitfield.imm32s = 1;
2518     }
2519   else if (fits_in_unsigned_long (num))
2520     t.bitfield.imm32 = 1;
2521
2522   return t;
2523 }
2524
2525 static offsetT
2526 offset_in_range (offsetT val, int size)
2527 {
2528   addressT mask;
2529
2530   switch (size)
2531     {
2532     case 1: mask = ((addressT) 1 <<  8) - 1; break;
2533     case 2: mask = ((addressT) 1 << 16) - 1; break;
2534     case 4: mask = ((addressT) 2 << 31) - 1; break;
2535 #ifdef BFD64
2536     case 8: mask = ((addressT) 2 << 63) - 1; break;
2537 #endif
2538     default: abort ();
2539     }
2540
2541   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
2542     {
2543       char buf1[40], buf2[40];
2544
2545       sprint_value (buf1, val);
2546       sprint_value (buf2, val & mask);
2547       as_warn (_("%s shortened to %s"), buf1, buf2);
2548     }
2549   return val & mask;
2550 }
2551
2552 enum PREFIX_GROUP
2553 {
2554   PREFIX_EXIST = 0,
2555   PREFIX_LOCK,
2556   PREFIX_REP,
2557   PREFIX_DS,
2558   PREFIX_OTHER
2559 };
2560
2561 /* Returns
2562    a. PREFIX_EXIST if attempting to add a prefix where one from the
2563    same class already exists.
2564    b. PREFIX_LOCK if lock prefix is added.
2565    c. PREFIX_REP if rep/repne prefix is added.
2566    d. PREFIX_DS if ds prefix is added.
2567    e. PREFIX_OTHER if other prefix is added.
2568  */
2569
2570 static enum PREFIX_GROUP
2571 add_prefix (unsigned int prefix)
2572 {
2573   enum PREFIX_GROUP ret = PREFIX_OTHER;
2574   unsigned int q;
2575
2576   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
2577       && flag_code == CODE_64BIT)
2578     {
2579       if ((i.prefix[REX_PREFIX] & prefix & REX_W)
2580           || (i.prefix[REX_PREFIX] & prefix & REX_R)
2581           || (i.prefix[REX_PREFIX] & prefix & REX_X)
2582           || (i.prefix[REX_PREFIX] & prefix & REX_B))
2583         ret = PREFIX_EXIST;
2584       q = REX_PREFIX;
2585     }
2586   else
2587     {
2588       switch (prefix)
2589         {
2590         default:
2591           abort ();
2592
2593         case DS_PREFIX_OPCODE:
2594           ret = PREFIX_DS;
2595           /* Fall through.  */
2596         case CS_PREFIX_OPCODE:
2597         case ES_PREFIX_OPCODE:
2598         case FS_PREFIX_OPCODE:
2599         case GS_PREFIX_OPCODE:
2600         case SS_PREFIX_OPCODE:
2601           q = SEG_PREFIX;
2602           break;
2603
2604         case REPNE_PREFIX_OPCODE:
2605         case REPE_PREFIX_OPCODE:
2606           q = REP_PREFIX;
2607           ret = PREFIX_REP;
2608           break;
2609
2610         case LOCK_PREFIX_OPCODE:
2611           q = LOCK_PREFIX;
2612           ret = PREFIX_LOCK;
2613           break;
2614
2615         case FWAIT_OPCODE:
2616           q = WAIT_PREFIX;
2617           break;
2618
2619         case ADDR_PREFIX_OPCODE:
2620           q = ADDR_PREFIX;
2621           break;
2622
2623         case DATA_PREFIX_OPCODE:
2624           q = DATA_PREFIX;
2625           break;
2626         }
2627       if (i.prefix[q] != 0)
2628         ret = PREFIX_EXIST;
2629     }
2630
2631   if (ret)
2632     {
2633       if (!i.prefix[q])
2634         ++i.prefixes;
2635       i.prefix[q] |= prefix;
2636     }
2637   else
2638     as_bad (_("same type of prefix used twice"));
2639
2640   return ret;
2641 }
2642
2643 static void
2644 update_code_flag (int value, int check)
2645 {
2646   PRINTF_LIKE ((*as_error));
2647
2648   flag_code = (enum flag_code) value;
2649   if (flag_code == CODE_64BIT)
2650     {
2651       cpu_arch_flags.bitfield.cpu64 = 1;
2652       cpu_arch_flags.bitfield.cpuno64 = 0;
2653     }
2654   else
2655     {
2656       cpu_arch_flags.bitfield.cpu64 = 0;
2657       cpu_arch_flags.bitfield.cpuno64 = 1;
2658     }
2659   if (value == CODE_64BIT && !cpu_arch_flags.bitfield.cpulm )
2660     {
2661       if (check)
2662         as_error = as_fatal;
2663       else
2664         as_error = as_bad;
2665       (*as_error) (_("64bit mode not supported on `%s'."),
2666                    cpu_arch_name ? cpu_arch_name : default_arch);
2667     }
2668   if (value == CODE_32BIT && !cpu_arch_flags.bitfield.cpui386)
2669     {
2670       if (check)
2671         as_error = as_fatal;
2672       else
2673         as_error = as_bad;
2674       (*as_error) (_("32bit mode not supported on `%s'."),
2675                    cpu_arch_name ? cpu_arch_name : default_arch);
2676     }
2677   stackop_size = '\0';
2678 }
2679
2680 static void
2681 set_code_flag (int value)
2682 {
2683   update_code_flag (value, 0);
2684 }
2685
2686 static void
2687 set_16bit_gcc_code_flag (int new_code_flag)
2688 {
2689   flag_code = (enum flag_code) new_code_flag;
2690   if (flag_code != CODE_16BIT)
2691     abort ();
2692   cpu_arch_flags.bitfield.cpu64 = 0;
2693   cpu_arch_flags.bitfield.cpuno64 = 1;
2694   stackop_size = LONG_MNEM_SUFFIX;
2695 }
2696
2697 static void
2698 set_intel_syntax (int syntax_flag)
2699 {
2700   /* Find out if register prefixing is specified.  */
2701   int ask_naked_reg = 0;
2702
2703   SKIP_WHITESPACE ();
2704   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2705     {
2706       char *string;
2707       int e = get_symbol_name (&string);
2708
2709       if (strcmp (string, "prefix") == 0)
2710         ask_naked_reg = 1;
2711       else if (strcmp (string, "noprefix") == 0)
2712         ask_naked_reg = -1;
2713       else
2714         as_bad (_("bad argument to syntax directive."));
2715       (void) restore_line_pointer (e);
2716     }
2717   demand_empty_rest_of_line ();
2718
2719   intel_syntax = syntax_flag;
2720
2721   if (ask_naked_reg == 0)
2722     allow_naked_reg = (intel_syntax
2723                        && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
2724   else
2725     allow_naked_reg = (ask_naked_reg < 0);
2726
2727   expr_set_rank (O_full_ptr, syntax_flag ? 10 : 0);
2728
2729   identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
2730   identifier_chars['$'] = intel_syntax ? '$' : 0;
2731   register_prefix = allow_naked_reg ? "" : "%";
2732 }
2733
2734 static void
2735 set_intel_mnemonic (int mnemonic_flag)
2736 {
2737   intel_mnemonic = mnemonic_flag;
2738 }
2739
2740 static void
2741 set_allow_index_reg (int flag)
2742 {
2743   allow_index_reg = flag;
2744 }
2745
2746 static void
2747 set_check (int what)
2748 {
2749   enum check_kind *kind;
2750   const char *str;
2751
2752   if (what)
2753     {
2754       kind = &operand_check;
2755       str = "operand";
2756     }
2757   else
2758     {
2759       kind = &sse_check;
2760       str = "sse";
2761     }
2762
2763   SKIP_WHITESPACE ();
2764
2765   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2766     {
2767       char *string;
2768       int e = get_symbol_name (&string);
2769
2770       if (strcmp (string, "none") == 0)
2771         *kind = check_none;
2772       else if (strcmp (string, "warning") == 0)
2773         *kind = check_warning;
2774       else if (strcmp (string, "error") == 0)
2775         *kind = check_error;
2776       else
2777         as_bad (_("bad argument to %s_check directive."), str);
2778       (void) restore_line_pointer (e);
2779     }
2780   else
2781     as_bad (_("missing argument for %s_check directive"), str);
2782
2783   demand_empty_rest_of_line ();
2784 }
2785
2786 static void
2787 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED,
2788                            i386_cpu_flags new_flag ATTRIBUTE_UNUSED)
2789 {
2790 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2791   static const char *arch;
2792
2793   /* Intel LIOM is only supported on ELF.  */
2794   if (!IS_ELF)
2795     return;
2796
2797   if (!arch)
2798     {
2799       /* Use cpu_arch_name if it is set in md_parse_option.  Otherwise
2800          use default_arch.  */
2801       arch = cpu_arch_name;
2802       if (!arch)
2803         arch = default_arch;
2804     }
2805
2806   /* If we are targeting Intel MCU, we must enable it.  */
2807   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_IAMCU
2808       || new_flag.bitfield.cpuiamcu)
2809     return;
2810
2811   /* If we are targeting Intel L1OM, we must enable it.  */
2812   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_L1OM
2813       || new_flag.bitfield.cpul1om)
2814     return;
2815
2816   /* If we are targeting Intel K1OM, we must enable it.  */
2817   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_K1OM
2818       || new_flag.bitfield.cpuk1om)
2819     return;
2820
2821   as_bad (_("`%s' is not supported on `%s'"), name, arch);
2822 #endif
2823 }
2824
2825 static void
2826 set_cpu_arch (int dummy ATTRIBUTE_UNUSED)
2827 {
2828   SKIP_WHITESPACE ();
2829
2830   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2831     {
2832       char *string;
2833       int e = get_symbol_name (&string);
2834       unsigned int j;
2835       i386_cpu_flags flags;
2836
2837       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
2838         {
2839           if (strcmp (string, cpu_arch[j].name) == 0)
2840             {
2841               check_cpu_arch_compatible (string, cpu_arch[j].flags);
2842
2843               if (*string != '.')
2844                 {
2845                   cpu_arch_name = cpu_arch[j].name;
2846                   cpu_sub_arch_name = NULL;
2847                   cpu_arch_flags = cpu_arch[j].flags;
2848                   if (flag_code == CODE_64BIT)
2849                     {
2850                       cpu_arch_flags.bitfield.cpu64 = 1;
2851                       cpu_arch_flags.bitfield.cpuno64 = 0;
2852                     }
2853                   else
2854                     {
2855                       cpu_arch_flags.bitfield.cpu64 = 0;
2856                       cpu_arch_flags.bitfield.cpuno64 = 1;
2857                     }
2858                   cpu_arch_isa = cpu_arch[j].type;
2859                   cpu_arch_isa_flags = cpu_arch[j].flags;
2860                   if (!cpu_arch_tune_set)
2861                     {
2862                       cpu_arch_tune = cpu_arch_isa;
2863                       cpu_arch_tune_flags = cpu_arch_isa_flags;
2864                     }
2865                   break;
2866                 }
2867
2868               flags = cpu_flags_or (cpu_arch_flags,
2869                                     cpu_arch[j].flags);
2870
2871               if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2872                 {
2873                   if (cpu_sub_arch_name)
2874                     {
2875                       char *name = cpu_sub_arch_name;
2876                       cpu_sub_arch_name = concat (name,
2877                                                   cpu_arch[j].name,
2878                                                   (const char *) NULL);
2879                       free (name);
2880                     }
2881                   else
2882                     cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
2883                   cpu_arch_flags = flags;
2884                   cpu_arch_isa_flags = flags;
2885                 }
2886               else
2887                 cpu_arch_isa_flags
2888                   = cpu_flags_or (cpu_arch_isa_flags,
2889                                   cpu_arch[j].flags);
2890               (void) restore_line_pointer (e);
2891               demand_empty_rest_of_line ();
2892               return;
2893             }
2894         }
2895
2896       if (*string == '.' && j >= ARRAY_SIZE (cpu_arch))
2897         {
2898           /* Disable an ISA extension.  */
2899           for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
2900             if (strcmp (string + 1, cpu_noarch [j].name) == 0)
2901               {
2902                 flags = cpu_flags_and_not (cpu_arch_flags,
2903                                            cpu_noarch[j].flags);
2904                 if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2905                   {
2906                     if (cpu_sub_arch_name)
2907                       {
2908                         char *name = cpu_sub_arch_name;
2909                         cpu_sub_arch_name = concat (name, string,
2910                                                     (const char *) NULL);
2911                         free (name);
2912                       }
2913                     else
2914                       cpu_sub_arch_name = xstrdup (string);
2915                     cpu_arch_flags = flags;
2916                     cpu_arch_isa_flags = flags;
2917                   }
2918                 (void) restore_line_pointer (e);
2919                 demand_empty_rest_of_line ();
2920                 return;
2921               }
2922
2923           j = ARRAY_SIZE (cpu_arch);
2924         }
2925
2926       if (j >= ARRAY_SIZE (cpu_arch))
2927         as_bad (_("no such architecture: `%s'"), string);
2928
2929       *input_line_pointer = e;
2930     }
2931   else
2932     as_bad (_("missing cpu architecture"));
2933
2934   no_cond_jump_promotion = 0;
2935   if (*input_line_pointer == ','
2936       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
2937     {
2938       char *string;
2939       char e;
2940
2941       ++input_line_pointer;
2942       e = get_symbol_name (&string);
2943
2944       if (strcmp (string, "nojumps") == 0)
2945         no_cond_jump_promotion = 1;
2946       else if (strcmp (string, "jumps") == 0)
2947         ;
2948       else
2949         as_bad (_("no such architecture modifier: `%s'"), string);
2950
2951       (void) restore_line_pointer (e);
2952     }
2953
2954   demand_empty_rest_of_line ();
2955 }
2956
2957 enum bfd_architecture
2958 i386_arch (void)
2959 {
2960   if (cpu_arch_isa == PROCESSOR_L1OM)
2961     {
2962       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2963           || flag_code != CODE_64BIT)
2964         as_fatal (_("Intel L1OM is 64bit ELF only"));
2965       return bfd_arch_l1om;
2966     }
2967   else if (cpu_arch_isa == PROCESSOR_K1OM)
2968     {
2969       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2970           || flag_code != CODE_64BIT)
2971         as_fatal (_("Intel K1OM is 64bit ELF only"));
2972       return bfd_arch_k1om;
2973     }
2974   else if (cpu_arch_isa == PROCESSOR_IAMCU)
2975     {
2976       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2977           || flag_code == CODE_64BIT)
2978         as_fatal (_("Intel MCU is 32bit ELF only"));
2979       return bfd_arch_iamcu;
2980     }
2981   else
2982     return bfd_arch_i386;
2983 }
2984
2985 unsigned long
2986 i386_mach (void)
2987 {
2988   if (!strncmp (default_arch, "x86_64", 6))
2989     {
2990       if (cpu_arch_isa == PROCESSOR_L1OM)
2991         {
2992           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2993               || default_arch[6] != '\0')
2994             as_fatal (_("Intel L1OM is 64bit ELF only"));
2995           return bfd_mach_l1om;
2996         }
2997       else if (cpu_arch_isa == PROCESSOR_K1OM)
2998         {
2999           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
3000               || default_arch[6] != '\0')
3001             as_fatal (_("Intel K1OM is 64bit ELF only"));
3002           return bfd_mach_k1om;
3003         }
3004       else if (default_arch[6] == '\0')
3005         return bfd_mach_x86_64;
3006       else
3007         return bfd_mach_x64_32;
3008     }
3009   else if (!strcmp (default_arch, "i386")
3010            || !strcmp (default_arch, "iamcu"))
3011     {
3012       if (cpu_arch_isa == PROCESSOR_IAMCU)
3013         {
3014           if (OUTPUT_FLAVOR != bfd_target_elf_flavour)
3015             as_fatal (_("Intel MCU is 32bit ELF only"));
3016           return bfd_mach_i386_iamcu;
3017         }
3018       else
3019         return bfd_mach_i386_i386;
3020     }
3021   else
3022     as_fatal (_("unknown architecture"));
3023 }
3024 \f
3025 void
3026 md_begin (void)
3027 {
3028   const char *hash_err;
3029
3030   /* Support pseudo prefixes like {disp32}.  */
3031   lex_type ['{'] = LEX_BEGIN_NAME;
3032
3033   /* Initialize op_hash hash table.  */
3034   op_hash = hash_new ();
3035
3036   {
3037     const insn_template *optab;
3038     templates *core_optab;
3039
3040     /* Setup for loop.  */
3041     optab = i386_optab;
3042     core_optab = XNEW (templates);
3043     core_optab->start = optab;
3044
3045     while (1)
3046       {
3047         ++optab;
3048         if (optab->name == NULL
3049             || strcmp (optab->name, (optab - 1)->name) != 0)
3050           {
3051             /* different name --> ship out current template list;
3052                add to hash table; & begin anew.  */
3053             core_optab->end = optab;
3054             hash_err = hash_insert (op_hash,
3055                                     (optab - 1)->name,
3056                                     (void *) core_optab);
3057             if (hash_err)
3058               {
3059                 as_fatal (_("can't hash %s: %s"),
3060                           (optab - 1)->name,
3061                           hash_err);
3062               }
3063             if (optab->name == NULL)
3064               break;
3065             core_optab = XNEW (templates);
3066             core_optab->start = optab;
3067           }
3068       }
3069   }
3070
3071   /* Initialize reg_hash hash table.  */
3072   reg_hash = hash_new ();
3073   {
3074     const reg_entry *regtab;
3075     unsigned int regtab_size = i386_regtab_size;
3076
3077     for (regtab = i386_regtab; regtab_size--; regtab++)
3078       {
3079         hash_err = hash_insert (reg_hash, regtab->reg_name, (void *) regtab);
3080         if (hash_err)
3081           as_fatal (_("can't hash %s: %s"),
3082                     regtab->reg_name,
3083                     hash_err);
3084       }
3085   }
3086
3087   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
3088   {
3089     int c;
3090     char *p;
3091
3092     for (c = 0; c < 256; c++)
3093       {
3094         if (ISDIGIT (c))
3095           {
3096             digit_chars[c] = c;
3097             mnemonic_chars[c] = c;
3098             register_chars[c] = c;
3099             operand_chars[c] = c;
3100           }
3101         else if (ISLOWER (c))
3102           {
3103             mnemonic_chars[c] = c;
3104             register_chars[c] = c;
3105             operand_chars[c] = c;
3106           }
3107         else if (ISUPPER (c))
3108           {
3109             mnemonic_chars[c] = TOLOWER (c);
3110             register_chars[c] = mnemonic_chars[c];
3111             operand_chars[c] = c;
3112           }
3113         else if (c == '{' || c == '}')
3114           {
3115             mnemonic_chars[c] = c;
3116             operand_chars[c] = c;
3117           }
3118 #ifdef SVR4_COMMENT_CHARS
3119         else if (c == '\\' && strchr (i386_comment_chars, '/'))
3120           operand_chars[c] = c;
3121 #endif
3122
3123         if (ISALPHA (c) || ISDIGIT (c))
3124           identifier_chars[c] = c;
3125         else if (c >= 128)
3126           {
3127             identifier_chars[c] = c;
3128             operand_chars[c] = c;
3129           }
3130       }
3131
3132 #ifdef LEX_AT
3133     identifier_chars['@'] = '@';
3134 #endif
3135 #ifdef LEX_QM
3136     identifier_chars['?'] = '?';
3137     operand_chars['?'] = '?';
3138 #endif
3139     digit_chars['-'] = '-';
3140     mnemonic_chars['_'] = '_';
3141     mnemonic_chars['-'] = '-';
3142     mnemonic_chars['.'] = '.';
3143     identifier_chars['_'] = '_';
3144     identifier_chars['.'] = '.';
3145
3146     for (p = operand_special_chars; *p != '\0'; p++)
3147       operand_chars[(unsigned char) *p] = *p;
3148   }
3149
3150   if (flag_code == CODE_64BIT)
3151     {
3152 #if defined (OBJ_COFF) && defined (TE_PE)
3153       x86_dwarf2_return_column = (OUTPUT_FLAVOR == bfd_target_coff_flavour
3154                                   ? 32 : 16);
3155 #else
3156       x86_dwarf2_return_column = 16;
3157 #endif
3158       x86_cie_data_alignment = -8;
3159     }
3160   else
3161     {
3162       x86_dwarf2_return_column = 8;
3163       x86_cie_data_alignment = -4;
3164     }
3165
3166   /* NB: FUSED_JCC_PADDING frag must have sufficient room so that it
3167      can be turned into BRANCH_PREFIX frag.  */
3168   if (align_branch_prefix_size > MAX_FUSED_JCC_PADDING_SIZE)
3169     abort ();
3170 }
3171
3172 void
3173 i386_print_statistics (FILE *file)
3174 {
3175   hash_print_statistics (file, "i386 opcode", op_hash);
3176   hash_print_statistics (file, "i386 register", reg_hash);
3177 }
3178 \f
3179 #ifdef DEBUG386
3180
3181 /* Debugging routines for md_assemble.  */
3182 static void pte (insn_template *);
3183 static void pt (i386_operand_type);
3184 static void pe (expressionS *);
3185 static void ps (symbolS *);
3186
3187 static void
3188 pi (const char *line, i386_insn *x)
3189 {
3190   unsigned int j;
3191
3192   fprintf (stdout, "%s: template ", line);
3193   pte (&x->tm);
3194   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
3195            x->base_reg ? x->base_reg->reg_name : "none",
3196            x->index_reg ? x->index_reg->reg_name : "none",
3197            x->log2_scale_factor);
3198   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
3199            x->rm.mode, x->rm.reg, x->rm.regmem);
3200   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
3201            x->sib.base, x->sib.index, x->sib.scale);
3202   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
3203            (x->rex & REX_W) != 0,
3204            (x->rex & REX_R) != 0,
3205            (x->rex & REX_X) != 0,
3206            (x->rex & REX_B) != 0);
3207   for (j = 0; j < x->operands; j++)
3208     {
3209       fprintf (stdout, "    #%d:  ", j + 1);
3210       pt (x->types[j]);
3211       fprintf (stdout, "\n");
3212       if (x->types[j].bitfield.class == Reg
3213           || x->types[j].bitfield.class == RegMMX
3214           || x->types[j].bitfield.class == RegSIMD
3215           || x->types[j].bitfield.class == RegMask
3216           || x->types[j].bitfield.class == SReg
3217           || x->types[j].bitfield.class == RegCR
3218           || x->types[j].bitfield.class == RegDR
3219           || x->types[j].bitfield.class == RegTR
3220           || x->types[j].bitfield.class == RegBND)
3221         fprintf (stdout, "%s\n", x->op[j].regs->reg_name);
3222       if (operand_type_check (x->types[j], imm))
3223         pe (x->op[j].imms);
3224       if (operand_type_check (x->types[j], disp))
3225         pe (x->op[j].disps);
3226     }
3227 }
3228
3229 static void
3230 pte (insn_template *t)
3231 {
3232   unsigned int j;
3233   fprintf (stdout, " %d operands ", t->operands);
3234   fprintf (stdout, "opcode %x ", t->base_opcode);
3235   if (t->extension_opcode != None)
3236     fprintf (stdout, "ext %x ", t->extension_opcode);
3237   if (t->opcode_modifier.d)
3238     fprintf (stdout, "D");
3239   if (t->opcode_modifier.w)
3240     fprintf (stdout, "W");
3241   fprintf (stdout, "\n");
3242   for (j = 0; j < t->operands; j++)
3243     {
3244       fprintf (stdout, "    #%d type ", j + 1);
3245       pt (t->operand_types[j]);
3246       fprintf (stdout, "\n");
3247     }
3248 }
3249
3250 static void
3251 pe (expressionS *e)
3252 {
3253   fprintf (stdout, "    operation     %d\n", e->X_op);
3254   fprintf (stdout, "    add_number    %ld (%lx)\n",
3255            (long) e->X_add_number, (long) e->X_add_number);
3256   if (e->X_add_symbol)
3257     {
3258       fprintf (stdout, "    add_symbol    ");
3259       ps (e->X_add_symbol);
3260       fprintf (stdout, "\n");
3261     }
3262   if (e->X_op_symbol)
3263     {
3264       fprintf (stdout, "    op_symbol    ");
3265       ps (e->X_op_symbol);
3266       fprintf (stdout, "\n");
3267     }
3268 }
3269
3270 static void
3271 ps (symbolS *s)
3272 {
3273   fprintf (stdout, "%s type %s%s",
3274            S_GET_NAME (s),
3275            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
3276            segment_name (S_GET_SEGMENT (s)));
3277 }
3278
3279 static struct type_name
3280   {
3281     i386_operand_type mask;
3282     const char *name;
3283   }
3284 const type_names[] =
3285 {
3286   { OPERAND_TYPE_REG8, "r8" },
3287   { OPERAND_TYPE_REG16, "r16" },
3288   { OPERAND_TYPE_REG32, "r32" },
3289   { OPERAND_TYPE_REG64, "r64" },
3290   { OPERAND_TYPE_ACC8, "acc8" },
3291   { OPERAND_TYPE_ACC16, "acc16" },
3292   { OPERAND_TYPE_ACC32, "acc32" },
3293   { OPERAND_TYPE_ACC64, "acc64" },
3294   { OPERAND_TYPE_IMM8, "i8" },
3295   { OPERAND_TYPE_IMM8, "i8s" },
3296   { OPERAND_TYPE_IMM16, "i16" },
3297   { OPERAND_TYPE_IMM32, "i32" },
3298   { OPERAND_TYPE_IMM32S, "i32s" },
3299   { OPERAND_TYPE_IMM64, "i64" },
3300   { OPERAND_TYPE_IMM1, "i1" },
3301   { OPERAND_TYPE_BASEINDEX, "BaseIndex" },
3302   { OPERAND_TYPE_DISP8, "d8" },
3303   { OPERAND_TYPE_DISP16, "d16" },
3304   { OPERAND_TYPE_DISP32, "d32" },
3305   { OPERAND_TYPE_DISP32S, "d32s" },
3306   { OPERAND_TYPE_DISP64, "d64" },
3307   { OPERAND_TYPE_INOUTPORTREG, "InOutPortReg" },
3308   { OPERAND_TYPE_SHIFTCOUNT, "ShiftCount" },
3309   { OPERAND_TYPE_CONTROL, "control reg" },
3310   { OPERAND_TYPE_TEST, "test reg" },
3311   { OPERAND_TYPE_DEBUG, "debug reg" },
3312   { OPERAND_TYPE_FLOATREG, "FReg" },
3313   { OPERAND_TYPE_FLOATACC, "FAcc" },
3314   { OPERAND_TYPE_SREG, "SReg" },
3315   { OPERAND_TYPE_REGMMX, "rMMX" },
3316   { OPERAND_TYPE_REGXMM, "rXMM" },
3317   { OPERAND_TYPE_REGYMM, "rYMM" },
3318   { OPERAND_TYPE_REGZMM, "rZMM" },
3319   { OPERAND_TYPE_REGTMM, "rTMM" },
3320   { OPERAND_TYPE_REGMASK, "Mask reg" },
3321 };
3322
3323 static void
3324 pt (i386_operand_type t)
3325 {
3326   unsigned int j;
3327   i386_operand_type a;
3328
3329   for (j = 0; j < ARRAY_SIZE (type_names); j++)
3330     {
3331       a = operand_type_and (t, type_names[j].mask);
3332       if (operand_type_equal (&a, &type_names[j].mask))
3333         fprintf (stdout, "%s, ",  type_names[j].name);
3334     }
3335   fflush (stdout);
3336 }
3337
3338 #endif /* DEBUG386 */
3339 \f
3340 static bfd_reloc_code_real_type
3341 reloc (unsigned int size,
3342        int pcrel,
3343        int sign,
3344        bfd_reloc_code_real_type other)
3345 {
3346   if (other != NO_RELOC)
3347     {
3348       reloc_howto_type *rel;
3349
3350       if (size == 8)
3351         switch (other)
3352           {
3353           case BFD_RELOC_X86_64_GOT32:
3354             return BFD_RELOC_X86_64_GOT64;
3355             break;
3356           case BFD_RELOC_X86_64_GOTPLT64:
3357             return BFD_RELOC_X86_64_GOTPLT64;
3358             break;
3359           case BFD_RELOC_X86_64_PLTOFF64:
3360             return BFD_RELOC_X86_64_PLTOFF64;
3361             break;
3362           case BFD_RELOC_X86_64_GOTPC32:
3363             other = BFD_RELOC_X86_64_GOTPC64;
3364             break;
3365           case BFD_RELOC_X86_64_GOTPCREL:
3366             other = BFD_RELOC_X86_64_GOTPCREL64;
3367             break;
3368           case BFD_RELOC_X86_64_TPOFF32:
3369             other = BFD_RELOC_X86_64_TPOFF64;
3370             break;
3371           case BFD_RELOC_X86_64_DTPOFF32:
3372             other = BFD_RELOC_X86_64_DTPOFF64;
3373             break;
3374           default:
3375             break;
3376           }
3377
3378 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3379       if (other == BFD_RELOC_SIZE32)
3380         {
3381           if (size == 8)
3382             other = BFD_RELOC_SIZE64;
3383           if (pcrel)
3384             {
3385               as_bad (_("there are no pc-relative size relocations"));
3386               return NO_RELOC;
3387             }
3388         }
3389 #endif
3390
3391       /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless.  */
3392       if (size == 4 && (flag_code != CODE_64BIT || disallow_64bit_reloc))
3393         sign = -1;
3394
3395       rel = bfd_reloc_type_lookup (stdoutput, other);
3396       if (!rel)
3397         as_bad (_("unknown relocation (%u)"), other);
3398       else if (size != bfd_get_reloc_size (rel))
3399         as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
3400                 bfd_get_reloc_size (rel),
3401                 size);
3402       else if (pcrel && !rel->pc_relative)
3403         as_bad (_("non-pc-relative relocation for pc-relative field"));
3404       else if ((rel->complain_on_overflow == complain_overflow_signed
3405                 && !sign)
3406                || (rel->complain_on_overflow == complain_overflow_unsigned
3407                    && sign > 0))
3408         as_bad (_("relocated field and relocation type differ in signedness"));
3409       else
3410         return other;
3411       return NO_RELOC;
3412     }
3413
3414   if (pcrel)
3415     {
3416       if (!sign)
3417         as_bad (_("there are no unsigned pc-relative relocations"));
3418       switch (size)
3419         {
3420         case 1: return BFD_RELOC_8_PCREL;
3421         case 2: return BFD_RELOC_16_PCREL;
3422         case 4: return BFD_RELOC_32_PCREL;
3423         case 8: return BFD_RELOC_64_PCREL;
3424         }
3425       as_bad (_("cannot do %u byte pc-relative relocation"), size);
3426     }
3427   else
3428     {
3429       if (sign > 0)
3430         switch (size)
3431           {
3432           case 4: return BFD_RELOC_X86_64_32S;
3433           }
3434       else
3435         switch (size)
3436           {
3437           case 1: return BFD_RELOC_8;
3438           case 2: return BFD_RELOC_16;
3439           case 4: return BFD_RELOC_32;
3440           case 8: return BFD_RELOC_64;
3441           }
3442       as_bad (_("cannot do %s %u byte relocation"),
3443               sign > 0 ? "signed" : "unsigned", size);
3444     }
3445
3446   return NO_RELOC;
3447 }
3448
3449 /* Here we decide which fixups can be adjusted to make them relative to
3450    the beginning of the section instead of the symbol.  Basically we need
3451    to make sure that the dynamic relocations are done correctly, so in
3452    some cases we force the original symbol to be used.  */
3453
3454 int
3455 tc_i386_fix_adjustable (fixS *fixP ATTRIBUTE_UNUSED)
3456 {
3457 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3458   if (!IS_ELF)
3459     return 1;
3460
3461   /* Don't adjust pc-relative references to merge sections in 64-bit
3462      mode.  */
3463   if (use_rela_relocations
3464       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
3465       && fixP->fx_pcrel)
3466     return 0;
3467
3468   /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
3469      and changed later by validate_fix.  */
3470   if (GOT_symbol && fixP->fx_subsy == GOT_symbol
3471       && fixP->fx_r_type == BFD_RELOC_32_PCREL)
3472     return 0;
3473
3474   /* Adjust_reloc_syms doesn't know about the GOT.  Need to keep symbol
3475      for size relocations.  */
3476   if (fixP->fx_r_type == BFD_RELOC_SIZE32
3477       || fixP->fx_r_type == BFD_RELOC_SIZE64
3478       || fixP->fx_r_type == BFD_RELOC_386_GOTOFF
3479       || fixP->fx_r_type == BFD_RELOC_386_GOT32
3480       || fixP->fx_r_type == BFD_RELOC_386_GOT32X
3481       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
3482       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
3483       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
3484       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
3485       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
3486       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
3487       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
3488       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
3489       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
3490       || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
3491       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
3492       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
3493       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCRELX
3494       || fixP->fx_r_type == BFD_RELOC_X86_64_REX_GOTPCRELX
3495       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
3496       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
3497       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
3498       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
3499       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
3500       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
3501       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
3502       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
3503       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
3504       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
3505       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3506       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3507     return 0;
3508 #endif
3509   return 1;
3510 }
3511
3512 static int
3513 intel_float_operand (const char *mnemonic)
3514 {
3515   /* Note that the value returned is meaningful only for opcodes with (memory)
3516      operands, hence the code here is free to improperly handle opcodes that
3517      have no operands (for better performance and smaller code). */
3518
3519   if (mnemonic[0] != 'f')
3520     return 0; /* non-math */
3521
3522   switch (mnemonic[1])
3523     {
3524     /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
3525        the fs segment override prefix not currently handled because no
3526        call path can make opcodes without operands get here */
3527     case 'i':
3528       return 2 /* integer op */;
3529     case 'l':
3530       if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
3531         return 3; /* fldcw/fldenv */
3532       break;
3533     case 'n':
3534       if (mnemonic[2] != 'o' /* fnop */)
3535         return 3; /* non-waiting control op */
3536       break;
3537     case 'r':
3538       if (mnemonic[2] == 's')
3539         return 3; /* frstor/frstpm */
3540       break;
3541     case 's':
3542       if (mnemonic[2] == 'a')
3543         return 3; /* fsave */
3544       if (mnemonic[2] == 't')
3545         {
3546           switch (mnemonic[3])
3547             {
3548             case 'c': /* fstcw */
3549             case 'd': /* fstdw */
3550             case 'e': /* fstenv */
3551             case 's': /* fsts[gw] */
3552               return 3;
3553             }
3554         }
3555       break;
3556     case 'x':
3557       if (mnemonic[2] == 'r' || mnemonic[2] == 's')
3558         return 0; /* fxsave/fxrstor are not really math ops */
3559       break;
3560     }
3561
3562   return 1;
3563 }
3564
3565 /* Build the VEX prefix.  */
3566
3567 static void
3568 build_vex_prefix (const insn_template *t)
3569 {
3570   unsigned int register_specifier;
3571   unsigned int implied_prefix;
3572   unsigned int vector_length;
3573   unsigned int w;
3574
3575   /* Check register specifier.  */
3576   if (i.vex.register_specifier)
3577     {
3578       register_specifier =
3579         ~register_number (i.vex.register_specifier) & 0xf;
3580       gas_assert ((i.vex.register_specifier->reg_flags & RegVRex) == 0);
3581     }
3582   else
3583     register_specifier = 0xf;
3584
3585   /* Use 2-byte VEX prefix by swapping destination and source operand
3586      if there are more than 1 register operand.  */
3587   if (i.reg_operands > 1
3588       && i.vec_encoding != vex_encoding_vex3
3589       && i.dir_encoding == dir_encoding_default
3590       && i.operands == i.reg_operands
3591       && operand_type_equal (&i.types[0], &i.types[i.operands - 1])
3592       && i.tm.opcode_modifier.vexopcode == VEX0F
3593       && (i.tm.opcode_modifier.load || i.tm.opcode_modifier.d)
3594       && i.rex == REX_B)
3595     {
3596       unsigned int xchg = i.operands - 1;
3597       union i386_op temp_op;
3598       i386_operand_type temp_type;
3599
3600       temp_type = i.types[xchg];
3601       i.types[xchg] = i.types[0];
3602       i.types[0] = temp_type;
3603       temp_op = i.op[xchg];
3604       i.op[xchg] = i.op[0];
3605       i.op[0] = temp_op;
3606
3607       gas_assert (i.rm.mode == 3);
3608
3609       i.rex = REX_R;
3610       xchg = i.rm.regmem;
3611       i.rm.regmem = i.rm.reg;
3612       i.rm.reg = xchg;
3613
3614       if (i.tm.opcode_modifier.d)
3615         i.tm.base_opcode ^= (i.tm.base_opcode & 0xee) != 0x6e
3616                             ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
3617       else /* Use the next insn.  */
3618         i.tm = t[1];
3619     }
3620
3621   /* Use 2-byte VEX prefix by swapping commutative source operands if there
3622      are no memory operands and at least 3 register ones.  */
3623   if (i.reg_operands >= 3
3624       && i.vec_encoding != vex_encoding_vex3
3625       && i.reg_operands == i.operands - i.imm_operands
3626       && i.tm.opcode_modifier.vex
3627       && i.tm.opcode_modifier.commutative
3628       && (i.tm.opcode_modifier.sse2avx || optimize > 1)
3629       && i.rex == REX_B
3630       && i.vex.register_specifier
3631       && !(i.vex.register_specifier->reg_flags & RegRex))
3632     {
3633       unsigned int xchg = i.operands - i.reg_operands;
3634       union i386_op temp_op;
3635       i386_operand_type temp_type;
3636
3637       gas_assert (i.tm.opcode_modifier.vexopcode == VEX0F);
3638       gas_assert (!i.tm.opcode_modifier.sae);
3639       gas_assert (operand_type_equal (&i.types[i.operands - 2],
3640                                       &i.types[i.operands - 3]));
3641       gas_assert (i.rm.mode == 3);
3642
3643       temp_type = i.types[xchg];
3644       i.types[xchg] = i.types[xchg + 1];
3645       i.types[xchg + 1] = temp_type;
3646       temp_op = i.op[xchg];
3647       i.op[xchg] = i.op[xchg + 1];
3648       i.op[xchg + 1] = temp_op;
3649
3650       i.rex = 0;
3651       xchg = i.rm.regmem | 8;
3652       i.rm.regmem = ~register_specifier & 0xf;
3653       gas_assert (!(i.rm.regmem & 8));
3654       i.vex.register_specifier += xchg - i.rm.regmem;
3655       register_specifier = ~xchg & 0xf;
3656     }
3657
3658   if (i.tm.opcode_modifier.vex == VEXScalar)
3659     vector_length = avxscalar;
3660   else if (i.tm.opcode_modifier.vex == VEX256)
3661     vector_length = 1;
3662   else
3663     {
3664       unsigned int op;
3665
3666       /* Determine vector length from the last multi-length vector
3667          operand.  */
3668       vector_length = 0;
3669       for (op = t->operands; op--;)
3670         if (t->operand_types[op].bitfield.xmmword
3671             && t->operand_types[op].bitfield.ymmword
3672             && i.types[op].bitfield.ymmword)
3673           {
3674             vector_length = 1;
3675             break;
3676           }
3677     }
3678
3679   switch ((i.tm.base_opcode >> (i.tm.opcode_length << 3)) & 0xff)
3680     {
3681     case 0:
3682       implied_prefix = 0;
3683       break;
3684     case DATA_PREFIX_OPCODE:
3685       implied_prefix = 1;
3686       break;
3687     case REPE_PREFIX_OPCODE:
3688       implied_prefix = 2;
3689       break;
3690     case REPNE_PREFIX_OPCODE:
3691       implied_prefix = 3;
3692       break;
3693     default:
3694       abort ();
3695     }
3696
3697   /* Check the REX.W bit and VEXW.  */
3698   if (i.tm.opcode_modifier.vexw == VEXWIG)
3699     w = (vexwig == vexw1 || (i.rex & REX_W)) ? 1 : 0;
3700   else if (i.tm.opcode_modifier.vexw)
3701     w = i.tm.opcode_modifier.vexw == VEXW1 ? 1 : 0;
3702   else
3703     w = (flag_code == CODE_64BIT ? i.rex & REX_W : vexwig == vexw1) ? 1 : 0;
3704
3705   /* Use 2-byte VEX prefix if possible.  */
3706   if (w == 0
3707       && i.vec_encoding != vex_encoding_vex3
3708       && i.tm.opcode_modifier.vexopcode == VEX0F
3709       && (i.rex & (REX_W | REX_X | REX_B)) == 0)
3710     {
3711       /* 2-byte VEX prefix.  */
3712       unsigned int r;
3713
3714       i.vex.length = 2;
3715       i.vex.bytes[0] = 0xc5;
3716
3717       /* Check the REX.R bit.  */
3718       r = (i.rex & REX_R) ? 0 : 1;
3719       i.vex.bytes[1] = (r << 7
3720                         | register_specifier << 3
3721                         | vector_length << 2
3722                         | implied_prefix);
3723     }
3724   else
3725     {
3726       /* 3-byte VEX prefix.  */
3727       unsigned int m;
3728
3729       i.vex.length = 3;
3730
3731       switch (i.tm.opcode_modifier.vexopcode)
3732         {
3733         case VEX0F:
3734           m = 0x1;
3735           i.vex.bytes[0] = 0xc4;
3736           break;
3737         case VEX0F38:
3738           m = 0x2;
3739           i.vex.bytes[0] = 0xc4;
3740           break;
3741         case VEX0F3A:
3742           m = 0x3;
3743           i.vex.bytes[0] = 0xc4;
3744           break;
3745         case XOP08:
3746           m = 0x8;
3747           i.vex.bytes[0] = 0x8f;
3748           break;
3749         case XOP09:
3750           m = 0x9;
3751           i.vex.bytes[0] = 0x8f;
3752           break;
3753         case XOP0A:
3754           m = 0xa;
3755           i.vex.bytes[0] = 0x8f;
3756           break;
3757         default:
3758           abort ();
3759         }
3760
3761       /* The high 3 bits of the second VEX byte are 1's compliment
3762          of RXB bits from REX.  */
3763       i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3764
3765       i.vex.bytes[2] = (w << 7
3766                         | register_specifier << 3
3767                         | vector_length << 2
3768                         | implied_prefix);
3769     }
3770 }
3771
3772 static INLINE bfd_boolean
3773 is_evex_encoding (const insn_template *t)
3774 {
3775   return t->opcode_modifier.evex || t->opcode_modifier.disp8memshift
3776          || t->opcode_modifier.broadcast || t->opcode_modifier.masking
3777          || t->opcode_modifier.sae;
3778 }
3779
3780 static INLINE bfd_boolean
3781 is_any_vex_encoding (const insn_template *t)
3782 {
3783   return t->opcode_modifier.vex || t->opcode_modifier.vexopcode
3784          || is_evex_encoding (t);
3785 }
3786
3787 /* Build the EVEX prefix.  */
3788
3789 static void
3790 build_evex_prefix (void)
3791 {
3792   unsigned int register_specifier;
3793   unsigned int implied_prefix;
3794   unsigned int m, w;
3795   rex_byte vrex_used = 0;
3796
3797   /* Check register specifier.  */
3798   if (i.vex.register_specifier)
3799     {
3800       gas_assert ((i.vrex & REX_X) == 0);
3801
3802       register_specifier = i.vex.register_specifier->reg_num;
3803       if ((i.vex.register_specifier->reg_flags & RegRex))
3804         register_specifier += 8;
3805       /* The upper 16 registers are encoded in the fourth byte of the
3806          EVEX prefix.  */
3807       if (!(i.vex.register_specifier->reg_flags & RegVRex))
3808         i.vex.bytes[3] = 0x8;
3809       register_specifier = ~register_specifier & 0xf;
3810     }
3811   else
3812     {
3813       register_specifier = 0xf;
3814
3815       /* Encode upper 16 vector index register in the fourth byte of
3816          the EVEX prefix.  */
3817       if (!(i.vrex & REX_X))
3818         i.vex.bytes[3] = 0x8;
3819       else
3820         vrex_used |= REX_X;
3821     }
3822
3823   switch ((i.tm.base_opcode >> 8) & 0xff)
3824     {
3825     case 0:
3826       implied_prefix = 0;
3827       break;
3828     case DATA_PREFIX_OPCODE:
3829       implied_prefix = 1;
3830       break;
3831     case REPE_PREFIX_OPCODE:
3832       implied_prefix = 2;
3833       break;
3834     case REPNE_PREFIX_OPCODE:
3835       implied_prefix = 3;
3836       break;
3837     default:
3838       abort ();
3839     }
3840
3841   /* 4 byte EVEX prefix.  */
3842   i.vex.length = 4;
3843   i.vex.bytes[0] = 0x62;
3844
3845   /* mmmm bits.  */
3846   switch (i.tm.opcode_modifier.vexopcode)
3847     {
3848     case VEX0F:
3849       m = 1;
3850       break;
3851     case VEX0F38:
3852       m = 2;
3853       break;
3854     case VEX0F3A:
3855       m = 3;
3856       break;
3857     default:
3858       abort ();
3859       break;
3860     }
3861
3862   /* The high 3 bits of the second EVEX byte are 1's compliment of RXB
3863      bits from REX.  */
3864   i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3865
3866   /* The fifth bit of the second EVEX byte is 1's compliment of the
3867      REX_R bit in VREX.  */
3868   if (!(i.vrex & REX_R))
3869     i.vex.bytes[1] |= 0x10;
3870   else
3871     vrex_used |= REX_R;
3872
3873   if ((i.reg_operands + i.imm_operands) == i.operands)
3874     {
3875       /* When all operands are registers, the REX_X bit in REX is not
3876          used.  We reuse it to encode the upper 16 registers, which is
3877          indicated by the REX_B bit in VREX.  The REX_X bit is encoded
3878          as 1's compliment.  */
3879       if ((i.vrex & REX_B))
3880         {
3881           vrex_used |= REX_B;
3882           i.vex.bytes[1] &= ~0x40;
3883         }
3884     }
3885
3886   /* EVEX instructions shouldn't need the REX prefix.  */
3887   i.vrex &= ~vrex_used;
3888   gas_assert (i.vrex == 0);
3889
3890   /* Check the REX.W bit and VEXW.  */
3891   if (i.tm.opcode_modifier.vexw == VEXWIG)
3892     w = (evexwig == evexw1 || (i.rex & REX_W)) ? 1 : 0;
3893   else if (i.tm.opcode_modifier.vexw)
3894     w = i.tm.opcode_modifier.vexw == VEXW1 ? 1 : 0;
3895   else
3896     w = (flag_code == CODE_64BIT ? i.rex & REX_W : evexwig == evexw1) ? 1 : 0;
3897
3898   /* Encode the U bit.  */
3899   implied_prefix |= 0x4;
3900
3901   /* The third byte of the EVEX prefix.  */
3902   i.vex.bytes[2] = (w << 7 | register_specifier << 3 | implied_prefix);
3903
3904   /* The fourth byte of the EVEX prefix.  */
3905   /* The zeroing-masking bit.  */
3906   if (i.mask && i.mask->zeroing)
3907     i.vex.bytes[3] |= 0x80;
3908
3909   /* Don't always set the broadcast bit if there is no RC.  */
3910   if (!i.rounding)
3911     {
3912       /* Encode the vector length.  */
3913       unsigned int vec_length;
3914
3915       if (!i.tm.opcode_modifier.evex
3916           || i.tm.opcode_modifier.evex == EVEXDYN)
3917         {
3918           unsigned int op;
3919
3920           /* Determine vector length from the last multi-length vector
3921              operand.  */
3922           for (op = i.operands; op--;)
3923             if (i.tm.operand_types[op].bitfield.xmmword
3924                 + i.tm.operand_types[op].bitfield.ymmword
3925                 + i.tm.operand_types[op].bitfield.zmmword > 1)
3926               {
3927                 if (i.types[op].bitfield.zmmword)
3928                   {
3929                     i.tm.opcode_modifier.evex = EVEX512;
3930                     break;
3931                   }
3932                 else if (i.types[op].bitfield.ymmword)
3933                   {
3934                     i.tm.opcode_modifier.evex = EVEX256;
3935                     break;
3936                   }
3937                 else if (i.types[op].bitfield.xmmword)
3938                   {
3939                     i.tm.opcode_modifier.evex = EVEX128;
3940                     break;
3941                   }
3942                 else if (i.broadcast && (int) op == i.broadcast->operand)
3943                   {
3944                     switch (i.broadcast->bytes)
3945                       {
3946                         case 64:
3947                           i.tm.opcode_modifier.evex = EVEX512;
3948                           break;
3949                         case 32:
3950                           i.tm.opcode_modifier.evex = EVEX256;
3951                           break;
3952                         case 16:
3953                           i.tm.opcode_modifier.evex = EVEX128;
3954                           break;
3955                         default:
3956                           abort ();
3957                       }
3958                     break;
3959                   }
3960               }
3961
3962           if (op >= MAX_OPERANDS)
3963             abort ();
3964         }
3965
3966       switch (i.tm.opcode_modifier.evex)
3967         {
3968         case EVEXLIG: /* LL' is ignored */
3969           vec_length = evexlig << 5;
3970           break;
3971         case EVEX128:
3972           vec_length = 0 << 5;
3973           break;
3974         case EVEX256:
3975           vec_length = 1 << 5;
3976           break;
3977         case EVEX512:
3978           vec_length = 2 << 5;
3979           break;
3980         default:
3981           abort ();
3982           break;
3983         }
3984       i.vex.bytes[3] |= vec_length;
3985       /* Encode the broadcast bit.  */
3986       if (i.broadcast)
3987         i.vex.bytes[3] |= 0x10;
3988     }
3989   else
3990     {
3991       if (i.rounding->type != saeonly)
3992         i.vex.bytes[3] |= 0x10 | (i.rounding->type << 5);
3993       else
3994         i.vex.bytes[3] |= 0x10 | (evexrcig << 5);
3995     }
3996
3997   if (i.mask && i.mask->mask)
3998     i.vex.bytes[3] |= i.mask->mask->reg_num;
3999 }
4000
4001 static void
4002 process_immext (void)
4003 {
4004   expressionS *exp;
4005
4006   /* These AMD 3DNow! and SSE2 instructions have an opcode suffix
4007      which is coded in the same place as an 8-bit immediate field
4008      would be.  Here we fake an 8-bit immediate operand from the
4009      opcode suffix stored in tm.extension_opcode.
4010
4011      AVX instructions also use this encoding, for some of
4012      3 argument instructions.  */
4013
4014   gas_assert (i.imm_operands <= 1
4015               && (i.operands <= 2
4016                   || (is_any_vex_encoding (&i.tm)
4017                       && i.operands <= 4)));
4018
4019   exp = &im_expressions[i.imm_operands++];
4020   i.op[i.operands].imms = exp;
4021   i.types[i.operands] = imm8;
4022   i.operands++;
4023   exp->X_op = O_constant;
4024   exp->X_add_number = i.tm.extension_opcode;
4025   i.tm.extension_opcode = None;
4026 }
4027
4028
4029 static int
4030 check_hle (void)
4031 {
4032   switch (i.tm.opcode_modifier.hleprefixok)
4033     {
4034     default:
4035       abort ();
4036     case HLEPrefixNone:
4037       as_bad (_("invalid instruction `%s' after `%s'"),
4038               i.tm.name, i.hle_prefix);
4039       return 0;
4040     case HLEPrefixLock:
4041       if (i.prefix[LOCK_PREFIX])
4042         return 1;
4043       as_bad (_("missing `lock' with `%s'"), i.hle_prefix);
4044       return 0;
4045     case HLEPrefixAny:
4046       return 1;
4047     case HLEPrefixRelease:
4048       if (i.prefix[HLE_PREFIX] != XRELEASE_PREFIX_OPCODE)
4049         {
4050           as_bad (_("instruction `%s' after `xacquire' not allowed"),
4051                   i.tm.name);
4052           return 0;
4053         }
4054       if (i.mem_operands == 0 || !(i.flags[i.operands - 1] & Operand_Mem))
4055         {
4056           as_bad (_("memory destination needed for instruction `%s'"
4057                     " after `xrelease'"), i.tm.name);
4058           return 0;
4059         }
4060       return 1;
4061     }
4062 }
4063
4064 /* Try the shortest encoding by shortening operand size.  */
4065
4066 static void
4067 optimize_encoding (void)
4068 {
4069   unsigned int j;
4070
4071   if (optimize_for_space
4072       && !is_any_vex_encoding (&i.tm)
4073       && i.reg_operands == 1
4074       && i.imm_operands == 1
4075       && !i.types[1].bitfield.byte
4076       && i.op[0].imms->X_op == O_constant
4077       && fits_in_imm7 (i.op[0].imms->X_add_number)
4078       && (i.tm.base_opcode == 0xa8
4079           || (i.tm.base_opcode == 0xf6
4080               && i.tm.extension_opcode == 0x0)))
4081     {
4082       /* Optimize: -Os:
4083            test $imm7, %r64/%r32/%r16  -> test $imm7, %r8
4084        */
4085       unsigned int base_regnum = i.op[1].regs->reg_num;
4086       if (flag_code == CODE_64BIT || base_regnum < 4)
4087         {
4088           i.types[1].bitfield.byte = 1;
4089           /* Ignore the suffix.  */
4090           i.suffix = 0;
4091           /* Convert to byte registers.  */
4092           if (i.types[1].bitfield.word)
4093             j = 16;
4094           else if (i.types[1].bitfield.dword)
4095             j = 32;
4096           else
4097             j = 48;
4098           if (!(i.op[1].regs->reg_flags & RegRex) && base_regnum < 4)
4099             j += 8;
4100           i.op[1].regs -= j;
4101         }
4102     }
4103   else if (flag_code == CODE_64BIT
4104            && !is_any_vex_encoding (&i.tm)
4105            && ((i.types[1].bitfield.qword
4106                 && i.reg_operands == 1
4107                 && i.imm_operands == 1
4108                 && i.op[0].imms->X_op == O_constant
4109                 && ((i.tm.base_opcode == 0xb8
4110                      && i.tm.extension_opcode == None
4111                      && fits_in_unsigned_long (i.op[0].imms->X_add_number))
4112                     || (fits_in_imm31 (i.op[0].imms->X_add_number)
4113                         && ((i.tm.base_opcode == 0x24
4114                              || i.tm.base_opcode == 0xa8)
4115                             || (i.tm.base_opcode == 0x80
4116                                 && i.tm.extension_opcode == 0x4)
4117                             || ((i.tm.base_opcode == 0xf6
4118                                  || (i.tm.base_opcode | 1) == 0xc7)
4119                                 && i.tm.extension_opcode == 0x0)))
4120                     || (fits_in_imm7 (i.op[0].imms->X_add_number)
4121                         && i.tm.base_opcode == 0x83
4122                         && i.tm.extension_opcode == 0x4)))
4123                || (i.types[0].bitfield.qword
4124                    && ((i.reg_operands == 2
4125                         && i.op[0].regs == i.op[1].regs
4126                         && (i.tm.base_opcode == 0x30
4127                             || i.tm.base_opcode == 0x28))
4128                        || (i.reg_operands == 1
4129                            && i.operands == 1
4130                            && i.tm.base_opcode == 0x30)))))
4131     {
4132       /* Optimize: -O:
4133            andq $imm31, %r64   -> andl $imm31, %r32
4134            andq $imm7, %r64    -> andl $imm7, %r32
4135            testq $imm31, %r64  -> testl $imm31, %r32
4136            xorq %r64, %r64     -> xorl %r32, %r32
4137            subq %r64, %r64     -> subl %r32, %r32
4138            movq $imm31, %r64   -> movl $imm31, %r32
4139            movq $imm32, %r64   -> movl $imm32, %r32
4140         */
4141       i.tm.opcode_modifier.norex64 = 1;
4142       if (i.tm.base_opcode == 0xb8 || (i.tm.base_opcode | 1) == 0xc7)
4143         {
4144           /* Handle
4145                movq $imm31, %r64   -> movl $imm31, %r32
4146                movq $imm32, %r64   -> movl $imm32, %r32
4147            */
4148           i.tm.operand_types[0].bitfield.imm32 = 1;
4149           i.tm.operand_types[0].bitfield.imm32s = 0;
4150           i.tm.operand_types[0].bitfield.imm64 = 0;
4151           i.types[0].bitfield.imm32 = 1;
4152           i.types[0].bitfield.imm32s = 0;
4153           i.types[0].bitfield.imm64 = 0;
4154           i.types[1].bitfield.dword = 1;
4155           i.types[1].bitfield.qword = 0;
4156           if ((i.tm.base_opcode | 1) == 0xc7)
4157             {
4158               /* Handle
4159                    movq $imm31, %r64   -> movl $imm31, %r32
4160                */
4161               i.tm.base_opcode = 0xb8;
4162               i.tm.extension_opcode = None;
4163               i.tm.opcode_modifier.w = 0;
4164               i.tm.opcode_modifier.modrm = 0;
4165             }
4166         }
4167     }
4168   else if (optimize > 1
4169            && !optimize_for_space
4170            && !is_any_vex_encoding (&i.tm)
4171            && i.reg_operands == 2
4172            && i.op[0].regs == i.op[1].regs
4173            && ((i.tm.base_opcode & ~(Opcode_D | 1)) == 0x8
4174                || (i.tm.base_opcode & ~(Opcode_D | 1)) == 0x20)
4175            && (flag_code != CODE_64BIT || !i.types[0].bitfield.dword))
4176     {
4177       /* Optimize: -O2:
4178            andb %rN, %rN  -> testb %rN, %rN
4179            andw %rN, %rN  -> testw %rN, %rN
4180            andq %rN, %rN  -> testq %rN, %rN
4181            orb %rN, %rN   -> testb %rN, %rN
4182            orw %rN, %rN   -> testw %rN, %rN
4183            orq %rN, %rN   -> testq %rN, %rN
4184
4185            and outside of 64-bit mode
4186
4187            andl %rN, %rN  -> testl %rN, %rN
4188            orl %rN, %rN   -> testl %rN, %rN
4189        */
4190       i.tm.base_opcode = 0x84 | (i.tm.base_opcode & 1);
4191     }
4192   else if (i.reg_operands == 3
4193            && i.op[0].regs == i.op[1].regs
4194            && !i.types[2].bitfield.xmmword
4195            && (i.tm.opcode_modifier.vex
4196                || ((!i.mask || i.mask->zeroing)
4197                    && !i.rounding
4198                    && is_evex_encoding (&i.tm)
4199                    && (i.vec_encoding != vex_encoding_evex
4200                        || cpu_arch_isa_flags.bitfield.cpuavx512vl
4201                        || i.tm.cpu_flags.bitfield.cpuavx512vl
4202                        || (i.tm.operand_types[2].bitfield.zmmword
4203                            && i.types[2].bitfield.ymmword))))
4204            && ((i.tm.base_opcode == 0x55
4205                 || i.tm.base_opcode == 0x6655
4206                 || i.tm.base_opcode == 0x66df
4207                 || i.tm.base_opcode == 0x57
4208                 || i.tm.base_opcode == 0x6657
4209                 || i.tm.base_opcode == 0x66ef
4210                 || i.tm.base_opcode == 0x66f8
4211                 || i.tm.base_opcode == 0x66f9
4212                 || i.tm.base_opcode == 0x66fa
4213                 || i.tm.base_opcode == 0x66fb
4214                 || i.tm.base_opcode == 0x42
4215                 || i.tm.base_opcode == 0x6642
4216                 || i.tm.base_opcode == 0x47
4217                 || i.tm.base_opcode == 0x6647)
4218                && i.tm.extension_opcode == None))
4219     {
4220       /* Optimize: -O1:
4221            VOP, one of vandnps, vandnpd, vxorps, vxorpd, vpsubb, vpsubd,
4222            vpsubq and vpsubw:
4223              EVEX VOP %zmmM, %zmmM, %zmmN
4224                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4225                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4226              EVEX VOP %ymmM, %ymmM, %ymmN
4227                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4228                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4229              VEX VOP %ymmM, %ymmM, %ymmN
4230                -> VEX VOP %xmmM, %xmmM, %xmmN
4231            VOP, one of vpandn and vpxor:
4232              VEX VOP %ymmM, %ymmM, %ymmN
4233                -> VEX VOP %xmmM, %xmmM, %xmmN
4234            VOP, one of vpandnd and vpandnq:
4235              EVEX VOP %zmmM, %zmmM, %zmmN
4236                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4237                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4238              EVEX VOP %ymmM, %ymmM, %ymmN
4239                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4240                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4241            VOP, one of vpxord and vpxorq:
4242              EVEX VOP %zmmM, %zmmM, %zmmN
4243                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4244                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4245              EVEX VOP %ymmM, %ymmM, %ymmN
4246                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4247                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4248            VOP, one of kxord and kxorq:
4249              VEX VOP %kM, %kM, %kN
4250                -> VEX kxorw %kM, %kM, %kN
4251            VOP, one of kandnd and kandnq:
4252              VEX VOP %kM, %kM, %kN
4253                -> VEX kandnw %kM, %kM, %kN
4254        */
4255       if (is_evex_encoding (&i.tm))
4256         {
4257           if (i.vec_encoding != vex_encoding_evex)
4258             {
4259               i.tm.opcode_modifier.vex = VEX128;
4260               i.tm.opcode_modifier.vexw = VEXW0;
4261               i.tm.opcode_modifier.evex = 0;
4262             }
4263           else if (optimize > 1)
4264             i.tm.opcode_modifier.evex = EVEX128;
4265           else
4266             return;
4267         }
4268       else if (i.tm.operand_types[0].bitfield.class == RegMask)
4269         {
4270           i.tm.base_opcode &= 0xff;
4271           i.tm.opcode_modifier.vexw = VEXW0;
4272         }
4273       else
4274         i.tm.opcode_modifier.vex = VEX128;
4275
4276       if (i.tm.opcode_modifier.vex)
4277         for (j = 0; j < 3; j++)
4278           {
4279             i.types[j].bitfield.xmmword = 1;
4280             i.types[j].bitfield.ymmword = 0;
4281           }
4282     }
4283   else if (i.vec_encoding != vex_encoding_evex
4284            && !i.types[0].bitfield.zmmword
4285            && !i.types[1].bitfield.zmmword
4286            && !i.mask
4287            && !i.broadcast
4288            && is_evex_encoding (&i.tm)
4289            && ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0x666f
4290                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf36f
4291                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f
4292                || (i.tm.base_opcode & ~4) == 0x66db
4293                || (i.tm.base_opcode & ~4) == 0x66eb)
4294            && i.tm.extension_opcode == None)
4295     {
4296       /* Optimize: -O1:
4297            VOP, one of vmovdqa32, vmovdqa64, vmovdqu8, vmovdqu16,
4298            vmovdqu32 and vmovdqu64:
4299              EVEX VOP %xmmM, %xmmN
4300                -> VEX vmovdqa|vmovdqu %xmmM, %xmmN (M and N < 16)
4301              EVEX VOP %ymmM, %ymmN
4302                -> VEX vmovdqa|vmovdqu %ymmM, %ymmN (M and N < 16)
4303              EVEX VOP %xmmM, mem
4304                -> VEX vmovdqa|vmovdqu %xmmM, mem (M < 16)
4305              EVEX VOP %ymmM, mem
4306                -> VEX vmovdqa|vmovdqu %ymmM, mem (M < 16)
4307              EVEX VOP mem, %xmmN
4308                -> VEX mvmovdqa|vmovdquem, %xmmN (N < 16)
4309              EVEX VOP mem, %ymmN
4310                -> VEX vmovdqa|vmovdqu mem, %ymmN (N < 16)
4311            VOP, one of vpand, vpandn, vpor, vpxor:
4312              EVEX VOP{d,q} %xmmL, %xmmM, %xmmN
4313                -> VEX VOP %xmmL, %xmmM, %xmmN (L, M, and N < 16)
4314              EVEX VOP{d,q} %ymmL, %ymmM, %ymmN
4315                -> VEX VOP %ymmL, %ymmM, %ymmN (L, M, and N < 16)
4316              EVEX VOP{d,q} mem, %xmmM, %xmmN
4317                -> VEX VOP mem, %xmmM, %xmmN (M and N < 16)
4318              EVEX VOP{d,q} mem, %ymmM, %ymmN
4319                -> VEX VOP mem, %ymmM, %ymmN (M and N < 16)
4320        */
4321       for (j = 0; j < i.operands; j++)
4322         if (operand_type_check (i.types[j], disp)
4323             && i.op[j].disps->X_op == O_constant)
4324           {
4325             /* Since the VEX prefix has 2 or 3 bytes, the EVEX prefix
4326                has 4 bytes, EVEX Disp8 has 1 byte and VEX Disp32 has 4
4327                bytes, we choose EVEX Disp8 over VEX Disp32.  */
4328             int evex_disp8, vex_disp8;
4329             unsigned int memshift = i.memshift;
4330             offsetT n = i.op[j].disps->X_add_number;
4331
4332             evex_disp8 = fits_in_disp8 (n);
4333             i.memshift = 0;
4334             vex_disp8 = fits_in_disp8 (n);
4335             if (evex_disp8 != vex_disp8)
4336               {
4337                 i.memshift = memshift;
4338                 return;
4339               }
4340
4341             i.types[j].bitfield.disp8 = vex_disp8;
4342             break;
4343           }
4344       if ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f)
4345         i.tm.base_opcode ^= 0xf36f ^ 0xf26f;
4346       i.tm.opcode_modifier.vex
4347         = i.types[0].bitfield.ymmword ? VEX256 : VEX128;
4348       i.tm.opcode_modifier.vexw = VEXW0;
4349       /* VPAND, VPOR, and VPXOR are commutative.  */
4350       if (i.reg_operands == 3 && i.tm.base_opcode != 0x66df)
4351         i.tm.opcode_modifier.commutative = 1;
4352       i.tm.opcode_modifier.evex = 0;
4353       i.tm.opcode_modifier.masking = 0;
4354       i.tm.opcode_modifier.broadcast = 0;
4355       i.tm.opcode_modifier.disp8memshift = 0;
4356       i.memshift = 0;
4357       if (j < i.operands)
4358         i.types[j].bitfield.disp8
4359           = fits_in_disp8 (i.op[j].disps->X_add_number);
4360     }
4361 }
4362
4363 /* Return non-zero for load instruction.  */
4364
4365 static int
4366 load_insn_p (void)
4367 {
4368   unsigned int dest;
4369   int any_vex_p = is_any_vex_encoding (&i.tm);
4370   unsigned int base_opcode = i.tm.base_opcode | 1;
4371
4372   if (!any_vex_p)
4373     {
4374       /* Anysize insns: lea, invlpg, clflush, prefetchnta, prefetcht0,
4375          prefetcht1, prefetcht2, prefetchtw, bndmk, bndcl, bndcu, bndcn,
4376          bndstx, bndldx, prefetchwt1, clflushopt, clwb, cldemote.  */
4377       if (i.tm.opcode_modifier.anysize)
4378         return 0;
4379
4380       /* pop, popf, popa.   */
4381       if (strcmp (i.tm.name, "pop") == 0
4382           || i.tm.base_opcode == 0x9d
4383           || i.tm.base_opcode == 0x61)
4384         return 1;
4385
4386       /* movs, cmps, lods, scas.  */
4387       if ((i.tm.base_opcode | 0xb) == 0xaf)
4388         return 1;
4389
4390       /* outs, xlatb.  */
4391       if (base_opcode == 0x6f
4392           || i.tm.base_opcode == 0xd7)
4393         return 1;
4394       /* NB: For AMD-specific insns with implicit memory operands,
4395          they're intentionally not covered.  */
4396     }
4397
4398   /* No memory operand.  */
4399   if (!i.mem_operands)
4400     return 0;
4401
4402   if (any_vex_p)
4403     {
4404       /* vldmxcsr.  */
4405       if (i.tm.base_opcode == 0xae
4406           && i.tm.opcode_modifier.vex
4407           && i.tm.opcode_modifier.vexopcode == VEX0F
4408           && i.tm.extension_opcode == 2)
4409         return 1;
4410     }
4411   else
4412     {
4413       /* test, not, neg, mul, imul, div, idiv.  */
4414       if ((i.tm.base_opcode == 0xf6 || i.tm.base_opcode == 0xf7)
4415           && i.tm.extension_opcode != 1)
4416         return 1;
4417
4418       /* inc, dec.  */
4419       if (base_opcode == 0xff && i.tm.extension_opcode <= 1)
4420         return 1;
4421
4422       /* add, or, adc, sbb, and, sub, xor, cmp.  */
4423       if (i.tm.base_opcode >= 0x80 && i.tm.base_opcode <= 0x83)
4424         return 1;
4425
4426       /* bt, bts, btr, btc.  */
4427       if (i.tm.base_opcode == 0xfba
4428           && (i.tm.extension_opcode >= 4 && i.tm.extension_opcode <= 7))
4429         return 1;
4430
4431       /* rol, ror, rcl, rcr, shl/sal, shr, sar. */
4432       if ((base_opcode == 0xc1
4433            || (i.tm.base_opcode >= 0xd0 && i.tm.base_opcode <= 0xd3))
4434           && i.tm.extension_opcode != 6)
4435         return 1;
4436
4437       /* cmpxchg8b, cmpxchg16b, xrstors.  */
4438       if (i.tm.base_opcode == 0xfc7
4439           && (i.tm.extension_opcode == 1 || i.tm.extension_opcode == 3))
4440         return 1;
4441
4442       /* fxrstor, ldmxcsr, xrstor.  */
4443       if (i.tm.base_opcode == 0xfae
4444           && (i.tm.extension_opcode == 1
4445               || i.tm.extension_opcode == 2
4446               || i.tm.extension_opcode == 5))
4447         return 1;
4448
4449       /* lgdt, lidt, lmsw.  */
4450       if (i.tm.base_opcode == 0xf01
4451           && (i.tm.extension_opcode == 2
4452               || i.tm.extension_opcode == 3
4453               || i.tm.extension_opcode == 6))
4454         return 1;
4455
4456       /* vmptrld */
4457       if (i.tm.base_opcode == 0xfc7
4458           && i.tm.extension_opcode == 6)
4459         return 1;
4460
4461       /* Check for x87 instructions.  */
4462       if (i.tm.base_opcode >= 0xd8 && i.tm.base_opcode <= 0xdf)
4463         {
4464           /* Skip fst, fstp, fstenv, fstcw.  */
4465           if (i.tm.base_opcode == 0xd9
4466               && (i.tm.extension_opcode == 2
4467                   || i.tm.extension_opcode == 3
4468                   || i.tm.extension_opcode == 6
4469                   || i.tm.extension_opcode == 7))
4470             return 0;
4471
4472           /* Skip fisttp, fist, fistp, fstp.  */
4473           if (i.tm.base_opcode == 0xdb
4474               && (i.tm.extension_opcode == 1
4475                   || i.tm.extension_opcode == 2
4476                   || i.tm.extension_opcode == 3
4477                   || i.tm.extension_opcode == 7))
4478             return 0;
4479
4480           /* Skip fisttp, fst, fstp, fsave, fstsw.  */
4481           if (i.tm.base_opcode == 0xdd
4482               && (i.tm.extension_opcode == 1
4483                   || i.tm.extension_opcode == 2
4484                   || i.tm.extension_opcode == 3
4485                   || i.tm.extension_opcode == 6
4486                   || i.tm.extension_opcode == 7))
4487             return 0;
4488
4489           /* Skip fisttp, fist, fistp, fbstp, fistp.  */
4490           if (i.tm.base_opcode == 0xdf
4491               && (i.tm.extension_opcode == 1
4492                   || i.tm.extension_opcode == 2
4493                   || i.tm.extension_opcode == 3
4494                   || i.tm.extension_opcode == 6
4495                   || i.tm.extension_opcode == 7))
4496             return 0;
4497
4498           return 1;
4499         }
4500     }
4501
4502   dest = i.operands - 1;
4503
4504   /* Check fake imm8 operand and 3 source operands.  */
4505   if ((i.tm.opcode_modifier.immext
4506        || i.tm.opcode_modifier.vexsources == VEX3SOURCES)
4507       && i.types[dest].bitfield.imm8)
4508     dest--;
4509
4510   /* add, or, adc, sbb, and, sub, xor, cmp, test, xchg, xadd  */
4511   if (!any_vex_p
4512       && (base_opcode == 0x1
4513           || base_opcode == 0x9
4514           || base_opcode == 0x11
4515           || base_opcode == 0x19
4516           || base_opcode == 0x21
4517           || base_opcode == 0x29
4518           || base_opcode == 0x31
4519           || base_opcode == 0x39
4520           || (i.tm.base_opcode >= 0x84 && i.tm.base_opcode <= 0x87)
4521           || base_opcode == 0xfc1))
4522     return 1;
4523
4524   /* Check for load instruction.  */
4525   return (i.types[dest].bitfield.class != ClassNone
4526           || i.types[dest].bitfield.instance == Accum);
4527 }
4528
4529 /* Output lfence, 0xfaee8, after instruction.  */
4530
4531 static void
4532 insert_lfence_after (void)
4533 {
4534   if (lfence_after_load && load_insn_p ())
4535     {
4536       /* There are also two REP string instructions that require
4537          special treatment. Specifically, the compare string (CMPS)
4538          and scan string (SCAS) instructions set EFLAGS in a manner
4539          that depends on the data being compared/scanned. When used
4540          with a REP prefix, the number of iterations may therefore
4541          vary depending on this data. If the data is a program secret
4542          chosen by the adversary using an LVI method,
4543          then this data-dependent behavior may leak some aspect
4544          of the secret.  */
4545       if (((i.tm.base_opcode | 0x1) == 0xa7
4546            || (i.tm.base_opcode | 0x1) == 0xaf)
4547           && i.prefix[REP_PREFIX])
4548         {
4549             as_warn (_("`%s` changes flags which would affect control flow behavior"),
4550                      i.tm.name);
4551         }
4552       char *p = frag_more (3);
4553       *p++ = 0xf;
4554       *p++ = 0xae;
4555       *p = 0xe8;
4556     }
4557 }
4558
4559 /* Output lfence, 0xfaee8, before instruction.  */
4560
4561 static void
4562 insert_lfence_before (void)
4563 {
4564   char *p;
4565
4566   if (is_any_vex_encoding (&i.tm))
4567     return;
4568
4569   if (i.tm.base_opcode == 0xff
4570       && (i.tm.extension_opcode == 2 || i.tm.extension_opcode == 4))
4571     {
4572       /* Insert lfence before indirect branch if needed.  */
4573
4574       if (lfence_before_indirect_branch == lfence_branch_none)
4575         return;
4576
4577       if (i.operands != 1)
4578         abort ();
4579
4580       if (i.reg_operands == 1)
4581         {
4582           /* Indirect branch via register.  Don't insert lfence with
4583              -mlfence-after-load=yes.  */
4584           if (lfence_after_load
4585               || lfence_before_indirect_branch == lfence_branch_memory)
4586             return;
4587         }
4588       else if (i.mem_operands == 1
4589                && lfence_before_indirect_branch != lfence_branch_register)
4590         {
4591           as_warn (_("indirect `%s` with memory operand should be avoided"),
4592                    i.tm.name);
4593           return;
4594         }
4595       else
4596         return;
4597
4598       if (last_insn.kind != last_insn_other
4599           && last_insn.seg == now_seg)
4600         {
4601           as_warn_where (last_insn.file, last_insn.line,
4602                          _("`%s` skips -mlfence-before-indirect-branch on `%s`"),
4603                          last_insn.name, i.tm.name);
4604           return;
4605         }
4606
4607       p = frag_more (3);
4608       *p++ = 0xf;
4609       *p++ = 0xae;
4610       *p = 0xe8;
4611       return;
4612     }
4613
4614   /* Output or/not/shl and lfence before near ret.  */
4615   if (lfence_before_ret != lfence_before_ret_none
4616       && (i.tm.base_opcode == 0xc2
4617           || i.tm.base_opcode == 0xc3))
4618     {
4619       if (last_insn.kind != last_insn_other
4620           && last_insn.seg == now_seg)
4621         {
4622           as_warn_where (last_insn.file, last_insn.line,
4623                          _("`%s` skips -mlfence-before-ret on `%s`"),
4624                          last_insn.name, i.tm.name);
4625           return;
4626         }
4627
4628       /* Near ret ingore operand size override under CPU64.  */
4629       char prefix = flag_code == CODE_64BIT
4630                     ? 0x48
4631                     : i.prefix[DATA_PREFIX] ? 0x66 : 0x0;
4632
4633       if (lfence_before_ret == lfence_before_ret_not)
4634         {
4635           /* not: 0xf71424, may add prefix
4636              for operand size override or 64-bit code.  */
4637           p = frag_more ((prefix ? 2 : 0) + 6 + 3);
4638           if (prefix)
4639             *p++ = prefix;
4640           *p++ = 0xf7;
4641           *p++ = 0x14;
4642           *p++ = 0x24;
4643           if (prefix)
4644             *p++ = prefix;
4645           *p++ = 0xf7;
4646           *p++ = 0x14;
4647           *p++ = 0x24;
4648         }
4649       else
4650         {
4651           p = frag_more ((prefix ? 1 : 0) + 4 + 3);
4652           if (prefix)
4653             *p++ = prefix;
4654           if (lfence_before_ret == lfence_before_ret_or)
4655             {
4656               /* or: 0x830c2400, may add prefix
4657                  for operand size override or 64-bit code.  */
4658               *p++ = 0x83;
4659               *p++ = 0x0c;
4660             }
4661           else
4662             {
4663               /* shl: 0xc1242400, may add prefix
4664                  for operand size override or 64-bit code.  */
4665               *p++ = 0xc1;
4666               *p++ = 0x24;
4667             }
4668
4669           *p++ = 0x24;
4670           *p++ = 0x0;
4671         }
4672
4673       *p++ = 0xf;
4674       *p++ = 0xae;
4675       *p = 0xe8;
4676     }
4677 }
4678
4679 /* This is the guts of the machine-dependent assembler.  LINE points to a
4680    machine dependent instruction.  This function is supposed to emit
4681    the frags/bytes it assembles to.  */
4682
4683 void
4684 md_assemble (char *line)
4685 {
4686   unsigned int j;
4687   char mnemonic[MAX_MNEM_SIZE], mnem_suffix;
4688   const insn_template *t;
4689
4690   /* Initialize globals.  */
4691   memset (&i, '\0', sizeof (i));
4692   for (j = 0; j < MAX_OPERANDS; j++)
4693     i.reloc[j] = NO_RELOC;
4694   memset (disp_expressions, '\0', sizeof (disp_expressions));
4695   memset (im_expressions, '\0', sizeof (im_expressions));
4696   save_stack_p = save_stack;
4697
4698   /* First parse an instruction mnemonic & call i386_operand for the operands.
4699      We assume that the scrubber has arranged it so that line[0] is the valid
4700      start of a (possibly prefixed) mnemonic.  */
4701
4702   line = parse_insn (line, mnemonic);
4703   if (line == NULL)
4704     return;
4705   mnem_suffix = i.suffix;
4706
4707   line = parse_operands (line, mnemonic);
4708   this_operand = -1;
4709   xfree (i.memop1_string);
4710   i.memop1_string = NULL;
4711   if (line == NULL)
4712     return;
4713
4714   /* Now we've parsed the mnemonic into a set of templates, and have the
4715      operands at hand.  */
4716
4717   /* All Intel opcodes have reversed operands except for "bound", "enter",
4718      "monitor*", "mwait*", "tpause", and "umwait".  We also don't reverse
4719      intersegment "jmp" and "call" instructions with 2 immediate operands so
4720      that the immediate segment precedes the offset, as it does when in AT&T
4721      mode.  */
4722   if (intel_syntax
4723       && i.operands > 1
4724       && (strcmp (mnemonic, "bound") != 0)
4725       && (strcmp (mnemonic, "invlpga") != 0)
4726       && (strncmp (mnemonic, "monitor", 7) != 0)
4727       && (strncmp (mnemonic, "mwait", 5) != 0)
4728       && (strcmp (mnemonic, "tpause") != 0)
4729       && (strcmp (mnemonic, "umwait") != 0)
4730       && !(operand_type_check (i.types[0], imm)
4731            && operand_type_check (i.types[1], imm)))
4732     swap_operands ();
4733
4734   /* The order of the immediates should be reversed
4735      for 2 immediates extrq and insertq instructions */
4736   if (i.imm_operands == 2
4737       && (strcmp (mnemonic, "extrq") == 0
4738           || strcmp (mnemonic, "insertq") == 0))
4739       swap_2_operands (0, 1);
4740
4741   if (i.imm_operands)
4742     optimize_imm ();
4743
4744   /* Don't optimize displacement for movabs since it only takes 64bit
4745      displacement.  */
4746   if (i.disp_operands
4747       && i.disp_encoding != disp_encoding_32bit
4748       && (flag_code != CODE_64BIT
4749           || strcmp (mnemonic, "movabs") != 0))
4750     optimize_disp ();
4751
4752   /* Next, we find a template that matches the given insn,
4753      making sure the overlap of the given operands types is consistent
4754      with the template operand types.  */
4755
4756   if (!(t = match_template (mnem_suffix)))
4757     return;
4758
4759   if (sse_check != check_none
4760       && !i.tm.opcode_modifier.noavx
4761       && !i.tm.cpu_flags.bitfield.cpuavx
4762       && !i.tm.cpu_flags.bitfield.cpuavx512f
4763       && (i.tm.cpu_flags.bitfield.cpusse
4764           || i.tm.cpu_flags.bitfield.cpusse2
4765           || i.tm.cpu_flags.bitfield.cpusse3
4766           || i.tm.cpu_flags.bitfield.cpussse3
4767           || i.tm.cpu_flags.bitfield.cpusse4_1
4768           || i.tm.cpu_flags.bitfield.cpusse4_2
4769           || i.tm.cpu_flags.bitfield.cpupclmul
4770           || i.tm.cpu_flags.bitfield.cpuaes
4771           || i.tm.cpu_flags.bitfield.cpusha
4772           || i.tm.cpu_flags.bitfield.cpugfni))
4773     {
4774       (sse_check == check_warning
4775        ? as_warn
4776        : as_bad) (_("SSE instruction `%s' is used"), i.tm.name);
4777     }
4778
4779   if (i.tm.opcode_modifier.fwait)
4780     if (!add_prefix (FWAIT_OPCODE))
4781       return;
4782
4783   /* Check if REP prefix is OK.  */
4784   if (i.rep_prefix && !i.tm.opcode_modifier.repprefixok)
4785     {
4786       as_bad (_("invalid instruction `%s' after `%s'"),
4787                 i.tm.name, i.rep_prefix);
4788       return;
4789     }
4790
4791   /* Check for lock without a lockable instruction.  Destination operand
4792      must be memory unless it is xchg (0x86).  */
4793   if (i.prefix[LOCK_PREFIX]
4794       && (!i.tm.opcode_modifier.islockable
4795           || i.mem_operands == 0
4796           || (i.tm.base_opcode != 0x86
4797               && !(i.flags[i.operands - 1] & Operand_Mem))))
4798     {
4799       as_bad (_("expecting lockable instruction after `lock'"));
4800       return;
4801     }
4802
4803   /* Check for data size prefix on VEX/XOP/EVEX encoded and SIMD insns.  */
4804   if (i.prefix[DATA_PREFIX]
4805       && (is_any_vex_encoding (&i.tm)
4806           || i.tm.operand_types[i.imm_operands].bitfield.class >= RegMMX
4807           || i.tm.operand_types[i.imm_operands + 1].bitfield.class >= RegMMX))
4808     {
4809       as_bad (_("data size prefix invalid with `%s'"), i.tm.name);
4810       return;
4811     }
4812
4813   /* Check if HLE prefix is OK.  */
4814   if (i.hle_prefix && !check_hle ())
4815     return;
4816
4817   /* Check BND prefix.  */
4818   if (i.bnd_prefix && !i.tm.opcode_modifier.bndprefixok)
4819     as_bad (_("expecting valid branch instruction after `bnd'"));
4820
4821   /* Check NOTRACK prefix.  */
4822   if (i.notrack_prefix && !i.tm.opcode_modifier.notrackprefixok)
4823     as_bad (_("expecting indirect branch instruction after `notrack'"));
4824
4825   if (i.tm.cpu_flags.bitfield.cpumpx)
4826     {
4827       if (flag_code == CODE_64BIT && i.prefix[ADDR_PREFIX])
4828         as_bad (_("32-bit address isn't allowed in 64-bit MPX instructions."));
4829       else if (flag_code != CODE_16BIT
4830                ? i.prefix[ADDR_PREFIX]
4831                : i.mem_operands && !i.prefix[ADDR_PREFIX])
4832         as_bad (_("16-bit address isn't allowed in MPX instructions"));
4833     }
4834
4835   /* Insert BND prefix.  */
4836   if (add_bnd_prefix && i.tm.opcode_modifier.bndprefixok)
4837     {
4838       if (!i.prefix[BND_PREFIX])
4839         add_prefix (BND_PREFIX_OPCODE);
4840       else if (i.prefix[BND_PREFIX] != BND_PREFIX_OPCODE)
4841         {
4842           as_warn (_("replacing `rep'/`repe' prefix by `bnd'"));
4843           i.prefix[BND_PREFIX] = BND_PREFIX_OPCODE;
4844         }
4845     }
4846
4847   /* Check string instruction segment overrides.  */
4848   if (i.tm.opcode_modifier.isstring >= IS_STRING_ES_OP0)
4849     {
4850       gas_assert (i.mem_operands);
4851       if (!check_string ())
4852         return;
4853       i.disp_operands = 0;
4854     }
4855
4856   if (optimize && !i.no_optimize && i.tm.opcode_modifier.optimize)
4857     optimize_encoding ();
4858
4859   if (!process_suffix ())
4860     return;
4861
4862   /* Update operand types and check extended states.  */
4863   for (j = 0; j < i.operands; j++)
4864     {
4865       i.types[j] = operand_type_and (i.types[j], i.tm.operand_types[j]);
4866       switch (i.tm.operand_types[j].bitfield.class)
4867         {
4868         default:
4869           break;
4870         case RegMMX:
4871           i.xstate |= xstate_mmx;
4872           break;
4873         case RegMask:
4874           i.xstate |= xstate_zmm;
4875           break;
4876         case RegSIMD:
4877           if (i.tm.operand_types[j].bitfield.tmmword)
4878             i.xstate |= xstate_tmm;
4879           else if (i.tm.operand_types[j].bitfield.zmmword)
4880             i.xstate |= xstate_zmm;
4881           else if (i.tm.operand_types[j].bitfield.ymmword)
4882             i.xstate |= xstate_ymm;
4883           else if (i.tm.operand_types[j].bitfield.xmmword)
4884             i.xstate |= xstate_xmm;
4885           break;
4886         }
4887     }
4888
4889   /* Make still unresolved immediate matches conform to size of immediate
4890      given in i.suffix.  */
4891   if (!finalize_imm ())
4892     return;
4893
4894   if (i.types[0].bitfield.imm1)
4895     i.imm_operands = 0; /* kludge for shift insns.  */
4896
4897   /* We only need to check those implicit registers for instructions
4898      with 3 operands or less.  */
4899   if (i.operands <= 3)
4900     for (j = 0; j < i.operands; j++)
4901       if (i.types[j].bitfield.instance != InstanceNone
4902           && !i.types[j].bitfield.xmmword)
4903         i.reg_operands--;
4904
4905   /* For insns with operands there are more diddles to do to the opcode.  */
4906   if (i.operands)
4907     {
4908       if (!process_operands ())
4909         return;
4910     }
4911   else if (!quiet_warnings && i.tm.opcode_modifier.ugh)
4912     {
4913       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
4914       as_warn (_("translating to `%sp'"), i.tm.name);
4915     }
4916
4917   if (is_any_vex_encoding (&i.tm))
4918     {
4919       if (!cpu_arch_flags.bitfield.cpui286)
4920         {
4921           as_bad (_("instruction `%s' isn't supported outside of protected mode."),
4922                   i.tm.name);
4923           return;
4924         }
4925
4926       /* Check for explicit REX prefix.  */
4927       if (i.prefix[REX_PREFIX] || i.rex_encoding)
4928         {
4929           as_bad (_("REX prefix invalid with `%s'"), i.tm.name);
4930           return;
4931         }
4932
4933       if (i.tm.opcode_modifier.vex)
4934         build_vex_prefix (t);
4935       else
4936         build_evex_prefix ();
4937
4938       /* The individual REX.RXBW bits got consumed.  */
4939       i.rex &= REX_OPCODE;
4940     }
4941
4942   /* Handle conversion of 'int $3' --> special int3 insn.  XOP or FMA4
4943      instructions may define INT_OPCODE as well, so avoid this corner
4944      case for those instructions that use MODRM.  */
4945   if (i.tm.base_opcode == INT_OPCODE
4946       && !i.tm.opcode_modifier.modrm
4947       && i.op[0].imms->X_add_number == 3)
4948     {
4949       i.tm.base_opcode = INT3_OPCODE;
4950       i.imm_operands = 0;
4951     }
4952
4953   if ((i.tm.opcode_modifier.jump == JUMP
4954        || i.tm.opcode_modifier.jump == JUMP_BYTE
4955        || i.tm.opcode_modifier.jump == JUMP_DWORD)
4956       && i.op[0].disps->X_op == O_constant)
4957     {
4958       /* Convert "jmp constant" (and "call constant") to a jump (call) to
4959          the absolute address given by the constant.  Since ix86 jumps and
4960          calls are pc relative, we need to generate a reloc.  */
4961       i.op[0].disps->X_add_symbol = &abs_symbol;
4962       i.op[0].disps->X_op = O_symbol;
4963     }
4964
4965   /* For 8 bit registers we need an empty rex prefix.  Also if the
4966      instruction already has a prefix, we need to convert old
4967      registers to new ones.  */
4968
4969   if ((i.types[0].bitfield.class == Reg && i.types[0].bitfield.byte
4970        && (i.op[0].regs->reg_flags & RegRex64) != 0)
4971       || (i.types[1].bitfield.class == Reg && i.types[1].bitfield.byte
4972           && (i.op[1].regs->reg_flags & RegRex64) != 0)
4973       || (((i.types[0].bitfield.class == Reg && i.types[0].bitfield.byte)
4974            || (i.types[1].bitfield.class == Reg && i.types[1].bitfield.byte))
4975           && i.rex != 0))
4976     {
4977       int x;
4978
4979       i.rex |= REX_OPCODE;
4980       for (x = 0; x < 2; x++)
4981         {
4982           /* Look for 8 bit operand that uses old registers.  */
4983           if (i.types[x].bitfield.class == Reg && i.types[x].bitfield.byte
4984               && (i.op[x].regs->reg_flags & RegRex64) == 0)
4985             {
4986               gas_assert (!(i.op[x].regs->reg_flags & RegRex));
4987               /* In case it is "hi" register, give up.  */
4988               if (i.op[x].regs->reg_num > 3)
4989                 as_bad (_("can't encode register '%s%s' in an "
4990                           "instruction requiring REX prefix."),
4991                         register_prefix, i.op[x].regs->reg_name);
4992
4993               /* Otherwise it is equivalent to the extended register.
4994                  Since the encoding doesn't change this is merely
4995                  cosmetic cleanup for debug output.  */
4996
4997               i.op[x].regs = i.op[x].regs + 8;
4998             }
4999         }
5000     }
5001
5002   if (i.rex == 0 && i.rex_encoding)
5003     {
5004       /* Check if we can add a REX_OPCODE byte.  Look for 8 bit operand
5005          that uses legacy register.  If it is "hi" register, don't add
5006          the REX_OPCODE byte.  */
5007       int x;
5008       for (x = 0; x < 2; x++)
5009         if (i.types[x].bitfield.class == Reg
5010             && i.types[x].bitfield.byte
5011             && (i.op[x].regs->reg_flags & RegRex64) == 0
5012             && i.op[x].regs->reg_num > 3)
5013           {
5014             gas_assert (!(i.op[x].regs->reg_flags & RegRex));
5015             i.rex_encoding = FALSE;
5016             break;
5017           }
5018
5019       if (i.rex_encoding)
5020         i.rex = REX_OPCODE;
5021     }
5022
5023   if (i.rex != 0)
5024     add_prefix (REX_OPCODE | i.rex);
5025
5026   insert_lfence_before ();
5027
5028   /* We are ready to output the insn.  */
5029   output_insn ();
5030
5031   insert_lfence_after ();
5032
5033   last_insn.seg = now_seg;
5034
5035   if (i.tm.opcode_modifier.isprefix)
5036     {
5037       last_insn.kind = last_insn_prefix;
5038       last_insn.name = i.tm.name;
5039       last_insn.file = as_where (&last_insn.line);
5040     }
5041   else
5042     last_insn.kind = last_insn_other;
5043 }
5044
5045 static char *
5046 parse_insn (char *line, char *mnemonic)
5047 {
5048   char *l = line;
5049   char *token_start = l;
5050   char *mnem_p;
5051   int supported;
5052   const insn_template *t;
5053   char *dot_p = NULL;
5054
5055   while (1)
5056     {
5057       mnem_p = mnemonic;
5058       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
5059         {
5060           if (*mnem_p == '.')
5061             dot_p = mnem_p;
5062           mnem_p++;
5063           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
5064             {
5065               as_bad (_("no such instruction: `%s'"), token_start);
5066               return NULL;
5067             }
5068           l++;
5069         }
5070       if (!is_space_char (*l)
5071           && *l != END_OF_INSN
5072           && (intel_syntax
5073               || (*l != PREFIX_SEPARATOR
5074                   && *l != ',')))
5075         {
5076           as_bad (_("invalid character %s in mnemonic"),
5077                   output_invalid (*l));
5078           return NULL;
5079         }
5080       if (token_start == l)
5081         {
5082           if (!intel_syntax && *l == PREFIX_SEPARATOR)
5083             as_bad (_("expecting prefix; got nothing"));
5084           else
5085             as_bad (_("expecting mnemonic; got nothing"));
5086           return NULL;
5087         }
5088
5089       /* Look up instruction (or prefix) via hash table.  */
5090       current_templates = (const templates *) hash_find (op_hash, mnemonic);
5091
5092       if (*l != END_OF_INSN
5093           && (!is_space_char (*l) || l[1] != END_OF_INSN)
5094           && current_templates
5095           && current_templates->start->opcode_modifier.isprefix)
5096         {
5097           if (!cpu_flags_check_cpu64 (current_templates->start->cpu_flags))
5098             {
5099               as_bad ((flag_code != CODE_64BIT
5100                        ? _("`%s' is only supported in 64-bit mode")
5101                        : _("`%s' is not supported in 64-bit mode")),
5102                       current_templates->start->name);
5103               return NULL;
5104             }
5105           /* If we are in 16-bit mode, do not allow addr16 or data16.
5106              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
5107           if ((current_templates->start->opcode_modifier.size == SIZE16
5108                || current_templates->start->opcode_modifier.size == SIZE32)
5109               && flag_code != CODE_64BIT
5110               && ((current_templates->start->opcode_modifier.size == SIZE32)
5111                   ^ (flag_code == CODE_16BIT)))
5112             {
5113               as_bad (_("redundant %s prefix"),
5114                       current_templates->start->name);
5115               return NULL;
5116             }
5117           if (current_templates->start->opcode_length == 0)
5118             {
5119               /* Handle pseudo prefixes.  */
5120               switch (current_templates->start->base_opcode)
5121                 {
5122                 case 0x0:
5123                   /* {disp8} */
5124                   i.disp_encoding = disp_encoding_8bit;
5125                   break;
5126                 case 0x1:
5127                   /* {disp32} */
5128                   i.disp_encoding = disp_encoding_32bit;
5129                   break;
5130                 case 0x2:
5131                   /* {load} */
5132                   i.dir_encoding = dir_encoding_load;
5133                   break;
5134                 case 0x3:
5135                   /* {store} */
5136                   i.dir_encoding = dir_encoding_store;
5137                   break;
5138                 case 0x4:
5139                   /* {vex} */
5140                   i.vec_encoding = vex_encoding_vex;
5141                   break;
5142                 case 0x5:
5143                   /* {vex3} */
5144                   i.vec_encoding = vex_encoding_vex3;
5145                   break;
5146                 case 0x6:
5147                   /* {evex} */
5148                   i.vec_encoding = vex_encoding_evex;
5149                   break;
5150                 case 0x7:
5151                   /* {rex} */
5152                   i.rex_encoding = TRUE;
5153                   break;
5154                 case 0x8:
5155                   /* {nooptimize} */
5156                   i.no_optimize = TRUE;
5157                   break;
5158                 default:
5159                   abort ();
5160                 }
5161             }
5162           else
5163             {
5164               /* Add prefix, checking for repeated prefixes.  */
5165               switch (add_prefix (current_templates->start->base_opcode))
5166                 {
5167                 case PREFIX_EXIST:
5168                   return NULL;
5169                 case PREFIX_DS:
5170                   if (current_templates->start->cpu_flags.bitfield.cpuibt)
5171                     i.notrack_prefix = current_templates->start->name;
5172                   break;
5173                 case PREFIX_REP:
5174                   if (current_templates->start->cpu_flags.bitfield.cpuhle)
5175                     i.hle_prefix = current_templates->start->name;
5176                   else if (current_templates->start->cpu_flags.bitfield.cpumpx)
5177                     i.bnd_prefix = current_templates->start->name;
5178                   else
5179                     i.rep_prefix = current_templates->start->name;
5180                   break;
5181                 default:
5182                   break;
5183                 }
5184             }
5185           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
5186           token_start = ++l;
5187         }
5188       else
5189         break;
5190     }
5191
5192   if (!current_templates)
5193     {
5194       /* Deprecated functionality (new code should use pseudo-prefixes instead):
5195          Check if we should swap operand or force 32bit displacement in
5196          encoding.  */
5197       if (mnem_p - 2 == dot_p && dot_p[1] == 's')
5198         i.dir_encoding = dir_encoding_swap;
5199       else if (mnem_p - 3 == dot_p
5200                && dot_p[1] == 'd'
5201                && dot_p[2] == '8')
5202         i.disp_encoding = disp_encoding_8bit;
5203       else if (mnem_p - 4 == dot_p
5204                && dot_p[1] == 'd'
5205                && dot_p[2] == '3'
5206                && dot_p[3] == '2')
5207         i.disp_encoding = disp_encoding_32bit;
5208       else
5209         goto check_suffix;
5210       mnem_p = dot_p;
5211       *dot_p = '\0';
5212       current_templates = (const templates *) hash_find (op_hash, mnemonic);
5213     }
5214
5215   if (!current_templates)
5216     {
5217     check_suffix:
5218       if (mnem_p > mnemonic)
5219         {
5220           /* See if we can get a match by trimming off a suffix.  */
5221           switch (mnem_p[-1])
5222             {
5223             case WORD_MNEM_SUFFIX:
5224               if (intel_syntax && (intel_float_operand (mnemonic) & 2))
5225                 i.suffix = SHORT_MNEM_SUFFIX;
5226               else
5227                 /* Fall through.  */
5228               case BYTE_MNEM_SUFFIX:
5229               case QWORD_MNEM_SUFFIX:
5230                 i.suffix = mnem_p[-1];
5231               mnem_p[-1] = '\0';
5232               current_templates = (const templates *) hash_find (op_hash,
5233                                                                  mnemonic);
5234               break;
5235             case SHORT_MNEM_SUFFIX:
5236             case LONG_MNEM_SUFFIX:
5237               if (!intel_syntax)
5238                 {
5239                   i.suffix = mnem_p[-1];
5240                   mnem_p[-1] = '\0';
5241                   current_templates = (const templates *) hash_find (op_hash,
5242                                                                      mnemonic);
5243                 }
5244               break;
5245
5246               /* Intel Syntax.  */
5247             case 'd':
5248               if (intel_syntax)
5249                 {
5250                   if (intel_float_operand (mnemonic) == 1)
5251                     i.suffix = SHORT_MNEM_SUFFIX;
5252                   else
5253                     i.suffix = LONG_MNEM_SUFFIX;
5254                   mnem_p[-1] = '\0';
5255                   current_templates = (const templates *) hash_find (op_hash,
5256                                                                      mnemonic);
5257                 }
5258               break;
5259             }
5260         }
5261
5262       if (!current_templates)
5263         {
5264           as_bad (_("no such instruction: `%s'"), token_start);
5265           return NULL;
5266         }
5267     }
5268
5269   if (current_templates->start->opcode_modifier.jump == JUMP
5270       || current_templates->start->opcode_modifier.jump == JUMP_BYTE)
5271     {
5272       /* Check for a branch hint.  We allow ",pt" and ",pn" for
5273          predict taken and predict not taken respectively.
5274          I'm not sure that branch hints actually do anything on loop
5275          and jcxz insns (JumpByte) for current Pentium4 chips.  They
5276          may work in the future and it doesn't hurt to accept them
5277          now.  */
5278       if (l[0] == ',' && l[1] == 'p')
5279         {
5280           if (l[2] == 't')
5281             {
5282               if (!add_prefix (DS_PREFIX_OPCODE))
5283                 return NULL;
5284               l += 3;
5285             }
5286           else if (l[2] == 'n')
5287             {
5288               if (!add_prefix (CS_PREFIX_OPCODE))
5289                 return NULL;
5290               l += 3;
5291             }
5292         }
5293     }
5294   /* Any other comma loses.  */
5295   if (*l == ',')
5296     {
5297       as_bad (_("invalid character %s in mnemonic"),
5298               output_invalid (*l));
5299       return NULL;
5300     }
5301
5302   /* Check if instruction is supported on specified architecture.  */
5303   supported = 0;
5304   for (t = current_templates->start; t < current_templates->end; ++t)
5305     {
5306       supported |= cpu_flags_match (t);
5307       if (supported == CPU_FLAGS_PERFECT_MATCH)
5308         {
5309           if (!cpu_arch_flags.bitfield.cpui386 && (flag_code != CODE_16BIT))
5310             as_warn (_("use .code16 to ensure correct addressing mode"));
5311
5312           return l;
5313         }
5314     }
5315
5316   if (!(supported & CPU_FLAGS_64BIT_MATCH))
5317     as_bad (flag_code == CODE_64BIT
5318             ? _("`%s' is not supported in 64-bit mode")
5319             : _("`%s' is only supported in 64-bit mode"),
5320             current_templates->start->name);
5321   else
5322     as_bad (_("`%s' is not supported on `%s%s'"),
5323             current_templates->start->name,
5324             cpu_arch_name ? cpu_arch_name : default_arch,
5325             cpu_sub_arch_name ? cpu_sub_arch_name : "");
5326
5327   return NULL;
5328 }
5329
5330 static char *
5331 parse_operands (char *l, const char *mnemonic)
5332 {
5333   char *token_start;
5334
5335   /* 1 if operand is pending after ','.  */
5336   unsigned int expecting_operand = 0;
5337
5338   /* Non-zero if operand parens not balanced.  */
5339   unsigned int paren_not_balanced;
5340
5341   while (*l != END_OF_INSN)
5342     {
5343       /* Skip optional white space before operand.  */
5344       if (is_space_char (*l))
5345         ++l;
5346       if (!is_operand_char (*l) && *l != END_OF_INSN && *l != '"')
5347         {
5348           as_bad (_("invalid character %s before operand %d"),
5349                   output_invalid (*l),
5350                   i.operands + 1);
5351           return NULL;
5352         }
5353       token_start = l;  /* After white space.  */
5354       paren_not_balanced = 0;
5355       while (paren_not_balanced || *l != ',')
5356         {
5357           if (*l == END_OF_INSN)
5358             {
5359               if (paren_not_balanced)
5360                 {
5361                   if (!intel_syntax)
5362                     as_bad (_("unbalanced parenthesis in operand %d."),
5363                             i.operands + 1);
5364                   else
5365                     as_bad (_("unbalanced brackets in operand %d."),
5366                             i.operands + 1);
5367                   return NULL;
5368                 }
5369               else
5370                 break;  /* we are done */
5371             }
5372           else if (!is_operand_char (*l) && !is_space_char (*l) && *l != '"')
5373             {
5374               as_bad (_("invalid character %s in operand %d"),
5375                       output_invalid (*l),
5376                       i.operands + 1);
5377               return NULL;
5378             }
5379           if (!intel_syntax)
5380             {
5381               if (*l == '(')
5382                 ++paren_not_balanced;
5383               if (*l == ')')
5384                 --paren_not_balanced;
5385             }
5386           else
5387             {
5388               if (*l == '[')
5389                 ++paren_not_balanced;
5390               if (*l == ']')
5391                 --paren_not_balanced;
5392             }
5393           l++;
5394         }
5395       if (l != token_start)
5396         {                       /* Yes, we've read in another operand.  */
5397           unsigned int operand_ok;
5398           this_operand = i.operands++;
5399           if (i.operands > MAX_OPERANDS)
5400             {
5401               as_bad (_("spurious operands; (%d operands/instruction max)"),
5402                       MAX_OPERANDS);
5403               return NULL;
5404             }
5405           i.types[this_operand].bitfield.unspecified = 1;
5406           /* Now parse operand adding info to 'i' as we go along.  */
5407           END_STRING_AND_SAVE (l);
5408
5409           if (i.mem_operands > 1)
5410             {
5411               as_bad (_("too many memory references for `%s'"),
5412                       mnemonic);
5413               return 0;
5414             }
5415
5416           if (intel_syntax)
5417             operand_ok =
5418               i386_intel_operand (token_start,
5419                                   intel_float_operand (mnemonic));
5420           else
5421             operand_ok = i386_att_operand (token_start);
5422
5423           RESTORE_END_STRING (l);
5424           if (!operand_ok)
5425             return NULL;
5426         }
5427       else
5428         {
5429           if (expecting_operand)
5430             {
5431             expecting_operand_after_comma:
5432               as_bad (_("expecting operand after ','; got nothing"));
5433               return NULL;
5434             }
5435           if (*l == ',')
5436             {
5437               as_bad (_("expecting operand before ','; got nothing"));
5438               return NULL;
5439             }
5440         }
5441
5442       /* Now *l must be either ',' or END_OF_INSN.  */
5443       if (*l == ',')
5444         {
5445           if (*++l == END_OF_INSN)
5446             {
5447               /* Just skip it, if it's \n complain.  */
5448               goto expecting_operand_after_comma;
5449             }
5450           expecting_operand = 1;
5451         }
5452     }
5453   return l;
5454 }
5455
5456 static void
5457 swap_2_operands (int xchg1, int xchg2)
5458 {
5459   union i386_op temp_op;
5460   i386_operand_type temp_type;
5461   unsigned int temp_flags;
5462   enum bfd_reloc_code_real temp_reloc;
5463
5464   temp_type = i.types[xchg2];
5465   i.types[xchg2] = i.types[xchg1];
5466   i.types[xchg1] = temp_type;
5467
5468   temp_flags = i.flags[xchg2];
5469   i.flags[xchg2] = i.flags[xchg1];
5470   i.flags[xchg1] = temp_flags;
5471
5472   temp_op = i.op[xchg2];
5473   i.op[xchg2] = i.op[xchg1];
5474   i.op[xchg1] = temp_op;
5475
5476   temp_reloc = i.reloc[xchg2];
5477   i.reloc[xchg2] = i.reloc[xchg1];
5478   i.reloc[xchg1] = temp_reloc;
5479
5480   if (i.mask)
5481     {
5482       if (i.mask->operand == xchg1)
5483         i.mask->operand = xchg2;
5484       else if (i.mask->operand == xchg2)
5485         i.mask->operand = xchg1;
5486     }
5487   if (i.broadcast)
5488     {
5489       if (i.broadcast->operand == xchg1)
5490         i.broadcast->operand = xchg2;
5491       else if (i.broadcast->operand == xchg2)
5492         i.broadcast->operand = xchg1;
5493     }
5494   if (i.rounding)
5495     {
5496       if (i.rounding->operand == xchg1)
5497         i.rounding->operand = xchg2;
5498       else if (i.rounding->operand == xchg2)
5499         i.rounding->operand = xchg1;
5500     }
5501 }
5502
5503 static void
5504 swap_operands (void)
5505 {
5506   switch (i.operands)
5507     {
5508     case 5:
5509     case 4:
5510       swap_2_operands (1, i.operands - 2);
5511       /* Fall through.  */
5512     case 3:
5513     case 2:
5514       swap_2_operands (0, i.operands - 1);
5515       break;
5516     default:
5517       abort ();
5518     }
5519
5520   if (i.mem_operands == 2)
5521     {
5522       const seg_entry *temp_seg;
5523       temp_seg = i.seg[0];
5524       i.seg[0] = i.seg[1];
5525       i.seg[1] = temp_seg;
5526     }
5527 }
5528
5529 /* Try to ensure constant immediates are represented in the smallest
5530    opcode possible.  */
5531 static void
5532 optimize_imm (void)
5533 {
5534   char guess_suffix = 0;
5535   int op;
5536
5537   if (i.suffix)
5538     guess_suffix = i.suffix;
5539   else if (i.reg_operands)
5540     {
5541       /* Figure out a suffix from the last register operand specified.
5542          We can't do this properly yet, i.e. excluding special register
5543          instances, but the following works for instructions with
5544          immediates.  In any case, we can't set i.suffix yet.  */
5545       for (op = i.operands; --op >= 0;)
5546         if (i.types[op].bitfield.class != Reg)
5547           continue;
5548         else if (i.types[op].bitfield.byte)
5549           {
5550             guess_suffix = BYTE_MNEM_SUFFIX;
5551             break;
5552           }
5553         else if (i.types[op].bitfield.word)
5554           {
5555             guess_suffix = WORD_MNEM_SUFFIX;
5556             break;
5557           }
5558         else if (i.types[op].bitfield.dword)
5559           {
5560             guess_suffix = LONG_MNEM_SUFFIX;
5561             break;
5562           }
5563         else if (i.types[op].bitfield.qword)
5564           {
5565             guess_suffix = QWORD_MNEM_SUFFIX;
5566             break;
5567           }
5568     }
5569   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
5570     guess_suffix = WORD_MNEM_SUFFIX;
5571
5572   for (op = i.operands; --op >= 0;)
5573     if (operand_type_check (i.types[op], imm))
5574       {
5575         switch (i.op[op].imms->X_op)
5576           {
5577           case O_constant:
5578             /* If a suffix is given, this operand may be shortened.  */
5579             switch (guess_suffix)
5580               {
5581               case LONG_MNEM_SUFFIX:
5582                 i.types[op].bitfield.imm32 = 1;
5583                 i.types[op].bitfield.imm64 = 1;
5584                 break;
5585               case WORD_MNEM_SUFFIX:
5586                 i.types[op].bitfield.imm16 = 1;
5587                 i.types[op].bitfield.imm32 = 1;
5588                 i.types[op].bitfield.imm32s = 1;
5589                 i.types[op].bitfield.imm64 = 1;
5590                 break;
5591               case BYTE_MNEM_SUFFIX:
5592                 i.types[op].bitfield.imm8 = 1;
5593                 i.types[op].bitfield.imm8s = 1;
5594                 i.types[op].bitfield.imm16 = 1;
5595                 i.types[op].bitfield.imm32 = 1;
5596                 i.types[op].bitfield.imm32s = 1;
5597                 i.types[op].bitfield.imm64 = 1;
5598                 break;
5599               }
5600
5601             /* If this operand is at most 16 bits, convert it
5602                to a signed 16 bit number before trying to see
5603                whether it will fit in an even smaller size.
5604                This allows a 16-bit operand such as $0xffe0 to
5605                be recognised as within Imm8S range.  */
5606             if ((i.types[op].bitfield.imm16)
5607                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
5608               {
5609                 i.op[op].imms->X_add_number =
5610                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
5611               }
5612 #ifdef BFD64
5613             /* Store 32-bit immediate in 64-bit for 64-bit BFD.  */
5614             if ((i.types[op].bitfield.imm32)
5615                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
5616                     == 0))
5617               {
5618                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
5619                                                 ^ ((offsetT) 1 << 31))
5620                                                - ((offsetT) 1 << 31));
5621               }
5622 #endif
5623             i.types[op]
5624               = operand_type_or (i.types[op],
5625                                  smallest_imm_type (i.op[op].imms->X_add_number));
5626
5627             /* We must avoid matching of Imm32 templates when 64bit
5628                only immediate is available.  */
5629             if (guess_suffix == QWORD_MNEM_SUFFIX)
5630               i.types[op].bitfield.imm32 = 0;
5631             break;
5632
5633           case O_absent:
5634           case O_register:
5635             abort ();
5636
5637             /* Symbols and expressions.  */
5638           default:
5639             /* Convert symbolic operand to proper sizes for matching, but don't
5640                prevent matching a set of insns that only supports sizes other
5641                than those matching the insn suffix.  */
5642             {
5643               i386_operand_type mask, allowed;
5644               const insn_template *t;
5645
5646               operand_type_set (&mask, 0);
5647               operand_type_set (&allowed, 0);
5648
5649               for (t = current_templates->start;
5650                    t < current_templates->end;
5651                    ++t)
5652                 {
5653                   allowed = operand_type_or (allowed, t->operand_types[op]);
5654                   allowed = operand_type_and (allowed, anyimm);
5655                 }
5656               switch (guess_suffix)
5657                 {
5658                 case QWORD_MNEM_SUFFIX:
5659                   mask.bitfield.imm64 = 1;
5660                   mask.bitfield.imm32s = 1;
5661                   break;
5662                 case LONG_MNEM_SUFFIX:
5663                   mask.bitfield.imm32 = 1;
5664                   break;
5665                 case WORD_MNEM_SUFFIX:
5666                   mask.bitfield.imm16 = 1;
5667                   break;
5668                 case BYTE_MNEM_SUFFIX:
5669                   mask.bitfield.imm8 = 1;
5670                   break;
5671                 default:
5672                   break;
5673                 }
5674               allowed = operand_type_and (mask, allowed);
5675               if (!operand_type_all_zero (&allowed))
5676                 i.types[op] = operand_type_and (i.types[op], mask);
5677             }
5678             break;
5679           }
5680       }
5681 }
5682
5683 /* Try to use the smallest displacement type too.  */
5684 static void
5685 optimize_disp (void)
5686 {
5687   int op;
5688
5689   for (op = i.operands; --op >= 0;)
5690     if (operand_type_check (i.types[op], disp))
5691       {
5692         if (i.op[op].disps->X_op == O_constant)
5693           {
5694             offsetT op_disp = i.op[op].disps->X_add_number;
5695
5696             if (i.types[op].bitfield.disp16
5697                 && (op_disp & ~(offsetT) 0xffff) == 0)
5698               {
5699                 /* If this operand is at most 16 bits, convert
5700                    to a signed 16 bit number and don't use 64bit
5701                    displacement.  */
5702                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
5703                 i.types[op].bitfield.disp64 = 0;
5704               }
5705 #ifdef BFD64
5706             /* Optimize 64-bit displacement to 32-bit for 64-bit BFD.  */
5707             if (i.types[op].bitfield.disp32
5708                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
5709               {
5710                 /* If this operand is at most 32 bits, convert
5711                    to a signed 32 bit number and don't use 64bit
5712                    displacement.  */
5713                 op_disp &= (((offsetT) 2 << 31) - 1);
5714                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
5715                 i.types[op].bitfield.disp64 = 0;
5716               }
5717 #endif
5718             if (!op_disp && i.types[op].bitfield.baseindex)
5719               {
5720                 i.types[op].bitfield.disp8 = 0;
5721                 i.types[op].bitfield.disp16 = 0;
5722                 i.types[op].bitfield.disp32 = 0;
5723                 i.types[op].bitfield.disp32s = 0;
5724                 i.types[op].bitfield.disp64 = 0;
5725                 i.op[op].disps = 0;
5726                 i.disp_operands--;
5727               }
5728             else if (flag_code == CODE_64BIT)
5729               {
5730                 if (fits_in_signed_long (op_disp))
5731                   {
5732                     i.types[op].bitfield.disp64 = 0;
5733                     i.types[op].bitfield.disp32s = 1;
5734                   }
5735                 if (i.prefix[ADDR_PREFIX]
5736                     && fits_in_unsigned_long (op_disp))
5737                   i.types[op].bitfield.disp32 = 1;
5738               }
5739             if ((i.types[op].bitfield.disp32
5740                  || i.types[op].bitfield.disp32s
5741                  || i.types[op].bitfield.disp16)
5742                 && fits_in_disp8 (op_disp))
5743               i.types[op].bitfield.disp8 = 1;
5744           }
5745         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
5746                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
5747           {
5748             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
5749                          i.op[op].disps, 0, i.reloc[op]);
5750             i.types[op].bitfield.disp8 = 0;
5751             i.types[op].bitfield.disp16 = 0;
5752             i.types[op].bitfield.disp32 = 0;
5753             i.types[op].bitfield.disp32s = 0;
5754             i.types[op].bitfield.disp64 = 0;
5755           }
5756         else
5757           /* We only support 64bit displacement on constants.  */
5758           i.types[op].bitfield.disp64 = 0;
5759       }
5760 }
5761
5762 /* Return 1 if there is a match in broadcast bytes between operand
5763    GIVEN and instruction template T.   */
5764
5765 static INLINE int
5766 match_broadcast_size (const insn_template *t, unsigned int given)
5767 {
5768   return ((t->opcode_modifier.broadcast == BYTE_BROADCAST
5769            && i.types[given].bitfield.byte)
5770           || (t->opcode_modifier.broadcast == WORD_BROADCAST
5771               && i.types[given].bitfield.word)
5772           || (t->opcode_modifier.broadcast == DWORD_BROADCAST
5773               && i.types[given].bitfield.dword)
5774           || (t->opcode_modifier.broadcast == QWORD_BROADCAST
5775               && i.types[given].bitfield.qword));
5776 }
5777
5778 /* Check if operands are valid for the instruction.  */
5779
5780 static int
5781 check_VecOperands (const insn_template *t)
5782 {
5783   unsigned int op;
5784   i386_cpu_flags cpu;
5785
5786   /* Templates allowing for ZMMword as well as YMMword and/or XMMword for
5787      any one operand are implicity requiring AVX512VL support if the actual
5788      operand size is YMMword or XMMword.  Since this function runs after
5789      template matching, there's no need to check for YMMword/XMMword in
5790      the template.  */
5791   cpu = cpu_flags_and (t->cpu_flags, avx512);
5792   if (!cpu_flags_all_zero (&cpu)
5793       && !t->cpu_flags.bitfield.cpuavx512vl
5794       && !cpu_arch_flags.bitfield.cpuavx512vl)
5795     {
5796       for (op = 0; op < t->operands; ++op)
5797         {
5798           if (t->operand_types[op].bitfield.zmmword
5799               && (i.types[op].bitfield.ymmword
5800                   || i.types[op].bitfield.xmmword))
5801             {
5802               i.error = unsupported;
5803               return 1;
5804             }
5805         }
5806     }
5807
5808   /* Without VSIB byte, we can't have a vector register for index.  */
5809   if (!t->opcode_modifier.sib
5810       && i.index_reg
5811       && (i.index_reg->reg_type.bitfield.xmmword
5812           || i.index_reg->reg_type.bitfield.ymmword
5813           || i.index_reg->reg_type.bitfield.zmmword))
5814     {
5815       i.error = unsupported_vector_index_register;
5816       return 1;
5817     }
5818
5819   /* Check if default mask is allowed.  */
5820   if (t->opcode_modifier.nodefmask
5821       && (!i.mask || i.mask->mask->reg_num == 0))
5822     {
5823       i.error = no_default_mask;
5824       return 1;
5825     }
5826
5827   /* For VSIB byte, we need a vector register for index, and all vector
5828      registers must be distinct.  */
5829   if (t->opcode_modifier.sib && t->opcode_modifier.sib != SIBMEM)
5830     {
5831       if (!i.index_reg
5832           || !((t->opcode_modifier.sib == VECSIB128
5833                 && i.index_reg->reg_type.bitfield.xmmword)
5834                || (t->opcode_modifier.sib == VECSIB256
5835                    && i.index_reg->reg_type.bitfield.ymmword)
5836                || (t->opcode_modifier.sib == VECSIB512
5837                    && i.index_reg->reg_type.bitfield.zmmword)))
5838       {
5839         i.error = invalid_vsib_address;
5840         return 1;
5841       }
5842
5843       gas_assert (i.reg_operands == 2 || i.mask);
5844       if (i.reg_operands == 2 && !i.mask)
5845         {
5846           gas_assert (i.types[0].bitfield.class == RegSIMD);
5847           gas_assert (i.types[0].bitfield.xmmword
5848                       || i.types[0].bitfield.ymmword);
5849           gas_assert (i.types[2].bitfield.class == RegSIMD);
5850           gas_assert (i.types[2].bitfield.xmmword
5851                       || i.types[2].bitfield.ymmword);
5852           if (operand_check == check_none)
5853             return 0;
5854           if (register_number (i.op[0].regs)
5855               != register_number (i.index_reg)
5856               && register_number (i.op[2].regs)
5857                  != register_number (i.index_reg)
5858               && register_number (i.op[0].regs)
5859                  != register_number (i.op[2].regs))
5860             return 0;
5861           if (operand_check == check_error)
5862             {
5863               i.error = invalid_vector_register_set;
5864               return 1;
5865             }
5866           as_warn (_("mask, index, and destination registers should be distinct"));
5867         }
5868       else if (i.reg_operands == 1 && i.mask)
5869         {
5870           if (i.types[1].bitfield.class == RegSIMD
5871               && (i.types[1].bitfield.xmmword
5872                   || i.types[1].bitfield.ymmword
5873                   || i.types[1].bitfield.zmmword)
5874               && (register_number (i.op[1].regs)
5875                   == register_number (i.index_reg)))
5876             {
5877               if (operand_check == check_error)
5878                 {
5879                   i.error = invalid_vector_register_set;
5880                   return 1;
5881                 }
5882               if (operand_check != check_none)
5883                 as_warn (_("index and destination registers should be distinct"));
5884             }
5885         }
5886     }
5887
5888   /* For AMX instructions with three tmmword operands, all tmmword operand must be
5889      distinct */
5890   if (t->operand_types[0].bitfield.tmmword
5891       && i.reg_operands == 3)
5892     {
5893       if (register_number (i.op[0].regs)
5894           == register_number (i.op[1].regs)
5895           || register_number (i.op[0].regs)
5896              == register_number (i.op[2].regs)
5897           || register_number (i.op[1].regs)
5898              == register_number (i.op[2].regs))
5899         {
5900           i.error = invalid_tmm_register_set;
5901           return 1;
5902         }
5903     }
5904
5905   /* Check if broadcast is supported by the instruction and is applied
5906      to the memory operand.  */
5907   if (i.broadcast)
5908     {
5909       i386_operand_type type, overlap;
5910
5911       /* Check if specified broadcast is supported in this instruction,
5912          and its broadcast bytes match the memory operand.  */
5913       op = i.broadcast->operand;
5914       if (!t->opcode_modifier.broadcast
5915           || !(i.flags[op] & Operand_Mem)
5916           || (!i.types[op].bitfield.unspecified
5917               && !match_broadcast_size (t, op)))
5918         {
5919         bad_broadcast:
5920           i.error = unsupported_broadcast;
5921           return 1;
5922         }
5923
5924       i.broadcast->bytes = ((1 << (t->opcode_modifier.broadcast - 1))
5925                             * i.broadcast->type);
5926       operand_type_set (&type, 0);
5927       switch (i.broadcast->bytes)
5928         {
5929         case 2:
5930           type.bitfield.word = 1;
5931           break;
5932         case 4:
5933           type.bitfield.dword = 1;
5934           break;
5935         case 8:
5936           type.bitfield.qword = 1;
5937           break;
5938         case 16:
5939           type.bitfield.xmmword = 1;
5940           break;
5941         case 32:
5942           type.bitfield.ymmword = 1;
5943           break;
5944         case 64:
5945           type.bitfield.zmmword = 1;
5946           break;
5947         default:
5948           goto bad_broadcast;
5949         }
5950
5951       overlap = operand_type_and (type, t->operand_types[op]);
5952       if (t->operand_types[op].bitfield.class == RegSIMD
5953           && t->operand_types[op].bitfield.byte
5954              + t->operand_types[op].bitfield.word
5955              + t->operand_types[op].bitfield.dword
5956              + t->operand_types[op].bitfield.qword > 1)
5957         {
5958           overlap.bitfield.xmmword = 0;
5959           overlap.bitfield.ymmword = 0;
5960           overlap.bitfield.zmmword = 0;
5961         }
5962       if (operand_type_all_zero (&overlap))
5963           goto bad_broadcast;
5964
5965       if (t->opcode_modifier.checkregsize)
5966         {
5967           unsigned int j;
5968
5969           type.bitfield.baseindex = 1;
5970           for (j = 0; j < i.operands; ++j)
5971             {
5972               if (j != op
5973                   && !operand_type_register_match(i.types[j],
5974                                                   t->operand_types[j],
5975                                                   type,
5976                                                   t->operand_types[op]))
5977                 goto bad_broadcast;
5978             }
5979         }
5980     }
5981   /* If broadcast is supported in this instruction, we need to check if
5982      operand of one-element size isn't specified without broadcast.  */
5983   else if (t->opcode_modifier.broadcast && i.mem_operands)
5984     {
5985       /* Find memory operand.  */
5986       for (op = 0; op < i.operands; op++)
5987         if (i.flags[op] & Operand_Mem)
5988           break;
5989       gas_assert (op < i.operands);
5990       /* Check size of the memory operand.  */
5991       if (match_broadcast_size (t, op))
5992         {
5993           i.error = broadcast_needed;
5994           return 1;
5995         }
5996     }
5997   else
5998     op = MAX_OPERANDS - 1; /* Avoid uninitialized variable warning.  */
5999
6000   /* Check if requested masking is supported.  */
6001   if (i.mask)
6002     {
6003       switch (t->opcode_modifier.masking)
6004         {
6005         case BOTH_MASKING:
6006           break;
6007         case MERGING_MASKING:
6008           if (i.mask->zeroing)
6009             {
6010         case 0:
6011               i.error = unsupported_masking;
6012               return 1;
6013             }
6014           break;
6015         case DYNAMIC_MASKING:
6016           /* Memory destinations allow only merging masking.  */
6017           if (i.mask->zeroing && i.mem_operands)
6018             {
6019               /* Find memory operand.  */
6020               for (op = 0; op < i.operands; op++)
6021                 if (i.flags[op] & Operand_Mem)
6022                   break;
6023               gas_assert (op < i.operands);
6024               if (op == i.operands - 1)
6025                 {
6026                   i.error = unsupported_masking;
6027                   return 1;
6028                 }
6029             }
6030           break;
6031         default:
6032           abort ();
6033         }
6034     }
6035
6036   /* Check if masking is applied to dest operand.  */
6037   if (i.mask && (i.mask->operand != (int) (i.operands - 1)))
6038     {
6039       i.error = mask_not_on_destination;
6040       return 1;
6041     }
6042
6043   /* Check RC/SAE.  */
6044   if (i.rounding)
6045     {
6046       if (!t->opcode_modifier.sae
6047           || (i.rounding->type != saeonly && !t->opcode_modifier.staticrounding))
6048         {
6049           i.error = unsupported_rc_sae;
6050           return 1;
6051         }
6052       /* If the instruction has several immediate operands and one of
6053          them is rounding, the rounding operand should be the last
6054          immediate operand.  */
6055       if (i.imm_operands > 1
6056           && i.rounding->operand != (int) (i.imm_operands - 1))
6057         {
6058           i.error = rc_sae_operand_not_last_imm;
6059           return 1;
6060         }
6061     }
6062
6063   /* Check the special Imm4 cases; must be the first operand.  */
6064   if (t->cpu_flags.bitfield.cpuxop && t->operands == 5)
6065     {
6066       if (i.op[0].imms->X_op != O_constant
6067           || !fits_in_imm4 (i.op[0].imms->X_add_number))
6068         {
6069           i.error = bad_imm4;
6070           return 1;
6071         }
6072
6073       /* Turn off Imm<N> so that update_imm won't complain.  */
6074       operand_type_set (&i.types[0], 0);
6075     }
6076
6077   /* Check vector Disp8 operand.  */
6078   if (t->opcode_modifier.disp8memshift
6079       && i.disp_encoding != disp_encoding_32bit)
6080     {
6081       if (i.broadcast)
6082         i.memshift = t->opcode_modifier.broadcast - 1;
6083       else if (t->opcode_modifier.disp8memshift != DISP8_SHIFT_VL)
6084         i.memshift = t->opcode_modifier.disp8memshift;
6085       else
6086         {
6087           const i386_operand_type *type = NULL;
6088
6089           i.memshift = 0;
6090           for (op = 0; op < i.operands; op++)
6091             if (i.flags[op] & Operand_Mem)
6092               {
6093                 if (t->opcode_modifier.evex == EVEXLIG)
6094                   i.memshift = 2 + (i.suffix == QWORD_MNEM_SUFFIX);
6095                 else if (t->operand_types[op].bitfield.xmmword
6096                          + t->operand_types[op].bitfield.ymmword
6097                          + t->operand_types[op].bitfield.zmmword <= 1)
6098                   type = &t->operand_types[op];
6099                 else if (!i.types[op].bitfield.unspecified)
6100                   type = &i.types[op];
6101               }
6102             else if (i.types[op].bitfield.class == RegSIMD
6103                      && t->opcode_modifier.evex != EVEXLIG)
6104               {
6105                 if (i.types[op].bitfield.zmmword)
6106                   i.memshift = 6;
6107                 else if (i.types[op].bitfield.ymmword && i.memshift < 5)
6108                   i.memshift = 5;
6109                 else if (i.types[op].bitfield.xmmword && i.memshift < 4)
6110                   i.memshift = 4;
6111               }
6112
6113           if (type)
6114             {
6115               if (type->bitfield.zmmword)
6116                 i.memshift = 6;
6117               else if (type->bitfield.ymmword)
6118                 i.memshift = 5;
6119               else if (type->bitfield.xmmword)
6120                 i.memshift = 4;
6121             }
6122
6123           /* For the check in fits_in_disp8().  */
6124           if (i.memshift == 0)
6125             i.memshift = -1;
6126         }
6127
6128       for (op = 0; op < i.operands; op++)
6129         if (operand_type_check (i.types[op], disp)
6130             && i.op[op].disps->X_op == O_constant)
6131           {
6132             if (fits_in_disp8 (i.op[op].disps->X_add_number))
6133               {
6134                 i.types[op].bitfield.disp8 = 1;
6135                 return 0;
6136               }
6137             i.types[op].bitfield.disp8 = 0;
6138           }
6139     }
6140
6141   i.memshift = 0;
6142
6143   return 0;
6144 }
6145
6146 /* Check if encoding requirements are met by the instruction.  */
6147
6148 static int
6149 VEX_check_encoding (const insn_template *t)
6150 {
6151   if (i.vec_encoding == vex_encoding_error)
6152     {
6153       i.error = unsupported;
6154       return 1;
6155     }
6156
6157   if (i.vec_encoding == vex_encoding_evex)
6158     {
6159       /* This instruction must be encoded with EVEX prefix.  */
6160       if (!is_evex_encoding (t))
6161         {
6162           i.error = unsupported;
6163           return 1;
6164         }
6165       return 0;
6166     }
6167
6168   if (!t->opcode_modifier.vex)
6169     {
6170       /* This instruction template doesn't have VEX prefix.  */
6171       if (i.vec_encoding != vex_encoding_default)
6172         {
6173           i.error = unsupported;
6174           return 1;
6175         }
6176       return 0;
6177     }
6178
6179   return 0;
6180 }
6181
6182 static const insn_template *
6183 match_template (char mnem_suffix)
6184 {
6185   /* Points to template once we've found it.  */
6186   const insn_template *t;
6187   i386_operand_type overlap0, overlap1, overlap2, overlap3;
6188   i386_operand_type overlap4;
6189   unsigned int found_reverse_match;
6190   i386_opcode_modifier suffix_check;
6191   i386_operand_type operand_types [MAX_OPERANDS];
6192   int addr_prefix_disp;
6193   unsigned int j, size_match, check_register;
6194   enum i386_error specific_error = 0;
6195
6196 #if MAX_OPERANDS != 5
6197 # error "MAX_OPERANDS must be 5."
6198 #endif
6199
6200   found_reverse_match = 0;
6201   addr_prefix_disp = -1;
6202
6203   /* Prepare for mnemonic suffix check.  */
6204   memset (&suffix_check, 0, sizeof (suffix_check));
6205   switch (mnem_suffix)
6206     {
6207     case BYTE_MNEM_SUFFIX:
6208       suffix_check.no_bsuf = 1;
6209       break;
6210     case WORD_MNEM_SUFFIX:
6211       suffix_check.no_wsuf = 1;
6212       break;
6213     case SHORT_MNEM_SUFFIX:
6214       suffix_check.no_ssuf = 1;
6215       break;
6216     case LONG_MNEM_SUFFIX:
6217       suffix_check.no_lsuf = 1;
6218       break;
6219     case QWORD_MNEM_SUFFIX:
6220       suffix_check.no_qsuf = 1;
6221       break;
6222     default:
6223       /* NB: In Intel syntax, normally we can check for memory operand
6224          size when there is no mnemonic suffix.  But jmp and call have
6225          2 different encodings with Dword memory operand size, one with
6226          No_ldSuf and the other without.  i.suffix is set to
6227          LONG_DOUBLE_MNEM_SUFFIX to skip the one with No_ldSuf.  */
6228       if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
6229         suffix_check.no_ldsuf = 1;
6230     }
6231
6232   /* Must have right number of operands.  */
6233   i.error = number_of_operands_mismatch;
6234
6235   for (t = current_templates->start; t < current_templates->end; t++)
6236     {
6237       addr_prefix_disp = -1;
6238       found_reverse_match = 0;
6239
6240       if (i.operands != t->operands)
6241         continue;
6242
6243       /* Check processor support.  */
6244       i.error = unsupported;
6245       if (cpu_flags_match (t) != CPU_FLAGS_PERFECT_MATCH)
6246         continue;
6247
6248       /* Check AT&T mnemonic.   */
6249       i.error = unsupported_with_intel_mnemonic;
6250       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
6251         continue;
6252
6253       /* Check AT&T/Intel syntax.  */
6254       i.error = unsupported_syntax;
6255       if ((intel_syntax && t->opcode_modifier.attsyntax)
6256           || (!intel_syntax && t->opcode_modifier.intelsyntax))
6257         continue;
6258
6259       /* Check Intel64/AMD64 ISA.   */
6260       switch (isa64)
6261         {
6262         default:
6263           /* Default: Don't accept Intel64.  */
6264           if (t->opcode_modifier.isa64 == INTEL64)
6265             continue;
6266           break;
6267         case amd64:
6268           /* -mamd64: Don't accept Intel64 and Intel64 only.  */
6269           if (t->opcode_modifier.isa64 >= INTEL64)
6270             continue;
6271           break;
6272         case intel64:
6273           /* -mintel64: Don't accept AMD64.  */
6274           if (t->opcode_modifier.isa64 == AMD64 && flag_code == CODE_64BIT)
6275             continue;
6276           break;
6277         }
6278
6279       /* Check the suffix.  */
6280       i.error = invalid_instruction_suffix;
6281       if ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
6282           || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
6283           || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
6284           || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
6285           || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
6286           || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf))
6287         continue;
6288
6289       size_match = operand_size_match (t);
6290       if (!size_match)
6291         continue;
6292
6293       /* This is intentionally not
6294
6295          if (i.jumpabsolute != (t->opcode_modifier.jump == JUMP_ABSOLUTE))
6296
6297          as the case of a missing * on the operand is accepted (perhaps with
6298          a warning, issued further down).  */
6299       if (i.jumpabsolute && t->opcode_modifier.jump != JUMP_ABSOLUTE)
6300         {
6301           i.error = operand_type_mismatch;
6302           continue;
6303         }
6304
6305       for (j = 0; j < MAX_OPERANDS; j++)
6306         operand_types[j] = t->operand_types[j];
6307
6308       /* In general, don't allow
6309          - 64-bit operands outside of 64-bit mode,
6310          - 32-bit operands on pre-386.  */
6311       j = i.imm_operands + (t->operands > i.imm_operands + 1);
6312       if (((i.suffix == QWORD_MNEM_SUFFIX
6313             && flag_code != CODE_64BIT
6314             && (t->base_opcode != 0x0fc7
6315                 || t->extension_opcode != 1 /* cmpxchg8b */))
6316            || (i.suffix == LONG_MNEM_SUFFIX
6317                && !cpu_arch_flags.bitfield.cpui386))
6318           && (intel_syntax
6319               ? (t->opcode_modifier.mnemonicsize != IGNORESIZE
6320                  && !intel_float_operand (t->name))
6321               : intel_float_operand (t->name) != 2)
6322           && (t->operands == i.imm_operands
6323               || (operand_types[i.imm_operands].bitfield.class != RegMMX
6324                && operand_types[i.imm_operands].bitfield.class != RegSIMD
6325                && operand_types[i.imm_operands].bitfield.class != RegMask)
6326               || (operand_types[j].bitfield.class != RegMMX
6327                   && operand_types[j].bitfield.class != RegSIMD
6328                   && operand_types[j].bitfield.class != RegMask))
6329           && !t->opcode_modifier.sib)
6330         continue;
6331
6332       /* Do not verify operands when there are none.  */
6333       if (!t->operands)
6334         {
6335           if (VEX_check_encoding (t))
6336             {
6337               specific_error = i.error;
6338               continue;
6339             }
6340
6341           /* We've found a match; break out of loop.  */
6342           break;
6343         }
6344
6345       if (!t->opcode_modifier.jump
6346           || t->opcode_modifier.jump == JUMP_ABSOLUTE)
6347         {
6348           /* There should be only one Disp operand.  */
6349           for (j = 0; j < MAX_OPERANDS; j++)
6350             if (operand_type_check (operand_types[j], disp))
6351               break;
6352           if (j < MAX_OPERANDS)
6353             {
6354               bfd_boolean override = (i.prefix[ADDR_PREFIX] != 0);
6355
6356               addr_prefix_disp = j;
6357
6358               /* Address size prefix will turn Disp64/Disp32S/Disp32/Disp16
6359                  operand into Disp32/Disp32/Disp16/Disp32 operand.  */
6360               switch (flag_code)
6361                 {
6362                 case CODE_16BIT:
6363                   override = !override;
6364                   /* Fall through.  */
6365                 case CODE_32BIT:
6366                   if (operand_types[j].bitfield.disp32
6367                       && operand_types[j].bitfield.disp16)
6368                     {
6369                       operand_types[j].bitfield.disp16 = override;
6370                       operand_types[j].bitfield.disp32 = !override;
6371                     }
6372                   operand_types[j].bitfield.disp32s = 0;
6373                   operand_types[j].bitfield.disp64 = 0;
6374                   break;
6375
6376                 case CODE_64BIT:
6377                   if (operand_types[j].bitfield.disp32s
6378                       || operand_types[j].bitfield.disp64)
6379                     {
6380                       operand_types[j].bitfield.disp64 &= !override;
6381                       operand_types[j].bitfield.disp32s &= !override;
6382                       operand_types[j].bitfield.disp32 = override;
6383                     }
6384                   operand_types[j].bitfield.disp16 = 0;
6385                   break;
6386                 }
6387             }
6388         }
6389
6390       /* Force 0x8b encoding for "mov foo@GOT, %eax".  */
6391       if (i.reloc[0] == BFD_RELOC_386_GOT32 && t->base_opcode == 0xa0)
6392         continue;
6393
6394       /* We check register size if needed.  */
6395       if (t->opcode_modifier.checkregsize)
6396         {
6397           check_register = (1 << t->operands) - 1;
6398           if (i.broadcast)
6399             check_register &= ~(1 << i.broadcast->operand);
6400         }
6401       else
6402         check_register = 0;
6403
6404       overlap0 = operand_type_and (i.types[0], operand_types[0]);
6405       switch (t->operands)
6406         {
6407         case 1:
6408           if (!operand_type_match (overlap0, i.types[0]))
6409             continue;
6410           break;
6411         case 2:
6412           /* xchg %eax, %eax is a special case. It is an alias for nop
6413              only in 32bit mode and we can use opcode 0x90.  In 64bit
6414              mode, we can't use 0x90 for xchg %eax, %eax since it should
6415              zero-extend %eax to %rax.  */
6416           if (flag_code == CODE_64BIT
6417               && t->base_opcode == 0x90
6418               && i.types[0].bitfield.instance == Accum
6419               && i.types[0].bitfield.dword
6420               && i.types[1].bitfield.instance == Accum
6421               && i.types[1].bitfield.dword)
6422             continue;
6423           /* xrelease mov %eax, <disp> is another special case. It must not
6424              match the accumulator-only encoding of mov.  */
6425           if (flag_code != CODE_64BIT
6426               && i.hle_prefix
6427               && t->base_opcode == 0xa0
6428               && i.types[0].bitfield.instance == Accum
6429               && (i.flags[1] & Operand_Mem))
6430             continue;
6431           /* Fall through.  */
6432
6433         case 3:
6434           if (!(size_match & MATCH_STRAIGHT))
6435             goto check_reverse;
6436           /* Reverse direction of operands if swapping is possible in the first
6437              place (operands need to be symmetric) and
6438              - the load form is requested, and the template is a store form,
6439              - the store form is requested, and the template is a load form,
6440              - the non-default (swapped) form is requested.  */
6441           overlap1 = operand_type_and (operand_types[0], operand_types[1]);
6442           if (t->opcode_modifier.d && i.reg_operands == i.operands
6443               && !operand_type_all_zero (&overlap1))
6444             switch (i.dir_encoding)
6445               {
6446               case dir_encoding_load:
6447                 if (operand_type_check (operand_types[i.operands - 1], anymem)
6448                     || t->opcode_modifier.regmem)
6449                   goto check_reverse;
6450                 break;
6451
6452               case dir_encoding_store:
6453                 if (!operand_type_check (operand_types[i.operands - 1], anymem)
6454                     && !t->opcode_modifier.regmem)
6455                   goto check_reverse;
6456                 break;
6457
6458               case dir_encoding_swap:
6459                 goto check_reverse;
6460
6461               case dir_encoding_default:
6462                 break;
6463               }
6464           /* If we want store form, we skip the current load.  */
6465           if ((i.dir_encoding == dir_encoding_store
6466                || i.dir_encoding == dir_encoding_swap)
6467               && i.mem_operands == 0
6468               && t->opcode_modifier.load)
6469             continue;
6470           /* Fall through.  */
6471         case 4:
6472         case 5:
6473           overlap1 = operand_type_and (i.types[1], operand_types[1]);
6474           if (!operand_type_match (overlap0, i.types[0])
6475               || !operand_type_match (overlap1, i.types[1])
6476               || ((check_register & 3) == 3
6477                   && !operand_type_register_match (i.types[0],
6478                                                    operand_types[0],
6479                                                    i.types[1],
6480                                                    operand_types[1])))
6481             {
6482               /* Check if other direction is valid ...  */
6483               if (!t->opcode_modifier.d)
6484                 continue;
6485
6486             check_reverse:
6487               if (!(size_match & MATCH_REVERSE))
6488                 continue;
6489               /* Try reversing direction of operands.  */
6490               overlap0 = operand_type_and (i.types[0], operand_types[i.operands - 1]);
6491               overlap1 = operand_type_and (i.types[i.operands - 1], operand_types[0]);
6492               if (!operand_type_match (overlap0, i.types[0])
6493                   || !operand_type_match (overlap1, i.types[i.operands - 1])
6494                   || (check_register
6495                       && !operand_type_register_match (i.types[0],
6496                                                        operand_types[i.operands - 1],
6497                                                        i.types[i.operands - 1],
6498                                                        operand_types[0])))
6499                 {
6500                   /* Does not match either direction.  */
6501                   continue;
6502                 }
6503               /* found_reverse_match holds which of D or FloatR
6504                  we've found.  */
6505               if (!t->opcode_modifier.d)
6506                 found_reverse_match = 0;
6507               else if (operand_types[0].bitfield.tbyte)
6508                 found_reverse_match = Opcode_FloatD;
6509               else if (operand_types[0].bitfield.xmmword
6510                        || operand_types[i.operands - 1].bitfield.xmmword
6511                        || operand_types[0].bitfield.class == RegMMX
6512                        || operand_types[i.operands - 1].bitfield.class == RegMMX
6513                        || is_any_vex_encoding(t))
6514                 found_reverse_match = (t->base_opcode & 0xee) != 0x6e
6515                                       ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
6516               else
6517                 found_reverse_match = Opcode_D;
6518               if (t->opcode_modifier.floatr)
6519                 found_reverse_match |= Opcode_FloatR;
6520             }
6521           else
6522             {
6523               /* Found a forward 2 operand match here.  */
6524               switch (t->operands)
6525                 {
6526                 case 5:
6527                   overlap4 = operand_type_and (i.types[4],
6528                                                operand_types[4]);
6529                   /* Fall through.  */
6530                 case 4:
6531                   overlap3 = operand_type_and (i.types[3],
6532                                                operand_types[3]);
6533                   /* Fall through.  */
6534                 case 3:
6535                   overlap2 = operand_type_and (i.types[2],
6536                                                operand_types[2]);
6537                   break;
6538                 }
6539
6540               switch (t->operands)
6541                 {
6542                 case 5:
6543                   if (!operand_type_match (overlap4, i.types[4])
6544                       || !operand_type_register_match (i.types[3],
6545                                                        operand_types[3],
6546                                                        i.types[4],
6547                                                        operand_types[4]))
6548                     continue;
6549                   /* Fall through.  */
6550                 case 4:
6551                   if (!operand_type_match (overlap3, i.types[3])
6552                       || ((check_register & 0xa) == 0xa
6553                           && !operand_type_register_match (i.types[1],
6554                                                             operand_types[1],
6555                                                             i.types[3],
6556                                                             operand_types[3]))
6557                       || ((check_register & 0xc) == 0xc
6558                           && !operand_type_register_match (i.types[2],
6559                                                             operand_types[2],
6560                                                             i.types[3],
6561                                                             operand_types[3])))
6562                     continue;
6563                   /* Fall through.  */
6564                 case 3:
6565                   /* Here we make use of the fact that there are no
6566                      reverse match 3 operand instructions.  */
6567                   if (!operand_type_match (overlap2, i.types[2])
6568                       || ((check_register & 5) == 5
6569                           && !operand_type_register_match (i.types[0],
6570                                                             operand_types[0],
6571                                                             i.types[2],
6572                                                             operand_types[2]))
6573                       || ((check_register & 6) == 6
6574                           && !operand_type_register_match (i.types[1],
6575                                                             operand_types[1],
6576                                                             i.types[2],
6577                                                             operand_types[2])))
6578                     continue;
6579                   break;
6580                 }
6581             }
6582           /* Found either forward/reverse 2, 3 or 4 operand match here:
6583              slip through to break.  */
6584         }
6585
6586       /* Check if vector operands are valid.  */
6587       if (check_VecOperands (t))
6588         {
6589           specific_error = i.error;
6590           continue;
6591         }
6592
6593       /* Check if VEX/EVEX encoding requirements can be satisfied.  */
6594       if (VEX_check_encoding (t))
6595         {
6596           specific_error = i.error;
6597           continue;
6598         }
6599
6600       /* We've found a match; break out of loop.  */
6601       break;
6602     }
6603
6604   if (t == current_templates->end)
6605     {
6606       /* We found no match.  */
6607       const char *err_msg;
6608       switch (specific_error ? specific_error : i.error)
6609         {
6610         default:
6611           abort ();
6612         case operand_size_mismatch:
6613           err_msg = _("operand size mismatch");
6614           break;
6615         case operand_type_mismatch:
6616           err_msg = _("operand type mismatch");
6617           break;
6618         case register_type_mismatch:
6619           err_msg = _("register type mismatch");
6620           break;
6621         case number_of_operands_mismatch:
6622           err_msg = _("number of operands mismatch");
6623           break;
6624         case invalid_instruction_suffix:
6625           err_msg = _("invalid instruction suffix");
6626           break;
6627         case bad_imm4:
6628           err_msg = _("constant doesn't fit in 4 bits");
6629           break;
6630         case unsupported_with_intel_mnemonic:
6631           err_msg = _("unsupported with Intel mnemonic");
6632           break;
6633         case unsupported_syntax:
6634           err_msg = _("unsupported syntax");
6635           break;
6636         case unsupported:
6637           as_bad (_("unsupported instruction `%s'"),
6638                   current_templates->start->name);
6639           return NULL;
6640         case invalid_sib_address:
6641           err_msg = _("invalid SIB address");
6642           break;
6643         case invalid_vsib_address:
6644           err_msg = _("invalid VSIB address");
6645           break;
6646         case invalid_vector_register_set:
6647           err_msg = _("mask, index, and destination registers must be distinct");
6648           break;
6649         case invalid_tmm_register_set:
6650           err_msg = _("all tmm registers must be distinct");
6651           break;
6652         case unsupported_vector_index_register:
6653           err_msg = _("unsupported vector index register");
6654           break;
6655         case unsupported_broadcast:
6656           err_msg = _("unsupported broadcast");
6657           break;
6658         case broadcast_needed:
6659           err_msg = _("broadcast is needed for operand of such type");
6660           break;
6661         case unsupported_masking:
6662           err_msg = _("unsupported masking");
6663           break;
6664         case mask_not_on_destination:
6665           err_msg = _("mask not on destination operand");
6666           break;
6667         case no_default_mask:
6668           err_msg = _("default mask isn't allowed");
6669           break;
6670         case unsupported_rc_sae:
6671           err_msg = _("unsupported static rounding/sae");
6672           break;
6673         case rc_sae_operand_not_last_imm:
6674           if (intel_syntax)
6675             err_msg = _("RC/SAE operand must precede immediate operands");
6676           else
6677             err_msg = _("RC/SAE operand must follow immediate operands");
6678           break;
6679         case invalid_register_operand:
6680           err_msg = _("invalid register operand");
6681           break;
6682         }
6683       as_bad (_("%s for `%s'"), err_msg,
6684               current_templates->start->name);
6685       return NULL;
6686     }
6687
6688   if (!quiet_warnings)
6689     {
6690       if (!intel_syntax
6691           && (i.jumpabsolute != (t->opcode_modifier.jump == JUMP_ABSOLUTE)))
6692         as_warn (_("indirect %s without `*'"), t->name);
6693
6694       if (t->opcode_modifier.isprefix
6695           && t->opcode_modifier.mnemonicsize == IGNORESIZE)
6696         {
6697           /* Warn them that a data or address size prefix doesn't
6698              affect assembly of the next line of code.  */
6699           as_warn (_("stand-alone `%s' prefix"), t->name);
6700         }
6701     }
6702
6703   /* Copy the template we found.  */
6704   i.tm = *t;
6705
6706   if (addr_prefix_disp != -1)
6707     i.tm.operand_types[addr_prefix_disp]
6708       = operand_types[addr_prefix_disp];
6709
6710   if (found_reverse_match)
6711     {
6712       /* If we found a reverse match we must alter the opcode direction
6713          bit and clear/flip the regmem modifier one.  found_reverse_match
6714          holds bits to change (different for int & float insns).  */
6715
6716       i.tm.base_opcode ^= found_reverse_match;
6717
6718       i.tm.operand_types[0] = operand_types[i.operands - 1];
6719       i.tm.operand_types[i.operands - 1] = operand_types[0];
6720
6721       /* Certain SIMD insns have their load forms specified in the opcode
6722          table, and hence we need to _set_ RegMem instead of clearing it.
6723          We need to avoid setting the bit though on insns like KMOVW.  */
6724       i.tm.opcode_modifier.regmem
6725         = i.tm.opcode_modifier.modrm && i.tm.opcode_modifier.d
6726           && i.tm.operands > 2U - i.tm.opcode_modifier.sse2avx
6727           && !i.tm.opcode_modifier.regmem;
6728     }
6729
6730   return t;
6731 }
6732
6733 static int
6734 check_string (void)
6735 {
6736   unsigned int es_op = i.tm.opcode_modifier.isstring - IS_STRING_ES_OP0;
6737   unsigned int op = i.tm.operand_types[0].bitfield.baseindex ? es_op : 0;
6738
6739   if (i.seg[op] != NULL && i.seg[op] != &es)
6740     {
6741       as_bad (_("`%s' operand %u must use `%ses' segment"),
6742               i.tm.name,
6743               intel_syntax ? i.tm.operands - es_op : es_op + 1,
6744               register_prefix);
6745       return 0;
6746     }
6747
6748   /* There's only ever one segment override allowed per instruction.
6749      This instruction possibly has a legal segment override on the
6750      second operand, so copy the segment to where non-string
6751      instructions store it, allowing common code.  */
6752   i.seg[op] = i.seg[1];
6753
6754   return 1;
6755 }
6756
6757 static int
6758 process_suffix (void)
6759 {
6760   /* If matched instruction specifies an explicit instruction mnemonic
6761      suffix, use it.  */
6762   if (i.tm.opcode_modifier.size == SIZE16)
6763     i.suffix = WORD_MNEM_SUFFIX;
6764   else if (i.tm.opcode_modifier.size == SIZE32)
6765     i.suffix = LONG_MNEM_SUFFIX;
6766   else if (i.tm.opcode_modifier.size == SIZE64)
6767     i.suffix = QWORD_MNEM_SUFFIX;
6768   else if (i.reg_operands
6769            && (i.operands > 1 || i.types[0].bitfield.class == Reg)
6770            && !i.tm.opcode_modifier.addrprefixopreg)
6771     {
6772       unsigned int numop = i.operands;
6773
6774       /* movsx/movzx want only their source operand considered here, for the
6775          ambiguity checking below.  The suffix will be replaced afterwards
6776          to represent the destination (register).  */
6777       if (((i.tm.base_opcode | 8) == 0xfbe && i.tm.opcode_modifier.w)
6778           || (i.tm.base_opcode == 0x63 && i.tm.cpu_flags.bitfield.cpu64))
6779         --i.operands;
6780
6781       /* crc32 needs REX.W set regardless of suffix / source operand size.  */
6782       if (i.tm.base_opcode == 0xf20f38f0
6783           && i.tm.operand_types[1].bitfield.qword)
6784         i.rex |= REX_W;
6785
6786       /* If there's no instruction mnemonic suffix we try to invent one
6787          based on GPR operands.  */
6788       if (!i.suffix)
6789         {
6790           /* We take i.suffix from the last register operand specified,
6791              Destination register type is more significant than source
6792              register type.  crc32 in SSE4.2 prefers source register
6793              type. */
6794           unsigned int op = i.tm.base_opcode != 0xf20f38f0 ? i.operands : 1;
6795
6796           while (op--)
6797             if (i.tm.operand_types[op].bitfield.instance == InstanceNone
6798                 || i.tm.operand_types[op].bitfield.instance == Accum)
6799               {
6800                 if (i.types[op].bitfield.class != Reg)
6801                   continue;
6802                 if (i.types[op].bitfield.byte)
6803                   i.suffix = BYTE_MNEM_SUFFIX;
6804                 else if (i.types[op].bitfield.word)
6805                   i.suffix = WORD_MNEM_SUFFIX;
6806                 else if (i.types[op].bitfield.dword)
6807                   i.suffix = LONG_MNEM_SUFFIX;
6808                 else if (i.types[op].bitfield.qword)
6809                   i.suffix = QWORD_MNEM_SUFFIX;
6810                 else
6811                   continue;
6812                 break;
6813               }
6814
6815           /* As an exception, movsx/movzx silently default to a byte source
6816              in AT&T mode.  */
6817           if ((i.tm.base_opcode | 8) == 0xfbe && i.tm.opcode_modifier.w
6818               && !i.suffix && !intel_syntax)
6819             i.suffix = BYTE_MNEM_SUFFIX;
6820         }
6821       else if (i.suffix == BYTE_MNEM_SUFFIX)
6822         {
6823           if (intel_syntax
6824               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6825               && i.tm.opcode_modifier.no_bsuf)
6826             i.suffix = 0;
6827           else if (!check_byte_reg ())
6828             return 0;
6829         }
6830       else if (i.suffix == LONG_MNEM_SUFFIX)
6831         {
6832           if (intel_syntax
6833               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6834               && i.tm.opcode_modifier.no_lsuf
6835               && !i.tm.opcode_modifier.todword
6836               && !i.tm.opcode_modifier.toqword)
6837             i.suffix = 0;
6838           else if (!check_long_reg ())
6839             return 0;
6840         }
6841       else if (i.suffix == QWORD_MNEM_SUFFIX)
6842         {
6843           if (intel_syntax
6844               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6845               && i.tm.opcode_modifier.no_qsuf
6846               && !i.tm.opcode_modifier.todword
6847               && !i.tm.opcode_modifier.toqword)
6848             i.suffix = 0;
6849           else if (!check_qword_reg ())
6850             return 0;
6851         }
6852       else if (i.suffix == WORD_MNEM_SUFFIX)
6853         {
6854           if (intel_syntax
6855               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6856               && i.tm.opcode_modifier.no_wsuf)
6857             i.suffix = 0;
6858           else if (!check_word_reg ())
6859             return 0;
6860         }
6861       else if (intel_syntax
6862                && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE)
6863         /* Do nothing if the instruction is going to ignore the prefix.  */
6864         ;
6865       else
6866         abort ();
6867
6868       /* Undo the movsx/movzx change done above.  */
6869       i.operands = numop;
6870     }
6871   else if (i.tm.opcode_modifier.mnemonicsize == DEFAULTSIZE
6872            && !i.suffix)
6873     {
6874       i.suffix = stackop_size;
6875       if (stackop_size == LONG_MNEM_SUFFIX)
6876         {
6877           /* stackop_size is set to LONG_MNEM_SUFFIX for the
6878              .code16gcc directive to support 16-bit mode with
6879              32-bit address.  For IRET without a suffix, generate
6880              16-bit IRET (opcode 0xcf) to return from an interrupt
6881              handler.  */
6882           if (i.tm.base_opcode == 0xcf)
6883             {
6884               i.suffix = WORD_MNEM_SUFFIX;
6885               as_warn (_("generating 16-bit `iret' for .code16gcc directive"));
6886             }
6887           /* Warn about changed behavior for segment register push/pop.  */
6888           else if ((i.tm.base_opcode | 1) == 0x07)
6889             as_warn (_("generating 32-bit `%s', unlike earlier gas versions"),
6890                      i.tm.name);
6891         }
6892     }
6893   else if (!i.suffix
6894            && (i.tm.opcode_modifier.jump == JUMP_ABSOLUTE
6895                || i.tm.opcode_modifier.jump == JUMP_BYTE
6896                || i.tm.opcode_modifier.jump == JUMP_INTERSEGMENT
6897                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
6898                    && i.tm.extension_opcode <= 3)))
6899     {
6900       switch (flag_code)
6901         {
6902         case CODE_64BIT:
6903           if (!i.tm.opcode_modifier.no_qsuf)
6904             {
6905               if (i.tm.opcode_modifier.jump == JUMP_BYTE
6906                   || i.tm.opcode_modifier.no_lsuf)
6907                 i.suffix = QWORD_MNEM_SUFFIX;
6908               break;
6909             }
6910           /* Fall through.  */
6911         case CODE_32BIT:
6912           if (!i.tm.opcode_modifier.no_lsuf)
6913             i.suffix = LONG_MNEM_SUFFIX;
6914           break;
6915         case CODE_16BIT:
6916           if (!i.tm.opcode_modifier.no_wsuf)
6917             i.suffix = WORD_MNEM_SUFFIX;
6918           break;
6919         }
6920     }
6921
6922   if (!i.suffix
6923       && (i.tm.opcode_modifier.mnemonicsize != DEFAULTSIZE
6924           /* Also cover lret/retf/iret in 64-bit mode.  */
6925           || (flag_code == CODE_64BIT
6926               && !i.tm.opcode_modifier.no_lsuf
6927               && !i.tm.opcode_modifier.no_qsuf))
6928       && i.tm.opcode_modifier.mnemonicsize != IGNORESIZE
6929       /* Explicit sizing prefixes are assumed to disambiguate insns.  */
6930       && !i.prefix[DATA_PREFIX] && !(i.prefix[REX_PREFIX] & REX_W)
6931       /* Accept FLDENV et al without suffix.  */
6932       && (i.tm.opcode_modifier.no_ssuf || i.tm.opcode_modifier.floatmf))
6933     {
6934       unsigned int suffixes, evex = 0;
6935
6936       suffixes = !i.tm.opcode_modifier.no_bsuf;
6937       if (!i.tm.opcode_modifier.no_wsuf)
6938         suffixes |= 1 << 1;
6939       if (!i.tm.opcode_modifier.no_lsuf)
6940         suffixes |= 1 << 2;
6941       if (!i.tm.opcode_modifier.no_ldsuf)
6942         suffixes |= 1 << 3;
6943       if (!i.tm.opcode_modifier.no_ssuf)
6944         suffixes |= 1 << 4;
6945       if (flag_code == CODE_64BIT && !i.tm.opcode_modifier.no_qsuf)
6946         suffixes |= 1 << 5;
6947
6948       /* For [XYZ]MMWORD operands inspect operand sizes.  While generally
6949          also suitable for AT&T syntax mode, it was requested that this be
6950          restricted to just Intel syntax.  */
6951       if (intel_syntax && is_any_vex_encoding (&i.tm) && !i.broadcast)
6952         {
6953           unsigned int op;
6954
6955           for (op = 0; op < i.tm.operands; ++op)
6956             {
6957               if (is_evex_encoding (&i.tm)
6958                   && !cpu_arch_flags.bitfield.cpuavx512vl)
6959                 {
6960                   if (i.tm.operand_types[op].bitfield.ymmword)
6961                     i.tm.operand_types[op].bitfield.xmmword = 0;
6962                   if (i.tm.operand_types[op].bitfield.zmmword)
6963                     i.tm.operand_types[op].bitfield.ymmword = 0;
6964                   if (!i.tm.opcode_modifier.evex
6965                       || i.tm.opcode_modifier.evex == EVEXDYN)
6966                     i.tm.opcode_modifier.evex = EVEX512;
6967                 }
6968
6969               if (i.tm.operand_types[op].bitfield.xmmword
6970                   + i.tm.operand_types[op].bitfield.ymmword
6971                   + i.tm.operand_types[op].bitfield.zmmword < 2)
6972                 continue;
6973
6974               /* Any properly sized operand disambiguates the insn.  */
6975               if (i.types[op].bitfield.xmmword
6976                   || i.types[op].bitfield.ymmword
6977                   || i.types[op].bitfield.zmmword)
6978                 {
6979                   suffixes &= ~(7 << 6);
6980                   evex = 0;
6981                   break;
6982                 }
6983
6984               if ((i.flags[op] & Operand_Mem)
6985                   && i.tm.operand_types[op].bitfield.unspecified)
6986                 {
6987                   if (i.tm.operand_types[op].bitfield.xmmword)
6988                     suffixes |= 1 << 6;
6989                   if (i.tm.operand_types[op].bitfield.ymmword)
6990                     suffixes |= 1 << 7;
6991                   if (i.tm.operand_types[op].bitfield.zmmword)
6992                     suffixes |= 1 << 8;
6993                   if (is_evex_encoding (&i.tm))
6994                     evex = EVEX512;
6995                 }
6996             }
6997         }
6998
6999       /* Are multiple suffixes / operand sizes allowed?  */
7000       if (suffixes & (suffixes - 1))
7001         {
7002           if (intel_syntax
7003               && (i.tm.opcode_modifier.mnemonicsize != DEFAULTSIZE
7004                   || operand_check == check_error))
7005             {
7006               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
7007               return 0;
7008             }
7009           if (operand_check == check_error)
7010             {
7011               as_bad (_("no instruction mnemonic suffix given and "
7012                         "no register operands; can't size `%s'"), i.tm.name);
7013               return 0;
7014             }
7015           if (operand_check == check_warning)
7016             as_warn (_("%s; using default for `%s'"),
7017                        intel_syntax
7018                        ? _("ambiguous operand size")
7019                        : _("no instruction mnemonic suffix given and "
7020                            "no register operands"),
7021                        i.tm.name);
7022
7023           if (i.tm.opcode_modifier.floatmf)
7024             i.suffix = SHORT_MNEM_SUFFIX;
7025           else if ((i.tm.base_opcode | 8) == 0xfbe
7026                    || (i.tm.base_opcode == 0x63
7027                        && i.tm.cpu_flags.bitfield.cpu64))
7028             /* handled below */;
7029           else if (evex)
7030             i.tm.opcode_modifier.evex = evex;
7031           else if (flag_code == CODE_16BIT)
7032             i.suffix = WORD_MNEM_SUFFIX;
7033           else if (!i.tm.opcode_modifier.no_lsuf)
7034             i.suffix = LONG_MNEM_SUFFIX;
7035           else
7036             i.suffix = QWORD_MNEM_SUFFIX;
7037         }
7038     }
7039
7040   if ((i.tm.base_opcode | 8) == 0xfbe
7041       || (i.tm.base_opcode == 0x63 && i.tm.cpu_flags.bitfield.cpu64))
7042     {
7043       /* In Intel syntax, movsx/movzx must have a "suffix" (checked above).
7044          In AT&T syntax, if there is no suffix (warned about above), the default
7045          will be byte extension.  */
7046       if (i.tm.opcode_modifier.w && i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
7047         i.tm.base_opcode |= 1;
7048
7049       /* For further processing, the suffix should represent the destination
7050          (register).  This is already the case when one was used with
7051          mov[sz][bw]*, but we need to replace it for mov[sz]x, or if there was
7052          no suffix to begin with.  */
7053       if (i.tm.opcode_modifier.w || i.tm.base_opcode == 0x63 || !i.suffix)
7054         {
7055           if (i.types[1].bitfield.word)
7056             i.suffix = WORD_MNEM_SUFFIX;
7057           else if (i.types[1].bitfield.qword)
7058             i.suffix = QWORD_MNEM_SUFFIX;
7059           else
7060             i.suffix = LONG_MNEM_SUFFIX;
7061
7062           i.tm.opcode_modifier.w = 0;
7063         }
7064     }
7065
7066   if (!i.tm.opcode_modifier.modrm && i.reg_operands && i.tm.operands < 3)
7067     i.short_form = (i.tm.operand_types[0].bitfield.class == Reg)
7068                    != (i.tm.operand_types[1].bitfield.class == Reg);
7069
7070   /* Change the opcode based on the operand size given by i.suffix.  */
7071   switch (i.suffix)
7072     {
7073     /* Size floating point instruction.  */
7074     case LONG_MNEM_SUFFIX:
7075       if (i.tm.opcode_modifier.floatmf)
7076         {
7077           i.tm.base_opcode ^= 4;
7078           break;
7079         }
7080     /* fall through */
7081     case WORD_MNEM_SUFFIX:
7082     case QWORD_MNEM_SUFFIX:
7083       /* It's not a byte, select word/dword operation.  */
7084       if (i.tm.opcode_modifier.w)
7085         {
7086           if (i.short_form)
7087             i.tm.base_opcode |= 8;
7088           else
7089             i.tm.base_opcode |= 1;
7090         }
7091     /* fall through */
7092     case SHORT_MNEM_SUFFIX:
7093       /* Now select between word & dword operations via the operand
7094          size prefix, except for instructions that will ignore this
7095          prefix anyway.  */
7096       if (i.suffix != QWORD_MNEM_SUFFIX
7097           && i.tm.opcode_modifier.mnemonicsize != IGNORESIZE
7098           && !i.tm.opcode_modifier.floatmf
7099           && !is_any_vex_encoding (&i.tm)
7100           && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
7101               || (flag_code == CODE_64BIT
7102                   && i.tm.opcode_modifier.jump == JUMP_BYTE)))
7103         {
7104           unsigned int prefix = DATA_PREFIX_OPCODE;
7105
7106           if (i.tm.opcode_modifier.jump == JUMP_BYTE) /* jcxz, loop */
7107             prefix = ADDR_PREFIX_OPCODE;
7108
7109           if (!add_prefix (prefix))
7110             return 0;
7111         }
7112
7113       /* Set mode64 for an operand.  */
7114       if (i.suffix == QWORD_MNEM_SUFFIX
7115           && flag_code == CODE_64BIT
7116           && !i.tm.opcode_modifier.norex64
7117           && !i.tm.opcode_modifier.vexw
7118           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
7119              need rex64. */
7120           && ! (i.operands == 2
7121                 && i.tm.base_opcode == 0x90
7122                 && i.tm.extension_opcode == None
7123                 && i.types[0].bitfield.instance == Accum
7124                 && i.types[0].bitfield.qword
7125                 && i.types[1].bitfield.instance == Accum
7126                 && i.types[1].bitfield.qword))
7127         i.rex |= REX_W;
7128
7129       break;
7130
7131     case 0:
7132       /* Select word/dword/qword operation with explict data sizing prefix
7133          when there are no suitable register operands.  */
7134       if (i.tm.opcode_modifier.w
7135           && (i.prefix[DATA_PREFIX] || (i.prefix[REX_PREFIX] & REX_W))
7136           && (!i.reg_operands
7137               || (i.reg_operands == 1
7138                       /* ShiftCount */
7139                   && (i.tm.operand_types[0].bitfield.instance == RegC
7140                       /* InOutPortReg */
7141                       || i.tm.operand_types[0].bitfield.instance == RegD
7142                       || i.tm.operand_types[1].bitfield.instance == RegD
7143                       /* CRC32 */
7144                       || i.tm.base_opcode == 0xf20f38f0))))
7145         i.tm.base_opcode |= 1;
7146       break;
7147     }
7148
7149   if (i.tm.opcode_modifier.addrprefixopreg)
7150     {
7151       gas_assert (!i.suffix);
7152       gas_assert (i.reg_operands);
7153
7154       if (i.tm.operand_types[0].bitfield.instance == Accum
7155           || i.operands == 1)
7156         {
7157           /* The address size override prefix changes the size of the
7158              first operand.  */
7159           if (flag_code == CODE_64BIT
7160               && i.op[0].regs->reg_type.bitfield.word)
7161             {
7162               as_bad (_("16-bit addressing unavailable for `%s'"),
7163                       i.tm.name);
7164               return 0;
7165             }
7166
7167           if ((flag_code == CODE_32BIT
7168                ? i.op[0].regs->reg_type.bitfield.word
7169                : i.op[0].regs->reg_type.bitfield.dword)
7170               && !add_prefix (ADDR_PREFIX_OPCODE))
7171             return 0;
7172         }
7173       else
7174         {
7175           /* Check invalid register operand when the address size override
7176              prefix changes the size of register operands.  */
7177           unsigned int op;
7178           enum { need_word, need_dword, need_qword } need;
7179
7180           if (flag_code == CODE_32BIT)
7181             need = i.prefix[ADDR_PREFIX] ? need_word : need_dword;
7182           else if (i.prefix[ADDR_PREFIX])
7183             need = need_dword;
7184           else
7185             need = flag_code == CODE_64BIT ? need_qword : need_word;
7186
7187           for (op = 0; op < i.operands; op++)
7188             {
7189               if (i.types[op].bitfield.class != Reg)
7190                 continue;
7191
7192               switch (need)
7193                 {
7194                 case need_word:
7195                   if (i.op[op].regs->reg_type.bitfield.word)
7196                     continue;
7197                   break;
7198                 case need_dword:
7199                   if (i.op[op].regs->reg_type.bitfield.dword)
7200                     continue;
7201                   break;
7202                 case need_qword:
7203                   if (i.op[op].regs->reg_type.bitfield.qword)
7204                     continue;
7205                   break;
7206                 }
7207
7208               as_bad (_("invalid register operand size for `%s'"),
7209                       i.tm.name);
7210               return 0;
7211             }
7212         }
7213     }
7214
7215   return 1;
7216 }
7217
7218 static int
7219 check_byte_reg (void)
7220 {
7221   int op;
7222
7223   for (op = i.operands; --op >= 0;)
7224     {
7225       /* Skip non-register operands. */
7226       if (i.types[op].bitfield.class != Reg)
7227         continue;
7228
7229       /* If this is an eight bit register, it's OK.  If it's the 16 or
7230          32 bit version of an eight bit register, we will just use the
7231          low portion, and that's OK too.  */
7232       if (i.types[op].bitfield.byte)
7233         continue;
7234
7235       /* I/O port address operands are OK too.  */
7236       if (i.tm.operand_types[op].bitfield.instance == RegD
7237           && i.tm.operand_types[op].bitfield.word)
7238         continue;
7239
7240       /* crc32 only wants its source operand checked here.  */
7241       if (i.tm.base_opcode == 0xf20f38f0 && op)
7242         continue;
7243
7244       /* Any other register is bad.  */
7245       as_bad (_("`%s%s' not allowed with `%s%c'"),
7246               register_prefix, i.op[op].regs->reg_name,
7247               i.tm.name, i.suffix);
7248       return 0;
7249     }
7250   return 1;
7251 }
7252
7253 static int
7254 check_long_reg (void)
7255 {
7256   int op;
7257
7258   for (op = i.operands; --op >= 0;)
7259     /* Skip non-register operands. */
7260     if (i.types[op].bitfield.class != Reg)
7261       continue;
7262     /* Reject eight bit registers, except where the template requires
7263        them. (eg. movzb)  */
7264     else if (i.types[op].bitfield.byte
7265              && (i.tm.operand_types[op].bitfield.class == Reg
7266                  || i.tm.operand_types[op].bitfield.instance == Accum)
7267              && (i.tm.operand_types[op].bitfield.word
7268                  || i.tm.operand_types[op].bitfield.dword))
7269       {
7270         as_bad (_("`%s%s' not allowed with `%s%c'"),
7271                 register_prefix,
7272                 i.op[op].regs->reg_name,
7273                 i.tm.name,
7274                 i.suffix);
7275         return 0;
7276       }
7277     /* Error if the e prefix on a general reg is missing.  */
7278     else if (i.types[op].bitfield.word
7279              && (i.tm.operand_types[op].bitfield.class == Reg
7280                  || i.tm.operand_types[op].bitfield.instance == Accum)
7281              && i.tm.operand_types[op].bitfield.dword)
7282       {
7283         as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7284                 register_prefix, i.op[op].regs->reg_name,
7285                 i.suffix);
7286         return 0;
7287       }
7288     /* Warn if the r prefix on a general reg is present.  */
7289     else if (i.types[op].bitfield.qword
7290              && (i.tm.operand_types[op].bitfield.class == Reg
7291                  || i.tm.operand_types[op].bitfield.instance == Accum)
7292              && i.tm.operand_types[op].bitfield.dword)
7293       {
7294         if (intel_syntax
7295             && i.tm.opcode_modifier.toqword
7296             && i.types[0].bitfield.class != RegSIMD)
7297           {
7298             /* Convert to QWORD.  We want REX byte. */
7299             i.suffix = QWORD_MNEM_SUFFIX;
7300           }
7301         else
7302           {
7303             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7304                     register_prefix, i.op[op].regs->reg_name,
7305                     i.suffix);
7306             return 0;
7307           }
7308       }
7309   return 1;
7310 }
7311
7312 static int
7313 check_qword_reg (void)
7314 {
7315   int op;
7316
7317   for (op = i.operands; --op >= 0; )
7318     /* Skip non-register operands. */
7319     if (i.types[op].bitfield.class != Reg)
7320       continue;
7321     /* Reject eight bit registers, except where the template requires
7322        them. (eg. movzb)  */
7323     else if (i.types[op].bitfield.byte
7324              && (i.tm.operand_types[op].bitfield.class == Reg
7325                  || i.tm.operand_types[op].bitfield.instance == Accum)
7326              && (i.tm.operand_types[op].bitfield.word
7327                  || i.tm.operand_types[op].bitfield.dword))
7328       {
7329         as_bad (_("`%s%s' not allowed with `%s%c'"),
7330                 register_prefix,
7331                 i.op[op].regs->reg_name,
7332                 i.tm.name,
7333                 i.suffix);
7334         return 0;
7335       }
7336     /* Warn if the r prefix on a general reg is missing.  */
7337     else if ((i.types[op].bitfield.word
7338               || i.types[op].bitfield.dword)
7339              && (i.tm.operand_types[op].bitfield.class == Reg
7340                  || i.tm.operand_types[op].bitfield.instance == Accum)
7341              && i.tm.operand_types[op].bitfield.qword)
7342       {
7343         /* Prohibit these changes in the 64bit mode, since the
7344            lowering is more complicated.  */
7345         if (intel_syntax
7346             && i.tm.opcode_modifier.todword
7347             && i.types[0].bitfield.class != RegSIMD)
7348           {
7349             /* Convert to DWORD.  We don't want REX byte. */
7350             i.suffix = LONG_MNEM_SUFFIX;
7351           }
7352         else
7353           {
7354             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7355                     register_prefix, i.op[op].regs->reg_name,
7356                     i.suffix);
7357             return 0;
7358           }
7359       }
7360   return 1;
7361 }
7362
7363 static int
7364 check_word_reg (void)
7365 {
7366   int op;
7367   for (op = i.operands; --op >= 0;)
7368     /* Skip non-register operands. */
7369     if (i.types[op].bitfield.class != Reg)
7370       continue;
7371     /* Reject eight bit registers, except where the template requires
7372        them. (eg. movzb)  */
7373     else if (i.types[op].bitfield.byte
7374              && (i.tm.operand_types[op].bitfield.class == Reg
7375                  || i.tm.operand_types[op].bitfield.instance == Accum)
7376              && (i.tm.operand_types[op].bitfield.word
7377                  || i.tm.operand_types[op].bitfield.dword))
7378       {
7379         as_bad (_("`%s%s' not allowed with `%s%c'"),
7380                 register_prefix,
7381                 i.op[op].regs->reg_name,
7382                 i.tm.name,
7383                 i.suffix);
7384         return 0;
7385       }
7386     /* Error if the e or r prefix on a general reg is present.  */
7387     else if ((i.types[op].bitfield.dword
7388                  || i.types[op].bitfield.qword)
7389              && (i.tm.operand_types[op].bitfield.class == Reg
7390                  || i.tm.operand_types[op].bitfield.instance == Accum)
7391              && i.tm.operand_types[op].bitfield.word)
7392       {
7393         as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7394                 register_prefix, i.op[op].regs->reg_name,
7395                 i.suffix);
7396         return 0;
7397       }
7398   return 1;
7399 }
7400
7401 static int
7402 update_imm (unsigned int j)
7403 {
7404   i386_operand_type overlap = i.types[j];
7405   if ((overlap.bitfield.imm8
7406        || overlap.bitfield.imm8s
7407        || overlap.bitfield.imm16
7408        || overlap.bitfield.imm32
7409        || overlap.bitfield.imm32s
7410        || overlap.bitfield.imm64)
7411       && !operand_type_equal (&overlap, &imm8)
7412       && !operand_type_equal (&overlap, &imm8s)
7413       && !operand_type_equal (&overlap, &imm16)
7414       && !operand_type_equal (&overlap, &imm32)
7415       && !operand_type_equal (&overlap, &imm32s)
7416       && !operand_type_equal (&overlap, &imm64))
7417     {
7418       if (i.suffix)
7419         {
7420           i386_operand_type temp;
7421
7422           operand_type_set (&temp, 0);
7423           if (i.suffix == BYTE_MNEM_SUFFIX)
7424             {
7425               temp.bitfield.imm8 = overlap.bitfield.imm8;
7426               temp.bitfield.imm8s = overlap.bitfield.imm8s;
7427             }
7428           else if (i.suffix == WORD_MNEM_SUFFIX)
7429             temp.bitfield.imm16 = overlap.bitfield.imm16;
7430           else if (i.suffix == QWORD_MNEM_SUFFIX)
7431             {
7432               temp.bitfield.imm64 = overlap.bitfield.imm64;
7433               temp.bitfield.imm32s = overlap.bitfield.imm32s;
7434             }
7435           else
7436             temp.bitfield.imm32 = overlap.bitfield.imm32;
7437           overlap = temp;
7438         }
7439       else if (operand_type_equal (&overlap, &imm16_32_32s)
7440                || operand_type_equal (&overlap, &imm16_32)
7441                || operand_type_equal (&overlap, &imm16_32s))
7442         {
7443           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
7444             overlap = imm16;
7445           else
7446             overlap = imm32s;
7447         }
7448       else if (i.prefix[REX_PREFIX] & REX_W)
7449         overlap = operand_type_and (overlap, imm32s);
7450       else if (i.prefix[DATA_PREFIX])
7451         overlap = operand_type_and (overlap,
7452                                     flag_code != CODE_16BIT ? imm16 : imm32);
7453       if (!operand_type_equal (&overlap, &imm8)
7454           && !operand_type_equal (&overlap, &imm8s)
7455           && !operand_type_equal (&overlap, &imm16)
7456           && !operand_type_equal (&overlap, &imm32)
7457           && !operand_type_equal (&overlap, &imm32s)
7458           && !operand_type_equal (&overlap, &imm64))
7459         {
7460           as_bad (_("no instruction mnemonic suffix given; "
7461                     "can't determine immediate size"));
7462           return 0;
7463         }
7464     }
7465   i.types[j] = overlap;
7466
7467   return 1;
7468 }
7469
7470 static int
7471 finalize_imm (void)
7472 {
7473   unsigned int j, n;
7474
7475   /* Update the first 2 immediate operands.  */
7476   n = i.operands > 2 ? 2 : i.operands;
7477   if (n)
7478     {
7479       for (j = 0; j < n; j++)
7480         if (update_imm (j) == 0)
7481           return 0;
7482
7483       /* The 3rd operand can't be immediate operand.  */
7484       gas_assert (operand_type_check (i.types[2], imm) == 0);
7485     }
7486
7487   return 1;
7488 }
7489
7490 static int
7491 process_operands (void)
7492 {
7493   /* Default segment register this instruction will use for memory
7494      accesses.  0 means unknown.  This is only for optimizing out
7495      unnecessary segment overrides.  */
7496   const seg_entry *default_seg = 0;
7497
7498   if (i.tm.opcode_modifier.sse2avx)
7499     {
7500       /* Legacy encoded insns allow explicit REX prefixes, so these prefixes
7501          need converting.  */
7502       i.rex |= i.prefix[REX_PREFIX] & (REX_W | REX_R | REX_X | REX_B);
7503       i.prefix[REX_PREFIX] = 0;
7504       i.rex_encoding = 0;
7505     }
7506   /* ImmExt should be processed after SSE2AVX.  */
7507   else if (i.tm.opcode_modifier.immext)
7508     process_immext ();
7509
7510   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
7511     {
7512       unsigned int dupl = i.operands;
7513       unsigned int dest = dupl - 1;
7514       unsigned int j;
7515
7516       /* The destination must be an xmm register.  */
7517       gas_assert (i.reg_operands
7518                   && MAX_OPERANDS > dupl
7519                   && operand_type_equal (&i.types[dest], &regxmm));
7520
7521       if (i.tm.operand_types[0].bitfield.instance == Accum
7522           && i.tm.operand_types[0].bitfield.xmmword)
7523         {
7524           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
7525             {
7526               /* Keep xmm0 for instructions with VEX prefix and 3
7527                  sources.  */
7528               i.tm.operand_types[0].bitfield.instance = InstanceNone;
7529               i.tm.operand_types[0].bitfield.class = RegSIMD;
7530               goto duplicate;
7531             }
7532           else
7533             {
7534               /* We remove the first xmm0 and keep the number of
7535                  operands unchanged, which in fact duplicates the
7536                  destination.  */
7537               for (j = 1; j < i.operands; j++)
7538                 {
7539                   i.op[j - 1] = i.op[j];
7540                   i.types[j - 1] = i.types[j];
7541                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
7542                   i.flags[j - 1] = i.flags[j];
7543                 }
7544             }
7545         }
7546       else if (i.tm.opcode_modifier.implicit1stxmm0)
7547         {
7548           gas_assert ((MAX_OPERANDS - 1) > dupl
7549                       && (i.tm.opcode_modifier.vexsources
7550                           == VEX3SOURCES));
7551
7552           /* Add the implicit xmm0 for instructions with VEX prefix
7553              and 3 sources.  */
7554           for (j = i.operands; j > 0; j--)
7555             {
7556               i.op[j] = i.op[j - 1];
7557               i.types[j] = i.types[j - 1];
7558               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
7559               i.flags[j] = i.flags[j - 1];
7560             }
7561           i.op[0].regs
7562             = (const reg_entry *) hash_find (reg_hash, "xmm0");
7563           i.types[0] = regxmm;
7564           i.tm.operand_types[0] = regxmm;
7565
7566           i.operands += 2;
7567           i.reg_operands += 2;
7568           i.tm.operands += 2;
7569
7570           dupl++;
7571           dest++;
7572           i.op[dupl] = i.op[dest];
7573           i.types[dupl] = i.types[dest];
7574           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
7575           i.flags[dupl] = i.flags[dest];
7576         }
7577       else
7578         {
7579         duplicate:
7580           i.operands++;
7581           i.reg_operands++;
7582           i.tm.operands++;
7583
7584           i.op[dupl] = i.op[dest];
7585           i.types[dupl] = i.types[dest];
7586           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
7587           i.flags[dupl] = i.flags[dest];
7588         }
7589
7590        if (i.tm.opcode_modifier.immext)
7591          process_immext ();
7592     }
7593   else if (i.tm.operand_types[0].bitfield.instance == Accum
7594            && i.tm.operand_types[0].bitfield.xmmword)
7595     {
7596       unsigned int j;
7597
7598       for (j = 1; j < i.operands; j++)
7599         {
7600           i.op[j - 1] = i.op[j];
7601           i.types[j - 1] = i.types[j];
7602
7603           /* We need to adjust fields in i.tm since they are used by
7604              build_modrm_byte.  */
7605           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
7606
7607           i.flags[j - 1] = i.flags[j];
7608         }
7609
7610       i.operands--;
7611       i.reg_operands--;
7612       i.tm.operands--;
7613     }
7614   else if (i.tm.opcode_modifier.implicitquadgroup)
7615     {
7616       unsigned int regnum, first_reg_in_group, last_reg_in_group;
7617
7618       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
7619       gas_assert (i.operands >= 2 && i.types[1].bitfield.class == RegSIMD);
7620       regnum = register_number (i.op[1].regs);
7621       first_reg_in_group = regnum & ~3;
7622       last_reg_in_group = first_reg_in_group + 3;
7623       if (regnum != first_reg_in_group)
7624         as_warn (_("source register `%s%s' implicitly denotes"
7625                    " `%s%.3s%u' to `%s%.3s%u' source group in `%s'"),
7626                  register_prefix, i.op[1].regs->reg_name,
7627                  register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
7628                  register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
7629                  i.tm.name);
7630     }
7631   else if (i.tm.opcode_modifier.regkludge)
7632     {
7633       /* The imul $imm, %reg instruction is converted into
7634          imul $imm, %reg, %reg, and the clr %reg instruction
7635          is converted into xor %reg, %reg.  */
7636
7637       unsigned int first_reg_op;
7638
7639       if (operand_type_check (i.types[0], reg))
7640         first_reg_op = 0;
7641       else
7642         first_reg_op = 1;
7643       /* Pretend we saw the extra register operand.  */
7644       gas_assert (i.reg_operands == 1
7645                   && i.op[first_reg_op + 1].regs == 0);
7646       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
7647       i.types[first_reg_op + 1] = i.types[first_reg_op];
7648       i.operands++;
7649       i.reg_operands++;
7650     }
7651
7652   if (i.tm.opcode_modifier.modrm)
7653     {
7654       /* The opcode is completed (modulo i.tm.extension_opcode which
7655          must be put into the modrm byte).  Now, we make the modrm and
7656          index base bytes based on all the info we've collected.  */
7657
7658       default_seg = build_modrm_byte ();
7659     }
7660   else if (i.types[0].bitfield.class == SReg)
7661     {
7662       if (flag_code != CODE_64BIT
7663           ? i.tm.base_opcode == POP_SEG_SHORT
7664             && i.op[0].regs->reg_num == 1
7665           : (i.tm.base_opcode | 1) == POP_SEG386_SHORT
7666             && i.op[0].regs->reg_num < 4)
7667         {
7668           as_bad (_("you can't `%s %s%s'"),
7669                   i.tm.name, register_prefix, i.op[0].regs->reg_name);
7670           return 0;
7671         }
7672       if ( i.op[0].regs->reg_num > 3 && i.tm.opcode_length == 1 )
7673         {
7674           i.tm.base_opcode ^= POP_SEG_SHORT ^ POP_SEG386_SHORT;
7675           i.tm.opcode_length = 2;
7676         }
7677       i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
7678     }
7679   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
7680     {
7681       default_seg = &ds;
7682     }
7683   else if (i.tm.opcode_modifier.isstring)
7684     {
7685       /* For the string instructions that allow a segment override
7686          on one of their operands, the default segment is ds.  */
7687       default_seg = &ds;
7688     }
7689   else if (i.short_form)
7690     {
7691       /* The register or float register operand is in operand
7692          0 or 1.  */
7693       unsigned int op = i.tm.operand_types[0].bitfield.class != Reg;
7694
7695       /* Register goes in low 3 bits of opcode.  */
7696       i.tm.base_opcode |= i.op[op].regs->reg_num;
7697       if ((i.op[op].regs->reg_flags & RegRex) != 0)
7698         i.rex |= REX_B;
7699       if (!quiet_warnings && i.tm.opcode_modifier.ugh)
7700         {
7701           /* Warn about some common errors, but press on regardless.
7702              The first case can be generated by gcc (<= 2.8.1).  */
7703           if (i.operands == 2)
7704             {
7705               /* Reversed arguments on faddp, fsubp, etc.  */
7706               as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
7707                        register_prefix, i.op[!intel_syntax].regs->reg_name,
7708                        register_prefix, i.op[intel_syntax].regs->reg_name);
7709             }
7710           else
7711             {
7712               /* Extraneous `l' suffix on fp insn.  */
7713               as_warn (_("translating to `%s %s%s'"), i.tm.name,
7714                        register_prefix, i.op[0].regs->reg_name);
7715             }
7716         }
7717     }
7718
7719   if ((i.seg[0] || i.prefix[SEG_PREFIX])
7720       && i.tm.base_opcode == 0x8d /* lea */
7721       && !is_any_vex_encoding(&i.tm))
7722     {
7723       if (!quiet_warnings)
7724         as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
7725       if (optimize)
7726         {
7727           i.seg[0] = NULL;
7728           i.prefix[SEG_PREFIX] = 0;
7729         }
7730     }
7731
7732   /* If a segment was explicitly specified, and the specified segment
7733      is neither the default nor the one already recorded from a prefix,
7734      use an opcode prefix to select it.  If we never figured out what
7735      the default segment is, then default_seg will be zero at this
7736      point, and the specified segment prefix will always be used.  */
7737   if (i.seg[0]
7738       && i.seg[0] != default_seg
7739       && i.seg[0]->seg_prefix != i.prefix[SEG_PREFIX])
7740     {
7741       if (!add_prefix (i.seg[0]->seg_prefix))
7742         return 0;
7743     }
7744   return 1;
7745 }
7746
7747 static INLINE void set_rex_vrex (const reg_entry *r, unsigned int rex_bit,
7748                                  bfd_boolean do_sse2avx)
7749 {
7750   if (r->reg_flags & RegRex)
7751     {
7752       if (i.rex & rex_bit)
7753         as_bad (_("same type of prefix used twice"));
7754       i.rex |= rex_bit;
7755     }
7756   else if (do_sse2avx && (i.rex & rex_bit) && i.vex.register_specifier)
7757     {
7758       gas_assert (i.vex.register_specifier == r);
7759       i.vex.register_specifier += 8;
7760     }
7761
7762   if (r->reg_flags & RegVRex)
7763     i.vrex |= rex_bit;
7764 }
7765
7766 static const seg_entry *
7767 build_modrm_byte (void)
7768 {
7769   const seg_entry *default_seg = 0;
7770   unsigned int source, dest;
7771   int vex_3_sources;
7772
7773   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
7774   if (vex_3_sources)
7775     {
7776       unsigned int nds, reg_slot;
7777       expressionS *exp;
7778
7779       dest = i.operands - 1;
7780       nds = dest - 1;
7781
7782       /* There are 2 kinds of instructions:
7783          1. 5 operands: 4 register operands or 3 register operands
7784          plus 1 memory operand plus one Imm4 operand, VexXDS, and
7785          VexW0 or VexW1.  The destination must be either XMM, YMM or
7786          ZMM register.
7787          2. 4 operands: 4 register operands or 3 register operands
7788          plus 1 memory operand, with VexXDS.  */
7789       gas_assert ((i.reg_operands == 4
7790                    || (i.reg_operands == 3 && i.mem_operands == 1))
7791                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
7792                   && i.tm.opcode_modifier.vexw
7793                   && i.tm.operand_types[dest].bitfield.class == RegSIMD);
7794
7795       /* If VexW1 is set, the first non-immediate operand is the source and
7796          the second non-immediate one is encoded in the immediate operand.  */
7797       if (i.tm.opcode_modifier.vexw == VEXW1)
7798         {
7799           source = i.imm_operands;
7800           reg_slot = i.imm_operands + 1;
7801         }
7802       else
7803         {
7804           source = i.imm_operands + 1;
7805           reg_slot = i.imm_operands;
7806         }
7807
7808       if (i.imm_operands == 0)
7809         {
7810           /* When there is no immediate operand, generate an 8bit
7811              immediate operand to encode the first operand.  */
7812           exp = &im_expressions[i.imm_operands++];
7813           i.op[i.operands].imms = exp;
7814           i.types[i.operands] = imm8;
7815           i.operands++;
7816
7817           gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD);
7818           exp->X_op = O_constant;
7819           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
7820           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7821         }
7822       else
7823         {
7824           gas_assert (i.imm_operands == 1);
7825           gas_assert (fits_in_imm4 (i.op[0].imms->X_add_number));
7826           gas_assert (!i.tm.opcode_modifier.immext);
7827
7828           /* Turn on Imm8 again so that output_imm will generate it.  */
7829           i.types[0].bitfield.imm8 = 1;
7830
7831           gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD);
7832           i.op[0].imms->X_add_number
7833               |= register_number (i.op[reg_slot].regs) << 4;
7834           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7835         }
7836
7837       gas_assert (i.tm.operand_types[nds].bitfield.class == RegSIMD);
7838       i.vex.register_specifier = i.op[nds].regs;
7839     }
7840   else
7841     source = dest = 0;
7842
7843   /* i.reg_operands MUST be the number of real register operands;
7844      implicit registers do not count.  If there are 3 register
7845      operands, it must be a instruction with VexNDS.  For a
7846      instruction with VexNDD, the destination register is encoded
7847      in VEX prefix.  If there are 4 register operands, it must be
7848      a instruction with VEX prefix and 3 sources.  */
7849   if (i.mem_operands == 0
7850       && ((i.reg_operands == 2
7851            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
7852           || (i.reg_operands == 3
7853               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
7854           || (i.reg_operands == 4 && vex_3_sources)))
7855     {
7856       switch (i.operands)
7857         {
7858         case 2:
7859           source = 0;
7860           break;
7861         case 3:
7862           /* When there are 3 operands, one of them may be immediate,
7863              which may be the first or the last operand.  Otherwise,
7864              the first operand must be shift count register (cl) or it
7865              is an instruction with VexNDS. */
7866           gas_assert (i.imm_operands == 1
7867                       || (i.imm_operands == 0
7868                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
7869                               || (i.types[0].bitfield.instance == RegC
7870                                   && i.types[0].bitfield.byte))));
7871           if (operand_type_check (i.types[0], imm)
7872               || (i.types[0].bitfield.instance == RegC
7873                   && i.types[0].bitfield.byte))
7874             source = 1;
7875           else
7876             source = 0;
7877           break;
7878         case 4:
7879           /* When there are 4 operands, the first two must be 8bit
7880              immediate operands. The source operand will be the 3rd
7881              one.
7882
7883              For instructions with VexNDS, if the first operand
7884              an imm8, the source operand is the 2nd one.  If the last
7885              operand is imm8, the source operand is the first one.  */
7886           gas_assert ((i.imm_operands == 2
7887                        && i.types[0].bitfield.imm8
7888                        && i.types[1].bitfield.imm8)
7889                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
7890                           && i.imm_operands == 1
7891                           && (i.types[0].bitfield.imm8
7892                               || i.types[i.operands - 1].bitfield.imm8
7893                               || i.rounding)));
7894           if (i.imm_operands == 2)
7895             source = 2;
7896           else
7897             {
7898               if (i.types[0].bitfield.imm8)
7899                 source = 1;
7900               else
7901                 source = 0;
7902             }
7903           break;
7904         case 5:
7905           if (is_evex_encoding (&i.tm))
7906             {
7907               /* For EVEX instructions, when there are 5 operands, the
7908                  first one must be immediate operand.  If the second one
7909                  is immediate operand, the source operand is the 3th
7910                  one.  If the last one is immediate operand, the source
7911                  operand is the 2nd one.  */
7912               gas_assert (i.imm_operands == 2
7913                           && i.tm.opcode_modifier.sae
7914                           && operand_type_check (i.types[0], imm));
7915               if (operand_type_check (i.types[1], imm))
7916                 source = 2;
7917               else if (operand_type_check (i.types[4], imm))
7918                 source = 1;
7919               else
7920                 abort ();
7921             }
7922           break;
7923         default:
7924           abort ();
7925         }
7926
7927       if (!vex_3_sources)
7928         {
7929           dest = source + 1;
7930
7931           /* RC/SAE operand could be between DEST and SRC.  That happens
7932              when one operand is GPR and the other one is XMM/YMM/ZMM
7933              register.  */
7934           if (i.rounding && i.rounding->operand == (int) dest)
7935             dest++;
7936
7937           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7938             {
7939               /* For instructions with VexNDS, the register-only source
7940                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
7941                  register.  It is encoded in VEX prefix.  */
7942
7943               i386_operand_type op;
7944               unsigned int vvvv;
7945
7946               /* Swap two source operands if needed.  */
7947               if (i.tm.opcode_modifier.swapsources)
7948                 {
7949                   vvvv = source;
7950                   source = dest;
7951                 }
7952               else
7953                 vvvv = dest;
7954
7955               op = i.tm.operand_types[vvvv];
7956               if ((dest + 1) >= i.operands
7957                   || ((op.bitfield.class != Reg
7958                        || (!op.bitfield.dword && !op.bitfield.qword))
7959                       && op.bitfield.class != RegSIMD
7960                       && !operand_type_equal (&op, &regmask)))
7961                 abort ();
7962               i.vex.register_specifier = i.op[vvvv].regs;
7963               dest++;
7964             }
7965         }
7966
7967       i.rm.mode = 3;
7968       /* One of the register operands will be encoded in the i.rm.reg
7969          field, the other in the combined i.rm.mode and i.rm.regmem
7970          fields.  If no form of this instruction supports a memory
7971          destination operand, then we assume the source operand may
7972          sometimes be a memory operand and so we need to store the
7973          destination in the i.rm.reg field.  */
7974       if (!i.tm.opcode_modifier.regmem
7975           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
7976         {
7977           i.rm.reg = i.op[dest].regs->reg_num;
7978           i.rm.regmem = i.op[source].regs->reg_num;
7979           set_rex_vrex (i.op[dest].regs, REX_R, i.tm.opcode_modifier.sse2avx);
7980           set_rex_vrex (i.op[source].regs, REX_B, FALSE);
7981         }
7982       else
7983         {
7984           i.rm.reg = i.op[source].regs->reg_num;
7985           i.rm.regmem = i.op[dest].regs->reg_num;
7986           set_rex_vrex (i.op[dest].regs, REX_B, i.tm.opcode_modifier.sse2avx);
7987           set_rex_vrex (i.op[source].regs, REX_R, FALSE);
7988         }
7989       if (flag_code != CODE_64BIT && (i.rex & REX_R))
7990         {
7991           if (i.types[!i.tm.opcode_modifier.regmem].bitfield.class != RegCR)
7992             abort ();
7993           i.rex &= ~REX_R;
7994           add_prefix (LOCK_PREFIX_OPCODE);
7995         }
7996     }
7997   else
7998     {                   /* If it's not 2 reg operands...  */
7999       unsigned int mem;
8000
8001       if (i.mem_operands)
8002         {
8003           unsigned int fake_zero_displacement = 0;
8004           unsigned int op;
8005
8006           for (op = 0; op < i.operands; op++)
8007             if (i.flags[op] & Operand_Mem)
8008               break;
8009           gas_assert (op < i.operands);
8010
8011           if (i.tm.opcode_modifier.sib)
8012             {
8013               /* The index register of VSIB shouldn't be RegIZ.  */
8014               if (i.tm.opcode_modifier.sib != SIBMEM
8015                   && i.index_reg->reg_num == RegIZ)
8016                 abort ();
8017
8018               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8019               if (!i.base_reg)
8020                 {
8021                   i.sib.base = NO_BASE_REGISTER;
8022                   i.sib.scale = i.log2_scale_factor;
8023                   i.types[op].bitfield.disp8 = 0;
8024                   i.types[op].bitfield.disp16 = 0;
8025                   i.types[op].bitfield.disp64 = 0;
8026                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
8027                     {
8028                       /* Must be 32 bit */
8029                       i.types[op].bitfield.disp32 = 1;
8030                       i.types[op].bitfield.disp32s = 0;
8031                     }
8032                   else
8033                     {
8034                       i.types[op].bitfield.disp32 = 0;
8035                       i.types[op].bitfield.disp32s = 1;
8036                     }
8037                 }
8038
8039               /* Since the mandatory SIB always has index register, so
8040                  the code logic remains unchanged. The non-mandatory SIB
8041                  without index register is allowed and will be handled
8042                  later.  */
8043               if (i.index_reg)
8044                 {
8045                   if (i.index_reg->reg_num == RegIZ)
8046                     i.sib.index = NO_INDEX_REGISTER;
8047                   else
8048                     i.sib.index = i.index_reg->reg_num;
8049                   set_rex_vrex (i.index_reg, REX_X, FALSE);
8050                 }
8051             }
8052
8053           default_seg = &ds;
8054
8055           if (i.base_reg == 0)
8056             {
8057               i.rm.mode = 0;
8058               if (!i.disp_operands)
8059                 fake_zero_displacement = 1;
8060               if (i.index_reg == 0)
8061                 {
8062                   i386_operand_type newdisp;
8063
8064                   /* Both check for VSIB and mandatory non-vector SIB. */
8065                   gas_assert (!i.tm.opcode_modifier.sib
8066                               || i.tm.opcode_modifier.sib == SIBMEM);
8067                   /* Operand is just <disp>  */
8068                   if (flag_code == CODE_64BIT)
8069                     {
8070                       /* 64bit mode overwrites the 32bit absolute
8071                          addressing by RIP relative addressing and
8072                          absolute addressing is encoded by one of the
8073                          redundant SIB forms.  */
8074                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8075                       i.sib.base = NO_BASE_REGISTER;
8076                       i.sib.index = NO_INDEX_REGISTER;
8077                       newdisp = (!i.prefix[ADDR_PREFIX] ? disp32s : disp32);
8078                     }
8079                   else if ((flag_code == CODE_16BIT)
8080                            ^ (i.prefix[ADDR_PREFIX] != 0))
8081                     {
8082                       i.rm.regmem = NO_BASE_REGISTER_16;
8083                       newdisp = disp16;
8084                     }
8085                   else
8086                     {
8087                       i.rm.regmem = NO_BASE_REGISTER;
8088                       newdisp = disp32;
8089                     }
8090                   i.types[op] = operand_type_and_not (i.types[op], anydisp);
8091                   i.types[op] = operand_type_or (i.types[op], newdisp);
8092                 }
8093               else if (!i.tm.opcode_modifier.sib)
8094                 {
8095                   /* !i.base_reg && i.index_reg  */
8096                   if (i.index_reg->reg_num == RegIZ)
8097                     i.sib.index = NO_INDEX_REGISTER;
8098                   else
8099                     i.sib.index = i.index_reg->reg_num;
8100                   i.sib.base = NO_BASE_REGISTER;
8101                   i.sib.scale = i.log2_scale_factor;
8102                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8103                   i.types[op].bitfield.disp8 = 0;
8104                   i.types[op].bitfield.disp16 = 0;
8105                   i.types[op].bitfield.disp64 = 0;
8106                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
8107                     {
8108                       /* Must be 32 bit */
8109                       i.types[op].bitfield.disp32 = 1;
8110                       i.types[op].bitfield.disp32s = 0;
8111                     }
8112                   else
8113                     {
8114                       i.types[op].bitfield.disp32 = 0;
8115                       i.types[op].bitfield.disp32s = 1;
8116                     }
8117                   if ((i.index_reg->reg_flags & RegRex) != 0)
8118                     i.rex |= REX_X;
8119                 }
8120             }
8121           /* RIP addressing for 64bit mode.  */
8122           else if (i.base_reg->reg_num == RegIP)
8123             {
8124               gas_assert (!i.tm.opcode_modifier.sib);
8125               i.rm.regmem = NO_BASE_REGISTER;
8126               i.types[op].bitfield.disp8 = 0;
8127               i.types[op].bitfield.disp16 = 0;
8128               i.types[op].bitfield.disp32 = 0;
8129               i.types[op].bitfield.disp32s = 1;
8130               i.types[op].bitfield.disp64 = 0;
8131               i.flags[op] |= Operand_PCrel;
8132               if (! i.disp_operands)
8133                 fake_zero_displacement = 1;
8134             }
8135           else if (i.base_reg->reg_type.bitfield.word)
8136             {
8137               gas_assert (!i.tm.opcode_modifier.sib);
8138               switch (i.base_reg->reg_num)
8139                 {
8140                 case 3: /* (%bx)  */
8141                   if (i.index_reg == 0)
8142                     i.rm.regmem = 7;
8143                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
8144                     i.rm.regmem = i.index_reg->reg_num - 6;
8145                   break;
8146                 case 5: /* (%bp)  */
8147                   default_seg = &ss;
8148                   if (i.index_reg == 0)
8149                     {
8150                       i.rm.regmem = 6;
8151                       if (operand_type_check (i.types[op], disp) == 0)
8152                         {
8153                           /* fake (%bp) into 0(%bp)  */
8154                           if (i.disp_encoding == disp_encoding_32bit)
8155                             /* NB: Use disp16 since there is no disp32
8156                                in 16-bit mode.  */
8157                             i.types[op].bitfield.disp16 = 1;
8158                           else
8159                             i.types[op].bitfield.disp8 = 1;
8160                           fake_zero_displacement = 1;
8161                         }
8162                     }
8163                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
8164                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
8165                   break;
8166                 default: /* (%si) -> 4 or (%di) -> 5  */
8167                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
8168                 }
8169               i.rm.mode = mode_from_disp_size (i.types[op]);
8170             }
8171           else /* i.base_reg and 32/64 bit mode  */
8172             {
8173               if (flag_code == CODE_64BIT
8174                   && operand_type_check (i.types[op], disp))
8175                 {
8176                   i.types[op].bitfield.disp16 = 0;
8177                   i.types[op].bitfield.disp64 = 0;
8178                   if (i.prefix[ADDR_PREFIX] == 0)
8179                     {
8180                       i.types[op].bitfield.disp32 = 0;
8181                       i.types[op].bitfield.disp32s = 1;
8182                     }
8183                   else
8184                     {
8185                       i.types[op].bitfield.disp32 = 1;
8186                       i.types[op].bitfield.disp32s = 0;
8187                     }
8188                 }
8189
8190               if (!i.tm.opcode_modifier.sib)
8191                 i.rm.regmem = i.base_reg->reg_num;
8192               if ((i.base_reg->reg_flags & RegRex) != 0)
8193                 i.rex |= REX_B;
8194               i.sib.base = i.base_reg->reg_num;
8195               /* x86-64 ignores REX prefix bit here to avoid decoder
8196                  complications.  */
8197               if (!(i.base_reg->reg_flags & RegRex)
8198                   && (i.base_reg->reg_num == EBP_REG_NUM
8199                    || i.base_reg->reg_num == ESP_REG_NUM))
8200                   default_seg = &ss;
8201               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
8202                 {
8203                   fake_zero_displacement = 1;
8204                   if (i.disp_encoding == disp_encoding_32bit)
8205                     i.types[op].bitfield.disp32 = 1;
8206                   else
8207                     i.types[op].bitfield.disp8 = 1;
8208                 }
8209               i.sib.scale = i.log2_scale_factor;
8210               if (i.index_reg == 0)
8211                 {
8212                   /* Only check for VSIB. */
8213                   gas_assert (i.tm.opcode_modifier.sib != VECSIB128
8214                               && i.tm.opcode_modifier.sib != VECSIB256
8215                               && i.tm.opcode_modifier.sib != VECSIB512);
8216
8217                   /* <disp>(%esp) becomes two byte modrm with no index
8218                      register.  We've already stored the code for esp
8219                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
8220                      Any base register besides %esp will not use the
8221                      extra modrm byte.  */
8222                   i.sib.index = NO_INDEX_REGISTER;
8223                 }
8224               else if (!i.tm.opcode_modifier.sib)
8225                 {
8226                   if (i.index_reg->reg_num == RegIZ)
8227                     i.sib.index = NO_INDEX_REGISTER;
8228                   else
8229                     i.sib.index = i.index_reg->reg_num;
8230                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8231                   if ((i.index_reg->reg_flags & RegRex) != 0)
8232                     i.rex |= REX_X;
8233                 }
8234
8235               if (i.disp_operands
8236                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
8237                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
8238                 i.rm.mode = 0;
8239               else
8240                 {
8241                   if (!fake_zero_displacement
8242                       && !i.disp_operands
8243                       && i.disp_encoding)
8244                     {
8245                       fake_zero_displacement = 1;
8246                       if (i.disp_encoding == disp_encoding_8bit)
8247                         i.types[op].bitfield.disp8 = 1;
8248                       else
8249                         i.types[op].bitfield.disp32 = 1;
8250                     }
8251                   i.rm.mode = mode_from_disp_size (i.types[op]);
8252                 }
8253             }
8254
8255           if (fake_zero_displacement)
8256             {
8257               /* Fakes a zero displacement assuming that i.types[op]
8258                  holds the correct displacement size.  */
8259               expressionS *exp;
8260
8261               gas_assert (i.op[op].disps == 0);
8262               exp = &disp_expressions[i.disp_operands++];
8263               i.op[op].disps = exp;
8264               exp->X_op = O_constant;
8265               exp->X_add_number = 0;
8266               exp->X_add_symbol = (symbolS *) 0;
8267               exp->X_op_symbol = (symbolS *) 0;
8268             }
8269
8270           mem = op;
8271         }
8272       else
8273         mem = ~0;
8274
8275       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
8276         {
8277           if (operand_type_check (i.types[0], imm))
8278             i.vex.register_specifier = NULL;
8279           else
8280             {
8281               /* VEX.vvvv encodes one of the sources when the first
8282                  operand is not an immediate.  */
8283               if (i.tm.opcode_modifier.vexw == VEXW0)
8284                 i.vex.register_specifier = i.op[0].regs;
8285               else
8286                 i.vex.register_specifier = i.op[1].regs;
8287             }
8288
8289           /* Destination is a XMM register encoded in the ModRM.reg
8290              and VEX.R bit.  */
8291           i.rm.reg = i.op[2].regs->reg_num;
8292           if ((i.op[2].regs->reg_flags & RegRex) != 0)
8293             i.rex |= REX_R;
8294
8295           /* ModRM.rm and VEX.B encodes the other source.  */
8296           if (!i.mem_operands)
8297             {
8298               i.rm.mode = 3;
8299
8300               if (i.tm.opcode_modifier.vexw == VEXW0)
8301                 i.rm.regmem = i.op[1].regs->reg_num;
8302               else
8303                 i.rm.regmem = i.op[0].regs->reg_num;
8304
8305               if ((i.op[1].regs->reg_flags & RegRex) != 0)
8306                 i.rex |= REX_B;
8307             }
8308         }
8309       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
8310         {
8311           i.vex.register_specifier = i.op[2].regs;
8312           if (!i.mem_operands)
8313             {
8314               i.rm.mode = 3;
8315               i.rm.regmem = i.op[1].regs->reg_num;
8316               if ((i.op[1].regs->reg_flags & RegRex) != 0)
8317                 i.rex |= REX_B;
8318             }
8319         }
8320       /* Fill in i.rm.reg or i.rm.regmem field with register operand
8321          (if any) based on i.tm.extension_opcode.  Again, we must be
8322          careful to make sure that segment/control/debug/test/MMX
8323          registers are coded into the i.rm.reg field.  */
8324       else if (i.reg_operands)
8325         {
8326           unsigned int op;
8327           unsigned int vex_reg = ~0;
8328
8329           for (op = 0; op < i.operands; op++)
8330             if (i.types[op].bitfield.class == Reg
8331                 || i.types[op].bitfield.class == RegBND
8332                 || i.types[op].bitfield.class == RegMask
8333                 || i.types[op].bitfield.class == SReg
8334                 || i.types[op].bitfield.class == RegCR
8335                 || i.types[op].bitfield.class == RegDR
8336                 || i.types[op].bitfield.class == RegTR
8337                 || i.types[op].bitfield.class == RegSIMD
8338                 || i.types[op].bitfield.class == RegMMX)
8339               break;
8340
8341           if (vex_3_sources)
8342             op = dest;
8343           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
8344             {
8345               /* For instructions with VexNDS, the register-only
8346                  source operand is encoded in VEX prefix. */
8347               gas_assert (mem != (unsigned int) ~0);
8348
8349               if (op > mem)
8350                 {
8351                   vex_reg = op++;
8352                   gas_assert (op < i.operands);
8353                 }
8354               else
8355                 {
8356                   /* Check register-only source operand when two source
8357                      operands are swapped.  */
8358                   if (!i.tm.operand_types[op].bitfield.baseindex
8359                       && i.tm.operand_types[op + 1].bitfield.baseindex)
8360                     {
8361                       vex_reg = op;
8362                       op += 2;
8363                       gas_assert (mem == (vex_reg + 1)
8364                                   && op < i.operands);
8365                     }
8366                   else
8367                     {
8368                       vex_reg = op + 1;
8369                       gas_assert (vex_reg < i.operands);
8370                     }
8371                 }
8372             }
8373           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
8374             {
8375               /* For instructions with VexNDD, the register destination
8376                  is encoded in VEX prefix.  */
8377               if (i.mem_operands == 0)
8378                 {
8379                   /* There is no memory operand.  */
8380                   gas_assert ((op + 2) == i.operands);
8381                   vex_reg = op + 1;
8382                 }
8383               else
8384                 {
8385                   /* There are only 2 non-immediate operands.  */
8386                   gas_assert (op < i.imm_operands + 2
8387                               && i.operands == i.imm_operands + 2);
8388                   vex_reg = i.imm_operands + 1;
8389                 }
8390             }
8391           else
8392             gas_assert (op < i.operands);
8393
8394           if (vex_reg != (unsigned int) ~0)
8395             {
8396               i386_operand_type *type = &i.tm.operand_types[vex_reg];
8397
8398               if ((type->bitfield.class != Reg
8399                    || (!type->bitfield.dword && !type->bitfield.qword))
8400                   && type->bitfield.class != RegSIMD
8401                   && !operand_type_equal (type, &regmask))
8402                 abort ();
8403
8404               i.vex.register_specifier = i.op[vex_reg].regs;
8405             }
8406
8407           /* Don't set OP operand twice.  */
8408           if (vex_reg != op)
8409             {
8410               /* If there is an extension opcode to put here, the
8411                  register number must be put into the regmem field.  */
8412               if (i.tm.extension_opcode != None)
8413                 {
8414                   i.rm.regmem = i.op[op].regs->reg_num;
8415                   set_rex_vrex (i.op[op].regs, REX_B,
8416                                 i.tm.opcode_modifier.sse2avx);
8417                 }
8418               else
8419                 {
8420                   i.rm.reg = i.op[op].regs->reg_num;
8421                   set_rex_vrex (i.op[op].regs, REX_R,
8422                                 i.tm.opcode_modifier.sse2avx);
8423                 }
8424             }
8425
8426           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
8427              must set it to 3 to indicate this is a register operand
8428              in the regmem field.  */
8429           if (!i.mem_operands)
8430             i.rm.mode = 3;
8431         }
8432
8433       /* Fill in i.rm.reg field with extension opcode (if any).  */
8434       if (i.tm.extension_opcode != None)
8435         i.rm.reg = i.tm.extension_opcode;
8436     }
8437   return default_seg;
8438 }
8439
8440 static INLINE void
8441 frag_opcode_byte (unsigned char byte)
8442 {
8443   if (now_seg != absolute_section)
8444     FRAG_APPEND_1_CHAR (byte);
8445   else
8446     ++abs_section_offset;
8447 }
8448
8449 static unsigned int
8450 flip_code16 (unsigned int code16)
8451 {
8452   gas_assert (i.tm.operands == 1);
8453
8454   return !(i.prefix[REX_PREFIX] & REX_W)
8455          && (code16 ? i.tm.operand_types[0].bitfield.disp32
8456                       || i.tm.operand_types[0].bitfield.disp32s
8457                     : i.tm.operand_types[0].bitfield.disp16)
8458          ? CODE16 : 0;
8459 }
8460
8461 static void
8462 output_branch (void)
8463 {
8464   char *p;
8465   int size;
8466   int code16;
8467   int prefix;
8468   relax_substateT subtype;
8469   symbolS *sym;
8470   offsetT off;
8471
8472   if (now_seg == absolute_section)
8473     {
8474       as_bad (_("relaxable branches not supported in absolute section"));
8475       return;
8476     }
8477
8478   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
8479   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
8480
8481   prefix = 0;
8482   if (i.prefix[DATA_PREFIX] != 0)
8483     {
8484       prefix = 1;
8485       i.prefixes -= 1;
8486       code16 ^= flip_code16(code16);
8487     }
8488   /* Pentium4 branch hints.  */
8489   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
8490       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
8491     {
8492       prefix++;
8493       i.prefixes--;
8494     }
8495   if (i.prefix[REX_PREFIX] != 0)
8496     {
8497       prefix++;
8498       i.prefixes--;
8499     }
8500
8501   /* BND prefixed jump.  */
8502   if (i.prefix[BND_PREFIX] != 0)
8503     {
8504       prefix++;
8505       i.prefixes--;
8506     }
8507
8508   if (i.prefixes != 0)
8509     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8510
8511   /* It's always a symbol;  End frag & setup for relax.
8512      Make sure there is enough room in this frag for the largest
8513      instruction we may generate in md_convert_frag.  This is 2
8514      bytes for the opcode and room for the prefix and largest
8515      displacement.  */
8516   frag_grow (prefix + 2 + 4);
8517   /* Prefix and 1 opcode byte go in fr_fix.  */
8518   p = frag_more (prefix + 1);
8519   if (i.prefix[DATA_PREFIX] != 0)
8520     *p++ = DATA_PREFIX_OPCODE;
8521   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
8522       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
8523     *p++ = i.prefix[SEG_PREFIX];
8524   if (i.prefix[BND_PREFIX] != 0)
8525     *p++ = BND_PREFIX_OPCODE;
8526   if (i.prefix[REX_PREFIX] != 0)
8527     *p++ = i.prefix[REX_PREFIX];
8528   *p = i.tm.base_opcode;
8529
8530   if ((unsigned char) *p == JUMP_PC_RELATIVE)
8531     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
8532   else if (cpu_arch_flags.bitfield.cpui386)
8533     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
8534   else
8535     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
8536   subtype |= code16;
8537
8538   sym = i.op[0].disps->X_add_symbol;
8539   off = i.op[0].disps->X_add_number;
8540
8541   if (i.op[0].disps->X_op != O_constant
8542       && i.op[0].disps->X_op != O_symbol)
8543     {
8544       /* Handle complex expressions.  */
8545       sym = make_expr_symbol (i.op[0].disps);
8546       off = 0;
8547     }
8548
8549   /* 1 possible extra opcode + 4 byte displacement go in var part.
8550      Pass reloc in fr_var.  */
8551   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
8552 }
8553
8554 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8555 /* Return TRUE iff PLT32 relocation should be used for branching to
8556    symbol S.  */
8557
8558 static bfd_boolean
8559 need_plt32_p (symbolS *s)
8560 {
8561   /* PLT32 relocation is ELF only.  */
8562   if (!IS_ELF)
8563     return FALSE;
8564
8565 #ifdef TE_SOLARIS
8566   /* Don't emit PLT32 relocation on Solaris: neither native linker nor
8567      krtld support it.  */
8568   return FALSE;
8569 #endif
8570
8571   /* Since there is no need to prepare for PLT branch on x86-64, we
8572      can generate R_X86_64_PLT32, instead of R_X86_64_PC32, which can
8573      be used as a marker for 32-bit PC-relative branches.  */
8574   if (!object_64bit)
8575     return FALSE;
8576
8577   /* Weak or undefined symbol need PLT32 relocation.  */
8578   if (S_IS_WEAK (s) || !S_IS_DEFINED (s))
8579     return TRUE;
8580
8581   /* Non-global symbol doesn't need PLT32 relocation.  */
8582   if (! S_IS_EXTERNAL (s))
8583     return FALSE;
8584
8585   /* Other global symbols need PLT32 relocation.  NB: Symbol with
8586      non-default visibilities are treated as normal global symbol
8587      so that PLT32 relocation can be used as a marker for 32-bit
8588      PC-relative branches.  It is useful for linker relaxation.  */
8589   return TRUE;
8590 }
8591 #endif
8592
8593 static void
8594 output_jump (void)
8595 {
8596   char *p;
8597   int size;
8598   fixS *fixP;
8599   bfd_reloc_code_real_type jump_reloc = i.reloc[0];
8600
8601   if (i.tm.opcode_modifier.jump == JUMP_BYTE)
8602     {
8603       /* This is a loop or jecxz type instruction.  */
8604       size = 1;
8605       if (i.prefix[ADDR_PREFIX] != 0)
8606         {
8607           frag_opcode_byte (ADDR_PREFIX_OPCODE);
8608           i.prefixes -= 1;
8609         }
8610       /* Pentium4 branch hints.  */
8611       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
8612           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
8613         {
8614           frag_opcode_byte (i.prefix[SEG_PREFIX]);
8615           i.prefixes--;
8616         }
8617     }
8618   else
8619     {
8620       int code16;
8621
8622       code16 = 0;
8623       if (flag_code == CODE_16BIT)
8624         code16 = CODE16;
8625
8626       if (i.prefix[DATA_PREFIX] != 0)
8627         {
8628           frag_opcode_byte (DATA_PREFIX_OPCODE);
8629           i.prefixes -= 1;
8630           code16 ^= flip_code16(code16);
8631         }
8632
8633       size = 4;
8634       if (code16)
8635         size = 2;
8636     }
8637
8638   /* BND prefixed jump.  */
8639   if (i.prefix[BND_PREFIX] != 0)
8640     {
8641       frag_opcode_byte (i.prefix[BND_PREFIX]);
8642       i.prefixes -= 1;
8643     }
8644
8645   if (i.prefix[REX_PREFIX] != 0)
8646     {
8647       frag_opcode_byte (i.prefix[REX_PREFIX]);
8648       i.prefixes -= 1;
8649     }
8650
8651   if (i.prefixes != 0)
8652     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8653
8654   if (now_seg == absolute_section)
8655     {
8656       abs_section_offset += i.tm.opcode_length + size;
8657       return;
8658     }
8659
8660   p = frag_more (i.tm.opcode_length + size);
8661   switch (i.tm.opcode_length)
8662     {
8663     case 2:
8664       *p++ = i.tm.base_opcode >> 8;
8665       /* Fall through.  */
8666     case 1:
8667       *p++ = i.tm.base_opcode;
8668       break;
8669     default:
8670       abort ();
8671     }
8672
8673 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8674   if (size == 4
8675       && jump_reloc == NO_RELOC
8676       && need_plt32_p (i.op[0].disps->X_add_symbol))
8677     jump_reloc = BFD_RELOC_X86_64_PLT32;
8678 #endif
8679
8680   jump_reloc = reloc (size, 1, 1, jump_reloc);
8681
8682   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8683                       i.op[0].disps, 1, jump_reloc);
8684
8685   /* All jumps handled here are signed, but don't use a signed limit
8686      check for 32 and 16 bit jumps as we want to allow wrap around at
8687      4G and 64k respectively.  */
8688   if (size == 1)
8689     fixP->fx_signed = 1;
8690 }
8691
8692 static void
8693 output_interseg_jump (void)
8694 {
8695   char *p;
8696   int size;
8697   int prefix;
8698   int code16;
8699
8700   code16 = 0;
8701   if (flag_code == CODE_16BIT)
8702     code16 = CODE16;
8703
8704   prefix = 0;
8705   if (i.prefix[DATA_PREFIX] != 0)
8706     {
8707       prefix = 1;
8708       i.prefixes -= 1;
8709       code16 ^= CODE16;
8710     }
8711
8712   gas_assert (!i.prefix[REX_PREFIX]);
8713
8714   size = 4;
8715   if (code16)
8716     size = 2;
8717
8718   if (i.prefixes != 0)
8719     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8720
8721   if (now_seg == absolute_section)
8722     {
8723       abs_section_offset += prefix + 1 + 2 + size;
8724       return;
8725     }
8726
8727   /* 1 opcode; 2 segment; offset  */
8728   p = frag_more (prefix + 1 + 2 + size);
8729
8730   if (i.prefix[DATA_PREFIX] != 0)
8731     *p++ = DATA_PREFIX_OPCODE;
8732
8733   if (i.prefix[REX_PREFIX] != 0)
8734     *p++ = i.prefix[REX_PREFIX];
8735
8736   *p++ = i.tm.base_opcode;
8737   if (i.op[1].imms->X_op == O_constant)
8738     {
8739       offsetT n = i.op[1].imms->X_add_number;
8740
8741       if (size == 2
8742           && !fits_in_unsigned_word (n)
8743           && !fits_in_signed_word (n))
8744         {
8745           as_bad (_("16-bit jump out of range"));
8746           return;
8747         }
8748       md_number_to_chars (p, n, size);
8749     }
8750   else
8751     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8752                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
8753   if (i.op[0].imms->X_op != O_constant)
8754     as_bad (_("can't handle non absolute segment in `%s'"),
8755             i.tm.name);
8756   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
8757 }
8758
8759 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8760 void
8761 x86_cleanup (void)
8762 {
8763   char *p;
8764   asection *seg = now_seg;
8765   subsegT subseg = now_subseg;
8766   asection *sec;
8767   unsigned int alignment, align_size_1;
8768   unsigned int isa_1_descsz, feature_2_descsz, descsz;
8769   unsigned int isa_1_descsz_raw, feature_2_descsz_raw;
8770   unsigned int padding;
8771
8772   if (!IS_ELF || !x86_used_note)
8773     return;
8774
8775   x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X86;
8776
8777   /* The .note.gnu.property section layout:
8778
8779      Field      Length          Contents
8780      ----       ----            ----
8781      n_namsz    4               4
8782      n_descsz   4               The note descriptor size
8783      n_type     4               NT_GNU_PROPERTY_TYPE_0
8784      n_name     4               "GNU"
8785      n_desc     n_descsz        The program property array
8786      ....       ....            ....
8787    */
8788
8789   /* Create the .note.gnu.property section.  */
8790   sec = subseg_new (NOTE_GNU_PROPERTY_SECTION_NAME, 0);
8791   bfd_set_section_flags (sec,
8792                          (SEC_ALLOC
8793                           | SEC_LOAD
8794                           | SEC_DATA
8795                           | SEC_HAS_CONTENTS
8796                           | SEC_READONLY));
8797
8798   if (get_elf_backend_data (stdoutput)->s->elfclass == ELFCLASS64)
8799     {
8800       align_size_1 = 7;
8801       alignment = 3;
8802     }
8803   else
8804     {
8805       align_size_1 = 3;
8806       alignment = 2;
8807     }
8808
8809   bfd_set_section_alignment (sec, alignment);
8810   elf_section_type (sec) = SHT_NOTE;
8811
8812   /* GNU_PROPERTY_X86_ISA_1_USED: 4-byte type + 4-byte data size
8813                                   + 4-byte data  */
8814   isa_1_descsz_raw = 4 + 4 + 4;
8815   /* Align GNU_PROPERTY_X86_ISA_1_USED.  */
8816   isa_1_descsz = (isa_1_descsz_raw + align_size_1) & ~align_size_1;
8817
8818   feature_2_descsz_raw = isa_1_descsz;
8819   /* GNU_PROPERTY_X86_FEATURE_2_USED: 4-byte type + 4-byte data size
8820                                       + 4-byte data  */
8821   feature_2_descsz_raw += 4 + 4 + 4;
8822   /* Align GNU_PROPERTY_X86_FEATURE_2_USED.  */
8823   feature_2_descsz = ((feature_2_descsz_raw + align_size_1)
8824                       & ~align_size_1);
8825
8826   descsz = feature_2_descsz;
8827   /* Section size: n_namsz + n_descsz + n_type + n_name + n_descsz.  */
8828   p = frag_more (4 + 4 + 4 + 4 + descsz);
8829
8830   /* Write n_namsz.  */
8831   md_number_to_chars (p, (valueT) 4, 4);
8832
8833   /* Write n_descsz.  */
8834   md_number_to_chars (p + 4, (valueT) descsz, 4);
8835
8836   /* Write n_type.  */
8837   md_number_to_chars (p + 4 * 2, (valueT) NT_GNU_PROPERTY_TYPE_0, 4);
8838
8839   /* Write n_name.  */
8840   memcpy (p + 4 * 3, "GNU", 4);
8841
8842   /* Write 4-byte type.  */
8843   md_number_to_chars (p + 4 * 4,
8844                       (valueT) GNU_PROPERTY_X86_ISA_1_USED, 4);
8845
8846   /* Write 4-byte data size.  */
8847   md_number_to_chars (p + 4 * 5, (valueT) 4, 4);
8848
8849   /* Write 4-byte data.  */
8850   md_number_to_chars (p + 4 * 6, (valueT) x86_isa_1_used, 4);
8851
8852   /* Zero out paddings.  */
8853   padding = isa_1_descsz - isa_1_descsz_raw;
8854   if (padding)
8855     memset (p + 4 * 7, 0, padding);
8856
8857   /* Write 4-byte type.  */
8858   md_number_to_chars (p + isa_1_descsz + 4 * 4,
8859                       (valueT) GNU_PROPERTY_X86_FEATURE_2_USED, 4);
8860
8861   /* Write 4-byte data size.  */
8862   md_number_to_chars (p + isa_1_descsz + 4 * 5, (valueT) 4, 4);
8863
8864   /* Write 4-byte data.  */
8865   md_number_to_chars (p + isa_1_descsz + 4 * 6,
8866                       (valueT) x86_feature_2_used, 4);
8867
8868   /* Zero out paddings.  */
8869   padding = feature_2_descsz - feature_2_descsz_raw;
8870   if (padding)
8871     memset (p + isa_1_descsz + 4 * 7, 0, padding);
8872
8873   /* We probably can't restore the current segment, for there likely
8874      isn't one yet...  */
8875   if (seg && subseg)
8876     subseg_set (seg, subseg);
8877 }
8878 #endif
8879
8880 static unsigned int
8881 encoding_length (const fragS *start_frag, offsetT start_off,
8882                  const char *frag_now_ptr)
8883 {
8884   unsigned int len = 0;
8885
8886   if (start_frag != frag_now)
8887     {
8888       const fragS *fr = start_frag;
8889
8890       do {
8891         len += fr->fr_fix;
8892         fr = fr->fr_next;
8893       } while (fr && fr != frag_now);
8894     }
8895
8896   return len - start_off + (frag_now_ptr - frag_now->fr_literal);
8897 }
8898
8899 /* Return 1 for test, and, cmp, add, sub, inc and dec which may
8900    be macro-fused with conditional jumps.
8901    NB: If TEST/AND/CMP/ADD/SUB/INC/DEC is of RIP relative address,
8902    or is one of the following format:
8903
8904     cmp m, imm
8905     add m, imm
8906     sub m, imm
8907    test m, imm
8908     and m, imm
8909     inc m
8910     dec m
8911
8912    it is unfusible.  */
8913
8914 static int
8915 maybe_fused_with_jcc_p (enum mf_cmp_kind* mf_cmp_p)
8916 {
8917   /* No RIP address.  */
8918   if (i.base_reg && i.base_reg->reg_num == RegIP)
8919     return 0;
8920
8921   /* No VEX/EVEX encoding.  */
8922   if (is_any_vex_encoding (&i.tm))
8923     return 0;
8924
8925   /* add, sub without add/sub m, imm.  */
8926   if (i.tm.base_opcode <= 5
8927       || (i.tm.base_opcode >= 0x28 && i.tm.base_opcode <= 0x2d)
8928       || ((i.tm.base_opcode | 3) == 0x83
8929           && (i.tm.extension_opcode == 0x5
8930               || i.tm.extension_opcode == 0x0)))
8931     {
8932       *mf_cmp_p = mf_cmp_alu_cmp;
8933       return !(i.mem_operands && i.imm_operands);
8934     }
8935
8936   /* and without and m, imm.  */
8937   if ((i.tm.base_opcode >= 0x20 && i.tm.base_opcode <= 0x25)
8938       || ((i.tm.base_opcode | 3) == 0x83
8939           && i.tm.extension_opcode == 0x4))
8940     {
8941       *mf_cmp_p = mf_cmp_test_and;
8942       return !(i.mem_operands && i.imm_operands);
8943     }
8944
8945   /* test without test m imm.  */
8946   if ((i.tm.base_opcode | 1) == 0x85
8947       || (i.tm.base_opcode | 1) == 0xa9
8948       || ((i.tm.base_opcode | 1) == 0xf7
8949           && i.tm.extension_opcode == 0))
8950     {
8951       *mf_cmp_p = mf_cmp_test_and;
8952       return !(i.mem_operands && i.imm_operands);
8953     }
8954
8955   /* cmp without cmp m, imm.  */
8956   if ((i.tm.base_opcode >= 0x38 && i.tm.base_opcode <= 0x3d)
8957       || ((i.tm.base_opcode | 3) == 0x83
8958           && (i.tm.extension_opcode == 0x7)))
8959     {
8960       *mf_cmp_p = mf_cmp_alu_cmp;
8961       return !(i.mem_operands && i.imm_operands);
8962     }
8963
8964   /* inc, dec without inc/dec m.   */
8965   if ((i.tm.cpu_flags.bitfield.cpuno64
8966        && (i.tm.base_opcode | 0xf) == 0x4f)
8967       || ((i.tm.base_opcode | 1) == 0xff
8968           && i.tm.extension_opcode <= 0x1))
8969     {
8970       *mf_cmp_p = mf_cmp_incdec;
8971       return !i.mem_operands;
8972     }
8973
8974   return 0;
8975 }
8976
8977 /* Return 1 if a FUSED_JCC_PADDING frag should be generated.  */
8978
8979 static int
8980 add_fused_jcc_padding_frag_p (enum mf_cmp_kind* mf_cmp_p)
8981 {
8982   /* NB: Don't work with COND_JUMP86 without i386.  */
8983   if (!align_branch_power
8984       || now_seg == absolute_section
8985       || !cpu_arch_flags.bitfield.cpui386
8986       || !(align_branch & align_branch_fused_bit))
8987     return 0;
8988
8989   if (maybe_fused_with_jcc_p (mf_cmp_p))
8990     {
8991       if (last_insn.kind == last_insn_other
8992           || last_insn.seg != now_seg)
8993         return 1;
8994       if (flag_debug)
8995         as_warn_where (last_insn.file, last_insn.line,
8996                        _("`%s` skips -malign-branch-boundary on `%s`"),
8997                        last_insn.name, i.tm.name);
8998     }
8999
9000   return 0;
9001 }
9002
9003 /* Return 1 if a BRANCH_PREFIX frag should be generated.  */
9004
9005 static int
9006 add_branch_prefix_frag_p (void)
9007 {
9008   /* NB: Don't work with COND_JUMP86 without i386.  Don't add prefix
9009      to PadLock instructions since they include prefixes in opcode.  */
9010   if (!align_branch_power
9011       || !align_branch_prefix_size
9012       || now_seg == absolute_section
9013       || i.tm.cpu_flags.bitfield.cpupadlock
9014       || !cpu_arch_flags.bitfield.cpui386)
9015     return 0;
9016
9017   /* Don't add prefix if it is a prefix or there is no operand in case
9018      that segment prefix is special.  */
9019   if (!i.operands || i.tm.opcode_modifier.isprefix)
9020     return 0;
9021
9022   if (last_insn.kind == last_insn_other
9023       || last_insn.seg != now_seg)
9024     return 1;
9025
9026   if (flag_debug)
9027     as_warn_where (last_insn.file, last_insn.line,
9028                    _("`%s` skips -malign-branch-boundary on `%s`"),
9029                    last_insn.name, i.tm.name);
9030
9031   return 0;
9032 }
9033
9034 /* Return 1 if a BRANCH_PADDING frag should be generated.  */
9035
9036 static int
9037 add_branch_padding_frag_p (enum align_branch_kind *branch_p,
9038                            enum mf_jcc_kind *mf_jcc_p)
9039 {
9040   int add_padding;
9041
9042   /* NB: Don't work with COND_JUMP86 without i386.  */
9043   if (!align_branch_power
9044       || now_seg == absolute_section
9045       || !cpu_arch_flags.bitfield.cpui386)
9046     return 0;
9047
9048   add_padding = 0;
9049
9050   /* Check for jcc and direct jmp.  */
9051   if (i.tm.opcode_modifier.jump == JUMP)
9052     {
9053       if (i.tm.base_opcode == JUMP_PC_RELATIVE)
9054         {
9055           *branch_p = align_branch_jmp;
9056           add_padding = align_branch & align_branch_jmp_bit;
9057         }
9058       else
9059         {
9060           /* Because J<cc> and JN<cc> share same group in macro-fusible table,
9061              igore the lowest bit.  */
9062           *mf_jcc_p = (i.tm.base_opcode & 0x0e) >> 1;
9063           *branch_p = align_branch_jcc;
9064           if ((align_branch & align_branch_jcc_bit))
9065             add_padding = 1;
9066         }
9067     }
9068   else if (is_any_vex_encoding (&i.tm))
9069     return 0;
9070   else if ((i.tm.base_opcode | 1) == 0xc3)
9071     {
9072       /* Near ret.  */
9073       *branch_p = align_branch_ret;
9074       if ((align_branch & align_branch_ret_bit))
9075         add_padding = 1;
9076     }
9077   else
9078     {
9079       /* Check for indirect jmp, direct and indirect calls.  */
9080       if (i.tm.base_opcode == 0xe8)
9081         {
9082           /* Direct call.  */
9083           *branch_p = align_branch_call;
9084           if ((align_branch & align_branch_call_bit))
9085             add_padding = 1;
9086         }
9087       else if (i.tm.base_opcode == 0xff
9088                && (i.tm.extension_opcode == 2
9089                    || i.tm.extension_opcode == 4))
9090         {
9091           /* Indirect call and jmp.  */
9092           *branch_p = align_branch_indirect;
9093           if ((align_branch & align_branch_indirect_bit))
9094             add_padding = 1;
9095         }
9096
9097       if (add_padding
9098           && i.disp_operands
9099           && tls_get_addr
9100           && (i.op[0].disps->X_op == O_symbol
9101               || (i.op[0].disps->X_op == O_subtract
9102                   && i.op[0].disps->X_op_symbol == GOT_symbol)))
9103         {
9104           symbolS *s = i.op[0].disps->X_add_symbol;
9105           /* No padding to call to global or undefined tls_get_addr.  */
9106           if ((S_IS_EXTERNAL (s) || !S_IS_DEFINED (s))
9107               && strcmp (S_GET_NAME (s), tls_get_addr) == 0)
9108             return 0;
9109         }
9110     }
9111
9112   if (add_padding
9113       && last_insn.kind != last_insn_other
9114       && last_insn.seg == now_seg)
9115     {
9116       if (flag_debug)
9117         as_warn_where (last_insn.file, last_insn.line,
9118                        _("`%s` skips -malign-branch-boundary on `%s`"),
9119                        last_insn.name, i.tm.name);
9120       return 0;
9121     }
9122
9123   return add_padding;
9124 }
9125
9126 static void
9127 output_insn (void)
9128 {
9129   fragS *insn_start_frag;
9130   offsetT insn_start_off;
9131   fragS *fragP = NULL;
9132   enum align_branch_kind branch = align_branch_none;
9133   /* The initializer is arbitrary just to avoid uninitialized error.
9134      it's actually either assigned in add_branch_padding_frag_p
9135      or never be used.  */
9136   enum mf_jcc_kind mf_jcc = mf_jcc_jo;
9137
9138 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9139   if (IS_ELF && x86_used_note && now_seg != absolute_section)
9140     {
9141       if (i.tm.cpu_flags.bitfield.cpucmov)
9142         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_CMOV;
9143       if (i.tm.cpu_flags.bitfield.cpusse)
9144         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE;
9145       if (i.tm.cpu_flags.bitfield.cpusse2)
9146         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE2;
9147       if (i.tm.cpu_flags.bitfield.cpusse3)
9148         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE3;
9149       if (i.tm.cpu_flags.bitfield.cpussse3)
9150         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSSE3;
9151       if (i.tm.cpu_flags.bitfield.cpusse4_1)
9152         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_1;
9153       if (i.tm.cpu_flags.bitfield.cpusse4_2)
9154         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_2;
9155       if (i.tm.cpu_flags.bitfield.cpuavx)
9156         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX;
9157       if (i.tm.cpu_flags.bitfield.cpuavx2)
9158         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX2;
9159       if (i.tm.cpu_flags.bitfield.cpufma)
9160         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_FMA;
9161       if (i.tm.cpu_flags.bitfield.cpuavx512f)
9162         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512F;
9163       if (i.tm.cpu_flags.bitfield.cpuavx512cd)
9164         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512CD;
9165       if (i.tm.cpu_flags.bitfield.cpuavx512er)
9166         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512ER;
9167       if (i.tm.cpu_flags.bitfield.cpuavx512pf)
9168         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512PF;
9169       if (i.tm.cpu_flags.bitfield.cpuavx512vl)
9170         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512VL;
9171       if (i.tm.cpu_flags.bitfield.cpuavx512dq)
9172         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512DQ;
9173       if (i.tm.cpu_flags.bitfield.cpuavx512bw)
9174         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512BW;
9175       if (i.tm.cpu_flags.bitfield.cpuavx512_4fmaps)
9176         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS;
9177       if (i.tm.cpu_flags.bitfield.cpuavx512_4vnniw)
9178         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW;
9179       if (i.tm.cpu_flags.bitfield.cpuavx512_bitalg)
9180         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BITALG;
9181       if (i.tm.cpu_flags.bitfield.cpuavx512ifma)
9182         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_IFMA;
9183       if (i.tm.cpu_flags.bitfield.cpuavx512vbmi)
9184         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI;
9185       if (i.tm.cpu_flags.bitfield.cpuavx512_vbmi2)
9186         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2;
9187       if (i.tm.cpu_flags.bitfield.cpuavx512_vnni)
9188         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VNNI;
9189       if (i.tm.cpu_flags.bitfield.cpuavx512_bf16)
9190         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BF16;
9191
9192       if (i.tm.cpu_flags.bitfield.cpu8087
9193           || i.tm.cpu_flags.bitfield.cpu287
9194           || i.tm.cpu_flags.bitfield.cpu387
9195           || i.tm.cpu_flags.bitfield.cpu687
9196           || i.tm.cpu_flags.bitfield.cpufisttp)
9197         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X87;
9198       if ((i.xstate & xstate_mmx)
9199           || i.tm.base_opcode == 0xf77 /* emms */
9200           || i.tm.base_opcode == 0xf0e /* femms */)
9201         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_MMX;
9202       if ((i.xstate & xstate_xmm))
9203         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XMM;
9204       if ((i.xstate & xstate_ymm) == xstate_ymm)
9205         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_YMM;
9206       if ((i.xstate & xstate_zmm) == xstate_zmm)
9207         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_ZMM;
9208       if (i.tm.cpu_flags.bitfield.cpufxsr)
9209         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_FXSR;
9210       if (i.tm.cpu_flags.bitfield.cpuxsave)
9211         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVE;
9212       if (i.tm.cpu_flags.bitfield.cpuxsaveopt)
9213         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT;
9214       if (i.tm.cpu_flags.bitfield.cpuxsavec)
9215         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEC;
9216
9217       if ((i.xstate & xstate_tmm) == xstate_tmm
9218           || i.tm.cpu_flags.bitfield.cpuamx_tile)
9219         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_TMM;
9220     }
9221 #endif
9222
9223   /* Tie dwarf2 debug info to the address at the start of the insn.
9224      We can't do this after the insn has been output as the current
9225      frag may have been closed off.  eg. by frag_var.  */
9226   dwarf2_emit_insn (0);
9227
9228   insn_start_frag = frag_now;
9229   insn_start_off = frag_now_fix ();
9230
9231   if (add_branch_padding_frag_p (&branch, &mf_jcc))
9232     {
9233       char *p;
9234       /* Branch can be 8 bytes.  Leave some room for prefixes.  */
9235       unsigned int max_branch_padding_size = 14;
9236
9237       /* Align section to boundary.  */
9238       record_alignment (now_seg, align_branch_power);
9239
9240       /* Make room for padding.  */
9241       frag_grow (max_branch_padding_size);
9242
9243       /* Start of the padding.  */
9244       p = frag_more (0);
9245
9246       fragP = frag_now;
9247
9248       frag_var (rs_machine_dependent, max_branch_padding_size, 0,
9249                 ENCODE_RELAX_STATE (BRANCH_PADDING, 0),
9250                 NULL, 0, p);
9251
9252       fragP->tc_frag_data.mf_type = mf_jcc;
9253       fragP->tc_frag_data.branch_type = branch;
9254       fragP->tc_frag_data.max_bytes = max_branch_padding_size;
9255     }
9256
9257   /* Output jumps.  */
9258   if (i.tm.opcode_modifier.jump == JUMP)
9259     output_branch ();
9260   else if (i.tm.opcode_modifier.jump == JUMP_BYTE
9261            || i.tm.opcode_modifier.jump == JUMP_DWORD)
9262     output_jump ();
9263   else if (i.tm.opcode_modifier.jump == JUMP_INTERSEGMENT)
9264     output_interseg_jump ();
9265   else
9266     {
9267       /* Output normal instructions here.  */
9268       char *p;
9269       unsigned char *q;
9270       unsigned int j;
9271       unsigned int prefix;
9272       enum mf_cmp_kind mf_cmp;
9273
9274       if (avoid_fence
9275           && (i.tm.base_opcode == 0xfaee8
9276               || i.tm.base_opcode == 0xfaef0
9277               || i.tm.base_opcode == 0xfaef8))
9278         {
9279           /* Encode lfence, mfence, and sfence as
9280              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
9281           if (now_seg != absolute_section)
9282             {
9283               offsetT val = 0x240483f0ULL;
9284
9285               p = frag_more (5);
9286               md_number_to_chars (p, val, 5);
9287             }
9288           else
9289             abs_section_offset += 5;
9290           return;
9291         }
9292
9293       /* Some processors fail on LOCK prefix. This options makes
9294          assembler ignore LOCK prefix and serves as a workaround.  */
9295       if (omit_lock_prefix)
9296         {
9297           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
9298             return;
9299           i.prefix[LOCK_PREFIX] = 0;
9300         }
9301
9302       if (branch)
9303         /* Skip if this is a branch.  */
9304         ;
9305       else if (add_fused_jcc_padding_frag_p (&mf_cmp))
9306         {
9307           /* Make room for padding.  */
9308           frag_grow (MAX_FUSED_JCC_PADDING_SIZE);
9309           p = frag_more (0);
9310
9311           fragP = frag_now;
9312
9313           frag_var (rs_machine_dependent, MAX_FUSED_JCC_PADDING_SIZE, 0,
9314                     ENCODE_RELAX_STATE (FUSED_JCC_PADDING, 0),
9315                     NULL, 0, p);
9316
9317           fragP->tc_frag_data.mf_type = mf_cmp;
9318           fragP->tc_frag_data.branch_type = align_branch_fused;
9319           fragP->tc_frag_data.max_bytes = MAX_FUSED_JCC_PADDING_SIZE;
9320         }
9321       else if (add_branch_prefix_frag_p ())
9322         {
9323           unsigned int max_prefix_size = align_branch_prefix_size;
9324
9325           /* Make room for padding.  */
9326           frag_grow (max_prefix_size);
9327           p = frag_more (0);
9328
9329           fragP = frag_now;
9330
9331           frag_var (rs_machine_dependent, max_prefix_size, 0,
9332                     ENCODE_RELAX_STATE (BRANCH_PREFIX, 0),
9333                     NULL, 0, p);
9334
9335           fragP->tc_frag_data.max_bytes = max_prefix_size;
9336         }
9337
9338       /* Since the VEX/EVEX prefix contains the implicit prefix, we
9339          don't need the explicit prefix.  */
9340       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
9341         {
9342           switch (i.tm.opcode_length)
9343             {
9344             case 3:
9345               if (i.tm.base_opcode & 0xff000000)
9346                 {
9347                   prefix = (i.tm.base_opcode >> 24) & 0xff;
9348                   if (!i.tm.cpu_flags.bitfield.cpupadlock
9349                       || prefix != REPE_PREFIX_OPCODE
9350                       || (i.prefix[REP_PREFIX] != REPE_PREFIX_OPCODE))
9351                     add_prefix (prefix);
9352                 }
9353               break;
9354             case 2:
9355               if ((i.tm.base_opcode & 0xff0000) != 0)
9356                 {
9357                   prefix = (i.tm.base_opcode >> 16) & 0xff;
9358                   add_prefix (prefix);
9359                 }
9360               break;
9361             case 1:
9362               break;
9363             case 0:
9364               /* Check for pseudo prefixes.  */
9365               as_bad_where (insn_start_frag->fr_file,
9366                             insn_start_frag->fr_line,
9367                              _("pseudo prefix without instruction"));
9368               return;
9369             default:
9370               abort ();
9371             }
9372
9373 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
9374           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
9375              R_X86_64_GOTTPOFF relocation so that linker can safely
9376              perform IE->LE optimization.  A dummy REX_OPCODE prefix
9377              is also needed for lea with R_X86_64_GOTPC32_TLSDESC
9378              relocation for GDesc -> IE/LE optimization.  */
9379           if (x86_elf_abi == X86_64_X32_ABI
9380               && i.operands == 2
9381               && (i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
9382                   || i.reloc[0] == BFD_RELOC_X86_64_GOTPC32_TLSDESC)
9383               && i.prefix[REX_PREFIX] == 0)
9384             add_prefix (REX_OPCODE);
9385 #endif
9386
9387           /* The prefix bytes.  */
9388           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
9389             if (*q)
9390               frag_opcode_byte (*q);
9391         }
9392       else
9393         {
9394           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
9395             if (*q)
9396               switch (j)
9397                 {
9398                 case SEG_PREFIX:
9399                 case ADDR_PREFIX:
9400                   frag_opcode_byte (*q);
9401                   break;
9402                 default:
9403                   /* There should be no other prefixes for instructions
9404                      with VEX prefix.  */
9405                   abort ();
9406                 }
9407
9408           /* For EVEX instructions i.vrex should become 0 after
9409              build_evex_prefix.  For VEX instructions upper 16 registers
9410              aren't available, so VREX should be 0.  */
9411           if (i.vrex)
9412             abort ();
9413           /* Now the VEX prefix.  */
9414           if (now_seg != absolute_section)
9415             {
9416               p = frag_more (i.vex.length);
9417               for (j = 0; j < i.vex.length; j++)
9418                 p[j] = i.vex.bytes[j];
9419             }
9420           else
9421             abs_section_offset += i.vex.length;
9422         }
9423
9424       /* Now the opcode; be careful about word order here!  */
9425       if (now_seg == absolute_section)
9426         abs_section_offset += i.tm.opcode_length;
9427       else if (i.tm.opcode_length == 1)
9428         {
9429           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
9430         }
9431       else
9432         {
9433           switch (i.tm.opcode_length)
9434             {
9435             case 4:
9436               p = frag_more (4);
9437               *p++ = (i.tm.base_opcode >> 24) & 0xff;
9438               *p++ = (i.tm.base_opcode >> 16) & 0xff;
9439               break;
9440             case 3:
9441               p = frag_more (3);
9442               *p++ = (i.tm.base_opcode >> 16) & 0xff;
9443               break;
9444             case 2:
9445               p = frag_more (2);
9446               break;
9447             default:
9448               abort ();
9449               break;
9450             }
9451
9452           /* Put out high byte first: can't use md_number_to_chars!  */
9453           *p++ = (i.tm.base_opcode >> 8) & 0xff;
9454           *p = i.tm.base_opcode & 0xff;
9455         }
9456
9457       /* Now the modrm byte and sib byte (if present).  */
9458       if (i.tm.opcode_modifier.modrm)
9459         {
9460           frag_opcode_byte ((i.rm.regmem << 0)
9461                              | (i.rm.reg << 3)
9462                              | (i.rm.mode << 6));
9463           /* If i.rm.regmem == ESP (4)
9464              && i.rm.mode != (Register mode)
9465              && not 16 bit
9466              ==> need second modrm byte.  */
9467           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
9468               && i.rm.mode != 3
9469               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
9470             frag_opcode_byte ((i.sib.base << 0)
9471                               | (i.sib.index << 3)
9472                               | (i.sib.scale << 6));
9473         }
9474
9475       if (i.disp_operands)
9476         output_disp (insn_start_frag, insn_start_off);
9477
9478       if (i.imm_operands)
9479         output_imm (insn_start_frag, insn_start_off);
9480
9481       /*
9482        * frag_now_fix () returning plain abs_section_offset when we're in the
9483        * absolute section, and abs_section_offset not getting updated as data
9484        * gets added to the frag breaks the logic below.
9485        */
9486       if (now_seg != absolute_section)
9487         {
9488           j = encoding_length (insn_start_frag, insn_start_off, frag_more (0));
9489           if (j > 15)
9490             as_warn (_("instruction length of %u bytes exceeds the limit of 15"),
9491                      j);
9492           else if (fragP)
9493             {
9494               /* NB: Don't add prefix with GOTPC relocation since
9495                  output_disp() above depends on the fixed encoding
9496                  length.  Can't add prefix with TLS relocation since
9497                  it breaks TLS linker optimization.  */
9498               unsigned int max = i.has_gotpc_tls_reloc ? 0 : 15 - j;
9499               /* Prefix count on the current instruction.  */
9500               unsigned int count = i.vex.length;
9501               unsigned int k;
9502               for (k = 0; k < ARRAY_SIZE (i.prefix); k++)
9503                 /* REX byte is encoded in VEX/EVEX prefix.  */
9504                 if (i.prefix[k] && (k != REX_PREFIX || !i.vex.length))
9505                   count++;
9506
9507               /* Count prefixes for extended opcode maps.  */
9508               if (!i.vex.length)
9509                 switch (i.tm.opcode_length)
9510                   {
9511                   case 3:
9512                     if (((i.tm.base_opcode >> 16) & 0xff) == 0xf)
9513                       {
9514                         count++;
9515                         switch ((i.tm.base_opcode >> 8) & 0xff)
9516                           {
9517                           case 0x38:
9518                           case 0x3a:
9519                             count++;
9520                             break;
9521                           default:
9522                             break;
9523                           }
9524                       }
9525                     break;
9526                   case 2:
9527                     if (((i.tm.base_opcode >> 8) & 0xff) == 0xf)
9528                       count++;
9529                     break;
9530                   case 1:
9531                     break;
9532                   default:
9533                     abort ();
9534                   }
9535
9536               if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
9537                   == BRANCH_PREFIX)
9538                 {
9539                   /* Set the maximum prefix size in BRANCH_PREFIX
9540                      frag.  */
9541                   if (fragP->tc_frag_data.max_bytes > max)
9542                     fragP->tc_frag_data.max_bytes = max;
9543                   if (fragP->tc_frag_data.max_bytes > count)
9544                     fragP->tc_frag_data.max_bytes -= count;
9545                   else
9546                     fragP->tc_frag_data.max_bytes = 0;
9547                 }
9548               else
9549                 {
9550                   /* Remember the maximum prefix size in FUSED_JCC_PADDING
9551                      frag.  */
9552                   unsigned int max_prefix_size;
9553                   if (align_branch_prefix_size > max)
9554                     max_prefix_size = max;
9555                   else
9556                     max_prefix_size = align_branch_prefix_size;
9557                   if (max_prefix_size > count)
9558                     fragP->tc_frag_data.max_prefix_length
9559                       = max_prefix_size - count;
9560                 }
9561
9562               /* Use existing segment prefix if possible.  Use CS
9563                  segment prefix in 64-bit mode.  In 32-bit mode, use SS
9564                  segment prefix with ESP/EBP base register and use DS
9565                  segment prefix without ESP/EBP base register.  */
9566               if (i.prefix[SEG_PREFIX])
9567                 fragP->tc_frag_data.default_prefix = i.prefix[SEG_PREFIX];
9568               else if (flag_code == CODE_64BIT)
9569                 fragP->tc_frag_data.default_prefix = CS_PREFIX_OPCODE;
9570               else if (i.base_reg
9571                        && (i.base_reg->reg_num == 4
9572                            || i.base_reg->reg_num == 5))
9573                 fragP->tc_frag_data.default_prefix = SS_PREFIX_OPCODE;
9574               else
9575                 fragP->tc_frag_data.default_prefix = DS_PREFIX_OPCODE;
9576             }
9577         }
9578     }
9579
9580   /* NB: Don't work with COND_JUMP86 without i386.  */
9581   if (align_branch_power
9582       && now_seg != absolute_section
9583       && cpu_arch_flags.bitfield.cpui386)
9584     {
9585       /* Terminate each frag so that we can add prefix and check for
9586          fused jcc.  */
9587       frag_wane (frag_now);
9588       frag_new (0);
9589     }
9590
9591 #ifdef DEBUG386
9592   if (flag_debug)
9593     {
9594       pi ("" /*line*/, &i);
9595     }
9596 #endif /* DEBUG386  */
9597 }
9598
9599 /* Return the size of the displacement operand N.  */
9600
9601 static int
9602 disp_size (unsigned int n)
9603 {
9604   int size = 4;
9605
9606   if (i.types[n].bitfield.disp64)
9607     size = 8;
9608   else if (i.types[n].bitfield.disp8)
9609     size = 1;
9610   else if (i.types[n].bitfield.disp16)
9611     size = 2;
9612   return size;
9613 }
9614
9615 /* Return the size of the immediate operand N.  */
9616
9617 static int
9618 imm_size (unsigned int n)
9619 {
9620   int size = 4;
9621   if (i.types[n].bitfield.imm64)
9622     size = 8;
9623   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
9624     size = 1;
9625   else if (i.types[n].bitfield.imm16)
9626     size = 2;
9627   return size;
9628 }
9629
9630 static void
9631 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
9632 {
9633   char *p;
9634   unsigned int n;
9635
9636   for (n = 0; n < i.operands; n++)
9637     {
9638       if (operand_type_check (i.types[n], disp))
9639         {
9640           int size = disp_size (n);
9641
9642           if (now_seg == absolute_section)
9643             abs_section_offset += size;
9644           else if (i.op[n].disps->X_op == O_constant)
9645             {
9646               offsetT val = i.op[n].disps->X_add_number;
9647
9648               val = offset_in_range (val >> (size == 1 ? i.memshift : 0),
9649                                      size);
9650               p = frag_more (size);
9651               md_number_to_chars (p, val, size);
9652             }
9653           else
9654             {
9655               enum bfd_reloc_code_real reloc_type;
9656               int sign = i.types[n].bitfield.disp32s;
9657               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
9658               fixS *fixP;
9659
9660               /* We can't have 8 bit displacement here.  */
9661               gas_assert (!i.types[n].bitfield.disp8);
9662
9663               /* The PC relative address is computed relative
9664                  to the instruction boundary, so in case immediate
9665                  fields follows, we need to adjust the value.  */
9666               if (pcrel && i.imm_operands)
9667                 {
9668                   unsigned int n1;
9669                   int sz = 0;
9670
9671                   for (n1 = 0; n1 < i.operands; n1++)
9672                     if (operand_type_check (i.types[n1], imm))
9673                       {
9674                         /* Only one immediate is allowed for PC
9675                            relative address.  */
9676                         gas_assert (sz == 0);
9677                         sz = imm_size (n1);
9678                         i.op[n].disps->X_add_number -= sz;
9679                       }
9680                   /* We should find the immediate.  */
9681                   gas_assert (sz != 0);
9682                 }
9683
9684               p = frag_more (size);
9685               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
9686               if (GOT_symbol
9687                   && GOT_symbol == i.op[n].disps->X_add_symbol
9688                   && (((reloc_type == BFD_RELOC_32
9689                         || reloc_type == BFD_RELOC_X86_64_32S
9690                         || (reloc_type == BFD_RELOC_64
9691                             && object_64bit))
9692                        && (i.op[n].disps->X_op == O_symbol
9693                            || (i.op[n].disps->X_op == O_add
9694                                && ((symbol_get_value_expression
9695                                     (i.op[n].disps->X_op_symbol)->X_op)
9696                                    == O_subtract))))
9697                       || reloc_type == BFD_RELOC_32_PCREL))
9698                 {
9699                   if (!object_64bit)
9700                     {
9701                       reloc_type = BFD_RELOC_386_GOTPC;
9702                       i.has_gotpc_tls_reloc = TRUE;
9703                       i.op[n].imms->X_add_number +=
9704                         encoding_length (insn_start_frag, insn_start_off, p);
9705                     }
9706                   else if (reloc_type == BFD_RELOC_64)
9707                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
9708                   else
9709                     /* Don't do the adjustment for x86-64, as there
9710                        the pcrel addressing is relative to the _next_
9711                        insn, and that is taken care of in other code.  */
9712                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
9713                 }
9714               else if (align_branch_power)
9715                 {
9716                   switch (reloc_type)
9717                     {
9718                     case BFD_RELOC_386_TLS_GD:
9719                     case BFD_RELOC_386_TLS_LDM:
9720                     case BFD_RELOC_386_TLS_IE:
9721                     case BFD_RELOC_386_TLS_IE_32:
9722                     case BFD_RELOC_386_TLS_GOTIE:
9723                     case BFD_RELOC_386_TLS_GOTDESC:
9724                     case BFD_RELOC_386_TLS_DESC_CALL:
9725                     case BFD_RELOC_X86_64_TLSGD:
9726                     case BFD_RELOC_X86_64_TLSLD:
9727                     case BFD_RELOC_X86_64_GOTTPOFF:
9728                     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
9729                     case BFD_RELOC_X86_64_TLSDESC_CALL:
9730                       i.has_gotpc_tls_reloc = TRUE;
9731                     default:
9732                       break;
9733                     }
9734                 }
9735               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
9736                                   size, i.op[n].disps, pcrel,
9737                                   reloc_type);
9738               /* Check for "call/jmp *mem", "mov mem, %reg",
9739                  "test %reg, mem" and "binop mem, %reg" where binop
9740                  is one of adc, add, and, cmp, or, sbb, sub, xor
9741                  instructions without data prefix.  Always generate
9742                  R_386_GOT32X for "sym*GOT" operand in 32-bit mode.  */
9743               if (i.prefix[DATA_PREFIX] == 0
9744                   && (generate_relax_relocations
9745                       || (!object_64bit
9746                           && i.rm.mode == 0
9747                           && i.rm.regmem == 5))
9748                   && (i.rm.mode == 2
9749                       || (i.rm.mode == 0 && i.rm.regmem == 5))
9750                   && !is_any_vex_encoding(&i.tm)
9751                   && ((i.operands == 1
9752                        && i.tm.base_opcode == 0xff
9753                        && (i.rm.reg == 2 || i.rm.reg == 4))
9754                       || (i.operands == 2
9755                           && (i.tm.base_opcode == 0x8b
9756                               || i.tm.base_opcode == 0x85
9757                               || (i.tm.base_opcode & ~0x38) == 0x03))))
9758                 {
9759                   if (object_64bit)
9760                     {
9761                       fixP->fx_tcbit = i.rex != 0;
9762                       if (i.base_reg
9763                           && (i.base_reg->reg_num == RegIP))
9764                       fixP->fx_tcbit2 = 1;
9765                     }
9766                   else
9767                     fixP->fx_tcbit2 = 1;
9768                 }
9769             }
9770         }
9771     }
9772 }
9773
9774 static void
9775 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
9776 {
9777   char *p;
9778   unsigned int n;
9779
9780   for (n = 0; n < i.operands; n++)
9781     {
9782       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
9783       if (i.rounding && (int) n == i.rounding->operand)
9784         continue;
9785
9786       if (operand_type_check (i.types[n], imm))
9787         {
9788           int size = imm_size (n);
9789
9790           if (now_seg == absolute_section)
9791             abs_section_offset += size;
9792           else if (i.op[n].imms->X_op == O_constant)
9793             {
9794               offsetT val;
9795
9796               val = offset_in_range (i.op[n].imms->X_add_number,
9797                                      size);
9798               p = frag_more (size);
9799               md_number_to_chars (p, val, size);
9800             }
9801           else
9802             {
9803               /* Not absolute_section.
9804                  Need a 32-bit fixup (don't support 8bit
9805                  non-absolute imms).  Try to support other
9806                  sizes ...  */
9807               enum bfd_reloc_code_real reloc_type;
9808               int sign;
9809
9810               if (i.types[n].bitfield.imm32s
9811                   && (i.suffix == QWORD_MNEM_SUFFIX
9812                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
9813                 sign = 1;
9814               else
9815                 sign = 0;
9816
9817               p = frag_more (size);
9818               reloc_type = reloc (size, 0, sign, i.reloc[n]);
9819
9820               /*   This is tough to explain.  We end up with this one if we
9821                * have operands that look like
9822                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
9823                * obtain the absolute address of the GOT, and it is strongly
9824                * preferable from a performance point of view to avoid using
9825                * a runtime relocation for this.  The actual sequence of
9826                * instructions often look something like:
9827                *
9828                *        call    .L66
9829                * .L66:
9830                *        popl    %ebx
9831                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
9832                *
9833                *   The call and pop essentially return the absolute address
9834                * of the label .L66 and store it in %ebx.  The linker itself
9835                * will ultimately change the first operand of the addl so
9836                * that %ebx points to the GOT, but to keep things simple, the
9837                * .o file must have this operand set so that it generates not
9838                * the absolute address of .L66, but the absolute address of
9839                * itself.  This allows the linker itself simply treat a GOTPC
9840                * relocation as asking for a pcrel offset to the GOT to be
9841                * added in, and the addend of the relocation is stored in the
9842                * operand field for the instruction itself.
9843                *
9844                *   Our job here is to fix the operand so that it would add
9845                * the correct offset so that %ebx would point to itself.  The
9846                * thing that is tricky is that .-.L66 will point to the
9847                * beginning of the instruction, so we need to further modify
9848                * the operand so that it will point to itself.  There are
9849                * other cases where you have something like:
9850                *
9851                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
9852                *
9853                * and here no correction would be required.  Internally in
9854                * the assembler we treat operands of this form as not being
9855                * pcrel since the '.' is explicitly mentioned, and I wonder
9856                * whether it would simplify matters to do it this way.  Who
9857                * knows.  In earlier versions of the PIC patches, the
9858                * pcrel_adjust field was used to store the correction, but
9859                * since the expression is not pcrel, I felt it would be
9860                * confusing to do it this way.  */
9861
9862               if ((reloc_type == BFD_RELOC_32
9863                    || reloc_type == BFD_RELOC_X86_64_32S
9864                    || reloc_type == BFD_RELOC_64)
9865                   && GOT_symbol
9866                   && GOT_symbol == i.op[n].imms->X_add_symbol
9867                   && (i.op[n].imms->X_op == O_symbol
9868                       || (i.op[n].imms->X_op == O_add
9869                           && ((symbol_get_value_expression
9870                                (i.op[n].imms->X_op_symbol)->X_op)
9871                               == O_subtract))))
9872                 {
9873                   if (!object_64bit)
9874                     reloc_type = BFD_RELOC_386_GOTPC;
9875                   else if (size == 4)
9876                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
9877                   else if (size == 8)
9878                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
9879                   i.has_gotpc_tls_reloc = TRUE;
9880                   i.op[n].imms->X_add_number +=
9881                     encoding_length (insn_start_frag, insn_start_off, p);
9882                 }
9883               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
9884                            i.op[n].imms, 0, reloc_type);
9885             }
9886         }
9887     }
9888 }
9889 \f
9890 /* x86_cons_fix_new is called via the expression parsing code when a
9891    reloc is needed.  We use this hook to get the correct .got reloc.  */
9892 static int cons_sign = -1;
9893
9894 void
9895 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
9896                   expressionS *exp, bfd_reloc_code_real_type r)
9897 {
9898   r = reloc (len, 0, cons_sign, r);
9899
9900 #ifdef TE_PE
9901   if (exp->X_op == O_secrel)
9902     {
9903       exp->X_op = O_symbol;
9904       r = BFD_RELOC_32_SECREL;
9905     }
9906 #endif
9907
9908   fix_new_exp (frag, off, len, exp, 0, r);
9909 }
9910
9911 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
9912    purpose of the `.dc.a' internal pseudo-op.  */
9913
9914 int
9915 x86_address_bytes (void)
9916 {
9917   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
9918     return 4;
9919   return stdoutput->arch_info->bits_per_address / 8;
9920 }
9921
9922 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
9923     || defined (LEX_AT)
9924 # define lex_got(reloc, adjust, types) NULL
9925 #else
9926 /* Parse operands of the form
9927    <symbol>@GOTOFF+<nnn>
9928    and similar .plt or .got references.
9929
9930    If we find one, set up the correct relocation in RELOC and copy the
9931    input string, minus the `@GOTOFF' into a malloc'd buffer for
9932    parsing by the calling routine.  Return this buffer, and if ADJUST
9933    is non-null set it to the length of the string we removed from the
9934    input line.  Otherwise return NULL.  */
9935 static char *
9936 lex_got (enum bfd_reloc_code_real *rel,
9937          int *adjust,
9938          i386_operand_type *types)
9939 {
9940   /* Some of the relocations depend on the size of what field is to
9941      be relocated.  But in our callers i386_immediate and i386_displacement
9942      we don't yet know the operand size (this will be set by insn
9943      matching).  Hence we record the word32 relocation here,
9944      and adjust the reloc according to the real size in reloc().  */
9945   static const struct {
9946     const char *str;
9947     int len;
9948     const enum bfd_reloc_code_real rel[2];
9949     const i386_operand_type types64;
9950   } gotrel[] = {
9951 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9952     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
9953                                         BFD_RELOC_SIZE32 },
9954       OPERAND_TYPE_IMM32_64 },
9955 #endif
9956     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
9957                                        BFD_RELOC_X86_64_PLTOFF64 },
9958       OPERAND_TYPE_IMM64 },
9959     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
9960                                        BFD_RELOC_X86_64_PLT32    },
9961       OPERAND_TYPE_IMM32_32S_DISP32 },
9962     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
9963                                        BFD_RELOC_X86_64_GOTPLT64 },
9964       OPERAND_TYPE_IMM64_DISP64 },
9965     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
9966                                        BFD_RELOC_X86_64_GOTOFF64 },
9967       OPERAND_TYPE_IMM64_DISP64 },
9968     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
9969                                        BFD_RELOC_X86_64_GOTPCREL },
9970       OPERAND_TYPE_IMM32_32S_DISP32 },
9971     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
9972                                        BFD_RELOC_X86_64_TLSGD    },
9973       OPERAND_TYPE_IMM32_32S_DISP32 },
9974     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
9975                                        _dummy_first_bfd_reloc_code_real },
9976       OPERAND_TYPE_NONE },
9977     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
9978                                        BFD_RELOC_X86_64_TLSLD    },
9979       OPERAND_TYPE_IMM32_32S_DISP32 },
9980     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
9981                                        BFD_RELOC_X86_64_GOTTPOFF },
9982       OPERAND_TYPE_IMM32_32S_DISP32 },
9983     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
9984                                        BFD_RELOC_X86_64_TPOFF32  },
9985       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
9986     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
9987                                        _dummy_first_bfd_reloc_code_real },
9988       OPERAND_TYPE_NONE },
9989     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
9990                                        BFD_RELOC_X86_64_DTPOFF32 },
9991       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
9992     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
9993                                        _dummy_first_bfd_reloc_code_real },
9994       OPERAND_TYPE_NONE },
9995     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
9996                                        _dummy_first_bfd_reloc_code_real },
9997       OPERAND_TYPE_NONE },
9998     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
9999                                        BFD_RELOC_X86_64_GOT32    },
10000       OPERAND_TYPE_IMM32_32S_64_DISP32 },
10001     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
10002                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
10003       OPERAND_TYPE_IMM32_32S_DISP32 },
10004     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
10005                                        BFD_RELOC_X86_64_TLSDESC_CALL },
10006       OPERAND_TYPE_IMM32_32S_DISP32 },
10007   };
10008   char *cp;
10009   unsigned int j;
10010
10011 #if defined (OBJ_MAYBE_ELF)
10012   if (!IS_ELF)
10013     return NULL;
10014 #endif
10015
10016   for (cp = input_line_pointer; *cp != '@'; cp++)
10017     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
10018       return NULL;
10019
10020   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
10021     {
10022       int len = gotrel[j].len;
10023       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
10024         {
10025           if (gotrel[j].rel[object_64bit] != 0)
10026             {
10027               int first, second;
10028               char *tmpbuf, *past_reloc;
10029
10030               *rel = gotrel[j].rel[object_64bit];
10031
10032               if (types)
10033                 {
10034                   if (flag_code != CODE_64BIT)
10035                     {
10036                       types->bitfield.imm32 = 1;
10037                       types->bitfield.disp32 = 1;
10038                     }
10039                   else
10040                     *types = gotrel[j].types64;
10041                 }
10042
10043               if (j != 0 && GOT_symbol == NULL)
10044                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
10045
10046               /* The length of the first part of our input line.  */
10047               first = cp - input_line_pointer;
10048
10049               /* The second part goes from after the reloc token until
10050                  (and including) an end_of_line char or comma.  */
10051               past_reloc = cp + 1 + len;
10052               cp = past_reloc;
10053               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
10054                 ++cp;
10055               second = cp + 1 - past_reloc;
10056
10057               /* Allocate and copy string.  The trailing NUL shouldn't
10058                  be necessary, but be safe.  */
10059               tmpbuf = XNEWVEC (char, first + second + 2);
10060               memcpy (tmpbuf, input_line_pointer, first);
10061               if (second != 0 && *past_reloc != ' ')
10062                 /* Replace the relocation token with ' ', so that
10063                    errors like foo@GOTOFF1 will be detected.  */
10064                 tmpbuf[first++] = ' ';
10065               else
10066                 /* Increment length by 1 if the relocation token is
10067                    removed.  */
10068                 len++;
10069               if (adjust)
10070                 *adjust = len;
10071               memcpy (tmpbuf + first, past_reloc, second);
10072               tmpbuf[first + second] = '\0';
10073               return tmpbuf;
10074             }
10075
10076           as_bad (_("@%s reloc is not supported with %d-bit output format"),
10077                   gotrel[j].str, 1 << (5 + object_64bit));
10078           return NULL;
10079         }
10080     }
10081
10082   /* Might be a symbol version string.  Don't as_bad here.  */
10083   return NULL;
10084 }
10085 #endif
10086
10087 #ifdef TE_PE
10088 #ifdef lex_got
10089 #undef lex_got
10090 #endif
10091 /* Parse operands of the form
10092    <symbol>@SECREL32+<nnn>
10093
10094    If we find one, set up the correct relocation in RELOC and copy the
10095    input string, minus the `@SECREL32' into a malloc'd buffer for
10096    parsing by the calling routine.  Return this buffer, and if ADJUST
10097    is non-null set it to the length of the string we removed from the
10098    input line.  Otherwise return NULL.
10099
10100    This function is copied from the ELF version above adjusted for PE targets.  */
10101
10102 static char *
10103 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
10104          int *adjust ATTRIBUTE_UNUSED,
10105          i386_operand_type *types)
10106 {
10107   static const struct
10108   {
10109     const char *str;
10110     int len;
10111     const enum bfd_reloc_code_real rel[2];
10112     const i386_operand_type types64;
10113   }
10114   gotrel[] =
10115   {
10116     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
10117                                           BFD_RELOC_32_SECREL },
10118       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10119   };
10120
10121   char *cp;
10122   unsigned j;
10123
10124   for (cp = input_line_pointer; *cp != '@'; cp++)
10125     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
10126       return NULL;
10127
10128   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
10129     {
10130       int len = gotrel[j].len;
10131
10132       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
10133         {
10134           if (gotrel[j].rel[object_64bit] != 0)
10135             {
10136               int first, second;
10137               char *tmpbuf, *past_reloc;
10138
10139               *rel = gotrel[j].rel[object_64bit];
10140               if (adjust)
10141                 *adjust = len;
10142
10143               if (types)
10144                 {
10145                   if (flag_code != CODE_64BIT)
10146                     {
10147                       types->bitfield.imm32 = 1;
10148                       types->bitfield.disp32 = 1;
10149                     }
10150                   else
10151                     *types = gotrel[j].types64;
10152                 }
10153
10154               /* The length of the first part of our input line.  */
10155               first = cp - input_line_pointer;
10156
10157               /* The second part goes from after the reloc token until
10158                  (and including) an end_of_line char or comma.  */
10159               past_reloc = cp + 1 + len;
10160               cp = past_reloc;
10161               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
10162                 ++cp;
10163               second = cp + 1 - past_reloc;
10164
10165               /* Allocate and copy string.  The trailing NUL shouldn't
10166                  be necessary, but be safe.  */
10167               tmpbuf = XNEWVEC (char, first + second + 2);
10168               memcpy (tmpbuf, input_line_pointer, first);
10169               if (second != 0 && *past_reloc != ' ')
10170                 /* Replace the relocation token with ' ', so that
10171                    errors like foo@SECLREL321 will be detected.  */
10172                 tmpbuf[first++] = ' ';
10173               memcpy (tmpbuf + first, past_reloc, second);
10174               tmpbuf[first + second] = '\0';
10175               return tmpbuf;
10176             }
10177
10178           as_bad (_("@%s reloc is not supported with %d-bit output format"),
10179                   gotrel[j].str, 1 << (5 + object_64bit));
10180           return NULL;
10181         }
10182     }
10183
10184   /* Might be a symbol version string.  Don't as_bad here.  */
10185   return NULL;
10186 }
10187
10188 #endif /* TE_PE */
10189
10190 bfd_reloc_code_real_type
10191 x86_cons (expressionS *exp, int size)
10192 {
10193   bfd_reloc_code_real_type got_reloc = NO_RELOC;
10194
10195   intel_syntax = -intel_syntax;
10196
10197   exp->X_md = 0;
10198   if (size == 4 || (object_64bit && size == 8))
10199     {
10200       /* Handle @GOTOFF and the like in an expression.  */
10201       char *save;
10202       char *gotfree_input_line;
10203       int adjust = 0;
10204
10205       save = input_line_pointer;
10206       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
10207       if (gotfree_input_line)
10208         input_line_pointer = gotfree_input_line;
10209
10210       expression (exp);
10211
10212       if (gotfree_input_line)
10213         {
10214           /* expression () has merrily parsed up to the end of line,
10215              or a comma - in the wrong buffer.  Transfer how far
10216              input_line_pointer has moved to the right buffer.  */
10217           input_line_pointer = (save
10218                                 + (input_line_pointer - gotfree_input_line)
10219                                 + adjust);
10220           free (gotfree_input_line);
10221           if (exp->X_op == O_constant
10222               || exp->X_op == O_absent
10223               || exp->X_op == O_illegal
10224               || exp->X_op == O_register
10225               || exp->X_op == O_big)
10226             {
10227               char c = *input_line_pointer;
10228               *input_line_pointer = 0;
10229               as_bad (_("missing or invalid expression `%s'"), save);
10230               *input_line_pointer = c;
10231             }
10232           else if ((got_reloc == BFD_RELOC_386_PLT32
10233                     || got_reloc == BFD_RELOC_X86_64_PLT32)
10234                    && exp->X_op != O_symbol)
10235             {
10236               char c = *input_line_pointer;
10237               *input_line_pointer = 0;
10238               as_bad (_("invalid PLT expression `%s'"), save);
10239               *input_line_pointer = c;
10240             }
10241         }
10242     }
10243   else
10244     expression (exp);
10245
10246   intel_syntax = -intel_syntax;
10247
10248   if (intel_syntax)
10249     i386_intel_simplify (exp);
10250
10251   return got_reloc;
10252 }
10253
10254 static void
10255 signed_cons (int size)
10256 {
10257   if (flag_code == CODE_64BIT)
10258     cons_sign = 1;
10259   cons (size);
10260   cons_sign = -1;
10261 }
10262
10263 #ifdef TE_PE
10264 static void
10265 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
10266 {
10267   expressionS exp;
10268
10269   do
10270     {
10271       expression (&exp);
10272       if (exp.X_op == O_symbol)
10273         exp.X_op = O_secrel;
10274
10275       emit_expr (&exp, 4);
10276     }
10277   while (*input_line_pointer++ == ',');
10278
10279   input_line_pointer--;
10280   demand_empty_rest_of_line ();
10281 }
10282 #endif
10283
10284 /* Handle Vector operations.  */
10285
10286 static char *
10287 check_VecOperations (char *op_string, char *op_end)
10288 {
10289   const reg_entry *mask;
10290   const char *saved;
10291   char *end_op;
10292
10293   while (*op_string
10294          && (op_end == NULL || op_string < op_end))
10295     {
10296       saved = op_string;
10297       if (*op_string == '{')
10298         {
10299           op_string++;
10300
10301           /* Check broadcasts.  */
10302           if (strncmp (op_string, "1to", 3) == 0)
10303             {
10304               int bcst_type;
10305
10306               if (i.broadcast)
10307                 goto duplicated_vec_op;
10308
10309               op_string += 3;
10310               if (*op_string == '8')
10311                 bcst_type = 8;
10312               else if (*op_string == '4')
10313                 bcst_type = 4;
10314               else if (*op_string == '2')
10315                 bcst_type = 2;
10316               else if (*op_string == '1'
10317                        && *(op_string+1) == '6')
10318                 {
10319                   bcst_type = 16;
10320                   op_string++;
10321                 }
10322               else
10323                 {
10324                   as_bad (_("Unsupported broadcast: `%s'"), saved);
10325                   return NULL;
10326                 }
10327               op_string++;
10328
10329               broadcast_op.type = bcst_type;
10330               broadcast_op.operand = this_operand;
10331               broadcast_op.bytes = 0;
10332               i.broadcast = &broadcast_op;
10333             }
10334           /* Check masking operation.  */
10335           else if ((mask = parse_register (op_string, &end_op)) != NULL)
10336             {
10337               if (mask == &bad_reg)
10338                 return NULL;
10339
10340               /* k0 can't be used for write mask.  */
10341               if (mask->reg_type.bitfield.class != RegMask || !mask->reg_num)
10342                 {
10343                   as_bad (_("`%s%s' can't be used for write mask"),
10344                           register_prefix, mask->reg_name);
10345                   return NULL;
10346                 }
10347
10348               if (!i.mask)
10349                 {
10350                   mask_op.mask = mask;
10351                   mask_op.zeroing = 0;
10352                   mask_op.operand = this_operand;
10353                   i.mask = &mask_op;
10354                 }
10355               else
10356                 {
10357                   if (i.mask->mask)
10358                     goto duplicated_vec_op;
10359
10360                   i.mask->mask = mask;
10361
10362                   /* Only "{z}" is allowed here.  No need to check
10363                      zeroing mask explicitly.  */
10364                   if (i.mask->operand != this_operand)
10365                     {
10366                       as_bad (_("invalid write mask `%s'"), saved);
10367                       return NULL;
10368                     }
10369                 }
10370
10371               op_string = end_op;
10372             }
10373           /* Check zeroing-flag for masking operation.  */
10374           else if (*op_string == 'z')
10375             {
10376               if (!i.mask)
10377                 {
10378                   mask_op.mask = NULL;
10379                   mask_op.zeroing = 1;
10380                   mask_op.operand = this_operand;
10381                   i.mask = &mask_op;
10382                 }
10383               else
10384                 {
10385                   if (i.mask->zeroing)
10386                     {
10387                     duplicated_vec_op:
10388                       as_bad (_("duplicated `%s'"), saved);
10389                       return NULL;
10390                     }
10391
10392                   i.mask->zeroing = 1;
10393
10394                   /* Only "{%k}" is allowed here.  No need to check mask
10395                      register explicitly.  */
10396                   if (i.mask->operand != this_operand)
10397                     {
10398                       as_bad (_("invalid zeroing-masking `%s'"),
10399                               saved);
10400                       return NULL;
10401                     }
10402                 }
10403
10404               op_string++;
10405             }
10406           else
10407             goto unknown_vec_op;
10408
10409           if (*op_string != '}')
10410             {
10411               as_bad (_("missing `}' in `%s'"), saved);
10412               return NULL;
10413             }
10414           op_string++;
10415
10416           /* Strip whitespace since the addition of pseudo prefixes
10417              changed how the scrubber treats '{'.  */
10418           if (is_space_char (*op_string))
10419             ++op_string;
10420
10421           continue;
10422         }
10423     unknown_vec_op:
10424       /* We don't know this one.  */
10425       as_bad (_("unknown vector operation: `%s'"), saved);
10426       return NULL;
10427     }
10428
10429   if (i.mask && i.mask->zeroing && !i.mask->mask)
10430     {
10431       as_bad (_("zeroing-masking only allowed with write mask"));
10432       return NULL;
10433     }
10434
10435   return op_string;
10436 }
10437
10438 static int
10439 i386_immediate (char *imm_start)
10440 {
10441   char *save_input_line_pointer;
10442   char *gotfree_input_line;
10443   segT exp_seg = 0;
10444   expressionS *exp;
10445   i386_operand_type types;
10446
10447   operand_type_set (&types, ~0);
10448
10449   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
10450     {
10451       as_bad (_("at most %d immediate operands are allowed"),
10452               MAX_IMMEDIATE_OPERANDS);
10453       return 0;
10454     }
10455
10456   exp = &im_expressions[i.imm_operands++];
10457   i.op[this_operand].imms = exp;
10458
10459   if (is_space_char (*imm_start))
10460     ++imm_start;
10461
10462   save_input_line_pointer = input_line_pointer;
10463   input_line_pointer = imm_start;
10464
10465   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
10466   if (gotfree_input_line)
10467     input_line_pointer = gotfree_input_line;
10468
10469   exp_seg = expression (exp);
10470
10471   SKIP_WHITESPACE ();
10472
10473   /* Handle vector operations.  */
10474   if (*input_line_pointer == '{')
10475     {
10476       input_line_pointer = check_VecOperations (input_line_pointer,
10477                                                 NULL);
10478       if (input_line_pointer == NULL)
10479         return 0;
10480     }
10481
10482   if (*input_line_pointer)
10483     as_bad (_("junk `%s' after expression"), input_line_pointer);
10484
10485   input_line_pointer = save_input_line_pointer;
10486   if (gotfree_input_line)
10487     {
10488       free (gotfree_input_line);
10489
10490       if (exp->X_op == O_constant || exp->X_op == O_register)
10491         exp->X_op = O_illegal;
10492     }
10493
10494   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
10495 }
10496
10497 static int
10498 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
10499                          i386_operand_type types, const char *imm_start)
10500 {
10501   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
10502     {
10503       if (imm_start)
10504         as_bad (_("missing or invalid immediate expression `%s'"),
10505                 imm_start);
10506       return 0;
10507     }
10508   else if (exp->X_op == O_constant)
10509     {
10510       /* Size it properly later.  */
10511       i.types[this_operand].bitfield.imm64 = 1;
10512       /* If not 64bit, sign extend val.  */
10513       if (flag_code != CODE_64BIT
10514           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
10515         exp->X_add_number
10516           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
10517     }
10518 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10519   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
10520            && exp_seg != absolute_section
10521            && exp_seg != text_section
10522            && exp_seg != data_section
10523            && exp_seg != bss_section
10524            && exp_seg != undefined_section
10525            && !bfd_is_com_section (exp_seg))
10526     {
10527       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
10528       return 0;
10529     }
10530 #endif
10531   else if (!intel_syntax && exp_seg == reg_section)
10532     {
10533       if (imm_start)
10534         as_bad (_("illegal immediate register operand %s"), imm_start);
10535       return 0;
10536     }
10537   else
10538     {
10539       /* This is an address.  The size of the address will be
10540          determined later, depending on destination register,
10541          suffix, or the default for the section.  */
10542       i.types[this_operand].bitfield.imm8 = 1;
10543       i.types[this_operand].bitfield.imm16 = 1;
10544       i.types[this_operand].bitfield.imm32 = 1;
10545       i.types[this_operand].bitfield.imm32s = 1;
10546       i.types[this_operand].bitfield.imm64 = 1;
10547       i.types[this_operand] = operand_type_and (i.types[this_operand],
10548                                                 types);
10549     }
10550
10551   return 1;
10552 }
10553
10554 static char *
10555 i386_scale (char *scale)
10556 {
10557   offsetT val;
10558   char *save = input_line_pointer;
10559
10560   input_line_pointer = scale;
10561   val = get_absolute_expression ();
10562
10563   switch (val)
10564     {
10565     case 1:
10566       i.log2_scale_factor = 0;
10567       break;
10568     case 2:
10569       i.log2_scale_factor = 1;
10570       break;
10571     case 4:
10572       i.log2_scale_factor = 2;
10573       break;
10574     case 8:
10575       i.log2_scale_factor = 3;
10576       break;
10577     default:
10578       {
10579         char sep = *input_line_pointer;
10580
10581         *input_line_pointer = '\0';
10582         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
10583                 scale);
10584         *input_line_pointer = sep;
10585         input_line_pointer = save;
10586         return NULL;
10587       }
10588     }
10589   if (i.log2_scale_factor != 0 && i.index_reg == 0)
10590     {
10591       as_warn (_("scale factor of %d without an index register"),
10592                1 << i.log2_scale_factor);
10593       i.log2_scale_factor = 0;
10594     }
10595   scale = input_line_pointer;
10596   input_line_pointer = save;
10597   return scale;
10598 }
10599
10600 static int
10601 i386_displacement (char *disp_start, char *disp_end)
10602 {
10603   expressionS *exp;
10604   segT exp_seg = 0;
10605   char *save_input_line_pointer;
10606   char *gotfree_input_line;
10607   int override;
10608   i386_operand_type bigdisp, types = anydisp;
10609   int ret;
10610
10611   if (i.disp_operands == MAX_MEMORY_OPERANDS)
10612     {
10613       as_bad (_("at most %d displacement operands are allowed"),
10614               MAX_MEMORY_OPERANDS);
10615       return 0;
10616     }
10617
10618   operand_type_set (&bigdisp, 0);
10619   if (i.jumpabsolute
10620       || i.types[this_operand].bitfield.baseindex
10621       || (current_templates->start->opcode_modifier.jump != JUMP
10622           && current_templates->start->opcode_modifier.jump != JUMP_DWORD))
10623     {
10624       i386_addressing_mode ();
10625       override = (i.prefix[ADDR_PREFIX] != 0);
10626       if (flag_code == CODE_64BIT)
10627         {
10628           if (!override)
10629             {
10630               bigdisp.bitfield.disp32s = 1;
10631               bigdisp.bitfield.disp64 = 1;
10632             }
10633           else
10634             bigdisp.bitfield.disp32 = 1;
10635         }
10636       else if ((flag_code == CODE_16BIT) ^ override)
10637           bigdisp.bitfield.disp16 = 1;
10638       else
10639           bigdisp.bitfield.disp32 = 1;
10640     }
10641   else
10642     {
10643       /* For PC-relative branches, the width of the displacement may be
10644          dependent upon data size, but is never dependent upon address size.
10645          Also make sure to not unintentionally match against a non-PC-relative
10646          branch template.  */
10647       static templates aux_templates;
10648       const insn_template *t = current_templates->start;
10649       bfd_boolean has_intel64 = FALSE;
10650
10651       aux_templates.start = t;
10652       while (++t < current_templates->end)
10653         {
10654           if (t->opcode_modifier.jump
10655               != current_templates->start->opcode_modifier.jump)
10656             break;
10657           if ((t->opcode_modifier.isa64 >= INTEL64))
10658             has_intel64 = TRUE;
10659         }
10660       if (t < current_templates->end)
10661         {
10662           aux_templates.end = t;
10663           current_templates = &aux_templates;
10664         }
10665
10666       override = (i.prefix[DATA_PREFIX] != 0);
10667       if (flag_code == CODE_64BIT)
10668         {
10669           if ((override || i.suffix == WORD_MNEM_SUFFIX)
10670               && (!intel64 || !has_intel64))
10671             bigdisp.bitfield.disp16 = 1;
10672           else
10673             bigdisp.bitfield.disp32s = 1;
10674         }
10675       else
10676         {
10677           if (!override)
10678             override = (i.suffix == (flag_code != CODE_16BIT
10679                                      ? WORD_MNEM_SUFFIX
10680                                      : LONG_MNEM_SUFFIX));
10681           bigdisp.bitfield.disp32 = 1;
10682           if ((flag_code == CODE_16BIT) ^ override)
10683             {
10684               bigdisp.bitfield.disp32 = 0;
10685               bigdisp.bitfield.disp16 = 1;
10686             }
10687         }
10688     }
10689   i.types[this_operand] = operand_type_or (i.types[this_operand],
10690                                            bigdisp);
10691
10692   exp = &disp_expressions[i.disp_operands];
10693   i.op[this_operand].disps = exp;
10694   i.disp_operands++;
10695   save_input_line_pointer = input_line_pointer;
10696   input_line_pointer = disp_start;
10697   END_STRING_AND_SAVE (disp_end);
10698
10699 #ifndef GCC_ASM_O_HACK
10700 #define GCC_ASM_O_HACK 0
10701 #endif
10702 #if GCC_ASM_O_HACK
10703   END_STRING_AND_SAVE (disp_end + 1);
10704   if (i.types[this_operand].bitfield.baseIndex
10705       && displacement_string_end[-1] == '+')
10706     {
10707       /* This hack is to avoid a warning when using the "o"
10708          constraint within gcc asm statements.
10709          For instance:
10710
10711          #define _set_tssldt_desc(n,addr,limit,type) \
10712          __asm__ __volatile__ ( \
10713          "movw %w2,%0\n\t" \
10714          "movw %w1,2+%0\n\t" \
10715          "rorl $16,%1\n\t" \
10716          "movb %b1,4+%0\n\t" \
10717          "movb %4,5+%0\n\t" \
10718          "movb $0,6+%0\n\t" \
10719          "movb %h1,7+%0\n\t" \
10720          "rorl $16,%1" \
10721          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
10722
10723          This works great except that the output assembler ends
10724          up looking a bit weird if it turns out that there is
10725          no offset.  You end up producing code that looks like:
10726
10727          #APP
10728          movw $235,(%eax)
10729          movw %dx,2+(%eax)
10730          rorl $16,%edx
10731          movb %dl,4+(%eax)
10732          movb $137,5+(%eax)
10733          movb $0,6+(%eax)
10734          movb %dh,7+(%eax)
10735          rorl $16,%edx
10736          #NO_APP
10737
10738          So here we provide the missing zero.  */
10739
10740       *displacement_string_end = '0';
10741     }
10742 #endif
10743   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
10744   if (gotfree_input_line)
10745     input_line_pointer = gotfree_input_line;
10746
10747   exp_seg = expression (exp);
10748
10749   SKIP_WHITESPACE ();
10750   if (*input_line_pointer)
10751     as_bad (_("junk `%s' after expression"), input_line_pointer);
10752 #if GCC_ASM_O_HACK
10753   RESTORE_END_STRING (disp_end + 1);
10754 #endif
10755   input_line_pointer = save_input_line_pointer;
10756   if (gotfree_input_line)
10757     {
10758       free (gotfree_input_line);
10759
10760       if (exp->X_op == O_constant || exp->X_op == O_register)
10761         exp->X_op = O_illegal;
10762     }
10763
10764   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
10765
10766   RESTORE_END_STRING (disp_end);
10767
10768   return ret;
10769 }
10770
10771 static int
10772 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
10773                             i386_operand_type types, const char *disp_start)
10774 {
10775   i386_operand_type bigdisp;
10776   int ret = 1;
10777
10778   /* We do this to make sure that the section symbol is in
10779      the symbol table.  We will ultimately change the relocation
10780      to be relative to the beginning of the section.  */
10781   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
10782       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
10783       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
10784     {
10785       if (exp->X_op != O_symbol)
10786         goto inv_disp;
10787
10788       if (S_IS_LOCAL (exp->X_add_symbol)
10789           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
10790           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
10791         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
10792       exp->X_op = O_subtract;
10793       exp->X_op_symbol = GOT_symbol;
10794       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
10795         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
10796       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
10797         i.reloc[this_operand] = BFD_RELOC_64;
10798       else
10799         i.reloc[this_operand] = BFD_RELOC_32;
10800     }
10801
10802   else if (exp->X_op == O_absent
10803            || exp->X_op == O_illegal
10804            || exp->X_op == O_big)
10805     {
10806     inv_disp:
10807       as_bad (_("missing or invalid displacement expression `%s'"),
10808               disp_start);
10809       ret = 0;
10810     }
10811
10812   else if (flag_code == CODE_64BIT
10813            && !i.prefix[ADDR_PREFIX]
10814            && exp->X_op == O_constant)
10815     {
10816       /* Since displacement is signed extended to 64bit, don't allow
10817          disp32 and turn off disp32s if they are out of range.  */
10818       i.types[this_operand].bitfield.disp32 = 0;
10819       if (!fits_in_signed_long (exp->X_add_number))
10820         {
10821           i.types[this_operand].bitfield.disp32s = 0;
10822           if (i.types[this_operand].bitfield.baseindex)
10823             {
10824               as_bad (_("0x%lx out range of signed 32bit displacement"),
10825                       (long) exp->X_add_number);
10826               ret = 0;
10827             }
10828         }
10829     }
10830
10831 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10832   else if (exp->X_op != O_constant
10833            && OUTPUT_FLAVOR == bfd_target_aout_flavour
10834            && exp_seg != absolute_section
10835            && exp_seg != text_section
10836            && exp_seg != data_section
10837            && exp_seg != bss_section
10838            && exp_seg != undefined_section
10839            && !bfd_is_com_section (exp_seg))
10840     {
10841       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
10842       ret = 0;
10843     }
10844 #endif
10845
10846   if (current_templates->start->opcode_modifier.jump == JUMP_BYTE
10847       /* Constants get taken care of by optimize_disp().  */
10848       && exp->X_op != O_constant)
10849     i.types[this_operand].bitfield.disp8 = 1;
10850
10851   /* Check if this is a displacement only operand.  */
10852   bigdisp = i.types[this_operand];
10853   bigdisp.bitfield.disp8 = 0;
10854   bigdisp.bitfield.disp16 = 0;
10855   bigdisp.bitfield.disp32 = 0;
10856   bigdisp.bitfield.disp32s = 0;
10857   bigdisp.bitfield.disp64 = 0;
10858   if (operand_type_all_zero (&bigdisp))
10859     i.types[this_operand] = operand_type_and (i.types[this_operand],
10860                                               types);
10861
10862   return ret;
10863 }
10864
10865 /* Return the active addressing mode, taking address override and
10866    registers forming the address into consideration.  Update the
10867    address override prefix if necessary.  */
10868
10869 static enum flag_code
10870 i386_addressing_mode (void)
10871 {
10872   enum flag_code addr_mode;
10873
10874   if (i.prefix[ADDR_PREFIX])
10875     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
10876   else if (flag_code == CODE_16BIT
10877            && current_templates->start->cpu_flags.bitfield.cpumpx
10878            /* Avoid replacing the "16-bit addressing not allowed" diagnostic
10879               from md_assemble() by "is not a valid base/index expression"
10880               when there is a base and/or index.  */
10881            && !i.types[this_operand].bitfield.baseindex)
10882     {
10883       /* MPX insn memory operands with neither base nor index must be forced
10884          to use 32-bit addressing in 16-bit mode.  */
10885       addr_mode = CODE_32BIT;
10886       i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
10887       ++i.prefixes;
10888       gas_assert (!i.types[this_operand].bitfield.disp16);
10889       gas_assert (!i.types[this_operand].bitfield.disp32);
10890     }
10891   else
10892     {
10893       addr_mode = flag_code;
10894
10895 #if INFER_ADDR_PREFIX
10896       if (i.mem_operands == 0)
10897         {
10898           /* Infer address prefix from the first memory operand.  */
10899           const reg_entry *addr_reg = i.base_reg;
10900
10901           if (addr_reg == NULL)
10902             addr_reg = i.index_reg;
10903
10904           if (addr_reg)
10905             {
10906               if (addr_reg->reg_type.bitfield.dword)
10907                 addr_mode = CODE_32BIT;
10908               else if (flag_code != CODE_64BIT
10909                        && addr_reg->reg_type.bitfield.word)
10910                 addr_mode = CODE_16BIT;
10911
10912               if (addr_mode != flag_code)
10913                 {
10914                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
10915                   i.prefixes += 1;
10916                   /* Change the size of any displacement too.  At most one
10917                      of Disp16 or Disp32 is set.
10918                      FIXME.  There doesn't seem to be any real need for
10919                      separate Disp16 and Disp32 flags.  The same goes for
10920                      Imm16 and Imm32.  Removing them would probably clean
10921                      up the code quite a lot.  */
10922                   if (flag_code != CODE_64BIT
10923                       && (i.types[this_operand].bitfield.disp16
10924                           || i.types[this_operand].bitfield.disp32))
10925                     i.types[this_operand]
10926                       = operand_type_xor (i.types[this_operand], disp16_32);
10927                 }
10928             }
10929         }
10930 #endif
10931     }
10932
10933   return addr_mode;
10934 }
10935
10936 /* Make sure the memory operand we've been dealt is valid.
10937    Return 1 on success, 0 on a failure.  */
10938
10939 static int
10940 i386_index_check (const char *operand_string)
10941 {
10942   const char *kind = "base/index";
10943   enum flag_code addr_mode = i386_addressing_mode ();
10944
10945   if (current_templates->start->opcode_modifier.isstring
10946       && !current_templates->start->cpu_flags.bitfield.cpupadlock
10947       && (current_templates->end[-1].opcode_modifier.isstring
10948           || i.mem_operands))
10949     {
10950       /* Memory operands of string insns are special in that they only allow
10951          a single register (rDI, rSI, or rBX) as their memory address.  */
10952       const reg_entry *expected_reg;
10953       static const char *di_si[][2] =
10954         {
10955           { "esi", "edi" },
10956           { "si", "di" },
10957           { "rsi", "rdi" }
10958         };
10959       static const char *bx[] = { "ebx", "bx", "rbx" };
10960
10961       kind = "string address";
10962
10963       if (current_templates->start->opcode_modifier.repprefixok)
10964         {
10965           int es_op = current_templates->end[-1].opcode_modifier.isstring
10966                       - IS_STRING_ES_OP0;
10967           int op = 0;
10968
10969           if (!current_templates->end[-1].operand_types[0].bitfield.baseindex
10970               || ((!i.mem_operands != !intel_syntax)
10971                   && current_templates->end[-1].operand_types[1]
10972                      .bitfield.baseindex))
10973             op = 1;
10974           expected_reg = hash_find (reg_hash, di_si[addr_mode][op == es_op]);
10975         }
10976       else
10977         expected_reg = hash_find (reg_hash, bx[addr_mode]);
10978
10979       if (i.base_reg != expected_reg
10980           || i.index_reg
10981           || operand_type_check (i.types[this_operand], disp))
10982         {
10983           /* The second memory operand must have the same size as
10984              the first one.  */
10985           if (i.mem_operands
10986               && i.base_reg
10987               && !((addr_mode == CODE_64BIT
10988                     && i.base_reg->reg_type.bitfield.qword)
10989                    || (addr_mode == CODE_32BIT
10990                        ? i.base_reg->reg_type.bitfield.dword
10991                        : i.base_reg->reg_type.bitfield.word)))
10992             goto bad_address;
10993
10994           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
10995                    operand_string,
10996                    intel_syntax ? '[' : '(',
10997                    register_prefix,
10998                    expected_reg->reg_name,
10999                    intel_syntax ? ']' : ')');
11000           return 1;
11001         }
11002       else
11003         return 1;
11004
11005     bad_address:
11006       as_bad (_("`%s' is not a valid %s expression"),
11007               operand_string, kind);
11008       return 0;
11009     }
11010   else
11011     {
11012       if (addr_mode != CODE_16BIT)
11013         {
11014           /* 32-bit/64-bit checks.  */
11015           if ((i.base_reg
11016                && ((addr_mode == CODE_64BIT
11017                     ? !i.base_reg->reg_type.bitfield.qword
11018                     : !i.base_reg->reg_type.bitfield.dword)
11019                    || (i.index_reg && i.base_reg->reg_num == RegIP)
11020                    || i.base_reg->reg_num == RegIZ))
11021               || (i.index_reg
11022                   && !i.index_reg->reg_type.bitfield.xmmword
11023                   && !i.index_reg->reg_type.bitfield.ymmword
11024                   && !i.index_reg->reg_type.bitfield.zmmword
11025                   && ((addr_mode == CODE_64BIT
11026                        ? !i.index_reg->reg_type.bitfield.qword
11027                        : !i.index_reg->reg_type.bitfield.dword)
11028                       || !i.index_reg->reg_type.bitfield.baseindex)))
11029             goto bad_address;
11030
11031           /* bndmk, bndldx, bndstx and mandatory non-vector SIB have special restrictions. */
11032           if (current_templates->start->base_opcode == 0xf30f1b
11033               || (current_templates->start->base_opcode & ~1) == 0x0f1a
11034               || current_templates->start->opcode_modifier.sib == SIBMEM)
11035             {
11036               /* They cannot use RIP-relative addressing. */
11037               if (i.base_reg && i.base_reg->reg_num == RegIP)
11038                 {
11039                   as_bad (_("`%s' cannot be used here"), operand_string);
11040                   return 0;
11041                 }
11042
11043               /* bndldx and bndstx ignore their scale factor. */
11044               if ((current_templates->start->base_opcode & ~1) == 0x0f1a
11045                   && i.log2_scale_factor)
11046                 as_warn (_("register scaling is being ignored here"));
11047             }
11048         }
11049       else
11050         {
11051           /* 16-bit checks.  */
11052           if ((i.base_reg
11053                && (!i.base_reg->reg_type.bitfield.word
11054                    || !i.base_reg->reg_type.bitfield.baseindex))
11055               || (i.index_reg
11056                   && (!i.index_reg->reg_type.bitfield.word
11057                       || !i.index_reg->reg_type.bitfield.baseindex
11058                       || !(i.base_reg
11059                            && i.base_reg->reg_num < 6
11060                            && i.index_reg->reg_num >= 6
11061                            && i.log2_scale_factor == 0))))
11062             goto bad_address;
11063         }
11064     }
11065   return 1;
11066 }
11067
11068 /* Handle vector immediates.  */
11069
11070 static int
11071 RC_SAE_immediate (const char *imm_start)
11072 {
11073   unsigned int match_found, j;
11074   const char *pstr = imm_start;
11075   expressionS *exp;
11076
11077   if (*pstr != '{')
11078     return 0;
11079
11080   pstr++;
11081   match_found = 0;
11082   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
11083     {
11084       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
11085         {
11086           if (!i.rounding)
11087             {
11088               rc_op.type = RC_NamesTable[j].type;
11089               rc_op.operand = this_operand;
11090               i.rounding = &rc_op;
11091             }
11092           else
11093             {
11094               as_bad (_("duplicated `%s'"), imm_start);
11095               return 0;
11096             }
11097           pstr += RC_NamesTable[j].len;
11098           match_found = 1;
11099           break;
11100         }
11101     }
11102   if (!match_found)
11103     return 0;
11104
11105   if (*pstr++ != '}')
11106     {
11107       as_bad (_("Missing '}': '%s'"), imm_start);
11108       return 0;
11109     }
11110   /* RC/SAE immediate string should contain nothing more.  */;
11111   if (*pstr != 0)
11112     {
11113       as_bad (_("Junk after '}': '%s'"), imm_start);
11114       return 0;
11115     }
11116
11117   exp = &im_expressions[i.imm_operands++];
11118   i.op[this_operand].imms = exp;
11119
11120   exp->X_op = O_constant;
11121   exp->X_add_number = 0;
11122   exp->X_add_symbol = (symbolS *) 0;
11123   exp->X_op_symbol = (symbolS *) 0;
11124
11125   i.types[this_operand].bitfield.imm8 = 1;
11126   return 1;
11127 }
11128
11129 /* Only string instructions can have a second memory operand, so
11130    reduce current_templates to just those if it contains any.  */
11131 static int
11132 maybe_adjust_templates (void)
11133 {
11134   const insn_template *t;
11135
11136   gas_assert (i.mem_operands == 1);
11137
11138   for (t = current_templates->start; t < current_templates->end; ++t)
11139     if (t->opcode_modifier.isstring)
11140       break;
11141
11142   if (t < current_templates->end)
11143     {
11144       static templates aux_templates;
11145       bfd_boolean recheck;
11146
11147       aux_templates.start = t;
11148       for (; t < current_templates->end; ++t)
11149         if (!t->opcode_modifier.isstring)
11150           break;
11151       aux_templates.end = t;
11152
11153       /* Determine whether to re-check the first memory operand.  */
11154       recheck = (aux_templates.start != current_templates->start
11155                  || t != current_templates->end);
11156
11157       current_templates = &aux_templates;
11158
11159       if (recheck)
11160         {
11161           i.mem_operands = 0;
11162           if (i.memop1_string != NULL
11163               && i386_index_check (i.memop1_string) == 0)
11164             return 0;
11165           i.mem_operands = 1;
11166         }
11167     }
11168
11169   return 1;
11170 }
11171
11172 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
11173    on error.  */
11174
11175 static int
11176 i386_att_operand (char *operand_string)
11177 {
11178   const reg_entry *r;
11179   char *end_op;
11180   char *op_string = operand_string;
11181
11182   if (is_space_char (*op_string))
11183     ++op_string;
11184
11185   /* We check for an absolute prefix (differentiating,
11186      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
11187   if (*op_string == ABSOLUTE_PREFIX)
11188     {
11189       ++op_string;
11190       if (is_space_char (*op_string))
11191         ++op_string;
11192       i.jumpabsolute = TRUE;
11193     }
11194
11195   /* Check if operand is a register.  */
11196   if ((r = parse_register (op_string, &end_op)) != NULL)
11197     {
11198       i386_operand_type temp;
11199
11200       if (r == &bad_reg)
11201         return 0;
11202
11203       /* Check for a segment override by searching for ':' after a
11204          segment register.  */
11205       op_string = end_op;
11206       if (is_space_char (*op_string))
11207         ++op_string;
11208       if (*op_string == ':' && r->reg_type.bitfield.class == SReg)
11209         {
11210           switch (r->reg_num)
11211             {
11212             case 0:
11213               i.seg[i.mem_operands] = &es;
11214               break;
11215             case 1:
11216               i.seg[i.mem_operands] = &cs;
11217               break;
11218             case 2:
11219               i.seg[i.mem_operands] = &ss;
11220               break;
11221             case 3:
11222               i.seg[i.mem_operands] = &ds;
11223               break;
11224             case 4:
11225               i.seg[i.mem_operands] = &fs;
11226               break;
11227             case 5:
11228               i.seg[i.mem_operands] = &gs;
11229               break;
11230             }
11231
11232           /* Skip the ':' and whitespace.  */
11233           ++op_string;
11234           if (is_space_char (*op_string))
11235             ++op_string;
11236
11237           if (!is_digit_char (*op_string)
11238               && !is_identifier_char (*op_string)
11239               && *op_string != '('
11240               && *op_string != ABSOLUTE_PREFIX)
11241             {
11242               as_bad (_("bad memory operand `%s'"), op_string);
11243               return 0;
11244             }
11245           /* Handle case of %es:*foo.  */
11246           if (*op_string == ABSOLUTE_PREFIX)
11247             {
11248               ++op_string;
11249               if (is_space_char (*op_string))
11250                 ++op_string;
11251               i.jumpabsolute = TRUE;
11252             }
11253           goto do_memory_reference;
11254         }
11255
11256       /* Handle vector operations.  */
11257       if (*op_string == '{')
11258         {
11259           op_string = check_VecOperations (op_string, NULL);
11260           if (op_string == NULL)
11261             return 0;
11262         }
11263
11264       if (*op_string)
11265         {
11266           as_bad (_("junk `%s' after register"), op_string);
11267           return 0;
11268         }
11269       temp = r->reg_type;
11270       temp.bitfield.baseindex = 0;
11271       i.types[this_operand] = operand_type_or (i.types[this_operand],
11272                                                temp);
11273       i.types[this_operand].bitfield.unspecified = 0;
11274       i.op[this_operand].regs = r;
11275       i.reg_operands++;
11276     }
11277   else if (*op_string == REGISTER_PREFIX)
11278     {
11279       as_bad (_("bad register name `%s'"), op_string);
11280       return 0;
11281     }
11282   else if (*op_string == IMMEDIATE_PREFIX)
11283     {
11284       ++op_string;
11285       if (i.jumpabsolute)
11286         {
11287           as_bad (_("immediate operand illegal with absolute jump"));
11288           return 0;
11289         }
11290       if (!i386_immediate (op_string))
11291         return 0;
11292     }
11293   else if (RC_SAE_immediate (operand_string))
11294     {
11295       /* If it is a RC or SAE immediate, do nothing.  */
11296       ;
11297     }
11298   else if (is_digit_char (*op_string)
11299            || is_identifier_char (*op_string)
11300            || *op_string == '"'
11301            || *op_string == '(')
11302     {
11303       /* This is a memory reference of some sort.  */
11304       char *base_string;
11305
11306       /* Start and end of displacement string expression (if found).  */
11307       char *displacement_string_start;
11308       char *displacement_string_end;
11309       char *vop_start;
11310
11311     do_memory_reference:
11312       if (i.mem_operands == 1 && !maybe_adjust_templates ())
11313         return 0;
11314       if ((i.mem_operands == 1
11315            && !current_templates->start->opcode_modifier.isstring)
11316           || i.mem_operands == 2)
11317         {
11318           as_bad (_("too many memory references for `%s'"),
11319                   current_templates->start->name);
11320           return 0;
11321         }
11322
11323       /* Check for base index form.  We detect the base index form by
11324          looking for an ')' at the end of the operand, searching
11325          for the '(' matching it, and finding a REGISTER_PREFIX or ','
11326          after the '('.  */
11327       base_string = op_string + strlen (op_string);
11328
11329       /* Handle vector operations.  */
11330       vop_start = strchr (op_string, '{');
11331       if (vop_start && vop_start < base_string)
11332         {
11333           if (check_VecOperations (vop_start, base_string) == NULL)
11334             return 0;
11335           base_string = vop_start;
11336         }
11337
11338       --base_string;
11339       if (is_space_char (*base_string))
11340         --base_string;
11341
11342       /* If we only have a displacement, set-up for it to be parsed later.  */
11343       displacement_string_start = op_string;
11344       displacement_string_end = base_string + 1;
11345
11346       if (*base_string == ')')
11347         {
11348           char *temp_string;
11349           unsigned int parens_balanced = 1;
11350           /* We've already checked that the number of left & right ()'s are
11351              equal, so this loop will not be infinite.  */
11352           do
11353             {
11354               base_string--;
11355               if (*base_string == ')')
11356                 parens_balanced++;
11357               if (*base_string == '(')
11358                 parens_balanced--;
11359             }
11360           while (parens_balanced);
11361
11362           temp_string = base_string;
11363
11364           /* Skip past '(' and whitespace.  */
11365           ++base_string;
11366           if (is_space_char (*base_string))
11367             ++base_string;
11368
11369           if (*base_string == ','
11370               || ((i.base_reg = parse_register (base_string, &end_op))
11371                   != NULL))
11372             {
11373               displacement_string_end = temp_string;
11374
11375               i.types[this_operand].bitfield.baseindex = 1;
11376
11377               if (i.base_reg)
11378                 {
11379                   if (i.base_reg == &bad_reg)
11380                     return 0;
11381                   base_string = end_op;
11382                   if (is_space_char (*base_string))
11383                     ++base_string;
11384                 }
11385
11386               /* There may be an index reg or scale factor here.  */
11387               if (*base_string == ',')
11388                 {
11389                   ++base_string;
11390                   if (is_space_char (*base_string))
11391                     ++base_string;
11392
11393                   if ((i.index_reg = parse_register (base_string, &end_op))
11394                       != NULL)
11395                     {
11396                       if (i.index_reg == &bad_reg)
11397                         return 0;
11398                       base_string = end_op;
11399                       if (is_space_char (*base_string))
11400                         ++base_string;
11401                       if (*base_string == ',')
11402                         {
11403                           ++base_string;
11404                           if (is_space_char (*base_string))
11405                             ++base_string;
11406                         }
11407                       else if (*base_string != ')')
11408                         {
11409                           as_bad (_("expecting `,' or `)' "
11410                                     "after index register in `%s'"),
11411                                   operand_string);
11412                           return 0;
11413                         }
11414                     }
11415                   else if (*base_string == REGISTER_PREFIX)
11416                     {
11417                       end_op = strchr (base_string, ',');
11418                       if (end_op)
11419                         *end_op = '\0';
11420                       as_bad (_("bad register name `%s'"), base_string);
11421                       return 0;
11422                     }
11423
11424                   /* Check for scale factor.  */
11425                   if (*base_string != ')')
11426                     {
11427                       char *end_scale = i386_scale (base_string);
11428
11429                       if (!end_scale)
11430                         return 0;
11431
11432                       base_string = end_scale;
11433                       if (is_space_char (*base_string))
11434                         ++base_string;
11435                       if (*base_string != ')')
11436                         {
11437                           as_bad (_("expecting `)' "
11438                                     "after scale factor in `%s'"),
11439                                   operand_string);
11440                           return 0;
11441                         }
11442                     }
11443                   else if (!i.index_reg)
11444                     {
11445                       as_bad (_("expecting index register or scale factor "
11446                                 "after `,'; got '%c'"),
11447                               *base_string);
11448                       return 0;
11449                     }
11450                 }
11451               else if (*base_string != ')')
11452                 {
11453                   as_bad (_("expecting `,' or `)' "
11454                             "after base register in `%s'"),
11455                           operand_string);
11456                   return 0;
11457                 }
11458             }
11459           else if (*base_string == REGISTER_PREFIX)
11460             {
11461               end_op = strchr (base_string, ',');
11462               if (end_op)
11463                 *end_op = '\0';
11464               as_bad (_("bad register name `%s'"), base_string);
11465               return 0;
11466             }
11467         }
11468
11469       /* If there's an expression beginning the operand, parse it,
11470          assuming displacement_string_start and
11471          displacement_string_end are meaningful.  */
11472       if (displacement_string_start != displacement_string_end)
11473         {
11474           if (!i386_displacement (displacement_string_start,
11475                                   displacement_string_end))
11476             return 0;
11477         }
11478
11479       /* Special case for (%dx) while doing input/output op.  */
11480       if (i.base_reg
11481           && i.base_reg->reg_type.bitfield.instance == RegD
11482           && i.base_reg->reg_type.bitfield.word
11483           && i.index_reg == 0
11484           && i.log2_scale_factor == 0
11485           && i.seg[i.mem_operands] == 0
11486           && !operand_type_check (i.types[this_operand], disp))
11487         {
11488           i.types[this_operand] = i.base_reg->reg_type;
11489           return 1;
11490         }
11491
11492       if (i386_index_check (operand_string) == 0)
11493         return 0;
11494       i.flags[this_operand] |= Operand_Mem;
11495       if (i.mem_operands == 0)
11496         i.memop1_string = xstrdup (operand_string);
11497       i.mem_operands++;
11498     }
11499   else
11500     {
11501       /* It's not a memory operand; argh!  */
11502       as_bad (_("invalid char %s beginning operand %d `%s'"),
11503               output_invalid (*op_string),
11504               this_operand + 1,
11505               op_string);
11506       return 0;
11507     }
11508   return 1;                     /* Normal return.  */
11509 }
11510 \f
11511 /* Calculate the maximum variable size (i.e., excluding fr_fix)
11512    that an rs_machine_dependent frag may reach.  */
11513
11514 unsigned int
11515 i386_frag_max_var (fragS *frag)
11516 {
11517   /* The only relaxable frags are for jumps.
11518      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
11519   gas_assert (frag->fr_type == rs_machine_dependent);
11520   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
11521 }
11522
11523 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11524 static int
11525 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
11526 {
11527   /* STT_GNU_IFUNC symbol must go through PLT.  */
11528   if ((symbol_get_bfdsym (fr_symbol)->flags
11529        & BSF_GNU_INDIRECT_FUNCTION) != 0)
11530     return 0;
11531
11532   if (!S_IS_EXTERNAL (fr_symbol))
11533     /* Symbol may be weak or local.  */
11534     return !S_IS_WEAK (fr_symbol);
11535
11536   /* Global symbols with non-default visibility can't be preempted. */
11537   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
11538     return 1;
11539
11540   if (fr_var != NO_RELOC)
11541     switch ((enum bfd_reloc_code_real) fr_var)
11542       {
11543       case BFD_RELOC_386_PLT32:
11544       case BFD_RELOC_X86_64_PLT32:
11545         /* Symbol with PLT relocation may be preempted. */
11546         return 0;
11547       default:
11548         abort ();
11549       }
11550
11551   /* Global symbols with default visibility in a shared library may be
11552      preempted by another definition.  */
11553   return !shared;
11554 }
11555 #endif
11556
11557 /* Table 3-2. Macro-Fusible Instructions in Haswell Microarchitecture
11558    Note also work for Skylake and Cascadelake.
11559 ---------------------------------------------------------------------
11560 |   JCC   | ADD/SUB/CMP | INC/DEC | TEST/AND |
11561 | ------  | ----------- | ------- | -------- |
11562 |   Jo    |      N      |    N    |     Y    |
11563 |   Jno   |      N      |    N    |     Y    |
11564 |  Jc/Jb  |      Y      |    N    |     Y    |
11565 | Jae/Jnb |      Y      |    N    |     Y    |
11566 |  Je/Jz  |      Y      |    Y    |     Y    |
11567 | Jne/Jnz |      Y      |    Y    |     Y    |
11568 | Jna/Jbe |      Y      |    N    |     Y    |
11569 | Ja/Jnbe |      Y      |    N    |     Y    |
11570 |   Js    |      N      |    N    |     Y    |
11571 |   Jns   |      N      |    N    |     Y    |
11572 |  Jp/Jpe |      N      |    N    |     Y    |
11573 | Jnp/Jpo |      N      |    N    |     Y    |
11574 | Jl/Jnge |      Y      |    Y    |     Y    |
11575 | Jge/Jnl |      Y      |    Y    |     Y    |
11576 | Jle/Jng |      Y      |    Y    |     Y    |
11577 | Jg/Jnle |      Y      |    Y    |     Y    |
11578 ---------------------------------------------------------------------  */
11579 static int
11580 i386_macro_fusible_p (enum mf_cmp_kind mf_cmp, enum mf_jcc_kind mf_jcc)
11581 {
11582   if (mf_cmp == mf_cmp_alu_cmp)
11583     return ((mf_jcc >= mf_jcc_jc && mf_jcc <= mf_jcc_jna)
11584             || mf_jcc == mf_jcc_jl || mf_jcc == mf_jcc_jle);
11585   if (mf_cmp == mf_cmp_incdec)
11586     return (mf_jcc == mf_jcc_je || mf_jcc == mf_jcc_jl
11587             || mf_jcc == mf_jcc_jle);
11588   if (mf_cmp == mf_cmp_test_and)
11589     return 1;
11590   return 0;
11591 }
11592
11593 /* Return the next non-empty frag.  */
11594
11595 static fragS *
11596 i386_next_non_empty_frag (fragS *fragP)
11597 {
11598   /* There may be a frag with a ".fill 0" when there is no room in
11599      the current frag for frag_grow in output_insn.  */
11600   for (fragP = fragP->fr_next;
11601        (fragP != NULL
11602         && fragP->fr_type == rs_fill
11603         && fragP->fr_fix == 0);
11604        fragP = fragP->fr_next)
11605     ;
11606   return fragP;
11607 }
11608
11609 /* Return the next jcc frag after BRANCH_PADDING.  */
11610
11611 static fragS *
11612 i386_next_fusible_jcc_frag (fragS *maybe_cmp_fragP, fragS *pad_fragP)
11613 {
11614   fragS *branch_fragP;
11615   if (!pad_fragP)
11616     return NULL;
11617
11618   if (pad_fragP->fr_type == rs_machine_dependent
11619       && (TYPE_FROM_RELAX_STATE (pad_fragP->fr_subtype)
11620           == BRANCH_PADDING))
11621     {
11622       branch_fragP = i386_next_non_empty_frag (pad_fragP);
11623       if (branch_fragP->fr_type != rs_machine_dependent)
11624         return NULL;
11625       if (TYPE_FROM_RELAX_STATE (branch_fragP->fr_subtype) == COND_JUMP
11626           && i386_macro_fusible_p (maybe_cmp_fragP->tc_frag_data.mf_type,
11627                                    pad_fragP->tc_frag_data.mf_type))
11628         return branch_fragP;
11629     }
11630
11631   return NULL;
11632 }
11633
11634 /* Classify BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING frags.  */
11635
11636 static void
11637 i386_classify_machine_dependent_frag (fragS *fragP)
11638 {
11639   fragS *cmp_fragP;
11640   fragS *pad_fragP;
11641   fragS *branch_fragP;
11642   fragS *next_fragP;
11643   unsigned int max_prefix_length;
11644
11645   if (fragP->tc_frag_data.classified)
11646     return;
11647
11648   /* First scan for BRANCH_PADDING and FUSED_JCC_PADDING.  Convert
11649      FUSED_JCC_PADDING and merge BRANCH_PADDING.  */
11650   for (next_fragP = fragP;
11651        next_fragP != NULL;
11652        next_fragP = next_fragP->fr_next)
11653     {
11654       next_fragP->tc_frag_data.classified = 1;
11655       if (next_fragP->fr_type == rs_machine_dependent)
11656         switch (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype))
11657           {
11658           case BRANCH_PADDING:
11659             /* The BRANCH_PADDING frag must be followed by a branch
11660                frag.  */
11661             branch_fragP = i386_next_non_empty_frag (next_fragP);
11662             next_fragP->tc_frag_data.u.branch_fragP = branch_fragP;
11663             break;
11664           case FUSED_JCC_PADDING:
11665             /* Check if this is a fused jcc:
11666                FUSED_JCC_PADDING
11667                CMP like instruction
11668                BRANCH_PADDING
11669                COND_JUMP
11670                */
11671             cmp_fragP = i386_next_non_empty_frag (next_fragP);
11672             pad_fragP = i386_next_non_empty_frag (cmp_fragP);
11673             branch_fragP = i386_next_fusible_jcc_frag (next_fragP, pad_fragP);
11674             if (branch_fragP)
11675               {
11676                 /* The BRANCH_PADDING frag is merged with the
11677                    FUSED_JCC_PADDING frag.  */
11678                 next_fragP->tc_frag_data.u.branch_fragP = branch_fragP;
11679                 /* CMP like instruction size.  */
11680                 next_fragP->tc_frag_data.cmp_size = cmp_fragP->fr_fix;
11681                 frag_wane (pad_fragP);
11682                 /* Skip to branch_fragP.  */
11683                 next_fragP = branch_fragP;
11684               }
11685             else if (next_fragP->tc_frag_data.max_prefix_length)
11686               {
11687                 /* Turn FUSED_JCC_PADDING into BRANCH_PREFIX if it isn't
11688                    a fused jcc.  */
11689                 next_fragP->fr_subtype
11690                   = ENCODE_RELAX_STATE (BRANCH_PREFIX, 0);
11691                 next_fragP->tc_frag_data.max_bytes
11692                   = next_fragP->tc_frag_data.max_prefix_length;
11693                 /* This will be updated in the BRANCH_PREFIX scan.  */
11694                 next_fragP->tc_frag_data.max_prefix_length = 0;
11695               }
11696             else
11697               frag_wane (next_fragP);
11698             break;
11699           }
11700     }
11701
11702   /* Stop if there is no BRANCH_PREFIX.  */
11703   if (!align_branch_prefix_size)
11704     return;
11705
11706   /* Scan for BRANCH_PREFIX.  */
11707   for (; fragP != NULL; fragP = fragP->fr_next)
11708     {
11709       if (fragP->fr_type != rs_machine_dependent
11710           || (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
11711               != BRANCH_PREFIX))
11712         continue;
11713
11714       /* Count all BRANCH_PREFIX frags before BRANCH_PADDING and
11715          COND_JUMP_PREFIX.  */
11716       max_prefix_length = 0;
11717       for (next_fragP = fragP;
11718            next_fragP != NULL;
11719            next_fragP = next_fragP->fr_next)
11720         {
11721           if (next_fragP->fr_type == rs_fill)
11722             /* Skip rs_fill frags.  */
11723             continue;
11724           else if (next_fragP->fr_type != rs_machine_dependent)
11725             /* Stop for all other frags.  */
11726             break;
11727
11728           /* rs_machine_dependent frags.  */
11729           if (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11730               == BRANCH_PREFIX)
11731             {
11732               /* Count BRANCH_PREFIX frags.  */
11733               if (max_prefix_length >= MAX_FUSED_JCC_PADDING_SIZE)
11734                 {
11735                   max_prefix_length = MAX_FUSED_JCC_PADDING_SIZE;
11736                   frag_wane (next_fragP);
11737                 }
11738               else
11739                 max_prefix_length
11740                   += next_fragP->tc_frag_data.max_bytes;
11741             }
11742           else if ((TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11743                     == BRANCH_PADDING)
11744                    || (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11745                        == FUSED_JCC_PADDING))
11746             {
11747               /* Stop at BRANCH_PADDING and FUSED_JCC_PADDING.  */
11748               fragP->tc_frag_data.u.padding_fragP = next_fragP;
11749               break;
11750             }
11751           else
11752             /* Stop for other rs_machine_dependent frags.  */
11753             break;
11754         }
11755
11756       fragP->tc_frag_data.max_prefix_length = max_prefix_length;
11757
11758       /* Skip to the next frag.  */
11759       fragP = next_fragP;
11760     }
11761 }
11762
11763 /* Compute padding size for
11764
11765         FUSED_JCC_PADDING
11766         CMP like instruction
11767         BRANCH_PADDING
11768         COND_JUMP/UNCOND_JUMP
11769
11770    or
11771
11772         BRANCH_PADDING
11773         COND_JUMP/UNCOND_JUMP
11774  */
11775
11776 static int
11777 i386_branch_padding_size (fragS *fragP, offsetT address)
11778 {
11779   unsigned int offset, size, padding_size;
11780   fragS *branch_fragP = fragP->tc_frag_data.u.branch_fragP;
11781
11782   /* The start address of the BRANCH_PADDING or FUSED_JCC_PADDING frag.  */
11783   if (!address)
11784     address = fragP->fr_address;
11785   address += fragP->fr_fix;
11786
11787   /* CMP like instrunction size.  */
11788   size = fragP->tc_frag_data.cmp_size;
11789
11790   /* The base size of the branch frag.  */
11791   size += branch_fragP->fr_fix;
11792
11793   /* Add opcode and displacement bytes for the rs_machine_dependent
11794      branch frag.  */
11795   if (branch_fragP->fr_type == rs_machine_dependent)
11796     size += md_relax_table[branch_fragP->fr_subtype].rlx_length;
11797
11798   /* Check if branch is within boundary and doesn't end at the last
11799      byte.  */
11800   offset = address & ((1U << align_branch_power) - 1);
11801   if ((offset + size) >= (1U << align_branch_power))
11802     /* Padding needed to avoid crossing boundary.  */
11803     padding_size = (1U << align_branch_power) - offset;
11804   else
11805     /* No padding needed.  */
11806     padding_size = 0;
11807
11808   /* The return value may be saved in tc_frag_data.length which is
11809      unsigned byte.  */
11810   if (!fits_in_unsigned_byte (padding_size))
11811     abort ();
11812
11813   return padding_size;
11814 }
11815
11816 /* i386_generic_table_relax_frag()
11817
11818    Handle BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING frags to
11819    grow/shrink padding to align branch frags.  Hand others to
11820    relax_frag().  */
11821
11822 long
11823 i386_generic_table_relax_frag (segT segment, fragS *fragP, long stretch)
11824 {
11825   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
11826       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
11827     {
11828       long padding_size = i386_branch_padding_size (fragP, 0);
11829       long grow = padding_size - fragP->tc_frag_data.length;
11830
11831       /* When the BRANCH_PREFIX frag is used, the computed address
11832          must match the actual address and there should be no padding.  */
11833       if (fragP->tc_frag_data.padding_address
11834           && (fragP->tc_frag_data.padding_address != fragP->fr_address
11835               || padding_size))
11836         abort ();
11837
11838       /* Update the padding size.  */
11839       if (grow)
11840         fragP->tc_frag_data.length = padding_size;
11841
11842       return grow;
11843     }
11844   else if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
11845     {
11846       fragS *padding_fragP, *next_fragP;
11847       long padding_size, left_size, last_size;
11848
11849       padding_fragP = fragP->tc_frag_data.u.padding_fragP;
11850       if (!padding_fragP)
11851         /* Use the padding set by the leading BRANCH_PREFIX frag.  */
11852         return (fragP->tc_frag_data.length
11853                 - fragP->tc_frag_data.last_length);
11854
11855       /* Compute the relative address of the padding frag in the very
11856         first time where the BRANCH_PREFIX frag sizes are zero.  */
11857       if (!fragP->tc_frag_data.padding_address)
11858         fragP->tc_frag_data.padding_address
11859           = padding_fragP->fr_address - (fragP->fr_address - stretch);
11860
11861       /* First update the last length from the previous interation.  */
11862       left_size = fragP->tc_frag_data.prefix_length;
11863       for (next_fragP = fragP;
11864            next_fragP != padding_fragP;
11865            next_fragP = next_fragP->fr_next)
11866         if (next_fragP->fr_type == rs_machine_dependent
11867             && (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11868                 == BRANCH_PREFIX))
11869           {
11870             if (left_size)
11871               {
11872                 int max = next_fragP->tc_frag_data.max_bytes;
11873                 if (max)
11874                   {
11875                     int size;
11876                     if (max > left_size)
11877                       size = left_size;
11878                     else
11879                       size = max;
11880                     left_size -= size;
11881                     next_fragP->tc_frag_data.last_length = size;
11882                   }
11883               }
11884             else
11885               next_fragP->tc_frag_data.last_length = 0;
11886           }
11887
11888       /* Check the padding size for the padding frag.  */
11889       padding_size = i386_branch_padding_size
11890         (padding_fragP, (fragP->fr_address
11891                          + fragP->tc_frag_data.padding_address));
11892
11893       last_size = fragP->tc_frag_data.prefix_length;
11894       /* Check if there is change from the last interation.  */
11895       if (padding_size == last_size)
11896         {
11897           /* Update the expected address of the padding frag.  */
11898           padding_fragP->tc_frag_data.padding_address
11899             = (fragP->fr_address + padding_size
11900                + fragP->tc_frag_data.padding_address);
11901           return 0;
11902         }
11903
11904       if (padding_size > fragP->tc_frag_data.max_prefix_length)
11905         {
11906           /* No padding if there is no sufficient room.  Clear the
11907              expected address of the padding frag.  */
11908           padding_fragP->tc_frag_data.padding_address = 0;
11909           padding_size = 0;
11910         }
11911       else
11912         /* Store the expected address of the padding frag.  */
11913         padding_fragP->tc_frag_data.padding_address
11914           = (fragP->fr_address + padding_size
11915              + fragP->tc_frag_data.padding_address);
11916
11917       fragP->tc_frag_data.prefix_length = padding_size;
11918
11919       /* Update the length for the current interation.  */
11920       left_size = padding_size;
11921       for (next_fragP = fragP;
11922            next_fragP != padding_fragP;
11923            next_fragP = next_fragP->fr_next)
11924         if (next_fragP->fr_type == rs_machine_dependent
11925             && (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11926                 == BRANCH_PREFIX))
11927           {
11928             if (left_size)
11929               {
11930                 int max = next_fragP->tc_frag_data.max_bytes;
11931                 if (max)
11932                   {
11933                     int size;
11934                     if (max > left_size)
11935                       size = left_size;
11936                     else
11937                       size = max;
11938                     left_size -= size;
11939                     next_fragP->tc_frag_data.length = size;
11940                   }
11941               }
11942             else
11943               next_fragP->tc_frag_data.length = 0;
11944           }
11945
11946       return (fragP->tc_frag_data.length
11947               - fragP->tc_frag_data.last_length);
11948     }
11949   return relax_frag (segment, fragP, stretch);
11950 }
11951
11952 /* md_estimate_size_before_relax()
11953
11954    Called just before relax() for rs_machine_dependent frags.  The x86
11955    assembler uses these frags to handle variable size jump
11956    instructions.
11957
11958    Any symbol that is now undefined will not become defined.
11959    Return the correct fr_subtype in the frag.
11960    Return the initial "guess for variable size of frag" to caller.
11961    The guess is actually the growth beyond the fixed part.  Whatever
11962    we do to grow the fixed or variable part contributes to our
11963    returned value.  */
11964
11965 int
11966 md_estimate_size_before_relax (fragS *fragP, segT segment)
11967 {
11968   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
11969       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX
11970       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
11971     {
11972       i386_classify_machine_dependent_frag (fragP);
11973       return fragP->tc_frag_data.length;
11974     }
11975
11976   /* We've already got fragP->fr_subtype right;  all we have to do is
11977      check for un-relaxable symbols.  On an ELF system, we can't relax
11978      an externally visible symbol, because it may be overridden by a
11979      shared library.  */
11980   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
11981 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11982       || (IS_ELF
11983           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
11984                                                 fragP->fr_var))
11985 #endif
11986 #if defined (OBJ_COFF) && defined (TE_PE)
11987       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
11988           && S_IS_WEAK (fragP->fr_symbol))
11989 #endif
11990       )
11991     {
11992       /* Symbol is undefined in this segment, or we need to keep a
11993          reloc so that weak symbols can be overridden.  */
11994       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
11995       enum bfd_reloc_code_real reloc_type;
11996       unsigned char *opcode;
11997       int old_fr_fix;
11998
11999       if (fragP->fr_var != NO_RELOC)
12000         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
12001       else if (size == 2)
12002         reloc_type = BFD_RELOC_16_PCREL;
12003 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12004       else if (need_plt32_p (fragP->fr_symbol))
12005         reloc_type = BFD_RELOC_X86_64_PLT32;
12006 #endif
12007       else
12008         reloc_type = BFD_RELOC_32_PCREL;
12009
12010       old_fr_fix = fragP->fr_fix;
12011       opcode = (unsigned char *) fragP->fr_opcode;
12012
12013       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
12014         {
12015         case UNCOND_JUMP:
12016           /* Make jmp (0xeb) a (d)word displacement jump.  */
12017           opcode[0] = 0xe9;
12018           fragP->fr_fix += size;
12019           fix_new (fragP, old_fr_fix, size,
12020                    fragP->fr_symbol,
12021                    fragP->fr_offset, 1,
12022                    reloc_type);
12023           break;
12024
12025         case COND_JUMP86:
12026           if (size == 2
12027               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
12028             {
12029               /* Negate the condition, and branch past an
12030                  unconditional jump.  */
12031               opcode[0] ^= 1;
12032               opcode[1] = 3;
12033               /* Insert an unconditional jump.  */
12034               opcode[2] = 0xe9;
12035               /* We added two extra opcode bytes, and have a two byte
12036                  offset.  */
12037               fragP->fr_fix += 2 + 2;
12038               fix_new (fragP, old_fr_fix + 2, 2,
12039                        fragP->fr_symbol,
12040                        fragP->fr_offset, 1,
12041                        reloc_type);
12042               break;
12043             }
12044           /* Fall through.  */
12045
12046         case COND_JUMP:
12047           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
12048             {
12049               fixS *fixP;
12050
12051               fragP->fr_fix += 1;
12052               fixP = fix_new (fragP, old_fr_fix, 1,
12053                               fragP->fr_symbol,
12054                               fragP->fr_offset, 1,
12055                               BFD_RELOC_8_PCREL);
12056               fixP->fx_signed = 1;
12057               break;
12058             }
12059
12060           /* This changes the byte-displacement jump 0x7N
12061              to the (d)word-displacement jump 0x0f,0x8N.  */
12062           opcode[1] = opcode[0] + 0x10;
12063           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12064           /* We've added an opcode byte.  */
12065           fragP->fr_fix += 1 + size;
12066           fix_new (fragP, old_fr_fix + 1, size,
12067                    fragP->fr_symbol,
12068                    fragP->fr_offset, 1,
12069                    reloc_type);
12070           break;
12071
12072         default:
12073           BAD_CASE (fragP->fr_subtype);
12074           break;
12075         }
12076       frag_wane (fragP);
12077       return fragP->fr_fix - old_fr_fix;
12078     }
12079
12080   /* Guess size depending on current relax state.  Initially the relax
12081      state will correspond to a short jump and we return 1, because
12082      the variable part of the frag (the branch offset) is one byte
12083      long.  However, we can relax a section more than once and in that
12084      case we must either set fr_subtype back to the unrelaxed state,
12085      or return the value for the appropriate branch.  */
12086   return md_relax_table[fragP->fr_subtype].rlx_length;
12087 }
12088
12089 /* Called after relax() is finished.
12090
12091    In:  Address of frag.
12092         fr_type == rs_machine_dependent.
12093         fr_subtype is what the address relaxed to.
12094
12095    Out: Any fixSs and constants are set up.
12096         Caller will turn frag into a ".space 0".  */
12097
12098 void
12099 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
12100                  fragS *fragP)
12101 {
12102   unsigned char *opcode;
12103   unsigned char *where_to_put_displacement = NULL;
12104   offsetT target_address;
12105   offsetT opcode_address;
12106   unsigned int extension = 0;
12107   offsetT displacement_from_opcode_start;
12108
12109   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
12110       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING
12111       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
12112     {
12113       /* Generate nop padding.  */
12114       unsigned int size = fragP->tc_frag_data.length;
12115       if (size)
12116         {
12117           if (size > fragP->tc_frag_data.max_bytes)
12118             abort ();
12119
12120           if (flag_debug)
12121             {
12122               const char *msg;
12123               const char *branch = "branch";
12124               const char *prefix = "";
12125               fragS *padding_fragP;
12126               if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
12127                   == BRANCH_PREFIX)
12128                 {
12129                   padding_fragP = fragP->tc_frag_data.u.padding_fragP;
12130                   switch (fragP->tc_frag_data.default_prefix)
12131                     {
12132                     default:
12133                       abort ();
12134                       break;
12135                     case CS_PREFIX_OPCODE:
12136                       prefix = " cs";
12137                       break;
12138                     case DS_PREFIX_OPCODE:
12139                       prefix = " ds";
12140                       break;
12141                     case ES_PREFIX_OPCODE:
12142                       prefix = " es";
12143                       break;
12144                     case FS_PREFIX_OPCODE:
12145                       prefix = " fs";
12146                       break;
12147                     case GS_PREFIX_OPCODE:
12148                       prefix = " gs";
12149                       break;
12150                     case SS_PREFIX_OPCODE:
12151                       prefix = " ss";
12152                       break;
12153                     }
12154                   if (padding_fragP)
12155                     msg = _("%s:%u: add %d%s at 0x%llx to align "
12156                             "%s within %d-byte boundary\n");
12157                   else
12158                     msg = _("%s:%u: add additional %d%s at 0x%llx to "
12159                             "align %s within %d-byte boundary\n");
12160                 }
12161               else
12162                 {
12163                   padding_fragP = fragP;
12164                   msg = _("%s:%u: add %d%s-byte nop at 0x%llx to align "
12165                           "%s within %d-byte boundary\n");
12166                 }
12167
12168               if (padding_fragP)
12169                 switch (padding_fragP->tc_frag_data.branch_type)
12170                   {
12171                   case align_branch_jcc:
12172                     branch = "jcc";
12173                     break;
12174                   case align_branch_fused:
12175                     branch = "fused jcc";
12176                     break;
12177                   case align_branch_jmp:
12178                     branch = "jmp";
12179                     break;
12180                   case align_branch_call:
12181                     branch = "call";
12182                     break;
12183                   case align_branch_indirect:
12184                     branch = "indiret branch";
12185                     break;
12186                   case align_branch_ret:
12187                     branch = "ret";
12188                     break;
12189                   default:
12190                     break;
12191                   }
12192
12193               fprintf (stdout, msg,
12194                        fragP->fr_file, fragP->fr_line, size, prefix,
12195                        (long long) fragP->fr_address, branch,
12196                        1 << align_branch_power);
12197             }
12198           if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
12199             memset (fragP->fr_opcode,
12200                     fragP->tc_frag_data.default_prefix, size);
12201           else
12202             i386_generate_nops (fragP, (char *) fragP->fr_opcode,
12203                                 size, 0);
12204           fragP->fr_fix += size;
12205         }
12206       return;
12207     }
12208
12209   opcode = (unsigned char *) fragP->fr_opcode;
12210
12211   /* Address we want to reach in file space.  */
12212   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
12213
12214   /* Address opcode resides at in file space.  */
12215   opcode_address = fragP->fr_address + fragP->fr_fix;
12216
12217   /* Displacement from opcode start to fill into instruction.  */
12218   displacement_from_opcode_start = target_address - opcode_address;
12219
12220   if ((fragP->fr_subtype & BIG) == 0)
12221     {
12222       /* Don't have to change opcode.  */
12223       extension = 1;            /* 1 opcode + 1 displacement  */
12224       where_to_put_displacement = &opcode[1];
12225     }
12226   else
12227     {
12228       if (no_cond_jump_promotion
12229           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
12230         as_warn_where (fragP->fr_file, fragP->fr_line,
12231                        _("long jump required"));
12232
12233       switch (fragP->fr_subtype)
12234         {
12235         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
12236           extension = 4;                /* 1 opcode + 4 displacement  */
12237           opcode[0] = 0xe9;
12238           where_to_put_displacement = &opcode[1];
12239           break;
12240
12241         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
12242           extension = 2;                /* 1 opcode + 2 displacement  */
12243           opcode[0] = 0xe9;
12244           where_to_put_displacement = &opcode[1];
12245           break;
12246
12247         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
12248         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
12249           extension = 5;                /* 2 opcode + 4 displacement  */
12250           opcode[1] = opcode[0] + 0x10;
12251           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12252           where_to_put_displacement = &opcode[2];
12253           break;
12254
12255         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
12256           extension = 3;                /* 2 opcode + 2 displacement  */
12257           opcode[1] = opcode[0] + 0x10;
12258           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12259           where_to_put_displacement = &opcode[2];
12260           break;
12261
12262         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
12263           extension = 4;
12264           opcode[0] ^= 1;
12265           opcode[1] = 3;
12266           opcode[2] = 0xe9;
12267           where_to_put_displacement = &opcode[3];
12268           break;
12269
12270         default:
12271           BAD_CASE (fragP->fr_subtype);
12272           break;
12273         }
12274     }
12275
12276   /* If size if less then four we are sure that the operand fits,
12277      but if it's 4, then it could be that the displacement is larger
12278      then -/+ 2GB.  */
12279   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
12280       && object_64bit
12281       && ((addressT) (displacement_from_opcode_start - extension
12282                       + ((addressT) 1 << 31))
12283           > (((addressT) 2 << 31) - 1)))
12284     {
12285       as_bad_where (fragP->fr_file, fragP->fr_line,
12286                     _("jump target out of range"));
12287       /* Make us emit 0.  */
12288       displacement_from_opcode_start = extension;
12289     }
12290   /* Now put displacement after opcode.  */
12291   md_number_to_chars ((char *) where_to_put_displacement,
12292                       (valueT) (displacement_from_opcode_start - extension),
12293                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
12294   fragP->fr_fix += extension;
12295 }
12296 \f
12297 /* Apply a fixup (fixP) to segment data, once it has been determined
12298    by our caller that we have all the info we need to fix it up.
12299
12300    Parameter valP is the pointer to the value of the bits.
12301
12302    On the 386, immediates, displacements, and data pointers are all in
12303    the same (little-endian) format, so we don't need to care about which
12304    we are handling.  */
12305
12306 void
12307 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
12308 {
12309   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
12310   valueT value = *valP;
12311
12312 #if !defined (TE_Mach)
12313   if (fixP->fx_pcrel)
12314     {
12315       switch (fixP->fx_r_type)
12316         {
12317         default:
12318           break;
12319
12320         case BFD_RELOC_64:
12321           fixP->fx_r_type = BFD_RELOC_64_PCREL;
12322           break;
12323         case BFD_RELOC_32:
12324         case BFD_RELOC_X86_64_32S:
12325           fixP->fx_r_type = BFD_RELOC_32_PCREL;
12326           break;
12327         case BFD_RELOC_16:
12328           fixP->fx_r_type = BFD_RELOC_16_PCREL;
12329           break;
12330         case BFD_RELOC_8:
12331           fixP->fx_r_type = BFD_RELOC_8_PCREL;
12332           break;
12333         }
12334     }
12335
12336   if (fixP->fx_addsy != NULL
12337       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
12338           || fixP->fx_r_type == BFD_RELOC_64_PCREL
12339           || fixP->fx_r_type == BFD_RELOC_16_PCREL
12340           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
12341       && !use_rela_relocations)
12342     {
12343       /* This is a hack.  There should be a better way to handle this.
12344          This covers for the fact that bfd_install_relocation will
12345          subtract the current location (for partial_inplace, PC relative
12346          relocations); see more below.  */
12347 #ifndef OBJ_AOUT
12348       if (IS_ELF
12349 #ifdef TE_PE
12350           || OUTPUT_FLAVOR == bfd_target_coff_flavour
12351 #endif
12352           )
12353         value += fixP->fx_where + fixP->fx_frag->fr_address;
12354 #endif
12355 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12356       if (IS_ELF)
12357         {
12358           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
12359
12360           if ((sym_seg == seg
12361                || (symbol_section_p (fixP->fx_addsy)
12362                    && sym_seg != absolute_section))
12363               && !generic_force_reloc (fixP))
12364             {
12365               /* Yes, we add the values in twice.  This is because
12366                  bfd_install_relocation subtracts them out again.  I think
12367                  bfd_install_relocation is broken, but I don't dare change
12368                  it.  FIXME.  */
12369               value += fixP->fx_where + fixP->fx_frag->fr_address;
12370             }
12371         }
12372 #endif
12373 #if defined (OBJ_COFF) && defined (TE_PE)
12374       /* For some reason, the PE format does not store a
12375          section address offset for a PC relative symbol.  */
12376       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
12377           || S_IS_WEAK (fixP->fx_addsy))
12378         value += md_pcrel_from (fixP);
12379 #endif
12380     }
12381 #if defined (OBJ_COFF) && defined (TE_PE)
12382   if (fixP->fx_addsy != NULL
12383       && S_IS_WEAK (fixP->fx_addsy)
12384       /* PR 16858: Do not modify weak function references.  */
12385       && ! fixP->fx_pcrel)
12386     {
12387 #if !defined (TE_PEP)
12388       /* For x86 PE weak function symbols are neither PC-relative
12389          nor do they set S_IS_FUNCTION.  So the only reliable way
12390          to detect them is to check the flags of their containing
12391          section.  */
12392       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
12393           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
12394         ;
12395       else
12396 #endif
12397       value -= S_GET_VALUE (fixP->fx_addsy);
12398     }
12399 #endif
12400
12401   /* Fix a few things - the dynamic linker expects certain values here,
12402      and we must not disappoint it.  */
12403 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12404   if (IS_ELF && fixP->fx_addsy)
12405     switch (fixP->fx_r_type)
12406       {
12407       case BFD_RELOC_386_PLT32:
12408       case BFD_RELOC_X86_64_PLT32:
12409         /* Make the jump instruction point to the address of the operand.
12410            At runtime we merely add the offset to the actual PLT entry.
12411            NB: Subtract the offset size only for jump instructions.  */
12412         if (fixP->fx_pcrel)
12413           value = -4;
12414         break;
12415
12416       case BFD_RELOC_386_TLS_GD:
12417       case BFD_RELOC_386_TLS_LDM:
12418       case BFD_RELOC_386_TLS_IE_32:
12419       case BFD_RELOC_386_TLS_IE:
12420       case BFD_RELOC_386_TLS_GOTIE:
12421       case BFD_RELOC_386_TLS_GOTDESC:
12422       case BFD_RELOC_X86_64_TLSGD:
12423       case BFD_RELOC_X86_64_TLSLD:
12424       case BFD_RELOC_X86_64_GOTTPOFF:
12425       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12426         value = 0; /* Fully resolved at runtime.  No addend.  */
12427         /* Fallthrough */
12428       case BFD_RELOC_386_TLS_LE:
12429       case BFD_RELOC_386_TLS_LDO_32:
12430       case BFD_RELOC_386_TLS_LE_32:
12431       case BFD_RELOC_X86_64_DTPOFF32:
12432       case BFD_RELOC_X86_64_DTPOFF64:
12433       case BFD_RELOC_X86_64_TPOFF32:
12434       case BFD_RELOC_X86_64_TPOFF64:
12435         S_SET_THREAD_LOCAL (fixP->fx_addsy);
12436         break;
12437
12438       case BFD_RELOC_386_TLS_DESC_CALL:
12439       case BFD_RELOC_X86_64_TLSDESC_CALL:
12440         value = 0; /* Fully resolved at runtime.  No addend.  */
12441         S_SET_THREAD_LOCAL (fixP->fx_addsy);
12442         fixP->fx_done = 0;
12443         return;
12444
12445       case BFD_RELOC_VTABLE_INHERIT:
12446       case BFD_RELOC_VTABLE_ENTRY:
12447         fixP->fx_done = 0;
12448         return;
12449
12450       default:
12451         break;
12452       }
12453 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
12454   *valP = value;
12455 #endif /* !defined (TE_Mach)  */
12456
12457   /* Are we finished with this relocation now?  */
12458   if (fixP->fx_addsy == NULL)
12459     fixP->fx_done = 1;
12460 #if defined (OBJ_COFF) && defined (TE_PE)
12461   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
12462     {
12463       fixP->fx_done = 0;
12464       /* Remember value for tc_gen_reloc.  */
12465       fixP->fx_addnumber = value;
12466       /* Clear out the frag for now.  */
12467       value = 0;
12468     }
12469 #endif
12470   else if (use_rela_relocations)
12471     {
12472       fixP->fx_no_overflow = 1;
12473       /* Remember value for tc_gen_reloc.  */
12474       fixP->fx_addnumber = value;
12475       value = 0;
12476     }
12477
12478   md_number_to_chars (p, value, fixP->fx_size);
12479 }
12480 \f
12481 const char *
12482 md_atof (int type, char *litP, int *sizeP)
12483 {
12484   /* This outputs the LITTLENUMs in REVERSE order;
12485      in accord with the bigendian 386.  */
12486   return ieee_md_atof (type, litP, sizeP, FALSE);
12487 }
12488 \f
12489 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
12490
12491 static char *
12492 output_invalid (int c)
12493 {
12494   if (ISPRINT (c))
12495     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
12496               "'%c'", c);
12497   else
12498     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
12499               "(0x%x)", (unsigned char) c);
12500   return output_invalid_buf;
12501 }
12502
12503 /* Verify that @r can be used in the current context.  */
12504
12505 static bfd_boolean check_register (const reg_entry *r)
12506 {
12507   if (allow_pseudo_reg)
12508     return TRUE;
12509
12510   if (operand_type_all_zero (&r->reg_type))
12511     return FALSE;
12512
12513   if ((r->reg_type.bitfield.dword
12514        || (r->reg_type.bitfield.class == SReg && r->reg_num > 3)
12515        || r->reg_type.bitfield.class == RegCR
12516        || r->reg_type.bitfield.class == RegDR)
12517       && !cpu_arch_flags.bitfield.cpui386)
12518     return FALSE;
12519
12520   if (r->reg_type.bitfield.class == RegTR
12521       && (flag_code == CODE_64BIT
12522           || !cpu_arch_flags.bitfield.cpui386
12523           || cpu_arch_isa_flags.bitfield.cpui586
12524           || cpu_arch_isa_flags.bitfield.cpui686))
12525     return FALSE;
12526
12527   if (r->reg_type.bitfield.class == RegMMX && !cpu_arch_flags.bitfield.cpummx)
12528     return FALSE;
12529
12530   if (!cpu_arch_flags.bitfield.cpuavx512f)
12531     {
12532       if (r->reg_type.bitfield.zmmword
12533           || r->reg_type.bitfield.class == RegMask)
12534         return FALSE;
12535
12536       if (!cpu_arch_flags.bitfield.cpuavx)
12537         {
12538           if (r->reg_type.bitfield.ymmword)
12539             return FALSE;
12540
12541           if (!cpu_arch_flags.bitfield.cpusse && r->reg_type.bitfield.xmmword)
12542             return FALSE;
12543         }
12544     }
12545
12546   if (r->reg_type.bitfield.tmmword
12547       && (!cpu_arch_flags.bitfield.cpuamx_tile
12548           || flag_code != CODE_64BIT))
12549     return FALSE;
12550
12551   if (r->reg_type.bitfield.class == RegBND && !cpu_arch_flags.bitfield.cpumpx)
12552     return FALSE;
12553
12554   /* Don't allow fake index register unless allow_index_reg isn't 0. */
12555   if (!allow_index_reg && r->reg_num == RegIZ)
12556     return FALSE;
12557
12558   /* Upper 16 vector registers are only available with VREX in 64bit
12559      mode, and require EVEX encoding.  */
12560   if (r->reg_flags & RegVRex)
12561     {
12562       if (!cpu_arch_flags.bitfield.cpuavx512f
12563           || flag_code != CODE_64BIT)
12564         return FALSE;
12565
12566       if (i.vec_encoding == vex_encoding_default)
12567         i.vec_encoding = vex_encoding_evex;
12568       else if (i.vec_encoding != vex_encoding_evex)
12569         i.vec_encoding = vex_encoding_error;
12570     }
12571
12572   if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword)
12573       && (!cpu_arch_flags.bitfield.cpulm || r->reg_type.bitfield.class != RegCR)
12574       && flag_code != CODE_64BIT)
12575     return FALSE;
12576
12577   if (r->reg_type.bitfield.class == SReg && r->reg_num == RegFlat
12578       && !intel_syntax)
12579     return FALSE;
12580
12581   return TRUE;
12582 }
12583
12584 /* REG_STRING starts *before* REGISTER_PREFIX.  */
12585
12586 static const reg_entry *
12587 parse_real_register (char *reg_string, char **end_op)
12588 {
12589   char *s = reg_string;
12590   char *p;
12591   char reg_name_given[MAX_REG_NAME_SIZE + 1];
12592   const reg_entry *r;
12593
12594   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
12595   if (*s == REGISTER_PREFIX)
12596     ++s;
12597
12598   if (is_space_char (*s))
12599     ++s;
12600
12601   p = reg_name_given;
12602   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
12603     {
12604       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
12605         return (const reg_entry *) NULL;
12606       s++;
12607     }
12608
12609   /* For naked regs, make sure that we are not dealing with an identifier.
12610      This prevents confusing an identifier like `eax_var' with register
12611      `eax'.  */
12612   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
12613     return (const reg_entry *) NULL;
12614
12615   *end_op = s;
12616
12617   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
12618
12619   /* Handle floating point regs, allowing spaces in the (i) part.  */
12620   if (r == i386_regtab /* %st is first entry of table  */)
12621     {
12622       if (!cpu_arch_flags.bitfield.cpu8087
12623           && !cpu_arch_flags.bitfield.cpu287
12624           && !cpu_arch_flags.bitfield.cpu387
12625           && !allow_pseudo_reg)
12626         return (const reg_entry *) NULL;
12627
12628       if (is_space_char (*s))
12629         ++s;
12630       if (*s == '(')
12631         {
12632           ++s;
12633           if (is_space_char (*s))
12634             ++s;
12635           if (*s >= '0' && *s <= '7')
12636             {
12637               int fpr = *s - '0';
12638               ++s;
12639               if (is_space_char (*s))
12640                 ++s;
12641               if (*s == ')')
12642                 {
12643                   *end_op = s + 1;
12644                   r = (const reg_entry *) hash_find (reg_hash, "st(0)");
12645                   know (r);
12646                   return r + fpr;
12647                 }
12648             }
12649           /* We have "%st(" then garbage.  */
12650           return (const reg_entry *) NULL;
12651         }
12652     }
12653
12654   return r && check_register (r) ? r : NULL;
12655 }
12656
12657 /* REG_STRING starts *before* REGISTER_PREFIX.  */
12658
12659 static const reg_entry *
12660 parse_register (char *reg_string, char **end_op)
12661 {
12662   const reg_entry *r;
12663
12664   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
12665     r = parse_real_register (reg_string, end_op);
12666   else
12667     r = NULL;
12668   if (!r)
12669     {
12670       char *save = input_line_pointer;
12671       char c;
12672       symbolS *symbolP;
12673
12674       input_line_pointer = reg_string;
12675       c = get_symbol_name (&reg_string);
12676       symbolP = symbol_find (reg_string);
12677       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
12678         {
12679           const expressionS *e = symbol_get_value_expression (symbolP);
12680
12681           know (e->X_op == O_register);
12682           know (e->X_add_number >= 0
12683                 && (valueT) e->X_add_number < i386_regtab_size);
12684           r = i386_regtab + e->X_add_number;
12685           if (!check_register (r))
12686             {
12687               as_bad (_("register '%s%s' cannot be used here"),
12688                       register_prefix, r->reg_name);
12689               r = &bad_reg;
12690             }
12691           *end_op = input_line_pointer;
12692         }
12693       *input_line_pointer = c;
12694       input_line_pointer = save;
12695     }
12696   return r;
12697 }
12698
12699 int
12700 i386_parse_name (char *name, expressionS *e, char *nextcharP)
12701 {
12702   const reg_entry *r;
12703   char *end = input_line_pointer;
12704
12705   *end = *nextcharP;
12706   r = parse_register (name, &input_line_pointer);
12707   if (r && end <= input_line_pointer)
12708     {
12709       *nextcharP = *input_line_pointer;
12710       *input_line_pointer = 0;
12711       if (r != &bad_reg)
12712         {
12713           e->X_op = O_register;
12714           e->X_add_number = r - i386_regtab;
12715         }
12716       else
12717           e->X_op = O_illegal;
12718       return 1;
12719     }
12720   input_line_pointer = end;
12721   *end = 0;
12722   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
12723 }
12724
12725 void
12726 md_operand (expressionS *e)
12727 {
12728   char *end;
12729   const reg_entry *r;
12730
12731   switch (*input_line_pointer)
12732     {
12733     case REGISTER_PREFIX:
12734       r = parse_real_register (input_line_pointer, &end);
12735       if (r)
12736         {
12737           e->X_op = O_register;
12738           e->X_add_number = r - i386_regtab;
12739           input_line_pointer = end;
12740         }
12741       break;
12742
12743     case '[':
12744       gas_assert (intel_syntax);
12745       end = input_line_pointer++;
12746       expression (e);
12747       if (*input_line_pointer == ']')
12748         {
12749           ++input_line_pointer;
12750           e->X_op_symbol = make_expr_symbol (e);
12751           e->X_add_symbol = NULL;
12752           e->X_add_number = 0;
12753           e->X_op = O_index;
12754         }
12755       else
12756         {
12757           e->X_op = O_absent;
12758           input_line_pointer = end;
12759         }
12760       break;
12761     }
12762 }
12763
12764 \f
12765 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12766 const char *md_shortopts = "kVQ:sqnO::";
12767 #else
12768 const char *md_shortopts = "qnO::";
12769 #endif
12770
12771 #define OPTION_32 (OPTION_MD_BASE + 0)
12772 #define OPTION_64 (OPTION_MD_BASE + 1)
12773 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
12774 #define OPTION_MARCH (OPTION_MD_BASE + 3)
12775 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
12776 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
12777 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
12778 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
12779 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
12780 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 9)
12781 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
12782 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
12783 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
12784 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
12785 #define OPTION_X32 (OPTION_MD_BASE + 14)
12786 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
12787 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
12788 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
12789 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
12790 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
12791 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
12792 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
12793 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
12794 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
12795 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
12796 #define OPTION_X86_USED_NOTE (OPTION_MD_BASE + 25)
12797 #define OPTION_MVEXWIG (OPTION_MD_BASE + 26)
12798 #define OPTION_MALIGN_BRANCH_BOUNDARY (OPTION_MD_BASE + 27)
12799 #define OPTION_MALIGN_BRANCH_PREFIX_SIZE (OPTION_MD_BASE + 28)
12800 #define OPTION_MALIGN_BRANCH (OPTION_MD_BASE + 29)
12801 #define OPTION_MBRANCHES_WITH_32B_BOUNDARIES (OPTION_MD_BASE + 30)
12802 #define OPTION_MLFENCE_AFTER_LOAD (OPTION_MD_BASE + 31)
12803 #define OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH (OPTION_MD_BASE + 32)
12804 #define OPTION_MLFENCE_BEFORE_RET (OPTION_MD_BASE + 33)
12805
12806 struct option md_longopts[] =
12807 {
12808   {"32", no_argument, NULL, OPTION_32},
12809 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
12810      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
12811   {"64", no_argument, NULL, OPTION_64},
12812 #endif
12813 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12814   {"x32", no_argument, NULL, OPTION_X32},
12815   {"mshared", no_argument, NULL, OPTION_MSHARED},
12816   {"mx86-used-note", required_argument, NULL, OPTION_X86_USED_NOTE},
12817 #endif
12818   {"divide", no_argument, NULL, OPTION_DIVIDE},
12819   {"march", required_argument, NULL, OPTION_MARCH},
12820   {"mtune", required_argument, NULL, OPTION_MTUNE},
12821   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
12822   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
12823   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
12824   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
12825   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
12826   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
12827   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
12828   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
12829   {"mvexwig", required_argument, NULL, OPTION_MVEXWIG},
12830   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
12831   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
12832   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
12833 # if defined (TE_PE) || defined (TE_PEP)
12834   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
12835 #endif
12836   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
12837   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
12838   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
12839   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
12840   {"malign-branch-boundary", required_argument, NULL, OPTION_MALIGN_BRANCH_BOUNDARY},
12841   {"malign-branch-prefix-size", required_argument, NULL, OPTION_MALIGN_BRANCH_PREFIX_SIZE},
12842   {"malign-branch", required_argument, NULL, OPTION_MALIGN_BRANCH},
12843   {"mbranches-within-32B-boundaries", no_argument, NULL, OPTION_MBRANCHES_WITH_32B_BOUNDARIES},
12844   {"mlfence-after-load", required_argument, NULL, OPTION_MLFENCE_AFTER_LOAD},
12845   {"mlfence-before-indirect-branch", required_argument, NULL,
12846    OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH},
12847   {"mlfence-before-ret", required_argument, NULL, OPTION_MLFENCE_BEFORE_RET},
12848   {"mamd64", no_argument, NULL, OPTION_MAMD64},
12849   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
12850   {NULL, no_argument, NULL, 0}
12851 };
12852 size_t md_longopts_size = sizeof (md_longopts);
12853
12854 int
12855 md_parse_option (int c, const char *arg)
12856 {
12857   unsigned int j;
12858   char *arch, *next, *saved, *type;
12859
12860   switch (c)
12861     {
12862     case 'n':
12863       optimize_align_code = 0;
12864       break;
12865
12866     case 'q':
12867       quiet_warnings = 1;
12868       break;
12869
12870 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12871       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
12872          should be emitted or not.  FIXME: Not implemented.  */
12873     case 'Q':
12874       if ((arg[0] != 'y' && arg[0] != 'n') || arg[1])
12875         return 0;
12876       break;
12877
12878       /* -V: SVR4 argument to print version ID.  */
12879     case 'V':
12880       print_version_id ();
12881       break;
12882
12883       /* -k: Ignore for FreeBSD compatibility.  */
12884     case 'k':
12885       break;
12886
12887     case 's':
12888       /* -s: On i386 Solaris, this tells the native assembler to use
12889          .stab instead of .stab.excl.  We always use .stab anyhow.  */
12890       break;
12891
12892     case OPTION_MSHARED:
12893       shared = 1;
12894       break;
12895
12896     case OPTION_X86_USED_NOTE:
12897       if (strcasecmp (arg, "yes") == 0)
12898         x86_used_note = 1;
12899       else if (strcasecmp (arg, "no") == 0)
12900         x86_used_note = 0;
12901       else
12902         as_fatal (_("invalid -mx86-used-note= option: `%s'"), arg);
12903       break;
12904
12905
12906 #endif
12907 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
12908      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
12909     case OPTION_64:
12910       {
12911         const char **list, **l;
12912
12913         list = bfd_target_list ();
12914         for (l = list; *l != NULL; l++)
12915           if (CONST_STRNEQ (*l, "elf64-x86-64")
12916               || strcmp (*l, "coff-x86-64") == 0
12917               || strcmp (*l, "pe-x86-64") == 0
12918               || strcmp (*l, "pei-x86-64") == 0
12919               || strcmp (*l, "mach-o-x86-64") == 0)
12920             {
12921               default_arch = "x86_64";
12922               break;
12923             }
12924         if (*l == NULL)
12925           as_fatal (_("no compiled in support for x86_64"));
12926         free (list);
12927       }
12928       break;
12929 #endif
12930
12931 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12932     case OPTION_X32:
12933       if (IS_ELF)
12934         {
12935           const char **list, **l;
12936
12937           list = bfd_target_list ();
12938           for (l = list; *l != NULL; l++)
12939             if (CONST_STRNEQ (*l, "elf32-x86-64"))
12940               {
12941                 default_arch = "x86_64:32";
12942                 break;
12943               }
12944           if (*l == NULL)
12945             as_fatal (_("no compiled in support for 32bit x86_64"));
12946           free (list);
12947         }
12948       else
12949         as_fatal (_("32bit x86_64 is only supported for ELF"));
12950       break;
12951 #endif
12952
12953     case OPTION_32:
12954       default_arch = "i386";
12955       break;
12956
12957     case OPTION_DIVIDE:
12958 #ifdef SVR4_COMMENT_CHARS
12959       {
12960         char *n, *t;
12961         const char *s;
12962
12963         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
12964         t = n;
12965         for (s = i386_comment_chars; *s != '\0'; s++)
12966           if (*s != '/')
12967             *t++ = *s;
12968         *t = '\0';
12969         i386_comment_chars = n;
12970       }
12971 #endif
12972       break;
12973
12974     case OPTION_MARCH:
12975       saved = xstrdup (arg);
12976       arch = saved;
12977       /* Allow -march=+nosse.  */
12978       if (*arch == '+')
12979         arch++;
12980       do
12981         {
12982           if (*arch == '.')
12983             as_fatal (_("invalid -march= option: `%s'"), arg);
12984           next = strchr (arch, '+');
12985           if (next)
12986             *next++ = '\0';
12987           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
12988             {
12989               if (strcmp (arch, cpu_arch [j].name) == 0)
12990                 {
12991                   /* Processor.  */
12992                   if (! cpu_arch[j].flags.bitfield.cpui386)
12993                     continue;
12994
12995                   cpu_arch_name = cpu_arch[j].name;
12996                   cpu_sub_arch_name = NULL;
12997                   cpu_arch_flags = cpu_arch[j].flags;
12998                   cpu_arch_isa = cpu_arch[j].type;
12999                   cpu_arch_isa_flags = cpu_arch[j].flags;
13000                   if (!cpu_arch_tune_set)
13001                     {
13002                       cpu_arch_tune = cpu_arch_isa;
13003                       cpu_arch_tune_flags = cpu_arch_isa_flags;
13004                     }
13005                   break;
13006                 }
13007               else if (*cpu_arch [j].name == '.'
13008                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
13009                 {
13010                   /* ISA extension.  */
13011                   i386_cpu_flags flags;
13012
13013                   flags = cpu_flags_or (cpu_arch_flags,
13014                                         cpu_arch[j].flags);
13015
13016                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
13017                     {
13018                       if (cpu_sub_arch_name)
13019                         {
13020                           char *name = cpu_sub_arch_name;
13021                           cpu_sub_arch_name = concat (name,
13022                                                       cpu_arch[j].name,
13023                                                       (const char *) NULL);
13024                           free (name);
13025                         }
13026                       else
13027                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
13028                       cpu_arch_flags = flags;
13029                       cpu_arch_isa_flags = flags;
13030                     }
13031                   else
13032                     cpu_arch_isa_flags
13033                       = cpu_flags_or (cpu_arch_isa_flags,
13034                                       cpu_arch[j].flags);
13035                   break;
13036                 }
13037             }
13038
13039           if (j >= ARRAY_SIZE (cpu_arch))
13040             {
13041               /* Disable an ISA extension.  */
13042               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
13043                 if (strcmp (arch, cpu_noarch [j].name) == 0)
13044                   {
13045                     i386_cpu_flags flags;
13046
13047                     flags = cpu_flags_and_not (cpu_arch_flags,
13048                                                cpu_noarch[j].flags);
13049                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
13050                       {
13051                         if (cpu_sub_arch_name)
13052                           {
13053                             char *name = cpu_sub_arch_name;
13054                             cpu_sub_arch_name = concat (arch,
13055                                                         (const char *) NULL);
13056                             free (name);
13057                           }
13058                         else
13059                           cpu_sub_arch_name = xstrdup (arch);
13060                         cpu_arch_flags = flags;
13061                         cpu_arch_isa_flags = flags;
13062                       }
13063                     break;
13064                   }
13065
13066               if (j >= ARRAY_SIZE (cpu_noarch))
13067                 j = ARRAY_SIZE (cpu_arch);
13068             }
13069
13070           if (j >= ARRAY_SIZE (cpu_arch))
13071             as_fatal (_("invalid -march= option: `%s'"), arg);
13072
13073           arch = next;
13074         }
13075       while (next != NULL);
13076       free (saved);
13077       break;
13078
13079     case OPTION_MTUNE:
13080       if (*arg == '.')
13081         as_fatal (_("invalid -mtune= option: `%s'"), arg);
13082       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13083         {
13084           if (strcmp (arg, cpu_arch [j].name) == 0)
13085             {
13086               cpu_arch_tune_set = 1;
13087               cpu_arch_tune = cpu_arch [j].type;
13088               cpu_arch_tune_flags = cpu_arch[j].flags;
13089               break;
13090             }
13091         }
13092       if (j >= ARRAY_SIZE (cpu_arch))
13093         as_fatal (_("invalid -mtune= option: `%s'"), arg);
13094       break;
13095
13096     case OPTION_MMNEMONIC:
13097       if (strcasecmp (arg, "att") == 0)
13098         intel_mnemonic = 0;
13099       else if (strcasecmp (arg, "intel") == 0)
13100         intel_mnemonic = 1;
13101       else
13102         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
13103       break;
13104
13105     case OPTION_MSYNTAX:
13106       if (strcasecmp (arg, "att") == 0)
13107         intel_syntax = 0;
13108       else if (strcasecmp (arg, "intel") == 0)
13109         intel_syntax = 1;
13110       else
13111         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
13112       break;
13113
13114     case OPTION_MINDEX_REG:
13115       allow_index_reg = 1;
13116       break;
13117
13118     case OPTION_MNAKED_REG:
13119       allow_naked_reg = 1;
13120       break;
13121
13122     case OPTION_MSSE2AVX:
13123       sse2avx = 1;
13124       break;
13125
13126     case OPTION_MSSE_CHECK:
13127       if (strcasecmp (arg, "error") == 0)
13128         sse_check = check_error;
13129       else if (strcasecmp (arg, "warning") == 0)
13130         sse_check = check_warning;
13131       else if (strcasecmp (arg, "none") == 0)
13132         sse_check = check_none;
13133       else
13134         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
13135       break;
13136
13137     case OPTION_MOPERAND_CHECK:
13138       if (strcasecmp (arg, "error") == 0)
13139         operand_check = check_error;
13140       else if (strcasecmp (arg, "warning") == 0)
13141         operand_check = check_warning;
13142       else if (strcasecmp (arg, "none") == 0)
13143         operand_check = check_none;
13144       else
13145         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
13146       break;
13147
13148     case OPTION_MAVXSCALAR:
13149       if (strcasecmp (arg, "128") == 0)
13150         avxscalar = vex128;
13151       else if (strcasecmp (arg, "256") == 0)
13152         avxscalar = vex256;
13153       else
13154         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
13155       break;
13156
13157     case OPTION_MVEXWIG:
13158       if (strcmp (arg, "0") == 0)
13159         vexwig = vexw0;
13160       else if (strcmp (arg, "1") == 0)
13161         vexwig = vexw1;
13162       else
13163         as_fatal (_("invalid -mvexwig= option: `%s'"), arg);
13164       break;
13165
13166     case OPTION_MADD_BND_PREFIX:
13167       add_bnd_prefix = 1;
13168       break;
13169
13170     case OPTION_MEVEXLIG:
13171       if (strcmp (arg, "128") == 0)
13172         evexlig = evexl128;
13173       else if (strcmp (arg, "256") == 0)
13174         evexlig = evexl256;
13175       else  if (strcmp (arg, "512") == 0)
13176         evexlig = evexl512;
13177       else
13178         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
13179       break;
13180
13181     case OPTION_MEVEXRCIG:
13182       if (strcmp (arg, "rne") == 0)
13183         evexrcig = rne;
13184       else if (strcmp (arg, "rd") == 0)
13185         evexrcig = rd;
13186       else if (strcmp (arg, "ru") == 0)
13187         evexrcig = ru;
13188       else if (strcmp (arg, "rz") == 0)
13189         evexrcig = rz;
13190       else
13191         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
13192       break;
13193
13194     case OPTION_MEVEXWIG:
13195       if (strcmp (arg, "0") == 0)
13196         evexwig = evexw0;
13197       else if (strcmp (arg, "1") == 0)
13198         evexwig = evexw1;
13199       else
13200         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
13201       break;
13202
13203 # if defined (TE_PE) || defined (TE_PEP)
13204     case OPTION_MBIG_OBJ:
13205       use_big_obj = 1;
13206       break;
13207 #endif
13208
13209     case OPTION_MOMIT_LOCK_PREFIX:
13210       if (strcasecmp (arg, "yes") == 0)
13211         omit_lock_prefix = 1;
13212       else if (strcasecmp (arg, "no") == 0)
13213         omit_lock_prefix = 0;
13214       else
13215         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
13216       break;
13217
13218     case OPTION_MFENCE_AS_LOCK_ADD:
13219       if (strcasecmp (arg, "yes") == 0)
13220         avoid_fence = 1;
13221       else if (strcasecmp (arg, "no") == 0)
13222         avoid_fence = 0;
13223       else
13224         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
13225       break;
13226
13227     case OPTION_MLFENCE_AFTER_LOAD:
13228       if (strcasecmp (arg, "yes") == 0)
13229         lfence_after_load = 1;
13230       else if (strcasecmp (arg, "no") == 0)
13231         lfence_after_load = 0;
13232       else
13233         as_fatal (_("invalid -mlfence-after-load= option: `%s'"), arg);
13234       break;
13235
13236     case OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH:
13237       if (strcasecmp (arg, "all") == 0)
13238         {
13239           lfence_before_indirect_branch = lfence_branch_all;
13240           if (lfence_before_ret == lfence_before_ret_none)
13241             lfence_before_ret = lfence_before_ret_shl;
13242         }
13243       else if (strcasecmp (arg, "memory") == 0)
13244         lfence_before_indirect_branch = lfence_branch_memory;
13245       else if (strcasecmp (arg, "register") == 0)
13246         lfence_before_indirect_branch = lfence_branch_register;
13247       else if (strcasecmp (arg, "none") == 0)
13248         lfence_before_indirect_branch = lfence_branch_none;
13249       else
13250         as_fatal (_("invalid -mlfence-before-indirect-branch= option: `%s'"),
13251                   arg);
13252       break;
13253
13254     case OPTION_MLFENCE_BEFORE_RET:
13255       if (strcasecmp (arg, "or") == 0)
13256         lfence_before_ret = lfence_before_ret_or;
13257       else if (strcasecmp (arg, "not") == 0)
13258         lfence_before_ret = lfence_before_ret_not;
13259       else if (strcasecmp (arg, "shl") == 0 || strcasecmp (arg, "yes") == 0)
13260         lfence_before_ret = lfence_before_ret_shl;
13261       else if (strcasecmp (arg, "none") == 0)
13262         lfence_before_ret = lfence_before_ret_none;
13263       else
13264         as_fatal (_("invalid -mlfence-before-ret= option: `%s'"),
13265                   arg);
13266       break;
13267
13268     case OPTION_MRELAX_RELOCATIONS:
13269       if (strcasecmp (arg, "yes") == 0)
13270         generate_relax_relocations = 1;
13271       else if (strcasecmp (arg, "no") == 0)
13272         generate_relax_relocations = 0;
13273       else
13274         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
13275       break;
13276
13277     case OPTION_MALIGN_BRANCH_BOUNDARY:
13278       {
13279         char *end;
13280         long int align = strtoul (arg, &end, 0);
13281         if (*end == '\0')
13282           {
13283             if (align == 0)
13284               {
13285                 align_branch_power = 0;
13286                 break;
13287               }
13288             else if (align >= 16)
13289               {
13290                 int align_power;
13291                 for (align_power = 0;
13292                      (align & 1) == 0;
13293                      align >>= 1, align_power++)
13294                   continue;
13295                 /* Limit alignment power to 31.  */
13296                 if (align == 1 && align_power < 32)
13297                   {
13298                     align_branch_power = align_power;
13299                     break;
13300                   }
13301               }
13302           }
13303         as_fatal (_("invalid -malign-branch-boundary= value: %s"), arg);
13304       }
13305       break;
13306
13307     case OPTION_MALIGN_BRANCH_PREFIX_SIZE:
13308       {
13309         char *end;
13310         int align = strtoul (arg, &end, 0);
13311         /* Some processors only support 5 prefixes.  */
13312         if (*end == '\0' && align >= 0 && align < 6)
13313           {
13314             align_branch_prefix_size = align;
13315             break;
13316           }
13317         as_fatal (_("invalid -malign-branch-prefix-size= value: %s"),
13318                   arg);
13319       }
13320       break;
13321
13322     case OPTION_MALIGN_BRANCH:
13323       align_branch = 0;
13324       saved = xstrdup (arg);
13325       type = saved;
13326       do
13327         {
13328           next = strchr (type, '+');
13329           if (next)
13330             *next++ = '\0';
13331           if (strcasecmp (type, "jcc") == 0)
13332             align_branch |= align_branch_jcc_bit;
13333           else if (strcasecmp (type, "fused") == 0)
13334             align_branch |= align_branch_fused_bit;
13335           else if (strcasecmp (type, "jmp") == 0)
13336             align_branch |= align_branch_jmp_bit;
13337           else if (strcasecmp (type, "call") == 0)
13338             align_branch |= align_branch_call_bit;
13339           else if (strcasecmp (type, "ret") == 0)
13340             align_branch |= align_branch_ret_bit;
13341           else if (strcasecmp (type, "indirect") == 0)
13342             align_branch |= align_branch_indirect_bit;
13343           else
13344             as_fatal (_("invalid -malign-branch= option: `%s'"), arg);
13345           type = next;
13346         }
13347       while (next != NULL);
13348       free (saved);
13349       break;
13350
13351     case OPTION_MBRANCHES_WITH_32B_BOUNDARIES:
13352       align_branch_power = 5;
13353       align_branch_prefix_size = 5;
13354       align_branch = (align_branch_jcc_bit
13355                       | align_branch_fused_bit
13356                       | align_branch_jmp_bit);
13357       break;
13358
13359     case OPTION_MAMD64:
13360       isa64 = amd64;
13361       break;
13362
13363     case OPTION_MINTEL64:
13364       isa64 = intel64;
13365       break;
13366
13367     case 'O':
13368       if (arg == NULL)
13369         {
13370           optimize = 1;
13371           /* Turn off -Os.  */
13372           optimize_for_space = 0;
13373         }
13374       else if (*arg == 's')
13375         {
13376           optimize_for_space = 1;
13377           /* Turn on all encoding optimizations.  */
13378           optimize = INT_MAX;
13379         }
13380       else
13381         {
13382           optimize = atoi (arg);
13383           /* Turn off -Os.  */
13384           optimize_for_space = 0;
13385         }
13386       break;
13387
13388     default:
13389       return 0;
13390     }
13391   return 1;
13392 }
13393
13394 #define MESSAGE_TEMPLATE \
13395 "                                                                                "
13396
13397 static char *
13398 output_message (FILE *stream, char *p, char *message, char *start,
13399                 int *left_p, const char *name, int len)
13400 {
13401   int size = sizeof (MESSAGE_TEMPLATE);
13402   int left = *left_p;
13403
13404   /* Reserve 2 spaces for ", " or ",\0" */
13405   left -= len + 2;
13406
13407   /* Check if there is any room.  */
13408   if (left >= 0)
13409     {
13410       if (p != start)
13411         {
13412           *p++ = ',';
13413           *p++ = ' ';
13414         }
13415       p = mempcpy (p, name, len);
13416     }
13417   else
13418     {
13419       /* Output the current message now and start a new one.  */
13420       *p++ = ',';
13421       *p = '\0';
13422       fprintf (stream, "%s\n", message);
13423       p = start;
13424       left = size - (start - message) - len - 2;
13425
13426       gas_assert (left >= 0);
13427
13428       p = mempcpy (p, name, len);
13429     }
13430
13431   *left_p = left;
13432   return p;
13433 }
13434
13435 static void
13436 show_arch (FILE *stream, int ext, int check)
13437 {
13438   static char message[] = MESSAGE_TEMPLATE;
13439   char *start = message + 27;
13440   char *p;
13441   int size = sizeof (MESSAGE_TEMPLATE);
13442   int left;
13443   const char *name;
13444   int len;
13445   unsigned int j;
13446
13447   p = start;
13448   left = size - (start - message);
13449   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13450     {
13451       /* Should it be skipped?  */
13452       if (cpu_arch [j].skip)
13453         continue;
13454
13455       name = cpu_arch [j].name;
13456       len = cpu_arch [j].len;
13457       if (*name == '.')
13458         {
13459           /* It is an extension.  Skip if we aren't asked to show it.  */
13460           if (ext)
13461             {
13462               name++;
13463               len--;
13464             }
13465           else
13466             continue;
13467         }
13468       else if (ext)
13469         {
13470           /* It is an processor.  Skip if we show only extension.  */
13471           continue;
13472         }
13473       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
13474         {
13475           /* It is an impossible processor - skip.  */
13476           continue;
13477         }
13478
13479       p = output_message (stream, p, message, start, &left, name, len);
13480     }
13481
13482   /* Display disabled extensions.  */
13483   if (ext)
13484     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
13485       {
13486         name = cpu_noarch [j].name;
13487         len = cpu_noarch [j].len;
13488         p = output_message (stream, p, message, start, &left, name,
13489                             len);
13490       }
13491
13492   *p = '\0';
13493   fprintf (stream, "%s\n", message);
13494 }
13495
13496 void
13497 md_show_usage (FILE *stream)
13498 {
13499 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13500   fprintf (stream, _("\
13501   -Qy, -Qn                ignored\n\
13502   -V                      print assembler version number\n\
13503   -k                      ignored\n"));
13504 #endif
13505   fprintf (stream, _("\
13506   -n                      Do not optimize code alignment\n\
13507   -q                      quieten some warnings\n"));
13508 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13509   fprintf (stream, _("\
13510   -s                      ignored\n"));
13511 #endif
13512 #if defined BFD64 && (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
13513                       || defined (TE_PE) || defined (TE_PEP))
13514   fprintf (stream, _("\
13515   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
13516 #endif
13517 #ifdef SVR4_COMMENT_CHARS
13518   fprintf (stream, _("\
13519   --divide                do not treat `/' as a comment character\n"));
13520 #else
13521   fprintf (stream, _("\
13522   --divide                ignored\n"));
13523 #endif
13524   fprintf (stream, _("\
13525   -march=CPU[,+EXTENSION...]\n\
13526                           generate code for CPU and EXTENSION, CPU is one of:\n"));
13527   show_arch (stream, 0, 1);
13528   fprintf (stream, _("\
13529                           EXTENSION is combination of:\n"));
13530   show_arch (stream, 1, 0);
13531   fprintf (stream, _("\
13532   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
13533   show_arch (stream, 0, 0);
13534   fprintf (stream, _("\
13535   -msse2avx               encode SSE instructions with VEX prefix\n"));
13536   fprintf (stream, _("\
13537   -msse-check=[none|error|warning] (default: warning)\n\
13538                           check SSE instructions\n"));
13539   fprintf (stream, _("\
13540   -moperand-check=[none|error|warning] (default: warning)\n\
13541                           check operand combinations for validity\n"));
13542   fprintf (stream, _("\
13543   -mavxscalar=[128|256] (default: 128)\n\
13544                           encode scalar AVX instructions with specific vector\n\
13545                            length\n"));
13546   fprintf (stream, _("\
13547   -mvexwig=[0|1] (default: 0)\n\
13548                           encode VEX instructions with specific VEX.W value\n\
13549                            for VEX.W bit ignored instructions\n"));
13550   fprintf (stream, _("\
13551   -mevexlig=[128|256|512] (default: 128)\n\
13552                           encode scalar EVEX instructions with specific vector\n\
13553                            length\n"));
13554   fprintf (stream, _("\
13555   -mevexwig=[0|1] (default: 0)\n\
13556                           encode EVEX instructions with specific EVEX.W value\n\
13557                            for EVEX.W bit ignored instructions\n"));
13558   fprintf (stream, _("\
13559   -mevexrcig=[rne|rd|ru|rz] (default: rne)\n\
13560                           encode EVEX instructions with specific EVEX.RC value\n\
13561                            for SAE-only ignored instructions\n"));
13562   fprintf (stream, _("\
13563   -mmnemonic=[att|intel] "));
13564   if (SYSV386_COMPAT)
13565     fprintf (stream, _("(default: att)\n"));
13566   else
13567     fprintf (stream, _("(default: intel)\n"));
13568   fprintf (stream, _("\
13569                           use AT&T/Intel mnemonic\n"));
13570   fprintf (stream, _("\
13571   -msyntax=[att|intel] (default: att)\n\
13572                           use AT&T/Intel syntax\n"));
13573   fprintf (stream, _("\
13574   -mindex-reg             support pseudo index registers\n"));
13575   fprintf (stream, _("\
13576   -mnaked-reg             don't require `%%' prefix for registers\n"));
13577   fprintf (stream, _("\
13578   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
13579 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13580   fprintf (stream, _("\
13581   -mshared                disable branch optimization for shared code\n"));
13582   fprintf (stream, _("\
13583   -mx86-used-note=[no|yes] "));
13584   if (DEFAULT_X86_USED_NOTE)
13585     fprintf (stream, _("(default: yes)\n"));
13586   else
13587     fprintf (stream, _("(default: no)\n"));
13588   fprintf (stream, _("\
13589                           generate x86 used ISA and feature properties\n"));
13590 #endif
13591 #if defined (TE_PE) || defined (TE_PEP)
13592   fprintf (stream, _("\
13593   -mbig-obj               generate big object files\n"));
13594 #endif
13595   fprintf (stream, _("\
13596   -momit-lock-prefix=[no|yes] (default: no)\n\
13597                           strip all lock prefixes\n"));
13598   fprintf (stream, _("\
13599   -mfence-as-lock-add=[no|yes] (default: no)\n\
13600                           encode lfence, mfence and sfence as\n\
13601                            lock addl $0x0, (%%{re}sp)\n"));
13602   fprintf (stream, _("\
13603   -mrelax-relocations=[no|yes] "));
13604   if (DEFAULT_GENERATE_X86_RELAX_RELOCATIONS)
13605     fprintf (stream, _("(default: yes)\n"));
13606   else
13607     fprintf (stream, _("(default: no)\n"));
13608   fprintf (stream, _("\
13609                           generate relax relocations\n"));
13610   fprintf (stream, _("\
13611   -malign-branch-boundary=NUM (default: 0)\n\
13612                           align branches within NUM byte boundary\n"));
13613   fprintf (stream, _("\
13614   -malign-branch=TYPE[+TYPE...] (default: jcc+fused+jmp)\n\
13615                           TYPE is combination of jcc, fused, jmp, call, ret,\n\
13616                            indirect\n\
13617                           specify types of branches to align\n"));
13618   fprintf (stream, _("\
13619   -malign-branch-prefix-size=NUM (default: 5)\n\
13620                           align branches with NUM prefixes per instruction\n"));
13621   fprintf (stream, _("\
13622   -mbranches-within-32B-boundaries\n\
13623                           align branches within 32 byte boundary\n"));
13624   fprintf (stream, _("\
13625   -mlfence-after-load=[no|yes] (default: no)\n\
13626                           generate lfence after load\n"));
13627   fprintf (stream, _("\
13628   -mlfence-before-indirect-branch=[none|all|register|memory] (default: none)\n\
13629                           generate lfence before indirect near branch\n"));
13630   fprintf (stream, _("\
13631   -mlfence-before-ret=[none|or|not|shl|yes] (default: none)\n\
13632                           generate lfence before ret\n"));
13633   fprintf (stream, _("\
13634   -mamd64                 accept only AMD64 ISA [default]\n"));
13635   fprintf (stream, _("\
13636   -mintel64               accept only Intel64 ISA\n"));
13637 }
13638
13639 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
13640      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
13641      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
13642
13643 /* Pick the target format to use.  */
13644
13645 const char *
13646 i386_target_format (void)
13647 {
13648   if (!strncmp (default_arch, "x86_64", 6))
13649     {
13650       update_code_flag (CODE_64BIT, 1);
13651       if (default_arch[6] == '\0')
13652         x86_elf_abi = X86_64_ABI;
13653       else
13654         x86_elf_abi = X86_64_X32_ABI;
13655     }
13656   else if (!strcmp (default_arch, "i386"))
13657     update_code_flag (CODE_32BIT, 1);
13658   else if (!strcmp (default_arch, "iamcu"))
13659     {
13660       update_code_flag (CODE_32BIT, 1);
13661       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
13662         {
13663           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
13664           cpu_arch_name = "iamcu";
13665           cpu_sub_arch_name = NULL;
13666           cpu_arch_flags = iamcu_flags;
13667           cpu_arch_isa = PROCESSOR_IAMCU;
13668           cpu_arch_isa_flags = iamcu_flags;
13669           if (!cpu_arch_tune_set)
13670             {
13671               cpu_arch_tune = cpu_arch_isa;
13672               cpu_arch_tune_flags = cpu_arch_isa_flags;
13673             }
13674         }
13675       else if (cpu_arch_isa != PROCESSOR_IAMCU)
13676         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
13677                   cpu_arch_name);
13678     }
13679   else
13680     as_fatal (_("unknown architecture"));
13681
13682   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
13683     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
13684   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
13685     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
13686
13687   switch (OUTPUT_FLAVOR)
13688     {
13689 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
13690     case bfd_target_aout_flavour:
13691       return AOUT_TARGET_FORMAT;
13692 #endif
13693 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
13694 # if defined (TE_PE) || defined (TE_PEP)
13695     case bfd_target_coff_flavour:
13696       if (flag_code == CODE_64BIT)
13697         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
13698       else
13699         return use_big_obj ? "pe-bigobj-i386" : "pe-i386";
13700 # elif defined (TE_GO32)
13701     case bfd_target_coff_flavour:
13702       return "coff-go32";
13703 # else
13704     case bfd_target_coff_flavour:
13705       return "coff-i386";
13706 # endif
13707 #endif
13708 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
13709     case bfd_target_elf_flavour:
13710       {
13711         const char *format;
13712
13713         switch (x86_elf_abi)
13714           {
13715           default:
13716             format = ELF_TARGET_FORMAT;
13717 #ifndef TE_SOLARIS
13718             tls_get_addr = "___tls_get_addr";
13719 #endif
13720             break;
13721           case X86_64_ABI:
13722             use_rela_relocations = 1;
13723             object_64bit = 1;
13724 #ifndef TE_SOLARIS
13725             tls_get_addr = "__tls_get_addr";
13726 #endif
13727             format = ELF_TARGET_FORMAT64;
13728             break;
13729           case X86_64_X32_ABI:
13730             use_rela_relocations = 1;
13731             object_64bit = 1;
13732 #ifndef TE_SOLARIS
13733             tls_get_addr = "__tls_get_addr";
13734 #endif
13735             disallow_64bit_reloc = 1;
13736             format = ELF_TARGET_FORMAT32;
13737             break;
13738           }
13739         if (cpu_arch_isa == PROCESSOR_L1OM)
13740           {
13741             if (x86_elf_abi != X86_64_ABI)
13742               as_fatal (_("Intel L1OM is 64bit only"));
13743             return ELF_TARGET_L1OM_FORMAT;
13744           }
13745         else if (cpu_arch_isa == PROCESSOR_K1OM)
13746           {
13747             if (x86_elf_abi != X86_64_ABI)
13748               as_fatal (_("Intel K1OM is 64bit only"));
13749             return ELF_TARGET_K1OM_FORMAT;
13750           }
13751         else if (cpu_arch_isa == PROCESSOR_IAMCU)
13752           {
13753             if (x86_elf_abi != I386_ABI)
13754               as_fatal (_("Intel MCU is 32bit only"));
13755             return ELF_TARGET_IAMCU_FORMAT;
13756           }
13757         else
13758           return format;
13759       }
13760 #endif
13761 #if defined (OBJ_MACH_O)
13762     case bfd_target_mach_o_flavour:
13763       if (flag_code == CODE_64BIT)
13764         {
13765           use_rela_relocations = 1;
13766           object_64bit = 1;
13767           return "mach-o-x86-64";
13768         }
13769       else
13770         return "mach-o-i386";
13771 #endif
13772     default:
13773       abort ();
13774       return NULL;
13775     }
13776 }
13777
13778 #endif /* OBJ_MAYBE_ more than one  */
13779 \f
13780 symbolS *
13781 md_undefined_symbol (char *name)
13782 {
13783   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
13784       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
13785       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
13786       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
13787     {
13788       if (!GOT_symbol)
13789         {
13790           if (symbol_find (name))
13791             as_bad (_("GOT already in symbol table"));
13792           GOT_symbol = symbol_new (name, undefined_section,
13793                                    (valueT) 0, &zero_address_frag);
13794         };
13795       return GOT_symbol;
13796     }
13797   return 0;
13798 }
13799
13800 /* Round up a section size to the appropriate boundary.  */
13801
13802 valueT
13803 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
13804 {
13805 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
13806   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
13807     {
13808       /* For a.out, force the section size to be aligned.  If we don't do
13809          this, BFD will align it for us, but it will not write out the
13810          final bytes of the section.  This may be a bug in BFD, but it is
13811          easier to fix it here since that is how the other a.out targets
13812          work.  */
13813       int align;
13814
13815       align = bfd_section_alignment (segment);
13816       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
13817     }
13818 #endif
13819
13820   return size;
13821 }
13822
13823 /* On the i386, PC-relative offsets are relative to the start of the
13824    next instruction.  That is, the address of the offset, plus its
13825    size, since the offset is always the last part of the insn.  */
13826
13827 long
13828 md_pcrel_from (fixS *fixP)
13829 {
13830   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
13831 }
13832
13833 #ifndef I386COFF
13834
13835 static void
13836 s_bss (int ignore ATTRIBUTE_UNUSED)
13837 {
13838   int temp;
13839
13840 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13841   if (IS_ELF)
13842     obj_elf_section_change_hook ();
13843 #endif
13844   temp = get_absolute_expression ();
13845   subseg_set (bss_section, (subsegT) temp);
13846   demand_empty_rest_of_line ();
13847 }
13848
13849 #endif
13850
13851 /* Remember constant directive.  */
13852
13853 void
13854 i386_cons_align (int ignore ATTRIBUTE_UNUSED)
13855 {
13856   if (last_insn.kind != last_insn_directive
13857       && (bfd_section_flags (now_seg) & SEC_CODE))
13858     {
13859       last_insn.seg = now_seg;
13860       last_insn.kind = last_insn_directive;
13861       last_insn.name = "constant directive";
13862       last_insn.file = as_where (&last_insn.line);
13863       if (lfence_before_ret != lfence_before_ret_none)
13864         {
13865           if (lfence_before_indirect_branch != lfence_branch_none)
13866             as_warn (_("constant directive skips -mlfence-before-ret "
13867                        "and -mlfence-before-indirect-branch"));
13868           else
13869             as_warn (_("constant directive skips -mlfence-before-ret"));
13870         }
13871       else if (lfence_before_indirect_branch != lfence_branch_none)
13872         as_warn (_("constant directive skips -mlfence-before-indirect-branch"));
13873     }
13874 }
13875
13876 void
13877 i386_validate_fix (fixS *fixp)
13878 {
13879   if (fixp->fx_subsy)
13880     {
13881       if (fixp->fx_subsy == GOT_symbol)
13882         {
13883           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
13884             {
13885               if (!object_64bit)
13886                 abort ();
13887 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13888               if (fixp->fx_tcbit2)
13889                 fixp->fx_r_type = (fixp->fx_tcbit
13890                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
13891                                    : BFD_RELOC_X86_64_GOTPCRELX);
13892               else
13893 #endif
13894                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
13895             }
13896           else
13897             {
13898               if (!object_64bit)
13899                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
13900               else
13901                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
13902             }
13903           fixp->fx_subsy = 0;
13904         }
13905     }
13906 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13907   else
13908     {
13909       /* NB: Commit 292676c1 resolved PLT32 reloc aganst local symbol
13910          to section.  Since PLT32 relocation must be against symbols,
13911          turn such PLT32 relocation into PC32 relocation.  */
13912       if (fixp->fx_addsy
13913           && (fixp->fx_r_type == BFD_RELOC_386_PLT32
13914               || fixp->fx_r_type == BFD_RELOC_X86_64_PLT32)
13915           && symbol_section_p (fixp->fx_addsy))
13916         fixp->fx_r_type = BFD_RELOC_32_PCREL;
13917       if (!object_64bit)
13918         {
13919           if (fixp->fx_r_type == BFD_RELOC_386_GOT32
13920               && fixp->fx_tcbit2)
13921             fixp->fx_r_type = BFD_RELOC_386_GOT32X;
13922         }
13923     }
13924 #endif
13925 }
13926
13927 arelent *
13928 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
13929 {
13930   arelent *rel;
13931   bfd_reloc_code_real_type code;
13932
13933   switch (fixp->fx_r_type)
13934     {
13935 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13936     case BFD_RELOC_SIZE32:
13937     case BFD_RELOC_SIZE64:
13938       if (S_IS_DEFINED (fixp->fx_addsy)
13939           && !S_IS_EXTERNAL (fixp->fx_addsy))
13940         {
13941           /* Resolve size relocation against local symbol to size of
13942              the symbol plus addend.  */
13943           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
13944           if (fixp->fx_r_type == BFD_RELOC_SIZE32
13945               && !fits_in_unsigned_long (value))
13946             as_bad_where (fixp->fx_file, fixp->fx_line,
13947                           _("symbol size computation overflow"));
13948           fixp->fx_addsy = NULL;
13949           fixp->fx_subsy = NULL;
13950           md_apply_fix (fixp, (valueT *) &value, NULL);
13951           return NULL;
13952         }
13953 #endif
13954       /* Fall through.  */
13955
13956     case BFD_RELOC_X86_64_PLT32:
13957     case BFD_RELOC_X86_64_GOT32:
13958     case BFD_RELOC_X86_64_GOTPCREL:
13959     case BFD_RELOC_X86_64_GOTPCRELX:
13960     case BFD_RELOC_X86_64_REX_GOTPCRELX:
13961     case BFD_RELOC_386_PLT32:
13962     case BFD_RELOC_386_GOT32:
13963     case BFD_RELOC_386_GOT32X:
13964     case BFD_RELOC_386_GOTOFF:
13965     case BFD_RELOC_386_GOTPC:
13966     case BFD_RELOC_386_TLS_GD:
13967     case BFD_RELOC_386_TLS_LDM:
13968     case BFD_RELOC_386_TLS_LDO_32:
13969     case BFD_RELOC_386_TLS_IE_32:
13970     case BFD_RELOC_386_TLS_IE:
13971     case BFD_RELOC_386_TLS_GOTIE:
13972     case BFD_RELOC_386_TLS_LE_32:
13973     case BFD_RELOC_386_TLS_LE:
13974     case BFD_RELOC_386_TLS_GOTDESC:
13975     case BFD_RELOC_386_TLS_DESC_CALL:
13976     case BFD_RELOC_X86_64_TLSGD:
13977     case BFD_RELOC_X86_64_TLSLD:
13978     case BFD_RELOC_X86_64_DTPOFF32:
13979     case BFD_RELOC_X86_64_DTPOFF64:
13980     case BFD_RELOC_X86_64_GOTTPOFF:
13981     case BFD_RELOC_X86_64_TPOFF32:
13982     case BFD_RELOC_X86_64_TPOFF64:
13983     case BFD_RELOC_X86_64_GOTOFF64:
13984     case BFD_RELOC_X86_64_GOTPC32:
13985     case BFD_RELOC_X86_64_GOT64:
13986     case BFD_RELOC_X86_64_GOTPCREL64:
13987     case BFD_RELOC_X86_64_GOTPC64:
13988     case BFD_RELOC_X86_64_GOTPLT64:
13989     case BFD_RELOC_X86_64_PLTOFF64:
13990     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
13991     case BFD_RELOC_X86_64_TLSDESC_CALL:
13992     case BFD_RELOC_RVA:
13993     case BFD_RELOC_VTABLE_ENTRY:
13994     case BFD_RELOC_VTABLE_INHERIT:
13995 #ifdef TE_PE
13996     case BFD_RELOC_32_SECREL:
13997 #endif
13998       code = fixp->fx_r_type;
13999       break;
14000     case BFD_RELOC_X86_64_32S:
14001       if (!fixp->fx_pcrel)
14002         {
14003           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
14004           code = fixp->fx_r_type;
14005           break;
14006         }
14007       /* Fall through.  */
14008     default:
14009       if (fixp->fx_pcrel)
14010         {
14011           switch (fixp->fx_size)
14012             {
14013             default:
14014               as_bad_where (fixp->fx_file, fixp->fx_line,
14015                             _("can not do %d byte pc-relative relocation"),
14016                             fixp->fx_size);
14017               code = BFD_RELOC_32_PCREL;
14018               break;
14019             case 1: code = BFD_RELOC_8_PCREL;  break;
14020             case 2: code = BFD_RELOC_16_PCREL; break;
14021             case 4: code = BFD_RELOC_32_PCREL; break;
14022 #ifdef BFD64
14023             case 8: code = BFD_RELOC_64_PCREL; break;
14024 #endif
14025             }
14026         }
14027       else
14028         {
14029           switch (fixp->fx_size)
14030             {
14031             default:
14032               as_bad_where (fixp->fx_file, fixp->fx_line,
14033                             _("can not do %d byte relocation"),
14034                             fixp->fx_size);
14035               code = BFD_RELOC_32;
14036               break;
14037             case 1: code = BFD_RELOC_8;  break;
14038             case 2: code = BFD_RELOC_16; break;
14039             case 4: code = BFD_RELOC_32; break;
14040 #ifdef BFD64
14041             case 8: code = BFD_RELOC_64; break;
14042 #endif
14043             }
14044         }
14045       break;
14046     }
14047
14048   if ((code == BFD_RELOC_32
14049        || code == BFD_RELOC_32_PCREL
14050        || code == BFD_RELOC_X86_64_32S)
14051       && GOT_symbol
14052       && fixp->fx_addsy == GOT_symbol)
14053     {
14054       if (!object_64bit)
14055         code = BFD_RELOC_386_GOTPC;
14056       else
14057         code = BFD_RELOC_X86_64_GOTPC32;
14058     }
14059   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
14060       && GOT_symbol
14061       && fixp->fx_addsy == GOT_symbol)
14062     {
14063       code = BFD_RELOC_X86_64_GOTPC64;
14064     }
14065
14066   rel = XNEW (arelent);
14067   rel->sym_ptr_ptr = XNEW (asymbol *);
14068   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
14069
14070   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
14071
14072   if (!use_rela_relocations)
14073     {
14074       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
14075          vtable entry to be used in the relocation's section offset.  */
14076       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
14077         rel->address = fixp->fx_offset;
14078 #if defined (OBJ_COFF) && defined (TE_PE)
14079       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
14080         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
14081       else
14082 #endif
14083       rel->addend = 0;
14084     }
14085   /* Use the rela in 64bit mode.  */
14086   else
14087     {
14088       if (disallow_64bit_reloc)
14089         switch (code)
14090           {
14091           case BFD_RELOC_X86_64_DTPOFF64:
14092           case BFD_RELOC_X86_64_TPOFF64:
14093           case BFD_RELOC_64_PCREL:
14094           case BFD_RELOC_X86_64_GOTOFF64:
14095           case BFD_RELOC_X86_64_GOT64:
14096           case BFD_RELOC_X86_64_GOTPCREL64:
14097           case BFD_RELOC_X86_64_GOTPC64:
14098           case BFD_RELOC_X86_64_GOTPLT64:
14099           case BFD_RELOC_X86_64_PLTOFF64:
14100             as_bad_where (fixp->fx_file, fixp->fx_line,
14101                           _("cannot represent relocation type %s in x32 mode"),
14102                           bfd_get_reloc_code_name (code));
14103             break;
14104           default:
14105             break;
14106           }
14107
14108       if (!fixp->fx_pcrel)
14109         rel->addend = fixp->fx_offset;
14110       else
14111         switch (code)
14112           {
14113           case BFD_RELOC_X86_64_PLT32:
14114           case BFD_RELOC_X86_64_GOT32:
14115           case BFD_RELOC_X86_64_GOTPCREL:
14116           case BFD_RELOC_X86_64_GOTPCRELX:
14117           case BFD_RELOC_X86_64_REX_GOTPCRELX:
14118           case BFD_RELOC_X86_64_TLSGD:
14119           case BFD_RELOC_X86_64_TLSLD:
14120           case BFD_RELOC_X86_64_GOTTPOFF:
14121           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
14122           case BFD_RELOC_X86_64_TLSDESC_CALL:
14123             rel->addend = fixp->fx_offset - fixp->fx_size;
14124             break;
14125           default:
14126             rel->addend = (section->vma
14127                            - fixp->fx_size
14128                            + fixp->fx_addnumber
14129                            + md_pcrel_from (fixp));
14130             break;
14131           }
14132     }
14133
14134   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
14135   if (rel->howto == NULL)
14136     {
14137       as_bad_where (fixp->fx_file, fixp->fx_line,
14138                     _("cannot represent relocation type %s"),
14139                     bfd_get_reloc_code_name (code));
14140       /* Set howto to a garbage value so that we can keep going.  */
14141       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
14142       gas_assert (rel->howto != NULL);
14143     }
14144
14145   return rel;
14146 }
14147
14148 #include "tc-i386-intel.c"
14149
14150 void
14151 tc_x86_parse_to_dw2regnum (expressionS *exp)
14152 {
14153   int saved_naked_reg;
14154   char saved_register_dot;
14155
14156   saved_naked_reg = allow_naked_reg;
14157   allow_naked_reg = 1;
14158   saved_register_dot = register_chars['.'];
14159   register_chars['.'] = '.';
14160   allow_pseudo_reg = 1;
14161   expression_and_evaluate (exp);
14162   allow_pseudo_reg = 0;
14163   register_chars['.'] = saved_register_dot;
14164   allow_naked_reg = saved_naked_reg;
14165
14166   if (exp->X_op == O_register && exp->X_add_number >= 0)
14167     {
14168       if ((addressT) exp->X_add_number < i386_regtab_size)
14169         {
14170           exp->X_op = O_constant;
14171           exp->X_add_number = i386_regtab[exp->X_add_number]
14172                               .dw2_regnum[flag_code >> 1];
14173         }
14174       else
14175         exp->X_op = O_illegal;
14176     }
14177 }
14178
14179 void
14180 tc_x86_frame_initial_instructions (void)
14181 {
14182   static unsigned int sp_regno[2];
14183
14184   if (!sp_regno[flag_code >> 1])
14185     {
14186       char *saved_input = input_line_pointer;
14187       char sp[][4] = {"esp", "rsp"};
14188       expressionS exp;
14189
14190       input_line_pointer = sp[flag_code >> 1];
14191       tc_x86_parse_to_dw2regnum (&exp);
14192       gas_assert (exp.X_op == O_constant);
14193       sp_regno[flag_code >> 1] = exp.X_add_number;
14194       input_line_pointer = saved_input;
14195     }
14196
14197   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
14198   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
14199 }
14200
14201 int
14202 x86_dwarf2_addr_size (void)
14203 {
14204 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
14205   if (x86_elf_abi == X86_64_X32_ABI)
14206     return 4;
14207 #endif
14208   return bfd_arch_bits_per_address (stdoutput) / 8;
14209 }
14210
14211 int
14212 i386_elf_section_type (const char *str, size_t len)
14213 {
14214   if (flag_code == CODE_64BIT
14215       && len == sizeof ("unwind") - 1
14216       && strncmp (str, "unwind", 6) == 0)
14217     return SHT_X86_64_UNWIND;
14218
14219   return -1;
14220 }
14221
14222 #ifdef TE_SOLARIS
14223 void
14224 i386_solaris_fix_up_eh_frame (segT sec)
14225 {
14226   if (flag_code == CODE_64BIT)
14227     elf_section_type (sec) = SHT_X86_64_UNWIND;
14228 }
14229 #endif
14230
14231 #ifdef TE_PE
14232 void
14233 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
14234 {
14235   expressionS exp;
14236
14237   exp.X_op = O_secrel;
14238   exp.X_add_symbol = symbol;
14239   exp.X_add_number = 0;
14240   emit_expr (&exp, size);
14241 }
14242 #endif
14243
14244 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
14245 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
14246
14247 bfd_vma
14248 x86_64_section_letter (int letter, const char **ptr_msg)
14249 {
14250   if (flag_code == CODE_64BIT)
14251     {
14252       if (letter == 'l')
14253         return SHF_X86_64_LARGE;
14254
14255       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
14256     }
14257   else
14258     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
14259   return -1;
14260 }
14261
14262 bfd_vma
14263 x86_64_section_word (char *str, size_t len)
14264 {
14265   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
14266     return SHF_X86_64_LARGE;
14267
14268   return -1;
14269 }
14270
14271 static void
14272 handle_large_common (int small ATTRIBUTE_UNUSED)
14273 {
14274   if (flag_code != CODE_64BIT)
14275     {
14276       s_comm_internal (0, elf_common_parse);
14277       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
14278     }
14279   else
14280     {
14281       static segT lbss_section;
14282       asection *saved_com_section_ptr = elf_com_section_ptr;
14283       asection *saved_bss_section = bss_section;
14284
14285       if (lbss_section == NULL)
14286         {
14287           flagword applicable;
14288           segT seg = now_seg;
14289           subsegT subseg = now_subseg;
14290
14291           /* The .lbss section is for local .largecomm symbols.  */
14292           lbss_section = subseg_new (".lbss", 0);
14293           applicable = bfd_applicable_section_flags (stdoutput);
14294           bfd_set_section_flags (lbss_section, applicable & SEC_ALLOC);
14295           seg_info (lbss_section)->bss = 1;
14296
14297           subseg_set (seg, subseg);
14298         }
14299
14300       elf_com_section_ptr = &_bfd_elf_large_com_section;
14301       bss_section = lbss_section;
14302
14303       s_comm_internal (0, elf_common_parse);
14304
14305       elf_com_section_ptr = saved_com_section_ptr;
14306       bss_section = saved_bss_section;
14307     }
14308 }
14309 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */