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         /* Use MASK state.  */
 379         xstate_mask = 1 << 5
 380       } xstate;
 381
 382     /* Has GOTPC or TLS relocation.  */
 383     bfd_boolean has_gotpc_tls_reloc;
 384
 385     /* RM and SIB are the modrm byte and the sib byte where the
 386        addressing modes of this insn are encoded.  */
 387     modrm_byte rm;
 388     rex_byte rex;
 389     rex_byte vrex;
 390     sib_byte sib;
 391     vex_prefix vex;
 392
 393     /* Masking attributes.  */
 394     struct Mask_Operation *mask;
 395
 396     /* Rounding control and SAE attributes.  */
 397     struct RC_Operation *rounding;
 398
 399     /* Broadcasting attributes.  */
 400     struct Broadcast_Operation *broadcast;
 401
 402     /* Compressed disp8*N attribute.  */
 403     unsigned int memshift;
 404
 405     /* Prefer load or store in encoding.  */
 406     enum
 407       {
 408         dir_encoding_default = 0,
 409         dir_encoding_load,
 410         dir_encoding_store,
 411         dir_encoding_swap
 412       } dir_encoding;
 413
 414     /* Prefer 8bit, 16bit, 32bit displacement in encoding.  */
 415     enum
 416       {
 417         disp_encoding_default = 0,
 418         disp_encoding_8bit,
 419         disp_encoding_16bit,
 420         disp_encoding_32bit
 421       } disp_encoding;
 422
 423     /* Prefer the REX byte in encoding.  */
 424     bfd_boolean rex_encoding;
 425
 426     /* Disable instruction size optimization.  */
 427     bfd_boolean no_optimize;
 428
 429     /* How to encode vector instructions.  */
 430     enum
 431       {
 432         vex_encoding_default = 0,
 433         vex_encoding_vex,
 434         vex_encoding_vex3,
 435         vex_encoding_evex,
 436         vex_encoding_error
 437       } vec_encoding;
 438
 439     /* REP prefix.  */
 440     const char *rep_prefix;
 441
 442     /* HLE prefix.  */
 443     const char *hle_prefix;
 444
 445     /* Have BND prefix.  */
 446     const char *bnd_prefix;
 447
 448     /* Have NOTRACK prefix.  */
 449     const char *notrack_prefix;
 450
 451     /* Error message.  */
 452     enum i386_error error;
 453   };
 454
 455 typedef struct _i386_insn i386_insn;
 456
 457 /* Link RC type with corresponding string, that'll be looked for in
 458    asm.  */
 459 struct RC_name
 460 {
 461   enum rc_type type;
 462   const char *name;
 463   unsigned int len;
 464 };
 465
 466 static const struct RC_name RC_NamesTable[] =
 467 {
 468   {  rne, STRING_COMMA_LEN ("rn-sae") },
 469   {  rd,  STRING_COMMA_LEN ("rd-sae") },
 470   {  ru,  STRING_COMMA_LEN ("ru-sae") },
 471   {  rz,  STRING_COMMA_LEN ("rz-sae") },
 472   {  saeonly,  STRING_COMMA_LEN ("sae") },
 473 };
 474
 475 /* List of chars besides those in app.c:symbol_chars that can start an
 476    operand.  Used to prevent the scrubber eating vital white-space.  */
 477 const char extra_symbol_chars[] = "*%-([{}"
 478 #ifdef LEX_AT
 479         "@"
 480 #endif
 481 #ifdef LEX_QM
 482         "?"
 483 #endif
 484         ;
 485
 486 #if ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))     \
 487      && !defined (TE_GNU)                               \
 488      && !defined (TE_LINUX)                             \
 489      && !defined (TE_FreeBSD)                           \
 490      && !defined (TE_DragonFly)                         \
 491      && !defined (TE_NetBSD))
 492 /* This array holds the chars that always start a comment.  If the
 493    pre-processor is disabled, these aren't very useful.  The option
 494    --divide will remove '/' from this list.  */
 495 const char *i386_comment_chars = "#/";
 496 #define SVR4_COMMENT_CHARS 1
 497 #define PREFIX_SEPARATOR '\\'
 498
 499 #else
 500 const char *i386_comment_chars = "#";
 501 #define PREFIX_SEPARATOR '/'
 502 #endif
 503
 504 /* This array holds the chars that only start a comment at the beginning of
 505    a line.  If the line seems to have the form '# 123 filename'
 506    .line and .file directives will appear in the pre-processed output.
 507    Note that input_file.c hand checks for '#' at the beginning of the
 508    first line of the input file.  This is because the compiler outputs
 509    #NO_APP at the beginning of its output.
 510    Also note that comments started like this one will always work if
 511    '/' isn't otherwise defined.  */
 512 const char line_comment_chars[] = "#/";
 513
 514 const char line_separator_chars[] = ";";
 515
 516 /* Chars that can be used to separate mant from exp in floating point
 517    nums.  */
 518 const char EXP_CHARS[] = "eE";
 519
 520 /* Chars that mean this number is a floating point constant
 521    As in 0f12.456
 522    or    0d1.2345e12.  */
 523 const char FLT_CHARS[] = "fFdDxX";
 524
 525 /* Tables for lexical analysis.  */
 526 static char mnemonic_chars[256];
 527 static char register_chars[256];
 528 static char operand_chars[256];
 529 static char identifier_chars[256];
 530 static char digit_chars[256];
 531
 532 /* Lexical macros.  */
 533 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 534 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 535 #define is_register_char(x) (register_chars[(unsigned char) x])
 536 #define is_space_char(x) ((x) == ' ')
 537 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 538 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 539
 540 /* All non-digit non-letter characters that may occur in an operand.  */
 541 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 542
 543 /* md_assemble() always leaves the strings it's passed unaltered.  To
 544    effect this we maintain a stack of saved characters that we've smashed
 545    with '\0's (indicating end of strings for various sub-fields of the
 546    assembler instruction).  */
 547 static char save_stack[32];
 548 static char *save_stack_p;
 549 #define END_STRING_AND_SAVE(s) \
 550         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 551 #define RESTORE_END_STRING(s) \
 552         do { *(s) = *--save_stack_p; } while (0)
 553
 554 /* The instruction we're assembling.  */
 555 static i386_insn i;
 556
 557 /* Possible templates for current insn.  */
 558 static const templates *current_templates;
 559
 560 /* Per instruction expressionS buffers: max displacements & immediates.  */
 561 static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
 562 static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
 563
 564 /* Current operand we are working on.  */
 565 static int this_operand = -1;
 566
 567 /* We support four different modes.  FLAG_CODE variable is used to distinguish
 568    these.  */
 569
 570 enum flag_code {
 571         CODE_32BIT,
 572         CODE_16BIT,
 573         CODE_64BIT };
 574
 575 static enum flag_code flag_code;
 576 static unsigned int object_64bit;
 577 static unsigned int disallow_64bit_reloc;
 578 static int use_rela_relocations = 0;
 579 /* __tls_get_addr/___tls_get_addr symbol for TLS.  */
 580 static const char *tls_get_addr;
 581
 582 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
 583      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
 584      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
 585
 586 /* The ELF ABI to use.  */
 587 enum x86_elf_abi
 588 {
 589   I386_ABI,
 590   X86_64_ABI,
 591   X86_64_X32_ABI
 592 };
 593
 594 static enum x86_elf_abi x86_elf_abi = I386_ABI;
 595 #endif
 596
 597 #if defined (TE_PE) || defined (TE_PEP)
 598 /* Use big object file format.  */
 599 static int use_big_obj = 0;
 600 #endif
 601
 602 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 603 /* 1 if generating code for a shared library.  */
 604 static int shared = 0;
 605 #endif
 606
 607 /* 1 for intel syntax,
 608    0 if att syntax.  */
 609 static int intel_syntax = 0;
 610
 611 static enum x86_64_isa
 612 {
 613   amd64 = 1,    /* AMD64 ISA.  */
 614   intel64       /* Intel64 ISA.  */
 615 } isa64;
 616
 617 /* 1 for intel mnemonic,
 618    0 if att mnemonic.  */
 619 static int intel_mnemonic = !SYSV386_COMPAT;
 620
 621 /* 1 if pseudo registers are permitted.  */
 622 static int allow_pseudo_reg = 0;
 623
 624 /* 1 if register prefix % not required.  */
 625 static int allow_naked_reg = 0;
 626
 627 /* 1 if the assembler should add BND prefix for all control-transferring
 628    instructions supporting it, even if this prefix wasn't specified
 629    explicitly.  */
 630 static int add_bnd_prefix = 0;
 631
 632 /* 1 if pseudo index register, eiz/riz, is allowed .  */
 633 static int allow_index_reg = 0;
 634
 635 /* 1 if the assembler should ignore LOCK prefix, even if it was
 636    specified explicitly.  */
 637 static int omit_lock_prefix = 0;
 638
 639 /* 1 if the assembler should encode lfence, mfence, and sfence as
 640    "lock addl $0, (%{re}sp)".  */
 641 static int avoid_fence = 0;
 642
 643 /* 1 if lfence should be inserted after every load.  */
 644 static int lfence_after_load = 0;
 645
 646 /* Non-zero if lfence should be inserted before indirect branch.  */
 647 static enum lfence_before_indirect_branch_kind
 648   {
 649     lfence_branch_none = 0,
 650     lfence_branch_register,
 651     lfence_branch_memory,
 652     lfence_branch_all
 653   }
 654 lfence_before_indirect_branch;
 655
 656 /* Non-zero if lfence should be inserted before ret.  */
 657 static enum lfence_before_ret_kind
 658   {
 659     lfence_before_ret_none = 0,
 660     lfence_before_ret_not,
 661     lfence_before_ret_or,
 662     lfence_before_ret_shl
 663   }
 664 lfence_before_ret;
 665
 666 /* Types of previous instruction is .byte or prefix.  */
 667 static struct
 668   {
 669     segT seg;
 670     const char *file;
 671     const char *name;
 672     unsigned int line;
 673     enum last_insn_kind
 674       {
 675         last_insn_other = 0,
 676         last_insn_directive,
 677         last_insn_prefix
 678       } kind;
 679   } last_insn;
 680
 681 /* 1 if the assembler should generate relax relocations.  */
 682
 683 static int generate_relax_relocations
 684   = DEFAULT_GENERATE_X86_RELAX_RELOCATIONS;
 685
 686 static enum check_kind
 687   {
 688     check_none = 0,
 689     check_warning,
 690     check_error
 691   }
 692 sse_check, operand_check = check_warning;
 693
 694 /* Non-zero if branches should be aligned within power of 2 boundary.  */
 695 static int align_branch_power = 0;
 696
 697 /* Types of branches to align.  */
 698 enum align_branch_kind
 699   {
 700     align_branch_none = 0,
 701     align_branch_jcc = 1,
 702     align_branch_fused = 2,
 703     align_branch_jmp = 3,
 704     align_branch_call = 4,
 705     align_branch_indirect = 5,
 706     align_branch_ret = 6
 707   };
 708
 709 /* Type bits of branches to align.  */
 710 enum align_branch_bit
 711   {
 712     align_branch_jcc_bit = 1 << align_branch_jcc,
 713     align_branch_fused_bit = 1 << align_branch_fused,
 714     align_branch_jmp_bit = 1 << align_branch_jmp,
 715     align_branch_call_bit = 1 << align_branch_call,
 716     align_branch_indirect_bit = 1 << align_branch_indirect,
 717     align_branch_ret_bit = 1 << align_branch_ret
 718   };
 719
 720 static unsigned int align_branch = (align_branch_jcc_bit
 721                                     | align_branch_fused_bit
 722                                     | align_branch_jmp_bit);
 723
 724 /* Types of condition jump used by macro-fusion.  */
 725 enum mf_jcc_kind
 726   {
 727     mf_jcc_jo = 0,  /* base opcode 0x70  */
 728     mf_jcc_jc,      /* base opcode 0x72  */
 729     mf_jcc_je,      /* base opcode 0x74  */
 730     mf_jcc_jna,     /* base opcode 0x76  */
 731     mf_jcc_js,      /* base opcode 0x78  */
 732     mf_jcc_jp,      /* base opcode 0x7a  */
 733     mf_jcc_jl,      /* base opcode 0x7c  */
 734     mf_jcc_jle,     /* base opcode 0x7e  */
 735   };
 736
 737 /* Types of compare flag-modifying insntructions used by macro-fusion.  */
 738 enum mf_cmp_kind
 739   {
 740     mf_cmp_test_and,  /* test/cmp */
 741     mf_cmp_alu_cmp,  /* add/sub/cmp */
 742     mf_cmp_incdec  /* inc/dec */
 743   };
 744
 745 /* The maximum padding size for fused jcc.  CMP like instruction can
 746    be 9 bytes and jcc can be 6 bytes.  Leave room just in case for
 747    prefixes.   */
 748 #define MAX_FUSED_JCC_PADDING_SIZE 20
 749
 750 /* The maximum number of prefixes added for an instruction.  */
 751 static unsigned int align_branch_prefix_size = 5;
 752
 753 /* Optimization:
 754    1. Clear the REX_W bit with register operand if possible.
 755    2. Above plus use 128bit vector instruction to clear the full vector
 756       register.
 757  */
 758 static int optimize = 0;
 759
 760 /* Optimization:
 761    1. Clear the REX_W bit with register operand if possible.
 762    2. Above plus use 128bit vector instruction to clear the full vector
 763       register.
 764    3. Above plus optimize "test{q,l,w} $imm8,%r{64,32,16}" to
 765       "testb $imm7,%r8".
 766  */
 767 static int optimize_for_space = 0;
 768
 769 /* Register prefix used for error message.  */
 770 static const char *register_prefix = "%";
 771
 772 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
 773    leave, push, and pop instructions so that gcc has the same stack
 774    frame as in 32 bit mode.  */
 775 static char stackop_size = '\0';
 776
 777 /* Non-zero to optimize code alignment.  */
 778 int optimize_align_code = 1;
 779
 780 /* Non-zero to quieten some warnings.  */
 781 static int quiet_warnings = 0;
 782
 783 /* CPU name.  */
 784 static const char *cpu_arch_name = NULL;
 785 static char *cpu_sub_arch_name = NULL;
 786
 787 /* CPU feature flags.  */
 788 static i386_cpu_flags cpu_arch_flags = CPU_UNKNOWN_FLAGS;
 789
 790 /* If we have selected a cpu we are generating instructions for.  */
 791 static int cpu_arch_tune_set = 0;
 792
 793 /* Cpu we are generating instructions for.  */
 794 enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
 795
 796 /* CPU feature flags of cpu we are generating instructions for.  */
 797 static i386_cpu_flags cpu_arch_tune_flags;
 798
 799 /* CPU instruction set architecture used.  */
 800 enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
 801
 802 /* CPU feature flags of instruction set architecture used.  */
 803 i386_cpu_flags cpu_arch_isa_flags;
 804
 805 /* If set, conditional jumps are not automatically promoted to handle
 806    larger than a byte offset.  */
 807 static unsigned int no_cond_jump_promotion = 0;
 808
 809 /* Encode SSE instructions with VEX prefix.  */
 810 static unsigned int sse2avx;
 811
 812 /* Encode scalar AVX instructions with specific vector length.  */
 813 static enum
 814   {
 815     vex128 = 0,
 816     vex256
 817   } avxscalar;
 818
 819 /* Encode VEX WIG instructions with specific vex.w.  */
 820 static enum
 821   {
 822     vexw0 = 0,
 823     vexw1
 824   } vexwig;
 825
 826 /* Encode scalar EVEX LIG instructions with specific vector length.  */
 827 static enum
 828   {
 829     evexl128 = 0,
 830     evexl256,
 831     evexl512
 832   } evexlig;
 833
 834 /* Encode EVEX WIG instructions with specific evex.w.  */
 835 static enum
 836   {
 837     evexw0 = 0,
 838     evexw1
 839   } evexwig;
 840
 841 /* Value to encode in EVEX RC bits, for SAE-only instructions.  */
 842 static enum rc_type evexrcig = rne;
 843
 844 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 845 static symbolS *GOT_symbol;
 846
 847 /* The dwarf2 return column, adjusted for 32 or 64 bit.  */
 848 unsigned int x86_dwarf2_return_column;
 849
 850 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
 851 int x86_cie_data_alignment;
 852
 853 /* Interface to relax_segment.
 854    There are 3 major relax states for 386 jump insns because the
 855    different types of jumps add different sizes to frags when we're
 856    figuring out what sort of jump to choose to reach a given label.
 857
 858    BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING are used to align
 859    branches which are handled by md_estimate_size_before_relax() and
 860    i386_generic_table_relax_frag().  */
 861
 862 /* Types.  */
 863 #define UNCOND_JUMP 0
 864 #define COND_JUMP 1
 865 #define COND_JUMP86 2
 866 #define BRANCH_PADDING 3
 867 #define BRANCH_PREFIX 4
 868 #define FUSED_JCC_PADDING 5
 869
 870 /* Sizes.  */
 871 #define CODE16  1
 872 #define SMALL   0
 873 #define SMALL16 (SMALL | CODE16)
 874 #define BIG     2
 875 #define BIG16   (BIG | CODE16)
 876
 877 #ifndef INLINE
 878 #ifdef __GNUC__
 879 #define INLINE __inline__
 880 #else
 881 #define INLINE
 882 #endif
 883 #endif
 884
 885 #define ENCODE_RELAX_STATE(type, size) \
 886   ((relax_substateT) (((type) << 2) | (size)))
 887 #define TYPE_FROM_RELAX_STATE(s) \
 888   ((s) >> 2)
 889 #define DISP_SIZE_FROM_RELAX_STATE(s) \
 890     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
 891
 892 /* This table is used by relax_frag to promote short jumps to long
 893    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 894    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 895    don't allow a short jump in a 32 bit code segment to be promoted to
 896    a 16 bit offset jump because it's slower (requires data size
 897    prefix), and doesn't work, unless the destination is in the bottom
 898    64k of the code segment (The top 16 bits of eip are zeroed).  */
 899
 900 const relax_typeS md_relax_table[] =
 901 {
 902   /* The fields are:
 903      1) most positive reach of this state,
 904      2) most negative reach of this state,
 905      3) how many bytes this mode will have in the variable part of the frag
 906      4) which index into the table to try if we can't fit into this one.  */
 907
 908   /* UNCOND_JUMP states.  */
 909   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 910   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 911   /* dword jmp adds 4 bytes to frag:
 912      0 extra opcode bytes, 4 displacement bytes.  */
 913   {0, 0, 4, 0},
 914   /* word jmp adds 2 byte2 to frag:
 915      0 extra opcode bytes, 2 displacement bytes.  */
 916   {0, 0, 2, 0},
 917
 918   /* COND_JUMP states.  */
 919   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 920   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 921   /* dword conditionals adds 5 bytes to frag:
 922      1 extra opcode byte, 4 displacement bytes.  */
 923   {0, 0, 5, 0},
 924   /* word conditionals add 3 bytes to frag:
 925      1 extra opcode byte, 2 displacement bytes.  */
 926   {0, 0, 3, 0},
 927
 928   /* COND_JUMP86 states.  */
 929   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
 930   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
 931   /* dword conditionals adds 5 bytes to frag:
 932      1 extra opcode byte, 4 displacement bytes.  */
 933   {0, 0, 5, 0},
 934   /* word conditionals add 4 bytes to frag:
 935      1 displacement byte and a 3 byte long branch insn.  */
 936   {0, 0, 4, 0}
 937 };
 938
 939 static const arch_entry cpu_arch[] =
 940 {
 941   /* Do not replace the first two entries - i386_target_format()
 942      relies on them being there in this order.  */
 943   { STRING_COMMA_LEN ("generic32"), PROCESSOR_GENERIC32,
 944     CPU_GENERIC32_FLAGS, 0 },
 945   { STRING_COMMA_LEN ("generic64"), PROCESSOR_GENERIC64,
 946     CPU_GENERIC64_FLAGS, 0 },
 947   { STRING_COMMA_LEN ("i8086"), PROCESSOR_UNKNOWN,
 948     CPU_NONE_FLAGS, 0 },
 949   { STRING_COMMA_LEN ("i186"), PROCESSOR_UNKNOWN,
 950     CPU_I186_FLAGS, 0 },
 951   { STRING_COMMA_LEN ("i286"), PROCESSOR_UNKNOWN,
 952     CPU_I286_FLAGS, 0 },
 953   { STRING_COMMA_LEN ("i386"), PROCESSOR_I386,
 954     CPU_I386_FLAGS, 0 },
 955   { STRING_COMMA_LEN ("i486"), PROCESSOR_I486,
 956     CPU_I486_FLAGS, 0 },
 957   { STRING_COMMA_LEN ("i586"), PROCESSOR_PENTIUM,
 958     CPU_I586_FLAGS, 0 },
 959   { STRING_COMMA_LEN ("i686"), PROCESSOR_PENTIUMPRO,
 960     CPU_I686_FLAGS, 0 },
 961   { STRING_COMMA_LEN ("pentium"), PROCESSOR_PENTIUM,
 962     CPU_I586_FLAGS, 0 },
 963   { STRING_COMMA_LEN ("pentiumpro"), PROCESSOR_PENTIUMPRO,
 964     CPU_PENTIUMPRO_FLAGS, 0 },
 965   { STRING_COMMA_LEN ("pentiumii"), PROCESSOR_PENTIUMPRO,
 966     CPU_P2_FLAGS, 0 },
 967   { STRING_COMMA_LEN ("pentiumiii"),PROCESSOR_PENTIUMPRO,
 968     CPU_P3_FLAGS, 0 },
 969   { STRING_COMMA_LEN ("pentium4"), PROCESSOR_PENTIUM4,
 970     CPU_P4_FLAGS, 0 },
 971   { STRING_COMMA_LEN ("prescott"), PROCESSOR_NOCONA,
 972     CPU_CORE_FLAGS, 0 },
 973   { STRING_COMMA_LEN ("nocona"), PROCESSOR_NOCONA,
 974     CPU_NOCONA_FLAGS, 0 },
 975   { STRING_COMMA_LEN ("yonah"), PROCESSOR_CORE,
 976     CPU_CORE_FLAGS, 1 },
 977   { STRING_COMMA_LEN ("core"), PROCESSOR_CORE,
 978     CPU_CORE_FLAGS, 0 },
 979   { STRING_COMMA_LEN ("merom"), PROCESSOR_CORE2,
 980     CPU_CORE2_FLAGS, 1 },
 981   { STRING_COMMA_LEN ("core2"), PROCESSOR_CORE2,
 982     CPU_CORE2_FLAGS, 0 },
 983   { STRING_COMMA_LEN ("corei7"), PROCESSOR_COREI7,
 984     CPU_COREI7_FLAGS, 0 },
 985   { STRING_COMMA_LEN ("l1om"), PROCESSOR_L1OM,
 986     CPU_L1OM_FLAGS, 0 },
 987   { STRING_COMMA_LEN ("k1om"), PROCESSOR_K1OM,
 988     CPU_K1OM_FLAGS, 0 },
 989   { STRING_COMMA_LEN ("iamcu"), PROCESSOR_IAMCU,
 990     CPU_IAMCU_FLAGS, 0 },
 991   { STRING_COMMA_LEN ("k6"), PROCESSOR_K6,
 992     CPU_K6_FLAGS, 0 },
 993   { STRING_COMMA_LEN ("k6_2"), PROCESSOR_K6,
 994     CPU_K6_2_FLAGS, 0 },
 995   { STRING_COMMA_LEN ("athlon"), PROCESSOR_ATHLON,
 996     CPU_ATHLON_FLAGS, 0 },
 997   { STRING_COMMA_LEN ("sledgehammer"), PROCESSOR_K8,
 998     CPU_K8_FLAGS, 1 },
 999   { STRING_COMMA_LEN ("opteron"), PROCESSOR_K8,
1000     CPU_K8_FLAGS, 0 },
1001   { STRING_COMMA_LEN ("k8"), PROCESSOR_K8,
1002     CPU_K8_FLAGS, 0 },
1003   { STRING_COMMA_LEN ("amdfam10"), PROCESSOR_AMDFAM10,
1004     CPU_AMDFAM10_FLAGS, 0 },
1005   { STRING_COMMA_LEN ("bdver1"), PROCESSOR_BD,
1006     CPU_BDVER1_FLAGS, 0 },
1007   { STRING_COMMA_LEN ("bdver2"), PROCESSOR_BD,
1008     CPU_BDVER2_FLAGS, 0 },
1009   { STRING_COMMA_LEN ("bdver3"), PROCESSOR_BD,
1010     CPU_BDVER3_FLAGS, 0 },
1011   { STRING_COMMA_LEN ("bdver4"), PROCESSOR_BD,
1012     CPU_BDVER4_FLAGS, 0 },
1013   { STRING_COMMA_LEN ("znver1"), PROCESSOR_ZNVER,
1014     CPU_ZNVER1_FLAGS, 0 },
1015   { STRING_COMMA_LEN ("znver2"), PROCESSOR_ZNVER,
1016     CPU_ZNVER2_FLAGS, 0 },
1017   { STRING_COMMA_LEN ("znver3"), PROCESSOR_ZNVER,
1018     CPU_ZNVER3_FLAGS, 0 },
1019   { STRING_COMMA_LEN ("btver1"), PROCESSOR_BT,
1020     CPU_BTVER1_FLAGS, 0 },
1021   { STRING_COMMA_LEN ("btver2"), PROCESSOR_BT,
1022     CPU_BTVER2_FLAGS, 0 },
1023   { STRING_COMMA_LEN (".8087"), PROCESSOR_UNKNOWN,
1024     CPU_8087_FLAGS, 0 },
1025   { STRING_COMMA_LEN (".287"), PROCESSOR_UNKNOWN,
1026     CPU_287_FLAGS, 0 },
1027   { STRING_COMMA_LEN (".387"), PROCESSOR_UNKNOWN,
1028     CPU_387_FLAGS, 0 },
1029   { STRING_COMMA_LEN (".687"), PROCESSOR_UNKNOWN,
1030     CPU_687_FLAGS, 0 },
1031   { STRING_COMMA_LEN (".cmov"), PROCESSOR_UNKNOWN,
1032     CPU_CMOV_FLAGS, 0 },
1033   { STRING_COMMA_LEN (".fxsr"), PROCESSOR_UNKNOWN,
1034     CPU_FXSR_FLAGS, 0 },
1035   { STRING_COMMA_LEN (".mmx"), PROCESSOR_UNKNOWN,
1036     CPU_MMX_FLAGS, 0 },
1037   { STRING_COMMA_LEN (".sse"), PROCESSOR_UNKNOWN,
1038     CPU_SSE_FLAGS, 0 },
1039   { STRING_COMMA_LEN (".sse2"), PROCESSOR_UNKNOWN,
1040     CPU_SSE2_FLAGS, 0 },
1041   { STRING_COMMA_LEN (".sse3"), PROCESSOR_UNKNOWN,
1042     CPU_SSE3_FLAGS, 0 },
1043   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
1044     CPU_SSE4A_FLAGS, 0 },
1045   { STRING_COMMA_LEN (".ssse3"), PROCESSOR_UNKNOWN,
1046     CPU_SSSE3_FLAGS, 0 },
1047   { STRING_COMMA_LEN (".sse4.1"), PROCESSOR_UNKNOWN,
1048     CPU_SSE4_1_FLAGS, 0 },
1049   { STRING_COMMA_LEN (".sse4.2"), PROCESSOR_UNKNOWN,
1050     CPU_SSE4_2_FLAGS, 0 },
1051   { STRING_COMMA_LEN (".sse4"), PROCESSOR_UNKNOWN,
1052     CPU_SSE4_2_FLAGS, 0 },
1053   { STRING_COMMA_LEN (".avx"), PROCESSOR_UNKNOWN,
1054     CPU_AVX_FLAGS, 0 },
1055   { STRING_COMMA_LEN (".avx2"), PROCESSOR_UNKNOWN,
1056     CPU_AVX2_FLAGS, 0 },
1057   { STRING_COMMA_LEN (".avx512f"), PROCESSOR_UNKNOWN,
1058     CPU_AVX512F_FLAGS, 0 },
1059   { STRING_COMMA_LEN (".avx512cd"), PROCESSOR_UNKNOWN,
1060     CPU_AVX512CD_FLAGS, 0 },
1061   { STRING_COMMA_LEN (".avx512er"), PROCESSOR_UNKNOWN,
1062     CPU_AVX512ER_FLAGS, 0 },
1063   { STRING_COMMA_LEN (".avx512pf"), PROCESSOR_UNKNOWN,
1064     CPU_AVX512PF_FLAGS, 0 },
1065   { STRING_COMMA_LEN (".avx512dq"), PROCESSOR_UNKNOWN,
1066     CPU_AVX512DQ_FLAGS, 0 },
1067   { STRING_COMMA_LEN (".avx512bw"), PROCESSOR_UNKNOWN,
1068     CPU_AVX512BW_FLAGS, 0 },
1069   { STRING_COMMA_LEN (".avx512vl"), PROCESSOR_UNKNOWN,
1070     CPU_AVX512VL_FLAGS, 0 },
1071   { STRING_COMMA_LEN (".vmx"), PROCESSOR_UNKNOWN,
1072     CPU_VMX_FLAGS, 0 },
1073   { STRING_COMMA_LEN (".vmfunc"), PROCESSOR_UNKNOWN,
1074     CPU_VMFUNC_FLAGS, 0 },
1075   { STRING_COMMA_LEN (".smx"), PROCESSOR_UNKNOWN,
1076     CPU_SMX_FLAGS, 0 },
1077   { STRING_COMMA_LEN (".xsave"), PROCESSOR_UNKNOWN,
1078     CPU_XSAVE_FLAGS, 0 },
1079   { STRING_COMMA_LEN (".xsaveopt"), PROCESSOR_UNKNOWN,
1080     CPU_XSAVEOPT_FLAGS, 0 },
1081   { STRING_COMMA_LEN (".xsavec"), PROCESSOR_UNKNOWN,
1082     CPU_XSAVEC_FLAGS, 0 },
1083   { STRING_COMMA_LEN (".xsaves"), PROCESSOR_UNKNOWN,
1084     CPU_XSAVES_FLAGS, 0 },
1085   { STRING_COMMA_LEN (".aes"), PROCESSOR_UNKNOWN,
1086     CPU_AES_FLAGS, 0 },
1087   { STRING_COMMA_LEN (".pclmul"), PROCESSOR_UNKNOWN,
1088     CPU_PCLMUL_FLAGS, 0 },
1089   { STRING_COMMA_LEN (".clmul"), PROCESSOR_UNKNOWN,
1090     CPU_PCLMUL_FLAGS, 1 },
1091   { STRING_COMMA_LEN (".fsgsbase"), PROCESSOR_UNKNOWN,
1092     CPU_FSGSBASE_FLAGS, 0 },
1093   { STRING_COMMA_LEN (".rdrnd"), PROCESSOR_UNKNOWN,
1094     CPU_RDRND_FLAGS, 0 },
1095   { STRING_COMMA_LEN (".f16c"), PROCESSOR_UNKNOWN,
1096     CPU_F16C_FLAGS, 0 },
1097   { STRING_COMMA_LEN (".bmi2"), PROCESSOR_UNKNOWN,
1098     CPU_BMI2_FLAGS, 0 },
1099   { STRING_COMMA_LEN (".fma"), PROCESSOR_UNKNOWN,
1100     CPU_FMA_FLAGS, 0 },
1101   { STRING_COMMA_LEN (".fma4"), PROCESSOR_UNKNOWN,
1102     CPU_FMA4_FLAGS, 0 },
1103   { STRING_COMMA_LEN (".xop"), PROCESSOR_UNKNOWN,
1104     CPU_XOP_FLAGS, 0 },
1105   { STRING_COMMA_LEN (".lwp"), PROCESSOR_UNKNOWN,
1106     CPU_LWP_FLAGS, 0 },
1107   { STRING_COMMA_LEN (".movbe"), PROCESSOR_UNKNOWN,
1108     CPU_MOVBE_FLAGS, 0 },
1109   { STRING_COMMA_LEN (".cx16"), PROCESSOR_UNKNOWN,
1110     CPU_CX16_FLAGS, 0 },
1111   { STRING_COMMA_LEN (".ept"), PROCESSOR_UNKNOWN,
1112     CPU_EPT_FLAGS, 0 },
1113   { STRING_COMMA_LEN (".lzcnt"), PROCESSOR_UNKNOWN,
1114     CPU_LZCNT_FLAGS, 0 },
1115   { STRING_COMMA_LEN (".popcnt"), PROCESSOR_UNKNOWN,
1116     CPU_POPCNT_FLAGS, 0 },
1117   { STRING_COMMA_LEN (".hle"), PROCESSOR_UNKNOWN,
1118     CPU_HLE_FLAGS, 0 },
1119   { STRING_COMMA_LEN (".rtm"), PROCESSOR_UNKNOWN,
1120     CPU_RTM_FLAGS, 0 },
1121   { STRING_COMMA_LEN (".invpcid"), PROCESSOR_UNKNOWN,
1122     CPU_INVPCID_FLAGS, 0 },
1123   { STRING_COMMA_LEN (".clflush"), PROCESSOR_UNKNOWN,
1124     CPU_CLFLUSH_FLAGS, 0 },
1125   { STRING_COMMA_LEN (".nop"), PROCESSOR_UNKNOWN,
1126     CPU_NOP_FLAGS, 0 },
1127   { STRING_COMMA_LEN (".syscall"), PROCESSOR_UNKNOWN,
1128     CPU_SYSCALL_FLAGS, 0 },
1129   { STRING_COMMA_LEN (".rdtscp"), PROCESSOR_UNKNOWN,
1130     CPU_RDTSCP_FLAGS, 0 },
1131   { STRING_COMMA_LEN (".3dnow"), PROCESSOR_UNKNOWN,
1132     CPU_3DNOW_FLAGS, 0 },
1133   { STRING_COMMA_LEN (".3dnowa"), PROCESSOR_UNKNOWN,
1134     CPU_3DNOWA_FLAGS, 0 },
1135   { STRING_COMMA_LEN (".padlock"), PROCESSOR_UNKNOWN,
1136     CPU_PADLOCK_FLAGS, 0 },
1137   { STRING_COMMA_LEN (".pacifica"), PROCESSOR_UNKNOWN,
1138     CPU_SVME_FLAGS, 1 },
1139   { STRING_COMMA_LEN (".svme"), PROCESSOR_UNKNOWN,
1140     CPU_SVME_FLAGS, 0 },
1141   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
1142     CPU_SSE4A_FLAGS, 0 },
1143   { STRING_COMMA_LEN (".abm"), PROCESSOR_UNKNOWN,
1144     CPU_ABM_FLAGS, 0 },
1145   { STRING_COMMA_LEN (".bmi"), PROCESSOR_UNKNOWN,
1146     CPU_BMI_FLAGS, 0 },
1147   { STRING_COMMA_LEN (".tbm"), PROCESSOR_UNKNOWN,
1148     CPU_TBM_FLAGS, 0 },
1149   { STRING_COMMA_LEN (".adx"), PROCESSOR_UNKNOWN,
1150     CPU_ADX_FLAGS, 0 },
1151   { STRING_COMMA_LEN (".rdseed"), PROCESSOR_UNKNOWN,
1152     CPU_RDSEED_FLAGS, 0 },
1153   { STRING_COMMA_LEN (".prfchw"), PROCESSOR_UNKNOWN,
1154     CPU_PRFCHW_FLAGS, 0 },
1155   { STRING_COMMA_LEN (".smap"), PROCESSOR_UNKNOWN,
1156     CPU_SMAP_FLAGS, 0 },
1157   { STRING_COMMA_LEN (".mpx"), PROCESSOR_UNKNOWN,
1158     CPU_MPX_FLAGS, 0 },
1159   { STRING_COMMA_LEN (".sha"), PROCESSOR_UNKNOWN,
1160     CPU_SHA_FLAGS, 0 },
1161   { STRING_COMMA_LEN (".clflushopt"), PROCESSOR_UNKNOWN,
1162     CPU_CLFLUSHOPT_FLAGS, 0 },
1163   { STRING_COMMA_LEN (".prefetchwt1"), PROCESSOR_UNKNOWN,
1164     CPU_PREFETCHWT1_FLAGS, 0 },
1165   { STRING_COMMA_LEN (".se1"), PROCESSOR_UNKNOWN,
1166     CPU_SE1_FLAGS, 0 },
1167   { STRING_COMMA_LEN (".clwb"), PROCESSOR_UNKNOWN,
1168     CPU_CLWB_FLAGS, 0 },
1169   { STRING_COMMA_LEN (".avx512ifma"), PROCESSOR_UNKNOWN,
1170     CPU_AVX512IFMA_FLAGS, 0 },
1171   { STRING_COMMA_LEN (".avx512vbmi"), PROCESSOR_UNKNOWN,
1172     CPU_AVX512VBMI_FLAGS, 0 },
1173   { STRING_COMMA_LEN (".avx512_4fmaps"), PROCESSOR_UNKNOWN,
1174     CPU_AVX512_4FMAPS_FLAGS, 0 },
1175   { STRING_COMMA_LEN (".avx512_4vnniw"), PROCESSOR_UNKNOWN,
1176     CPU_AVX512_4VNNIW_FLAGS, 0 },
1177   { STRING_COMMA_LEN (".avx512_vpopcntdq"), PROCESSOR_UNKNOWN,
1178     CPU_AVX512_VPOPCNTDQ_FLAGS, 0 },
1179   { STRING_COMMA_LEN (".avx512_vbmi2"), PROCESSOR_UNKNOWN,
1180     CPU_AVX512_VBMI2_FLAGS, 0 },
1181   { STRING_COMMA_LEN (".avx512_vnni"), PROCESSOR_UNKNOWN,
1182     CPU_AVX512_VNNI_FLAGS, 0 },
1183   { STRING_COMMA_LEN (".avx512_bitalg"), PROCESSOR_UNKNOWN,
1184     CPU_AVX512_BITALG_FLAGS, 0 },
1185   { STRING_COMMA_LEN (".avx_vnni"), PROCESSOR_UNKNOWN,
1186     CPU_AVX_VNNI_FLAGS, 0 },
1187   { STRING_COMMA_LEN (".clzero"), PROCESSOR_UNKNOWN,
1188     CPU_CLZERO_FLAGS, 0 },
1189   { STRING_COMMA_LEN (".mwaitx"), PROCESSOR_UNKNOWN,
1190     CPU_MWAITX_FLAGS, 0 },
1191   { STRING_COMMA_LEN (".ospke"), PROCESSOR_UNKNOWN,
1192     CPU_OSPKE_FLAGS, 0 },
1193   { STRING_COMMA_LEN (".rdpid"), PROCESSOR_UNKNOWN,
1194     CPU_RDPID_FLAGS, 0 },
1195   { STRING_COMMA_LEN (".ptwrite"), PROCESSOR_UNKNOWN,
1196     CPU_PTWRITE_FLAGS, 0 },
1197   { STRING_COMMA_LEN (".ibt"), PROCESSOR_UNKNOWN,
1198     CPU_IBT_FLAGS, 0 },
1199   { STRING_COMMA_LEN (".shstk"), PROCESSOR_UNKNOWN,
1200     CPU_SHSTK_FLAGS, 0 },
1201   { STRING_COMMA_LEN (".gfni"), PROCESSOR_UNKNOWN,
1202     CPU_GFNI_FLAGS, 0 },
1203   { STRING_COMMA_LEN (".vaes"), PROCESSOR_UNKNOWN,
1204     CPU_VAES_FLAGS, 0 },
1205   { STRING_COMMA_LEN (".vpclmulqdq"), PROCESSOR_UNKNOWN,
1206     CPU_VPCLMULQDQ_FLAGS, 0 },
1207   { STRING_COMMA_LEN (".wbnoinvd"), PROCESSOR_UNKNOWN,
1208     CPU_WBNOINVD_FLAGS, 0 },
1209   { STRING_COMMA_LEN (".pconfig"), PROCESSOR_UNKNOWN,
1210     CPU_PCONFIG_FLAGS, 0 },
1211   { STRING_COMMA_LEN (".waitpkg"), PROCESSOR_UNKNOWN,
1212     CPU_WAITPKG_FLAGS, 0 },
1213   { STRING_COMMA_LEN (".cldemote"), PROCESSOR_UNKNOWN,
1214     CPU_CLDEMOTE_FLAGS, 0 },
1215   { STRING_COMMA_LEN (".amx_int8"), PROCESSOR_UNKNOWN,
1216     CPU_AMX_INT8_FLAGS, 0 },
1217   { STRING_COMMA_LEN (".amx_bf16"), PROCESSOR_UNKNOWN,
1218     CPU_AMX_BF16_FLAGS, 0 },
1219   { STRING_COMMA_LEN (".amx_tile"), PROCESSOR_UNKNOWN,
1220     CPU_AMX_TILE_FLAGS, 0 },
1221   { STRING_COMMA_LEN (".movdiri"), PROCESSOR_UNKNOWN,
1222     CPU_MOVDIRI_FLAGS, 0 },
1223   { STRING_COMMA_LEN (".movdir64b"), PROCESSOR_UNKNOWN,
1224     CPU_MOVDIR64B_FLAGS, 0 },
1225   { STRING_COMMA_LEN (".avx512_bf16"), PROCESSOR_UNKNOWN,
1226     CPU_AVX512_BF16_FLAGS, 0 },
1227   { STRING_COMMA_LEN (".avx512_vp2intersect"), PROCESSOR_UNKNOWN,
1228     CPU_AVX512_VP2INTERSECT_FLAGS, 0 },
1229   { STRING_COMMA_LEN (".tdx"), PROCESSOR_UNKNOWN,
1230     CPU_TDX_FLAGS, 0 },
1231   { STRING_COMMA_LEN (".enqcmd"), PROCESSOR_UNKNOWN,
1232     CPU_ENQCMD_FLAGS, 0 },
1233   { STRING_COMMA_LEN (".serialize"), PROCESSOR_UNKNOWN,
1234     CPU_SERIALIZE_FLAGS, 0 },
1235   { STRING_COMMA_LEN (".rdpru"), PROCESSOR_UNKNOWN,
1236     CPU_RDPRU_FLAGS, 0 },
1237   { STRING_COMMA_LEN (".mcommit"), PROCESSOR_UNKNOWN,
1238     CPU_MCOMMIT_FLAGS, 0 },
1239   { STRING_COMMA_LEN (".sev_es"), PROCESSOR_UNKNOWN,
1240     CPU_SEV_ES_FLAGS, 0 },
1241   { STRING_COMMA_LEN (".tsxldtrk"), PROCESSOR_UNKNOWN,
1242     CPU_TSXLDTRK_FLAGS, 0 },
1243   { STRING_COMMA_LEN (".kl"), PROCESSOR_UNKNOWN,
1244     CPU_KL_FLAGS, 0 },
1245   { STRING_COMMA_LEN (".widekl"), PROCESSOR_UNKNOWN,
1246     CPU_WIDEKL_FLAGS, 0 },
1247   { STRING_COMMA_LEN (".uintr"), PROCESSOR_UNKNOWN,
1248     CPU_UINTR_FLAGS, 0 },
1249   { STRING_COMMA_LEN (".hreset"), PROCESSOR_UNKNOWN,
1250     CPU_HRESET_FLAGS, 0 },
1251 };
1252
1253 static const noarch_entry cpu_noarch[] =
1254 {
1255   { STRING_COMMA_LEN ("no87"),  CPU_ANY_X87_FLAGS },
1256   { STRING_COMMA_LEN ("no287"),  CPU_ANY_287_FLAGS },
1257   { STRING_COMMA_LEN ("no387"),  CPU_ANY_387_FLAGS },
1258   { STRING_COMMA_LEN ("no687"),  CPU_ANY_687_FLAGS },
1259   { STRING_COMMA_LEN ("nocmov"),  CPU_ANY_CMOV_FLAGS },
1260   { STRING_COMMA_LEN ("nofxsr"),  CPU_ANY_FXSR_FLAGS },
1261   { STRING_COMMA_LEN ("nommx"),  CPU_ANY_MMX_FLAGS },
1262   { STRING_COMMA_LEN ("nosse"),  CPU_ANY_SSE_FLAGS },
1263   { STRING_COMMA_LEN ("nosse2"),  CPU_ANY_SSE2_FLAGS },
1264   { STRING_COMMA_LEN ("nosse3"),  CPU_ANY_SSE3_FLAGS },
1265   { STRING_COMMA_LEN ("nosse4a"),  CPU_ANY_SSE4A_FLAGS },
1266   { STRING_COMMA_LEN ("nossse3"),  CPU_ANY_SSSE3_FLAGS },
1267   { STRING_COMMA_LEN ("nosse4.1"),  CPU_ANY_SSE4_1_FLAGS },
1268   { STRING_COMMA_LEN ("nosse4.2"),  CPU_ANY_SSE4_2_FLAGS },
1269   { STRING_COMMA_LEN ("nosse4"),  CPU_ANY_SSE4_1_FLAGS },
1270   { STRING_COMMA_LEN ("noavx"),  CPU_ANY_AVX_FLAGS },
1271   { STRING_COMMA_LEN ("noavx2"),  CPU_ANY_AVX2_FLAGS },
1272   { STRING_COMMA_LEN ("noavx512f"), CPU_ANY_AVX512F_FLAGS },
1273   { STRING_COMMA_LEN ("noavx512cd"), CPU_ANY_AVX512CD_FLAGS },
1274   { STRING_COMMA_LEN ("noavx512er"), CPU_ANY_AVX512ER_FLAGS },
1275   { STRING_COMMA_LEN ("noavx512pf"), CPU_ANY_AVX512PF_FLAGS },
1276   { STRING_COMMA_LEN ("noavx512dq"), CPU_ANY_AVX512DQ_FLAGS },
1277   { STRING_COMMA_LEN ("noavx512bw"), CPU_ANY_AVX512BW_FLAGS },
1278   { STRING_COMMA_LEN ("noavx512vl"), CPU_ANY_AVX512VL_FLAGS },
1279   { STRING_COMMA_LEN ("noavx512ifma"), CPU_ANY_AVX512IFMA_FLAGS },
1280   { STRING_COMMA_LEN ("noavx512vbmi"), CPU_ANY_AVX512VBMI_FLAGS },
1281   { STRING_COMMA_LEN ("noavx512_4fmaps"), CPU_ANY_AVX512_4FMAPS_FLAGS },
1282   { STRING_COMMA_LEN ("noavx512_4vnniw"), CPU_ANY_AVX512_4VNNIW_FLAGS },
1283   { STRING_COMMA_LEN ("noavx512_vpopcntdq"), CPU_ANY_AVX512_VPOPCNTDQ_FLAGS },
1284   { STRING_COMMA_LEN ("noavx512_vbmi2"), CPU_ANY_AVX512_VBMI2_FLAGS },
1285   { STRING_COMMA_LEN ("noavx512_vnni"), CPU_ANY_AVX512_VNNI_FLAGS },
1286   { STRING_COMMA_LEN ("noavx512_bitalg"), CPU_ANY_AVX512_BITALG_FLAGS },
1287   { STRING_COMMA_LEN ("noavx_vnni"), CPU_ANY_AVX_VNNI_FLAGS },
1288   { STRING_COMMA_LEN ("noibt"), CPU_ANY_IBT_FLAGS },
1289   { STRING_COMMA_LEN ("noshstk"), CPU_ANY_SHSTK_FLAGS },
1290   { STRING_COMMA_LEN ("noamx_int8"), CPU_ANY_AMX_INT8_FLAGS },
1291   { STRING_COMMA_LEN ("noamx_bf16"), CPU_ANY_AMX_BF16_FLAGS },
1292   { STRING_COMMA_LEN ("noamx_tile"), CPU_ANY_AMX_TILE_FLAGS },
1293   { STRING_COMMA_LEN ("nomovdiri"), CPU_ANY_MOVDIRI_FLAGS },
1294   { STRING_COMMA_LEN ("nomovdir64b"), CPU_ANY_MOVDIR64B_FLAGS },
1295   { STRING_COMMA_LEN ("noavx512_bf16"), CPU_ANY_AVX512_BF16_FLAGS },
1296   { STRING_COMMA_LEN ("noavx512_vp2intersect"),
1297     CPU_ANY_AVX512_VP2INTERSECT_FLAGS },
1298   { STRING_COMMA_LEN ("notdx"), CPU_ANY_TDX_FLAGS },
1299   { STRING_COMMA_LEN ("noenqcmd"), CPU_ANY_ENQCMD_FLAGS },
1300   { STRING_COMMA_LEN ("noserialize"), CPU_ANY_SERIALIZE_FLAGS },
1301   { STRING_COMMA_LEN ("notsxldtrk"), CPU_ANY_TSXLDTRK_FLAGS },
1302   { STRING_COMMA_LEN ("nokl"), CPU_ANY_KL_FLAGS },
1303   { STRING_COMMA_LEN ("nowidekl"), CPU_ANY_WIDEKL_FLAGS },
1304   { STRING_COMMA_LEN ("nouintr"), CPU_ANY_UINTR_FLAGS },
1305   { STRING_COMMA_LEN ("nohreset"), CPU_ANY_HRESET_FLAGS },
1306 };
1307
1308 #ifdef I386COFF
1309 /* Like s_lcomm_internal in gas/read.c but the alignment string
1310    is allowed to be optional.  */
1311
1312 static symbolS *
1313 pe_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
1314 {
1315   addressT align = 0;
1316
1317   SKIP_WHITESPACE ();
1318
1319   if (needs_align
1320       && *input_line_pointer == ',')
1321     {
1322       align = parse_align (needs_align - 1);
1323
1324       if (align == (addressT) -1)
1325         return NULL;
1326     }
1327   else
1328     {
1329       if (size >= 8)
1330         align = 3;
1331       else if (size >= 4)
1332         align = 2;
1333       else if (size >= 2)
1334         align = 1;
1335       else
1336         align = 0;
1337     }
1338
1339   bss_alloc (symbolP, size, align);
1340   return symbolP;
1341 }
1342
1343 static void
1344 pe_lcomm (int needs_align)
1345 {
1346   s_comm_internal (needs_align * 2, pe_lcomm_internal);
1347 }
1348 #endif
1349
1350 const pseudo_typeS md_pseudo_table[] =
1351 {
1352 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
1353   {"align", s_align_bytes, 0},
1354 #else
1355   {"align", s_align_ptwo, 0},
1356 #endif
1357   {"arch", set_cpu_arch, 0},
1358 #ifndef I386COFF
1359   {"bss", s_bss, 0},
1360 #else
1361   {"lcomm", pe_lcomm, 1},
1362 #endif
1363   {"ffloat", float_cons, 'f'},
1364   {"dfloat", float_cons, 'd'},
1365   {"tfloat", float_cons, 'x'},
1366   {"value", cons, 2},
1367   {"slong", signed_cons, 4},
1368   {"noopt", s_ignore, 0},
1369   {"optim", s_ignore, 0},
1370   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
1371   {"code16", set_code_flag, CODE_16BIT},
1372   {"code32", set_code_flag, CODE_32BIT},
1373 #ifdef BFD64
1374   {"code64", set_code_flag, CODE_64BIT},
1375 #endif
1376   {"intel_syntax", set_intel_syntax, 1},
1377   {"att_syntax", set_intel_syntax, 0},
1378   {"intel_mnemonic", set_intel_mnemonic, 1},
1379   {"att_mnemonic", set_intel_mnemonic, 0},
1380   {"allow_index_reg", set_allow_index_reg, 1},
1381   {"disallow_index_reg", set_allow_index_reg, 0},
1382   {"sse_check", set_check, 0},
1383   {"operand_check", set_check, 1},
1384 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1385   {"largecomm", handle_large_common, 0},
1386 #else
1387   {"file", dwarf2_directive_file, 0},
1388   {"loc", dwarf2_directive_loc, 0},
1389   {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
1390 #endif
1391 #ifdef TE_PE
1392   {"secrel32", pe_directive_secrel, 0},
1393 #endif
1394   {0, 0, 0}
1395 };
1396
1397 /* For interface with expression ().  */
1398 extern char *input_line_pointer;
1399
1400 /* Hash table for instruction mnemonic lookup.  */
1401 static htab_t op_hash;
1402
1403 /* Hash table for register lookup.  */
1404 static htab_t reg_hash;
1405 \f
1406   /* Various efficient no-op patterns for aligning code labels.
1407      Note: Don't try to assemble the instructions in the comments.
1408      0L and 0w are not legal.  */
1409 static const unsigned char f32_1[] =
1410   {0x90};                               /* nop                  */
1411 static const unsigned char f32_2[] =
1412   {0x66,0x90};                          /* xchg %ax,%ax         */
1413 static const unsigned char f32_3[] =
1414   {0x8d,0x76,0x00};                     /* leal 0(%esi),%esi    */
1415 static const unsigned char f32_4[] =
1416   {0x8d,0x74,0x26,0x00};                /* leal 0(%esi,1),%esi  */
1417 static const unsigned char f32_6[] =
1418   {0x8d,0xb6,0x00,0x00,0x00,0x00};      /* leal 0L(%esi),%esi   */
1419 static const unsigned char f32_7[] =
1420   {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
1421 static const unsigned char f16_3[] =
1422   {0x8d,0x74,0x00};                     /* lea 0(%si),%si       */
1423 static const unsigned char f16_4[] =
1424   {0x8d,0xb4,0x00,0x00};                /* lea 0W(%si),%si      */
1425 static const unsigned char jump_disp8[] =
1426   {0xeb};                               /* jmp disp8           */
1427 static const unsigned char jump32_disp32[] =
1428   {0xe9};                               /* jmp disp32          */
1429 static const unsigned char jump16_disp32[] =
1430   {0x66,0xe9};                          /* jmp disp32          */
1431 /* 32-bit NOPs patterns.  */
1432 static const unsigned char *const f32_patt[] = {
1433   f32_1, f32_2, f32_3, f32_4, NULL, f32_6, f32_7
1434 };
1435 /* 16-bit NOPs patterns.  */
1436 static const unsigned char *const f16_patt[] = {
1437   f32_1, f32_2, f16_3, f16_4
1438 };
1439 /* nopl (%[re]ax) */
1440 static const unsigned char alt_3[] =
1441   {0x0f,0x1f,0x00};
1442 /* nopl 0(%[re]ax) */
1443 static const unsigned char alt_4[] =
1444   {0x0f,0x1f,0x40,0x00};
1445 /* nopl 0(%[re]ax,%[re]ax,1) */
1446 static const unsigned char alt_5[] =
1447   {0x0f,0x1f,0x44,0x00,0x00};
1448 /* nopw 0(%[re]ax,%[re]ax,1) */
1449 static const unsigned char alt_6[] =
1450   {0x66,0x0f,0x1f,0x44,0x00,0x00};
1451 /* nopl 0L(%[re]ax) */
1452 static const unsigned char alt_7[] =
1453   {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
1454 /* nopl 0L(%[re]ax,%[re]ax,1) */
1455 static const unsigned char alt_8[] =
1456   {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1457 /* nopw 0L(%[re]ax,%[re]ax,1) */
1458 static const unsigned char alt_9[] =
1459   {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1460 /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
1461 static const unsigned char alt_10[] =
1462   {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1463 /* data16 nopw %cs:0L(%eax,%eax,1) */
1464 static const unsigned char alt_11[] =
1465   {0x66,0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
1466 /* 32-bit and 64-bit NOPs patterns.  */
1467 static const unsigned char *const alt_patt[] = {
1468   f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
1469   alt_9, alt_10, alt_11
1470 };
1471
1472 /* Genenerate COUNT bytes of NOPs to WHERE from PATT with the maximum
1473    size of a single NOP instruction MAX_SINGLE_NOP_SIZE.  */
1474
1475 static void
1476 i386_output_nops (char *where, const unsigned char *const *patt,
1477                   int count, int max_single_nop_size)
1478
1479 {
1480   /* Place the longer NOP first.  */
1481   int last;
1482   int offset;
1483   const unsigned char *nops;
1484
1485   if (max_single_nop_size < 1)
1486     {
1487       as_fatal (_("i386_output_nops called to generate nops of at most %d bytes!"),
1488                 max_single_nop_size);
1489       return;
1490     }
1491
1492   nops = patt[max_single_nop_size - 1];
1493
1494   /* Use the smaller one if the requsted one isn't available.  */
1495   if (nops == NULL)
1496     {
1497       max_single_nop_size--;
1498       nops = patt[max_single_nop_size - 1];
1499     }
1500
1501   last = count % max_single_nop_size;
1502
1503   count -= last;
1504   for (offset = 0; offset < count; offset += max_single_nop_size)
1505     memcpy (where + offset, nops, max_single_nop_size);
1506
1507   if (last)
1508     {
1509       nops = patt[last - 1];
1510       if (nops == NULL)
1511         {
1512           /* Use the smaller one plus one-byte NOP if the needed one
1513              isn't available.  */
1514           last--;
1515           nops = patt[last - 1];
1516           memcpy (where + offset, nops, last);
1517           where[offset + last] = *patt[0];
1518         }
1519       else
1520         memcpy (where + offset, nops, last);
1521     }
1522 }
1523
1524 static INLINE int
1525 fits_in_imm7 (offsetT num)
1526 {
1527   return (num & 0x7f) == num;
1528 }
1529
1530 static INLINE int
1531 fits_in_imm31 (offsetT num)
1532 {
1533   return (num & 0x7fffffff) == num;
1534 }
1535
1536 /* Genenerate COUNT bytes of NOPs to WHERE with the maximum size of a
1537    single NOP instruction LIMIT.  */
1538
1539 void
1540 i386_generate_nops (fragS *fragP, char *where, offsetT count, int limit)
1541 {
1542   const unsigned char *const *patt = NULL;
1543   int max_single_nop_size;
1544   /* Maximum number of NOPs before switching to jump over NOPs.  */
1545   int max_number_of_nops;
1546
1547   switch (fragP->fr_type)
1548     {
1549     case rs_fill_nop:
1550     case rs_align_code:
1551       break;
1552     case rs_machine_dependent:
1553       /* Allow NOP padding for jumps and calls.  */
1554       if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
1555           || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
1556         break;
1557       /* Fall through.  */
1558     default:
1559       return;
1560     }
1561
1562   /* We need to decide which NOP sequence to use for 32bit and
1563      64bit. When -mtune= is used:
1564
1565      1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
1566      PROCESSOR_GENERIC32, f32_patt will be used.
1567      2. For the rest, alt_patt will be used.
1568
1569      When -mtune= isn't used, alt_patt will be used if
1570      cpu_arch_isa_flags has CpuNop.  Otherwise, f32_patt will
1571      be used.
1572
1573      When -march= or .arch is used, we can't use anything beyond
1574      cpu_arch_isa_flags.   */
1575
1576   if (flag_code == CODE_16BIT)
1577     {
1578       patt = f16_patt;
1579       max_single_nop_size = sizeof (f16_patt) / sizeof (f16_patt[0]);
1580       /* Limit number of NOPs to 2 in 16-bit mode.  */
1581       max_number_of_nops = 2;
1582     }
1583   else
1584     {
1585       if (fragP->tc_frag_data.isa == PROCESSOR_UNKNOWN)
1586         {
1587           /* PROCESSOR_UNKNOWN means that all ISAs may be used.  */
1588           switch (cpu_arch_tune)
1589             {
1590             case PROCESSOR_UNKNOWN:
1591               /* We use cpu_arch_isa_flags to check if we SHOULD
1592                  optimize with nops.  */
1593               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1594                 patt = alt_patt;
1595               else
1596                 patt = f32_patt;
1597               break;
1598             case PROCESSOR_PENTIUM4:
1599             case PROCESSOR_NOCONA:
1600             case PROCESSOR_CORE:
1601             case PROCESSOR_CORE2:
1602             case PROCESSOR_COREI7:
1603             case PROCESSOR_L1OM:
1604             case PROCESSOR_K1OM:
1605             case PROCESSOR_GENERIC64:
1606             case PROCESSOR_K6:
1607             case PROCESSOR_ATHLON:
1608             case PROCESSOR_K8:
1609             case PROCESSOR_AMDFAM10:
1610             case PROCESSOR_BD:
1611             case PROCESSOR_ZNVER:
1612             case PROCESSOR_BT:
1613               patt = alt_patt;
1614               break;
1615             case PROCESSOR_I386:
1616             case PROCESSOR_I486:
1617             case PROCESSOR_PENTIUM:
1618             case PROCESSOR_PENTIUMPRO:
1619             case PROCESSOR_IAMCU:
1620             case PROCESSOR_GENERIC32:
1621               patt = f32_patt;
1622               break;
1623             }
1624         }
1625       else
1626         {
1627           switch (fragP->tc_frag_data.tune)
1628             {
1629             case PROCESSOR_UNKNOWN:
1630               /* When cpu_arch_isa is set, cpu_arch_tune shouldn't be
1631                  PROCESSOR_UNKNOWN.  */
1632               abort ();
1633               break;
1634
1635             case PROCESSOR_I386:
1636             case PROCESSOR_I486:
1637             case PROCESSOR_PENTIUM:
1638             case PROCESSOR_IAMCU:
1639             case PROCESSOR_K6:
1640             case PROCESSOR_ATHLON:
1641             case PROCESSOR_K8:
1642             case PROCESSOR_AMDFAM10:
1643             case PROCESSOR_BD:
1644             case PROCESSOR_ZNVER:
1645             case PROCESSOR_BT:
1646             case PROCESSOR_GENERIC32:
1647               /* We use cpu_arch_isa_flags to check if we CAN optimize
1648                  with nops.  */
1649               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1650                 patt = alt_patt;
1651               else
1652                 patt = f32_patt;
1653               break;
1654             case PROCESSOR_PENTIUMPRO:
1655             case PROCESSOR_PENTIUM4:
1656             case PROCESSOR_NOCONA:
1657             case PROCESSOR_CORE:
1658             case PROCESSOR_CORE2:
1659             case PROCESSOR_COREI7:
1660             case PROCESSOR_L1OM:
1661             case PROCESSOR_K1OM:
1662               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1663                 patt = alt_patt;
1664               else
1665                 patt = f32_patt;
1666               break;
1667             case PROCESSOR_GENERIC64:
1668               patt = alt_patt;
1669               break;
1670             }
1671         }
1672
1673       if (patt == f32_patt)
1674         {
1675           max_single_nop_size = sizeof (f32_patt) / sizeof (f32_patt[0]);
1676           /* Limit number of NOPs to 2 for older processors.  */
1677           max_number_of_nops = 2;
1678         }
1679       else
1680         {
1681           max_single_nop_size = sizeof (alt_patt) / sizeof (alt_patt[0]);
1682           /* Limit number of NOPs to 7 for newer processors.  */
1683           max_number_of_nops = 7;
1684         }
1685     }
1686
1687   if (limit == 0)
1688     limit = max_single_nop_size;
1689
1690   if (fragP->fr_type == rs_fill_nop)
1691     {
1692       /* Output NOPs for .nop directive.  */
1693       if (limit > max_single_nop_size)
1694         {
1695           as_bad_where (fragP->fr_file, fragP->fr_line,
1696                         _("invalid single nop size: %d "
1697                           "(expect within [0, %d])"),
1698                         limit, max_single_nop_size);
1699           return;
1700         }
1701     }
1702   else if (fragP->fr_type != rs_machine_dependent)
1703     fragP->fr_var = count;
1704
1705   if ((count / max_single_nop_size) > max_number_of_nops)
1706     {
1707       /* Generate jump over NOPs.  */
1708       offsetT disp = count - 2;
1709       if (fits_in_imm7 (disp))
1710         {
1711           /* Use "jmp disp8" if possible.  */
1712           count = disp;
1713           where[0] = jump_disp8[0];
1714           where[1] = count;
1715           where += 2;
1716         }
1717       else
1718         {
1719           unsigned int size_of_jump;
1720
1721           if (flag_code == CODE_16BIT)
1722             {
1723               where[0] = jump16_disp32[0];
1724               where[1] = jump16_disp32[1];
1725               size_of_jump = 2;
1726             }
1727           else
1728             {
1729               where[0] = jump32_disp32[0];
1730               size_of_jump = 1;
1731             }
1732
1733           count -= size_of_jump + 4;
1734           if (!fits_in_imm31 (count))
1735             {
1736               as_bad_where (fragP->fr_file, fragP->fr_line,
1737                             _("jump over nop padding out of range"));
1738               return;
1739             }
1740
1741           md_number_to_chars (where + size_of_jump, count, 4);
1742           where += size_of_jump + 4;
1743         }
1744     }
1745
1746   /* Generate multiple NOPs.  */
1747   i386_output_nops (where, patt, count, limit);
1748 }
1749
1750 static INLINE int
1751 operand_type_all_zero (const union i386_operand_type *x)
1752 {
1753   switch (ARRAY_SIZE(x->array))
1754     {
1755     case 3:
1756       if (x->array[2])
1757         return 0;
1758       /* Fall through.  */
1759     case 2:
1760       if (x->array[1])
1761         return 0;
1762       /* Fall through.  */
1763     case 1:
1764       return !x->array[0];
1765     default:
1766       abort ();
1767     }
1768 }
1769
1770 static INLINE void
1771 operand_type_set (union i386_operand_type *x, unsigned int v)
1772 {
1773   switch (ARRAY_SIZE(x->array))
1774     {
1775     case 3:
1776       x->array[2] = v;
1777       /* Fall through.  */
1778     case 2:
1779       x->array[1] = v;
1780       /* Fall through.  */
1781     case 1:
1782       x->array[0] = v;
1783       /* Fall through.  */
1784       break;
1785     default:
1786       abort ();
1787     }
1788
1789   x->bitfield.class = ClassNone;
1790   x->bitfield.instance = InstanceNone;
1791 }
1792
1793 static INLINE int
1794 operand_type_equal (const union i386_operand_type *x,
1795                     const union i386_operand_type *y)
1796 {
1797   switch (ARRAY_SIZE(x->array))
1798     {
1799     case 3:
1800       if (x->array[2] != y->array[2])
1801         return 0;
1802       /* Fall through.  */
1803     case 2:
1804       if (x->array[1] != y->array[1])
1805         return 0;
1806       /* Fall through.  */
1807     case 1:
1808       return x->array[0] == y->array[0];
1809       break;
1810     default:
1811       abort ();
1812     }
1813 }
1814
1815 static INLINE int
1816 cpu_flags_all_zero (const union i386_cpu_flags *x)
1817 {
1818   switch (ARRAY_SIZE(x->array))
1819     {
1820     case 4:
1821       if (x->array[3])
1822         return 0;
1823       /* Fall through.  */
1824     case 3:
1825       if (x->array[2])
1826         return 0;
1827       /* Fall through.  */
1828     case 2:
1829       if (x->array[1])
1830         return 0;
1831       /* Fall through.  */
1832     case 1:
1833       return !x->array[0];
1834     default:
1835       abort ();
1836     }
1837 }
1838
1839 static INLINE int
1840 cpu_flags_equal (const union i386_cpu_flags *x,
1841                  const union i386_cpu_flags *y)
1842 {
1843   switch (ARRAY_SIZE(x->array))
1844     {
1845     case 4:
1846       if (x->array[3] != y->array[3])
1847         return 0;
1848       /* Fall through.  */
1849     case 3:
1850       if (x->array[2] != y->array[2])
1851         return 0;
1852       /* Fall through.  */
1853     case 2:
1854       if (x->array[1] != y->array[1])
1855         return 0;
1856       /* Fall through.  */
1857     case 1:
1858       return x->array[0] == y->array[0];
1859       break;
1860     default:
1861       abort ();
1862     }
1863 }
1864
1865 static INLINE int
1866 cpu_flags_check_cpu64 (i386_cpu_flags f)
1867 {
1868   return !((flag_code == CODE_64BIT && f.bitfield.cpuno64)
1869            || (flag_code != CODE_64BIT && f.bitfield.cpu64));
1870 }
1871
1872 static INLINE i386_cpu_flags
1873 cpu_flags_and (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_or (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 INLINE i386_cpu_flags
1919 cpu_flags_and_not (i386_cpu_flags x, i386_cpu_flags y)
1920 {
1921   switch (ARRAY_SIZE (x.array))
1922     {
1923     case 4:
1924       x.array [3] &= ~y.array [3];
1925       /* Fall through.  */
1926     case 3:
1927       x.array [2] &= ~y.array [2];
1928       /* Fall through.  */
1929     case 2:
1930       x.array [1] &= ~y.array [1];
1931       /* Fall through.  */
1932     case 1:
1933       x.array [0] &= ~y.array [0];
1934       break;
1935     default:
1936       abort ();
1937     }
1938   return x;
1939 }
1940
1941 static const i386_cpu_flags avx512 = CPU_ANY_AVX512F_FLAGS;
1942
1943 #define CPU_FLAGS_ARCH_MATCH            0x1
1944 #define CPU_FLAGS_64BIT_MATCH           0x2
1945
1946 #define CPU_FLAGS_PERFECT_MATCH \
1947   (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_64BIT_MATCH)
1948
1949 /* Return CPU flags match bits. */
1950
1951 static int
1952 cpu_flags_match (const insn_template *t)
1953 {
1954   i386_cpu_flags x = t->cpu_flags;
1955   int match = cpu_flags_check_cpu64 (x) ? CPU_FLAGS_64BIT_MATCH : 0;
1956
1957   x.bitfield.cpu64 = 0;
1958   x.bitfield.cpuno64 = 0;
1959
1960   if (cpu_flags_all_zero (&x))
1961     {
1962       /* This instruction is available on all archs.  */
1963       match |= CPU_FLAGS_ARCH_MATCH;
1964     }
1965   else
1966     {
1967       /* This instruction is available only on some archs.  */
1968       i386_cpu_flags cpu = cpu_arch_flags;
1969
1970       /* AVX512VL is no standalone feature - match it and then strip it.  */
1971       if (x.bitfield.cpuavx512vl && !cpu.bitfield.cpuavx512vl)
1972         return match;
1973       x.bitfield.cpuavx512vl = 0;
1974
1975       cpu = cpu_flags_and (x, cpu);
1976       if (!cpu_flags_all_zero (&cpu))
1977         {
1978           if (x.bitfield.cpuavx)
1979             {
1980               /* We need to check a few extra flags with AVX.  */
1981               if (cpu.bitfield.cpuavx
1982                   && (!t->opcode_modifier.sse2avx
1983                       || (sse2avx && !i.prefix[DATA_PREFIX]))
1984                   && (!x.bitfield.cpuaes || cpu.bitfield.cpuaes)
1985                   && (!x.bitfield.cpugfni || cpu.bitfield.cpugfni)
1986                   && (!x.bitfield.cpupclmul || cpu.bitfield.cpupclmul))
1987                 match |= CPU_FLAGS_ARCH_MATCH;
1988             }
1989           else if (x.bitfield.cpuavx512f)
1990             {
1991               /* We need to check a few extra flags with AVX512F.  */
1992               if (cpu.bitfield.cpuavx512f
1993                   && (!x.bitfield.cpugfni || cpu.bitfield.cpugfni)
1994                   && (!x.bitfield.cpuvaes || cpu.bitfield.cpuvaes)
1995                   && (!x.bitfield.cpuvpclmulqdq || cpu.bitfield.cpuvpclmulqdq))
1996                 match |= CPU_FLAGS_ARCH_MATCH;
1997             }
1998           else
1999             match |= CPU_FLAGS_ARCH_MATCH;
2000         }
2001     }
2002   return match;
2003 }
2004
2005 static INLINE i386_operand_type
2006 operand_type_and (i386_operand_type x, i386_operand_type y)
2007 {
2008   if (x.bitfield.class != y.bitfield.class)
2009     x.bitfield.class = ClassNone;
2010   if (x.bitfield.instance != y.bitfield.instance)
2011     x.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_and_not (i386_operand_type x, i386_operand_type y)
2032 {
2033   gas_assert (y.bitfield.class == ClassNone);
2034   gas_assert (y.bitfield.instance == InstanceNone);
2035
2036   switch (ARRAY_SIZE (x.array))
2037     {
2038     case 3:
2039       x.array [2] &= ~y.array [2];
2040       /* Fall through.  */
2041     case 2:
2042       x.array [1] &= ~y.array [1];
2043       /* Fall through.  */
2044     case 1:
2045       x.array [0] &= ~y.array [0];
2046       break;
2047     default:
2048       abort ();
2049     }
2050   return x;
2051 }
2052
2053 static INLINE i386_operand_type
2054 operand_type_or (i386_operand_type x, i386_operand_type y)
2055 {
2056   gas_assert (x.bitfield.class == ClassNone ||
2057               y.bitfield.class == ClassNone ||
2058               x.bitfield.class == y.bitfield.class);
2059   gas_assert (x.bitfield.instance == InstanceNone ||
2060               y.bitfield.instance == InstanceNone ||
2061               x.bitfield.instance == y.bitfield.instance);
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 INLINE i386_operand_type
2081 operand_type_xor (i386_operand_type x, i386_operand_type y)
2082 {
2083   gas_assert (y.bitfield.class == ClassNone);
2084   gas_assert (y.bitfield.instance == InstanceNone);
2085
2086   switch (ARRAY_SIZE (x.array))
2087     {
2088     case 3:
2089       x.array [2] ^= y.array [2];
2090       /* Fall through.  */
2091     case 2:
2092       x.array [1] ^= y.array [1];
2093       /* Fall through.  */
2094     case 1:
2095       x.array [0] ^= y.array [0];
2096       break;
2097     default:
2098       abort ();
2099     }
2100   return x;
2101 }
2102
2103 static const i386_operand_type disp16 = OPERAND_TYPE_DISP16;
2104 static const i386_operand_type disp32 = OPERAND_TYPE_DISP32;
2105 static const i386_operand_type disp32s = OPERAND_TYPE_DISP32S;
2106 static const i386_operand_type disp16_32 = OPERAND_TYPE_DISP16_32;
2107 static const i386_operand_type anydisp = OPERAND_TYPE_ANYDISP;
2108 static const i386_operand_type anyimm = OPERAND_TYPE_ANYIMM;
2109 static const i386_operand_type regxmm = OPERAND_TYPE_REGXMM;
2110 static const i386_operand_type regmask = OPERAND_TYPE_REGMASK;
2111 static const i386_operand_type imm8 = OPERAND_TYPE_IMM8;
2112 static const i386_operand_type imm8s = OPERAND_TYPE_IMM8S;
2113 static const i386_operand_type imm16 = OPERAND_TYPE_IMM16;
2114 static const i386_operand_type imm32 = OPERAND_TYPE_IMM32;
2115 static const i386_operand_type imm32s = OPERAND_TYPE_IMM32S;
2116 static const i386_operand_type imm64 = OPERAND_TYPE_IMM64;
2117 static const i386_operand_type imm16_32 = OPERAND_TYPE_IMM16_32;
2118 static const i386_operand_type imm16_32s = OPERAND_TYPE_IMM16_32S;
2119 static const i386_operand_type imm16_32_32s = OPERAND_TYPE_IMM16_32_32S;
2120
2121 enum operand_type
2122 {
2123   reg,
2124   imm,
2125   disp,
2126   anymem
2127 };
2128
2129 static INLINE int
2130 operand_type_check (i386_operand_type t, enum operand_type c)
2131 {
2132   switch (c)
2133     {
2134     case reg:
2135       return t.bitfield.class == Reg;
2136
2137     case imm:
2138       return (t.bitfield.imm8
2139               || t.bitfield.imm8s
2140               || t.bitfield.imm16
2141               || t.bitfield.imm32
2142               || t.bitfield.imm32s
2143               || t.bitfield.imm64);
2144
2145     case disp:
2146       return (t.bitfield.disp8
2147               || t.bitfield.disp16
2148               || t.bitfield.disp32
2149               || t.bitfield.disp32s
2150               || t.bitfield.disp64);
2151
2152     case anymem:
2153       return (t.bitfield.disp8
2154               || t.bitfield.disp16
2155               || t.bitfield.disp32
2156               || t.bitfield.disp32s
2157               || t.bitfield.disp64
2158               || t.bitfield.baseindex);
2159
2160     default:
2161       abort ();
2162     }
2163
2164   return 0;
2165 }
2166
2167 /* Return 1 if there is no conflict in 8bit/16bit/32bit/64bit/80bit size
2168    between operand GIVEN and opeand WANTED for instruction template T.  */
2169
2170 static INLINE int
2171 match_operand_size (const insn_template *t, unsigned int wanted,
2172                     unsigned int given)
2173 {
2174   return !((i.types[given].bitfield.byte
2175             && !t->operand_types[wanted].bitfield.byte)
2176            || (i.types[given].bitfield.word
2177                && !t->operand_types[wanted].bitfield.word)
2178            || (i.types[given].bitfield.dword
2179                && !t->operand_types[wanted].bitfield.dword)
2180            || (i.types[given].bitfield.qword
2181                && !t->operand_types[wanted].bitfield.qword)
2182            || (i.types[given].bitfield.tbyte
2183                && !t->operand_types[wanted].bitfield.tbyte));
2184 }
2185
2186 /* Return 1 if there is no conflict in SIMD register between operand
2187    GIVEN and opeand WANTED for instruction template T.  */
2188
2189 static INLINE int
2190 match_simd_size (const insn_template *t, unsigned int wanted,
2191                  unsigned int given)
2192 {
2193   return !((i.types[given].bitfield.xmmword
2194             && !t->operand_types[wanted].bitfield.xmmword)
2195            || (i.types[given].bitfield.ymmword
2196                && !t->operand_types[wanted].bitfield.ymmword)
2197            || (i.types[given].bitfield.zmmword
2198                && !t->operand_types[wanted].bitfield.zmmword)
2199            || (i.types[given].bitfield.tmmword
2200                && !t->operand_types[wanted].bitfield.tmmword));
2201 }
2202
2203 /* Return 1 if there is no conflict in any size between operand GIVEN
2204    and opeand WANTED for instruction template T.  */
2205
2206 static INLINE int
2207 match_mem_size (const insn_template *t, unsigned int wanted,
2208                 unsigned int given)
2209 {
2210   return (match_operand_size (t, wanted, given)
2211           && !((i.types[given].bitfield.unspecified
2212                 && !i.broadcast
2213                 && !t->operand_types[wanted].bitfield.unspecified)
2214                || (i.types[given].bitfield.fword
2215                    && !t->operand_types[wanted].bitfield.fword)
2216                /* For scalar opcode templates to allow register and memory
2217                   operands at the same time, some special casing is needed
2218                   here.  Also for v{,p}broadcast*, {,v}pmov{s,z}*, and
2219                   down-conversion vpmov*.  */
2220                || ((t->operand_types[wanted].bitfield.class == RegSIMD
2221                     && t->operand_types[wanted].bitfield.byte
2222                        + t->operand_types[wanted].bitfield.word
2223                        + t->operand_types[wanted].bitfield.dword
2224                        + t->operand_types[wanted].bitfield.qword
2225                        > !!t->opcode_modifier.broadcast)
2226                    ? (i.types[given].bitfield.xmmword
2227                       || i.types[given].bitfield.ymmword
2228                       || i.types[given].bitfield.zmmword)
2229                    : !match_simd_size(t, wanted, given))));
2230 }
2231
2232 /* Return value has MATCH_STRAIGHT set if there is no size conflict on any
2233    operands for instruction template T, and it has MATCH_REVERSE set if there
2234    is no size conflict on any operands for the template with operands reversed
2235    (and the template allows for reversing in the first place).  */
2236
2237 #define MATCH_STRAIGHT 1
2238 #define MATCH_REVERSE  2
2239
2240 static INLINE unsigned int
2241 operand_size_match (const insn_template *t)
2242 {
2243   unsigned int j, match = MATCH_STRAIGHT;
2244
2245   /* Don't check non-absolute jump instructions.  */
2246   if (t->opcode_modifier.jump
2247       && t->opcode_modifier.jump != JUMP_ABSOLUTE)
2248     return match;
2249
2250   /* Check memory and accumulator operand size.  */
2251   for (j = 0; j < i.operands; j++)
2252     {
2253       if (i.types[j].bitfield.class != Reg
2254           && i.types[j].bitfield.class != RegSIMD
2255           && t->opcode_modifier.anysize)
2256         continue;
2257
2258       if (t->operand_types[j].bitfield.class == Reg
2259           && !match_operand_size (t, j, j))
2260         {
2261           match = 0;
2262           break;
2263         }
2264
2265       if (t->operand_types[j].bitfield.class == RegSIMD
2266           && !match_simd_size (t, j, j))
2267         {
2268           match = 0;
2269           break;
2270         }
2271
2272       if (t->operand_types[j].bitfield.instance == Accum
2273           && (!match_operand_size (t, j, j) || !match_simd_size (t, j, j)))
2274         {
2275           match = 0;
2276           break;
2277         }
2278
2279       if ((i.flags[j] & Operand_Mem) && !match_mem_size (t, j, j))
2280         {
2281           match = 0;
2282           break;
2283         }
2284     }
2285
2286   if (!t->opcode_modifier.d)
2287     {
2288     mismatch:
2289       if (!match)
2290         i.error = operand_size_mismatch;
2291       return match;
2292     }
2293
2294   /* Check reverse.  */
2295   gas_assert (i.operands >= 2 && i.operands <= 3);
2296
2297   for (j = 0; j < i.operands; j++)
2298     {
2299       unsigned int given = i.operands - j - 1;
2300
2301       if (t->operand_types[j].bitfield.class == Reg
2302           && !match_operand_size (t, j, given))
2303         goto mismatch;
2304
2305       if (t->operand_types[j].bitfield.class == RegSIMD
2306           && !match_simd_size (t, j, given))
2307         goto mismatch;
2308
2309       if (t->operand_types[j].bitfield.instance == Accum
2310           && (!match_operand_size (t, j, given)
2311               || !match_simd_size (t, j, given)))
2312         goto mismatch;
2313
2314       if ((i.flags[given] & Operand_Mem) && !match_mem_size (t, j, given))
2315         goto mismatch;
2316     }
2317
2318   return match | MATCH_REVERSE;
2319 }
2320
2321 static INLINE int
2322 operand_type_match (i386_operand_type overlap,
2323                     i386_operand_type given)
2324 {
2325   i386_operand_type temp = overlap;
2326
2327   temp.bitfield.unspecified = 0;
2328   temp.bitfield.byte = 0;
2329   temp.bitfield.word = 0;
2330   temp.bitfield.dword = 0;
2331   temp.bitfield.fword = 0;
2332   temp.bitfield.qword = 0;
2333   temp.bitfield.tbyte = 0;
2334   temp.bitfield.xmmword = 0;
2335   temp.bitfield.ymmword = 0;
2336   temp.bitfield.zmmword = 0;
2337   temp.bitfield.tmmword = 0;
2338   if (operand_type_all_zero (&temp))
2339     goto mismatch;
2340
2341   if (given.bitfield.baseindex == overlap.bitfield.baseindex)
2342     return 1;
2343
2344  mismatch:
2345   i.error = operand_type_mismatch;
2346   return 0;
2347 }
2348
2349 /* If given types g0 and g1 are registers they must be of the same type
2350    unless the expected operand type register overlap is null.
2351    Some Intel syntax memory operand size checking also happens here.  */
2352
2353 static INLINE int
2354 operand_type_register_match (i386_operand_type g0,
2355                              i386_operand_type t0,
2356                              i386_operand_type g1,
2357                              i386_operand_type t1)
2358 {
2359   if (g0.bitfield.class != Reg
2360       && g0.bitfield.class != RegSIMD
2361       && (!operand_type_check (g0, anymem)
2362           || g0.bitfield.unspecified
2363           || (t0.bitfield.class != Reg
2364               && t0.bitfield.class != RegSIMD)))
2365     return 1;
2366
2367   if (g1.bitfield.class != Reg
2368       && g1.bitfield.class != RegSIMD
2369       && (!operand_type_check (g1, anymem)
2370           || g1.bitfield.unspecified
2371           || (t1.bitfield.class != Reg
2372               && t1.bitfield.class != RegSIMD)))
2373     return 1;
2374
2375   if (g0.bitfield.byte == g1.bitfield.byte
2376       && g0.bitfield.word == g1.bitfield.word
2377       && g0.bitfield.dword == g1.bitfield.dword
2378       && g0.bitfield.qword == g1.bitfield.qword
2379       && g0.bitfield.xmmword == g1.bitfield.xmmword
2380       && g0.bitfield.ymmword == g1.bitfield.ymmword
2381       && g0.bitfield.zmmword == g1.bitfield.zmmword)
2382     return 1;
2383
2384   if (!(t0.bitfield.byte & t1.bitfield.byte)
2385       && !(t0.bitfield.word & t1.bitfield.word)
2386       && !(t0.bitfield.dword & t1.bitfield.dword)
2387       && !(t0.bitfield.qword & t1.bitfield.qword)
2388       && !(t0.bitfield.xmmword & t1.bitfield.xmmword)
2389       && !(t0.bitfield.ymmword & t1.bitfield.ymmword)
2390       && !(t0.bitfield.zmmword & t1.bitfield.zmmword))
2391     return 1;
2392
2393   i.error = register_type_mismatch;
2394
2395   return 0;
2396 }
2397
2398 static INLINE unsigned int
2399 register_number (const reg_entry *r)
2400 {
2401   unsigned int nr = r->reg_num;
2402
2403   if (r->reg_flags & RegRex)
2404     nr += 8;
2405
2406   if (r->reg_flags & RegVRex)
2407     nr += 16;
2408
2409   return nr;
2410 }
2411
2412 static INLINE unsigned int
2413 mode_from_disp_size (i386_operand_type t)
2414 {
2415   if (t.bitfield.disp8)
2416     return 1;
2417   else if (t.bitfield.disp16
2418            || t.bitfield.disp32
2419            || t.bitfield.disp32s)
2420     return 2;
2421   else
2422     return 0;
2423 }
2424
2425 static INLINE int
2426 fits_in_signed_byte (addressT num)
2427 {
2428   return num + 0x80 <= 0xff;
2429 }
2430
2431 static INLINE int
2432 fits_in_unsigned_byte (addressT num)
2433 {
2434   return num <= 0xff;
2435 }
2436
2437 static INLINE int
2438 fits_in_unsigned_word (addressT num)
2439 {
2440   return num <= 0xffff;
2441 }
2442
2443 static INLINE int
2444 fits_in_signed_word (addressT num)
2445 {
2446   return num + 0x8000 <= 0xffff;
2447 }
2448
2449 static INLINE int
2450 fits_in_signed_long (addressT num ATTRIBUTE_UNUSED)
2451 {
2452 #ifndef BFD64
2453   return 1;
2454 #else
2455   return num + 0x80000000 <= 0xffffffff;
2456 #endif
2457 }                               /* fits_in_signed_long() */
2458
2459 static INLINE int
2460 fits_in_unsigned_long (addressT num ATTRIBUTE_UNUSED)
2461 {
2462 #ifndef BFD64
2463   return 1;
2464 #else
2465   return num <= 0xffffffff;
2466 #endif
2467 }                               /* fits_in_unsigned_long() */
2468
2469 static INLINE int
2470 fits_in_disp8 (offsetT num)
2471 {
2472   int shift = i.memshift;
2473   unsigned int mask;
2474
2475   if (shift == -1)
2476     abort ();
2477
2478   mask = (1 << shift) - 1;
2479
2480   /* Return 0 if NUM isn't properly aligned.  */
2481   if ((num & mask))
2482     return 0;
2483
2484   /* Check if NUM will fit in 8bit after shift.  */
2485   return fits_in_signed_byte (num >> shift);
2486 }
2487
2488 static INLINE int
2489 fits_in_imm4 (offsetT num)
2490 {
2491   return (num & 0xf) == num;
2492 }
2493
2494 static i386_operand_type
2495 smallest_imm_type (offsetT num)
2496 {
2497   i386_operand_type t;
2498
2499   operand_type_set (&t, 0);
2500   t.bitfield.imm64 = 1;
2501
2502   if (cpu_arch_tune != PROCESSOR_I486 && num == 1)
2503     {
2504       /* This code is disabled on the 486 because all the Imm1 forms
2505          in the opcode table are slower on the i486.  They're the
2506          versions with the implicitly specified single-position
2507          displacement, which has another syntax if you really want to
2508          use that form.  */
2509       t.bitfield.imm1 = 1;
2510       t.bitfield.imm8 = 1;
2511       t.bitfield.imm8s = 1;
2512       t.bitfield.imm16 = 1;
2513       t.bitfield.imm32 = 1;
2514       t.bitfield.imm32s = 1;
2515     }
2516   else if (fits_in_signed_byte (num))
2517     {
2518       t.bitfield.imm8 = 1;
2519       t.bitfield.imm8s = 1;
2520       t.bitfield.imm16 = 1;
2521       t.bitfield.imm32 = 1;
2522       t.bitfield.imm32s = 1;
2523     }
2524   else if (fits_in_unsigned_byte (num))
2525     {
2526       t.bitfield.imm8 = 1;
2527       t.bitfield.imm16 = 1;
2528       t.bitfield.imm32 = 1;
2529       t.bitfield.imm32s = 1;
2530     }
2531   else if (fits_in_signed_word (num) || fits_in_unsigned_word (num))
2532     {
2533       t.bitfield.imm16 = 1;
2534       t.bitfield.imm32 = 1;
2535       t.bitfield.imm32s = 1;
2536     }
2537   else if (fits_in_signed_long (num))
2538     {
2539       t.bitfield.imm32 = 1;
2540       t.bitfield.imm32s = 1;
2541     }
2542   else if (fits_in_unsigned_long (num))
2543     t.bitfield.imm32 = 1;
2544
2545   return t;
2546 }
2547
2548 static offsetT
2549 offset_in_range (offsetT val, int size)
2550 {
2551   addressT mask;
2552
2553   switch (size)
2554     {
2555     case 1: mask = ((addressT) 1 <<  8) - 1; break;
2556     case 2: mask = ((addressT) 1 << 16) - 1; break;
2557     case 4: mask = ((addressT) 2 << 31) - 1; break;
2558 #ifdef BFD64
2559     case 8: mask = ((addressT) 2 << 63) - 1; break;
2560 #endif
2561     default: abort ();
2562     }
2563
2564   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
2565     {
2566       char buf1[40], buf2[40];
2567
2568       sprint_value (buf1, val);
2569       sprint_value (buf2, val & mask);
2570       as_warn (_("%s shortened to %s"), buf1, buf2);
2571     }
2572   return val & mask;
2573 }
2574
2575 enum PREFIX_GROUP
2576 {
2577   PREFIX_EXIST = 0,
2578   PREFIX_LOCK,
2579   PREFIX_REP,
2580   PREFIX_DS,
2581   PREFIX_OTHER
2582 };
2583
2584 /* Returns
2585    a. PREFIX_EXIST if attempting to add a prefix where one from the
2586    same class already exists.
2587    b. PREFIX_LOCK if lock prefix is added.
2588    c. PREFIX_REP if rep/repne prefix is added.
2589    d. PREFIX_DS if ds prefix is added.
2590    e. PREFIX_OTHER if other prefix is added.
2591  */
2592
2593 static enum PREFIX_GROUP
2594 add_prefix (unsigned int prefix)
2595 {
2596   enum PREFIX_GROUP ret = PREFIX_OTHER;
2597   unsigned int q;
2598
2599   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
2600       && flag_code == CODE_64BIT)
2601     {
2602       if ((i.prefix[REX_PREFIX] & prefix & REX_W)
2603           || (i.prefix[REX_PREFIX] & prefix & REX_R)
2604           || (i.prefix[REX_PREFIX] & prefix & REX_X)
2605           || (i.prefix[REX_PREFIX] & prefix & REX_B))
2606         ret = PREFIX_EXIST;
2607       q = REX_PREFIX;
2608     }
2609   else
2610     {
2611       switch (prefix)
2612         {
2613         default:
2614           abort ();
2615
2616         case DS_PREFIX_OPCODE:
2617           ret = PREFIX_DS;
2618           /* Fall through.  */
2619         case CS_PREFIX_OPCODE:
2620         case ES_PREFIX_OPCODE:
2621         case FS_PREFIX_OPCODE:
2622         case GS_PREFIX_OPCODE:
2623         case SS_PREFIX_OPCODE:
2624           q = SEG_PREFIX;
2625           break;
2626
2627         case REPNE_PREFIX_OPCODE:
2628         case REPE_PREFIX_OPCODE:
2629           q = REP_PREFIX;
2630           ret = PREFIX_REP;
2631           break;
2632
2633         case LOCK_PREFIX_OPCODE:
2634           q = LOCK_PREFIX;
2635           ret = PREFIX_LOCK;
2636           break;
2637
2638         case FWAIT_OPCODE:
2639           q = WAIT_PREFIX;
2640           break;
2641
2642         case ADDR_PREFIX_OPCODE:
2643           q = ADDR_PREFIX;
2644           break;
2645
2646         case DATA_PREFIX_OPCODE:
2647           q = DATA_PREFIX;
2648           break;
2649         }
2650       if (i.prefix[q] != 0)
2651         ret = PREFIX_EXIST;
2652     }
2653
2654   if (ret)
2655     {
2656       if (!i.prefix[q])
2657         ++i.prefixes;
2658       i.prefix[q] |= prefix;
2659     }
2660   else
2661     as_bad (_("same type of prefix used twice"));
2662
2663   return ret;
2664 }
2665
2666 static void
2667 update_code_flag (int value, int check)
2668 {
2669   PRINTF_LIKE ((*as_error));
2670
2671   flag_code = (enum flag_code) value;
2672   if (flag_code == CODE_64BIT)
2673     {
2674       cpu_arch_flags.bitfield.cpu64 = 1;
2675       cpu_arch_flags.bitfield.cpuno64 = 0;
2676     }
2677   else
2678     {
2679       cpu_arch_flags.bitfield.cpu64 = 0;
2680       cpu_arch_flags.bitfield.cpuno64 = 1;
2681     }
2682   if (value == CODE_64BIT && !cpu_arch_flags.bitfield.cpulm )
2683     {
2684       if (check)
2685         as_error = as_fatal;
2686       else
2687         as_error = as_bad;
2688       (*as_error) (_("64bit mode not supported on `%s'."),
2689                    cpu_arch_name ? cpu_arch_name : default_arch);
2690     }
2691   if (value == CODE_32BIT && !cpu_arch_flags.bitfield.cpui386)
2692     {
2693       if (check)
2694         as_error = as_fatal;
2695       else
2696         as_error = as_bad;
2697       (*as_error) (_("32bit mode not supported on `%s'."),
2698                    cpu_arch_name ? cpu_arch_name : default_arch);
2699     }
2700   stackop_size = '\0';
2701 }
2702
2703 static void
2704 set_code_flag (int value)
2705 {
2706   update_code_flag (value, 0);
2707 }
2708
2709 static void
2710 set_16bit_gcc_code_flag (int new_code_flag)
2711 {
2712   flag_code = (enum flag_code) new_code_flag;
2713   if (flag_code != CODE_16BIT)
2714     abort ();
2715   cpu_arch_flags.bitfield.cpu64 = 0;
2716   cpu_arch_flags.bitfield.cpuno64 = 1;
2717   stackop_size = LONG_MNEM_SUFFIX;
2718 }
2719
2720 static void
2721 set_intel_syntax (int syntax_flag)
2722 {
2723   /* Find out if register prefixing is specified.  */
2724   int ask_naked_reg = 0;
2725
2726   SKIP_WHITESPACE ();
2727   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2728     {
2729       char *string;
2730       int e = get_symbol_name (&string);
2731
2732       if (strcmp (string, "prefix") == 0)
2733         ask_naked_reg = 1;
2734       else if (strcmp (string, "noprefix") == 0)
2735         ask_naked_reg = -1;
2736       else
2737         as_bad (_("bad argument to syntax directive."));
2738       (void) restore_line_pointer (e);
2739     }
2740   demand_empty_rest_of_line ();
2741
2742   intel_syntax = syntax_flag;
2743
2744   if (ask_naked_reg == 0)
2745     allow_naked_reg = (intel_syntax
2746                        && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
2747   else
2748     allow_naked_reg = (ask_naked_reg < 0);
2749
2750   expr_set_rank (O_full_ptr, syntax_flag ? 10 : 0);
2751
2752   identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
2753   identifier_chars['$'] = intel_syntax ? '$' : 0;
2754   register_prefix = allow_naked_reg ? "" : "%";
2755 }
2756
2757 static void
2758 set_intel_mnemonic (int mnemonic_flag)
2759 {
2760   intel_mnemonic = mnemonic_flag;
2761 }
2762
2763 static void
2764 set_allow_index_reg (int flag)
2765 {
2766   allow_index_reg = flag;
2767 }
2768
2769 static void
2770 set_check (int what)
2771 {
2772   enum check_kind *kind;
2773   const char *str;
2774
2775   if (what)
2776     {
2777       kind = &operand_check;
2778       str = "operand";
2779     }
2780   else
2781     {
2782       kind = &sse_check;
2783       str = "sse";
2784     }
2785
2786   SKIP_WHITESPACE ();
2787
2788   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2789     {
2790       char *string;
2791       int e = get_symbol_name (&string);
2792
2793       if (strcmp (string, "none") == 0)
2794         *kind = check_none;
2795       else if (strcmp (string, "warning") == 0)
2796         *kind = check_warning;
2797       else if (strcmp (string, "error") == 0)
2798         *kind = check_error;
2799       else
2800         as_bad (_("bad argument to %s_check directive."), str);
2801       (void) restore_line_pointer (e);
2802     }
2803   else
2804     as_bad (_("missing argument for %s_check directive"), str);
2805
2806   demand_empty_rest_of_line ();
2807 }
2808
2809 static void
2810 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED,
2811                            i386_cpu_flags new_flag ATTRIBUTE_UNUSED)
2812 {
2813 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2814   static const char *arch;
2815
2816   /* Intel LIOM is only supported on ELF.  */
2817   if (!IS_ELF)
2818     return;
2819
2820   if (!arch)
2821     {
2822       /* Use cpu_arch_name if it is set in md_parse_option.  Otherwise
2823          use default_arch.  */
2824       arch = cpu_arch_name;
2825       if (!arch)
2826         arch = default_arch;
2827     }
2828
2829   /* If we are targeting Intel MCU, we must enable it.  */
2830   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_IAMCU
2831       || new_flag.bitfield.cpuiamcu)
2832     return;
2833
2834   /* If we are targeting Intel L1OM, we must enable it.  */
2835   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_L1OM
2836       || new_flag.bitfield.cpul1om)
2837     return;
2838
2839   /* If we are targeting Intel K1OM, we must enable it.  */
2840   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_K1OM
2841       || new_flag.bitfield.cpuk1om)
2842     return;
2843
2844   as_bad (_("`%s' is not supported on `%s'"), name, arch);
2845 #endif
2846 }
2847
2848 static void
2849 set_cpu_arch (int dummy ATTRIBUTE_UNUSED)
2850 {
2851   SKIP_WHITESPACE ();
2852
2853   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2854     {
2855       char *string;
2856       int e = get_symbol_name (&string);
2857       unsigned int j;
2858       i386_cpu_flags flags;
2859
2860       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
2861         {
2862           if (strcmp (string, cpu_arch[j].name) == 0)
2863             {
2864               check_cpu_arch_compatible (string, cpu_arch[j].flags);
2865
2866               if (*string != '.')
2867                 {
2868                   cpu_arch_name = cpu_arch[j].name;
2869                   cpu_sub_arch_name = NULL;
2870                   cpu_arch_flags = cpu_arch[j].flags;
2871                   if (flag_code == CODE_64BIT)
2872                     {
2873                       cpu_arch_flags.bitfield.cpu64 = 1;
2874                       cpu_arch_flags.bitfield.cpuno64 = 0;
2875                     }
2876                   else
2877                     {
2878                       cpu_arch_flags.bitfield.cpu64 = 0;
2879                       cpu_arch_flags.bitfield.cpuno64 = 1;
2880                     }
2881                   cpu_arch_isa = cpu_arch[j].type;
2882                   cpu_arch_isa_flags = cpu_arch[j].flags;
2883                   if (!cpu_arch_tune_set)
2884                     {
2885                       cpu_arch_tune = cpu_arch_isa;
2886                       cpu_arch_tune_flags = cpu_arch_isa_flags;
2887                     }
2888                   break;
2889                 }
2890
2891               flags = cpu_flags_or (cpu_arch_flags,
2892                                     cpu_arch[j].flags);
2893
2894               if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2895                 {
2896                   if (cpu_sub_arch_name)
2897                     {
2898                       char *name = cpu_sub_arch_name;
2899                       cpu_sub_arch_name = concat (name,
2900                                                   cpu_arch[j].name,
2901                                                   (const char *) NULL);
2902                       free (name);
2903                     }
2904                   else
2905                     cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
2906                   cpu_arch_flags = flags;
2907                   cpu_arch_isa_flags = flags;
2908                 }
2909               else
2910                 cpu_arch_isa_flags
2911                   = cpu_flags_or (cpu_arch_isa_flags,
2912                                   cpu_arch[j].flags);
2913               (void) restore_line_pointer (e);
2914               demand_empty_rest_of_line ();
2915               return;
2916             }
2917         }
2918
2919       if (*string == '.' && j >= ARRAY_SIZE (cpu_arch))
2920         {
2921           /* Disable an ISA extension.  */
2922           for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
2923             if (strcmp (string + 1, cpu_noarch [j].name) == 0)
2924               {
2925                 flags = cpu_flags_and_not (cpu_arch_flags,
2926                                            cpu_noarch[j].flags);
2927                 if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2928                   {
2929                     if (cpu_sub_arch_name)
2930                       {
2931                         char *name = cpu_sub_arch_name;
2932                         cpu_sub_arch_name = concat (name, string,
2933                                                     (const char *) NULL);
2934                         free (name);
2935                       }
2936                     else
2937                       cpu_sub_arch_name = xstrdup (string);
2938                     cpu_arch_flags = flags;
2939                     cpu_arch_isa_flags = flags;
2940                   }
2941                 (void) restore_line_pointer (e);
2942                 demand_empty_rest_of_line ();
2943                 return;
2944               }
2945
2946           j = ARRAY_SIZE (cpu_arch);
2947         }
2948
2949       if (j >= ARRAY_SIZE (cpu_arch))
2950         as_bad (_("no such architecture: `%s'"), string);
2951
2952       *input_line_pointer = e;
2953     }
2954   else
2955     as_bad (_("missing cpu architecture"));
2956
2957   no_cond_jump_promotion = 0;
2958   if (*input_line_pointer == ','
2959       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
2960     {
2961       char *string;
2962       char e;
2963
2964       ++input_line_pointer;
2965       e = get_symbol_name (&string);
2966
2967       if (strcmp (string, "nojumps") == 0)
2968         no_cond_jump_promotion = 1;
2969       else if (strcmp (string, "jumps") == 0)
2970         ;
2971       else
2972         as_bad (_("no such architecture modifier: `%s'"), string);
2973
2974       (void) restore_line_pointer (e);
2975     }
2976
2977   demand_empty_rest_of_line ();
2978 }
2979
2980 enum bfd_architecture
2981 i386_arch (void)
2982 {
2983   if (cpu_arch_isa == PROCESSOR_L1OM)
2984     {
2985       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2986           || flag_code != CODE_64BIT)
2987         as_fatal (_("Intel L1OM is 64bit ELF only"));
2988       return bfd_arch_l1om;
2989     }
2990   else if (cpu_arch_isa == PROCESSOR_K1OM)
2991     {
2992       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2993           || flag_code != CODE_64BIT)
2994         as_fatal (_("Intel K1OM is 64bit ELF only"));
2995       return bfd_arch_k1om;
2996     }
2997   else if (cpu_arch_isa == PROCESSOR_IAMCU)
2998     {
2999       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
3000           || flag_code == CODE_64BIT)
3001         as_fatal (_("Intel MCU is 32bit ELF only"));
3002       return bfd_arch_iamcu;
3003     }
3004   else
3005     return bfd_arch_i386;
3006 }
3007
3008 unsigned long
3009 i386_mach (void)
3010 {
3011   if (!strncmp (default_arch, "x86_64", 6))
3012     {
3013       if (cpu_arch_isa == PROCESSOR_L1OM)
3014         {
3015           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
3016               || default_arch[6] != '\0')
3017             as_fatal (_("Intel L1OM is 64bit ELF only"));
3018           return bfd_mach_l1om;
3019         }
3020       else if (cpu_arch_isa == PROCESSOR_K1OM)
3021         {
3022           if (OUTPUT_FLAVOR != bfd_target_elf_flavour
3023               || default_arch[6] != '\0')
3024             as_fatal (_("Intel K1OM is 64bit ELF only"));
3025           return bfd_mach_k1om;
3026         }
3027       else if (default_arch[6] == '\0')
3028         return bfd_mach_x86_64;
3029       else
3030         return bfd_mach_x64_32;
3031     }
3032   else if (!strcmp (default_arch, "i386")
3033            || !strcmp (default_arch, "iamcu"))
3034     {
3035       if (cpu_arch_isa == PROCESSOR_IAMCU)
3036         {
3037           if (OUTPUT_FLAVOR != bfd_target_elf_flavour)
3038             as_fatal (_("Intel MCU is 32bit ELF only"));
3039           return bfd_mach_i386_iamcu;
3040         }
3041       else
3042         return bfd_mach_i386_i386;
3043     }
3044   else
3045     as_fatal (_("unknown architecture"));
3046 }
3047 \f
3048 void
3049 md_begin (void)
3050 {
3051   /* Support pseudo prefixes like {disp32}.  */
3052   lex_type ['{'] = LEX_BEGIN_NAME;
3053
3054   /* Initialize op_hash hash table.  */
3055   op_hash = str_htab_create ();
3056
3057   {
3058     const insn_template *optab;
3059     templates *core_optab;
3060
3061     /* Setup for loop.  */
3062     optab = i386_optab;
3063     core_optab = XNEW (templates);
3064     core_optab->start = optab;
3065
3066     while (1)
3067       {
3068         ++optab;
3069         if (optab->name == NULL
3070             || strcmp (optab->name, (optab - 1)->name) != 0)
3071           {
3072             /* different name --> ship out current template list;
3073                add to hash table; & begin anew.  */
3074             core_optab->end = optab;
3075             if (str_hash_insert (op_hash, (optab - 1)->name, core_optab, 0))
3076               as_fatal (_("duplicate %s"), (optab - 1)->name);
3077
3078             if (optab->name == NULL)
3079               break;
3080             core_optab = XNEW (templates);
3081             core_optab->start = optab;
3082           }
3083       }
3084   }
3085
3086   /* Initialize reg_hash hash table.  */
3087   reg_hash = str_htab_create ();
3088   {
3089     const reg_entry *regtab;
3090     unsigned int regtab_size = i386_regtab_size;
3091
3092     for (regtab = i386_regtab; regtab_size--; regtab++)
3093       if (str_hash_insert (reg_hash, regtab->reg_name, regtab, 0) != NULL)
3094         as_fatal (_("duplicate %s"), regtab->reg_name);
3095   }
3096
3097   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
3098   {
3099     int c;
3100     char *p;
3101
3102     for (c = 0; c < 256; c++)
3103       {
3104         if (ISDIGIT (c))
3105           {
3106             digit_chars[c] = c;
3107             mnemonic_chars[c] = c;
3108             register_chars[c] = c;
3109             operand_chars[c] = c;
3110           }
3111         else if (ISLOWER (c))
3112           {
3113             mnemonic_chars[c] = c;
3114             register_chars[c] = c;
3115             operand_chars[c] = c;
3116           }
3117         else if (ISUPPER (c))
3118           {
3119             mnemonic_chars[c] = TOLOWER (c);
3120             register_chars[c] = mnemonic_chars[c];
3121             operand_chars[c] = c;
3122           }
3123         else if (c == '{' || c == '}')
3124           {
3125             mnemonic_chars[c] = c;
3126             operand_chars[c] = c;
3127           }
3128 #ifdef SVR4_COMMENT_CHARS
3129         else if (c == '\\' && strchr (i386_comment_chars, '/'))
3130           operand_chars[c] = c;
3131 #endif
3132
3133         if (ISALPHA (c) || ISDIGIT (c))
3134           identifier_chars[c] = c;
3135         else if (c >= 128)
3136           {
3137             identifier_chars[c] = c;
3138             operand_chars[c] = c;
3139           }
3140       }
3141
3142 #ifdef LEX_AT
3143     identifier_chars['@'] = '@';
3144 #endif
3145 #ifdef LEX_QM
3146     identifier_chars['?'] = '?';
3147     operand_chars['?'] = '?';
3148 #endif
3149     digit_chars['-'] = '-';
3150     mnemonic_chars['_'] = '_';
3151     mnemonic_chars['-'] = '-';
3152     mnemonic_chars['.'] = '.';
3153     identifier_chars['_'] = '_';
3154     identifier_chars['.'] = '.';
3155
3156     for (p = operand_special_chars; *p != '\0'; p++)
3157       operand_chars[(unsigned char) *p] = *p;
3158   }
3159
3160   if (flag_code == CODE_64BIT)
3161     {
3162 #if defined (OBJ_COFF) && defined (TE_PE)
3163       x86_dwarf2_return_column = (OUTPUT_FLAVOR == bfd_target_coff_flavour
3164                                   ? 32 : 16);
3165 #else
3166       x86_dwarf2_return_column = 16;
3167 #endif
3168       x86_cie_data_alignment = -8;
3169     }
3170   else
3171     {
3172       x86_dwarf2_return_column = 8;
3173       x86_cie_data_alignment = -4;
3174     }
3175
3176   /* NB: FUSED_JCC_PADDING frag must have sufficient room so that it
3177      can be turned into BRANCH_PREFIX frag.  */
3178   if (align_branch_prefix_size > MAX_FUSED_JCC_PADDING_SIZE)
3179     abort ();
3180 }
3181
3182 void
3183 i386_print_statistics (FILE *file)
3184 {
3185   htab_print_statistics (file, "i386 opcode", op_hash);
3186   htab_print_statistics (file, "i386 register", reg_hash);
3187 }
3188 \f
3189 #ifdef DEBUG386
3190
3191 /* Debugging routines for md_assemble.  */
3192 static void pte (insn_template *);
3193 static void pt (i386_operand_type);
3194 static void pe (expressionS *);
3195 static void ps (symbolS *);
3196
3197 static void
3198 pi (const char *line, i386_insn *x)
3199 {
3200   unsigned int j;
3201
3202   fprintf (stdout, "%s: template ", line);
3203   pte (&x->tm);
3204   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
3205            x->base_reg ? x->base_reg->reg_name : "none",
3206            x->index_reg ? x->index_reg->reg_name : "none",
3207            x->log2_scale_factor);
3208   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
3209            x->rm.mode, x->rm.reg, x->rm.regmem);
3210   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
3211            x->sib.base, x->sib.index, x->sib.scale);
3212   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
3213            (x->rex & REX_W) != 0,
3214            (x->rex & REX_R) != 0,
3215            (x->rex & REX_X) != 0,
3216            (x->rex & REX_B) != 0);
3217   for (j = 0; j < x->operands; j++)
3218     {
3219       fprintf (stdout, "    #%d:  ", j + 1);
3220       pt (x->types[j]);
3221       fprintf (stdout, "\n");
3222       if (x->types[j].bitfield.class == Reg
3223           || x->types[j].bitfield.class == RegMMX
3224           || x->types[j].bitfield.class == RegSIMD
3225           || x->types[j].bitfield.class == RegMask
3226           || x->types[j].bitfield.class == SReg
3227           || x->types[j].bitfield.class == RegCR
3228           || x->types[j].bitfield.class == RegDR
3229           || x->types[j].bitfield.class == RegTR
3230           || x->types[j].bitfield.class == RegBND)
3231         fprintf (stdout, "%s\n", x->op[j].regs->reg_name);
3232       if (operand_type_check (x->types[j], imm))
3233         pe (x->op[j].imms);
3234       if (operand_type_check (x->types[j], disp))
3235         pe (x->op[j].disps);
3236     }
3237 }
3238
3239 static void
3240 pte (insn_template *t)
3241 {
3242   unsigned int j;
3243   fprintf (stdout, " %d operands ", t->operands);
3244   fprintf (stdout, "opcode %x ", t->base_opcode);
3245   if (t->extension_opcode != None)
3246     fprintf (stdout, "ext %x ", t->extension_opcode);
3247   if (t->opcode_modifier.d)
3248     fprintf (stdout, "D");
3249   if (t->opcode_modifier.w)
3250     fprintf (stdout, "W");
3251   fprintf (stdout, "\n");
3252   for (j = 0; j < t->operands; j++)
3253     {
3254       fprintf (stdout, "    #%d type ", j + 1);
3255       pt (t->operand_types[j]);
3256       fprintf (stdout, "\n");
3257     }
3258 }
3259
3260 static void
3261 pe (expressionS *e)
3262 {
3263   fprintf (stdout, "    operation     %d\n", e->X_op);
3264   fprintf (stdout, "    add_number    %ld (%lx)\n",
3265            (long) e->X_add_number, (long) e->X_add_number);
3266   if (e->X_add_symbol)
3267     {
3268       fprintf (stdout, "    add_symbol    ");
3269       ps (e->X_add_symbol);
3270       fprintf (stdout, "\n");
3271     }
3272   if (e->X_op_symbol)
3273     {
3274       fprintf (stdout, "    op_symbol    ");
3275       ps (e->X_op_symbol);
3276       fprintf (stdout, "\n");
3277     }
3278 }
3279
3280 static void
3281 ps (symbolS *s)
3282 {
3283   fprintf (stdout, "%s type %s%s",
3284            S_GET_NAME (s),
3285            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
3286            segment_name (S_GET_SEGMENT (s)));
3287 }
3288
3289 static struct type_name
3290   {
3291     i386_operand_type mask;
3292     const char *name;
3293   }
3294 const type_names[] =
3295 {
3296   { OPERAND_TYPE_REG8, "r8" },
3297   { OPERAND_TYPE_REG16, "r16" },
3298   { OPERAND_TYPE_REG32, "r32" },
3299   { OPERAND_TYPE_REG64, "r64" },
3300   { OPERAND_TYPE_ACC8, "acc8" },
3301   { OPERAND_TYPE_ACC16, "acc16" },
3302   { OPERAND_TYPE_ACC32, "acc32" },
3303   { OPERAND_TYPE_ACC64, "acc64" },
3304   { OPERAND_TYPE_IMM8, "i8" },
3305   { OPERAND_TYPE_IMM8, "i8s" },
3306   { OPERAND_TYPE_IMM16, "i16" },
3307   { OPERAND_TYPE_IMM32, "i32" },
3308   { OPERAND_TYPE_IMM32S, "i32s" },
3309   { OPERAND_TYPE_IMM64, "i64" },
3310   { OPERAND_TYPE_IMM1, "i1" },
3311   { OPERAND_TYPE_BASEINDEX, "BaseIndex" },
3312   { OPERAND_TYPE_DISP8, "d8" },
3313   { OPERAND_TYPE_DISP16, "d16" },
3314   { OPERAND_TYPE_DISP32, "d32" },
3315   { OPERAND_TYPE_DISP32S, "d32s" },
3316   { OPERAND_TYPE_DISP64, "d64" },
3317   { OPERAND_TYPE_INOUTPORTREG, "InOutPortReg" },
3318   { OPERAND_TYPE_SHIFTCOUNT, "ShiftCount" },
3319   { OPERAND_TYPE_CONTROL, "control reg" },
3320   { OPERAND_TYPE_TEST, "test reg" },
3321   { OPERAND_TYPE_DEBUG, "debug reg" },
3322   { OPERAND_TYPE_FLOATREG, "FReg" },
3323   { OPERAND_TYPE_FLOATACC, "FAcc" },
3324   { OPERAND_TYPE_SREG, "SReg" },
3325   { OPERAND_TYPE_REGMMX, "rMMX" },
3326   { OPERAND_TYPE_REGXMM, "rXMM" },
3327   { OPERAND_TYPE_REGYMM, "rYMM" },
3328   { OPERAND_TYPE_REGZMM, "rZMM" },
3329   { OPERAND_TYPE_REGTMM, "rTMM" },
3330   { OPERAND_TYPE_REGMASK, "Mask reg" },
3331 };
3332
3333 static void
3334 pt (i386_operand_type t)
3335 {
3336   unsigned int j;
3337   i386_operand_type a;
3338
3339   for (j = 0; j < ARRAY_SIZE (type_names); j++)
3340     {
3341       a = operand_type_and (t, type_names[j].mask);
3342       if (operand_type_equal (&a, &type_names[j].mask))
3343         fprintf (stdout, "%s, ",  type_names[j].name);
3344     }
3345   fflush (stdout);
3346 }
3347
3348 #endif /* DEBUG386 */
3349 \f
3350 static bfd_reloc_code_real_type
3351 reloc (unsigned int size,
3352        int pcrel,
3353        int sign,
3354        bfd_reloc_code_real_type other)
3355 {
3356   if (other != NO_RELOC)
3357     {
3358       reloc_howto_type *rel;
3359
3360       if (size == 8)
3361         switch (other)
3362           {
3363           case BFD_RELOC_X86_64_GOT32:
3364             return BFD_RELOC_X86_64_GOT64;
3365             break;
3366           case BFD_RELOC_X86_64_GOTPLT64:
3367             return BFD_RELOC_X86_64_GOTPLT64;
3368             break;
3369           case BFD_RELOC_X86_64_PLTOFF64:
3370             return BFD_RELOC_X86_64_PLTOFF64;
3371             break;
3372           case BFD_RELOC_X86_64_GOTPC32:
3373             other = BFD_RELOC_X86_64_GOTPC64;
3374             break;
3375           case BFD_RELOC_X86_64_GOTPCREL:
3376             other = BFD_RELOC_X86_64_GOTPCREL64;
3377             break;
3378           case BFD_RELOC_X86_64_TPOFF32:
3379             other = BFD_RELOC_X86_64_TPOFF64;
3380             break;
3381           case BFD_RELOC_X86_64_DTPOFF32:
3382             other = BFD_RELOC_X86_64_DTPOFF64;
3383             break;
3384           default:
3385             break;
3386           }
3387
3388 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3389       if (other == BFD_RELOC_SIZE32)
3390         {
3391           if (size == 8)
3392             other = BFD_RELOC_SIZE64;
3393           if (pcrel)
3394             {
3395               as_bad (_("there are no pc-relative size relocations"));
3396               return NO_RELOC;
3397             }
3398         }
3399 #endif
3400
3401       /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless.  */
3402       if (size == 4 && (flag_code != CODE_64BIT || disallow_64bit_reloc))
3403         sign = -1;
3404
3405       rel = bfd_reloc_type_lookup (stdoutput, other);
3406       if (!rel)
3407         as_bad (_("unknown relocation (%u)"), other);
3408       else if (size != bfd_get_reloc_size (rel))
3409         as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
3410                 bfd_get_reloc_size (rel),
3411                 size);
3412       else if (pcrel && !rel->pc_relative)
3413         as_bad (_("non-pc-relative relocation for pc-relative field"));
3414       else if ((rel->complain_on_overflow == complain_overflow_signed
3415                 && !sign)
3416                || (rel->complain_on_overflow == complain_overflow_unsigned
3417                    && sign > 0))
3418         as_bad (_("relocated field and relocation type differ in signedness"));
3419       else
3420         return other;
3421       return NO_RELOC;
3422     }
3423
3424   if (pcrel)
3425     {
3426       if (!sign)
3427         as_bad (_("there are no unsigned pc-relative relocations"));
3428       switch (size)
3429         {
3430         case 1: return BFD_RELOC_8_PCREL;
3431         case 2: return BFD_RELOC_16_PCREL;
3432         case 4: return BFD_RELOC_32_PCREL;
3433         case 8: return BFD_RELOC_64_PCREL;
3434         }
3435       as_bad (_("cannot do %u byte pc-relative relocation"), size);
3436     }
3437   else
3438     {
3439       if (sign > 0)
3440         switch (size)
3441           {
3442           case 4: return BFD_RELOC_X86_64_32S;
3443           }
3444       else
3445         switch (size)
3446           {
3447           case 1: return BFD_RELOC_8;
3448           case 2: return BFD_RELOC_16;
3449           case 4: return BFD_RELOC_32;
3450           case 8: return BFD_RELOC_64;
3451           }
3452       as_bad (_("cannot do %s %u byte relocation"),
3453               sign > 0 ? "signed" : "unsigned", size);
3454     }
3455
3456   return NO_RELOC;
3457 }
3458
3459 /* Here we decide which fixups can be adjusted to make them relative to
3460    the beginning of the section instead of the symbol.  Basically we need
3461    to make sure that the dynamic relocations are done correctly, so in
3462    some cases we force the original symbol to be used.  */
3463
3464 int
3465 tc_i386_fix_adjustable (fixS *fixP ATTRIBUTE_UNUSED)
3466 {
3467 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3468   if (!IS_ELF)
3469     return 1;
3470
3471   /* Don't adjust pc-relative references to merge sections in 64-bit
3472      mode.  */
3473   if (use_rela_relocations
3474       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
3475       && fixP->fx_pcrel)
3476     return 0;
3477
3478   /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
3479      and changed later by validate_fix.  */
3480   if (GOT_symbol && fixP->fx_subsy == GOT_symbol
3481       && fixP->fx_r_type == BFD_RELOC_32_PCREL)
3482     return 0;
3483
3484   /* Adjust_reloc_syms doesn't know about the GOT.  Need to keep symbol
3485      for size relocations.  */
3486   if (fixP->fx_r_type == BFD_RELOC_SIZE32
3487       || fixP->fx_r_type == BFD_RELOC_SIZE64
3488       || fixP->fx_r_type == BFD_RELOC_386_GOTOFF
3489       || fixP->fx_r_type == BFD_RELOC_386_GOT32
3490       || fixP->fx_r_type == BFD_RELOC_386_GOT32X
3491       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
3492       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
3493       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
3494       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
3495       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
3496       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
3497       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
3498       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
3499       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
3500       || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
3501       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
3502       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
3503       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCRELX
3504       || fixP->fx_r_type == BFD_RELOC_X86_64_REX_GOTPCRELX
3505       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
3506       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
3507       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
3508       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
3509       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
3510       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
3511       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
3512       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
3513       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
3514       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
3515       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
3516       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
3517     return 0;
3518 #endif
3519   return 1;
3520 }
3521
3522 static int
3523 intel_float_operand (const char *mnemonic)
3524 {
3525   /* Note that the value returned is meaningful only for opcodes with (memory)
3526      operands, hence the code here is free to improperly handle opcodes that
3527      have no operands (for better performance and smaller code). */
3528
3529   if (mnemonic[0] != 'f')
3530     return 0; /* non-math */
3531
3532   switch (mnemonic[1])
3533     {
3534     /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
3535        the fs segment override prefix not currently handled because no
3536        call path can make opcodes without operands get here */
3537     case 'i':
3538       return 2 /* integer op */;
3539     case 'l':
3540       if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
3541         return 3; /* fldcw/fldenv */
3542       break;
3543     case 'n':
3544       if (mnemonic[2] != 'o' /* fnop */)
3545         return 3; /* non-waiting control op */
3546       break;
3547     case 'r':
3548       if (mnemonic[2] == 's')
3549         return 3; /* frstor/frstpm */
3550       break;
3551     case 's':
3552       if (mnemonic[2] == 'a')
3553         return 3; /* fsave */
3554       if (mnemonic[2] == 't')
3555         {
3556           switch (mnemonic[3])
3557             {
3558             case 'c': /* fstcw */
3559             case 'd': /* fstdw */
3560             case 'e': /* fstenv */
3561             case 's': /* fsts[gw] */
3562               return 3;
3563             }
3564         }
3565       break;
3566     case 'x':
3567       if (mnemonic[2] == 'r' || mnemonic[2] == 's')
3568         return 0; /* fxsave/fxrstor are not really math ops */
3569       break;
3570     }
3571
3572   return 1;
3573 }
3574
3575 /* Build the VEX prefix.  */
3576
3577 static void
3578 build_vex_prefix (const insn_template *t)
3579 {
3580   unsigned int register_specifier;
3581   unsigned int implied_prefix;
3582   unsigned int vector_length;
3583   unsigned int w;
3584
3585   /* Check register specifier.  */
3586   if (i.vex.register_specifier)
3587     {
3588       register_specifier =
3589         ~register_number (i.vex.register_specifier) & 0xf;
3590       gas_assert ((i.vex.register_specifier->reg_flags & RegVRex) == 0);
3591     }
3592   else
3593     register_specifier = 0xf;
3594
3595   /* Use 2-byte VEX prefix by swapping destination and source operand
3596      if there are more than 1 register operand.  */
3597   if (i.reg_operands > 1
3598       && i.vec_encoding != vex_encoding_vex3
3599       && i.dir_encoding == dir_encoding_default
3600       && i.operands == i.reg_operands
3601       && operand_type_equal (&i.types[0], &i.types[i.operands - 1])
3602       && i.tm.opcode_modifier.opcodeprefix == VEX0F
3603       && (i.tm.opcode_modifier.load || i.tm.opcode_modifier.d)
3604       && i.rex == REX_B)
3605     {
3606       unsigned int xchg = i.operands - 1;
3607       union i386_op temp_op;
3608       i386_operand_type temp_type;
3609
3610       temp_type = i.types[xchg];
3611       i.types[xchg] = i.types[0];
3612       i.types[0] = temp_type;
3613       temp_op = i.op[xchg];
3614       i.op[xchg] = i.op[0];
3615       i.op[0] = temp_op;
3616
3617       gas_assert (i.rm.mode == 3);
3618
3619       i.rex = REX_R;
3620       xchg = i.rm.regmem;
3621       i.rm.regmem = i.rm.reg;
3622       i.rm.reg = xchg;
3623
3624       if (i.tm.opcode_modifier.d)
3625         i.tm.base_opcode ^= (i.tm.base_opcode & 0xee) != 0x6e
3626                             ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
3627       else /* Use the next insn.  */
3628         i.tm = t[1];
3629     }
3630
3631   /* Use 2-byte VEX prefix by swapping commutative source operands if there
3632      are no memory operands and at least 3 register ones.  */
3633   if (i.reg_operands >= 3
3634       && i.vec_encoding != vex_encoding_vex3
3635       && i.reg_operands == i.operands - i.imm_operands
3636       && i.tm.opcode_modifier.vex
3637       && i.tm.opcode_modifier.commutative
3638       && (i.tm.opcode_modifier.sse2avx || optimize > 1)
3639       && i.rex == REX_B
3640       && i.vex.register_specifier
3641       && !(i.vex.register_specifier->reg_flags & RegRex))
3642     {
3643       unsigned int xchg = i.operands - i.reg_operands;
3644       union i386_op temp_op;
3645       i386_operand_type temp_type;
3646
3647       gas_assert (i.tm.opcode_modifier.opcodeprefix == VEX0F);
3648       gas_assert (!i.tm.opcode_modifier.sae);
3649       gas_assert (operand_type_equal (&i.types[i.operands - 2],
3650                                       &i.types[i.operands - 3]));
3651       gas_assert (i.rm.mode == 3);
3652
3653       temp_type = i.types[xchg];
3654       i.types[xchg] = i.types[xchg + 1];
3655       i.types[xchg + 1] = temp_type;
3656       temp_op = i.op[xchg];
3657       i.op[xchg] = i.op[xchg + 1];
3658       i.op[xchg + 1] = temp_op;
3659
3660       i.rex = 0;
3661       xchg = i.rm.regmem | 8;
3662       i.rm.regmem = ~register_specifier & 0xf;
3663       gas_assert (!(i.rm.regmem & 8));
3664       i.vex.register_specifier += xchg - i.rm.regmem;
3665       register_specifier = ~xchg & 0xf;
3666     }
3667
3668   if (i.tm.opcode_modifier.vex == VEXScalar)
3669     vector_length = avxscalar;
3670   else if (i.tm.opcode_modifier.vex == VEX256)
3671     vector_length = 1;
3672   else
3673     {
3674       unsigned int op;
3675
3676       /* Determine vector length from the last multi-length vector
3677          operand.  */
3678       vector_length = 0;
3679       for (op = t->operands; op--;)
3680         if (t->operand_types[op].bitfield.xmmword
3681             && t->operand_types[op].bitfield.ymmword
3682             && i.types[op].bitfield.ymmword)
3683           {
3684             vector_length = 1;
3685             break;
3686           }
3687     }
3688
3689   switch ((i.tm.base_opcode >> (i.tm.opcode_length << 3)) & 0xff)
3690     {
3691     case 0:
3692       implied_prefix = 0;
3693       break;
3694     case DATA_PREFIX_OPCODE:
3695       implied_prefix = 1;
3696       break;
3697     case REPE_PREFIX_OPCODE:
3698       implied_prefix = 2;
3699       break;
3700     case REPNE_PREFIX_OPCODE:
3701       implied_prefix = 3;
3702       break;
3703     default:
3704       abort ();
3705     }
3706
3707   /* Check the REX.W bit and VEXW.  */
3708   if (i.tm.opcode_modifier.vexw == VEXWIG)
3709     w = (vexwig == vexw1 || (i.rex & REX_W)) ? 1 : 0;
3710   else if (i.tm.opcode_modifier.vexw)
3711     w = i.tm.opcode_modifier.vexw == VEXW1 ? 1 : 0;
3712   else
3713     w = (flag_code == CODE_64BIT ? i.rex & REX_W : vexwig == vexw1) ? 1 : 0;
3714
3715   /* Use 2-byte VEX prefix if possible.  */
3716   if (w == 0
3717       && i.vec_encoding != vex_encoding_vex3
3718       && i.tm.opcode_modifier.opcodeprefix == VEX0F
3719       && (i.rex & (REX_W | REX_X | REX_B)) == 0)
3720     {
3721       /* 2-byte VEX prefix.  */
3722       unsigned int r;
3723
3724       i.vex.length = 2;
3725       i.vex.bytes[0] = 0xc5;
3726
3727       /* Check the REX.R bit.  */
3728       r = (i.rex & REX_R) ? 0 : 1;
3729       i.vex.bytes[1] = (r << 7
3730                         | register_specifier << 3
3731                         | vector_length << 2
3732                         | implied_prefix);
3733     }
3734   else
3735     {
3736       /* 3-byte VEX prefix.  */
3737       unsigned int m;
3738
3739       i.vex.length = 3;
3740
3741       switch (i.tm.opcode_modifier.opcodeprefix)
3742         {
3743         case VEX0F:
3744           m = 0x1;
3745           i.vex.bytes[0] = 0xc4;
3746           break;
3747         case VEX0F38:
3748           m = 0x2;
3749           i.vex.bytes[0] = 0xc4;
3750           break;
3751         case VEX0F3A:
3752           m = 0x3;
3753           i.vex.bytes[0] = 0xc4;
3754           break;
3755         case XOP08:
3756           m = 0x8;
3757           i.vex.bytes[0] = 0x8f;
3758           break;
3759         case XOP09:
3760           m = 0x9;
3761           i.vex.bytes[0] = 0x8f;
3762           break;
3763         case XOP0A:
3764           m = 0xa;
3765           i.vex.bytes[0] = 0x8f;
3766           break;
3767         default:
3768           abort ();
3769         }
3770
3771       /* The high 3 bits of the second VEX byte are 1's compliment
3772          of RXB bits from REX.  */
3773       i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3774
3775       i.vex.bytes[2] = (w << 7
3776                         | register_specifier << 3
3777                         | vector_length << 2
3778                         | implied_prefix);
3779     }
3780 }
3781
3782 static INLINE bfd_boolean
3783 is_evex_encoding (const insn_template *t)
3784 {
3785   return t->opcode_modifier.evex || t->opcode_modifier.disp8memshift
3786          || t->opcode_modifier.broadcast || t->opcode_modifier.masking
3787          || t->opcode_modifier.sae;
3788 }
3789
3790 static INLINE bfd_boolean
3791 is_any_vex_encoding (const insn_template *t)
3792 {
3793   return t->opcode_modifier.vex || is_evex_encoding (t);
3794 }
3795
3796 /* Build the EVEX prefix.  */
3797
3798 static void
3799 build_evex_prefix (void)
3800 {
3801   unsigned int register_specifier;
3802   unsigned int implied_prefix;
3803   unsigned int m, w;
3804   rex_byte vrex_used = 0;
3805
3806   /* Check register specifier.  */
3807   if (i.vex.register_specifier)
3808     {
3809       gas_assert ((i.vrex & REX_X) == 0);
3810
3811       register_specifier = i.vex.register_specifier->reg_num;
3812       if ((i.vex.register_specifier->reg_flags & RegRex))
3813         register_specifier += 8;
3814       /* The upper 16 registers are encoded in the fourth byte of the
3815          EVEX prefix.  */
3816       if (!(i.vex.register_specifier->reg_flags & RegVRex))
3817         i.vex.bytes[3] = 0x8;
3818       register_specifier = ~register_specifier & 0xf;
3819     }
3820   else
3821     {
3822       register_specifier = 0xf;
3823
3824       /* Encode upper 16 vector index register in the fourth byte of
3825          the EVEX prefix.  */
3826       if (!(i.vrex & REX_X))
3827         i.vex.bytes[3] = 0x8;
3828       else
3829         vrex_used |= REX_X;
3830     }
3831
3832   switch ((i.tm.base_opcode >> 8) & 0xff)
3833     {
3834     case 0:
3835       implied_prefix = 0;
3836       break;
3837     case DATA_PREFIX_OPCODE:
3838       implied_prefix = 1;
3839       break;
3840     case REPE_PREFIX_OPCODE:
3841       implied_prefix = 2;
3842       break;
3843     case REPNE_PREFIX_OPCODE:
3844       implied_prefix = 3;
3845       break;
3846     default:
3847       abort ();
3848     }
3849
3850   /* 4 byte EVEX prefix.  */
3851   i.vex.length = 4;
3852   i.vex.bytes[0] = 0x62;
3853
3854   /* mmmm bits.  */
3855   switch (i.tm.opcode_modifier.opcodeprefix)
3856     {
3857     case VEX0F:
3858       m = 1;
3859       break;
3860     case VEX0F38:
3861       m = 2;
3862       break;
3863     case VEX0F3A:
3864       m = 3;
3865       break;
3866     default:
3867       abort ();
3868       break;
3869     }
3870
3871   /* The high 3 bits of the second EVEX byte are 1's compliment of RXB
3872      bits from REX.  */
3873   i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
3874
3875   /* The fifth bit of the second EVEX byte is 1's compliment of the
3876      REX_R bit in VREX.  */
3877   if (!(i.vrex & REX_R))
3878     i.vex.bytes[1] |= 0x10;
3879   else
3880     vrex_used |= REX_R;
3881
3882   if ((i.reg_operands + i.imm_operands) == i.operands)
3883     {
3884       /* When all operands are registers, the REX_X bit in REX is not
3885          used.  We reuse it to encode the upper 16 registers, which is
3886          indicated by the REX_B bit in VREX.  The REX_X bit is encoded
3887          as 1's compliment.  */
3888       if ((i.vrex & REX_B))
3889         {
3890           vrex_used |= REX_B;
3891           i.vex.bytes[1] &= ~0x40;
3892         }
3893     }
3894
3895   /* EVEX instructions shouldn't need the REX prefix.  */
3896   i.vrex &= ~vrex_used;
3897   gas_assert (i.vrex == 0);
3898
3899   /* Check the REX.W bit and VEXW.  */
3900   if (i.tm.opcode_modifier.vexw == VEXWIG)
3901     w = (evexwig == evexw1 || (i.rex & REX_W)) ? 1 : 0;
3902   else if (i.tm.opcode_modifier.vexw)
3903     w = i.tm.opcode_modifier.vexw == VEXW1 ? 1 : 0;
3904   else
3905     w = (flag_code == CODE_64BIT ? i.rex & REX_W : evexwig == evexw1) ? 1 : 0;
3906
3907   /* Encode the U bit.  */
3908   implied_prefix |= 0x4;
3909
3910   /* The third byte of the EVEX prefix.  */
3911   i.vex.bytes[2] = (w << 7 | register_specifier << 3 | implied_prefix);
3912
3913   /* The fourth byte of the EVEX prefix.  */
3914   /* The zeroing-masking bit.  */
3915   if (i.mask && i.mask->zeroing)
3916     i.vex.bytes[3] |= 0x80;
3917
3918   /* Don't always set the broadcast bit if there is no RC.  */
3919   if (!i.rounding)
3920     {
3921       /* Encode the vector length.  */
3922       unsigned int vec_length;
3923
3924       if (!i.tm.opcode_modifier.evex
3925           || i.tm.opcode_modifier.evex == EVEXDYN)
3926         {
3927           unsigned int op;
3928
3929           /* Determine vector length from the last multi-length vector
3930              operand.  */
3931           for (op = i.operands; op--;)
3932             if (i.tm.operand_types[op].bitfield.xmmword
3933                 + i.tm.operand_types[op].bitfield.ymmword
3934                 + i.tm.operand_types[op].bitfield.zmmword > 1)
3935               {
3936                 if (i.types[op].bitfield.zmmword)
3937                   {
3938                     i.tm.opcode_modifier.evex = EVEX512;
3939                     break;
3940                   }
3941                 else if (i.types[op].bitfield.ymmword)
3942                   {
3943                     i.tm.opcode_modifier.evex = EVEX256;
3944                     break;
3945                   }
3946                 else if (i.types[op].bitfield.xmmword)
3947                   {
3948                     i.tm.opcode_modifier.evex = EVEX128;
3949                     break;
3950                   }
3951                 else if (i.broadcast && (int) op == i.broadcast->operand)
3952                   {
3953                     switch (i.broadcast->bytes)
3954                       {
3955                         case 64:
3956                           i.tm.opcode_modifier.evex = EVEX512;
3957                           break;
3958                         case 32:
3959                           i.tm.opcode_modifier.evex = EVEX256;
3960                           break;
3961                         case 16:
3962                           i.tm.opcode_modifier.evex = EVEX128;
3963                           break;
3964                         default:
3965                           abort ();
3966                       }
3967                     break;
3968                   }
3969               }
3970
3971           if (op >= MAX_OPERANDS)
3972             abort ();
3973         }
3974
3975       switch (i.tm.opcode_modifier.evex)
3976         {
3977         case EVEXLIG: /* LL' is ignored */
3978           vec_length = evexlig << 5;
3979           break;
3980         case EVEX128:
3981           vec_length = 0 << 5;
3982           break;
3983         case EVEX256:
3984           vec_length = 1 << 5;
3985           break;
3986         case EVEX512:
3987           vec_length = 2 << 5;
3988           break;
3989         default:
3990           abort ();
3991           break;
3992         }
3993       i.vex.bytes[3] |= vec_length;
3994       /* Encode the broadcast bit.  */
3995       if (i.broadcast)
3996         i.vex.bytes[3] |= 0x10;
3997     }
3998   else
3999     {
4000       if (i.rounding->type != saeonly)
4001         i.vex.bytes[3] |= 0x10 | (i.rounding->type << 5);
4002       else
4003         i.vex.bytes[3] |= 0x10 | (evexrcig << 5);
4004     }
4005
4006   if (i.mask && i.mask->mask)
4007     i.vex.bytes[3] |= i.mask->mask->reg_num;
4008 }
4009
4010 static void
4011 process_immext (void)
4012 {
4013   expressionS *exp;
4014
4015   /* These AMD 3DNow! and SSE2 instructions have an opcode suffix
4016      which is coded in the same place as an 8-bit immediate field
4017      would be.  Here we fake an 8-bit immediate operand from the
4018      opcode suffix stored in tm.extension_opcode.
4019
4020      AVX instructions also use this encoding, for some of
4021      3 argument instructions.  */
4022
4023   gas_assert (i.imm_operands <= 1
4024               && (i.operands <= 2
4025                   || (is_any_vex_encoding (&i.tm)
4026                       && i.operands <= 4)));
4027
4028   exp = &im_expressions[i.imm_operands++];
4029   i.op[i.operands].imms = exp;
4030   i.types[i.operands] = imm8;
4031   i.operands++;
4032   exp->X_op = O_constant;
4033   exp->X_add_number = i.tm.extension_opcode;
4034   i.tm.extension_opcode = None;
4035 }
4036
4037
4038 static int
4039 check_hle (void)
4040 {
4041   switch (i.tm.opcode_modifier.hleprefixok)
4042     {
4043     default:
4044       abort ();
4045     case HLEPrefixNone:
4046       as_bad (_("invalid instruction `%s' after `%s'"),
4047               i.tm.name, i.hle_prefix);
4048       return 0;
4049     case HLEPrefixLock:
4050       if (i.prefix[LOCK_PREFIX])
4051         return 1;
4052       as_bad (_("missing `lock' with `%s'"), i.hle_prefix);
4053       return 0;
4054     case HLEPrefixAny:
4055       return 1;
4056     case HLEPrefixRelease:
4057       if (i.prefix[HLE_PREFIX] != XRELEASE_PREFIX_OPCODE)
4058         {
4059           as_bad (_("instruction `%s' after `xacquire' not allowed"),
4060                   i.tm.name);
4061           return 0;
4062         }
4063       if (i.mem_operands == 0 || !(i.flags[i.operands - 1] & Operand_Mem))
4064         {
4065           as_bad (_("memory destination needed for instruction `%s'"
4066                     " after `xrelease'"), i.tm.name);
4067           return 0;
4068         }
4069       return 1;
4070     }
4071 }
4072
4073 /* Try the shortest encoding by shortening operand size.  */
4074
4075 static void
4076 optimize_encoding (void)
4077 {
4078   unsigned int j;
4079
4080   if (optimize_for_space
4081       && !is_any_vex_encoding (&i.tm)
4082       && i.reg_operands == 1
4083       && i.imm_operands == 1
4084       && !i.types[1].bitfield.byte
4085       && i.op[0].imms->X_op == O_constant
4086       && fits_in_imm7 (i.op[0].imms->X_add_number)
4087       && (i.tm.base_opcode == 0xa8
4088           || (i.tm.base_opcode == 0xf6
4089               && i.tm.extension_opcode == 0x0)))
4090     {
4091       /* Optimize: -Os:
4092            test $imm7, %r64/%r32/%r16  -> test $imm7, %r8
4093        */
4094       unsigned int base_regnum = i.op[1].regs->reg_num;
4095       if (flag_code == CODE_64BIT || base_regnum < 4)
4096         {
4097           i.types[1].bitfield.byte = 1;
4098           /* Ignore the suffix.  */
4099           i.suffix = 0;
4100           /* Convert to byte registers.  */
4101           if (i.types[1].bitfield.word)
4102             j = 16;
4103           else if (i.types[1].bitfield.dword)
4104             j = 32;
4105           else
4106             j = 48;
4107           if (!(i.op[1].regs->reg_flags & RegRex) && base_regnum < 4)
4108             j += 8;
4109           i.op[1].regs -= j;
4110         }
4111     }
4112   else if (flag_code == CODE_64BIT
4113            && !is_any_vex_encoding (&i.tm)
4114            && ((i.types[1].bitfield.qword
4115                 && i.reg_operands == 1
4116                 && i.imm_operands == 1
4117                 && i.op[0].imms->X_op == O_constant
4118                 && ((i.tm.base_opcode == 0xb8
4119                      && i.tm.extension_opcode == None
4120                      && fits_in_unsigned_long (i.op[0].imms->X_add_number))
4121                     || (fits_in_imm31 (i.op[0].imms->X_add_number)
4122                         && ((i.tm.base_opcode == 0x24
4123                              || i.tm.base_opcode == 0xa8)
4124                             || (i.tm.base_opcode == 0x80
4125                                 && i.tm.extension_opcode == 0x4)
4126                             || ((i.tm.base_opcode == 0xf6
4127                                  || (i.tm.base_opcode | 1) == 0xc7)
4128                                 && i.tm.extension_opcode == 0x0)))
4129                     || (fits_in_imm7 (i.op[0].imms->X_add_number)
4130                         && i.tm.base_opcode == 0x83
4131                         && i.tm.extension_opcode == 0x4)))
4132                || (i.types[0].bitfield.qword
4133                    && ((i.reg_operands == 2
4134                         && i.op[0].regs == i.op[1].regs
4135                         && (i.tm.base_opcode == 0x30
4136                             || i.tm.base_opcode == 0x28))
4137                        || (i.reg_operands == 1
4138                            && i.operands == 1
4139                            && i.tm.base_opcode == 0x30)))))
4140     {
4141       /* Optimize: -O:
4142            andq $imm31, %r64   -> andl $imm31, %r32
4143            andq $imm7, %r64    -> andl $imm7, %r32
4144            testq $imm31, %r64  -> testl $imm31, %r32
4145            xorq %r64, %r64     -> xorl %r32, %r32
4146            subq %r64, %r64     -> subl %r32, %r32
4147            movq $imm31, %r64   -> movl $imm31, %r32
4148            movq $imm32, %r64   -> movl $imm32, %r32
4149         */
4150       i.tm.opcode_modifier.norex64 = 1;
4151       if (i.tm.base_opcode == 0xb8 || (i.tm.base_opcode | 1) == 0xc7)
4152         {
4153           /* Handle
4154                movq $imm31, %r64   -> movl $imm31, %r32
4155                movq $imm32, %r64   -> movl $imm32, %r32
4156            */
4157           i.tm.operand_types[0].bitfield.imm32 = 1;
4158           i.tm.operand_types[0].bitfield.imm32s = 0;
4159           i.tm.operand_types[0].bitfield.imm64 = 0;
4160           i.types[0].bitfield.imm32 = 1;
4161           i.types[0].bitfield.imm32s = 0;
4162           i.types[0].bitfield.imm64 = 0;
4163           i.types[1].bitfield.dword = 1;
4164           i.types[1].bitfield.qword = 0;
4165           if ((i.tm.base_opcode | 1) == 0xc7)
4166             {
4167               /* Handle
4168                    movq $imm31, %r64   -> movl $imm31, %r32
4169                */
4170               i.tm.base_opcode = 0xb8;
4171               i.tm.extension_opcode = None;
4172               i.tm.opcode_modifier.w = 0;
4173               i.tm.opcode_modifier.modrm = 0;
4174             }
4175         }
4176     }
4177   else if (optimize > 1
4178            && !optimize_for_space
4179            && !is_any_vex_encoding (&i.tm)
4180            && i.reg_operands == 2
4181            && i.op[0].regs == i.op[1].regs
4182            && ((i.tm.base_opcode & ~(Opcode_D | 1)) == 0x8
4183                || (i.tm.base_opcode & ~(Opcode_D | 1)) == 0x20)
4184            && (flag_code != CODE_64BIT || !i.types[0].bitfield.dword))
4185     {
4186       /* Optimize: -O2:
4187            andb %rN, %rN  -> testb %rN, %rN
4188            andw %rN, %rN  -> testw %rN, %rN
4189            andq %rN, %rN  -> testq %rN, %rN
4190            orb %rN, %rN   -> testb %rN, %rN
4191            orw %rN, %rN   -> testw %rN, %rN
4192            orq %rN, %rN   -> testq %rN, %rN
4193
4194            and outside of 64-bit mode
4195
4196            andl %rN, %rN  -> testl %rN, %rN
4197            orl %rN, %rN   -> testl %rN, %rN
4198        */
4199       i.tm.base_opcode = 0x84 | (i.tm.base_opcode & 1);
4200     }
4201   else if (i.reg_operands == 3
4202            && i.op[0].regs == i.op[1].regs
4203            && !i.types[2].bitfield.xmmword
4204            && (i.tm.opcode_modifier.vex
4205                || ((!i.mask || i.mask->zeroing)
4206                    && !i.rounding
4207                    && is_evex_encoding (&i.tm)
4208                    && (i.vec_encoding != vex_encoding_evex
4209                        || cpu_arch_isa_flags.bitfield.cpuavx512vl
4210                        || i.tm.cpu_flags.bitfield.cpuavx512vl
4211                        || (i.tm.operand_types[2].bitfield.zmmword
4212                            && i.types[2].bitfield.ymmword))))
4213            && ((i.tm.base_opcode == 0x55
4214                 || i.tm.base_opcode == 0x6655
4215                 || i.tm.base_opcode == 0x66df
4216                 || i.tm.base_opcode == 0x57
4217                 || i.tm.base_opcode == 0x6657
4218                 || i.tm.base_opcode == 0x66ef
4219                 || i.tm.base_opcode == 0x66f8
4220                 || i.tm.base_opcode == 0x66f9
4221                 || i.tm.base_opcode == 0x66fa
4222                 || i.tm.base_opcode == 0x66fb
4223                 || i.tm.base_opcode == 0x42
4224                 || i.tm.base_opcode == 0x6642
4225                 || i.tm.base_opcode == 0x47
4226                 || i.tm.base_opcode == 0x6647)
4227                && i.tm.extension_opcode == None))
4228     {
4229       /* Optimize: -O1:
4230            VOP, one of vandnps, vandnpd, vxorps, vxorpd, vpsubb, vpsubd,
4231            vpsubq and vpsubw:
4232              EVEX VOP %zmmM, %zmmM, %zmmN
4233                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4234                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4235              EVEX VOP %ymmM, %ymmM, %ymmN
4236                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4237                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4238              VEX VOP %ymmM, %ymmM, %ymmN
4239                -> VEX VOP %xmmM, %xmmM, %xmmN
4240            VOP, one of vpandn and vpxor:
4241              VEX VOP %ymmM, %ymmM, %ymmN
4242                -> VEX VOP %xmmM, %xmmM, %xmmN
4243            VOP, one of vpandnd and vpandnq:
4244              EVEX VOP %zmmM, %zmmM, %zmmN
4245                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4246                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4247              EVEX VOP %ymmM, %ymmM, %ymmN
4248                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4249                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4250            VOP, one of vpxord and vpxorq:
4251              EVEX VOP %zmmM, %zmmM, %zmmN
4252                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4253                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4254              EVEX VOP %ymmM, %ymmM, %ymmN
4255                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4256                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4257            VOP, one of kxord and kxorq:
4258              VEX VOP %kM, %kM, %kN
4259                -> VEX kxorw %kM, %kM, %kN
4260            VOP, one of kandnd and kandnq:
4261              VEX VOP %kM, %kM, %kN
4262                -> VEX kandnw %kM, %kM, %kN
4263        */
4264       if (is_evex_encoding (&i.tm))
4265         {
4266           if (i.vec_encoding != vex_encoding_evex)
4267             {
4268               i.tm.opcode_modifier.vex = VEX128;
4269               i.tm.opcode_modifier.vexw = VEXW0;
4270               i.tm.opcode_modifier.evex = 0;
4271             }
4272           else if (optimize > 1)
4273             i.tm.opcode_modifier.evex = EVEX128;
4274           else
4275             return;
4276         }
4277       else if (i.tm.operand_types[0].bitfield.class == RegMask)
4278         {
4279           i.tm.base_opcode &= 0xff;
4280           i.tm.opcode_modifier.vexw = VEXW0;
4281         }
4282       else
4283         i.tm.opcode_modifier.vex = VEX128;
4284
4285       if (i.tm.opcode_modifier.vex)
4286         for (j = 0; j < 3; j++)
4287           {
4288             i.types[j].bitfield.xmmword = 1;
4289             i.types[j].bitfield.ymmword = 0;
4290           }
4291     }
4292   else if (i.vec_encoding != vex_encoding_evex
4293            && !i.types[0].bitfield.zmmword
4294            && !i.types[1].bitfield.zmmword
4295            && !i.mask
4296            && !i.broadcast
4297            && is_evex_encoding (&i.tm)
4298            && ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0x666f
4299                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf36f
4300                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f
4301                || (i.tm.base_opcode & ~4) == 0x66db
4302                || (i.tm.base_opcode & ~4) == 0x66eb)
4303            && i.tm.extension_opcode == None)
4304     {
4305       /* Optimize: -O1:
4306            VOP, one of vmovdqa32, vmovdqa64, vmovdqu8, vmovdqu16,
4307            vmovdqu32 and vmovdqu64:
4308              EVEX VOP %xmmM, %xmmN
4309                -> VEX vmovdqa|vmovdqu %xmmM, %xmmN (M and N < 16)
4310              EVEX VOP %ymmM, %ymmN
4311                -> VEX vmovdqa|vmovdqu %ymmM, %ymmN (M and N < 16)
4312              EVEX VOP %xmmM, mem
4313                -> VEX vmovdqa|vmovdqu %xmmM, mem (M < 16)
4314              EVEX VOP %ymmM, mem
4315                -> VEX vmovdqa|vmovdqu %ymmM, mem (M < 16)
4316              EVEX VOP mem, %xmmN
4317                -> VEX mvmovdqa|vmovdquem, %xmmN (N < 16)
4318              EVEX VOP mem, %ymmN
4319                -> VEX vmovdqa|vmovdqu mem, %ymmN (N < 16)
4320            VOP, one of vpand, vpandn, vpor, vpxor:
4321              EVEX VOP{d,q} %xmmL, %xmmM, %xmmN
4322                -> VEX VOP %xmmL, %xmmM, %xmmN (L, M, and N < 16)
4323              EVEX VOP{d,q} %ymmL, %ymmM, %ymmN
4324                -> VEX VOP %ymmL, %ymmM, %ymmN (L, M, and N < 16)
4325              EVEX VOP{d,q} mem, %xmmM, %xmmN
4326                -> VEX VOP mem, %xmmM, %xmmN (M and N < 16)
4327              EVEX VOP{d,q} mem, %ymmM, %ymmN
4328                -> VEX VOP mem, %ymmM, %ymmN (M and N < 16)
4329        */
4330       for (j = 0; j < i.operands; j++)
4331         if (operand_type_check (i.types[j], disp)
4332             && i.op[j].disps->X_op == O_constant)
4333           {
4334             /* Since the VEX prefix has 2 or 3 bytes, the EVEX prefix
4335                has 4 bytes, EVEX Disp8 has 1 byte and VEX Disp32 has 4
4336                bytes, we choose EVEX Disp8 over VEX Disp32.  */
4337             int evex_disp8, vex_disp8;
4338             unsigned int memshift = i.memshift;
4339             offsetT n = i.op[j].disps->X_add_number;
4340
4341             evex_disp8 = fits_in_disp8 (n);
4342             i.memshift = 0;
4343             vex_disp8 = fits_in_disp8 (n);
4344             if (evex_disp8 != vex_disp8)
4345               {
4346                 i.memshift = memshift;
4347                 return;
4348               }
4349
4350             i.types[j].bitfield.disp8 = vex_disp8;
4351             break;
4352           }
4353       if ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f)
4354         i.tm.base_opcode ^= 0xf36f ^ 0xf26f;
4355       i.tm.opcode_modifier.vex
4356         = i.types[0].bitfield.ymmword ? VEX256 : VEX128;
4357       i.tm.opcode_modifier.vexw = VEXW0;
4358       /* VPAND, VPOR, and VPXOR are commutative.  */
4359       if (i.reg_operands == 3 && i.tm.base_opcode != 0x66df)
4360         i.tm.opcode_modifier.commutative = 1;
4361       i.tm.opcode_modifier.evex = 0;
4362       i.tm.opcode_modifier.masking = 0;
4363       i.tm.opcode_modifier.broadcast = 0;
4364       i.tm.opcode_modifier.disp8memshift = 0;
4365       i.memshift = 0;
4366       if (j < i.operands)
4367         i.types[j].bitfield.disp8
4368           = fits_in_disp8 (i.op[j].disps->X_add_number);
4369     }
4370 }
4371
4372 /* Return non-zero for load instruction.  */
4373
4374 static int
4375 load_insn_p (void)
4376 {
4377   unsigned int dest;
4378   int any_vex_p = is_any_vex_encoding (&i.tm);
4379   unsigned int base_opcode = i.tm.base_opcode | 1;
4380
4381   if (!any_vex_p)
4382     {
4383       /* Anysize insns: lea, invlpg, clflush, prefetchnta, prefetcht0,
4384          prefetcht1, prefetcht2, prefetchtw, bndmk, bndcl, bndcu, bndcn,
4385          bndstx, bndldx, prefetchwt1, clflushopt, clwb, cldemote.  */
4386       if (i.tm.opcode_modifier.anysize)
4387         return 0;
4388
4389       /* pop, popf, popa.   */
4390       if (strcmp (i.tm.name, "pop") == 0
4391           || i.tm.base_opcode == 0x9d
4392           || i.tm.base_opcode == 0x61)
4393         return 1;
4394
4395       /* movs, cmps, lods, scas.  */
4396       if ((i.tm.base_opcode | 0xb) == 0xaf)
4397         return 1;
4398
4399       /* outs, xlatb.  */
4400       if (base_opcode == 0x6f
4401           || i.tm.base_opcode == 0xd7)
4402         return 1;
4403       /* NB: For AMD-specific insns with implicit memory operands,
4404          they're intentionally not covered.  */
4405     }
4406
4407   /* No memory operand.  */
4408   if (!i.mem_operands)
4409     return 0;
4410
4411   if (any_vex_p)
4412     {
4413       /* vldmxcsr.  */
4414       if (i.tm.base_opcode == 0xae
4415           && i.tm.opcode_modifier.vex
4416           && i.tm.opcode_modifier.opcodeprefix == VEX0F
4417           && i.tm.extension_opcode == 2)
4418         return 1;
4419     }
4420   else
4421     {
4422       /* test, not, neg, mul, imul, div, idiv.  */
4423       if ((i.tm.base_opcode == 0xf6 || i.tm.base_opcode == 0xf7)
4424           && i.tm.extension_opcode != 1)
4425         return 1;
4426
4427       /* inc, dec.  */
4428       if (base_opcode == 0xff && i.tm.extension_opcode <= 1)
4429         return 1;
4430
4431       /* add, or, adc, sbb, and, sub, xor, cmp.  */
4432       if (i.tm.base_opcode >= 0x80 && i.tm.base_opcode <= 0x83)
4433         return 1;
4434
4435       /* bt, bts, btr, btc.  */
4436       if (i.tm.base_opcode == 0xfba
4437           && (i.tm.extension_opcode >= 4 && i.tm.extension_opcode <= 7))
4438         return 1;
4439
4440       /* rol, ror, rcl, rcr, shl/sal, shr, sar. */
4441       if ((base_opcode == 0xc1
4442            || (i.tm.base_opcode >= 0xd0 && i.tm.base_opcode <= 0xd3))
4443           && i.tm.extension_opcode != 6)
4444         return 1;
4445
4446       /* cmpxchg8b, cmpxchg16b, xrstors.  */
4447       if (i.tm.base_opcode == 0xfc7
4448           && i.tm.opcode_modifier.opcodeprefix == 0
4449           && (i.tm.extension_opcode == 1 || i.tm.extension_opcode == 3))
4450         return 1;
4451
4452       /* fxrstor, ldmxcsr, xrstor.  */
4453       if (i.tm.base_opcode == 0xfae
4454           && (i.tm.extension_opcode == 1
4455               || i.tm.extension_opcode == 2
4456               || i.tm.extension_opcode == 5))
4457         return 1;
4458
4459       /* lgdt, lidt, lmsw.  */
4460       if (i.tm.base_opcode == 0xf01
4461           && (i.tm.extension_opcode == 2
4462               || i.tm.extension_opcode == 3
4463               || i.tm.extension_opcode == 6))
4464         return 1;
4465
4466       /* vmptrld */
4467       if (i.tm.base_opcode == 0xfc7
4468           && i.tm.opcode_modifier.opcodeprefix == 0
4469           && i.tm.extension_opcode == 6)
4470         return 1;
4471
4472       /* Check for x87 instructions.  */
4473       if (i.tm.base_opcode >= 0xd8 && i.tm.base_opcode <= 0xdf)
4474         {
4475           /* Skip fst, fstp, fstenv, fstcw.  */
4476           if (i.tm.base_opcode == 0xd9
4477               && (i.tm.extension_opcode == 2
4478                   || i.tm.extension_opcode == 3
4479                   || i.tm.extension_opcode == 6
4480                   || i.tm.extension_opcode == 7))
4481             return 0;
4482
4483           /* Skip fisttp, fist, fistp, fstp.  */
4484           if (i.tm.base_opcode == 0xdb
4485               && (i.tm.extension_opcode == 1
4486                   || i.tm.extension_opcode == 2
4487                   || i.tm.extension_opcode == 3
4488                   || i.tm.extension_opcode == 7))
4489             return 0;
4490
4491           /* Skip fisttp, fst, fstp, fsave, fstsw.  */
4492           if (i.tm.base_opcode == 0xdd
4493               && (i.tm.extension_opcode == 1
4494                   || i.tm.extension_opcode == 2
4495                   || i.tm.extension_opcode == 3
4496                   || i.tm.extension_opcode == 6
4497                   || i.tm.extension_opcode == 7))
4498             return 0;
4499
4500           /* Skip fisttp, fist, fistp, fbstp, fistp.  */
4501           if (i.tm.base_opcode == 0xdf
4502               && (i.tm.extension_opcode == 1
4503                   || i.tm.extension_opcode == 2
4504                   || i.tm.extension_opcode == 3
4505                   || i.tm.extension_opcode == 6
4506                   || i.tm.extension_opcode == 7))
4507             return 0;
4508
4509           return 1;
4510         }
4511     }
4512
4513   dest = i.operands - 1;
4514
4515   /* Check fake imm8 operand and 3 source operands.  */
4516   if ((i.tm.opcode_modifier.immext
4517        || i.tm.opcode_modifier.vexsources == VEX3SOURCES)
4518       && i.types[dest].bitfield.imm8)
4519     dest--;
4520
4521   /* add, or, adc, sbb, and, sub, xor, cmp, test, xchg, xadd  */
4522   if (!any_vex_p
4523       && (base_opcode == 0x1
4524           || base_opcode == 0x9
4525           || base_opcode == 0x11
4526           || base_opcode == 0x19
4527           || base_opcode == 0x21
4528           || base_opcode == 0x29
4529           || base_opcode == 0x31
4530           || base_opcode == 0x39
4531           || (i.tm.base_opcode >= 0x84 && i.tm.base_opcode <= 0x87)
4532           || base_opcode == 0xfc1))
4533     return 1;
4534
4535   /* Check for load instruction.  */
4536   return (i.types[dest].bitfield.class != ClassNone
4537           || i.types[dest].bitfield.instance == Accum);
4538 }
4539
4540 /* Output lfence, 0xfaee8, after instruction.  */
4541
4542 static void
4543 insert_lfence_after (void)
4544 {
4545   if (lfence_after_load && load_insn_p ())
4546     {
4547       /* There are also two REP string instructions that require
4548          special treatment. Specifically, the compare string (CMPS)
4549          and scan string (SCAS) instructions set EFLAGS in a manner
4550          that depends on the data being compared/scanned. When used
4551          with a REP prefix, the number of iterations may therefore
4552          vary depending on this data. If the data is a program secret
4553          chosen by the adversary using an LVI method,
4554          then this data-dependent behavior may leak some aspect
4555          of the secret.  */
4556       if (((i.tm.base_opcode | 0x1) == 0xa7
4557            || (i.tm.base_opcode | 0x1) == 0xaf)
4558           && i.prefix[REP_PREFIX])
4559         {
4560             as_warn (_("`%s` changes flags which would affect control flow behavior"),
4561                      i.tm.name);
4562         }
4563       char *p = frag_more (3);
4564       *p++ = 0xf;
4565       *p++ = 0xae;
4566       *p = 0xe8;
4567     }
4568 }
4569
4570 /* Output lfence, 0xfaee8, before instruction.  */
4571
4572 static void
4573 insert_lfence_before (void)
4574 {
4575   char *p;
4576
4577   if (is_any_vex_encoding (&i.tm))
4578     return;
4579
4580   if (i.tm.base_opcode == 0xff
4581       && (i.tm.extension_opcode == 2 || i.tm.extension_opcode == 4))
4582     {
4583       /* Insert lfence before indirect branch if needed.  */
4584
4585       if (lfence_before_indirect_branch == lfence_branch_none)
4586         return;
4587
4588       if (i.operands != 1)
4589         abort ();
4590
4591       if (i.reg_operands == 1)
4592         {
4593           /* Indirect branch via register.  Don't insert lfence with
4594              -mlfence-after-load=yes.  */
4595           if (lfence_after_load
4596               || lfence_before_indirect_branch == lfence_branch_memory)
4597             return;
4598         }
4599       else if (i.mem_operands == 1
4600                && lfence_before_indirect_branch != lfence_branch_register)
4601         {
4602           as_warn (_("indirect `%s` with memory operand should be avoided"),
4603                    i.tm.name);
4604           return;
4605         }
4606       else
4607         return;
4608
4609       if (last_insn.kind != last_insn_other
4610           && last_insn.seg == now_seg)
4611         {
4612           as_warn_where (last_insn.file, last_insn.line,
4613                          _("`%s` skips -mlfence-before-indirect-branch on `%s`"),
4614                          last_insn.name, i.tm.name);
4615           return;
4616         }
4617
4618       p = frag_more (3);
4619       *p++ = 0xf;
4620       *p++ = 0xae;
4621       *p = 0xe8;
4622       return;
4623     }
4624
4625   /* Output or/not/shl and lfence before near ret.  */
4626   if (lfence_before_ret != lfence_before_ret_none
4627       && (i.tm.base_opcode == 0xc2
4628           || i.tm.base_opcode == 0xc3))
4629     {
4630       if (last_insn.kind != last_insn_other
4631           && last_insn.seg == now_seg)
4632         {
4633           as_warn_where (last_insn.file, last_insn.line,
4634                          _("`%s` skips -mlfence-before-ret on `%s`"),
4635                          last_insn.name, i.tm.name);
4636           return;
4637         }
4638
4639       /* Near ret ingore operand size override under CPU64.  */
4640       char prefix = flag_code == CODE_64BIT
4641                     ? 0x48
4642                     : i.prefix[DATA_PREFIX] ? 0x66 : 0x0;
4643
4644       if (lfence_before_ret == lfence_before_ret_not)
4645         {
4646           /* not: 0xf71424, may add prefix
4647              for operand size override or 64-bit code.  */
4648           p = frag_more ((prefix ? 2 : 0) + 6 + 3);
4649           if (prefix)
4650             *p++ = prefix;
4651           *p++ = 0xf7;
4652           *p++ = 0x14;
4653           *p++ = 0x24;
4654           if (prefix)
4655             *p++ = prefix;
4656           *p++ = 0xf7;
4657           *p++ = 0x14;
4658           *p++ = 0x24;
4659         }
4660       else
4661         {
4662           p = frag_more ((prefix ? 1 : 0) + 4 + 3);
4663           if (prefix)
4664             *p++ = prefix;
4665           if (lfence_before_ret == lfence_before_ret_or)
4666             {
4667               /* or: 0x830c2400, may add prefix
4668                  for operand size override or 64-bit code.  */
4669               *p++ = 0x83;
4670               *p++ = 0x0c;
4671             }
4672           else
4673             {
4674               /* shl: 0xc1242400, may add prefix
4675                  for operand size override or 64-bit code.  */
4676               *p++ = 0xc1;
4677               *p++ = 0x24;
4678             }
4679
4680           *p++ = 0x24;
4681           *p++ = 0x0;
4682         }
4683
4684       *p++ = 0xf;
4685       *p++ = 0xae;
4686       *p = 0xe8;
4687     }
4688 }
4689
4690 /* This is the guts of the machine-dependent assembler.  LINE points to a
4691    machine dependent instruction.  This function is supposed to emit
4692    the frags/bytes it assembles to.  */
4693
4694 void
4695 md_assemble (char *line)
4696 {
4697   unsigned int j;
4698   char mnemonic[MAX_MNEM_SIZE], mnem_suffix;
4699   const insn_template *t;
4700
4701   /* Initialize globals.  */
4702   memset (&i, '\0', sizeof (i));
4703   for (j = 0; j < MAX_OPERANDS; j++)
4704     i.reloc[j] = NO_RELOC;
4705   memset (disp_expressions, '\0', sizeof (disp_expressions));
4706   memset (im_expressions, '\0', sizeof (im_expressions));
4707   save_stack_p = save_stack;
4708
4709   /* First parse an instruction mnemonic & call i386_operand for the operands.
4710      We assume that the scrubber has arranged it so that line[0] is the valid
4711      start of a (possibly prefixed) mnemonic.  */
4712
4713   line = parse_insn (line, mnemonic);
4714   if (line == NULL)
4715     return;
4716   mnem_suffix = i.suffix;
4717
4718   line = parse_operands (line, mnemonic);
4719   this_operand = -1;
4720   xfree (i.memop1_string);
4721   i.memop1_string = NULL;
4722   if (line == NULL)
4723     return;
4724
4725   /* Now we've parsed the mnemonic into a set of templates, and have the
4726      operands at hand.  */
4727
4728   /* All Intel opcodes have reversed operands except for "bound", "enter",
4729      "monitor*", "mwait*", "tpause", and "umwait".  We also don't reverse
4730      intersegment "jmp" and "call" instructions with 2 immediate operands so
4731      that the immediate segment precedes the offset, as it does when in AT&T
4732      mode.  */
4733   if (intel_syntax
4734       && i.operands > 1
4735       && (strcmp (mnemonic, "bound") != 0)
4736       && (strcmp (mnemonic, "invlpga") != 0)
4737       && (strncmp (mnemonic, "monitor", 7) != 0)
4738       && (strncmp (mnemonic, "mwait", 5) != 0)
4739       && (strcmp (mnemonic, "tpause") != 0)
4740       && (strcmp (mnemonic, "umwait") != 0)
4741       && !(operand_type_check (i.types[0], imm)
4742            && operand_type_check (i.types[1], imm)))
4743     swap_operands ();
4744
4745   /* The order of the immediates should be reversed
4746      for 2 immediates extrq and insertq instructions */
4747   if (i.imm_operands == 2
4748       && (strcmp (mnemonic, "extrq") == 0
4749           || strcmp (mnemonic, "insertq") == 0))
4750       swap_2_operands (0, 1);
4751
4752   if (i.imm_operands)
4753     optimize_imm ();
4754
4755   /* Don't optimize displacement for movabs since it only takes 64bit
4756      displacement.  */
4757   if (i.disp_operands
4758       && i.disp_encoding != disp_encoding_32bit
4759       && (flag_code != CODE_64BIT
4760           || strcmp (mnemonic, "movabs") != 0))
4761     optimize_disp ();
4762
4763   /* Next, we find a template that matches the given insn,
4764      making sure the overlap of the given operands types is consistent
4765      with the template operand types.  */
4766
4767   if (!(t = match_template (mnem_suffix)))
4768     return;
4769
4770   if (sse_check != check_none
4771       && !i.tm.opcode_modifier.noavx
4772       && !i.tm.cpu_flags.bitfield.cpuavx
4773       && !i.tm.cpu_flags.bitfield.cpuavx512f
4774       && (i.tm.cpu_flags.bitfield.cpusse
4775           || i.tm.cpu_flags.bitfield.cpusse2
4776           || i.tm.cpu_flags.bitfield.cpusse3
4777           || i.tm.cpu_flags.bitfield.cpussse3
4778           || i.tm.cpu_flags.bitfield.cpusse4_1
4779           || i.tm.cpu_flags.bitfield.cpusse4_2
4780           || i.tm.cpu_flags.bitfield.cpupclmul
4781           || i.tm.cpu_flags.bitfield.cpuaes
4782           || i.tm.cpu_flags.bitfield.cpusha
4783           || i.tm.cpu_flags.bitfield.cpugfni))
4784     {
4785       (sse_check == check_warning
4786        ? as_warn
4787        : as_bad) (_("SSE instruction `%s' is used"), i.tm.name);
4788     }
4789
4790   if (i.tm.opcode_modifier.fwait)
4791     if (!add_prefix (FWAIT_OPCODE))
4792       return;
4793
4794   /* Check if REP prefix is OK.  */
4795   if (i.rep_prefix && !i.tm.opcode_modifier.repprefixok)
4796     {
4797       as_bad (_("invalid instruction `%s' after `%s'"),
4798                 i.tm.name, i.rep_prefix);
4799       return;
4800     }
4801
4802   /* Check for lock without a lockable instruction.  Destination operand
4803      must be memory unless it is xchg (0x86).  */
4804   if (i.prefix[LOCK_PREFIX]
4805       && (!i.tm.opcode_modifier.islockable
4806           || i.mem_operands == 0
4807           || (i.tm.base_opcode != 0x86
4808               && !(i.flags[i.operands - 1] & Operand_Mem))))
4809     {
4810       as_bad (_("expecting lockable instruction after `lock'"));
4811       return;
4812     }
4813
4814   /* Check for data size prefix on VEX/XOP/EVEX encoded and SIMD insns.  */
4815   if (i.prefix[DATA_PREFIX]
4816       && (is_any_vex_encoding (&i.tm)
4817           || i.tm.operand_types[i.imm_operands].bitfield.class >= RegMMX
4818           || i.tm.operand_types[i.imm_operands + 1].bitfield.class >= RegMMX))
4819     {
4820       as_bad (_("data size prefix invalid with `%s'"), i.tm.name);
4821       return;
4822     }
4823
4824   /* Check if HLE prefix is OK.  */
4825   if (i.hle_prefix && !check_hle ())
4826     return;
4827
4828   /* Check BND prefix.  */
4829   if (i.bnd_prefix && !i.tm.opcode_modifier.bndprefixok)
4830     as_bad (_("expecting valid branch instruction after `bnd'"));
4831
4832   /* Check NOTRACK prefix.  */
4833   if (i.notrack_prefix && !i.tm.opcode_modifier.notrackprefixok)
4834     as_bad (_("expecting indirect branch instruction after `notrack'"));
4835
4836   if (i.tm.cpu_flags.bitfield.cpumpx)
4837     {
4838       if (flag_code == CODE_64BIT && i.prefix[ADDR_PREFIX])
4839         as_bad (_("32-bit address isn't allowed in 64-bit MPX instructions."));
4840       else if (flag_code != CODE_16BIT
4841                ? i.prefix[ADDR_PREFIX]
4842                : i.mem_operands && !i.prefix[ADDR_PREFIX])
4843         as_bad (_("16-bit address isn't allowed in MPX instructions"));
4844     }
4845
4846   /* Insert BND prefix.  */
4847   if (add_bnd_prefix && i.tm.opcode_modifier.bndprefixok)
4848     {
4849       if (!i.prefix[BND_PREFIX])
4850         add_prefix (BND_PREFIX_OPCODE);
4851       else if (i.prefix[BND_PREFIX] != BND_PREFIX_OPCODE)
4852         {
4853           as_warn (_("replacing `rep'/`repe' prefix by `bnd'"));
4854           i.prefix[BND_PREFIX] = BND_PREFIX_OPCODE;
4855         }
4856     }
4857
4858   /* Check string instruction segment overrides.  */
4859   if (i.tm.opcode_modifier.isstring >= IS_STRING_ES_OP0)
4860     {
4861       gas_assert (i.mem_operands);
4862       if (!check_string ())
4863         return;
4864       i.disp_operands = 0;
4865     }
4866
4867   if (optimize && !i.no_optimize && i.tm.opcode_modifier.optimize)
4868     optimize_encoding ();
4869
4870   if (!process_suffix ())
4871     return;
4872
4873   /* Update operand types and check extended states.  */
4874   for (j = 0; j < i.operands; j++)
4875     {
4876       i.types[j] = operand_type_and (i.types[j], i.tm.operand_types[j]);
4877       switch (i.types[j].bitfield.class)
4878         {
4879         default:
4880           break;
4881         case RegMMX:
4882           i.xstate |= xstate_mmx;
4883           break;
4884         case RegMask:
4885           i.xstate |= xstate_mask;
4886           break;
4887         case RegSIMD:
4888           if (i.types[j].bitfield.tmmword)
4889             i.xstate |= xstate_tmm;
4890           else if (i.types[j].bitfield.zmmword)
4891             i.xstate |= xstate_zmm;
4892           else if (i.types[j].bitfield.ymmword)
4893             i.xstate |= xstate_ymm;
4894           else if (i.types[j].bitfield.xmmword)
4895             i.xstate |= xstate_xmm;
4896           break;
4897         }
4898     }
4899
4900   /* Make still unresolved immediate matches conform to size of immediate
4901      given in i.suffix.  */
4902   if (!finalize_imm ())
4903     return;
4904
4905   if (i.types[0].bitfield.imm1)
4906     i.imm_operands = 0; /* kludge for shift insns.  */
4907
4908   /* We only need to check those implicit registers for instructions
4909      with 3 operands or less.  */
4910   if (i.operands <= 3)
4911     for (j = 0; j < i.operands; j++)
4912       if (i.types[j].bitfield.instance != InstanceNone
4913           && !i.types[j].bitfield.xmmword)
4914         i.reg_operands--;
4915
4916   /* For insns with operands there are more diddles to do to the opcode.  */
4917   if (i.operands)
4918     {
4919       if (!process_operands ())
4920         return;
4921     }
4922   else if (!quiet_warnings && i.tm.opcode_modifier.ugh)
4923     {
4924       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
4925       as_warn (_("translating to `%sp'"), i.tm.name);
4926     }
4927
4928   if (is_any_vex_encoding (&i.tm))
4929     {
4930       if (!cpu_arch_flags.bitfield.cpui286)
4931         {
4932           as_bad (_("instruction `%s' isn't supported outside of protected mode."),
4933                   i.tm.name);
4934           return;
4935         }
4936
4937       /* Check for explicit REX prefix.  */
4938       if (i.prefix[REX_PREFIX] || i.rex_encoding)
4939         {
4940           as_bad (_("REX prefix invalid with `%s'"), i.tm.name);
4941           return;
4942         }
4943
4944       if (i.tm.opcode_modifier.vex)
4945         build_vex_prefix (t);
4946       else
4947         build_evex_prefix ();
4948
4949       /* The individual REX.RXBW bits got consumed.  */
4950       i.rex &= REX_OPCODE;
4951     }
4952
4953   /* Handle conversion of 'int $3' --> special int3 insn.  XOP or FMA4
4954      instructions may define INT_OPCODE as well, so avoid this corner
4955      case for those instructions that use MODRM.  */
4956   if (i.tm.base_opcode == INT_OPCODE
4957       && !i.tm.opcode_modifier.modrm
4958       && i.op[0].imms->X_add_number == 3)
4959     {
4960       i.tm.base_opcode = INT3_OPCODE;
4961       i.imm_operands = 0;
4962     }
4963
4964   if ((i.tm.opcode_modifier.jump == JUMP
4965        || i.tm.opcode_modifier.jump == JUMP_BYTE
4966        || i.tm.opcode_modifier.jump == JUMP_DWORD)
4967       && i.op[0].disps->X_op == O_constant)
4968     {
4969       /* Convert "jmp constant" (and "call constant") to a jump (call) to
4970          the absolute address given by the constant.  Since ix86 jumps and
4971          calls are pc relative, we need to generate a reloc.  */
4972       i.op[0].disps->X_add_symbol = &abs_symbol;
4973       i.op[0].disps->X_op = O_symbol;
4974     }
4975
4976   /* For 8 bit registers we need an empty rex prefix.  Also if the
4977      instruction already has a prefix, we need to convert old
4978      registers to new ones.  */
4979
4980   if ((i.types[0].bitfield.class == Reg && i.types[0].bitfield.byte
4981        && (i.op[0].regs->reg_flags & RegRex64) != 0)
4982       || (i.types[1].bitfield.class == Reg && i.types[1].bitfield.byte
4983           && (i.op[1].regs->reg_flags & RegRex64) != 0)
4984       || (((i.types[0].bitfield.class == Reg && i.types[0].bitfield.byte)
4985            || (i.types[1].bitfield.class == Reg && i.types[1].bitfield.byte))
4986           && i.rex != 0))
4987     {
4988       int x;
4989
4990       i.rex |= REX_OPCODE;
4991       for (x = 0; x < 2; x++)
4992         {
4993           /* Look for 8 bit operand that uses old registers.  */
4994           if (i.types[x].bitfield.class == Reg && i.types[x].bitfield.byte
4995               && (i.op[x].regs->reg_flags & RegRex64) == 0)
4996             {
4997               gas_assert (!(i.op[x].regs->reg_flags & RegRex));
4998               /* In case it is "hi" register, give up.  */
4999               if (i.op[x].regs->reg_num > 3)
5000                 as_bad (_("can't encode register '%s%s' in an "
5001                           "instruction requiring REX prefix."),
5002                         register_prefix, i.op[x].regs->reg_name);
5003
5004               /* Otherwise it is equivalent to the extended register.
5005                  Since the encoding doesn't change this is merely
5006                  cosmetic cleanup for debug output.  */
5007
5008               i.op[x].regs = i.op[x].regs + 8;
5009             }
5010         }
5011     }
5012
5013   if (i.rex == 0 && i.rex_encoding)
5014     {
5015       /* Check if we can add a REX_OPCODE byte.  Look for 8 bit operand
5016          that uses legacy register.  If it is "hi" register, don't add
5017          the REX_OPCODE byte.  */
5018       int x;
5019       for (x = 0; x < 2; x++)
5020         if (i.types[x].bitfield.class == Reg
5021             && i.types[x].bitfield.byte
5022             && (i.op[x].regs->reg_flags & RegRex64) == 0
5023             && i.op[x].regs->reg_num > 3)
5024           {
5025             gas_assert (!(i.op[x].regs->reg_flags & RegRex));
5026             i.rex_encoding = FALSE;
5027             break;
5028           }
5029
5030       if (i.rex_encoding)
5031         i.rex = REX_OPCODE;
5032     }
5033
5034   if (i.rex != 0)
5035     add_prefix (REX_OPCODE | i.rex);
5036
5037   insert_lfence_before ();
5038
5039   /* We are ready to output the insn.  */
5040   output_insn ();
5041
5042   insert_lfence_after ();
5043
5044   last_insn.seg = now_seg;
5045
5046   if (i.tm.opcode_modifier.isprefix)
5047     {
5048       last_insn.kind = last_insn_prefix;
5049       last_insn.name = i.tm.name;
5050       last_insn.file = as_where (&last_insn.line);
5051     }
5052   else
5053     last_insn.kind = last_insn_other;
5054 }
5055
5056 static char *
5057 parse_insn (char *line, char *mnemonic)
5058 {
5059   char *l = line;
5060   char *token_start = l;
5061   char *mnem_p;
5062   int supported;
5063   const insn_template *t;
5064   char *dot_p = NULL;
5065
5066   while (1)
5067     {
5068       mnem_p = mnemonic;
5069       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
5070         {
5071           if (*mnem_p == '.')
5072             dot_p = mnem_p;
5073           mnem_p++;
5074           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
5075             {
5076               as_bad (_("no such instruction: `%s'"), token_start);
5077               return NULL;
5078             }
5079           l++;
5080         }
5081       if (!is_space_char (*l)
5082           && *l != END_OF_INSN
5083           && (intel_syntax
5084               || (*l != PREFIX_SEPARATOR
5085                   && *l != ',')))
5086         {
5087           as_bad (_("invalid character %s in mnemonic"),
5088                   output_invalid (*l));
5089           return NULL;
5090         }
5091       if (token_start == l)
5092         {
5093           if (!intel_syntax && *l == PREFIX_SEPARATOR)
5094             as_bad (_("expecting prefix; got nothing"));
5095           else
5096             as_bad (_("expecting mnemonic; got nothing"));
5097           return NULL;
5098         }
5099
5100       /* Look up instruction (or prefix) via hash table.  */
5101       current_templates = (const templates *) str_hash_find (op_hash, mnemonic);
5102
5103       if (*l != END_OF_INSN
5104           && (!is_space_char (*l) || l[1] != END_OF_INSN)
5105           && current_templates
5106           && current_templates->start->opcode_modifier.isprefix)
5107         {
5108           if (!cpu_flags_check_cpu64 (current_templates->start->cpu_flags))
5109             {
5110               as_bad ((flag_code != CODE_64BIT
5111                        ? _("`%s' is only supported in 64-bit mode")
5112                        : _("`%s' is not supported in 64-bit mode")),
5113                       current_templates->start->name);
5114               return NULL;
5115             }
5116           /* If we are in 16-bit mode, do not allow addr16 or data16.
5117              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
5118           if ((current_templates->start->opcode_modifier.size == SIZE16
5119                || current_templates->start->opcode_modifier.size == SIZE32)
5120               && flag_code != CODE_64BIT
5121               && ((current_templates->start->opcode_modifier.size == SIZE32)
5122                   ^ (flag_code == CODE_16BIT)))
5123             {
5124               as_bad (_("redundant %s prefix"),
5125                       current_templates->start->name);
5126               return NULL;
5127             }
5128           if (current_templates->start->opcode_length == 0)
5129             {
5130               /* Handle pseudo prefixes.  */
5131               switch (current_templates->start->base_opcode)
5132                 {
5133                 case Prefix_Disp8:
5134                   /* {disp8} */
5135                   i.disp_encoding = disp_encoding_8bit;
5136                   break;
5137                 case Prefix_Disp16:
5138                   /* {disp16} */
5139                   i.disp_encoding = disp_encoding_16bit;
5140                   break;
5141                 case Prefix_Disp32:
5142                   /* {disp32} */
5143                   i.disp_encoding = disp_encoding_32bit;
5144                   break;
5145                 case Prefix_Load:
5146                   /* {load} */
5147                   i.dir_encoding = dir_encoding_load;
5148                   break;
5149                 case Prefix_Store:
5150                   /* {store} */
5151                   i.dir_encoding = dir_encoding_store;
5152                   break;
5153                 case Prefix_VEX:
5154                   /* {vex} */
5155                   i.vec_encoding = vex_encoding_vex;
5156                   break;
5157                 case Prefix_VEX3:
5158                   /* {vex3} */
5159                   i.vec_encoding = vex_encoding_vex3;
5160                   break;
5161                 case Prefix_EVEX:
5162                   /* {evex} */
5163                   i.vec_encoding = vex_encoding_evex;
5164                   break;
5165                 case Prefix_REX:
5166                   /* {rex} */
5167                   i.rex_encoding = TRUE;
5168                   break;
5169                 case Prefix_NoOptimize:
5170                   /* {nooptimize} */
5171                   i.no_optimize = TRUE;
5172                   break;
5173                 default:
5174                   abort ();
5175                 }
5176             }
5177           else
5178             {
5179               /* Add prefix, checking for repeated prefixes.  */
5180               switch (add_prefix (current_templates->start->base_opcode))
5181                 {
5182                 case PREFIX_EXIST:
5183                   return NULL;
5184                 case PREFIX_DS:
5185                   if (current_templates->start->cpu_flags.bitfield.cpuibt)
5186                     i.notrack_prefix = current_templates->start->name;
5187                   break;
5188                 case PREFIX_REP:
5189                   if (current_templates->start->cpu_flags.bitfield.cpuhle)
5190                     i.hle_prefix = current_templates->start->name;
5191                   else if (current_templates->start->cpu_flags.bitfield.cpumpx)
5192                     i.bnd_prefix = current_templates->start->name;
5193                   else
5194                     i.rep_prefix = current_templates->start->name;
5195                   break;
5196                 default:
5197                   break;
5198                 }
5199             }
5200           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
5201           token_start = ++l;
5202         }
5203       else
5204         break;
5205     }
5206
5207   if (!current_templates)
5208     {
5209       /* Deprecated functionality (new code should use pseudo-prefixes instead):
5210          Check if we should swap operand or force 32bit displacement in
5211          encoding.  */
5212       if (mnem_p - 2 == dot_p && dot_p[1] == 's')
5213         i.dir_encoding = dir_encoding_swap;
5214       else if (mnem_p - 3 == dot_p
5215                && dot_p[1] == 'd'
5216                && dot_p[2] == '8')
5217         i.disp_encoding = disp_encoding_8bit;
5218       else if (mnem_p - 4 == dot_p
5219                && dot_p[1] == 'd'
5220                && dot_p[2] == '3'
5221                && dot_p[3] == '2')
5222         i.disp_encoding = disp_encoding_32bit;
5223       else
5224         goto check_suffix;
5225       mnem_p = dot_p;
5226       *dot_p = '\0';
5227       current_templates = (const templates *) str_hash_find (op_hash, mnemonic);
5228     }
5229
5230   if (!current_templates)
5231     {
5232     check_suffix:
5233       if (mnem_p > mnemonic)
5234         {
5235           /* See if we can get a match by trimming off a suffix.  */
5236           switch (mnem_p[-1])
5237             {
5238             case WORD_MNEM_SUFFIX:
5239               if (intel_syntax && (intel_float_operand (mnemonic) & 2))
5240                 i.suffix = SHORT_MNEM_SUFFIX;
5241               else
5242                 /* Fall through.  */
5243               case BYTE_MNEM_SUFFIX:
5244               case QWORD_MNEM_SUFFIX:
5245                 i.suffix = mnem_p[-1];
5246               mnem_p[-1] = '\0';
5247               current_templates
5248                 = (const templates *) str_hash_find (op_hash, mnemonic);
5249               break;
5250             case SHORT_MNEM_SUFFIX:
5251             case LONG_MNEM_SUFFIX:
5252               if (!intel_syntax)
5253                 {
5254                   i.suffix = mnem_p[-1];
5255                   mnem_p[-1] = '\0';
5256                   current_templates
5257                     = (const templates *) str_hash_find (op_hash, mnemonic);
5258                 }
5259               break;
5260
5261               /* Intel Syntax.  */
5262             case 'd':
5263               if (intel_syntax)
5264                 {
5265                   if (intel_float_operand (mnemonic) == 1)
5266                     i.suffix = SHORT_MNEM_SUFFIX;
5267                   else
5268                     i.suffix = LONG_MNEM_SUFFIX;
5269                   mnem_p[-1] = '\0';
5270                   current_templates
5271                     = (const templates *) str_hash_find (op_hash, mnemonic);
5272                 }
5273               break;
5274             }
5275         }
5276
5277       if (!current_templates)
5278         {
5279           as_bad (_("no such instruction: `%s'"), token_start);
5280           return NULL;
5281         }
5282     }
5283
5284   if (current_templates->start->opcode_modifier.jump == JUMP
5285       || current_templates->start->opcode_modifier.jump == JUMP_BYTE)
5286     {
5287       /* Check for a branch hint.  We allow ",pt" and ",pn" for
5288          predict taken and predict not taken respectively.
5289          I'm not sure that branch hints actually do anything on loop
5290          and jcxz insns (JumpByte) for current Pentium4 chips.  They
5291          may work in the future and it doesn't hurt to accept them
5292          now.  */
5293       if (l[0] == ',' && l[1] == 'p')
5294         {
5295           if (l[2] == 't')
5296             {
5297               if (!add_prefix (DS_PREFIX_OPCODE))
5298                 return NULL;
5299               l += 3;
5300             }
5301           else if (l[2] == 'n')
5302             {
5303               if (!add_prefix (CS_PREFIX_OPCODE))
5304                 return NULL;
5305               l += 3;
5306             }
5307         }
5308     }
5309   /* Any other comma loses.  */
5310   if (*l == ',')
5311     {
5312       as_bad (_("invalid character %s in mnemonic"),
5313               output_invalid (*l));
5314       return NULL;
5315     }
5316
5317   /* Check if instruction is supported on specified architecture.  */
5318   supported = 0;
5319   for (t = current_templates->start; t < current_templates->end; ++t)
5320     {
5321       supported |= cpu_flags_match (t);
5322       if (supported == CPU_FLAGS_PERFECT_MATCH)
5323         {
5324           if (!cpu_arch_flags.bitfield.cpui386 && (flag_code != CODE_16BIT))
5325             as_warn (_("use .code16 to ensure correct addressing mode"));
5326
5327           return l;
5328         }
5329     }
5330
5331   if (!(supported & CPU_FLAGS_64BIT_MATCH))
5332     as_bad (flag_code == CODE_64BIT
5333             ? _("`%s' is not supported in 64-bit mode")
5334             : _("`%s' is only supported in 64-bit mode"),
5335             current_templates->start->name);
5336   else
5337     as_bad (_("`%s' is not supported on `%s%s'"),
5338             current_templates->start->name,
5339             cpu_arch_name ? cpu_arch_name : default_arch,
5340             cpu_sub_arch_name ? cpu_sub_arch_name : "");
5341
5342   return NULL;
5343 }
5344
5345 static char *
5346 parse_operands (char *l, const char *mnemonic)
5347 {
5348   char *token_start;
5349
5350   /* 1 if operand is pending after ','.  */
5351   unsigned int expecting_operand = 0;
5352
5353   /* Non-zero if operand parens not balanced.  */
5354   unsigned int paren_not_balanced;
5355
5356   while (*l != END_OF_INSN)
5357     {
5358       /* Skip optional white space before operand.  */
5359       if (is_space_char (*l))
5360         ++l;
5361       if (!is_operand_char (*l) && *l != END_OF_INSN && *l != '"')
5362         {
5363           as_bad (_("invalid character %s before operand %d"),
5364                   output_invalid (*l),
5365                   i.operands + 1);
5366           return NULL;
5367         }
5368       token_start = l;  /* After white space.  */
5369       paren_not_balanced = 0;
5370       while (paren_not_balanced || *l != ',')
5371         {
5372           if (*l == END_OF_INSN)
5373             {
5374               if (paren_not_balanced)
5375                 {
5376                   if (!intel_syntax)
5377                     as_bad (_("unbalanced parenthesis in operand %d."),
5378                             i.operands + 1);
5379                   else
5380                     as_bad (_("unbalanced brackets in operand %d."),
5381                             i.operands + 1);
5382                   return NULL;
5383                 }
5384               else
5385                 break;  /* we are done */
5386             }
5387           else if (!is_operand_char (*l) && !is_space_char (*l) && *l != '"')
5388             {
5389               as_bad (_("invalid character %s in operand %d"),
5390                       output_invalid (*l),
5391                       i.operands + 1);
5392               return NULL;
5393             }
5394           if (!intel_syntax)
5395             {
5396               if (*l == '(')
5397                 ++paren_not_balanced;
5398               if (*l == ')')
5399                 --paren_not_balanced;
5400             }
5401           else
5402             {
5403               if (*l == '[')
5404                 ++paren_not_balanced;
5405               if (*l == ']')
5406                 --paren_not_balanced;
5407             }
5408           l++;
5409         }
5410       if (l != token_start)
5411         {                       /* Yes, we've read in another operand.  */
5412           unsigned int operand_ok;
5413           this_operand = i.operands++;
5414           if (i.operands > MAX_OPERANDS)
5415             {
5416               as_bad (_("spurious operands; (%d operands/instruction max)"),
5417                       MAX_OPERANDS);
5418               return NULL;
5419             }
5420           i.types[this_operand].bitfield.unspecified = 1;
5421           /* Now parse operand adding info to 'i' as we go along.  */
5422           END_STRING_AND_SAVE (l);
5423
5424           if (i.mem_operands > 1)
5425             {
5426               as_bad (_("too many memory references for `%s'"),
5427                       mnemonic);
5428               return 0;
5429             }
5430
5431           if (intel_syntax)
5432             operand_ok =
5433               i386_intel_operand (token_start,
5434                                   intel_float_operand (mnemonic));
5435           else
5436             operand_ok = i386_att_operand (token_start);
5437
5438           RESTORE_END_STRING (l);
5439           if (!operand_ok)
5440             return NULL;
5441         }
5442       else
5443         {
5444           if (expecting_operand)
5445             {
5446             expecting_operand_after_comma:
5447               as_bad (_("expecting operand after ','; got nothing"));
5448               return NULL;
5449             }
5450           if (*l == ',')
5451             {
5452               as_bad (_("expecting operand before ','; got nothing"));
5453               return NULL;
5454             }
5455         }
5456
5457       /* Now *l must be either ',' or END_OF_INSN.  */
5458       if (*l == ',')
5459         {
5460           if (*++l == END_OF_INSN)
5461             {
5462               /* Just skip it, if it's \n complain.  */
5463               goto expecting_operand_after_comma;
5464             }
5465           expecting_operand = 1;
5466         }
5467     }
5468   return l;
5469 }
5470
5471 static void
5472 swap_2_operands (int xchg1, int xchg2)
5473 {
5474   union i386_op temp_op;
5475   i386_operand_type temp_type;
5476   unsigned int temp_flags;
5477   enum bfd_reloc_code_real temp_reloc;
5478
5479   temp_type = i.types[xchg2];
5480   i.types[xchg2] = i.types[xchg1];
5481   i.types[xchg1] = temp_type;
5482
5483   temp_flags = i.flags[xchg2];
5484   i.flags[xchg2] = i.flags[xchg1];
5485   i.flags[xchg1] = temp_flags;
5486
5487   temp_op = i.op[xchg2];
5488   i.op[xchg2] = i.op[xchg1];
5489   i.op[xchg1] = temp_op;
5490
5491   temp_reloc = i.reloc[xchg2];
5492   i.reloc[xchg2] = i.reloc[xchg1];
5493   i.reloc[xchg1] = temp_reloc;
5494
5495   if (i.mask)
5496     {
5497       if (i.mask->operand == xchg1)
5498         i.mask->operand = xchg2;
5499       else if (i.mask->operand == xchg2)
5500         i.mask->operand = xchg1;
5501     }
5502   if (i.broadcast)
5503     {
5504       if (i.broadcast->operand == xchg1)
5505         i.broadcast->operand = xchg2;
5506       else if (i.broadcast->operand == xchg2)
5507         i.broadcast->operand = xchg1;
5508     }
5509   if (i.rounding)
5510     {
5511       if (i.rounding->operand == xchg1)
5512         i.rounding->operand = xchg2;
5513       else if (i.rounding->operand == xchg2)
5514         i.rounding->operand = xchg1;
5515     }
5516 }
5517
5518 static void
5519 swap_operands (void)
5520 {
5521   switch (i.operands)
5522     {
5523     case 5:
5524     case 4:
5525       swap_2_operands (1, i.operands - 2);
5526       /* Fall through.  */
5527     case 3:
5528     case 2:
5529       swap_2_operands (0, i.operands - 1);
5530       break;
5531     default:
5532       abort ();
5533     }
5534
5535   if (i.mem_operands == 2)
5536     {
5537       const seg_entry *temp_seg;
5538       temp_seg = i.seg[0];
5539       i.seg[0] = i.seg[1];
5540       i.seg[1] = temp_seg;
5541     }
5542 }
5543
5544 /* Try to ensure constant immediates are represented in the smallest
5545    opcode possible.  */
5546 static void
5547 optimize_imm (void)
5548 {
5549   char guess_suffix = 0;
5550   int op;
5551
5552   if (i.suffix)
5553     guess_suffix = i.suffix;
5554   else if (i.reg_operands)
5555     {
5556       /* Figure out a suffix from the last register operand specified.
5557          We can't do this properly yet, i.e. excluding special register
5558          instances, but the following works for instructions with
5559          immediates.  In any case, we can't set i.suffix yet.  */
5560       for (op = i.operands; --op >= 0;)
5561         if (i.types[op].bitfield.class != Reg)
5562           continue;
5563         else if (i.types[op].bitfield.byte)
5564           {
5565             guess_suffix = BYTE_MNEM_SUFFIX;
5566             break;
5567           }
5568         else if (i.types[op].bitfield.word)
5569           {
5570             guess_suffix = WORD_MNEM_SUFFIX;
5571             break;
5572           }
5573         else if (i.types[op].bitfield.dword)
5574           {
5575             guess_suffix = LONG_MNEM_SUFFIX;
5576             break;
5577           }
5578         else if (i.types[op].bitfield.qword)
5579           {
5580             guess_suffix = QWORD_MNEM_SUFFIX;
5581             break;
5582           }
5583     }
5584   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
5585     guess_suffix = WORD_MNEM_SUFFIX;
5586
5587   for (op = i.operands; --op >= 0;)
5588     if (operand_type_check (i.types[op], imm))
5589       {
5590         switch (i.op[op].imms->X_op)
5591           {
5592           case O_constant:
5593             /* If a suffix is given, this operand may be shortened.  */
5594             switch (guess_suffix)
5595               {
5596               case LONG_MNEM_SUFFIX:
5597                 i.types[op].bitfield.imm32 = 1;
5598                 i.types[op].bitfield.imm64 = 1;
5599                 break;
5600               case WORD_MNEM_SUFFIX:
5601                 i.types[op].bitfield.imm16 = 1;
5602                 i.types[op].bitfield.imm32 = 1;
5603                 i.types[op].bitfield.imm32s = 1;
5604                 i.types[op].bitfield.imm64 = 1;
5605                 break;
5606               case BYTE_MNEM_SUFFIX:
5607                 i.types[op].bitfield.imm8 = 1;
5608                 i.types[op].bitfield.imm8s = 1;
5609                 i.types[op].bitfield.imm16 = 1;
5610                 i.types[op].bitfield.imm32 = 1;
5611                 i.types[op].bitfield.imm32s = 1;
5612                 i.types[op].bitfield.imm64 = 1;
5613                 break;
5614               }
5615
5616             /* If this operand is at most 16 bits, convert it
5617                to a signed 16 bit number before trying to see
5618                whether it will fit in an even smaller size.
5619                This allows a 16-bit operand such as $0xffe0 to
5620                be recognised as within Imm8S range.  */
5621             if ((i.types[op].bitfield.imm16)
5622                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
5623               {
5624                 i.op[op].imms->X_add_number =
5625                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
5626               }
5627 #ifdef BFD64
5628             /* Store 32-bit immediate in 64-bit for 64-bit BFD.  */
5629             if ((i.types[op].bitfield.imm32)
5630                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
5631                     == 0))
5632               {
5633                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
5634                                                 ^ ((offsetT) 1 << 31))
5635                                                - ((offsetT) 1 << 31));
5636               }
5637 #endif
5638             i.types[op]
5639               = operand_type_or (i.types[op],
5640                                  smallest_imm_type (i.op[op].imms->X_add_number));
5641
5642             /* We must avoid matching of Imm32 templates when 64bit
5643                only immediate is available.  */
5644             if (guess_suffix == QWORD_MNEM_SUFFIX)
5645               i.types[op].bitfield.imm32 = 0;
5646             break;
5647
5648           case O_absent:
5649           case O_register:
5650             abort ();
5651
5652             /* Symbols and expressions.  */
5653           default:
5654             /* Convert symbolic operand to proper sizes for matching, but don't
5655                prevent matching a set of insns that only supports sizes other
5656                than those matching the insn suffix.  */
5657             {
5658               i386_operand_type mask, allowed;
5659               const insn_template *t;
5660
5661               operand_type_set (&mask, 0);
5662               operand_type_set (&allowed, 0);
5663
5664               for (t = current_templates->start;
5665                    t < current_templates->end;
5666                    ++t)
5667                 {
5668                   allowed = operand_type_or (allowed, t->operand_types[op]);
5669                   allowed = operand_type_and (allowed, anyimm);
5670                 }
5671               switch (guess_suffix)
5672                 {
5673                 case QWORD_MNEM_SUFFIX:
5674                   mask.bitfield.imm64 = 1;
5675                   mask.bitfield.imm32s = 1;
5676                   break;
5677                 case LONG_MNEM_SUFFIX:
5678                   mask.bitfield.imm32 = 1;
5679                   break;
5680                 case WORD_MNEM_SUFFIX:
5681                   mask.bitfield.imm16 = 1;
5682                   break;
5683                 case BYTE_MNEM_SUFFIX:
5684                   mask.bitfield.imm8 = 1;
5685                   break;
5686                 default:
5687                   break;
5688                 }
5689               allowed = operand_type_and (mask, allowed);
5690               if (!operand_type_all_zero (&allowed))
5691                 i.types[op] = operand_type_and (i.types[op], mask);
5692             }
5693             break;
5694           }
5695       }
5696 }
5697
5698 /* Try to use the smallest displacement type too.  */
5699 static void
5700 optimize_disp (void)
5701 {
5702   int op;
5703
5704   for (op = i.operands; --op >= 0;)
5705     if (operand_type_check (i.types[op], disp))
5706       {
5707         if (i.op[op].disps->X_op == O_constant)
5708           {
5709             offsetT op_disp = i.op[op].disps->X_add_number;
5710
5711             if (i.types[op].bitfield.disp16
5712                 && (op_disp & ~(offsetT) 0xffff) == 0)
5713               {
5714                 /* If this operand is at most 16 bits, convert
5715                    to a signed 16 bit number and don't use 64bit
5716                    displacement.  */
5717                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
5718                 i.types[op].bitfield.disp64 = 0;
5719               }
5720 #ifdef BFD64
5721             /* Optimize 64-bit displacement to 32-bit for 64-bit BFD.  */
5722             if (i.types[op].bitfield.disp32
5723                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
5724               {
5725                 /* If this operand is at most 32 bits, convert
5726                    to a signed 32 bit number and don't use 64bit
5727                    displacement.  */
5728                 op_disp &= (((offsetT) 2 << 31) - 1);
5729                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
5730                 i.types[op].bitfield.disp64 = 0;
5731               }
5732 #endif
5733             if (!op_disp && i.types[op].bitfield.baseindex)
5734               {
5735                 i.types[op].bitfield.disp8 = 0;
5736                 i.types[op].bitfield.disp16 = 0;
5737                 i.types[op].bitfield.disp32 = 0;
5738                 i.types[op].bitfield.disp32s = 0;
5739                 i.types[op].bitfield.disp64 = 0;
5740                 i.op[op].disps = 0;
5741                 i.disp_operands--;
5742               }
5743             else if (flag_code == CODE_64BIT)
5744               {
5745                 if (fits_in_signed_long (op_disp))
5746                   {
5747                     i.types[op].bitfield.disp64 = 0;
5748                     i.types[op].bitfield.disp32s = 1;
5749                   }
5750                 if (i.prefix[ADDR_PREFIX]
5751                     && fits_in_unsigned_long (op_disp))
5752                   i.types[op].bitfield.disp32 = 1;
5753               }
5754             if ((i.types[op].bitfield.disp32
5755                  || i.types[op].bitfield.disp32s
5756                  || i.types[op].bitfield.disp16)
5757                 && fits_in_disp8 (op_disp))
5758               i.types[op].bitfield.disp8 = 1;
5759           }
5760         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
5761                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
5762           {
5763             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
5764                          i.op[op].disps, 0, i.reloc[op]);
5765             i.types[op].bitfield.disp8 = 0;
5766             i.types[op].bitfield.disp16 = 0;
5767             i.types[op].bitfield.disp32 = 0;
5768             i.types[op].bitfield.disp32s = 0;
5769             i.types[op].bitfield.disp64 = 0;
5770           }
5771         else
5772           /* We only support 64bit displacement on constants.  */
5773           i.types[op].bitfield.disp64 = 0;
5774       }
5775 }
5776
5777 /* Return 1 if there is a match in broadcast bytes between operand
5778    GIVEN and instruction template T.   */
5779
5780 static INLINE int
5781 match_broadcast_size (const insn_template *t, unsigned int given)
5782 {
5783   return ((t->opcode_modifier.broadcast == BYTE_BROADCAST
5784            && i.types[given].bitfield.byte)
5785           || (t->opcode_modifier.broadcast == WORD_BROADCAST
5786               && i.types[given].bitfield.word)
5787           || (t->opcode_modifier.broadcast == DWORD_BROADCAST
5788               && i.types[given].bitfield.dword)
5789           || (t->opcode_modifier.broadcast == QWORD_BROADCAST
5790               && i.types[given].bitfield.qword));
5791 }
5792
5793 /* Check if operands are valid for the instruction.  */
5794
5795 static int
5796 check_VecOperands (const insn_template *t)
5797 {
5798   unsigned int op;
5799   i386_cpu_flags cpu;
5800
5801   /* Templates allowing for ZMMword as well as YMMword and/or XMMword for
5802      any one operand are implicity requiring AVX512VL support if the actual
5803      operand size is YMMword or XMMword.  Since this function runs after
5804      template matching, there's no need to check for YMMword/XMMword in
5805      the template.  */
5806   cpu = cpu_flags_and (t->cpu_flags, avx512);
5807   if (!cpu_flags_all_zero (&cpu)
5808       && !t->cpu_flags.bitfield.cpuavx512vl
5809       && !cpu_arch_flags.bitfield.cpuavx512vl)
5810     {
5811       for (op = 0; op < t->operands; ++op)
5812         {
5813           if (t->operand_types[op].bitfield.zmmword
5814               && (i.types[op].bitfield.ymmword
5815                   || i.types[op].bitfield.xmmword))
5816             {
5817               i.error = unsupported;
5818               return 1;
5819             }
5820         }
5821     }
5822
5823   /* Without VSIB byte, we can't have a vector register for index.  */
5824   if (!t->opcode_modifier.sib
5825       && i.index_reg
5826       && (i.index_reg->reg_type.bitfield.xmmword
5827           || i.index_reg->reg_type.bitfield.ymmword
5828           || i.index_reg->reg_type.bitfield.zmmword))
5829     {
5830       i.error = unsupported_vector_index_register;
5831       return 1;
5832     }
5833
5834   /* Check if default mask is allowed.  */
5835   if (t->opcode_modifier.nodefmask
5836       && (!i.mask || i.mask->mask->reg_num == 0))
5837     {
5838       i.error = no_default_mask;
5839       return 1;
5840     }
5841
5842   /* For VSIB byte, we need a vector register for index, and all vector
5843      registers must be distinct.  */
5844   if (t->opcode_modifier.sib && t->opcode_modifier.sib != SIBMEM)
5845     {
5846       if (!i.index_reg
5847           || !((t->opcode_modifier.sib == VECSIB128
5848                 && i.index_reg->reg_type.bitfield.xmmword)
5849                || (t->opcode_modifier.sib == VECSIB256
5850                    && i.index_reg->reg_type.bitfield.ymmword)
5851                || (t->opcode_modifier.sib == VECSIB512
5852                    && i.index_reg->reg_type.bitfield.zmmword)))
5853       {
5854         i.error = invalid_vsib_address;
5855         return 1;
5856       }
5857
5858       gas_assert (i.reg_operands == 2 || i.mask);
5859       if (i.reg_operands == 2 && !i.mask)
5860         {
5861           gas_assert (i.types[0].bitfield.class == RegSIMD);
5862           gas_assert (i.types[0].bitfield.xmmword
5863                       || i.types[0].bitfield.ymmword);
5864           gas_assert (i.types[2].bitfield.class == RegSIMD);
5865           gas_assert (i.types[2].bitfield.xmmword
5866                       || i.types[2].bitfield.ymmword);
5867           if (operand_check == check_none)
5868             return 0;
5869           if (register_number (i.op[0].regs)
5870               != register_number (i.index_reg)
5871               && register_number (i.op[2].regs)
5872                  != register_number (i.index_reg)
5873               && register_number (i.op[0].regs)
5874                  != register_number (i.op[2].regs))
5875             return 0;
5876           if (operand_check == check_error)
5877             {
5878               i.error = invalid_vector_register_set;
5879               return 1;
5880             }
5881           as_warn (_("mask, index, and destination registers should be distinct"));
5882         }
5883       else if (i.reg_operands == 1 && i.mask)
5884         {
5885           if (i.types[1].bitfield.class == RegSIMD
5886               && (i.types[1].bitfield.xmmword
5887                   || i.types[1].bitfield.ymmword
5888                   || i.types[1].bitfield.zmmword)
5889               && (register_number (i.op[1].regs)
5890                   == register_number (i.index_reg)))
5891             {
5892               if (operand_check == check_error)
5893                 {
5894                   i.error = invalid_vector_register_set;
5895                   return 1;
5896                 }
5897               if (operand_check != check_none)
5898                 as_warn (_("index and destination registers should be distinct"));
5899             }
5900         }
5901     }
5902
5903   /* For AMX instructions with three tmmword operands, all tmmword operand must be
5904      distinct */
5905   if (t->operand_types[0].bitfield.tmmword
5906       && i.reg_operands == 3)
5907     {
5908       if (register_number (i.op[0].regs)
5909           == register_number (i.op[1].regs)
5910           || register_number (i.op[0].regs)
5911              == register_number (i.op[2].regs)
5912           || register_number (i.op[1].regs)
5913              == register_number (i.op[2].regs))
5914         {
5915           i.error = invalid_tmm_register_set;
5916           return 1;
5917         }
5918     }
5919
5920   /* Check if broadcast is supported by the instruction and is applied
5921      to the memory operand.  */
5922   if (i.broadcast)
5923     {
5924       i386_operand_type type, overlap;
5925
5926       /* Check if specified broadcast is supported in this instruction,
5927          and its broadcast bytes match the memory operand.  */
5928       op = i.broadcast->operand;
5929       if (!t->opcode_modifier.broadcast
5930           || !(i.flags[op] & Operand_Mem)
5931           || (!i.types[op].bitfield.unspecified
5932               && !match_broadcast_size (t, op)))
5933         {
5934         bad_broadcast:
5935           i.error = unsupported_broadcast;
5936           return 1;
5937         }
5938
5939       i.broadcast->bytes = ((1 << (t->opcode_modifier.broadcast - 1))
5940                             * i.broadcast->type);
5941       operand_type_set (&type, 0);
5942       switch (i.broadcast->bytes)
5943         {
5944         case 2:
5945           type.bitfield.word = 1;
5946           break;
5947         case 4:
5948           type.bitfield.dword = 1;
5949           break;
5950         case 8:
5951           type.bitfield.qword = 1;
5952           break;
5953         case 16:
5954           type.bitfield.xmmword = 1;
5955           break;
5956         case 32:
5957           type.bitfield.ymmword = 1;
5958           break;
5959         case 64:
5960           type.bitfield.zmmword = 1;
5961           break;
5962         default:
5963           goto bad_broadcast;
5964         }
5965
5966       overlap = operand_type_and (type, t->operand_types[op]);
5967       if (t->operand_types[op].bitfield.class == RegSIMD
5968           && t->operand_types[op].bitfield.byte
5969              + t->operand_types[op].bitfield.word
5970              + t->operand_types[op].bitfield.dword
5971              + t->operand_types[op].bitfield.qword > 1)
5972         {
5973           overlap.bitfield.xmmword = 0;
5974           overlap.bitfield.ymmword = 0;
5975           overlap.bitfield.zmmword = 0;
5976         }
5977       if (operand_type_all_zero (&overlap))
5978           goto bad_broadcast;
5979
5980       if (t->opcode_modifier.checkregsize)
5981         {
5982           unsigned int j;
5983
5984           type.bitfield.baseindex = 1;
5985           for (j = 0; j < i.operands; ++j)
5986             {
5987               if (j != op
5988                   && !operand_type_register_match(i.types[j],
5989                                                   t->operand_types[j],
5990                                                   type,
5991                                                   t->operand_types[op]))
5992                 goto bad_broadcast;
5993             }
5994         }
5995     }
5996   /* If broadcast is supported in this instruction, we need to check if
5997      operand of one-element size isn't specified without broadcast.  */
5998   else if (t->opcode_modifier.broadcast && i.mem_operands)
5999     {
6000       /* Find memory operand.  */
6001       for (op = 0; op < i.operands; op++)
6002         if (i.flags[op] & Operand_Mem)
6003           break;
6004       gas_assert (op < i.operands);
6005       /* Check size of the memory operand.  */
6006       if (match_broadcast_size (t, op))
6007         {
6008           i.error = broadcast_needed;
6009           return 1;
6010         }
6011     }
6012   else
6013     op = MAX_OPERANDS - 1; /* Avoid uninitialized variable warning.  */
6014
6015   /* Check if requested masking is supported.  */
6016   if (i.mask)
6017     {
6018       switch (t->opcode_modifier.masking)
6019         {
6020         case BOTH_MASKING:
6021           break;
6022         case MERGING_MASKING:
6023           if (i.mask->zeroing)
6024             {
6025         case 0:
6026               i.error = unsupported_masking;
6027               return 1;
6028             }
6029           break;
6030         case DYNAMIC_MASKING:
6031           /* Memory destinations allow only merging masking.  */
6032           if (i.mask->zeroing && i.mem_operands)
6033             {
6034               /* Find memory operand.  */
6035               for (op = 0; op < i.operands; op++)
6036                 if (i.flags[op] & Operand_Mem)
6037                   break;
6038               gas_assert (op < i.operands);
6039               if (op == i.operands - 1)
6040                 {
6041                   i.error = unsupported_masking;
6042                   return 1;
6043                 }
6044             }
6045           break;
6046         default:
6047           abort ();
6048         }
6049     }
6050
6051   /* Check if masking is applied to dest operand.  */
6052   if (i.mask && (i.mask->operand != (int) (i.operands - 1)))
6053     {
6054       i.error = mask_not_on_destination;
6055       return 1;
6056     }
6057
6058   /* Check RC/SAE.  */
6059   if (i.rounding)
6060     {
6061       if (!t->opcode_modifier.sae
6062           || (i.rounding->type != saeonly && !t->opcode_modifier.staticrounding))
6063         {
6064           i.error = unsupported_rc_sae;
6065           return 1;
6066         }
6067       /* If the instruction has several immediate operands and one of
6068          them is rounding, the rounding operand should be the last
6069          immediate operand.  */
6070       if (i.imm_operands > 1
6071           && i.rounding->operand != (int) (i.imm_operands - 1))
6072         {
6073           i.error = rc_sae_operand_not_last_imm;
6074           return 1;
6075         }
6076     }
6077
6078   /* Check the special Imm4 cases; must be the first operand.  */
6079   if (t->cpu_flags.bitfield.cpuxop && t->operands == 5)
6080     {
6081       if (i.op[0].imms->X_op != O_constant
6082           || !fits_in_imm4 (i.op[0].imms->X_add_number))
6083         {
6084           i.error = bad_imm4;
6085           return 1;
6086         }
6087
6088       /* Turn off Imm<N> so that update_imm won't complain.  */
6089       operand_type_set (&i.types[0], 0);
6090     }
6091
6092   /* Check vector Disp8 operand.  */
6093   if (t->opcode_modifier.disp8memshift
6094       && i.disp_encoding != disp_encoding_32bit)
6095     {
6096       if (i.broadcast)
6097         i.memshift = t->opcode_modifier.broadcast - 1;
6098       else if (t->opcode_modifier.disp8memshift != DISP8_SHIFT_VL)
6099         i.memshift = t->opcode_modifier.disp8memshift;
6100       else
6101         {
6102           const i386_operand_type *type = NULL;
6103
6104           i.memshift = 0;
6105           for (op = 0; op < i.operands; op++)
6106             if (i.flags[op] & Operand_Mem)
6107               {
6108                 if (t->opcode_modifier.evex == EVEXLIG)
6109                   i.memshift = 2 + (i.suffix == QWORD_MNEM_SUFFIX);
6110                 else if (t->operand_types[op].bitfield.xmmword
6111                          + t->operand_types[op].bitfield.ymmword
6112                          + t->operand_types[op].bitfield.zmmword <= 1)
6113                   type = &t->operand_types[op];
6114                 else if (!i.types[op].bitfield.unspecified)
6115                   type = &i.types[op];
6116               }
6117             else if (i.types[op].bitfield.class == RegSIMD
6118                      && t->opcode_modifier.evex != EVEXLIG)
6119               {
6120                 if (i.types[op].bitfield.zmmword)
6121                   i.memshift = 6;
6122                 else if (i.types[op].bitfield.ymmword && i.memshift < 5)
6123                   i.memshift = 5;
6124                 else if (i.types[op].bitfield.xmmword && i.memshift < 4)
6125                   i.memshift = 4;
6126               }
6127
6128           if (type)
6129             {
6130               if (type->bitfield.zmmword)
6131                 i.memshift = 6;
6132               else if (type->bitfield.ymmword)
6133                 i.memshift = 5;
6134               else if (type->bitfield.xmmword)
6135                 i.memshift = 4;
6136             }
6137
6138           /* For the check in fits_in_disp8().  */
6139           if (i.memshift == 0)
6140             i.memshift = -1;
6141         }
6142
6143       for (op = 0; op < i.operands; op++)
6144         if (operand_type_check (i.types[op], disp)
6145             && i.op[op].disps->X_op == O_constant)
6146           {
6147             if (fits_in_disp8 (i.op[op].disps->X_add_number))
6148               {
6149                 i.types[op].bitfield.disp8 = 1;
6150                 return 0;
6151               }
6152             i.types[op].bitfield.disp8 = 0;
6153           }
6154     }
6155
6156   i.memshift = 0;
6157
6158   return 0;
6159 }
6160
6161 /* Check if encoding requirements are met by the instruction.  */
6162
6163 static int
6164 VEX_check_encoding (const insn_template *t)
6165 {
6166   if (i.vec_encoding == vex_encoding_error)
6167     {
6168       i.error = unsupported;
6169       return 1;
6170     }
6171
6172   if (i.vec_encoding == vex_encoding_evex)
6173     {
6174       /* This instruction must be encoded with EVEX prefix.  */
6175       if (!is_evex_encoding (t))
6176         {
6177           i.error = unsupported;
6178           return 1;
6179         }
6180       return 0;
6181     }
6182
6183   if (!t->opcode_modifier.vex)
6184     {
6185       /* This instruction template doesn't have VEX prefix.  */
6186       if (i.vec_encoding != vex_encoding_default)
6187         {
6188           i.error = unsupported;
6189           return 1;
6190         }
6191       return 0;
6192     }
6193
6194   return 0;
6195 }
6196
6197 static const insn_template *
6198 match_template (char mnem_suffix)
6199 {
6200   /* Points to template once we've found it.  */
6201   const insn_template *t;
6202   i386_operand_type overlap0, overlap1, overlap2, overlap3;
6203   i386_operand_type overlap4;
6204   unsigned int found_reverse_match;
6205   i386_opcode_modifier suffix_check;
6206   i386_operand_type operand_types [MAX_OPERANDS];
6207   int addr_prefix_disp;
6208   unsigned int j, size_match, check_register;
6209   enum i386_error specific_error = 0;
6210
6211 #if MAX_OPERANDS != 5
6212 # error "MAX_OPERANDS must be 5."
6213 #endif
6214
6215   found_reverse_match = 0;
6216   addr_prefix_disp = -1;
6217
6218   /* Prepare for mnemonic suffix check.  */
6219   memset (&suffix_check, 0, sizeof (suffix_check));
6220   switch (mnem_suffix)
6221     {
6222     case BYTE_MNEM_SUFFIX:
6223       suffix_check.no_bsuf = 1;
6224       break;
6225     case WORD_MNEM_SUFFIX:
6226       suffix_check.no_wsuf = 1;
6227       break;
6228     case SHORT_MNEM_SUFFIX:
6229       suffix_check.no_ssuf = 1;
6230       break;
6231     case LONG_MNEM_SUFFIX:
6232       suffix_check.no_lsuf = 1;
6233       break;
6234     case QWORD_MNEM_SUFFIX:
6235       suffix_check.no_qsuf = 1;
6236       break;
6237     default:
6238       /* NB: In Intel syntax, normally we can check for memory operand
6239          size when there is no mnemonic suffix.  But jmp and call have
6240          2 different encodings with Dword memory operand size, one with
6241          No_ldSuf and the other without.  i.suffix is set to
6242          LONG_DOUBLE_MNEM_SUFFIX to skip the one with No_ldSuf.  */
6243       if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
6244         suffix_check.no_ldsuf = 1;
6245     }
6246
6247   /* Must have right number of operands.  */
6248   i.error = number_of_operands_mismatch;
6249
6250   for (t = current_templates->start; t < current_templates->end; t++)
6251     {
6252       addr_prefix_disp = -1;
6253       found_reverse_match = 0;
6254
6255       if (i.operands != t->operands)
6256         continue;
6257
6258       /* Check processor support.  */
6259       i.error = unsupported;
6260       if (cpu_flags_match (t) != CPU_FLAGS_PERFECT_MATCH)
6261         continue;
6262
6263       /* Check Pseudo Prefix.  */
6264       i.error = unsupported;
6265       if (t->opcode_modifier.pseudovexprefix
6266           && !(i.vec_encoding == vex_encoding_vex
6267               || i.vec_encoding == vex_encoding_vex3))
6268         continue;
6269
6270       /* Check AT&T mnemonic.   */
6271       i.error = unsupported_with_intel_mnemonic;
6272       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
6273         continue;
6274
6275       /* Check AT&T/Intel syntax.  */
6276       i.error = unsupported_syntax;
6277       if ((intel_syntax && t->opcode_modifier.attsyntax)
6278           || (!intel_syntax && t->opcode_modifier.intelsyntax))
6279         continue;
6280
6281       /* Check Intel64/AMD64 ISA.   */
6282       switch (isa64)
6283         {
6284         default:
6285           /* Default: Don't accept Intel64.  */
6286           if (t->opcode_modifier.isa64 == INTEL64)
6287             continue;
6288           break;
6289         case amd64:
6290           /* -mamd64: Don't accept Intel64 and Intel64 only.  */
6291           if (t->opcode_modifier.isa64 >= INTEL64)
6292             continue;
6293           break;
6294         case intel64:
6295           /* -mintel64: Don't accept AMD64.  */
6296           if (t->opcode_modifier.isa64 == AMD64 && flag_code == CODE_64BIT)
6297             continue;
6298           break;
6299         }
6300
6301       /* Check the suffix.  */
6302       i.error = invalid_instruction_suffix;
6303       if ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
6304           || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
6305           || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
6306           || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
6307           || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
6308           || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf))
6309         continue;
6310
6311       size_match = operand_size_match (t);
6312       if (!size_match)
6313         continue;
6314
6315       /* This is intentionally not
6316
6317          if (i.jumpabsolute != (t->opcode_modifier.jump == JUMP_ABSOLUTE))
6318
6319          as the case of a missing * on the operand is accepted (perhaps with
6320          a warning, issued further down).  */
6321       if (i.jumpabsolute && t->opcode_modifier.jump != JUMP_ABSOLUTE)
6322         {
6323           i.error = operand_type_mismatch;
6324           continue;
6325         }
6326
6327       for (j = 0; j < MAX_OPERANDS; j++)
6328         operand_types[j] = t->operand_types[j];
6329
6330       /* In general, don't allow
6331          - 64-bit operands outside of 64-bit mode,
6332          - 32-bit operands on pre-386.  */
6333       j = i.imm_operands + (t->operands > i.imm_operands + 1);
6334       if (((i.suffix == QWORD_MNEM_SUFFIX
6335             && flag_code != CODE_64BIT
6336             && !(t->base_opcode == 0xfc7
6337                  && i.tm.opcode_modifier.opcodeprefix == 0
6338                  && t->extension_opcode == 1) /* cmpxchg8b */)
6339            || (i.suffix == LONG_MNEM_SUFFIX
6340                && !cpu_arch_flags.bitfield.cpui386))
6341           && (intel_syntax
6342               ? (t->opcode_modifier.mnemonicsize != IGNORESIZE
6343                  && !intel_float_operand (t->name))
6344               : intel_float_operand (t->name) != 2)
6345           && (t->operands == i.imm_operands
6346               || (operand_types[i.imm_operands].bitfield.class != RegMMX
6347                && operand_types[i.imm_operands].bitfield.class != RegSIMD
6348                && operand_types[i.imm_operands].bitfield.class != RegMask)
6349               || (operand_types[j].bitfield.class != RegMMX
6350                   && operand_types[j].bitfield.class != RegSIMD
6351                   && operand_types[j].bitfield.class != RegMask))
6352           && !t->opcode_modifier.sib)
6353         continue;
6354
6355       /* Do not verify operands when there are none.  */
6356       if (!t->operands)
6357         {
6358           if (VEX_check_encoding (t))
6359             {
6360               specific_error = i.error;
6361               continue;
6362             }
6363
6364           /* We've found a match; break out of loop.  */
6365           break;
6366         }
6367
6368       if (!t->opcode_modifier.jump
6369           || t->opcode_modifier.jump == JUMP_ABSOLUTE)
6370         {
6371           /* There should be only one Disp operand.  */
6372           for (j = 0; j < MAX_OPERANDS; j++)
6373             if (operand_type_check (operand_types[j], disp))
6374               break;
6375           if (j < MAX_OPERANDS)
6376             {
6377               bfd_boolean override = (i.prefix[ADDR_PREFIX] != 0);
6378
6379               addr_prefix_disp = j;
6380
6381               /* Address size prefix will turn Disp64/Disp32S/Disp32/Disp16
6382                  operand into Disp32/Disp32/Disp16/Disp32 operand.  */
6383               switch (flag_code)
6384                 {
6385                 case CODE_16BIT:
6386                   override = !override;
6387                   /* Fall through.  */
6388                 case CODE_32BIT:
6389                   if (operand_types[j].bitfield.disp32
6390                       && operand_types[j].bitfield.disp16)
6391                     {
6392                       operand_types[j].bitfield.disp16 = override;
6393                       operand_types[j].bitfield.disp32 = !override;
6394                     }
6395                   operand_types[j].bitfield.disp32s = 0;
6396                   operand_types[j].bitfield.disp64 = 0;
6397                   break;
6398
6399                 case CODE_64BIT:
6400                   if (operand_types[j].bitfield.disp32s
6401                       || operand_types[j].bitfield.disp64)
6402                     {
6403                       operand_types[j].bitfield.disp64 &= !override;
6404                       operand_types[j].bitfield.disp32s &= !override;
6405                       operand_types[j].bitfield.disp32 = override;
6406                     }
6407                   operand_types[j].bitfield.disp16 = 0;
6408                   break;
6409                 }
6410             }
6411         }
6412
6413       /* Force 0x8b encoding for "mov foo@GOT, %eax".  */
6414       if (i.reloc[0] == BFD_RELOC_386_GOT32 && t->base_opcode == 0xa0)
6415         continue;
6416
6417       /* We check register size if needed.  */
6418       if (t->opcode_modifier.checkregsize)
6419         {
6420           check_register = (1 << t->operands) - 1;
6421           if (i.broadcast)
6422             check_register &= ~(1 << i.broadcast->operand);
6423         }
6424       else
6425         check_register = 0;
6426
6427       overlap0 = operand_type_and (i.types[0], operand_types[0]);
6428       switch (t->operands)
6429         {
6430         case 1:
6431           if (!operand_type_match (overlap0, i.types[0]))
6432             continue;
6433           break;
6434         case 2:
6435           /* xchg %eax, %eax is a special case. It is an alias for nop
6436              only in 32bit mode and we can use opcode 0x90.  In 64bit
6437              mode, we can't use 0x90 for xchg %eax, %eax since it should
6438              zero-extend %eax to %rax.  */
6439           if (flag_code == CODE_64BIT
6440               && t->base_opcode == 0x90
6441               && i.types[0].bitfield.instance == Accum
6442               && i.types[0].bitfield.dword
6443               && i.types[1].bitfield.instance == Accum
6444               && i.types[1].bitfield.dword)
6445             continue;
6446           /* xrelease mov %eax, <disp> is another special case. It must not
6447              match the accumulator-only encoding of mov.  */
6448           if (flag_code != CODE_64BIT
6449               && i.hle_prefix
6450               && t->base_opcode == 0xa0
6451               && i.types[0].bitfield.instance == Accum
6452               && (i.flags[1] & Operand_Mem))
6453             continue;
6454           /* Fall through.  */
6455
6456         case 3:
6457           if (!(size_match & MATCH_STRAIGHT))
6458             goto check_reverse;
6459           /* Reverse direction of operands if swapping is possible in the first
6460              place (operands need to be symmetric) and
6461              - the load form is requested, and the template is a store form,
6462              - the store form is requested, and the template is a load form,
6463              - the non-default (swapped) form is requested.  */
6464           overlap1 = operand_type_and (operand_types[0], operand_types[1]);
6465           if (t->opcode_modifier.d && i.reg_operands == i.operands
6466               && !operand_type_all_zero (&overlap1))
6467             switch (i.dir_encoding)
6468               {
6469               case dir_encoding_load:
6470                 if (operand_type_check (operand_types[i.operands - 1], anymem)
6471                     || t->opcode_modifier.regmem)
6472                   goto check_reverse;
6473                 break;
6474
6475               case dir_encoding_store:
6476                 if (!operand_type_check (operand_types[i.operands - 1], anymem)
6477                     && !t->opcode_modifier.regmem)
6478                   goto check_reverse;
6479                 break;
6480
6481               case dir_encoding_swap:
6482                 goto check_reverse;
6483
6484               case dir_encoding_default:
6485                 break;
6486               }
6487           /* If we want store form, we skip the current load.  */
6488           if ((i.dir_encoding == dir_encoding_store
6489                || i.dir_encoding == dir_encoding_swap)
6490               && i.mem_operands == 0
6491               && t->opcode_modifier.load)
6492             continue;
6493           /* Fall through.  */
6494         case 4:
6495         case 5:
6496           overlap1 = operand_type_and (i.types[1], operand_types[1]);
6497           if (!operand_type_match (overlap0, i.types[0])
6498               || !operand_type_match (overlap1, i.types[1])
6499               || ((check_register & 3) == 3
6500                   && !operand_type_register_match (i.types[0],
6501                                                    operand_types[0],
6502                                                    i.types[1],
6503                                                    operand_types[1])))
6504             {
6505               /* Check if other direction is valid ...  */
6506               if (!t->opcode_modifier.d)
6507                 continue;
6508
6509             check_reverse:
6510               if (!(size_match & MATCH_REVERSE))
6511                 continue;
6512               /* Try reversing direction of operands.  */
6513               overlap0 = operand_type_and (i.types[0], operand_types[i.operands - 1]);
6514               overlap1 = operand_type_and (i.types[i.operands - 1], operand_types[0]);
6515               if (!operand_type_match (overlap0, i.types[0])
6516                   || !operand_type_match (overlap1, i.types[i.operands - 1])
6517                   || (check_register
6518                       && !operand_type_register_match (i.types[0],
6519                                                        operand_types[i.operands - 1],
6520                                                        i.types[i.operands - 1],
6521                                                        operand_types[0])))
6522                 {
6523                   /* Does not match either direction.  */
6524                   continue;
6525                 }
6526               /* found_reverse_match holds which of D or FloatR
6527                  we've found.  */
6528               if (!t->opcode_modifier.d)
6529                 found_reverse_match = 0;
6530               else if (operand_types[0].bitfield.tbyte)
6531                 found_reverse_match = Opcode_FloatD;
6532               else if (operand_types[0].bitfield.xmmword
6533                        || operand_types[i.operands - 1].bitfield.xmmword
6534                        || operand_types[0].bitfield.class == RegMMX
6535                        || operand_types[i.operands - 1].bitfield.class == RegMMX
6536                        || is_any_vex_encoding(t))
6537                 found_reverse_match = (t->base_opcode & 0xee) != 0x6e
6538                                       ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
6539               else
6540                 found_reverse_match = Opcode_D;
6541               if (t->opcode_modifier.floatr)
6542                 found_reverse_match |= Opcode_FloatR;
6543             }
6544           else
6545             {
6546               /* Found a forward 2 operand match here.  */
6547               switch (t->operands)
6548                 {
6549                 case 5:
6550                   overlap4 = operand_type_and (i.types[4],
6551                                                operand_types[4]);
6552                   /* Fall through.  */
6553                 case 4:
6554                   overlap3 = operand_type_and (i.types[3],
6555                                                operand_types[3]);
6556                   /* Fall through.  */
6557                 case 3:
6558                   overlap2 = operand_type_and (i.types[2],
6559                                                operand_types[2]);
6560                   break;
6561                 }
6562
6563               switch (t->operands)
6564                 {
6565                 case 5:
6566                   if (!operand_type_match (overlap4, i.types[4])
6567                       || !operand_type_register_match (i.types[3],
6568                                                        operand_types[3],
6569                                                        i.types[4],
6570                                                        operand_types[4]))
6571                     continue;
6572                   /* Fall through.  */
6573                 case 4:
6574                   if (!operand_type_match (overlap3, i.types[3])
6575                       || ((check_register & 0xa) == 0xa
6576                           && !operand_type_register_match (i.types[1],
6577                                                             operand_types[1],
6578                                                             i.types[3],
6579                                                             operand_types[3]))
6580                       || ((check_register & 0xc) == 0xc
6581                           && !operand_type_register_match (i.types[2],
6582                                                             operand_types[2],
6583                                                             i.types[3],
6584                                                             operand_types[3])))
6585                     continue;
6586                   /* Fall through.  */
6587                 case 3:
6588                   /* Here we make use of the fact that there are no
6589                      reverse match 3 operand instructions.  */
6590                   if (!operand_type_match (overlap2, i.types[2])
6591                       || ((check_register & 5) == 5
6592                           && !operand_type_register_match (i.types[0],
6593                                                             operand_types[0],
6594                                                             i.types[2],
6595                                                             operand_types[2]))
6596                       || ((check_register & 6) == 6
6597                           && !operand_type_register_match (i.types[1],
6598                                                             operand_types[1],
6599                                                             i.types[2],
6600                                                             operand_types[2])))
6601                     continue;
6602                   break;
6603                 }
6604             }
6605           /* Found either forward/reverse 2, 3 or 4 operand match here:
6606              slip through to break.  */
6607         }
6608
6609       /* Check if vector operands are valid.  */
6610       if (check_VecOperands (t))
6611         {
6612           specific_error = i.error;
6613           continue;
6614         }
6615
6616       /* Check if VEX/EVEX encoding requirements can be satisfied.  */
6617       if (VEX_check_encoding (t))
6618         {
6619           specific_error = i.error;
6620           continue;
6621         }
6622
6623       /* We've found a match; break out of loop.  */
6624       break;
6625     }
6626
6627   if (t == current_templates->end)
6628     {
6629       /* We found no match.  */
6630       const char *err_msg;
6631       switch (specific_error ? specific_error : i.error)
6632         {
6633         default:
6634           abort ();
6635         case operand_size_mismatch:
6636           err_msg = _("operand size mismatch");
6637           break;
6638         case operand_type_mismatch:
6639           err_msg = _("operand type mismatch");
6640           break;
6641         case register_type_mismatch:
6642           err_msg = _("register type mismatch");
6643           break;
6644         case number_of_operands_mismatch:
6645           err_msg = _("number of operands mismatch");
6646           break;
6647         case invalid_instruction_suffix:
6648           err_msg = _("invalid instruction suffix");
6649           break;
6650         case bad_imm4:
6651           err_msg = _("constant doesn't fit in 4 bits");
6652           break;
6653         case unsupported_with_intel_mnemonic:
6654           err_msg = _("unsupported with Intel mnemonic");
6655           break;
6656         case unsupported_syntax:
6657           err_msg = _("unsupported syntax");
6658           break;
6659         case unsupported:
6660           as_bad (_("unsupported instruction `%s'"),
6661                   current_templates->start->name);
6662           return NULL;
6663         case invalid_sib_address:
6664           err_msg = _("invalid SIB address");
6665           break;
6666         case invalid_vsib_address:
6667           err_msg = _("invalid VSIB address");
6668           break;
6669         case invalid_vector_register_set:
6670           err_msg = _("mask, index, and destination registers must be distinct");
6671           break;
6672         case invalid_tmm_register_set:
6673           err_msg = _("all tmm registers must be distinct");
6674           break;
6675         case unsupported_vector_index_register:
6676           err_msg = _("unsupported vector index register");
6677           break;
6678         case unsupported_broadcast:
6679           err_msg = _("unsupported broadcast");
6680           break;
6681         case broadcast_needed:
6682           err_msg = _("broadcast is needed for operand of such type");
6683           break;
6684         case unsupported_masking:
6685           err_msg = _("unsupported masking");
6686           break;
6687         case mask_not_on_destination:
6688           err_msg = _("mask not on destination operand");
6689           break;
6690         case no_default_mask:
6691           err_msg = _("default mask isn't allowed");
6692           break;
6693         case unsupported_rc_sae:
6694           err_msg = _("unsupported static rounding/sae");
6695           break;
6696         case rc_sae_operand_not_last_imm:
6697           if (intel_syntax)
6698             err_msg = _("RC/SAE operand must precede immediate operands");
6699           else
6700             err_msg = _("RC/SAE operand must follow immediate operands");
6701           break;
6702         case invalid_register_operand:
6703           err_msg = _("invalid register operand");
6704           break;
6705         }
6706       as_bad (_("%s for `%s'"), err_msg,
6707               current_templates->start->name);
6708       return NULL;
6709     }
6710
6711   if (!quiet_warnings)
6712     {
6713       if (!intel_syntax
6714           && (i.jumpabsolute != (t->opcode_modifier.jump == JUMP_ABSOLUTE)))
6715         as_warn (_("indirect %s without `*'"), t->name);
6716
6717       if (t->opcode_modifier.isprefix
6718           && t->opcode_modifier.mnemonicsize == IGNORESIZE)
6719         {
6720           /* Warn them that a data or address size prefix doesn't
6721              affect assembly of the next line of code.  */
6722           as_warn (_("stand-alone `%s' prefix"), t->name);
6723         }
6724     }
6725
6726   /* Copy the template we found.  */
6727   i.tm = *t;
6728
6729   if (addr_prefix_disp != -1)
6730     i.tm.operand_types[addr_prefix_disp]
6731       = operand_types[addr_prefix_disp];
6732
6733   if (found_reverse_match)
6734     {
6735       /* If we found a reverse match we must alter the opcode direction
6736          bit and clear/flip the regmem modifier one.  found_reverse_match
6737          holds bits to change (different for int & float insns).  */
6738
6739       i.tm.base_opcode ^= found_reverse_match;
6740
6741       i.tm.operand_types[0] = operand_types[i.operands - 1];
6742       i.tm.operand_types[i.operands - 1] = operand_types[0];
6743
6744       /* Certain SIMD insns have their load forms specified in the opcode
6745          table, and hence we need to _set_ RegMem instead of clearing it.
6746          We need to avoid setting the bit though on insns like KMOVW.  */
6747       i.tm.opcode_modifier.regmem
6748         = i.tm.opcode_modifier.modrm && i.tm.opcode_modifier.d
6749           && i.tm.operands > 2U - i.tm.opcode_modifier.sse2avx
6750           && !i.tm.opcode_modifier.regmem;
6751     }
6752
6753   return t;
6754 }
6755
6756 static int
6757 check_string (void)
6758 {
6759   unsigned int es_op = i.tm.opcode_modifier.isstring - IS_STRING_ES_OP0;
6760   unsigned int op = i.tm.operand_types[0].bitfield.baseindex ? es_op : 0;
6761
6762   if (i.seg[op] != NULL && i.seg[op] != &es)
6763     {
6764       as_bad (_("`%s' operand %u must use `%ses' segment"),
6765               i.tm.name,
6766               intel_syntax ? i.tm.operands - es_op : es_op + 1,
6767               register_prefix);
6768       return 0;
6769     }
6770
6771   /* There's only ever one segment override allowed per instruction.
6772      This instruction possibly has a legal segment override on the
6773      second operand, so copy the segment to where non-string
6774      instructions store it, allowing common code.  */
6775   i.seg[op] = i.seg[1];
6776
6777   return 1;
6778 }
6779
6780 static int
6781 process_suffix (void)
6782 {
6783   bfd_boolean is_crc32 = FALSE;
6784
6785   /* If matched instruction specifies an explicit instruction mnemonic
6786      suffix, use it.  */
6787   if (i.tm.opcode_modifier.size == SIZE16)
6788     i.suffix = WORD_MNEM_SUFFIX;
6789   else if (i.tm.opcode_modifier.size == SIZE32)
6790     i.suffix = LONG_MNEM_SUFFIX;
6791   else if (i.tm.opcode_modifier.size == SIZE64)
6792     i.suffix = QWORD_MNEM_SUFFIX;
6793   else if (i.reg_operands
6794            && (i.operands > 1 || i.types[0].bitfield.class == Reg)
6795            && !i.tm.opcode_modifier.addrprefixopreg)
6796     {
6797       unsigned int numop = i.operands;
6798       /* CRC32 */
6799       is_crc32 = (i.tm.base_opcode == 0xf38f0
6800                   && i.tm.opcode_modifier.opcodeprefix == PREFIX_0XF2);
6801
6802       /* movsx/movzx want only their source operand considered here, for the
6803          ambiguity checking below.  The suffix will be replaced afterwards
6804          to represent the destination (register).  */
6805       if (((i.tm.base_opcode | 8) == 0xfbe && i.tm.opcode_modifier.w)
6806           || (i.tm.base_opcode == 0x63 && i.tm.cpu_flags.bitfield.cpu64))
6807         --i.operands;
6808
6809       /* crc32 needs REX.W set regardless of suffix / source operand size.  */
6810       if (is_crc32 && i.tm.operand_types[1].bitfield.qword)
6811         i.rex |= REX_W;
6812
6813       /* If there's no instruction mnemonic suffix we try to invent one
6814          based on GPR operands.  */
6815       if (!i.suffix)
6816         {
6817           /* We take i.suffix from the last register operand specified,
6818              Destination register type is more significant than source
6819              register type.  crc32 in SSE4.2 prefers source register
6820              type. */
6821           unsigned int op = is_crc32 ? 1 : i.operands;
6822
6823           while (op--)
6824             if (i.tm.operand_types[op].bitfield.instance == InstanceNone
6825                 || i.tm.operand_types[op].bitfield.instance == Accum)
6826               {
6827                 if (i.types[op].bitfield.class != Reg)
6828                   continue;
6829                 if (i.types[op].bitfield.byte)
6830                   i.suffix = BYTE_MNEM_SUFFIX;
6831                 else if (i.types[op].bitfield.word)
6832                   i.suffix = WORD_MNEM_SUFFIX;
6833                 else if (i.types[op].bitfield.dword)
6834                   i.suffix = LONG_MNEM_SUFFIX;
6835                 else if (i.types[op].bitfield.qword)
6836                   i.suffix = QWORD_MNEM_SUFFIX;
6837                 else
6838                   continue;
6839                 break;
6840               }
6841
6842           /* As an exception, movsx/movzx silently default to a byte source
6843              in AT&T mode.  */
6844           if ((i.tm.base_opcode | 8) == 0xfbe && i.tm.opcode_modifier.w
6845               && !i.suffix && !intel_syntax)
6846             i.suffix = BYTE_MNEM_SUFFIX;
6847         }
6848       else if (i.suffix == BYTE_MNEM_SUFFIX)
6849         {
6850           if (intel_syntax
6851               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6852               && i.tm.opcode_modifier.no_bsuf)
6853             i.suffix = 0;
6854           else if (!check_byte_reg ())
6855             return 0;
6856         }
6857       else if (i.suffix == LONG_MNEM_SUFFIX)
6858         {
6859           if (intel_syntax
6860               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6861               && i.tm.opcode_modifier.no_lsuf
6862               && !i.tm.opcode_modifier.todword
6863               && !i.tm.opcode_modifier.toqword)
6864             i.suffix = 0;
6865           else if (!check_long_reg ())
6866             return 0;
6867         }
6868       else if (i.suffix == QWORD_MNEM_SUFFIX)
6869         {
6870           if (intel_syntax
6871               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6872               && i.tm.opcode_modifier.no_qsuf
6873               && !i.tm.opcode_modifier.todword
6874               && !i.tm.opcode_modifier.toqword)
6875             i.suffix = 0;
6876           else if (!check_qword_reg ())
6877             return 0;
6878         }
6879       else if (i.suffix == WORD_MNEM_SUFFIX)
6880         {
6881           if (intel_syntax
6882               && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE
6883               && i.tm.opcode_modifier.no_wsuf)
6884             i.suffix = 0;
6885           else if (!check_word_reg ())
6886             return 0;
6887         }
6888       else if (intel_syntax
6889                && i.tm.opcode_modifier.mnemonicsize == IGNORESIZE)
6890         /* Do nothing if the instruction is going to ignore the prefix.  */
6891         ;
6892       else
6893         abort ();
6894
6895       /* Undo the movsx/movzx change done above.  */
6896       i.operands = numop;
6897     }
6898   else if (i.tm.opcode_modifier.mnemonicsize == DEFAULTSIZE
6899            && !i.suffix)
6900     {
6901       i.suffix = stackop_size;
6902       if (stackop_size == LONG_MNEM_SUFFIX)
6903         {
6904           /* stackop_size is set to LONG_MNEM_SUFFIX for the
6905              .code16gcc directive to support 16-bit mode with
6906              32-bit address.  For IRET without a suffix, generate
6907              16-bit IRET (opcode 0xcf) to return from an interrupt
6908              handler.  */
6909           if (i.tm.base_opcode == 0xcf)
6910             {
6911               i.suffix = WORD_MNEM_SUFFIX;
6912               as_warn (_("generating 16-bit `iret' for .code16gcc directive"));
6913             }
6914           /* Warn about changed behavior for segment register push/pop.  */
6915           else if ((i.tm.base_opcode | 1) == 0x07)
6916             as_warn (_("generating 32-bit `%s', unlike earlier gas versions"),
6917                      i.tm.name);
6918         }
6919     }
6920   else if (!i.suffix
6921            && (i.tm.opcode_modifier.jump == JUMP_ABSOLUTE
6922                || i.tm.opcode_modifier.jump == JUMP_BYTE
6923                || i.tm.opcode_modifier.jump == JUMP_INTERSEGMENT
6924                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
6925                    && i.tm.extension_opcode <= 3)))
6926     {
6927       switch (flag_code)
6928         {
6929         case CODE_64BIT:
6930           if (!i.tm.opcode_modifier.no_qsuf)
6931             {
6932               if (i.tm.opcode_modifier.jump == JUMP_BYTE
6933                   || i.tm.opcode_modifier.no_lsuf)
6934                 i.suffix = QWORD_MNEM_SUFFIX;
6935               break;
6936             }
6937           /* Fall through.  */
6938         case CODE_32BIT:
6939           if (!i.tm.opcode_modifier.no_lsuf)
6940             i.suffix = LONG_MNEM_SUFFIX;
6941           break;
6942         case CODE_16BIT:
6943           if (!i.tm.opcode_modifier.no_wsuf)
6944             i.suffix = WORD_MNEM_SUFFIX;
6945           break;
6946         }
6947     }
6948
6949   if (!i.suffix
6950       && (i.tm.opcode_modifier.mnemonicsize != DEFAULTSIZE
6951           /* Also cover lret/retf/iret in 64-bit mode.  */
6952           || (flag_code == CODE_64BIT
6953               && !i.tm.opcode_modifier.no_lsuf
6954               && !i.tm.opcode_modifier.no_qsuf))
6955       && i.tm.opcode_modifier.mnemonicsize != IGNORESIZE
6956       /* Explicit sizing prefixes are assumed to disambiguate insns.  */
6957       && !i.prefix[DATA_PREFIX] && !(i.prefix[REX_PREFIX] & REX_W)
6958       /* Accept FLDENV et al without suffix.  */
6959       && (i.tm.opcode_modifier.no_ssuf || i.tm.opcode_modifier.floatmf))
6960     {
6961       unsigned int suffixes, evex = 0;
6962
6963       suffixes = !i.tm.opcode_modifier.no_bsuf;
6964       if (!i.tm.opcode_modifier.no_wsuf)
6965         suffixes |= 1 << 1;
6966       if (!i.tm.opcode_modifier.no_lsuf)
6967         suffixes |= 1 << 2;
6968       if (!i.tm.opcode_modifier.no_ldsuf)
6969         suffixes |= 1 << 3;
6970       if (!i.tm.opcode_modifier.no_ssuf)
6971         suffixes |= 1 << 4;
6972       if (flag_code == CODE_64BIT && !i.tm.opcode_modifier.no_qsuf)
6973         suffixes |= 1 << 5;
6974
6975       /* For [XYZ]MMWORD operands inspect operand sizes.  While generally
6976          also suitable for AT&T syntax mode, it was requested that this be
6977          restricted to just Intel syntax.  */
6978       if (intel_syntax && is_any_vex_encoding (&i.tm) && !i.broadcast)
6979         {
6980           unsigned int op;
6981
6982           for (op = 0; op < i.tm.operands; ++op)
6983             {
6984               if (is_evex_encoding (&i.tm)
6985                   && !cpu_arch_flags.bitfield.cpuavx512vl)
6986                 {
6987                   if (i.tm.operand_types[op].bitfield.ymmword)
6988                     i.tm.operand_types[op].bitfield.xmmword = 0;
6989                   if (i.tm.operand_types[op].bitfield.zmmword)
6990                     i.tm.operand_types[op].bitfield.ymmword = 0;
6991                   if (!i.tm.opcode_modifier.evex
6992                       || i.tm.opcode_modifier.evex == EVEXDYN)
6993                     i.tm.opcode_modifier.evex = EVEX512;
6994                 }
6995
6996               if (i.tm.operand_types[op].bitfield.xmmword
6997                   + i.tm.operand_types[op].bitfield.ymmword
6998                   + i.tm.operand_types[op].bitfield.zmmword < 2)
6999                 continue;
7000
7001               /* Any properly sized operand disambiguates the insn.  */
7002               if (i.types[op].bitfield.xmmword
7003                   || i.types[op].bitfield.ymmword
7004                   || i.types[op].bitfield.zmmword)
7005                 {
7006                   suffixes &= ~(7 << 6);
7007                   evex = 0;
7008                   break;
7009                 }
7010
7011               if ((i.flags[op] & Operand_Mem)
7012                   && i.tm.operand_types[op].bitfield.unspecified)
7013                 {
7014                   if (i.tm.operand_types[op].bitfield.xmmword)
7015                     suffixes |= 1 << 6;
7016                   if (i.tm.operand_types[op].bitfield.ymmword)
7017                     suffixes |= 1 << 7;
7018                   if (i.tm.operand_types[op].bitfield.zmmword)
7019                     suffixes |= 1 << 8;
7020                   if (is_evex_encoding (&i.tm))
7021                     evex = EVEX512;
7022                 }
7023             }
7024         }
7025
7026       /* Are multiple suffixes / operand sizes allowed?  */
7027       if (suffixes & (suffixes - 1))
7028         {
7029           if (intel_syntax
7030               && (i.tm.opcode_modifier.mnemonicsize != DEFAULTSIZE
7031                   || operand_check == check_error))
7032             {
7033               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
7034               return 0;
7035             }
7036           if (operand_check == check_error)
7037             {
7038               as_bad (_("no instruction mnemonic suffix given and "
7039                         "no register operands; can't size `%s'"), i.tm.name);
7040               return 0;
7041             }
7042           if (operand_check == check_warning)
7043             as_warn (_("%s; using default for `%s'"),
7044                        intel_syntax
7045                        ? _("ambiguous operand size")
7046                        : _("no instruction mnemonic suffix given and "
7047                            "no register operands"),
7048                        i.tm.name);
7049
7050           if (i.tm.opcode_modifier.floatmf)
7051             i.suffix = SHORT_MNEM_SUFFIX;
7052           else if ((i.tm.base_opcode | 8) == 0xfbe
7053                    || (i.tm.base_opcode == 0x63
7054                        && i.tm.cpu_flags.bitfield.cpu64))
7055             /* handled below */;
7056           else if (evex)
7057             i.tm.opcode_modifier.evex = evex;
7058           else if (flag_code == CODE_16BIT)
7059             i.suffix = WORD_MNEM_SUFFIX;
7060           else if (!i.tm.opcode_modifier.no_lsuf)
7061             i.suffix = LONG_MNEM_SUFFIX;
7062           else
7063             i.suffix = QWORD_MNEM_SUFFIX;
7064         }
7065     }
7066
7067   if ((i.tm.base_opcode | 8) == 0xfbe
7068       || (i.tm.base_opcode == 0x63 && i.tm.cpu_flags.bitfield.cpu64))
7069     {
7070       /* In Intel syntax, movsx/movzx must have a "suffix" (checked above).
7071          In AT&T syntax, if there is no suffix (warned about above), the default
7072          will be byte extension.  */
7073       if (i.tm.opcode_modifier.w && i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
7074         i.tm.base_opcode |= 1;
7075
7076       /* For further processing, the suffix should represent the destination
7077          (register).  This is already the case when one was used with
7078          mov[sz][bw]*, but we need to replace it for mov[sz]x, or if there was
7079          no suffix to begin with.  */
7080       if (i.tm.opcode_modifier.w || i.tm.base_opcode == 0x63 || !i.suffix)
7081         {
7082           if (i.types[1].bitfield.word)
7083             i.suffix = WORD_MNEM_SUFFIX;
7084           else if (i.types[1].bitfield.qword)
7085             i.suffix = QWORD_MNEM_SUFFIX;
7086           else
7087             i.suffix = LONG_MNEM_SUFFIX;
7088
7089           i.tm.opcode_modifier.w = 0;
7090         }
7091     }
7092
7093   if (!i.tm.opcode_modifier.modrm && i.reg_operands && i.tm.operands < 3)
7094     i.short_form = (i.tm.operand_types[0].bitfield.class == Reg)
7095                    != (i.tm.operand_types[1].bitfield.class == Reg);
7096
7097   /* Change the opcode based on the operand size given by i.suffix.  */
7098   switch (i.suffix)
7099     {
7100     /* Size floating point instruction.  */
7101     case LONG_MNEM_SUFFIX:
7102       if (i.tm.opcode_modifier.floatmf)
7103         {
7104           i.tm.base_opcode ^= 4;
7105           break;
7106         }
7107     /* fall through */
7108     case WORD_MNEM_SUFFIX:
7109     case QWORD_MNEM_SUFFIX:
7110       /* It's not a byte, select word/dword operation.  */
7111       if (i.tm.opcode_modifier.w)
7112         {
7113           if (i.short_form)
7114             i.tm.base_opcode |= 8;
7115           else
7116             i.tm.base_opcode |= 1;
7117         }
7118     /* fall through */
7119     case SHORT_MNEM_SUFFIX:
7120       /* Now select between word & dword operations via the operand
7121          size prefix, except for instructions that will ignore this
7122          prefix anyway.  */
7123       if (i.suffix != QWORD_MNEM_SUFFIX
7124           && i.tm.opcode_modifier.mnemonicsize != IGNORESIZE
7125           && !i.tm.opcode_modifier.floatmf
7126           && !is_any_vex_encoding (&i.tm)
7127           && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
7128               || (flag_code == CODE_64BIT
7129                   && i.tm.opcode_modifier.jump == JUMP_BYTE)))
7130         {
7131           unsigned int prefix = DATA_PREFIX_OPCODE;
7132
7133           if (i.tm.opcode_modifier.jump == JUMP_BYTE) /* jcxz, loop */
7134             prefix = ADDR_PREFIX_OPCODE;
7135
7136           if (!add_prefix (prefix))
7137             return 0;
7138         }
7139
7140       /* Set mode64 for an operand.  */
7141       if (i.suffix == QWORD_MNEM_SUFFIX
7142           && flag_code == CODE_64BIT
7143           && !i.tm.opcode_modifier.norex64
7144           && !i.tm.opcode_modifier.vexw
7145           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
7146              need rex64. */
7147           && ! (i.operands == 2
7148                 && i.tm.base_opcode == 0x90
7149                 && i.tm.extension_opcode == None
7150                 && i.types[0].bitfield.instance == Accum
7151                 && i.types[0].bitfield.qword
7152                 && i.types[1].bitfield.instance == Accum
7153                 && i.types[1].bitfield.qword))
7154         i.rex |= REX_W;
7155
7156       break;
7157
7158     case 0:
7159       /* Select word/dword/qword operation with explict data sizing prefix
7160          when there are no suitable register operands.  */
7161       if (i.tm.opcode_modifier.w
7162           && (i.prefix[DATA_PREFIX] || (i.prefix[REX_PREFIX] & REX_W))
7163           && (!i.reg_operands
7164               || (i.reg_operands == 1
7165                       /* ShiftCount */
7166                   && (i.tm.operand_types[0].bitfield.instance == RegC
7167                       /* InOutPortReg */
7168                       || i.tm.operand_types[0].bitfield.instance == RegD
7169                       || i.tm.operand_types[1].bitfield.instance == RegD
7170                       /* CRC32 */
7171                       || is_crc32))))
7172         i.tm.base_opcode |= 1;
7173       break;
7174     }
7175
7176   if (i.tm.opcode_modifier.addrprefixopreg)
7177     {
7178       gas_assert (!i.suffix);
7179       gas_assert (i.reg_operands);
7180
7181       if (i.tm.operand_types[0].bitfield.instance == Accum
7182           || i.operands == 1)
7183         {
7184           /* The address size override prefix changes the size of the
7185              first operand.  */
7186           if (flag_code == CODE_64BIT
7187               && i.op[0].regs->reg_type.bitfield.word)
7188             {
7189               as_bad (_("16-bit addressing unavailable for `%s'"),
7190                       i.tm.name);
7191               return 0;
7192             }
7193
7194           if ((flag_code == CODE_32BIT
7195                ? i.op[0].regs->reg_type.bitfield.word
7196                : i.op[0].regs->reg_type.bitfield.dword)
7197               && !add_prefix (ADDR_PREFIX_OPCODE))
7198             return 0;
7199         }
7200       else
7201         {
7202           /* Check invalid register operand when the address size override
7203              prefix changes the size of register operands.  */
7204           unsigned int op;
7205           enum { need_word, need_dword, need_qword } need;
7206
7207           /* Check the register operand for the address size prefix if
7208              the memory operand has no real registers, like symbol, DISP
7209              or symbol(%rip).  */
7210           if (i.mem_operands == 1
7211               && i.reg_operands == 1
7212               && i.operands == 2
7213               && i.types[1].bitfield.class == Reg
7214               && (flag_code == CODE_32BIT
7215                   ? i.op[1].regs->reg_type.bitfield.word
7216                   : i.op[1].regs->reg_type.bitfield.dword)
7217               && ((i.base_reg == NULL && i.index_reg == NULL)
7218                   || (i.base_reg
7219                       && i.base_reg->reg_num == RegIP
7220                       && i.base_reg->reg_type.bitfield.qword))
7221               && !add_prefix (ADDR_PREFIX_OPCODE))
7222             return 0;
7223
7224           if (flag_code == CODE_32BIT)
7225             need = i.prefix[ADDR_PREFIX] ? need_word : need_dword;
7226           else if (i.prefix[ADDR_PREFIX])
7227             need = need_dword;
7228           else
7229             need = flag_code == CODE_64BIT ? need_qword : need_word;
7230
7231           for (op = 0; op < i.operands; op++)
7232             {
7233               if (i.types[op].bitfield.class != Reg)
7234                 continue;
7235
7236               switch (need)
7237                 {
7238                 case need_word:
7239                   if (i.op[op].regs->reg_type.bitfield.word)
7240                     continue;
7241                   break;
7242                 case need_dword:
7243                   if (i.op[op].regs->reg_type.bitfield.dword)
7244                     continue;
7245                   break;
7246                 case need_qword:
7247                   if (i.op[op].regs->reg_type.bitfield.qword)
7248                     continue;
7249                   break;
7250                 }
7251
7252               as_bad (_("invalid register operand size for `%s'"),
7253                       i.tm.name);
7254               return 0;
7255             }
7256         }
7257     }
7258
7259   return 1;
7260 }
7261
7262 static int
7263 check_byte_reg (void)
7264 {
7265   int op;
7266
7267   for (op = i.operands; --op >= 0;)
7268     {
7269       /* Skip non-register operands. */
7270       if (i.types[op].bitfield.class != Reg)
7271         continue;
7272
7273       /* If this is an eight bit register, it's OK.  If it's the 16 or
7274          32 bit version of an eight bit register, we will just use the
7275          low portion, and that's OK too.  */
7276       if (i.types[op].bitfield.byte)
7277         continue;
7278
7279       /* I/O port address operands are OK too.  */
7280       if (i.tm.operand_types[op].bitfield.instance == RegD
7281           && i.tm.operand_types[op].bitfield.word)
7282         continue;
7283
7284       /* crc32 only wants its source operand checked here.  */
7285       if (i.tm.base_opcode == 0xf38f0
7286           && i.tm.opcode_modifier.opcodeprefix == PREFIX_0XF2
7287           && op != 0)
7288         continue;
7289
7290       /* Any other register is bad.  */
7291       as_bad (_("`%s%s' not allowed with `%s%c'"),
7292               register_prefix, i.op[op].regs->reg_name,
7293               i.tm.name, i.suffix);
7294       return 0;
7295     }
7296   return 1;
7297 }
7298
7299 static int
7300 check_long_reg (void)
7301 {
7302   int op;
7303
7304   for (op = i.operands; --op >= 0;)
7305     /* Skip non-register operands. */
7306     if (i.types[op].bitfield.class != Reg)
7307       continue;
7308     /* Reject eight bit registers, except where the template requires
7309        them. (eg. movzb)  */
7310     else if (i.types[op].bitfield.byte
7311              && (i.tm.operand_types[op].bitfield.class == Reg
7312                  || i.tm.operand_types[op].bitfield.instance == Accum)
7313              && (i.tm.operand_types[op].bitfield.word
7314                  || i.tm.operand_types[op].bitfield.dword))
7315       {
7316         as_bad (_("`%s%s' not allowed with `%s%c'"),
7317                 register_prefix,
7318                 i.op[op].regs->reg_name,
7319                 i.tm.name,
7320                 i.suffix);
7321         return 0;
7322       }
7323     /* Error if the e prefix on a general reg is missing.  */
7324     else if (i.types[op].bitfield.word
7325              && (i.tm.operand_types[op].bitfield.class == Reg
7326                  || i.tm.operand_types[op].bitfield.instance == Accum)
7327              && i.tm.operand_types[op].bitfield.dword)
7328       {
7329         as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7330                 register_prefix, i.op[op].regs->reg_name,
7331                 i.suffix);
7332         return 0;
7333       }
7334     /* Warn if the r prefix on a general reg is present.  */
7335     else if (i.types[op].bitfield.qword
7336              && (i.tm.operand_types[op].bitfield.class == Reg
7337                  || i.tm.operand_types[op].bitfield.instance == Accum)
7338              && i.tm.operand_types[op].bitfield.dword)
7339       {
7340         if (intel_syntax
7341             && i.tm.opcode_modifier.toqword
7342             && i.types[0].bitfield.class != RegSIMD)
7343           {
7344             /* Convert to QWORD.  We want REX byte. */
7345             i.suffix = QWORD_MNEM_SUFFIX;
7346           }
7347         else
7348           {
7349             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7350                     register_prefix, i.op[op].regs->reg_name,
7351                     i.suffix);
7352             return 0;
7353           }
7354       }
7355   return 1;
7356 }
7357
7358 static int
7359 check_qword_reg (void)
7360 {
7361   int op;
7362
7363   for (op = i.operands; --op >= 0; )
7364     /* Skip non-register operands. */
7365     if (i.types[op].bitfield.class != Reg)
7366       continue;
7367     /* Reject eight bit registers, except where the template requires
7368        them. (eg. movzb)  */
7369     else if (i.types[op].bitfield.byte
7370              && (i.tm.operand_types[op].bitfield.class == Reg
7371                  || i.tm.operand_types[op].bitfield.instance == Accum)
7372              && (i.tm.operand_types[op].bitfield.word
7373                  || i.tm.operand_types[op].bitfield.dword))
7374       {
7375         as_bad (_("`%s%s' not allowed with `%s%c'"),
7376                 register_prefix,
7377                 i.op[op].regs->reg_name,
7378                 i.tm.name,
7379                 i.suffix);
7380         return 0;
7381       }
7382     /* Warn if the r prefix on a general reg is missing.  */
7383     else if ((i.types[op].bitfield.word
7384               || i.types[op].bitfield.dword)
7385              && (i.tm.operand_types[op].bitfield.class == Reg
7386                  || i.tm.operand_types[op].bitfield.instance == Accum)
7387              && i.tm.operand_types[op].bitfield.qword)
7388       {
7389         /* Prohibit these changes in the 64bit mode, since the
7390            lowering is more complicated.  */
7391         if (intel_syntax
7392             && i.tm.opcode_modifier.todword
7393             && i.types[0].bitfield.class != RegSIMD)
7394           {
7395             /* Convert to DWORD.  We don't want REX byte. */
7396             i.suffix = LONG_MNEM_SUFFIX;
7397           }
7398         else
7399           {
7400             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7401                     register_prefix, i.op[op].regs->reg_name,
7402                     i.suffix);
7403             return 0;
7404           }
7405       }
7406   return 1;
7407 }
7408
7409 static int
7410 check_word_reg (void)
7411 {
7412   int op;
7413   for (op = i.operands; --op >= 0;)
7414     /* Skip non-register operands. */
7415     if (i.types[op].bitfield.class != Reg)
7416       continue;
7417     /* Reject eight bit registers, except where the template requires
7418        them. (eg. movzb)  */
7419     else if (i.types[op].bitfield.byte
7420              && (i.tm.operand_types[op].bitfield.class == Reg
7421                  || i.tm.operand_types[op].bitfield.instance == Accum)
7422              && (i.tm.operand_types[op].bitfield.word
7423                  || i.tm.operand_types[op].bitfield.dword))
7424       {
7425         as_bad (_("`%s%s' not allowed with `%s%c'"),
7426                 register_prefix,
7427                 i.op[op].regs->reg_name,
7428                 i.tm.name,
7429                 i.suffix);
7430         return 0;
7431       }
7432     /* Error if the e or r prefix on a general reg is present.  */
7433     else if ((i.types[op].bitfield.dword
7434                  || i.types[op].bitfield.qword)
7435              && (i.tm.operand_types[op].bitfield.class == Reg
7436                  || i.tm.operand_types[op].bitfield.instance == Accum)
7437              && i.tm.operand_types[op].bitfield.word)
7438       {
7439         as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
7440                 register_prefix, i.op[op].regs->reg_name,
7441                 i.suffix);
7442         return 0;
7443       }
7444   return 1;
7445 }
7446
7447 static int
7448 update_imm (unsigned int j)
7449 {
7450   i386_operand_type overlap = i.types[j];
7451   if ((overlap.bitfield.imm8
7452        || overlap.bitfield.imm8s
7453        || overlap.bitfield.imm16
7454        || overlap.bitfield.imm32
7455        || overlap.bitfield.imm32s
7456        || overlap.bitfield.imm64)
7457       && !operand_type_equal (&overlap, &imm8)
7458       && !operand_type_equal (&overlap, &imm8s)
7459       && !operand_type_equal (&overlap, &imm16)
7460       && !operand_type_equal (&overlap, &imm32)
7461       && !operand_type_equal (&overlap, &imm32s)
7462       && !operand_type_equal (&overlap, &imm64))
7463     {
7464       if (i.suffix)
7465         {
7466           i386_operand_type temp;
7467
7468           operand_type_set (&temp, 0);
7469           if (i.suffix == BYTE_MNEM_SUFFIX)
7470             {
7471               temp.bitfield.imm8 = overlap.bitfield.imm8;
7472               temp.bitfield.imm8s = overlap.bitfield.imm8s;
7473             }
7474           else if (i.suffix == WORD_MNEM_SUFFIX)
7475             temp.bitfield.imm16 = overlap.bitfield.imm16;
7476           else if (i.suffix == QWORD_MNEM_SUFFIX)
7477             {
7478               temp.bitfield.imm64 = overlap.bitfield.imm64;
7479               temp.bitfield.imm32s = overlap.bitfield.imm32s;
7480             }
7481           else
7482             temp.bitfield.imm32 = overlap.bitfield.imm32;
7483           overlap = temp;
7484         }
7485       else if (operand_type_equal (&overlap, &imm16_32_32s)
7486                || operand_type_equal (&overlap, &imm16_32)
7487                || operand_type_equal (&overlap, &imm16_32s))
7488         {
7489           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
7490             overlap = imm16;
7491           else
7492             overlap = imm32s;
7493         }
7494       else if (i.prefix[REX_PREFIX] & REX_W)
7495         overlap = operand_type_and (overlap, imm32s);
7496       else if (i.prefix[DATA_PREFIX])
7497         overlap = operand_type_and (overlap,
7498                                     flag_code != CODE_16BIT ? imm16 : imm32);
7499       if (!operand_type_equal (&overlap, &imm8)
7500           && !operand_type_equal (&overlap, &imm8s)
7501           && !operand_type_equal (&overlap, &imm16)
7502           && !operand_type_equal (&overlap, &imm32)
7503           && !operand_type_equal (&overlap, &imm32s)
7504           && !operand_type_equal (&overlap, &imm64))
7505         {
7506           as_bad (_("no instruction mnemonic suffix given; "
7507                     "can't determine immediate size"));
7508           return 0;
7509         }
7510     }
7511   i.types[j] = overlap;
7512
7513   return 1;
7514 }
7515
7516 static int
7517 finalize_imm (void)
7518 {
7519   unsigned int j, n;
7520
7521   /* Update the first 2 immediate operands.  */
7522   n = i.operands > 2 ? 2 : i.operands;
7523   if (n)
7524     {
7525       for (j = 0; j < n; j++)
7526         if (update_imm (j) == 0)
7527           return 0;
7528
7529       /* The 3rd operand can't be immediate operand.  */
7530       gas_assert (operand_type_check (i.types[2], imm) == 0);
7531     }
7532
7533   return 1;
7534 }
7535
7536 static int
7537 process_operands (void)
7538 {
7539   /* Default segment register this instruction will use for memory
7540      accesses.  0 means unknown.  This is only for optimizing out
7541      unnecessary segment overrides.  */
7542   const seg_entry *default_seg = 0;
7543
7544   if (i.tm.opcode_modifier.sse2avx)
7545     {
7546       /* Legacy encoded insns allow explicit REX prefixes, so these prefixes
7547          need converting.  */
7548       i.rex |= i.prefix[REX_PREFIX] & (REX_W | REX_R | REX_X | REX_B);
7549       i.prefix[REX_PREFIX] = 0;
7550       i.rex_encoding = 0;
7551     }
7552   /* ImmExt should be processed after SSE2AVX.  */
7553   else if (i.tm.opcode_modifier.immext)
7554     process_immext ();
7555
7556   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
7557     {
7558       unsigned int dupl = i.operands;
7559       unsigned int dest = dupl - 1;
7560       unsigned int j;
7561
7562       /* The destination must be an xmm register.  */
7563       gas_assert (i.reg_operands
7564                   && MAX_OPERANDS > dupl
7565                   && operand_type_equal (&i.types[dest], &regxmm));
7566
7567       if (i.tm.operand_types[0].bitfield.instance == Accum
7568           && i.tm.operand_types[0].bitfield.xmmword)
7569         {
7570           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
7571             {
7572               /* Keep xmm0 for instructions with VEX prefix and 3
7573                  sources.  */
7574               i.tm.operand_types[0].bitfield.instance = InstanceNone;
7575               i.tm.operand_types[0].bitfield.class = RegSIMD;
7576               goto duplicate;
7577             }
7578           else
7579             {
7580               /* We remove the first xmm0 and keep the number of
7581                  operands unchanged, which in fact duplicates the
7582                  destination.  */
7583               for (j = 1; j < i.operands; j++)
7584                 {
7585                   i.op[j - 1] = i.op[j];
7586                   i.types[j - 1] = i.types[j];
7587                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
7588                   i.flags[j - 1] = i.flags[j];
7589                 }
7590             }
7591         }
7592       else if (i.tm.opcode_modifier.implicit1stxmm0)
7593         {
7594           gas_assert ((MAX_OPERANDS - 1) > dupl
7595                       && (i.tm.opcode_modifier.vexsources
7596                           == VEX3SOURCES));
7597
7598           /* Add the implicit xmm0 for instructions with VEX prefix
7599              and 3 sources.  */
7600           for (j = i.operands; j > 0; j--)
7601             {
7602               i.op[j] = i.op[j - 1];
7603               i.types[j] = i.types[j - 1];
7604               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
7605               i.flags[j] = i.flags[j - 1];
7606             }
7607           i.op[0].regs
7608             = (const reg_entry *) str_hash_find (reg_hash, "xmm0");
7609           i.types[0] = regxmm;
7610           i.tm.operand_types[0] = regxmm;
7611
7612           i.operands += 2;
7613           i.reg_operands += 2;
7614           i.tm.operands += 2;
7615
7616           dupl++;
7617           dest++;
7618           i.op[dupl] = i.op[dest];
7619           i.types[dupl] = i.types[dest];
7620           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
7621           i.flags[dupl] = i.flags[dest];
7622         }
7623       else
7624         {
7625         duplicate:
7626           i.operands++;
7627           i.reg_operands++;
7628           i.tm.operands++;
7629
7630           i.op[dupl] = i.op[dest];
7631           i.types[dupl] = i.types[dest];
7632           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
7633           i.flags[dupl] = i.flags[dest];
7634         }
7635
7636        if (i.tm.opcode_modifier.immext)
7637          process_immext ();
7638     }
7639   else if (i.tm.operand_types[0].bitfield.instance == Accum
7640            && i.tm.operand_types[0].bitfield.xmmword)
7641     {
7642       unsigned int j;
7643
7644       for (j = 1; j < i.operands; j++)
7645         {
7646           i.op[j - 1] = i.op[j];
7647           i.types[j - 1] = i.types[j];
7648
7649           /* We need to adjust fields in i.tm since they are used by
7650              build_modrm_byte.  */
7651           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
7652
7653           i.flags[j - 1] = i.flags[j];
7654         }
7655
7656       i.operands--;
7657       i.reg_operands--;
7658       i.tm.operands--;
7659     }
7660   else if (i.tm.opcode_modifier.implicitquadgroup)
7661     {
7662       unsigned int regnum, first_reg_in_group, last_reg_in_group;
7663
7664       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
7665       gas_assert (i.operands >= 2 && i.types[1].bitfield.class == RegSIMD);
7666       regnum = register_number (i.op[1].regs);
7667       first_reg_in_group = regnum & ~3;
7668       last_reg_in_group = first_reg_in_group + 3;
7669       if (regnum != first_reg_in_group)
7670         as_warn (_("source register `%s%s' implicitly denotes"
7671                    " `%s%.3s%u' to `%s%.3s%u' source group in `%s'"),
7672                  register_prefix, i.op[1].regs->reg_name,
7673                  register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
7674                  register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
7675                  i.tm.name);
7676     }
7677   else if (i.tm.opcode_modifier.regkludge)
7678     {
7679       /* The imul $imm, %reg instruction is converted into
7680          imul $imm, %reg, %reg, and the clr %reg instruction
7681          is converted into xor %reg, %reg.  */
7682
7683       unsigned int first_reg_op;
7684
7685       if (operand_type_check (i.types[0], reg))
7686         first_reg_op = 0;
7687       else
7688         first_reg_op = 1;
7689       /* Pretend we saw the extra register operand.  */
7690       gas_assert (i.reg_operands == 1
7691                   && i.op[first_reg_op + 1].regs == 0);
7692       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
7693       i.types[first_reg_op + 1] = i.types[first_reg_op];
7694       i.operands++;
7695       i.reg_operands++;
7696     }
7697
7698   if (i.tm.opcode_modifier.modrm)
7699     {
7700       /* The opcode is completed (modulo i.tm.extension_opcode which
7701          must be put into the modrm byte).  Now, we make the modrm and
7702          index base bytes based on all the info we've collected.  */
7703
7704       default_seg = build_modrm_byte ();
7705     }
7706   else if (i.types[0].bitfield.class == SReg)
7707     {
7708       if (flag_code != CODE_64BIT
7709           ? i.tm.base_opcode == POP_SEG_SHORT
7710             && i.op[0].regs->reg_num == 1
7711           : (i.tm.base_opcode | 1) == POP_SEG386_SHORT
7712             && i.op[0].regs->reg_num < 4)
7713         {
7714           as_bad (_("you can't `%s %s%s'"),
7715                   i.tm.name, register_prefix, i.op[0].regs->reg_name);
7716           return 0;
7717         }
7718       if ( i.op[0].regs->reg_num > 3 && i.tm.opcode_length == 1 )
7719         {
7720           i.tm.base_opcode ^= POP_SEG_SHORT ^ POP_SEG386_SHORT;
7721           i.tm.opcode_length = 2;
7722         }
7723       i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
7724     }
7725   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
7726     {
7727       default_seg = &ds;
7728     }
7729   else if (i.tm.opcode_modifier.isstring)
7730     {
7731       /* For the string instructions that allow a segment override
7732          on one of their operands, the default segment is ds.  */
7733       default_seg = &ds;
7734     }
7735   else if (i.short_form)
7736     {
7737       /* The register or float register operand is in operand
7738          0 or 1.  */
7739       unsigned int op = i.tm.operand_types[0].bitfield.class != Reg;
7740
7741       /* Register goes in low 3 bits of opcode.  */
7742       i.tm.base_opcode |= i.op[op].regs->reg_num;
7743       if ((i.op[op].regs->reg_flags & RegRex) != 0)
7744         i.rex |= REX_B;
7745       if (!quiet_warnings && i.tm.opcode_modifier.ugh)
7746         {
7747           /* Warn about some common errors, but press on regardless.
7748              The first case can be generated by gcc (<= 2.8.1).  */
7749           if (i.operands == 2)
7750             {
7751               /* Reversed arguments on faddp, fsubp, etc.  */
7752               as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
7753                        register_prefix, i.op[!intel_syntax].regs->reg_name,
7754                        register_prefix, i.op[intel_syntax].regs->reg_name);
7755             }
7756           else
7757             {
7758               /* Extraneous `l' suffix on fp insn.  */
7759               as_warn (_("translating to `%s %s%s'"), i.tm.name,
7760                        register_prefix, i.op[0].regs->reg_name);
7761             }
7762         }
7763     }
7764
7765   if ((i.seg[0] || i.prefix[SEG_PREFIX])
7766       && i.tm.base_opcode == 0x8d /* lea */
7767       && !is_any_vex_encoding(&i.tm))
7768     {
7769       if (!quiet_warnings)
7770         as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
7771       if (optimize)
7772         {
7773           i.seg[0] = NULL;
7774           i.prefix[SEG_PREFIX] = 0;
7775         }
7776     }
7777
7778   /* If a segment was explicitly specified, and the specified segment
7779      is neither the default nor the one already recorded from a prefix,
7780      use an opcode prefix to select it.  If we never figured out what
7781      the default segment is, then default_seg will be zero at this
7782      point, and the specified segment prefix will always be used.  */
7783   if (i.seg[0]
7784       && i.seg[0] != default_seg
7785       && i.seg[0]->seg_prefix != i.prefix[SEG_PREFIX])
7786     {
7787       if (!add_prefix (i.seg[0]->seg_prefix))
7788         return 0;
7789     }
7790   return 1;
7791 }
7792
7793 static INLINE void set_rex_vrex (const reg_entry *r, unsigned int rex_bit,
7794                                  bfd_boolean do_sse2avx)
7795 {
7796   if (r->reg_flags & RegRex)
7797     {
7798       if (i.rex & rex_bit)
7799         as_bad (_("same type of prefix used twice"));
7800       i.rex |= rex_bit;
7801     }
7802   else if (do_sse2avx && (i.rex & rex_bit) && i.vex.register_specifier)
7803     {
7804       gas_assert (i.vex.register_specifier == r);
7805       i.vex.register_specifier += 8;
7806     }
7807
7808   if (r->reg_flags & RegVRex)
7809     i.vrex |= rex_bit;
7810 }
7811
7812 static const seg_entry *
7813 build_modrm_byte (void)
7814 {
7815   const seg_entry *default_seg = 0;
7816   unsigned int source, dest;
7817   int vex_3_sources;
7818
7819   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
7820   if (vex_3_sources)
7821     {
7822       unsigned int nds, reg_slot;
7823       expressionS *exp;
7824
7825       dest = i.operands - 1;
7826       nds = dest - 1;
7827
7828       /* There are 2 kinds of instructions:
7829          1. 5 operands: 4 register operands or 3 register operands
7830          plus 1 memory operand plus one Imm4 operand, VexXDS, and
7831          VexW0 or VexW1.  The destination must be either XMM, YMM or
7832          ZMM register.
7833          2. 4 operands: 4 register operands or 3 register operands
7834          plus 1 memory operand, with VexXDS.  */
7835       gas_assert ((i.reg_operands == 4
7836                    || (i.reg_operands == 3 && i.mem_operands == 1))
7837                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
7838                   && i.tm.opcode_modifier.vexw
7839                   && i.tm.operand_types[dest].bitfield.class == RegSIMD);
7840
7841       /* If VexW1 is set, the first non-immediate operand is the source and
7842          the second non-immediate one is encoded in the immediate operand.  */
7843       if (i.tm.opcode_modifier.vexw == VEXW1)
7844         {
7845           source = i.imm_operands;
7846           reg_slot = i.imm_operands + 1;
7847         }
7848       else
7849         {
7850           source = i.imm_operands + 1;
7851           reg_slot = i.imm_operands;
7852         }
7853
7854       if (i.imm_operands == 0)
7855         {
7856           /* When there is no immediate operand, generate an 8bit
7857              immediate operand to encode the first operand.  */
7858           exp = &im_expressions[i.imm_operands++];
7859           i.op[i.operands].imms = exp;
7860           i.types[i.operands] = imm8;
7861           i.operands++;
7862
7863           gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD);
7864           exp->X_op = O_constant;
7865           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
7866           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7867         }
7868       else
7869         {
7870           gas_assert (i.imm_operands == 1);
7871           gas_assert (fits_in_imm4 (i.op[0].imms->X_add_number));
7872           gas_assert (!i.tm.opcode_modifier.immext);
7873
7874           /* Turn on Imm8 again so that output_imm will generate it.  */
7875           i.types[0].bitfield.imm8 = 1;
7876
7877           gas_assert (i.tm.operand_types[reg_slot].bitfield.class == RegSIMD);
7878           i.op[0].imms->X_add_number
7879               |= register_number (i.op[reg_slot].regs) << 4;
7880           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7881         }
7882
7883       gas_assert (i.tm.operand_types[nds].bitfield.class == RegSIMD);
7884       i.vex.register_specifier = i.op[nds].regs;
7885     }
7886   else
7887     source = dest = 0;
7888
7889   /* i.reg_operands MUST be the number of real register operands;
7890      implicit registers do not count.  If there are 3 register
7891      operands, it must be a instruction with VexNDS.  For a
7892      instruction with VexNDD, the destination register is encoded
7893      in VEX prefix.  If there are 4 register operands, it must be
7894      a instruction with VEX prefix and 3 sources.  */
7895   if (i.mem_operands == 0
7896       && ((i.reg_operands == 2
7897            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
7898           || (i.reg_operands == 3
7899               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
7900           || (i.reg_operands == 4 && vex_3_sources)))
7901     {
7902       switch (i.operands)
7903         {
7904         case 2:
7905           source = 0;
7906           break;
7907         case 3:
7908           /* When there are 3 operands, one of them may be immediate,
7909              which may be the first or the last operand.  Otherwise,
7910              the first operand must be shift count register (cl) or it
7911              is an instruction with VexNDS. */
7912           gas_assert (i.imm_operands == 1
7913                       || (i.imm_operands == 0
7914                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
7915                               || (i.types[0].bitfield.instance == RegC
7916                                   && i.types[0].bitfield.byte))));
7917           if (operand_type_check (i.types[0], imm)
7918               || (i.types[0].bitfield.instance == RegC
7919                   && i.types[0].bitfield.byte))
7920             source = 1;
7921           else
7922             source = 0;
7923           break;
7924         case 4:
7925           /* When there are 4 operands, the first two must be 8bit
7926              immediate operands. The source operand will be the 3rd
7927              one.
7928
7929              For instructions with VexNDS, if the first operand
7930              an imm8, the source operand is the 2nd one.  If the last
7931              operand is imm8, the source operand is the first one.  */
7932           gas_assert ((i.imm_operands == 2
7933                        && i.types[0].bitfield.imm8
7934                        && i.types[1].bitfield.imm8)
7935                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
7936                           && i.imm_operands == 1
7937                           && (i.types[0].bitfield.imm8
7938                               || i.types[i.operands - 1].bitfield.imm8
7939                               || i.rounding)));
7940           if (i.imm_operands == 2)
7941             source = 2;
7942           else
7943             {
7944               if (i.types[0].bitfield.imm8)
7945                 source = 1;
7946               else
7947                 source = 0;
7948             }
7949           break;
7950         case 5:
7951           if (is_evex_encoding (&i.tm))
7952             {
7953               /* For EVEX instructions, when there are 5 operands, the
7954                  first one must be immediate operand.  If the second one
7955                  is immediate operand, the source operand is the 3th
7956                  one.  If the last one is immediate operand, the source
7957                  operand is the 2nd one.  */
7958               gas_assert (i.imm_operands == 2
7959                           && i.tm.opcode_modifier.sae
7960                           && operand_type_check (i.types[0], imm));
7961               if (operand_type_check (i.types[1], imm))
7962                 source = 2;
7963               else if (operand_type_check (i.types[4], imm))
7964                 source = 1;
7965               else
7966                 abort ();
7967             }
7968           break;
7969         default:
7970           abort ();
7971         }
7972
7973       if (!vex_3_sources)
7974         {
7975           dest = source + 1;
7976
7977           /* RC/SAE operand could be between DEST and SRC.  That happens
7978              when one operand is GPR and the other one is XMM/YMM/ZMM
7979              register.  */
7980           if (i.rounding && i.rounding->operand == (int) dest)
7981             dest++;
7982
7983           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7984             {
7985               /* For instructions with VexNDS, the register-only source
7986                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
7987                  register.  It is encoded in VEX prefix.  */
7988
7989               i386_operand_type op;
7990               unsigned int vvvv;
7991
7992               /* Swap two source operands if needed.  */
7993               if (i.tm.opcode_modifier.swapsources)
7994                 {
7995                   vvvv = source;
7996                   source = dest;
7997                 }
7998               else
7999                 vvvv = dest;
8000
8001               op = i.tm.operand_types[vvvv];
8002               if ((dest + 1) >= i.operands
8003                   || ((op.bitfield.class != Reg
8004                        || (!op.bitfield.dword && !op.bitfield.qword))
8005                       && op.bitfield.class != RegSIMD
8006                       && !operand_type_equal (&op, &regmask)))
8007                 abort ();
8008               i.vex.register_specifier = i.op[vvvv].regs;
8009               dest++;
8010             }
8011         }
8012
8013       i.rm.mode = 3;
8014       /* One of the register operands will be encoded in the i.rm.reg
8015          field, the other in the combined i.rm.mode and i.rm.regmem
8016          fields.  If no form of this instruction supports a memory
8017          destination operand, then we assume the source operand may
8018          sometimes be a memory operand and so we need to store the
8019          destination in the i.rm.reg field.  */
8020       if (!i.tm.opcode_modifier.regmem
8021           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
8022         {
8023           i.rm.reg = i.op[dest].regs->reg_num;
8024           i.rm.regmem = i.op[source].regs->reg_num;
8025           set_rex_vrex (i.op[dest].regs, REX_R, i.tm.opcode_modifier.sse2avx);
8026           set_rex_vrex (i.op[source].regs, REX_B, FALSE);
8027         }
8028       else
8029         {
8030           i.rm.reg = i.op[source].regs->reg_num;
8031           i.rm.regmem = i.op[dest].regs->reg_num;
8032           set_rex_vrex (i.op[dest].regs, REX_B, i.tm.opcode_modifier.sse2avx);
8033           set_rex_vrex (i.op[source].regs, REX_R, FALSE);
8034         }
8035       if (flag_code != CODE_64BIT && (i.rex & REX_R))
8036         {
8037           if (i.types[!i.tm.opcode_modifier.regmem].bitfield.class != RegCR)
8038             abort ();
8039           i.rex &= ~REX_R;
8040           add_prefix (LOCK_PREFIX_OPCODE);
8041         }
8042     }
8043   else
8044     {                   /* If it's not 2 reg operands...  */
8045       unsigned int mem;
8046
8047       if (i.mem_operands)
8048         {
8049           unsigned int fake_zero_displacement = 0;
8050           unsigned int op;
8051
8052           for (op = 0; op < i.operands; op++)
8053             if (i.flags[op] & Operand_Mem)
8054               break;
8055           gas_assert (op < i.operands);
8056
8057           if (i.tm.opcode_modifier.sib)
8058             {
8059               /* The index register of VSIB shouldn't be RegIZ.  */
8060               if (i.tm.opcode_modifier.sib != SIBMEM
8061                   && i.index_reg->reg_num == RegIZ)
8062                 abort ();
8063
8064               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8065               if (!i.base_reg)
8066                 {
8067                   i.sib.base = NO_BASE_REGISTER;
8068                   i.sib.scale = i.log2_scale_factor;
8069                   i.types[op].bitfield.disp8 = 0;
8070                   i.types[op].bitfield.disp16 = 0;
8071                   i.types[op].bitfield.disp64 = 0;
8072                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
8073                     {
8074                       /* Must be 32 bit */
8075                       i.types[op].bitfield.disp32 = 1;
8076                       i.types[op].bitfield.disp32s = 0;
8077                     }
8078                   else
8079                     {
8080                       i.types[op].bitfield.disp32 = 0;
8081                       i.types[op].bitfield.disp32s = 1;
8082                     }
8083                 }
8084
8085               /* Since the mandatory SIB always has index register, so
8086                  the code logic remains unchanged. The non-mandatory SIB
8087                  without index register is allowed and will be handled
8088                  later.  */
8089               if (i.index_reg)
8090                 {
8091                   if (i.index_reg->reg_num == RegIZ)
8092                     i.sib.index = NO_INDEX_REGISTER;
8093                   else
8094                     i.sib.index = i.index_reg->reg_num;
8095                   set_rex_vrex (i.index_reg, REX_X, FALSE);
8096                 }
8097             }
8098
8099           default_seg = &ds;
8100
8101           if (i.base_reg == 0)
8102             {
8103               i.rm.mode = 0;
8104               if (!i.disp_operands)
8105                 fake_zero_displacement = 1;
8106               if (i.index_reg == 0)
8107                 {
8108                   i386_operand_type newdisp;
8109
8110                   /* Both check for VSIB and mandatory non-vector SIB. */
8111                   gas_assert (!i.tm.opcode_modifier.sib
8112                               || i.tm.opcode_modifier.sib == SIBMEM);
8113                   /* Operand is just <disp>  */
8114                   if (flag_code == CODE_64BIT)
8115                     {
8116                       /* 64bit mode overwrites the 32bit absolute
8117                          addressing by RIP relative addressing and
8118                          absolute addressing is encoded by one of the
8119                          redundant SIB forms.  */
8120                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8121                       i.sib.base = NO_BASE_REGISTER;
8122                       i.sib.index = NO_INDEX_REGISTER;
8123                       newdisp = (!i.prefix[ADDR_PREFIX] ? disp32s : disp32);
8124                     }
8125                   else if ((flag_code == CODE_16BIT)
8126                            ^ (i.prefix[ADDR_PREFIX] != 0))
8127                     {
8128                       i.rm.regmem = NO_BASE_REGISTER_16;
8129                       newdisp = disp16;
8130                     }
8131                   else
8132                     {
8133                       i.rm.regmem = NO_BASE_REGISTER;
8134                       newdisp = disp32;
8135                     }
8136                   i.types[op] = operand_type_and_not (i.types[op], anydisp);
8137                   i.types[op] = operand_type_or (i.types[op], newdisp);
8138                 }
8139               else if (!i.tm.opcode_modifier.sib)
8140                 {
8141                   /* !i.base_reg && i.index_reg  */
8142                   if (i.index_reg->reg_num == RegIZ)
8143                     i.sib.index = NO_INDEX_REGISTER;
8144                   else
8145                     i.sib.index = i.index_reg->reg_num;
8146                   i.sib.base = NO_BASE_REGISTER;
8147                   i.sib.scale = i.log2_scale_factor;
8148                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8149                   i.types[op].bitfield.disp8 = 0;
8150                   i.types[op].bitfield.disp16 = 0;
8151                   i.types[op].bitfield.disp64 = 0;
8152                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
8153                     {
8154                       /* Must be 32 bit */
8155                       i.types[op].bitfield.disp32 = 1;
8156                       i.types[op].bitfield.disp32s = 0;
8157                     }
8158                   else
8159                     {
8160                       i.types[op].bitfield.disp32 = 0;
8161                       i.types[op].bitfield.disp32s = 1;
8162                     }
8163                   if ((i.index_reg->reg_flags & RegRex) != 0)
8164                     i.rex |= REX_X;
8165                 }
8166             }
8167           /* RIP addressing for 64bit mode.  */
8168           else if (i.base_reg->reg_num == RegIP)
8169             {
8170               gas_assert (!i.tm.opcode_modifier.sib);
8171               i.rm.regmem = NO_BASE_REGISTER;
8172               i.types[op].bitfield.disp8 = 0;
8173               i.types[op].bitfield.disp16 = 0;
8174               i.types[op].bitfield.disp32 = 0;
8175               i.types[op].bitfield.disp32s = 1;
8176               i.types[op].bitfield.disp64 = 0;
8177               i.flags[op] |= Operand_PCrel;
8178               if (! i.disp_operands)
8179                 fake_zero_displacement = 1;
8180             }
8181           else if (i.base_reg->reg_type.bitfield.word)
8182             {
8183               gas_assert (!i.tm.opcode_modifier.sib);
8184               switch (i.base_reg->reg_num)
8185                 {
8186                 case 3: /* (%bx)  */
8187                   if (i.index_reg == 0)
8188                     i.rm.regmem = 7;
8189                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
8190                     i.rm.regmem = i.index_reg->reg_num - 6;
8191                   break;
8192                 case 5: /* (%bp)  */
8193                   default_seg = &ss;
8194                   if (i.index_reg == 0)
8195                     {
8196                       i.rm.regmem = 6;
8197                       if (operand_type_check (i.types[op], disp) == 0)
8198                         {
8199                           /* fake (%bp) into 0(%bp)  */
8200                           if (i.disp_encoding == disp_encoding_16bit)
8201                             i.types[op].bitfield.disp16 = 1;
8202                           else
8203                             i.types[op].bitfield.disp8 = 1;
8204                           fake_zero_displacement = 1;
8205                         }
8206                     }
8207                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
8208                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
8209                   break;
8210                 default: /* (%si) -> 4 or (%di) -> 5  */
8211                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
8212                 }
8213               if (!fake_zero_displacement
8214                   && !i.disp_operands
8215                   && i.disp_encoding)
8216                 {
8217                   fake_zero_displacement = 1;
8218                   if (i.disp_encoding == disp_encoding_8bit)
8219                     i.types[op].bitfield.disp8 = 1;
8220                   else
8221                     i.types[op].bitfield.disp16 = 1;
8222                 }
8223               i.rm.mode = mode_from_disp_size (i.types[op]);
8224             }
8225           else /* i.base_reg and 32/64 bit mode  */
8226             {
8227               if (flag_code == CODE_64BIT
8228                   && operand_type_check (i.types[op], disp))
8229                 {
8230                   i.types[op].bitfield.disp16 = 0;
8231                   i.types[op].bitfield.disp64 = 0;
8232                   if (i.prefix[ADDR_PREFIX] == 0)
8233                     {
8234                       i.types[op].bitfield.disp32 = 0;
8235                       i.types[op].bitfield.disp32s = 1;
8236                     }
8237                   else
8238                     {
8239                       i.types[op].bitfield.disp32 = 1;
8240                       i.types[op].bitfield.disp32s = 0;
8241                     }
8242                 }
8243
8244               if (!i.tm.opcode_modifier.sib)
8245                 i.rm.regmem = i.base_reg->reg_num;
8246               if ((i.base_reg->reg_flags & RegRex) != 0)
8247                 i.rex |= REX_B;
8248               i.sib.base = i.base_reg->reg_num;
8249               /* x86-64 ignores REX prefix bit here to avoid decoder
8250                  complications.  */
8251               if (!(i.base_reg->reg_flags & RegRex)
8252                   && (i.base_reg->reg_num == EBP_REG_NUM
8253                    || i.base_reg->reg_num == ESP_REG_NUM))
8254                   default_seg = &ss;
8255               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
8256                 {
8257                   fake_zero_displacement = 1;
8258                   if (i.disp_encoding == disp_encoding_32bit)
8259                     i.types[op].bitfield.disp32 = 1;
8260                   else
8261                     i.types[op].bitfield.disp8 = 1;
8262                 }
8263               i.sib.scale = i.log2_scale_factor;
8264               if (i.index_reg == 0)
8265                 {
8266                   /* Only check for VSIB. */
8267                   gas_assert (i.tm.opcode_modifier.sib != VECSIB128
8268                               && i.tm.opcode_modifier.sib != VECSIB256
8269                               && i.tm.opcode_modifier.sib != VECSIB512);
8270
8271                   /* <disp>(%esp) becomes two byte modrm with no index
8272                      register.  We've already stored the code for esp
8273                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
8274                      Any base register besides %esp will not use the
8275                      extra modrm byte.  */
8276                   i.sib.index = NO_INDEX_REGISTER;
8277                 }
8278               else if (!i.tm.opcode_modifier.sib)
8279                 {
8280                   if (i.index_reg->reg_num == RegIZ)
8281                     i.sib.index = NO_INDEX_REGISTER;
8282                   else
8283                     i.sib.index = i.index_reg->reg_num;
8284                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
8285                   if ((i.index_reg->reg_flags & RegRex) != 0)
8286                     i.rex |= REX_X;
8287                 }
8288
8289               if (i.disp_operands
8290                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
8291                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
8292                 i.rm.mode = 0;
8293               else
8294                 {
8295                   if (!fake_zero_displacement
8296                       && !i.disp_operands
8297                       && i.disp_encoding)
8298                     {
8299                       fake_zero_displacement = 1;
8300                       if (i.disp_encoding == disp_encoding_8bit)
8301                         i.types[op].bitfield.disp8 = 1;
8302                       else
8303                         i.types[op].bitfield.disp32 = 1;
8304                     }
8305                   i.rm.mode = mode_from_disp_size (i.types[op]);
8306                 }
8307             }
8308
8309           if (fake_zero_displacement)
8310             {
8311               /* Fakes a zero displacement assuming that i.types[op]
8312                  holds the correct displacement size.  */
8313               expressionS *exp;
8314
8315               gas_assert (i.op[op].disps == 0);
8316               exp = &disp_expressions[i.disp_operands++];
8317               i.op[op].disps = exp;
8318               exp->X_op = O_constant;
8319               exp->X_add_number = 0;
8320               exp->X_add_symbol = (symbolS *) 0;
8321               exp->X_op_symbol = (symbolS *) 0;
8322             }
8323
8324           mem = op;
8325         }
8326       else
8327         mem = ~0;
8328
8329       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
8330         {
8331           if (operand_type_check (i.types[0], imm))
8332             i.vex.register_specifier = NULL;
8333           else
8334             {
8335               /* VEX.vvvv encodes one of the sources when the first
8336                  operand is not an immediate.  */
8337               if (i.tm.opcode_modifier.vexw == VEXW0)
8338                 i.vex.register_specifier = i.op[0].regs;
8339               else
8340                 i.vex.register_specifier = i.op[1].regs;
8341             }
8342
8343           /* Destination is a XMM register encoded in the ModRM.reg
8344              and VEX.R bit.  */
8345           i.rm.reg = i.op[2].regs->reg_num;
8346           if ((i.op[2].regs->reg_flags & RegRex) != 0)
8347             i.rex |= REX_R;
8348
8349           /* ModRM.rm and VEX.B encodes the other source.  */
8350           if (!i.mem_operands)
8351             {
8352               i.rm.mode = 3;
8353
8354               if (i.tm.opcode_modifier.vexw == VEXW0)
8355                 i.rm.regmem = i.op[1].regs->reg_num;
8356               else
8357                 i.rm.regmem = i.op[0].regs->reg_num;
8358
8359               if ((i.op[1].regs->reg_flags & RegRex) != 0)
8360                 i.rex |= REX_B;
8361             }
8362         }
8363       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
8364         {
8365           i.vex.register_specifier = i.op[2].regs;
8366           if (!i.mem_operands)
8367             {
8368               i.rm.mode = 3;
8369               i.rm.regmem = i.op[1].regs->reg_num;
8370               if ((i.op[1].regs->reg_flags & RegRex) != 0)
8371                 i.rex |= REX_B;
8372             }
8373         }
8374       /* Fill in i.rm.reg or i.rm.regmem field with register operand
8375          (if any) based on i.tm.extension_opcode.  Again, we must be
8376          careful to make sure that segment/control/debug/test/MMX
8377          registers are coded into the i.rm.reg field.  */
8378       else if (i.reg_operands)
8379         {
8380           unsigned int op;
8381           unsigned int vex_reg = ~0;
8382
8383           for (op = 0; op < i.operands; op++)
8384             if (i.types[op].bitfield.class == Reg
8385                 || i.types[op].bitfield.class == RegBND
8386                 || i.types[op].bitfield.class == RegMask
8387                 || i.types[op].bitfield.class == SReg
8388                 || i.types[op].bitfield.class == RegCR
8389                 || i.types[op].bitfield.class == RegDR
8390                 || i.types[op].bitfield.class == RegTR
8391                 || i.types[op].bitfield.class == RegSIMD
8392                 || i.types[op].bitfield.class == RegMMX)
8393               break;
8394
8395           if (vex_3_sources)
8396             op = dest;
8397           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
8398             {
8399               /* For instructions with VexNDS, the register-only
8400                  source operand is encoded in VEX prefix. */
8401               gas_assert (mem != (unsigned int) ~0);
8402
8403               if (op > mem)
8404                 {
8405                   vex_reg = op++;
8406                   gas_assert (op < i.operands);
8407                 }
8408               else
8409                 {
8410                   /* Check register-only source operand when two source
8411                      operands are swapped.  */
8412                   if (!i.tm.operand_types[op].bitfield.baseindex
8413                       && i.tm.operand_types[op + 1].bitfield.baseindex)
8414                     {
8415                       vex_reg = op;
8416                       op += 2;
8417                       gas_assert (mem == (vex_reg + 1)
8418                                   && op < i.operands);
8419                     }
8420                   else
8421                     {
8422                       vex_reg = op + 1;
8423                       gas_assert (vex_reg < i.operands);
8424                     }
8425                 }
8426             }
8427           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
8428             {
8429               /* For instructions with VexNDD, the register destination
8430                  is encoded in VEX prefix.  */
8431               if (i.mem_operands == 0)
8432                 {
8433                   /* There is no memory operand.  */
8434                   gas_assert ((op + 2) == i.operands);
8435                   vex_reg = op + 1;
8436                 }
8437               else
8438                 {
8439                   /* There are only 2 non-immediate operands.  */
8440                   gas_assert (op < i.imm_operands + 2
8441                               && i.operands == i.imm_operands + 2);
8442                   vex_reg = i.imm_operands + 1;
8443                 }
8444             }
8445           else
8446             gas_assert (op < i.operands);
8447
8448           if (vex_reg != (unsigned int) ~0)
8449             {
8450               i386_operand_type *type = &i.tm.operand_types[vex_reg];
8451
8452               if ((type->bitfield.class != Reg
8453                    || (!type->bitfield.dword && !type->bitfield.qword))
8454                   && type->bitfield.class != RegSIMD
8455                   && !operand_type_equal (type, &regmask))
8456                 abort ();
8457
8458               i.vex.register_specifier = i.op[vex_reg].regs;
8459             }
8460
8461           /* Don't set OP operand twice.  */
8462           if (vex_reg != op)
8463             {
8464               /* If there is an extension opcode to put here, the
8465                  register number must be put into the regmem field.  */
8466               if (i.tm.extension_opcode != None)
8467                 {
8468                   i.rm.regmem = i.op[op].regs->reg_num;
8469                   set_rex_vrex (i.op[op].regs, REX_B,
8470                                 i.tm.opcode_modifier.sse2avx);
8471                 }
8472               else
8473                 {
8474                   i.rm.reg = i.op[op].regs->reg_num;
8475                   set_rex_vrex (i.op[op].regs, REX_R,
8476                                 i.tm.opcode_modifier.sse2avx);
8477                 }
8478             }
8479
8480           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
8481              must set it to 3 to indicate this is a register operand
8482              in the regmem field.  */
8483           if (!i.mem_operands)
8484             i.rm.mode = 3;
8485         }
8486
8487       /* Fill in i.rm.reg field with extension opcode (if any).  */
8488       if (i.tm.extension_opcode != None)
8489         i.rm.reg = i.tm.extension_opcode;
8490     }
8491   return default_seg;
8492 }
8493
8494 static INLINE void
8495 frag_opcode_byte (unsigned char byte)
8496 {
8497   if (now_seg != absolute_section)
8498     FRAG_APPEND_1_CHAR (byte);
8499   else
8500     ++abs_section_offset;
8501 }
8502
8503 static unsigned int
8504 flip_code16 (unsigned int code16)
8505 {
8506   gas_assert (i.tm.operands == 1);
8507
8508   return !(i.prefix[REX_PREFIX] & REX_W)
8509          && (code16 ? i.tm.operand_types[0].bitfield.disp32
8510                       || i.tm.operand_types[0].bitfield.disp32s
8511                     : i.tm.operand_types[0].bitfield.disp16)
8512          ? CODE16 : 0;
8513 }
8514
8515 static void
8516 output_branch (void)
8517 {
8518   char *p;
8519   int size;
8520   int code16;
8521   int prefix;
8522   relax_substateT subtype;
8523   symbolS *sym;
8524   offsetT off;
8525
8526   if (now_seg == absolute_section)
8527     {
8528       as_bad (_("relaxable branches not supported in absolute section"));
8529       return;
8530     }
8531
8532   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
8533   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
8534
8535   prefix = 0;
8536   if (i.prefix[DATA_PREFIX] != 0)
8537     {
8538       prefix = 1;
8539       i.prefixes -= 1;
8540       code16 ^= flip_code16(code16);
8541     }
8542   /* Pentium4 branch hints.  */
8543   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
8544       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
8545     {
8546       prefix++;
8547       i.prefixes--;
8548     }
8549   if (i.prefix[REX_PREFIX] != 0)
8550     {
8551       prefix++;
8552       i.prefixes--;
8553     }
8554
8555   /* BND prefixed jump.  */
8556   if (i.prefix[BND_PREFIX] != 0)
8557     {
8558       prefix++;
8559       i.prefixes--;
8560     }
8561
8562   if (i.prefixes != 0)
8563     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8564
8565   /* It's always a symbol;  End frag & setup for relax.
8566      Make sure there is enough room in this frag for the largest
8567      instruction we may generate in md_convert_frag.  This is 2
8568      bytes for the opcode and room for the prefix and largest
8569      displacement.  */
8570   frag_grow (prefix + 2 + 4);
8571   /* Prefix and 1 opcode byte go in fr_fix.  */
8572   p = frag_more (prefix + 1);
8573   if (i.prefix[DATA_PREFIX] != 0)
8574     *p++ = DATA_PREFIX_OPCODE;
8575   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
8576       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
8577     *p++ = i.prefix[SEG_PREFIX];
8578   if (i.prefix[BND_PREFIX] != 0)
8579     *p++ = BND_PREFIX_OPCODE;
8580   if (i.prefix[REX_PREFIX] != 0)
8581     *p++ = i.prefix[REX_PREFIX];
8582   *p = i.tm.base_opcode;
8583
8584   if ((unsigned char) *p == JUMP_PC_RELATIVE)
8585     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
8586   else if (cpu_arch_flags.bitfield.cpui386)
8587     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
8588   else
8589     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
8590   subtype |= code16;
8591
8592   sym = i.op[0].disps->X_add_symbol;
8593   off = i.op[0].disps->X_add_number;
8594
8595   if (i.op[0].disps->X_op != O_constant
8596       && i.op[0].disps->X_op != O_symbol)
8597     {
8598       /* Handle complex expressions.  */
8599       sym = make_expr_symbol (i.op[0].disps);
8600       off = 0;
8601     }
8602
8603   /* 1 possible extra opcode + 4 byte displacement go in var part.
8604      Pass reloc in fr_var.  */
8605   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
8606 }
8607
8608 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8609 /* Return TRUE iff PLT32 relocation should be used for branching to
8610    symbol S.  */
8611
8612 static bfd_boolean
8613 need_plt32_p (symbolS *s)
8614 {
8615   /* PLT32 relocation is ELF only.  */
8616   if (!IS_ELF)
8617     return FALSE;
8618
8619 #ifdef TE_SOLARIS
8620   /* Don't emit PLT32 relocation on Solaris: neither native linker nor
8621      krtld support it.  */
8622   return FALSE;
8623 #endif
8624
8625   /* Since there is no need to prepare for PLT branch on x86-64, we
8626      can generate R_X86_64_PLT32, instead of R_X86_64_PC32, which can
8627      be used as a marker for 32-bit PC-relative branches.  */
8628   if (!object_64bit)
8629     return FALSE;
8630
8631   /* Weak or undefined symbol need PLT32 relocation.  */
8632   if (S_IS_WEAK (s) || !S_IS_DEFINED (s))
8633     return TRUE;
8634
8635   /* Non-global symbol doesn't need PLT32 relocation.  */
8636   if (! S_IS_EXTERNAL (s))
8637     return FALSE;
8638
8639   /* Other global symbols need PLT32 relocation.  NB: Symbol with
8640      non-default visibilities are treated as normal global symbol
8641      so that PLT32 relocation can be used as a marker for 32-bit
8642      PC-relative branches.  It is useful for linker relaxation.  */
8643   return TRUE;
8644 }
8645 #endif
8646
8647 static void
8648 output_jump (void)
8649 {
8650   char *p;
8651   int size;
8652   fixS *fixP;
8653   bfd_reloc_code_real_type jump_reloc = i.reloc[0];
8654
8655   if (i.tm.opcode_modifier.jump == JUMP_BYTE)
8656     {
8657       /* This is a loop or jecxz type instruction.  */
8658       size = 1;
8659       if (i.prefix[ADDR_PREFIX] != 0)
8660         {
8661           frag_opcode_byte (ADDR_PREFIX_OPCODE);
8662           i.prefixes -= 1;
8663         }
8664       /* Pentium4 branch hints.  */
8665       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
8666           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
8667         {
8668           frag_opcode_byte (i.prefix[SEG_PREFIX]);
8669           i.prefixes--;
8670         }
8671     }
8672   else
8673     {
8674       int code16;
8675
8676       code16 = 0;
8677       if (flag_code == CODE_16BIT)
8678         code16 = CODE16;
8679
8680       if (i.prefix[DATA_PREFIX] != 0)
8681         {
8682           frag_opcode_byte (DATA_PREFIX_OPCODE);
8683           i.prefixes -= 1;
8684           code16 ^= flip_code16(code16);
8685         }
8686
8687       size = 4;
8688       if (code16)
8689         size = 2;
8690     }
8691
8692   /* BND prefixed jump.  */
8693   if (i.prefix[BND_PREFIX] != 0)
8694     {
8695       frag_opcode_byte (i.prefix[BND_PREFIX]);
8696       i.prefixes -= 1;
8697     }
8698
8699   if (i.prefix[REX_PREFIX] != 0)
8700     {
8701       frag_opcode_byte (i.prefix[REX_PREFIX]);
8702       i.prefixes -= 1;
8703     }
8704
8705   if (i.prefixes != 0)
8706     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8707
8708   if (now_seg == absolute_section)
8709     {
8710       abs_section_offset += i.tm.opcode_length + size;
8711       return;
8712     }
8713
8714   p = frag_more (i.tm.opcode_length + size);
8715   switch (i.tm.opcode_length)
8716     {
8717     case 2:
8718       *p++ = i.tm.base_opcode >> 8;
8719       /* Fall through.  */
8720     case 1:
8721       *p++ = i.tm.base_opcode;
8722       break;
8723     default:
8724       abort ();
8725     }
8726
8727 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8728   if (size == 4
8729       && jump_reloc == NO_RELOC
8730       && need_plt32_p (i.op[0].disps->X_add_symbol))
8731     jump_reloc = BFD_RELOC_X86_64_PLT32;
8732 #endif
8733
8734   jump_reloc = reloc (size, 1, 1, jump_reloc);
8735
8736   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8737                       i.op[0].disps, 1, jump_reloc);
8738
8739   /* All jumps handled here are signed, but don't use a signed limit
8740      check for 32 and 16 bit jumps as we want to allow wrap around at
8741      4G and 64k respectively.  */
8742   if (size == 1)
8743     fixP->fx_signed = 1;
8744 }
8745
8746 static void
8747 output_interseg_jump (void)
8748 {
8749   char *p;
8750   int size;
8751   int prefix;
8752   int code16;
8753
8754   code16 = 0;
8755   if (flag_code == CODE_16BIT)
8756     code16 = CODE16;
8757
8758   prefix = 0;
8759   if (i.prefix[DATA_PREFIX] != 0)
8760     {
8761       prefix = 1;
8762       i.prefixes -= 1;
8763       code16 ^= CODE16;
8764     }
8765
8766   gas_assert (!i.prefix[REX_PREFIX]);
8767
8768   size = 4;
8769   if (code16)
8770     size = 2;
8771
8772   if (i.prefixes != 0)
8773     as_warn (_("skipping prefixes on `%s'"), i.tm.name);
8774
8775   if (now_seg == absolute_section)
8776     {
8777       abs_section_offset += prefix + 1 + 2 + size;
8778       return;
8779     }
8780
8781   /* 1 opcode; 2 segment; offset  */
8782   p = frag_more (prefix + 1 + 2 + size);
8783
8784   if (i.prefix[DATA_PREFIX] != 0)
8785     *p++ = DATA_PREFIX_OPCODE;
8786
8787   if (i.prefix[REX_PREFIX] != 0)
8788     *p++ = i.prefix[REX_PREFIX];
8789
8790   *p++ = i.tm.base_opcode;
8791   if (i.op[1].imms->X_op == O_constant)
8792     {
8793       offsetT n = i.op[1].imms->X_add_number;
8794
8795       if (size == 2
8796           && !fits_in_unsigned_word (n)
8797           && !fits_in_signed_word (n))
8798         {
8799           as_bad (_("16-bit jump out of range"));
8800           return;
8801         }
8802       md_number_to_chars (p, n, size);
8803     }
8804   else
8805     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8806                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
8807
8808   p += size;
8809   if (i.op[0].imms->X_op == O_constant)
8810     md_number_to_chars (p, (valueT) i.op[0].imms->X_add_number, 2);
8811   else
8812     fix_new_exp (frag_now, p - frag_now->fr_literal, 2,
8813                  i.op[0].imms, 0, reloc (2, 0, 0, i.reloc[0]));
8814 }
8815
8816 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8817 void
8818 x86_cleanup (void)
8819 {
8820   char *p;
8821   asection *seg = now_seg;
8822   subsegT subseg = now_subseg;
8823   asection *sec;
8824   unsigned int alignment, align_size_1;
8825   unsigned int isa_1_descsz, feature_2_descsz, descsz;
8826   unsigned int isa_1_descsz_raw, feature_2_descsz_raw;
8827   unsigned int padding;
8828
8829   if (!IS_ELF || !x86_used_note)
8830     return;
8831
8832   x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X86;
8833
8834   /* The .note.gnu.property section layout:
8835
8836      Field      Length          Contents
8837      ----       ----            ----
8838      n_namsz    4               4
8839      n_descsz   4               The note descriptor size
8840      n_type     4               NT_GNU_PROPERTY_TYPE_0
8841      n_name     4               "GNU"
8842      n_desc     n_descsz        The program property array
8843      ....       ....            ....
8844    */
8845
8846   /* Create the .note.gnu.property section.  */
8847   sec = subseg_new (NOTE_GNU_PROPERTY_SECTION_NAME, 0);
8848   bfd_set_section_flags (sec,
8849                          (SEC_ALLOC
8850                           | SEC_LOAD
8851                           | SEC_DATA
8852                           | SEC_HAS_CONTENTS
8853                           | SEC_READONLY));
8854
8855   if (get_elf_backend_data (stdoutput)->s->elfclass == ELFCLASS64)
8856     {
8857       align_size_1 = 7;
8858       alignment = 3;
8859     }
8860   else
8861     {
8862       align_size_1 = 3;
8863       alignment = 2;
8864     }
8865
8866   bfd_set_section_alignment (sec, alignment);
8867   elf_section_type (sec) = SHT_NOTE;
8868
8869   /* GNU_PROPERTY_X86_ISA_1_USED: 4-byte type + 4-byte data size
8870                                   + 4-byte data  */
8871   isa_1_descsz_raw = 4 + 4 + 4;
8872   /* Align GNU_PROPERTY_X86_ISA_1_USED.  */
8873   isa_1_descsz = (isa_1_descsz_raw + align_size_1) & ~align_size_1;
8874
8875   feature_2_descsz_raw = isa_1_descsz;
8876   /* GNU_PROPERTY_X86_FEATURE_2_USED: 4-byte type + 4-byte data size
8877                                       + 4-byte data  */
8878   feature_2_descsz_raw += 4 + 4 + 4;
8879   /* Align GNU_PROPERTY_X86_FEATURE_2_USED.  */
8880   feature_2_descsz = ((feature_2_descsz_raw + align_size_1)
8881                       & ~align_size_1);
8882
8883   descsz = feature_2_descsz;
8884   /* Section size: n_namsz + n_descsz + n_type + n_name + n_descsz.  */
8885   p = frag_more (4 + 4 + 4 + 4 + descsz);
8886
8887   /* Write n_namsz.  */
8888   md_number_to_chars (p, (valueT) 4, 4);
8889
8890   /* Write n_descsz.  */
8891   md_number_to_chars (p + 4, (valueT) descsz, 4);
8892
8893   /* Write n_type.  */
8894   md_number_to_chars (p + 4 * 2, (valueT) NT_GNU_PROPERTY_TYPE_0, 4);
8895
8896   /* Write n_name.  */
8897   memcpy (p + 4 * 3, "GNU", 4);
8898
8899   /* Write 4-byte type.  */
8900   md_number_to_chars (p + 4 * 4,
8901                       (valueT) GNU_PROPERTY_X86_ISA_1_USED, 4);
8902
8903   /* Write 4-byte data size.  */
8904   md_number_to_chars (p + 4 * 5, (valueT) 4, 4);
8905
8906   /* Write 4-byte data.  */
8907   md_number_to_chars (p + 4 * 6, (valueT) x86_isa_1_used, 4);
8908
8909   /* Zero out paddings.  */
8910   padding = isa_1_descsz - isa_1_descsz_raw;
8911   if (padding)
8912     memset (p + 4 * 7, 0, padding);
8913
8914   /* Write 4-byte type.  */
8915   md_number_to_chars (p + isa_1_descsz + 4 * 4,
8916                       (valueT) GNU_PROPERTY_X86_FEATURE_2_USED, 4);
8917
8918   /* Write 4-byte data size.  */
8919   md_number_to_chars (p + isa_1_descsz + 4 * 5, (valueT) 4, 4);
8920
8921   /* Write 4-byte data.  */
8922   md_number_to_chars (p + isa_1_descsz + 4 * 6,
8923                       (valueT) x86_feature_2_used, 4);
8924
8925   /* Zero out paddings.  */
8926   padding = feature_2_descsz - feature_2_descsz_raw;
8927   if (padding)
8928     memset (p + isa_1_descsz + 4 * 7, 0, padding);
8929
8930   /* We probably can't restore the current segment, for there likely
8931      isn't one yet...  */
8932   if (seg && subseg)
8933     subseg_set (seg, subseg);
8934 }
8935 #endif
8936
8937 static unsigned int
8938 encoding_length (const fragS *start_frag, offsetT start_off,
8939                  const char *frag_now_ptr)
8940 {
8941   unsigned int len = 0;
8942
8943   if (start_frag != frag_now)
8944     {
8945       const fragS *fr = start_frag;
8946
8947       do {
8948         len += fr->fr_fix;
8949         fr = fr->fr_next;
8950       } while (fr && fr != frag_now);
8951     }
8952
8953   return len - start_off + (frag_now_ptr - frag_now->fr_literal);
8954 }
8955
8956 /* Return 1 for test, and, cmp, add, sub, inc and dec which may
8957    be macro-fused with conditional jumps.
8958    NB: If TEST/AND/CMP/ADD/SUB/INC/DEC is of RIP relative address,
8959    or is one of the following format:
8960
8961     cmp m, imm
8962     add m, imm
8963     sub m, imm
8964    test m, imm
8965     and m, imm
8966     inc m
8967     dec m
8968
8969    it is unfusible.  */
8970
8971 static int
8972 maybe_fused_with_jcc_p (enum mf_cmp_kind* mf_cmp_p)
8973 {
8974   /* No RIP address.  */
8975   if (i.base_reg && i.base_reg->reg_num == RegIP)
8976     return 0;
8977
8978   /* No VEX/EVEX encoding.  */
8979   if (is_any_vex_encoding (&i.tm))
8980     return 0;
8981
8982   /* add, sub without add/sub m, imm.  */
8983   if (i.tm.base_opcode <= 5
8984       || (i.tm.base_opcode >= 0x28 && i.tm.base_opcode <= 0x2d)
8985       || ((i.tm.base_opcode | 3) == 0x83
8986           && (i.tm.extension_opcode == 0x5
8987               || i.tm.extension_opcode == 0x0)))
8988     {
8989       *mf_cmp_p = mf_cmp_alu_cmp;
8990       return !(i.mem_operands && i.imm_operands);
8991     }
8992
8993   /* and without and m, imm.  */
8994   if ((i.tm.base_opcode >= 0x20 && i.tm.base_opcode <= 0x25)
8995       || ((i.tm.base_opcode | 3) == 0x83
8996           && i.tm.extension_opcode == 0x4))
8997     {
8998       *mf_cmp_p = mf_cmp_test_and;
8999       return !(i.mem_operands && i.imm_operands);
9000     }
9001
9002   /* test without test m imm.  */
9003   if ((i.tm.base_opcode | 1) == 0x85
9004       || (i.tm.base_opcode | 1) == 0xa9
9005       || ((i.tm.base_opcode | 1) == 0xf7
9006           && i.tm.extension_opcode == 0))
9007     {
9008       *mf_cmp_p = mf_cmp_test_and;
9009       return !(i.mem_operands && i.imm_operands);
9010     }
9011
9012   /* cmp without cmp m, imm.  */
9013   if ((i.tm.base_opcode >= 0x38 && i.tm.base_opcode <= 0x3d)
9014       || ((i.tm.base_opcode | 3) == 0x83
9015           && (i.tm.extension_opcode == 0x7)))
9016     {
9017       *mf_cmp_p = mf_cmp_alu_cmp;
9018       return !(i.mem_operands && i.imm_operands);
9019     }
9020
9021   /* inc, dec without inc/dec m.   */
9022   if ((i.tm.cpu_flags.bitfield.cpuno64
9023        && (i.tm.base_opcode | 0xf) == 0x4f)
9024       || ((i.tm.base_opcode | 1) == 0xff
9025           && i.tm.extension_opcode <= 0x1))
9026     {
9027       *mf_cmp_p = mf_cmp_incdec;
9028       return !i.mem_operands;
9029     }
9030
9031   return 0;
9032 }
9033
9034 /* Return 1 if a FUSED_JCC_PADDING frag should be generated.  */
9035
9036 static int
9037 add_fused_jcc_padding_frag_p (enum mf_cmp_kind* mf_cmp_p)
9038 {
9039   /* NB: Don't work with COND_JUMP86 without i386.  */
9040   if (!align_branch_power
9041       || now_seg == absolute_section
9042       || !cpu_arch_flags.bitfield.cpui386
9043       || !(align_branch & align_branch_fused_bit))
9044     return 0;
9045
9046   if (maybe_fused_with_jcc_p (mf_cmp_p))
9047     {
9048       if (last_insn.kind == last_insn_other
9049           || last_insn.seg != now_seg)
9050         return 1;
9051       if (flag_debug)
9052         as_warn_where (last_insn.file, last_insn.line,
9053                        _("`%s` skips -malign-branch-boundary on `%s`"),
9054                        last_insn.name, i.tm.name);
9055     }
9056
9057   return 0;
9058 }
9059
9060 /* Return 1 if a BRANCH_PREFIX frag should be generated.  */
9061
9062 static int
9063 add_branch_prefix_frag_p (void)
9064 {
9065   /* NB: Don't work with COND_JUMP86 without i386.  Don't add prefix
9066      to PadLock instructions since they include prefixes in opcode.  */
9067   if (!align_branch_power
9068       || !align_branch_prefix_size
9069       || now_seg == absolute_section
9070       || i.tm.cpu_flags.bitfield.cpupadlock
9071       || !cpu_arch_flags.bitfield.cpui386)
9072     return 0;
9073
9074   /* Don't add prefix if it is a prefix or there is no operand in case
9075      that segment prefix is special.  */
9076   if (!i.operands || i.tm.opcode_modifier.isprefix)
9077     return 0;
9078
9079   if (last_insn.kind == last_insn_other
9080       || last_insn.seg != now_seg)
9081     return 1;
9082
9083   if (flag_debug)
9084     as_warn_where (last_insn.file, last_insn.line,
9085                    _("`%s` skips -malign-branch-boundary on `%s`"),
9086                    last_insn.name, i.tm.name);
9087
9088   return 0;
9089 }
9090
9091 /* Return 1 if a BRANCH_PADDING frag should be generated.  */
9092
9093 static int
9094 add_branch_padding_frag_p (enum align_branch_kind *branch_p,
9095                            enum mf_jcc_kind *mf_jcc_p)
9096 {
9097   int add_padding;
9098
9099   /* NB: Don't work with COND_JUMP86 without i386.  */
9100   if (!align_branch_power
9101       || now_seg == absolute_section
9102       || !cpu_arch_flags.bitfield.cpui386)
9103     return 0;
9104
9105   add_padding = 0;
9106
9107   /* Check for jcc and direct jmp.  */
9108   if (i.tm.opcode_modifier.jump == JUMP)
9109     {
9110       if (i.tm.base_opcode == JUMP_PC_RELATIVE)
9111         {
9112           *branch_p = align_branch_jmp;
9113           add_padding = align_branch & align_branch_jmp_bit;
9114         }
9115       else
9116         {
9117           /* Because J<cc> and JN<cc> share same group in macro-fusible table,
9118              igore the lowest bit.  */
9119           *mf_jcc_p = (i.tm.base_opcode & 0x0e) >> 1;
9120           *branch_p = align_branch_jcc;
9121           if ((align_branch & align_branch_jcc_bit))
9122             add_padding = 1;
9123         }
9124     }
9125   else if (is_any_vex_encoding (&i.tm))
9126     return 0;
9127   else if ((i.tm.base_opcode | 1) == 0xc3)
9128     {
9129       /* Near ret.  */
9130       *branch_p = align_branch_ret;
9131       if ((align_branch & align_branch_ret_bit))
9132         add_padding = 1;
9133     }
9134   else
9135     {
9136       /* Check for indirect jmp, direct and indirect calls.  */
9137       if (i.tm.base_opcode == 0xe8)
9138         {
9139           /* Direct call.  */
9140           *branch_p = align_branch_call;
9141           if ((align_branch & align_branch_call_bit))
9142             add_padding = 1;
9143         }
9144       else if (i.tm.base_opcode == 0xff
9145                && (i.tm.extension_opcode == 2
9146                    || i.tm.extension_opcode == 4))
9147         {
9148           /* Indirect call and jmp.  */
9149           *branch_p = align_branch_indirect;
9150           if ((align_branch & align_branch_indirect_bit))
9151             add_padding = 1;
9152         }
9153
9154       if (add_padding
9155           && i.disp_operands
9156           && tls_get_addr
9157           && (i.op[0].disps->X_op == O_symbol
9158               || (i.op[0].disps->X_op == O_subtract
9159                   && i.op[0].disps->X_op_symbol == GOT_symbol)))
9160         {
9161           symbolS *s = i.op[0].disps->X_add_symbol;
9162           /* No padding to call to global or undefined tls_get_addr.  */
9163           if ((S_IS_EXTERNAL (s) || !S_IS_DEFINED (s))
9164               && strcmp (S_GET_NAME (s), tls_get_addr) == 0)
9165             return 0;
9166         }
9167     }
9168
9169   if (add_padding
9170       && last_insn.kind != last_insn_other
9171       && last_insn.seg == now_seg)
9172     {
9173       if (flag_debug)
9174         as_warn_where (last_insn.file, last_insn.line,
9175                        _("`%s` skips -malign-branch-boundary on `%s`"),
9176                        last_insn.name, i.tm.name);
9177       return 0;
9178     }
9179
9180   return add_padding;
9181 }
9182
9183 static void
9184 output_insn (void)
9185 {
9186   fragS *insn_start_frag;
9187   offsetT insn_start_off;
9188   fragS *fragP = NULL;
9189   enum align_branch_kind branch = align_branch_none;
9190   /* The initializer is arbitrary just to avoid uninitialized error.
9191      it's actually either assigned in add_branch_padding_frag_p
9192      or never be used.  */
9193   enum mf_jcc_kind mf_jcc = mf_jcc_jo;
9194
9195 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9196   if (IS_ELF && x86_used_note && now_seg != absolute_section)
9197     {
9198       if ((i.xstate & xstate_tmm) == xstate_tmm
9199           || i.tm.cpu_flags.bitfield.cpuamx_tile)
9200         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_TMM;
9201
9202       if (i.tm.cpu_flags.bitfield.cpusse3
9203           || i.tm.cpu_flags.bitfield.cpussse3
9204           || i.tm.cpu_flags.bitfield.cpusse4_1
9205           || i.tm.cpu_flags.bitfield.cpusse4_2
9206           || i.tm.cpu_flags.bitfield.cpucx16
9207           || i.tm.cpu_flags.bitfield.cpupopcnt
9208           /* LAHF-SAHF insns in 64-bit mode.  */
9209           || (flag_code == CODE_64BIT
9210               && (i.tm.base_opcode | 1) == 0x9f))
9211         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_V2;
9212       if (i.tm.cpu_flags.bitfield.cpuavx
9213           || i.tm.cpu_flags.bitfield.cpuavx2
9214           /* Any VEX encoded insns execpt for CpuAVX512F, CpuAVX512BW,
9215              CpuAVX512DQ, LPW, TBM and AMX.  */
9216           || (i.tm.opcode_modifier.vex
9217               && !i.tm.cpu_flags.bitfield.cpuavx512f
9218               && !i.tm.cpu_flags.bitfield.cpuavx512bw
9219               && !i.tm.cpu_flags.bitfield.cpuavx512dq
9220               && !i.tm.cpu_flags.bitfield.cpulwp
9221               && !i.tm.cpu_flags.bitfield.cputbm
9222               && !(x86_feature_2_used & GNU_PROPERTY_X86_FEATURE_2_TMM))
9223           || i.tm.cpu_flags.bitfield.cpuf16c
9224           || i.tm.cpu_flags.bitfield.cpufma
9225           || i.tm.cpu_flags.bitfield.cpulzcnt
9226           || i.tm.cpu_flags.bitfield.cpumovbe
9227           || i.tm.cpu_flags.bitfield.cpuxsave
9228           || i.tm.cpu_flags.bitfield.cpuxsavec
9229           || i.tm.cpu_flags.bitfield.cpuxsaveopt
9230           || i.tm.cpu_flags.bitfield.cpuxsaves)
9231         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_V3;
9232       if (i.tm.cpu_flags.bitfield.cpuavx512f
9233           || i.tm.cpu_flags.bitfield.cpuavx512bw
9234           || i.tm.cpu_flags.bitfield.cpuavx512dq
9235           || i.tm.cpu_flags.bitfield.cpuavx512vl
9236           /* Any EVEX encoded insns except for AVX512ER, AVX512PF and
9237              VNNIW.  */
9238           || (i.tm.opcode_modifier.evex
9239               && !i.tm.cpu_flags.bitfield.cpuavx512er
9240               && !i.tm.cpu_flags.bitfield.cpuavx512pf
9241               && !i.tm.cpu_flags.bitfield.cpuavx512_4vnniw))
9242         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_V4;
9243
9244       if (i.tm.cpu_flags.bitfield.cpu8087
9245           || i.tm.cpu_flags.bitfield.cpu287
9246           || i.tm.cpu_flags.bitfield.cpu387
9247           || i.tm.cpu_flags.bitfield.cpu687
9248           || i.tm.cpu_flags.bitfield.cpufisttp)
9249         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X87;
9250       if ((i.xstate & xstate_mmx)
9251           || i.tm.base_opcode == 0xf77 /* emms */
9252           || i.tm.base_opcode == 0xf0e /* femms */)
9253         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_MMX;
9254       if (i.index_reg)
9255         {
9256           if (i.index_reg->reg_type.bitfield.zmmword)
9257             i.xstate |= xstate_zmm;
9258           else if (i.index_reg->reg_type.bitfield.ymmword)
9259             i.xstate |= xstate_ymm;
9260           else if (i.index_reg->reg_type.bitfield.xmmword)
9261             i.xstate |= xstate_xmm;
9262         }
9263       if ((i.xstate & xstate_xmm)
9264           || i.tm.cpu_flags.bitfield.cpuwidekl
9265           || i.tm.cpu_flags.bitfield.cpukl)
9266         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XMM;
9267       if ((i.xstate & xstate_ymm) == xstate_ymm)
9268         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_YMM;
9269       if ((i.xstate & xstate_zmm) == xstate_zmm)
9270         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_ZMM;
9271       if (i.mask || (i.xstate & xstate_mask) == xstate_mask)
9272         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_MASK;
9273       if (i.tm.cpu_flags.bitfield.cpufxsr)
9274         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_FXSR;
9275       if (i.tm.cpu_flags.bitfield.cpuxsave)
9276         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVE;
9277       if (i.tm.cpu_flags.bitfield.cpuxsaveopt)
9278         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT;
9279       if (i.tm.cpu_flags.bitfield.cpuxsavec)
9280         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEC;
9281     }
9282 #endif
9283
9284   /* Tie dwarf2 debug info to the address at the start of the insn.
9285      We can't do this after the insn has been output as the current
9286      frag may have been closed off.  eg. by frag_var.  */
9287   dwarf2_emit_insn (0);
9288
9289   insn_start_frag = frag_now;
9290   insn_start_off = frag_now_fix ();
9291
9292   if (add_branch_padding_frag_p (&branch, &mf_jcc))
9293     {
9294       char *p;
9295       /* Branch can be 8 bytes.  Leave some room for prefixes.  */
9296       unsigned int max_branch_padding_size = 14;
9297
9298       /* Align section to boundary.  */
9299       record_alignment (now_seg, align_branch_power);
9300
9301       /* Make room for padding.  */
9302       frag_grow (max_branch_padding_size);
9303
9304       /* Start of the padding.  */
9305       p = frag_more (0);
9306
9307       fragP = frag_now;
9308
9309       frag_var (rs_machine_dependent, max_branch_padding_size, 0,
9310                 ENCODE_RELAX_STATE (BRANCH_PADDING, 0),
9311                 NULL, 0, p);
9312
9313       fragP->tc_frag_data.mf_type = mf_jcc;
9314       fragP->tc_frag_data.branch_type = branch;
9315       fragP->tc_frag_data.max_bytes = max_branch_padding_size;
9316     }
9317
9318   /* Output jumps.  */
9319   if (i.tm.opcode_modifier.jump == JUMP)
9320     output_branch ();
9321   else if (i.tm.opcode_modifier.jump == JUMP_BYTE
9322            || i.tm.opcode_modifier.jump == JUMP_DWORD)
9323     output_jump ();
9324   else if (i.tm.opcode_modifier.jump == JUMP_INTERSEGMENT)
9325     output_interseg_jump ();
9326   else
9327     {
9328       /* Output normal instructions here.  */
9329       char *p;
9330       unsigned char *q;
9331       unsigned int j;
9332       enum mf_cmp_kind mf_cmp;
9333
9334       if (avoid_fence
9335           && (i.tm.base_opcode == 0xfaee8
9336               || i.tm.base_opcode == 0xfaef0
9337               || i.tm.base_opcode == 0xfaef8))
9338         {
9339           /* Encode lfence, mfence, and sfence as
9340              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
9341           if (now_seg != absolute_section)
9342             {
9343               offsetT val = 0x240483f0ULL;
9344
9345               p = frag_more (5);
9346               md_number_to_chars (p, val, 5);
9347             }
9348           else
9349             abs_section_offset += 5;
9350           return;
9351         }
9352
9353       /* Some processors fail on LOCK prefix. This options makes
9354          assembler ignore LOCK prefix and serves as a workaround.  */
9355       if (omit_lock_prefix)
9356         {
9357           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
9358             return;
9359           i.prefix[LOCK_PREFIX] = 0;
9360         }
9361
9362       if (branch)
9363         /* Skip if this is a branch.  */
9364         ;
9365       else if (add_fused_jcc_padding_frag_p (&mf_cmp))
9366         {
9367           /* Make room for padding.  */
9368           frag_grow (MAX_FUSED_JCC_PADDING_SIZE);
9369           p = frag_more (0);
9370
9371           fragP = frag_now;
9372
9373           frag_var (rs_machine_dependent, MAX_FUSED_JCC_PADDING_SIZE, 0,
9374                     ENCODE_RELAX_STATE (FUSED_JCC_PADDING, 0),
9375                     NULL, 0, p);
9376
9377           fragP->tc_frag_data.mf_type = mf_cmp;
9378           fragP->tc_frag_data.branch_type = align_branch_fused;
9379           fragP->tc_frag_data.max_bytes = MAX_FUSED_JCC_PADDING_SIZE;
9380         }
9381       else if (add_branch_prefix_frag_p ())
9382         {
9383           unsigned int max_prefix_size = align_branch_prefix_size;
9384
9385           /* Make room for padding.  */
9386           frag_grow (max_prefix_size);
9387           p = frag_more (0);
9388
9389           fragP = frag_now;
9390
9391           frag_var (rs_machine_dependent, max_prefix_size, 0,
9392                     ENCODE_RELAX_STATE (BRANCH_PREFIX, 0),
9393                     NULL, 0, p);
9394
9395           fragP->tc_frag_data.max_bytes = max_prefix_size;
9396         }
9397
9398       /* Since the VEX/EVEX prefix contains the implicit prefix, we
9399          don't need the explicit prefix.  */
9400       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
9401         {
9402           switch (i.tm.opcode_modifier.opcodeprefix)
9403             {
9404             case PREFIX_0X66:
9405               add_prefix (0x66);
9406               break;
9407             case PREFIX_0XF2:
9408               add_prefix (0xf2);
9409               break;
9410             case PREFIX_0XF3:
9411               if (!i.tm.cpu_flags.bitfield.cpupadlock
9412                   || (i.prefix[REP_PREFIX] != 0xf3))
9413                 add_prefix (0xf3);
9414               break;
9415             case PREFIX_NONE:
9416               switch (i.tm.opcode_length)
9417                 {
9418                 case 3:
9419                 case 2:
9420                 case 1:
9421                   break;
9422                 case 0:
9423                   /* Check for pseudo prefixes.  */
9424                   as_bad_where (insn_start_frag->fr_file,
9425                                 insn_start_frag->fr_line,
9426                                 _("pseudo prefix without instruction"));
9427                   return;
9428                 default:
9429                   abort ();
9430                 }
9431               break;
9432             default:
9433               abort ();
9434             }
9435
9436 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
9437           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
9438              R_X86_64_GOTTPOFF relocation so that linker can safely
9439              perform IE->LE optimization.  A dummy REX_OPCODE prefix
9440              is also needed for lea with R_X86_64_GOTPC32_TLSDESC
9441              relocation for GDesc -> IE/LE optimization.  */
9442           if (x86_elf_abi == X86_64_X32_ABI
9443               && i.operands == 2
9444               && (i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
9445                   || i.reloc[0] == BFD_RELOC_X86_64_GOTPC32_TLSDESC)
9446               && i.prefix[REX_PREFIX] == 0)
9447             add_prefix (REX_OPCODE);
9448 #endif
9449
9450           /* The prefix bytes.  */
9451           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
9452             if (*q)
9453               frag_opcode_byte (*q);
9454         }
9455       else
9456         {
9457           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
9458             if (*q)
9459               switch (j)
9460                 {
9461                 case SEG_PREFIX:
9462                 case ADDR_PREFIX:
9463                   frag_opcode_byte (*q);
9464                   break;
9465                 default:
9466                   /* There should be no other prefixes for instructions
9467                      with VEX prefix.  */
9468                   abort ();
9469                 }
9470
9471           /* For EVEX instructions i.vrex should become 0 after
9472              build_evex_prefix.  For VEX instructions upper 16 registers
9473              aren't available, so VREX should be 0.  */
9474           if (i.vrex)
9475             abort ();
9476           /* Now the VEX prefix.  */
9477           if (now_seg != absolute_section)
9478             {
9479               p = frag_more (i.vex.length);
9480               for (j = 0; j < i.vex.length; j++)
9481                 p[j] = i.vex.bytes[j];
9482             }
9483           else
9484             abs_section_offset += i.vex.length;
9485         }
9486
9487       /* Now the opcode; be careful about word order here!  */
9488       if (now_seg == absolute_section)
9489         abs_section_offset += i.tm.opcode_length;
9490       else if (i.tm.opcode_length == 1)
9491         {
9492           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
9493         }
9494       else
9495         {
9496           switch (i.tm.opcode_length)
9497             {
9498             case 4:
9499               p = frag_more (4);
9500               *p++ = (i.tm.base_opcode >> 24) & 0xff;
9501               *p++ = (i.tm.base_opcode >> 16) & 0xff;
9502               break;
9503             case 3:
9504               p = frag_more (3);
9505               *p++ = (i.tm.base_opcode >> 16) & 0xff;
9506               break;
9507             case 2:
9508               p = frag_more (2);
9509               break;
9510             default:
9511               abort ();
9512               break;
9513             }
9514
9515           /* Put out high byte first: can't use md_number_to_chars!  */
9516           *p++ = (i.tm.base_opcode >> 8) & 0xff;
9517           *p = i.tm.base_opcode & 0xff;
9518         }
9519
9520       /* Now the modrm byte and sib byte (if present).  */
9521       if (i.tm.opcode_modifier.modrm)
9522         {
9523           frag_opcode_byte ((i.rm.regmem << 0)
9524                              | (i.rm.reg << 3)
9525                              | (i.rm.mode << 6));
9526           /* If i.rm.regmem == ESP (4)
9527              && i.rm.mode != (Register mode)
9528              && not 16 bit
9529              ==> need second modrm byte.  */
9530           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
9531               && i.rm.mode != 3
9532               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
9533             frag_opcode_byte ((i.sib.base << 0)
9534                               | (i.sib.index << 3)
9535                               | (i.sib.scale << 6));
9536         }
9537
9538       if (i.disp_operands)
9539         output_disp (insn_start_frag, insn_start_off);
9540
9541       if (i.imm_operands)
9542         output_imm (insn_start_frag, insn_start_off);
9543
9544       /*
9545        * frag_now_fix () returning plain abs_section_offset when we're in the
9546        * absolute section, and abs_section_offset not getting updated as data
9547        * gets added to the frag breaks the logic below.
9548        */
9549       if (now_seg != absolute_section)
9550         {
9551           j = encoding_length (insn_start_frag, insn_start_off, frag_more (0));
9552           if (j > 15)
9553             as_warn (_("instruction length of %u bytes exceeds the limit of 15"),
9554                      j);
9555           else if (fragP)
9556             {
9557               /* NB: Don't add prefix with GOTPC relocation since
9558                  output_disp() above depends on the fixed encoding
9559                  length.  Can't add prefix with TLS relocation since
9560                  it breaks TLS linker optimization.  */
9561               unsigned int max = i.has_gotpc_tls_reloc ? 0 : 15 - j;
9562               /* Prefix count on the current instruction.  */
9563               unsigned int count = i.vex.length;
9564               unsigned int k;
9565               for (k = 0; k < ARRAY_SIZE (i.prefix); k++)
9566                 /* REX byte is encoded in VEX/EVEX prefix.  */
9567                 if (i.prefix[k] && (k != REX_PREFIX || !i.vex.length))
9568                   count++;
9569
9570               /* Count prefixes for extended opcode maps.  */
9571               if (!i.vex.length)
9572                 switch (i.tm.opcode_length)
9573                   {
9574                   case 3:
9575                     if (((i.tm.base_opcode >> 16) & 0xff) == 0xf)
9576                       {
9577                         count++;
9578                         switch ((i.tm.base_opcode >> 8) & 0xff)
9579                           {
9580                           case 0x38:
9581                           case 0x3a:
9582                             count++;
9583                             break;
9584                           default:
9585                             break;
9586                           }
9587                       }
9588                     break;
9589                   case 2:
9590                     if (((i.tm.base_opcode >> 8) & 0xff) == 0xf)
9591                       count++;
9592                     break;
9593                   case 1:
9594                     break;
9595                   default:
9596                     abort ();
9597                   }
9598
9599               if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
9600                   == BRANCH_PREFIX)
9601                 {
9602                   /* Set the maximum prefix size in BRANCH_PREFIX
9603                      frag.  */
9604                   if (fragP->tc_frag_data.max_bytes > max)
9605                     fragP->tc_frag_data.max_bytes = max;
9606                   if (fragP->tc_frag_data.max_bytes > count)
9607                     fragP->tc_frag_data.max_bytes -= count;
9608                   else
9609                     fragP->tc_frag_data.max_bytes = 0;
9610                 }
9611               else
9612                 {
9613                   /* Remember the maximum prefix size in FUSED_JCC_PADDING
9614                      frag.  */
9615                   unsigned int max_prefix_size;
9616                   if (align_branch_prefix_size > max)
9617                     max_prefix_size = max;
9618                   else
9619                     max_prefix_size = align_branch_prefix_size;
9620                   if (max_prefix_size > count)
9621                     fragP->tc_frag_data.max_prefix_length
9622                       = max_prefix_size - count;
9623                 }
9624
9625               /* Use existing segment prefix if possible.  Use CS
9626                  segment prefix in 64-bit mode.  In 32-bit mode, use SS
9627                  segment prefix with ESP/EBP base register and use DS
9628                  segment prefix without ESP/EBP base register.  */
9629               if (i.prefix[SEG_PREFIX])
9630                 fragP->tc_frag_data.default_prefix = i.prefix[SEG_PREFIX];
9631               else if (flag_code == CODE_64BIT)
9632                 fragP->tc_frag_data.default_prefix = CS_PREFIX_OPCODE;
9633               else if (i.base_reg
9634                        && (i.base_reg->reg_num == 4
9635                            || i.base_reg->reg_num == 5))
9636                 fragP->tc_frag_data.default_prefix = SS_PREFIX_OPCODE;
9637               else
9638                 fragP->tc_frag_data.default_prefix = DS_PREFIX_OPCODE;
9639             }
9640         }
9641     }
9642
9643   /* NB: Don't work with COND_JUMP86 without i386.  */
9644   if (align_branch_power
9645       && now_seg != absolute_section
9646       && cpu_arch_flags.bitfield.cpui386)
9647     {
9648       /* Terminate each frag so that we can add prefix and check for
9649          fused jcc.  */
9650       frag_wane (frag_now);
9651       frag_new (0);
9652     }
9653
9654 #ifdef DEBUG386
9655   if (flag_debug)
9656     {
9657       pi ("" /*line*/, &i);
9658     }
9659 #endif /* DEBUG386  */
9660 }
9661
9662 /* Return the size of the displacement operand N.  */
9663
9664 static int
9665 disp_size (unsigned int n)
9666 {
9667   int size = 4;
9668
9669   if (i.types[n].bitfield.disp64)
9670     size = 8;
9671   else if (i.types[n].bitfield.disp8)
9672     size = 1;
9673   else if (i.types[n].bitfield.disp16)
9674     size = 2;
9675   return size;
9676 }
9677
9678 /* Return the size of the immediate operand N.  */
9679
9680 static int
9681 imm_size (unsigned int n)
9682 {
9683   int size = 4;
9684   if (i.types[n].bitfield.imm64)
9685     size = 8;
9686   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
9687     size = 1;
9688   else if (i.types[n].bitfield.imm16)
9689     size = 2;
9690   return size;
9691 }
9692
9693 static void
9694 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
9695 {
9696   char *p;
9697   unsigned int n;
9698
9699   for (n = 0; n < i.operands; n++)
9700     {
9701       if (operand_type_check (i.types[n], disp))
9702         {
9703           int size = disp_size (n);
9704
9705           if (now_seg == absolute_section)
9706             abs_section_offset += size;
9707           else if (i.op[n].disps->X_op == O_constant)
9708             {
9709               offsetT val = i.op[n].disps->X_add_number;
9710
9711               val = offset_in_range (val >> (size == 1 ? i.memshift : 0),
9712                                      size);
9713               p = frag_more (size);
9714               md_number_to_chars (p, val, size);
9715             }
9716           else
9717             {
9718               enum bfd_reloc_code_real reloc_type;
9719               int sign = i.types[n].bitfield.disp32s;
9720               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
9721               fixS *fixP;
9722
9723               /* We can't have 8 bit displacement here.  */
9724               gas_assert (!i.types[n].bitfield.disp8);
9725
9726               /* The PC relative address is computed relative
9727                  to the instruction boundary, so in case immediate
9728                  fields follows, we need to adjust the value.  */
9729               if (pcrel && i.imm_operands)
9730                 {
9731                   unsigned int n1;
9732                   int sz = 0;
9733
9734                   for (n1 = 0; n1 < i.operands; n1++)
9735                     if (operand_type_check (i.types[n1], imm))
9736                       {
9737                         /* Only one immediate is allowed for PC
9738                            relative address.  */
9739                         gas_assert (sz == 0);
9740                         sz = imm_size (n1);
9741                         i.op[n].disps->X_add_number -= sz;
9742                       }
9743                   /* We should find the immediate.  */
9744                   gas_assert (sz != 0);
9745                 }
9746
9747               p = frag_more (size);
9748               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
9749               if (GOT_symbol
9750                   && GOT_symbol == i.op[n].disps->X_add_symbol
9751                   && (((reloc_type == BFD_RELOC_32
9752                         || reloc_type == BFD_RELOC_X86_64_32S
9753                         || (reloc_type == BFD_RELOC_64
9754                             && object_64bit))
9755                        && (i.op[n].disps->X_op == O_symbol
9756                            || (i.op[n].disps->X_op == O_add
9757                                && ((symbol_get_value_expression
9758                                     (i.op[n].disps->X_op_symbol)->X_op)
9759                                    == O_subtract))))
9760                       || reloc_type == BFD_RELOC_32_PCREL))
9761                 {
9762                   if (!object_64bit)
9763                     {
9764                       reloc_type = BFD_RELOC_386_GOTPC;
9765                       i.has_gotpc_tls_reloc = TRUE;
9766                       i.op[n].imms->X_add_number +=
9767                         encoding_length (insn_start_frag, insn_start_off, p);
9768                     }
9769                   else if (reloc_type == BFD_RELOC_64)
9770                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
9771                   else
9772                     /* Don't do the adjustment for x86-64, as there
9773                        the pcrel addressing is relative to the _next_
9774                        insn, and that is taken care of in other code.  */
9775                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
9776                 }
9777               else if (align_branch_power)
9778                 {
9779                   switch (reloc_type)
9780                     {
9781                     case BFD_RELOC_386_TLS_GD:
9782                     case BFD_RELOC_386_TLS_LDM:
9783                     case BFD_RELOC_386_TLS_IE:
9784                     case BFD_RELOC_386_TLS_IE_32:
9785                     case BFD_RELOC_386_TLS_GOTIE:
9786                     case BFD_RELOC_386_TLS_GOTDESC:
9787                     case BFD_RELOC_386_TLS_DESC_CALL:
9788                     case BFD_RELOC_X86_64_TLSGD:
9789                     case BFD_RELOC_X86_64_TLSLD:
9790                     case BFD_RELOC_X86_64_GOTTPOFF:
9791                     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
9792                     case BFD_RELOC_X86_64_TLSDESC_CALL:
9793                       i.has_gotpc_tls_reloc = TRUE;
9794                     default:
9795                       break;
9796                     }
9797                 }
9798               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
9799                                   size, i.op[n].disps, pcrel,
9800                                   reloc_type);
9801               /* Check for "call/jmp *mem", "mov mem, %reg",
9802                  "test %reg, mem" and "binop mem, %reg" where binop
9803                  is one of adc, add, and, cmp, or, sbb, sub, xor
9804                  instructions without data prefix.  Always generate
9805                  R_386_GOT32X for "sym*GOT" operand in 32-bit mode.  */
9806               if (i.prefix[DATA_PREFIX] == 0
9807                   && (generate_relax_relocations
9808                       || (!object_64bit
9809                           && i.rm.mode == 0
9810                           && i.rm.regmem == 5))
9811                   && (i.rm.mode == 2
9812                       || (i.rm.mode == 0 && i.rm.regmem == 5))
9813                   && !is_any_vex_encoding(&i.tm)
9814                   && ((i.operands == 1
9815                        && i.tm.base_opcode == 0xff
9816                        && (i.rm.reg == 2 || i.rm.reg == 4))
9817                       || (i.operands == 2
9818                           && (i.tm.base_opcode == 0x8b
9819                               || i.tm.base_opcode == 0x85
9820                               || (i.tm.base_opcode & ~0x38) == 0x03))))
9821                 {
9822                   if (object_64bit)
9823                     {
9824                       fixP->fx_tcbit = i.rex != 0;
9825                       if (i.base_reg
9826                           && (i.base_reg->reg_num == RegIP))
9827                       fixP->fx_tcbit2 = 1;
9828                     }
9829                   else
9830                     fixP->fx_tcbit2 = 1;
9831                 }
9832             }
9833         }
9834     }
9835 }
9836
9837 static void
9838 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
9839 {
9840   char *p;
9841   unsigned int n;
9842
9843   for (n = 0; n < i.operands; n++)
9844     {
9845       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
9846       if (i.rounding && (int) n == i.rounding->operand)
9847         continue;
9848
9849       if (operand_type_check (i.types[n], imm))
9850         {
9851           int size = imm_size (n);
9852
9853           if (now_seg == absolute_section)
9854             abs_section_offset += size;
9855           else if (i.op[n].imms->X_op == O_constant)
9856             {
9857               offsetT val;
9858
9859               val = offset_in_range (i.op[n].imms->X_add_number,
9860                                      size);
9861               p = frag_more (size);
9862               md_number_to_chars (p, val, size);
9863             }
9864           else
9865             {
9866               /* Not absolute_section.
9867                  Need a 32-bit fixup (don't support 8bit
9868                  non-absolute imms).  Try to support other
9869                  sizes ...  */
9870               enum bfd_reloc_code_real reloc_type;
9871               int sign;
9872
9873               if (i.types[n].bitfield.imm32s
9874                   && (i.suffix == QWORD_MNEM_SUFFIX
9875                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
9876                 sign = 1;
9877               else
9878                 sign = 0;
9879
9880               p = frag_more (size);
9881               reloc_type = reloc (size, 0, sign, i.reloc[n]);
9882
9883               /*   This is tough to explain.  We end up with this one if we
9884                * have operands that look like
9885                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
9886                * obtain the absolute address of the GOT, and it is strongly
9887                * preferable from a performance point of view to avoid using
9888                * a runtime relocation for this.  The actual sequence of
9889                * instructions often look something like:
9890                *
9891                *        call    .L66
9892                * .L66:
9893                *        popl    %ebx
9894                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
9895                *
9896                *   The call and pop essentially return the absolute address
9897                * of the label .L66 and store it in %ebx.  The linker itself
9898                * will ultimately change the first operand of the addl so
9899                * that %ebx points to the GOT, but to keep things simple, the
9900                * .o file must have this operand set so that it generates not
9901                * the absolute address of .L66, but the absolute address of
9902                * itself.  This allows the linker itself simply treat a GOTPC
9903                * relocation as asking for a pcrel offset to the GOT to be
9904                * added in, and the addend of the relocation is stored in the
9905                * operand field for the instruction itself.
9906                *
9907                *   Our job here is to fix the operand so that it would add
9908                * the correct offset so that %ebx would point to itself.  The
9909                * thing that is tricky is that .-.L66 will point to the
9910                * beginning of the instruction, so we need to further modify
9911                * the operand so that it will point to itself.  There are
9912                * other cases where you have something like:
9913                *
9914                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
9915                *
9916                * and here no correction would be required.  Internally in
9917                * the assembler we treat operands of this form as not being
9918                * pcrel since the '.' is explicitly mentioned, and I wonder
9919                * whether it would simplify matters to do it this way.  Who
9920                * knows.  In earlier versions of the PIC patches, the
9921                * pcrel_adjust field was used to store the correction, but
9922                * since the expression is not pcrel, I felt it would be
9923                * confusing to do it this way.  */
9924
9925               if ((reloc_type == BFD_RELOC_32
9926                    || reloc_type == BFD_RELOC_X86_64_32S
9927                    || reloc_type == BFD_RELOC_64)
9928                   && GOT_symbol
9929                   && GOT_symbol == i.op[n].imms->X_add_symbol
9930                   && (i.op[n].imms->X_op == O_symbol
9931                       || (i.op[n].imms->X_op == O_add
9932                           && ((symbol_get_value_expression
9933                                (i.op[n].imms->X_op_symbol)->X_op)
9934                               == O_subtract))))
9935                 {
9936                   if (!object_64bit)
9937                     reloc_type = BFD_RELOC_386_GOTPC;
9938                   else if (size == 4)
9939                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
9940                   else if (size == 8)
9941                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
9942                   i.has_gotpc_tls_reloc = TRUE;
9943                   i.op[n].imms->X_add_number +=
9944                     encoding_length (insn_start_frag, insn_start_off, p);
9945                 }
9946               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
9947                            i.op[n].imms, 0, reloc_type);
9948             }
9949         }
9950     }
9951 }
9952 \f
9953 /* x86_cons_fix_new is called via the expression parsing code when a
9954    reloc is needed.  We use this hook to get the correct .got reloc.  */
9955 static int cons_sign = -1;
9956
9957 void
9958 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
9959                   expressionS *exp, bfd_reloc_code_real_type r)
9960 {
9961   r = reloc (len, 0, cons_sign, r);
9962
9963 #ifdef TE_PE
9964   if (exp->X_op == O_secrel)
9965     {
9966       exp->X_op = O_symbol;
9967       r = BFD_RELOC_32_SECREL;
9968     }
9969 #endif
9970
9971   fix_new_exp (frag, off, len, exp, 0, r);
9972 }
9973
9974 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
9975    purpose of the `.dc.a' internal pseudo-op.  */
9976
9977 int
9978 x86_address_bytes (void)
9979 {
9980   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
9981     return 4;
9982   return stdoutput->arch_info->bits_per_address / 8;
9983 }
9984
9985 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
9986     || defined (LEX_AT)
9987 # define lex_got(reloc, adjust, types) NULL
9988 #else
9989 /* Parse operands of the form
9990    <symbol>@GOTOFF+<nnn>
9991    and similar .plt or .got references.
9992
9993    If we find one, set up the correct relocation in RELOC and copy the
9994    input string, minus the `@GOTOFF' into a malloc'd buffer for
9995    parsing by the calling routine.  Return this buffer, and if ADJUST
9996    is non-null set it to the length of the string we removed from the
9997    input line.  Otherwise return NULL.  */
9998 static char *
9999 lex_got (enum bfd_reloc_code_real *rel,
10000          int *adjust,
10001          i386_operand_type *types)
10002 {
10003   /* Some of the relocations depend on the size of what field is to
10004      be relocated.  But in our callers i386_immediate and i386_displacement
10005      we don't yet know the operand size (this will be set by insn
10006      matching).  Hence we record the word32 relocation here,
10007      and adjust the reloc according to the real size in reloc().  */
10008   static const struct {
10009     const char *str;
10010     int len;
10011     const enum bfd_reloc_code_real rel[2];
10012     const i386_operand_type types64;
10013   } gotrel[] = {
10014 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10015     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
10016                                         BFD_RELOC_SIZE32 },
10017       OPERAND_TYPE_IMM32_64 },
10018 #endif
10019     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
10020                                        BFD_RELOC_X86_64_PLTOFF64 },
10021       OPERAND_TYPE_IMM64 },
10022     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
10023                                        BFD_RELOC_X86_64_PLT32    },
10024       OPERAND_TYPE_IMM32_32S_DISP32 },
10025     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
10026                                        BFD_RELOC_X86_64_GOTPLT64 },
10027       OPERAND_TYPE_IMM64_DISP64 },
10028     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
10029                                        BFD_RELOC_X86_64_GOTOFF64 },
10030       OPERAND_TYPE_IMM64_DISP64 },
10031     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
10032                                        BFD_RELOC_X86_64_GOTPCREL },
10033       OPERAND_TYPE_IMM32_32S_DISP32 },
10034     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
10035                                        BFD_RELOC_X86_64_TLSGD    },
10036       OPERAND_TYPE_IMM32_32S_DISP32 },
10037     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
10038                                        _dummy_first_bfd_reloc_code_real },
10039       OPERAND_TYPE_NONE },
10040     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
10041                                        BFD_RELOC_X86_64_TLSLD    },
10042       OPERAND_TYPE_IMM32_32S_DISP32 },
10043     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
10044                                        BFD_RELOC_X86_64_GOTTPOFF },
10045       OPERAND_TYPE_IMM32_32S_DISP32 },
10046     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
10047                                        BFD_RELOC_X86_64_TPOFF32  },
10048       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10049     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
10050                                        _dummy_first_bfd_reloc_code_real },
10051       OPERAND_TYPE_NONE },
10052     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
10053                                        BFD_RELOC_X86_64_DTPOFF32 },
10054       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10055     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
10056                                        _dummy_first_bfd_reloc_code_real },
10057       OPERAND_TYPE_NONE },
10058     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
10059                                        _dummy_first_bfd_reloc_code_real },
10060       OPERAND_TYPE_NONE },
10061     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
10062                                        BFD_RELOC_X86_64_GOT32    },
10063       OPERAND_TYPE_IMM32_32S_64_DISP32 },
10064     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
10065                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
10066       OPERAND_TYPE_IMM32_32S_DISP32 },
10067     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
10068                                        BFD_RELOC_X86_64_TLSDESC_CALL },
10069       OPERAND_TYPE_IMM32_32S_DISP32 },
10070   };
10071   char *cp;
10072   unsigned int j;
10073
10074 #if defined (OBJ_MAYBE_ELF)
10075   if (!IS_ELF)
10076     return NULL;
10077 #endif
10078
10079   for (cp = input_line_pointer; *cp != '@'; cp++)
10080     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
10081       return NULL;
10082
10083   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
10084     {
10085       int len = gotrel[j].len;
10086       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
10087         {
10088           if (gotrel[j].rel[object_64bit] != 0)
10089             {
10090               int first, second;
10091               char *tmpbuf, *past_reloc;
10092
10093               *rel = gotrel[j].rel[object_64bit];
10094
10095               if (types)
10096                 {
10097                   if (flag_code != CODE_64BIT)
10098                     {
10099                       types->bitfield.imm32 = 1;
10100                       types->bitfield.disp32 = 1;
10101                     }
10102                   else
10103                     *types = gotrel[j].types64;
10104                 }
10105
10106               if (j != 0 && GOT_symbol == NULL)
10107                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
10108
10109               /* The length of the first part of our input line.  */
10110               first = cp - input_line_pointer;
10111
10112               /* The second part goes from after the reloc token until
10113                  (and including) an end_of_line char or comma.  */
10114               past_reloc = cp + 1 + len;
10115               cp = past_reloc;
10116               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
10117                 ++cp;
10118               second = cp + 1 - past_reloc;
10119
10120               /* Allocate and copy string.  The trailing NUL shouldn't
10121                  be necessary, but be safe.  */
10122               tmpbuf = XNEWVEC (char, first + second + 2);
10123               memcpy (tmpbuf, input_line_pointer, first);
10124               if (second != 0 && *past_reloc != ' ')
10125                 /* Replace the relocation token with ' ', so that
10126                    errors like foo@GOTOFF1 will be detected.  */
10127                 tmpbuf[first++] = ' ';
10128               else
10129                 /* Increment length by 1 if the relocation token is
10130                    removed.  */
10131                 len++;
10132               if (adjust)
10133                 *adjust = len;
10134               memcpy (tmpbuf + first, past_reloc, second);
10135               tmpbuf[first + second] = '\0';
10136               return tmpbuf;
10137             }
10138
10139           as_bad (_("@%s reloc is not supported with %d-bit output format"),
10140                   gotrel[j].str, 1 << (5 + object_64bit));
10141           return NULL;
10142         }
10143     }
10144
10145   /* Might be a symbol version string.  Don't as_bad here.  */
10146   return NULL;
10147 }
10148 #endif
10149
10150 #ifdef TE_PE
10151 #ifdef lex_got
10152 #undef lex_got
10153 #endif
10154 /* Parse operands of the form
10155    <symbol>@SECREL32+<nnn>
10156
10157    If we find one, set up the correct relocation in RELOC and copy the
10158    input string, minus the `@SECREL32' into a malloc'd buffer for
10159    parsing by the calling routine.  Return this buffer, and if ADJUST
10160    is non-null set it to the length of the string we removed from the
10161    input line.  Otherwise return NULL.
10162
10163    This function is copied from the ELF version above adjusted for PE targets.  */
10164
10165 static char *
10166 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
10167          int *adjust ATTRIBUTE_UNUSED,
10168          i386_operand_type *types)
10169 {
10170   static const struct
10171   {
10172     const char *str;
10173     int len;
10174     const enum bfd_reloc_code_real rel[2];
10175     const i386_operand_type types64;
10176   }
10177   gotrel[] =
10178   {
10179     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
10180                                           BFD_RELOC_32_SECREL },
10181       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
10182   };
10183
10184   char *cp;
10185   unsigned j;
10186
10187   for (cp = input_line_pointer; *cp != '@'; cp++)
10188     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
10189       return NULL;
10190
10191   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
10192     {
10193       int len = gotrel[j].len;
10194
10195       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
10196         {
10197           if (gotrel[j].rel[object_64bit] != 0)
10198             {
10199               int first, second;
10200               char *tmpbuf, *past_reloc;
10201
10202               *rel = gotrel[j].rel[object_64bit];
10203               if (adjust)
10204                 *adjust = len;
10205
10206               if (types)
10207                 {
10208                   if (flag_code != CODE_64BIT)
10209                     {
10210                       types->bitfield.imm32 = 1;
10211                       types->bitfield.disp32 = 1;
10212                     }
10213                   else
10214                     *types = gotrel[j].types64;
10215                 }
10216
10217               /* The length of the first part of our input line.  */
10218               first = cp - input_line_pointer;
10219
10220               /* The second part goes from after the reloc token until
10221                  (and including) an end_of_line char or comma.  */
10222               past_reloc = cp + 1 + len;
10223               cp = past_reloc;
10224               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
10225                 ++cp;
10226               second = cp + 1 - past_reloc;
10227
10228               /* Allocate and copy string.  The trailing NUL shouldn't
10229                  be necessary, but be safe.  */
10230               tmpbuf = XNEWVEC (char, first + second + 2);
10231               memcpy (tmpbuf, input_line_pointer, first);
10232               if (second != 0 && *past_reloc != ' ')
10233                 /* Replace the relocation token with ' ', so that
10234                    errors like foo@SECLREL321 will be detected.  */
10235                 tmpbuf[first++] = ' ';
10236               memcpy (tmpbuf + first, past_reloc, second);
10237               tmpbuf[first + second] = '\0';
10238               return tmpbuf;
10239             }
10240
10241           as_bad (_("@%s reloc is not supported with %d-bit output format"),
10242                   gotrel[j].str, 1 << (5 + object_64bit));
10243           return NULL;
10244         }
10245     }
10246
10247   /* Might be a symbol version string.  Don't as_bad here.  */
10248   return NULL;
10249 }
10250
10251 #endif /* TE_PE */
10252
10253 bfd_reloc_code_real_type
10254 x86_cons (expressionS *exp, int size)
10255 {
10256   bfd_reloc_code_real_type got_reloc = NO_RELOC;
10257
10258   intel_syntax = -intel_syntax;
10259
10260   exp->X_md = 0;
10261   if (size == 4 || (object_64bit && size == 8))
10262     {
10263       /* Handle @GOTOFF and the like in an expression.  */
10264       char *save;
10265       char *gotfree_input_line;
10266       int adjust = 0;
10267
10268       save = input_line_pointer;
10269       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
10270       if (gotfree_input_line)
10271         input_line_pointer = gotfree_input_line;
10272
10273       expression (exp);
10274
10275       if (gotfree_input_line)
10276         {
10277           /* expression () has merrily parsed up to the end of line,
10278              or a comma - in the wrong buffer.  Transfer how far
10279              input_line_pointer has moved to the right buffer.  */
10280           input_line_pointer = (save
10281                                 + (input_line_pointer - gotfree_input_line)
10282                                 + adjust);
10283           free (gotfree_input_line);
10284           if (exp->X_op == O_constant
10285               || exp->X_op == O_absent
10286               || exp->X_op == O_illegal
10287               || exp->X_op == O_register
10288               || exp->X_op == O_big)
10289             {
10290               char c = *input_line_pointer;
10291               *input_line_pointer = 0;
10292               as_bad (_("missing or invalid expression `%s'"), save);
10293               *input_line_pointer = c;
10294             }
10295           else if ((got_reloc == BFD_RELOC_386_PLT32
10296                     || got_reloc == BFD_RELOC_X86_64_PLT32)
10297                    && exp->X_op != O_symbol)
10298             {
10299               char c = *input_line_pointer;
10300               *input_line_pointer = 0;
10301               as_bad (_("invalid PLT expression `%s'"), save);
10302               *input_line_pointer = c;
10303             }
10304         }
10305     }
10306   else
10307     expression (exp);
10308
10309   intel_syntax = -intel_syntax;
10310
10311   if (intel_syntax)
10312     i386_intel_simplify (exp);
10313
10314   return got_reloc;
10315 }
10316
10317 static void
10318 signed_cons (int size)
10319 {
10320   if (flag_code == CODE_64BIT)
10321     cons_sign = 1;
10322   cons (size);
10323   cons_sign = -1;
10324 }
10325
10326 #ifdef TE_PE
10327 static void
10328 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
10329 {
10330   expressionS exp;
10331
10332   do
10333     {
10334       expression (&exp);
10335       if (exp.X_op == O_symbol)
10336         exp.X_op = O_secrel;
10337
10338       emit_expr (&exp, 4);
10339     }
10340   while (*input_line_pointer++ == ',');
10341
10342   input_line_pointer--;
10343   demand_empty_rest_of_line ();
10344 }
10345 #endif
10346
10347 /* Handle Vector operations.  */
10348
10349 static char *
10350 check_VecOperations (char *op_string, char *op_end)
10351 {
10352   const reg_entry *mask;
10353   const char *saved;
10354   char *end_op;
10355
10356   while (*op_string
10357          && (op_end == NULL || op_string < op_end))
10358     {
10359       saved = op_string;
10360       if (*op_string == '{')
10361         {
10362           op_string++;
10363
10364           /* Check broadcasts.  */
10365           if (strncmp (op_string, "1to", 3) == 0)
10366             {
10367               int bcst_type;
10368
10369               if (i.broadcast)
10370                 goto duplicated_vec_op;
10371
10372               op_string += 3;
10373               if (*op_string == '8')
10374                 bcst_type = 8;
10375               else if (*op_string == '4')
10376                 bcst_type = 4;
10377               else if (*op_string == '2')
10378                 bcst_type = 2;
10379               else if (*op_string == '1'
10380                        && *(op_string+1) == '6')
10381                 {
10382                   bcst_type = 16;
10383                   op_string++;
10384                 }
10385               else
10386                 {
10387                   as_bad (_("Unsupported broadcast: `%s'"), saved);
10388                   return NULL;
10389                 }
10390               op_string++;
10391
10392               broadcast_op.type = bcst_type;
10393               broadcast_op.operand = this_operand;
10394               broadcast_op.bytes = 0;
10395               i.broadcast = &broadcast_op;
10396             }
10397           /* Check masking operation.  */
10398           else if ((mask = parse_register (op_string, &end_op)) != NULL)
10399             {
10400               if (mask == &bad_reg)
10401                 return NULL;
10402
10403               /* k0 can't be used for write mask.  */
10404               if (mask->reg_type.bitfield.class != RegMask || !mask->reg_num)
10405                 {
10406                   as_bad (_("`%s%s' can't be used for write mask"),
10407                           register_prefix, mask->reg_name);
10408                   return NULL;
10409                 }
10410
10411               if (!i.mask)
10412                 {
10413                   mask_op.mask = mask;
10414                   mask_op.zeroing = 0;
10415                   mask_op.operand = this_operand;
10416                   i.mask = &mask_op;
10417                 }
10418               else
10419                 {
10420                   if (i.mask->mask)
10421                     goto duplicated_vec_op;
10422
10423                   i.mask->mask = mask;
10424
10425                   /* Only "{z}" is allowed here.  No need to check
10426                      zeroing mask explicitly.  */
10427                   if (i.mask->operand != this_operand)
10428                     {
10429                       as_bad (_("invalid write mask `%s'"), saved);
10430                       return NULL;
10431                     }
10432                 }
10433
10434               op_string = end_op;
10435             }
10436           /* Check zeroing-flag for masking operation.  */
10437           else if (*op_string == 'z')
10438             {
10439               if (!i.mask)
10440                 {
10441                   mask_op.mask = NULL;
10442                   mask_op.zeroing = 1;
10443                   mask_op.operand = this_operand;
10444                   i.mask = &mask_op;
10445                 }
10446               else
10447                 {
10448                   if (i.mask->zeroing)
10449                     {
10450                     duplicated_vec_op:
10451                       as_bad (_("duplicated `%s'"), saved);
10452                       return NULL;
10453                     }
10454
10455                   i.mask->zeroing = 1;
10456
10457                   /* Only "{%k}" is allowed here.  No need to check mask
10458                      register explicitly.  */
10459                   if (i.mask->operand != this_operand)
10460                     {
10461                       as_bad (_("invalid zeroing-masking `%s'"),
10462                               saved);
10463                       return NULL;
10464                     }
10465                 }
10466
10467               op_string++;
10468             }
10469           else
10470             goto unknown_vec_op;
10471
10472           if (*op_string != '}')
10473             {
10474               as_bad (_("missing `}' in `%s'"), saved);
10475               return NULL;
10476             }
10477           op_string++;
10478
10479           /* Strip whitespace since the addition of pseudo prefixes
10480              changed how the scrubber treats '{'.  */
10481           if (is_space_char (*op_string))
10482             ++op_string;
10483
10484           continue;
10485         }
10486     unknown_vec_op:
10487       /* We don't know this one.  */
10488       as_bad (_("unknown vector operation: `%s'"), saved);
10489       return NULL;
10490     }
10491
10492   if (i.mask && i.mask->zeroing && !i.mask->mask)
10493     {
10494       as_bad (_("zeroing-masking only allowed with write mask"));
10495       return NULL;
10496     }
10497
10498   return op_string;
10499 }
10500
10501 static int
10502 i386_immediate (char *imm_start)
10503 {
10504   char *save_input_line_pointer;
10505   char *gotfree_input_line;
10506   segT exp_seg = 0;
10507   expressionS *exp;
10508   i386_operand_type types;
10509
10510   operand_type_set (&types, ~0);
10511
10512   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
10513     {
10514       as_bad (_("at most %d immediate operands are allowed"),
10515               MAX_IMMEDIATE_OPERANDS);
10516       return 0;
10517     }
10518
10519   exp = &im_expressions[i.imm_operands++];
10520   i.op[this_operand].imms = exp;
10521
10522   if (is_space_char (*imm_start))
10523     ++imm_start;
10524
10525   save_input_line_pointer = input_line_pointer;
10526   input_line_pointer = imm_start;
10527
10528   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
10529   if (gotfree_input_line)
10530     input_line_pointer = gotfree_input_line;
10531
10532   exp_seg = expression (exp);
10533
10534   SKIP_WHITESPACE ();
10535
10536   /* Handle vector operations.  */
10537   if (*input_line_pointer == '{')
10538     {
10539       input_line_pointer = check_VecOperations (input_line_pointer,
10540                                                 NULL);
10541       if (input_line_pointer == NULL)
10542         return 0;
10543     }
10544
10545   if (*input_line_pointer)
10546     as_bad (_("junk `%s' after expression"), input_line_pointer);
10547
10548   input_line_pointer = save_input_line_pointer;
10549   if (gotfree_input_line)
10550     {
10551       free (gotfree_input_line);
10552
10553       if (exp->X_op == O_constant || exp->X_op == O_register)
10554         exp->X_op = O_illegal;
10555     }
10556
10557   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
10558 }
10559
10560 static int
10561 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
10562                          i386_operand_type types, const char *imm_start)
10563 {
10564   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
10565     {
10566       if (imm_start)
10567         as_bad (_("missing or invalid immediate expression `%s'"),
10568                 imm_start);
10569       return 0;
10570     }
10571   else if (exp->X_op == O_constant)
10572     {
10573       /* Size it properly later.  */
10574       i.types[this_operand].bitfield.imm64 = 1;
10575       /* If not 64bit, sign extend val.  */
10576       if (flag_code != CODE_64BIT
10577           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
10578         exp->X_add_number
10579           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
10580     }
10581 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10582   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
10583            && exp_seg != absolute_section
10584            && exp_seg != text_section
10585            && exp_seg != data_section
10586            && exp_seg != bss_section
10587            && exp_seg != undefined_section
10588            && !bfd_is_com_section (exp_seg))
10589     {
10590       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
10591       return 0;
10592     }
10593 #endif
10594   else if (!intel_syntax && exp_seg == reg_section)
10595     {
10596       if (imm_start)
10597         as_bad (_("illegal immediate register operand %s"), imm_start);
10598       return 0;
10599     }
10600   else
10601     {
10602       /* This is an address.  The size of the address will be
10603          determined later, depending on destination register,
10604          suffix, or the default for the section.  */
10605       i.types[this_operand].bitfield.imm8 = 1;
10606       i.types[this_operand].bitfield.imm16 = 1;
10607       i.types[this_operand].bitfield.imm32 = 1;
10608       i.types[this_operand].bitfield.imm32s = 1;
10609       i.types[this_operand].bitfield.imm64 = 1;
10610       i.types[this_operand] = operand_type_and (i.types[this_operand],
10611                                                 types);
10612     }
10613
10614   return 1;
10615 }
10616
10617 static char *
10618 i386_scale (char *scale)
10619 {
10620   offsetT val;
10621   char *save = input_line_pointer;
10622
10623   input_line_pointer = scale;
10624   val = get_absolute_expression ();
10625
10626   switch (val)
10627     {
10628     case 1:
10629       i.log2_scale_factor = 0;
10630       break;
10631     case 2:
10632       i.log2_scale_factor = 1;
10633       break;
10634     case 4:
10635       i.log2_scale_factor = 2;
10636       break;
10637     case 8:
10638       i.log2_scale_factor = 3;
10639       break;
10640     default:
10641       {
10642         char sep = *input_line_pointer;
10643
10644         *input_line_pointer = '\0';
10645         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
10646                 scale);
10647         *input_line_pointer = sep;
10648         input_line_pointer = save;
10649         return NULL;
10650       }
10651     }
10652   if (i.log2_scale_factor != 0 && i.index_reg == 0)
10653     {
10654       as_warn (_("scale factor of %d without an index register"),
10655                1 << i.log2_scale_factor);
10656       i.log2_scale_factor = 0;
10657     }
10658   scale = input_line_pointer;
10659   input_line_pointer = save;
10660   return scale;
10661 }
10662
10663 static int
10664 i386_displacement (char *disp_start, char *disp_end)
10665 {
10666   expressionS *exp;
10667   segT exp_seg = 0;
10668   char *save_input_line_pointer;
10669   char *gotfree_input_line;
10670   int override;
10671   i386_operand_type bigdisp, types = anydisp;
10672   int ret;
10673
10674   if (i.disp_operands == MAX_MEMORY_OPERANDS)
10675     {
10676       as_bad (_("at most %d displacement operands are allowed"),
10677               MAX_MEMORY_OPERANDS);
10678       return 0;
10679     }
10680
10681   operand_type_set (&bigdisp, 0);
10682   if (i.jumpabsolute
10683       || i.types[this_operand].bitfield.baseindex
10684       || (current_templates->start->opcode_modifier.jump != JUMP
10685           && current_templates->start->opcode_modifier.jump != JUMP_DWORD))
10686     {
10687       i386_addressing_mode ();
10688       override = (i.prefix[ADDR_PREFIX] != 0);
10689       if (flag_code == CODE_64BIT)
10690         {
10691           if (!override)
10692             {
10693               bigdisp.bitfield.disp32s = 1;
10694               bigdisp.bitfield.disp64 = 1;
10695             }
10696           else
10697             bigdisp.bitfield.disp32 = 1;
10698         }
10699       else if ((flag_code == CODE_16BIT) ^ override)
10700           bigdisp.bitfield.disp16 = 1;
10701       else
10702           bigdisp.bitfield.disp32 = 1;
10703     }
10704   else
10705     {
10706       /* For PC-relative branches, the width of the displacement may be
10707          dependent upon data size, but is never dependent upon address size.
10708          Also make sure to not unintentionally match against a non-PC-relative
10709          branch template.  */
10710       static templates aux_templates;
10711       const insn_template *t = current_templates->start;
10712       bfd_boolean has_intel64 = FALSE;
10713
10714       aux_templates.start = t;
10715       while (++t < current_templates->end)
10716         {
10717           if (t->opcode_modifier.jump
10718               != current_templates->start->opcode_modifier.jump)
10719             break;
10720           if ((t->opcode_modifier.isa64 >= INTEL64))
10721             has_intel64 = TRUE;
10722         }
10723       if (t < current_templates->end)
10724         {
10725           aux_templates.end = t;
10726           current_templates = &aux_templates;
10727         }
10728
10729       override = (i.prefix[DATA_PREFIX] != 0);
10730       if (flag_code == CODE_64BIT)
10731         {
10732           if ((override || i.suffix == WORD_MNEM_SUFFIX)
10733               && (!intel64 || !has_intel64))
10734             bigdisp.bitfield.disp16 = 1;
10735           else
10736             bigdisp.bitfield.disp32s = 1;
10737         }
10738       else
10739         {
10740           if (!override)
10741             override = (i.suffix == (flag_code != CODE_16BIT
10742                                      ? WORD_MNEM_SUFFIX
10743                                      : LONG_MNEM_SUFFIX));
10744           bigdisp.bitfield.disp32 = 1;
10745           if ((flag_code == CODE_16BIT) ^ override)
10746             {
10747               bigdisp.bitfield.disp32 = 0;
10748               bigdisp.bitfield.disp16 = 1;
10749             }
10750         }
10751     }
10752   i.types[this_operand] = operand_type_or (i.types[this_operand],
10753                                            bigdisp);
10754
10755   exp = &disp_expressions[i.disp_operands];
10756   i.op[this_operand].disps = exp;
10757   i.disp_operands++;
10758   save_input_line_pointer = input_line_pointer;
10759   input_line_pointer = disp_start;
10760   END_STRING_AND_SAVE (disp_end);
10761
10762 #ifndef GCC_ASM_O_HACK
10763 #define GCC_ASM_O_HACK 0
10764 #endif
10765 #if GCC_ASM_O_HACK
10766   END_STRING_AND_SAVE (disp_end + 1);
10767   if (i.types[this_operand].bitfield.baseIndex
10768       && displacement_string_end[-1] == '+')
10769     {
10770       /* This hack is to avoid a warning when using the "o"
10771          constraint within gcc asm statements.
10772          For instance:
10773
10774          #define _set_tssldt_desc(n,addr,limit,type) \
10775          __asm__ __volatile__ ( \
10776          "movw %w2,%0\n\t" \
10777          "movw %w1,2+%0\n\t" \
10778          "rorl $16,%1\n\t" \
10779          "movb %b1,4+%0\n\t" \
10780          "movb %4,5+%0\n\t" \
10781          "movb $0,6+%0\n\t" \
10782          "movb %h1,7+%0\n\t" \
10783          "rorl $16,%1" \
10784          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
10785
10786          This works great except that the output assembler ends
10787          up looking a bit weird if it turns out that there is
10788          no offset.  You end up producing code that looks like:
10789
10790          #APP
10791          movw $235,(%eax)
10792          movw %dx,2+(%eax)
10793          rorl $16,%edx
10794          movb %dl,4+(%eax)
10795          movb $137,5+(%eax)
10796          movb $0,6+(%eax)
10797          movb %dh,7+(%eax)
10798          rorl $16,%edx
10799          #NO_APP
10800
10801          So here we provide the missing zero.  */
10802
10803       *displacement_string_end = '0';
10804     }
10805 #endif
10806   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
10807   if (gotfree_input_line)
10808     input_line_pointer = gotfree_input_line;
10809
10810   exp_seg = expression (exp);
10811
10812   SKIP_WHITESPACE ();
10813   if (*input_line_pointer)
10814     as_bad (_("junk `%s' after expression"), input_line_pointer);
10815 #if GCC_ASM_O_HACK
10816   RESTORE_END_STRING (disp_end + 1);
10817 #endif
10818   input_line_pointer = save_input_line_pointer;
10819   if (gotfree_input_line)
10820     {
10821       free (gotfree_input_line);
10822
10823       if (exp->X_op == O_constant || exp->X_op == O_register)
10824         exp->X_op = O_illegal;
10825     }
10826
10827   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
10828
10829   RESTORE_END_STRING (disp_end);
10830
10831   return ret;
10832 }
10833
10834 static int
10835 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
10836                             i386_operand_type types, const char *disp_start)
10837 {
10838   i386_operand_type bigdisp;
10839   int ret = 1;
10840
10841   /* We do this to make sure that the section symbol is in
10842      the symbol table.  We will ultimately change the relocation
10843      to be relative to the beginning of the section.  */
10844   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
10845       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
10846       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
10847     {
10848       if (exp->X_op != O_symbol)
10849         goto inv_disp;
10850
10851       if (S_IS_LOCAL (exp->X_add_symbol)
10852           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
10853           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
10854         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
10855       exp->X_op = O_subtract;
10856       exp->X_op_symbol = GOT_symbol;
10857       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
10858         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
10859       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
10860         i.reloc[this_operand] = BFD_RELOC_64;
10861       else
10862         i.reloc[this_operand] = BFD_RELOC_32;
10863     }
10864
10865   else if (exp->X_op == O_absent
10866            || exp->X_op == O_illegal
10867            || exp->X_op == O_big)
10868     {
10869     inv_disp:
10870       as_bad (_("missing or invalid displacement expression `%s'"),
10871               disp_start);
10872       ret = 0;
10873     }
10874
10875   else if (flag_code == CODE_64BIT
10876            && !i.prefix[ADDR_PREFIX]
10877            && exp->X_op == O_constant)
10878     {
10879       /* Since displacement is signed extended to 64bit, don't allow
10880          disp32 and turn off disp32s if they are out of range.  */
10881       i.types[this_operand].bitfield.disp32 = 0;
10882       if (!fits_in_signed_long (exp->X_add_number))
10883         {
10884           i.types[this_operand].bitfield.disp32s = 0;
10885           if (i.types[this_operand].bitfield.baseindex)
10886             {
10887               as_bad (_("0x%lx out range of signed 32bit displacement"),
10888                       (long) exp->X_add_number);
10889               ret = 0;
10890             }
10891         }
10892     }
10893
10894 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
10895   else if (exp->X_op != O_constant
10896            && OUTPUT_FLAVOR == bfd_target_aout_flavour
10897            && exp_seg != absolute_section
10898            && exp_seg != text_section
10899            && exp_seg != data_section
10900            && exp_seg != bss_section
10901            && exp_seg != undefined_section
10902            && !bfd_is_com_section (exp_seg))
10903     {
10904       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
10905       ret = 0;
10906     }
10907 #endif
10908
10909   if (current_templates->start->opcode_modifier.jump == JUMP_BYTE
10910       /* Constants get taken care of by optimize_disp().  */
10911       && exp->X_op != O_constant)
10912     i.types[this_operand].bitfield.disp8 = 1;
10913
10914   /* Check if this is a displacement only operand.  */
10915   bigdisp = i.types[this_operand];
10916   bigdisp.bitfield.disp8 = 0;
10917   bigdisp.bitfield.disp16 = 0;
10918   bigdisp.bitfield.disp32 = 0;
10919   bigdisp.bitfield.disp32s = 0;
10920   bigdisp.bitfield.disp64 = 0;
10921   if (operand_type_all_zero (&bigdisp))
10922     i.types[this_operand] = operand_type_and (i.types[this_operand],
10923                                               types);
10924
10925   return ret;
10926 }
10927
10928 /* Return the active addressing mode, taking address override and
10929    registers forming the address into consideration.  Update the
10930    address override prefix if necessary.  */
10931
10932 static enum flag_code
10933 i386_addressing_mode (void)
10934 {
10935   enum flag_code addr_mode;
10936
10937   if (i.prefix[ADDR_PREFIX])
10938     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
10939   else if (flag_code == CODE_16BIT
10940            && current_templates->start->cpu_flags.bitfield.cpumpx
10941            /* Avoid replacing the "16-bit addressing not allowed" diagnostic
10942               from md_assemble() by "is not a valid base/index expression"
10943               when there is a base and/or index.  */
10944            && !i.types[this_operand].bitfield.baseindex)
10945     {
10946       /* MPX insn memory operands with neither base nor index must be forced
10947          to use 32-bit addressing in 16-bit mode.  */
10948       addr_mode = CODE_32BIT;
10949       i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
10950       ++i.prefixes;
10951       gas_assert (!i.types[this_operand].bitfield.disp16);
10952       gas_assert (!i.types[this_operand].bitfield.disp32);
10953     }
10954   else
10955     {
10956       addr_mode = flag_code;
10957
10958 #if INFER_ADDR_PREFIX
10959       if (i.mem_operands == 0)
10960         {
10961           /* Infer address prefix from the first memory operand.  */
10962           const reg_entry *addr_reg = i.base_reg;
10963
10964           if (addr_reg == NULL)
10965             addr_reg = i.index_reg;
10966
10967           if (addr_reg)
10968             {
10969               if (addr_reg->reg_type.bitfield.dword)
10970                 addr_mode = CODE_32BIT;
10971               else if (flag_code != CODE_64BIT
10972                        && addr_reg->reg_type.bitfield.word)
10973                 addr_mode = CODE_16BIT;
10974
10975               if (addr_mode != flag_code)
10976                 {
10977                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
10978                   i.prefixes += 1;
10979                   /* Change the size of any displacement too.  At most one
10980                      of Disp16 or Disp32 is set.
10981                      FIXME.  There doesn't seem to be any real need for
10982                      separate Disp16 and Disp32 flags.  The same goes for
10983                      Imm16 and Imm32.  Removing them would probably clean
10984                      up the code quite a lot.  */
10985                   if (flag_code != CODE_64BIT
10986                       && (i.types[this_operand].bitfield.disp16
10987                           || i.types[this_operand].bitfield.disp32))
10988                     i.types[this_operand]
10989                       = operand_type_xor (i.types[this_operand], disp16_32);
10990                 }
10991             }
10992         }
10993 #endif
10994     }
10995
10996   return addr_mode;
10997 }
10998
10999 /* Make sure the memory operand we've been dealt is valid.
11000    Return 1 on success, 0 on a failure.  */
11001
11002 static int
11003 i386_index_check (const char *operand_string)
11004 {
11005   const char *kind = "base/index";
11006   enum flag_code addr_mode = i386_addressing_mode ();
11007
11008   if (current_templates->start->opcode_modifier.isstring
11009       && !current_templates->start->cpu_flags.bitfield.cpupadlock
11010       && (current_templates->end[-1].opcode_modifier.isstring
11011           || i.mem_operands))
11012     {
11013       /* Memory operands of string insns are special in that they only allow
11014          a single register (rDI, rSI, or rBX) as their memory address.  */
11015       const reg_entry *expected_reg;
11016       static const char *di_si[][2] =
11017         {
11018           { "esi", "edi" },
11019           { "si", "di" },
11020           { "rsi", "rdi" }
11021         };
11022       static const char *bx[] = { "ebx", "bx", "rbx" };
11023
11024       kind = "string address";
11025
11026       if (current_templates->start->opcode_modifier.repprefixok)
11027         {
11028           int es_op = current_templates->end[-1].opcode_modifier.isstring
11029                       - IS_STRING_ES_OP0;
11030           int op = 0;
11031
11032           if (!current_templates->end[-1].operand_types[0].bitfield.baseindex
11033               || ((!i.mem_operands != !intel_syntax)
11034                   && current_templates->end[-1].operand_types[1]
11035                      .bitfield.baseindex))
11036             op = 1;
11037           expected_reg
11038             = (const reg_entry *) str_hash_find (reg_hash,
11039                                                  di_si[addr_mode][op == es_op]);
11040         }
11041       else
11042         expected_reg
11043           = (const reg_entry *)str_hash_find (reg_hash, bx[addr_mode]);
11044
11045       if (i.base_reg != expected_reg
11046           || i.index_reg
11047           || operand_type_check (i.types[this_operand], disp))
11048         {
11049           /* The second memory operand must have the same size as
11050              the first one.  */
11051           if (i.mem_operands
11052               && i.base_reg
11053               && !((addr_mode == CODE_64BIT
11054                     && i.base_reg->reg_type.bitfield.qword)
11055                    || (addr_mode == CODE_32BIT
11056                        ? i.base_reg->reg_type.bitfield.dword
11057                        : i.base_reg->reg_type.bitfield.word)))
11058             goto bad_address;
11059
11060           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
11061                    operand_string,
11062                    intel_syntax ? '[' : '(',
11063                    register_prefix,
11064                    expected_reg->reg_name,
11065                    intel_syntax ? ']' : ')');
11066           return 1;
11067         }
11068       else
11069         return 1;
11070
11071     bad_address:
11072       as_bad (_("`%s' is not a valid %s expression"),
11073               operand_string, kind);
11074       return 0;
11075     }
11076   else
11077     {
11078       if (addr_mode != CODE_16BIT)
11079         {
11080           /* 32-bit/64-bit checks.  */
11081           if (i.disp_encoding == disp_encoding_16bit)
11082             {
11083             bad_disp:
11084               as_bad (_("invalid `%s' prefix"),
11085                       addr_mode == CODE_16BIT ? "{disp32}" : "{disp16}");
11086               return 0;
11087             }
11088
11089           if ((i.base_reg
11090                && ((addr_mode == CODE_64BIT
11091                     ? !i.base_reg->reg_type.bitfield.qword
11092                     : !i.base_reg->reg_type.bitfield.dword)
11093                    || (i.index_reg && i.base_reg->reg_num == RegIP)
11094                    || i.base_reg->reg_num == RegIZ))
11095               || (i.index_reg
11096                   && !i.index_reg->reg_type.bitfield.xmmword
11097                   && !i.index_reg->reg_type.bitfield.ymmword
11098                   && !i.index_reg->reg_type.bitfield.zmmword
11099                   && ((addr_mode == CODE_64BIT
11100                        ? !i.index_reg->reg_type.bitfield.qword
11101                        : !i.index_reg->reg_type.bitfield.dword)
11102                       || !i.index_reg->reg_type.bitfield.baseindex)))
11103             goto bad_address;
11104
11105           /* bndmk, bndldx, bndstx and mandatory non-vector SIB have special restrictions. */
11106           if (current_templates->start->base_opcode == 0xf30f1b
11107               || (current_templates->start->base_opcode & ~1) == 0x0f1a
11108               || current_templates->start->opcode_modifier.sib == SIBMEM)
11109             {
11110               /* They cannot use RIP-relative addressing. */
11111               if (i.base_reg && i.base_reg->reg_num == RegIP)
11112                 {
11113                   as_bad (_("`%s' cannot be used here"), operand_string);
11114                   return 0;
11115                 }
11116
11117               /* bndldx and bndstx ignore their scale factor. */
11118               if ((current_templates->start->base_opcode & ~1) == 0x0f1a
11119                   && i.log2_scale_factor)
11120                 as_warn (_("register scaling is being ignored here"));
11121             }
11122         }
11123       else
11124         {
11125           /* 16-bit checks.  */
11126           if (i.disp_encoding == disp_encoding_32bit)
11127             goto bad_disp;
11128
11129           if ((i.base_reg
11130                && (!i.base_reg->reg_type.bitfield.word
11131                    || !i.base_reg->reg_type.bitfield.baseindex))
11132               || (i.index_reg
11133                   && (!i.index_reg->reg_type.bitfield.word
11134                       || !i.index_reg->reg_type.bitfield.baseindex
11135                       || !(i.base_reg
11136                            && i.base_reg->reg_num < 6
11137                            && i.index_reg->reg_num >= 6
11138                            && i.log2_scale_factor == 0))))
11139             goto bad_address;
11140         }
11141     }
11142   return 1;
11143 }
11144
11145 /* Handle vector immediates.  */
11146
11147 static int
11148 RC_SAE_immediate (const char *imm_start)
11149 {
11150   unsigned int match_found, j;
11151   const char *pstr = imm_start;
11152   expressionS *exp;
11153
11154   if (*pstr != '{')
11155     return 0;
11156
11157   pstr++;
11158   match_found = 0;
11159   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
11160     {
11161       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
11162         {
11163           if (!i.rounding)
11164             {
11165               rc_op.type = RC_NamesTable[j].type;
11166               rc_op.operand = this_operand;
11167               i.rounding = &rc_op;
11168             }
11169           else
11170             {
11171               as_bad (_("duplicated `%s'"), imm_start);
11172               return 0;
11173             }
11174           pstr += RC_NamesTable[j].len;
11175           match_found = 1;
11176           break;
11177         }
11178     }
11179   if (!match_found)
11180     return 0;
11181
11182   if (*pstr++ != '}')
11183     {
11184       as_bad (_("Missing '}': '%s'"), imm_start);
11185       return 0;
11186     }
11187   /* RC/SAE immediate string should contain nothing more.  */;
11188   if (*pstr != 0)
11189     {
11190       as_bad (_("Junk after '}': '%s'"), imm_start);
11191       return 0;
11192     }
11193
11194   exp = &im_expressions[i.imm_operands++];
11195   i.op[this_operand].imms = exp;
11196
11197   exp->X_op = O_constant;
11198   exp->X_add_number = 0;
11199   exp->X_add_symbol = (symbolS *) 0;
11200   exp->X_op_symbol = (symbolS *) 0;
11201
11202   i.types[this_operand].bitfield.imm8 = 1;
11203   return 1;
11204 }
11205
11206 /* Only string instructions can have a second memory operand, so
11207    reduce current_templates to just those if it contains any.  */
11208 static int
11209 maybe_adjust_templates (void)
11210 {
11211   const insn_template *t;
11212
11213   gas_assert (i.mem_operands == 1);
11214
11215   for (t = current_templates->start; t < current_templates->end; ++t)
11216     if (t->opcode_modifier.isstring)
11217       break;
11218
11219   if (t < current_templates->end)
11220     {
11221       static templates aux_templates;
11222       bfd_boolean recheck;
11223
11224       aux_templates.start = t;
11225       for (; t < current_templates->end; ++t)
11226         if (!t->opcode_modifier.isstring)
11227           break;
11228       aux_templates.end = t;
11229
11230       /* Determine whether to re-check the first memory operand.  */
11231       recheck = (aux_templates.start != current_templates->start
11232                  || t != current_templates->end);
11233
11234       current_templates = &aux_templates;
11235
11236       if (recheck)
11237         {
11238           i.mem_operands = 0;
11239           if (i.memop1_string != NULL
11240               && i386_index_check (i.memop1_string) == 0)
11241             return 0;
11242           i.mem_operands = 1;
11243         }
11244     }
11245
11246   return 1;
11247 }
11248
11249 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
11250    on error.  */
11251
11252 static int
11253 i386_att_operand (char *operand_string)
11254 {
11255   const reg_entry *r;
11256   char *end_op;
11257   char *op_string = operand_string;
11258
11259   if (is_space_char (*op_string))
11260     ++op_string;
11261
11262   /* We check for an absolute prefix (differentiating,
11263      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
11264   if (*op_string == ABSOLUTE_PREFIX)
11265     {
11266       ++op_string;
11267       if (is_space_char (*op_string))
11268         ++op_string;
11269       i.jumpabsolute = TRUE;
11270     }
11271
11272   /* Check if operand is a register.  */
11273   if ((r = parse_register (op_string, &end_op)) != NULL)
11274     {
11275       i386_operand_type temp;
11276
11277       if (r == &bad_reg)
11278         return 0;
11279
11280       /* Check for a segment override by searching for ':' after a
11281          segment register.  */
11282       op_string = end_op;
11283       if (is_space_char (*op_string))
11284         ++op_string;
11285       if (*op_string == ':' && r->reg_type.bitfield.class == SReg)
11286         {
11287           switch (r->reg_num)
11288             {
11289             case 0:
11290               i.seg[i.mem_operands] = &es;
11291               break;
11292             case 1:
11293               i.seg[i.mem_operands] = &cs;
11294               break;
11295             case 2:
11296               i.seg[i.mem_operands] = &ss;
11297               break;
11298             case 3:
11299               i.seg[i.mem_operands] = &ds;
11300               break;
11301             case 4:
11302               i.seg[i.mem_operands] = &fs;
11303               break;
11304             case 5:
11305               i.seg[i.mem_operands] = &gs;
11306               break;
11307             }
11308
11309           /* Skip the ':' and whitespace.  */
11310           ++op_string;
11311           if (is_space_char (*op_string))
11312             ++op_string;
11313
11314           if (!is_digit_char (*op_string)
11315               && !is_identifier_char (*op_string)
11316               && *op_string != '('
11317               && *op_string != ABSOLUTE_PREFIX)
11318             {
11319               as_bad (_("bad memory operand `%s'"), op_string);
11320               return 0;
11321             }
11322           /* Handle case of %es:*foo.  */
11323           if (*op_string == ABSOLUTE_PREFIX)
11324             {
11325               ++op_string;
11326               if (is_space_char (*op_string))
11327                 ++op_string;
11328               i.jumpabsolute = TRUE;
11329             }
11330           goto do_memory_reference;
11331         }
11332
11333       /* Handle vector operations.  */
11334       if (*op_string == '{')
11335         {
11336           op_string = check_VecOperations (op_string, NULL);
11337           if (op_string == NULL)
11338             return 0;
11339         }
11340
11341       if (*op_string)
11342         {
11343           as_bad (_("junk `%s' after register"), op_string);
11344           return 0;
11345         }
11346       temp = r->reg_type;
11347       temp.bitfield.baseindex = 0;
11348       i.types[this_operand] = operand_type_or (i.types[this_operand],
11349                                                temp);
11350       i.types[this_operand].bitfield.unspecified = 0;
11351       i.op[this_operand].regs = r;
11352       i.reg_operands++;
11353     }
11354   else if (*op_string == REGISTER_PREFIX)
11355     {
11356       as_bad (_("bad register name `%s'"), op_string);
11357       return 0;
11358     }
11359   else if (*op_string == IMMEDIATE_PREFIX)
11360     {
11361       ++op_string;
11362       if (i.jumpabsolute)
11363         {
11364           as_bad (_("immediate operand illegal with absolute jump"));
11365           return 0;
11366         }
11367       if (!i386_immediate (op_string))
11368         return 0;
11369     }
11370   else if (RC_SAE_immediate (operand_string))
11371     {
11372       /* If it is a RC or SAE immediate, do nothing.  */
11373       ;
11374     }
11375   else if (is_digit_char (*op_string)
11376            || is_identifier_char (*op_string)
11377            || *op_string == '"'
11378            || *op_string == '(')
11379     {
11380       /* This is a memory reference of some sort.  */
11381       char *base_string;
11382
11383       /* Start and end of displacement string expression (if found).  */
11384       char *displacement_string_start;
11385       char *displacement_string_end;
11386       char *vop_start;
11387
11388     do_memory_reference:
11389       if (i.mem_operands == 1 && !maybe_adjust_templates ())
11390         return 0;
11391       if ((i.mem_operands == 1
11392            && !current_templates->start->opcode_modifier.isstring)
11393           || i.mem_operands == 2)
11394         {
11395           as_bad (_("too many memory references for `%s'"),
11396                   current_templates->start->name);
11397           return 0;
11398         }
11399
11400       /* Check for base index form.  We detect the base index form by
11401          looking for an ')' at the end of the operand, searching
11402          for the '(' matching it, and finding a REGISTER_PREFIX or ','
11403          after the '('.  */
11404       base_string = op_string + strlen (op_string);
11405
11406       /* Handle vector operations.  */
11407       vop_start = strchr (op_string, '{');
11408       if (vop_start && vop_start < base_string)
11409         {
11410           if (check_VecOperations (vop_start, base_string) == NULL)
11411             return 0;
11412           base_string = vop_start;
11413         }
11414
11415       --base_string;
11416       if (is_space_char (*base_string))
11417         --base_string;
11418
11419       /* If we only have a displacement, set-up for it to be parsed later.  */
11420       displacement_string_start = op_string;
11421       displacement_string_end = base_string + 1;
11422
11423       if (*base_string == ')')
11424         {
11425           char *temp_string;
11426           unsigned int parens_balanced = 1;
11427           /* We've already checked that the number of left & right ()'s are
11428              equal, so this loop will not be infinite.  */
11429           do
11430             {
11431               base_string--;
11432               if (*base_string == ')')
11433                 parens_balanced++;
11434               if (*base_string == '(')
11435                 parens_balanced--;
11436             }
11437           while (parens_balanced);
11438
11439           temp_string = base_string;
11440
11441           /* Skip past '(' and whitespace.  */
11442           ++base_string;
11443           if (is_space_char (*base_string))
11444             ++base_string;
11445
11446           if (*base_string == ','
11447               || ((i.base_reg = parse_register (base_string, &end_op))
11448                   != NULL))
11449             {
11450               displacement_string_end = temp_string;
11451
11452               i.types[this_operand].bitfield.baseindex = 1;
11453
11454               if (i.base_reg)
11455                 {
11456                   if (i.base_reg == &bad_reg)
11457                     return 0;
11458                   base_string = end_op;
11459                   if (is_space_char (*base_string))
11460                     ++base_string;
11461                 }
11462
11463               /* There may be an index reg or scale factor here.  */
11464               if (*base_string == ',')
11465                 {
11466                   ++base_string;
11467                   if (is_space_char (*base_string))
11468                     ++base_string;
11469
11470                   if ((i.index_reg = parse_register (base_string, &end_op))
11471                       != NULL)
11472                     {
11473                       if (i.index_reg == &bad_reg)
11474                         return 0;
11475                       base_string = end_op;
11476                       if (is_space_char (*base_string))
11477                         ++base_string;
11478                       if (*base_string == ',')
11479                         {
11480                           ++base_string;
11481                           if (is_space_char (*base_string))
11482                             ++base_string;
11483                         }
11484                       else if (*base_string != ')')
11485                         {
11486                           as_bad (_("expecting `,' or `)' "
11487                                     "after index register in `%s'"),
11488                                   operand_string);
11489                           return 0;
11490                         }
11491                     }
11492                   else if (*base_string == REGISTER_PREFIX)
11493                     {
11494                       end_op = strchr (base_string, ',');
11495                       if (end_op)
11496                         *end_op = '\0';
11497                       as_bad (_("bad register name `%s'"), base_string);
11498                       return 0;
11499                     }
11500
11501                   /* Check for scale factor.  */
11502                   if (*base_string != ')')
11503                     {
11504                       char *end_scale = i386_scale (base_string);
11505
11506                       if (!end_scale)
11507                         return 0;
11508
11509                       base_string = end_scale;
11510                       if (is_space_char (*base_string))
11511                         ++base_string;
11512                       if (*base_string != ')')
11513                         {
11514                           as_bad (_("expecting `)' "
11515                                     "after scale factor in `%s'"),
11516                                   operand_string);
11517                           return 0;
11518                         }
11519                     }
11520                   else if (!i.index_reg)
11521                     {
11522                       as_bad (_("expecting index register or scale factor "
11523                                 "after `,'; got '%c'"),
11524                               *base_string);
11525                       return 0;
11526                     }
11527                 }
11528               else if (*base_string != ')')
11529                 {
11530                   as_bad (_("expecting `,' or `)' "
11531                             "after base register in `%s'"),
11532                           operand_string);
11533                   return 0;
11534                 }
11535             }
11536           else if (*base_string == REGISTER_PREFIX)
11537             {
11538               end_op = strchr (base_string, ',');
11539               if (end_op)
11540                 *end_op = '\0';
11541               as_bad (_("bad register name `%s'"), base_string);
11542               return 0;
11543             }
11544         }
11545
11546       /* If there's an expression beginning the operand, parse it,
11547          assuming displacement_string_start and
11548          displacement_string_end are meaningful.  */
11549       if (displacement_string_start != displacement_string_end)
11550         {
11551           if (!i386_displacement (displacement_string_start,
11552                                   displacement_string_end))
11553             return 0;
11554         }
11555
11556       /* Special case for (%dx) while doing input/output op.  */
11557       if (i.base_reg
11558           && i.base_reg->reg_type.bitfield.instance == RegD
11559           && i.base_reg->reg_type.bitfield.word
11560           && i.index_reg == 0
11561           && i.log2_scale_factor == 0
11562           && i.seg[i.mem_operands] == 0
11563           && !operand_type_check (i.types[this_operand], disp))
11564         {
11565           i.types[this_operand] = i.base_reg->reg_type;
11566           return 1;
11567         }
11568
11569       if (i386_index_check (operand_string) == 0)
11570         return 0;
11571       i.flags[this_operand] |= Operand_Mem;
11572       if (i.mem_operands == 0)
11573         i.memop1_string = xstrdup (operand_string);
11574       i.mem_operands++;
11575     }
11576   else
11577     {
11578       /* It's not a memory operand; argh!  */
11579       as_bad (_("invalid char %s beginning operand %d `%s'"),
11580               output_invalid (*op_string),
11581               this_operand + 1,
11582               op_string);
11583       return 0;
11584     }
11585   return 1;                     /* Normal return.  */
11586 }
11587 \f
11588 /* Calculate the maximum variable size (i.e., excluding fr_fix)
11589    that an rs_machine_dependent frag may reach.  */
11590
11591 unsigned int
11592 i386_frag_max_var (fragS *frag)
11593 {
11594   /* The only relaxable frags are for jumps.
11595      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
11596   gas_assert (frag->fr_type == rs_machine_dependent);
11597   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
11598 }
11599
11600 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11601 static int
11602 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
11603 {
11604   /* STT_GNU_IFUNC symbol must go through PLT.  */
11605   if ((symbol_get_bfdsym (fr_symbol)->flags
11606        & BSF_GNU_INDIRECT_FUNCTION) != 0)
11607     return 0;
11608
11609   if (!S_IS_EXTERNAL (fr_symbol))
11610     /* Symbol may be weak or local.  */
11611     return !S_IS_WEAK (fr_symbol);
11612
11613   /* Global symbols with non-default visibility can't be preempted. */
11614   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
11615     return 1;
11616
11617   if (fr_var != NO_RELOC)
11618     switch ((enum bfd_reloc_code_real) fr_var)
11619       {
11620       case BFD_RELOC_386_PLT32:
11621       case BFD_RELOC_X86_64_PLT32:
11622         /* Symbol with PLT relocation may be preempted. */
11623         return 0;
11624       default:
11625         abort ();
11626       }
11627
11628   /* Global symbols with default visibility in a shared library may be
11629      preempted by another definition.  */
11630   return !shared;
11631 }
11632 #endif
11633
11634 /* Table 3-2. Macro-Fusible Instructions in Haswell Microarchitecture
11635    Note also work for Skylake and Cascadelake.
11636 ---------------------------------------------------------------------
11637 |   JCC   | ADD/SUB/CMP | INC/DEC | TEST/AND |
11638 | ------  | ----------- | ------- | -------- |
11639 |   Jo    |      N      |    N    |     Y    |
11640 |   Jno   |      N      |    N    |     Y    |
11641 |  Jc/Jb  |      Y      |    N    |     Y    |
11642 | Jae/Jnb |      Y      |    N    |     Y    |
11643 |  Je/Jz  |      Y      |    Y    |     Y    |
11644 | Jne/Jnz |      Y      |    Y    |     Y    |
11645 | Jna/Jbe |      Y      |    N    |     Y    |
11646 | Ja/Jnbe |      Y      |    N    |     Y    |
11647 |   Js    |      N      |    N    |     Y    |
11648 |   Jns   |      N      |    N    |     Y    |
11649 |  Jp/Jpe |      N      |    N    |     Y    |
11650 | Jnp/Jpo |      N      |    N    |     Y    |
11651 | Jl/Jnge |      Y      |    Y    |     Y    |
11652 | Jge/Jnl |      Y      |    Y    |     Y    |
11653 | Jle/Jng |      Y      |    Y    |     Y    |
11654 | Jg/Jnle |      Y      |    Y    |     Y    |
11655 ---------------------------------------------------------------------  */
11656 static int
11657 i386_macro_fusible_p (enum mf_cmp_kind mf_cmp, enum mf_jcc_kind mf_jcc)
11658 {
11659   if (mf_cmp == mf_cmp_alu_cmp)
11660     return ((mf_jcc >= mf_jcc_jc && mf_jcc <= mf_jcc_jna)
11661             || mf_jcc == mf_jcc_jl || mf_jcc == mf_jcc_jle);
11662   if (mf_cmp == mf_cmp_incdec)
11663     return (mf_jcc == mf_jcc_je || mf_jcc == mf_jcc_jl
11664             || mf_jcc == mf_jcc_jle);
11665   if (mf_cmp == mf_cmp_test_and)
11666     return 1;
11667   return 0;
11668 }
11669
11670 /* Return the next non-empty frag.  */
11671
11672 static fragS *
11673 i386_next_non_empty_frag (fragS *fragP)
11674 {
11675   /* There may be a frag with a ".fill 0" when there is no room in
11676      the current frag for frag_grow in output_insn.  */
11677   for (fragP = fragP->fr_next;
11678        (fragP != NULL
11679         && fragP->fr_type == rs_fill
11680         && fragP->fr_fix == 0);
11681        fragP = fragP->fr_next)
11682     ;
11683   return fragP;
11684 }
11685
11686 /* Return the next jcc frag after BRANCH_PADDING.  */
11687
11688 static fragS *
11689 i386_next_fusible_jcc_frag (fragS *maybe_cmp_fragP, fragS *pad_fragP)
11690 {
11691   fragS *branch_fragP;
11692   if (!pad_fragP)
11693     return NULL;
11694
11695   if (pad_fragP->fr_type == rs_machine_dependent
11696       && (TYPE_FROM_RELAX_STATE (pad_fragP->fr_subtype)
11697           == BRANCH_PADDING))
11698     {
11699       branch_fragP = i386_next_non_empty_frag (pad_fragP);
11700       if (branch_fragP->fr_type != rs_machine_dependent)
11701         return NULL;
11702       if (TYPE_FROM_RELAX_STATE (branch_fragP->fr_subtype) == COND_JUMP
11703           && i386_macro_fusible_p (maybe_cmp_fragP->tc_frag_data.mf_type,
11704                                    pad_fragP->tc_frag_data.mf_type))
11705         return branch_fragP;
11706     }
11707
11708   return NULL;
11709 }
11710
11711 /* Classify BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING frags.  */
11712
11713 static void
11714 i386_classify_machine_dependent_frag (fragS *fragP)
11715 {
11716   fragS *cmp_fragP;
11717   fragS *pad_fragP;
11718   fragS *branch_fragP;
11719   fragS *next_fragP;
11720   unsigned int max_prefix_length;
11721
11722   if (fragP->tc_frag_data.classified)
11723     return;
11724
11725   /* First scan for BRANCH_PADDING and FUSED_JCC_PADDING.  Convert
11726      FUSED_JCC_PADDING and merge BRANCH_PADDING.  */
11727   for (next_fragP = fragP;
11728        next_fragP != NULL;
11729        next_fragP = next_fragP->fr_next)
11730     {
11731       next_fragP->tc_frag_data.classified = 1;
11732       if (next_fragP->fr_type == rs_machine_dependent)
11733         switch (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype))
11734           {
11735           case BRANCH_PADDING:
11736             /* The BRANCH_PADDING frag must be followed by a branch
11737                frag.  */
11738             branch_fragP = i386_next_non_empty_frag (next_fragP);
11739             next_fragP->tc_frag_data.u.branch_fragP = branch_fragP;
11740             break;
11741           case FUSED_JCC_PADDING:
11742             /* Check if this is a fused jcc:
11743                FUSED_JCC_PADDING
11744                CMP like instruction
11745                BRANCH_PADDING
11746                COND_JUMP
11747                */
11748             cmp_fragP = i386_next_non_empty_frag (next_fragP);
11749             pad_fragP = i386_next_non_empty_frag (cmp_fragP);
11750             branch_fragP = i386_next_fusible_jcc_frag (next_fragP, pad_fragP);
11751             if (branch_fragP)
11752               {
11753                 /* The BRANCH_PADDING frag is merged with the
11754                    FUSED_JCC_PADDING frag.  */
11755                 next_fragP->tc_frag_data.u.branch_fragP = branch_fragP;
11756                 /* CMP like instruction size.  */
11757                 next_fragP->tc_frag_data.cmp_size = cmp_fragP->fr_fix;
11758                 frag_wane (pad_fragP);
11759                 /* Skip to branch_fragP.  */
11760                 next_fragP = branch_fragP;
11761               }
11762             else if (next_fragP->tc_frag_data.max_prefix_length)
11763               {
11764                 /* Turn FUSED_JCC_PADDING into BRANCH_PREFIX if it isn't
11765                    a fused jcc.  */
11766                 next_fragP->fr_subtype
11767                   = ENCODE_RELAX_STATE (BRANCH_PREFIX, 0);
11768                 next_fragP->tc_frag_data.max_bytes
11769                   = next_fragP->tc_frag_data.max_prefix_length;
11770                 /* This will be updated in the BRANCH_PREFIX scan.  */
11771                 next_fragP->tc_frag_data.max_prefix_length = 0;
11772               }
11773             else
11774               frag_wane (next_fragP);
11775             break;
11776           }
11777     }
11778
11779   /* Stop if there is no BRANCH_PREFIX.  */
11780   if (!align_branch_prefix_size)
11781     return;
11782
11783   /* Scan for BRANCH_PREFIX.  */
11784   for (; fragP != NULL; fragP = fragP->fr_next)
11785     {
11786       if (fragP->fr_type != rs_machine_dependent
11787           || (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
11788               != BRANCH_PREFIX))
11789         continue;
11790
11791       /* Count all BRANCH_PREFIX frags before BRANCH_PADDING and
11792          COND_JUMP_PREFIX.  */
11793       max_prefix_length = 0;
11794       for (next_fragP = fragP;
11795            next_fragP != NULL;
11796            next_fragP = next_fragP->fr_next)
11797         {
11798           if (next_fragP->fr_type == rs_fill)
11799             /* Skip rs_fill frags.  */
11800             continue;
11801           else if (next_fragP->fr_type != rs_machine_dependent)
11802             /* Stop for all other frags.  */
11803             break;
11804
11805           /* rs_machine_dependent frags.  */
11806           if (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11807               == BRANCH_PREFIX)
11808             {
11809               /* Count BRANCH_PREFIX frags.  */
11810               if (max_prefix_length >= MAX_FUSED_JCC_PADDING_SIZE)
11811                 {
11812                   max_prefix_length = MAX_FUSED_JCC_PADDING_SIZE;
11813                   frag_wane (next_fragP);
11814                 }
11815               else
11816                 max_prefix_length
11817                   += next_fragP->tc_frag_data.max_bytes;
11818             }
11819           else if ((TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11820                     == BRANCH_PADDING)
11821                    || (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11822                        == FUSED_JCC_PADDING))
11823             {
11824               /* Stop at BRANCH_PADDING and FUSED_JCC_PADDING.  */
11825               fragP->tc_frag_data.u.padding_fragP = next_fragP;
11826               break;
11827             }
11828           else
11829             /* Stop for other rs_machine_dependent frags.  */
11830             break;
11831         }
11832
11833       fragP->tc_frag_data.max_prefix_length = max_prefix_length;
11834
11835       /* Skip to the next frag.  */
11836       fragP = next_fragP;
11837     }
11838 }
11839
11840 /* Compute padding size for
11841
11842         FUSED_JCC_PADDING
11843         CMP like instruction
11844         BRANCH_PADDING
11845         COND_JUMP/UNCOND_JUMP
11846
11847    or
11848
11849         BRANCH_PADDING
11850         COND_JUMP/UNCOND_JUMP
11851  */
11852
11853 static int
11854 i386_branch_padding_size (fragS *fragP, offsetT address)
11855 {
11856   unsigned int offset, size, padding_size;
11857   fragS *branch_fragP = fragP->tc_frag_data.u.branch_fragP;
11858
11859   /* The start address of the BRANCH_PADDING or FUSED_JCC_PADDING frag.  */
11860   if (!address)
11861     address = fragP->fr_address;
11862   address += fragP->fr_fix;
11863
11864   /* CMP like instrunction size.  */
11865   size = fragP->tc_frag_data.cmp_size;
11866
11867   /* The base size of the branch frag.  */
11868   size += branch_fragP->fr_fix;
11869
11870   /* Add opcode and displacement bytes for the rs_machine_dependent
11871      branch frag.  */
11872   if (branch_fragP->fr_type == rs_machine_dependent)
11873     size += md_relax_table[branch_fragP->fr_subtype].rlx_length;
11874
11875   /* Check if branch is within boundary and doesn't end at the last
11876      byte.  */
11877   offset = address & ((1U << align_branch_power) - 1);
11878   if ((offset + size) >= (1U << align_branch_power))
11879     /* Padding needed to avoid crossing boundary.  */
11880     padding_size = (1U << align_branch_power) - offset;
11881   else
11882     /* No padding needed.  */
11883     padding_size = 0;
11884
11885   /* The return value may be saved in tc_frag_data.length which is
11886      unsigned byte.  */
11887   if (!fits_in_unsigned_byte (padding_size))
11888     abort ();
11889
11890   return padding_size;
11891 }
11892
11893 /* i386_generic_table_relax_frag()
11894
11895    Handle BRANCH_PADDING, BRANCH_PREFIX and FUSED_JCC_PADDING frags to
11896    grow/shrink padding to align branch frags.  Hand others to
11897    relax_frag().  */
11898
11899 long
11900 i386_generic_table_relax_frag (segT segment, fragS *fragP, long stretch)
11901 {
11902   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
11903       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
11904     {
11905       long padding_size = i386_branch_padding_size (fragP, 0);
11906       long grow = padding_size - fragP->tc_frag_data.length;
11907
11908       /* When the BRANCH_PREFIX frag is used, the computed address
11909          must match the actual address and there should be no padding.  */
11910       if (fragP->tc_frag_data.padding_address
11911           && (fragP->tc_frag_data.padding_address != fragP->fr_address
11912               || padding_size))
11913         abort ();
11914
11915       /* Update the padding size.  */
11916       if (grow)
11917         fragP->tc_frag_data.length = padding_size;
11918
11919       return grow;
11920     }
11921   else if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
11922     {
11923       fragS *padding_fragP, *next_fragP;
11924       long padding_size, left_size, last_size;
11925
11926       padding_fragP = fragP->tc_frag_data.u.padding_fragP;
11927       if (!padding_fragP)
11928         /* Use the padding set by the leading BRANCH_PREFIX frag.  */
11929         return (fragP->tc_frag_data.length
11930                 - fragP->tc_frag_data.last_length);
11931
11932       /* Compute the relative address of the padding frag in the very
11933         first time where the BRANCH_PREFIX frag sizes are zero.  */
11934       if (!fragP->tc_frag_data.padding_address)
11935         fragP->tc_frag_data.padding_address
11936           = padding_fragP->fr_address - (fragP->fr_address - stretch);
11937
11938       /* First update the last length from the previous interation.  */
11939       left_size = fragP->tc_frag_data.prefix_length;
11940       for (next_fragP = fragP;
11941            next_fragP != padding_fragP;
11942            next_fragP = next_fragP->fr_next)
11943         if (next_fragP->fr_type == rs_machine_dependent
11944             && (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
11945                 == BRANCH_PREFIX))
11946           {
11947             if (left_size)
11948               {
11949                 int max = next_fragP->tc_frag_data.max_bytes;
11950                 if (max)
11951                   {
11952                     int size;
11953                     if (max > left_size)
11954                       size = left_size;
11955                     else
11956                       size = max;
11957                     left_size -= size;
11958                     next_fragP->tc_frag_data.last_length = size;
11959                   }
11960               }
11961             else
11962               next_fragP->tc_frag_data.last_length = 0;
11963           }
11964
11965       /* Check the padding size for the padding frag.  */
11966       padding_size = i386_branch_padding_size
11967         (padding_fragP, (fragP->fr_address
11968                          + fragP->tc_frag_data.padding_address));
11969
11970       last_size = fragP->tc_frag_data.prefix_length;
11971       /* Check if there is change from the last interation.  */
11972       if (padding_size == last_size)
11973         {
11974           /* Update the expected address of the padding frag.  */
11975           padding_fragP->tc_frag_data.padding_address
11976             = (fragP->fr_address + padding_size
11977                + fragP->tc_frag_data.padding_address);
11978           return 0;
11979         }
11980
11981       if (padding_size > fragP->tc_frag_data.max_prefix_length)
11982         {
11983           /* No padding if there is no sufficient room.  Clear the
11984              expected address of the padding frag.  */
11985           padding_fragP->tc_frag_data.padding_address = 0;
11986           padding_size = 0;
11987         }
11988       else
11989         /* Store the expected address of the padding frag.  */
11990         padding_fragP->tc_frag_data.padding_address
11991           = (fragP->fr_address + padding_size
11992              + fragP->tc_frag_data.padding_address);
11993
11994       fragP->tc_frag_data.prefix_length = padding_size;
11995
11996       /* Update the length for the current interation.  */
11997       left_size = padding_size;
11998       for (next_fragP = fragP;
11999            next_fragP != padding_fragP;
12000            next_fragP = next_fragP->fr_next)
12001         if (next_fragP->fr_type == rs_machine_dependent
12002             && (TYPE_FROM_RELAX_STATE (next_fragP->fr_subtype)
12003                 == BRANCH_PREFIX))
12004           {
12005             if (left_size)
12006               {
12007                 int max = next_fragP->tc_frag_data.max_bytes;
12008                 if (max)
12009                   {
12010                     int size;
12011                     if (max > left_size)
12012                       size = left_size;
12013                     else
12014                       size = max;
12015                     left_size -= size;
12016                     next_fragP->tc_frag_data.length = size;
12017                   }
12018               }
12019             else
12020               next_fragP->tc_frag_data.length = 0;
12021           }
12022
12023       return (fragP->tc_frag_data.length
12024               - fragP->tc_frag_data.last_length);
12025     }
12026   return relax_frag (segment, fragP, stretch);
12027 }
12028
12029 /* md_estimate_size_before_relax()
12030
12031    Called just before relax() for rs_machine_dependent frags.  The x86
12032    assembler uses these frags to handle variable size jump
12033    instructions.
12034
12035    Any symbol that is now undefined will not become defined.
12036    Return the correct fr_subtype in the frag.
12037    Return the initial "guess for variable size of frag" to caller.
12038    The guess is actually the growth beyond the fixed part.  Whatever
12039    we do to grow the fixed or variable part contributes to our
12040    returned value.  */
12041
12042 int
12043 md_estimate_size_before_relax (fragS *fragP, segT segment)
12044 {
12045   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
12046       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX
12047       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING)
12048     {
12049       i386_classify_machine_dependent_frag (fragP);
12050       return fragP->tc_frag_data.length;
12051     }
12052
12053   /* We've already got fragP->fr_subtype right;  all we have to do is
12054      check for un-relaxable symbols.  On an ELF system, we can't relax
12055      an externally visible symbol, because it may be overridden by a
12056      shared library.  */
12057   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
12058 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12059       || (IS_ELF
12060           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
12061                                                 fragP->fr_var))
12062 #endif
12063 #if defined (OBJ_COFF) && defined (TE_PE)
12064       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
12065           && S_IS_WEAK (fragP->fr_symbol))
12066 #endif
12067       )
12068     {
12069       /* Symbol is undefined in this segment, or we need to keep a
12070          reloc so that weak symbols can be overridden.  */
12071       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
12072       enum bfd_reloc_code_real reloc_type;
12073       unsigned char *opcode;
12074       int old_fr_fix;
12075
12076       if (fragP->fr_var != NO_RELOC)
12077         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
12078       else if (size == 2)
12079         reloc_type = BFD_RELOC_16_PCREL;
12080 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12081       else if (need_plt32_p (fragP->fr_symbol))
12082         reloc_type = BFD_RELOC_X86_64_PLT32;
12083 #endif
12084       else
12085         reloc_type = BFD_RELOC_32_PCREL;
12086
12087       old_fr_fix = fragP->fr_fix;
12088       opcode = (unsigned char *) fragP->fr_opcode;
12089
12090       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
12091         {
12092         case UNCOND_JUMP:
12093           /* Make jmp (0xeb) a (d)word displacement jump.  */
12094           opcode[0] = 0xe9;
12095           fragP->fr_fix += size;
12096           fix_new (fragP, old_fr_fix, size,
12097                    fragP->fr_symbol,
12098                    fragP->fr_offset, 1,
12099                    reloc_type);
12100           break;
12101
12102         case COND_JUMP86:
12103           if (size == 2
12104               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
12105             {
12106               /* Negate the condition, and branch past an
12107                  unconditional jump.  */
12108               opcode[0] ^= 1;
12109               opcode[1] = 3;
12110               /* Insert an unconditional jump.  */
12111               opcode[2] = 0xe9;
12112               /* We added two extra opcode bytes, and have a two byte
12113                  offset.  */
12114               fragP->fr_fix += 2 + 2;
12115               fix_new (fragP, old_fr_fix + 2, 2,
12116                        fragP->fr_symbol,
12117                        fragP->fr_offset, 1,
12118                        reloc_type);
12119               break;
12120             }
12121           /* Fall through.  */
12122
12123         case COND_JUMP:
12124           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
12125             {
12126               fixS *fixP;
12127
12128               fragP->fr_fix += 1;
12129               fixP = fix_new (fragP, old_fr_fix, 1,
12130                               fragP->fr_symbol,
12131                               fragP->fr_offset, 1,
12132                               BFD_RELOC_8_PCREL);
12133               fixP->fx_signed = 1;
12134               break;
12135             }
12136
12137           /* This changes the byte-displacement jump 0x7N
12138              to the (d)word-displacement jump 0x0f,0x8N.  */
12139           opcode[1] = opcode[0] + 0x10;
12140           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12141           /* We've added an opcode byte.  */
12142           fragP->fr_fix += 1 + size;
12143           fix_new (fragP, old_fr_fix + 1, size,
12144                    fragP->fr_symbol,
12145                    fragP->fr_offset, 1,
12146                    reloc_type);
12147           break;
12148
12149         default:
12150           BAD_CASE (fragP->fr_subtype);
12151           break;
12152         }
12153       frag_wane (fragP);
12154       return fragP->fr_fix - old_fr_fix;
12155     }
12156
12157   /* Guess size depending on current relax state.  Initially the relax
12158      state will correspond to a short jump and we return 1, because
12159      the variable part of the frag (the branch offset) is one byte
12160      long.  However, we can relax a section more than once and in that
12161      case we must either set fr_subtype back to the unrelaxed state,
12162      or return the value for the appropriate branch.  */
12163   return md_relax_table[fragP->fr_subtype].rlx_length;
12164 }
12165
12166 /* Called after relax() is finished.
12167
12168    In:  Address of frag.
12169         fr_type == rs_machine_dependent.
12170         fr_subtype is what the address relaxed to.
12171
12172    Out: Any fixSs and constants are set up.
12173         Caller will turn frag into a ".space 0".  */
12174
12175 void
12176 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
12177                  fragS *fragP)
12178 {
12179   unsigned char *opcode;
12180   unsigned char *where_to_put_displacement = NULL;
12181   offsetT target_address;
12182   offsetT opcode_address;
12183   unsigned int extension = 0;
12184   offsetT displacement_from_opcode_start;
12185
12186   if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PADDING
12187       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == FUSED_JCC_PADDING
12188       || TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
12189     {
12190       /* Generate nop padding.  */
12191       unsigned int size = fragP->tc_frag_data.length;
12192       if (size)
12193         {
12194           if (size > fragP->tc_frag_data.max_bytes)
12195             abort ();
12196
12197           if (flag_debug)
12198             {
12199               const char *msg;
12200               const char *branch = "branch";
12201               const char *prefix = "";
12202               fragS *padding_fragP;
12203               if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype)
12204                   == BRANCH_PREFIX)
12205                 {
12206                   padding_fragP = fragP->tc_frag_data.u.padding_fragP;
12207                   switch (fragP->tc_frag_data.default_prefix)
12208                     {
12209                     default:
12210                       abort ();
12211                       break;
12212                     case CS_PREFIX_OPCODE:
12213                       prefix = " cs";
12214                       break;
12215                     case DS_PREFIX_OPCODE:
12216                       prefix = " ds";
12217                       break;
12218                     case ES_PREFIX_OPCODE:
12219                       prefix = " es";
12220                       break;
12221                     case FS_PREFIX_OPCODE:
12222                       prefix = " fs";
12223                       break;
12224                     case GS_PREFIX_OPCODE:
12225                       prefix = " gs";
12226                       break;
12227                     case SS_PREFIX_OPCODE:
12228                       prefix = " ss";
12229                       break;
12230                     }
12231                   if (padding_fragP)
12232                     msg = _("%s:%u: add %d%s at 0x%llx to align "
12233                             "%s within %d-byte boundary\n");
12234                   else
12235                     msg = _("%s:%u: add additional %d%s at 0x%llx to "
12236                             "align %s within %d-byte boundary\n");
12237                 }
12238               else
12239                 {
12240                   padding_fragP = fragP;
12241                   msg = _("%s:%u: add %d%s-byte nop at 0x%llx to align "
12242                           "%s within %d-byte boundary\n");
12243                 }
12244
12245               if (padding_fragP)
12246                 switch (padding_fragP->tc_frag_data.branch_type)
12247                   {
12248                   case align_branch_jcc:
12249                     branch = "jcc";
12250                     break;
12251                   case align_branch_fused:
12252                     branch = "fused jcc";
12253                     break;
12254                   case align_branch_jmp:
12255                     branch = "jmp";
12256                     break;
12257                   case align_branch_call:
12258                     branch = "call";
12259                     break;
12260                   case align_branch_indirect:
12261                     branch = "indiret branch";
12262                     break;
12263                   case align_branch_ret:
12264                     branch = "ret";
12265                     break;
12266                   default:
12267                     break;
12268                   }
12269
12270               fprintf (stdout, msg,
12271                        fragP->fr_file, fragP->fr_line, size, prefix,
12272                        (long long) fragP->fr_address, branch,
12273                        1 << align_branch_power);
12274             }
12275           if (TYPE_FROM_RELAX_STATE (fragP->fr_subtype) == BRANCH_PREFIX)
12276             memset (fragP->fr_opcode,
12277                     fragP->tc_frag_data.default_prefix, size);
12278           else
12279             i386_generate_nops (fragP, (char *) fragP->fr_opcode,
12280                                 size, 0);
12281           fragP->fr_fix += size;
12282         }
12283       return;
12284     }
12285
12286   opcode = (unsigned char *) fragP->fr_opcode;
12287
12288   /* Address we want to reach in file space.  */
12289   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
12290
12291   /* Address opcode resides at in file space.  */
12292   opcode_address = fragP->fr_address + fragP->fr_fix;
12293
12294   /* Displacement from opcode start to fill into instruction.  */
12295   displacement_from_opcode_start = target_address - opcode_address;
12296
12297   if ((fragP->fr_subtype & BIG) == 0)
12298     {
12299       /* Don't have to change opcode.  */
12300       extension = 1;            /* 1 opcode + 1 displacement  */
12301       where_to_put_displacement = &opcode[1];
12302     }
12303   else
12304     {
12305       if (no_cond_jump_promotion
12306           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
12307         as_warn_where (fragP->fr_file, fragP->fr_line,
12308                        _("long jump required"));
12309
12310       switch (fragP->fr_subtype)
12311         {
12312         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
12313           extension = 4;                /* 1 opcode + 4 displacement  */
12314           opcode[0] = 0xe9;
12315           where_to_put_displacement = &opcode[1];
12316           break;
12317
12318         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
12319           extension = 2;                /* 1 opcode + 2 displacement  */
12320           opcode[0] = 0xe9;
12321           where_to_put_displacement = &opcode[1];
12322           break;
12323
12324         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
12325         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
12326           extension = 5;                /* 2 opcode + 4 displacement  */
12327           opcode[1] = opcode[0] + 0x10;
12328           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12329           where_to_put_displacement = &opcode[2];
12330           break;
12331
12332         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
12333           extension = 3;                /* 2 opcode + 2 displacement  */
12334           opcode[1] = opcode[0] + 0x10;
12335           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
12336           where_to_put_displacement = &opcode[2];
12337           break;
12338
12339         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
12340           extension = 4;
12341           opcode[0] ^= 1;
12342           opcode[1] = 3;
12343           opcode[2] = 0xe9;
12344           where_to_put_displacement = &opcode[3];
12345           break;
12346
12347         default:
12348           BAD_CASE (fragP->fr_subtype);
12349           break;
12350         }
12351     }
12352
12353   /* If size if less then four we are sure that the operand fits,
12354      but if it's 4, then it could be that the displacement is larger
12355      then -/+ 2GB.  */
12356   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
12357       && object_64bit
12358       && ((addressT) (displacement_from_opcode_start - extension
12359                       + ((addressT) 1 << 31))
12360           > (((addressT) 2 << 31) - 1)))
12361     {
12362       as_bad_where (fragP->fr_file, fragP->fr_line,
12363                     _("jump target out of range"));
12364       /* Make us emit 0.  */
12365       displacement_from_opcode_start = extension;
12366     }
12367   /* Now put displacement after opcode.  */
12368   md_number_to_chars ((char *) where_to_put_displacement,
12369                       (valueT) (displacement_from_opcode_start - extension),
12370                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
12371   fragP->fr_fix += extension;
12372 }
12373 \f
12374 /* Apply a fixup (fixP) to segment data, once it has been determined
12375    by our caller that we have all the info we need to fix it up.
12376
12377    Parameter valP is the pointer to the value of the bits.
12378
12379    On the 386, immediates, displacements, and data pointers are all in
12380    the same (little-endian) format, so we don't need to care about which
12381    we are handling.  */
12382
12383 void
12384 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
12385 {
12386   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
12387   valueT value = *valP;
12388
12389 #if !defined (TE_Mach)
12390   if (fixP->fx_pcrel)
12391     {
12392       switch (fixP->fx_r_type)
12393         {
12394         default:
12395           break;
12396
12397         case BFD_RELOC_64:
12398           fixP->fx_r_type = BFD_RELOC_64_PCREL;
12399           break;
12400         case BFD_RELOC_32:
12401         case BFD_RELOC_X86_64_32S:
12402           fixP->fx_r_type = BFD_RELOC_32_PCREL;
12403           break;
12404         case BFD_RELOC_16:
12405           fixP->fx_r_type = BFD_RELOC_16_PCREL;
12406           break;
12407         case BFD_RELOC_8:
12408           fixP->fx_r_type = BFD_RELOC_8_PCREL;
12409           break;
12410         }
12411     }
12412
12413   if (fixP->fx_addsy != NULL
12414       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
12415           || fixP->fx_r_type == BFD_RELOC_64_PCREL
12416           || fixP->fx_r_type == BFD_RELOC_16_PCREL
12417           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
12418       && !use_rela_relocations)
12419     {
12420       /* This is a hack.  There should be a better way to handle this.
12421          This covers for the fact that bfd_install_relocation will
12422          subtract the current location (for partial_inplace, PC relative
12423          relocations); see more below.  */
12424 #ifndef OBJ_AOUT
12425       if (IS_ELF
12426 #ifdef TE_PE
12427           || OUTPUT_FLAVOR == bfd_target_coff_flavour
12428 #endif
12429           )
12430         value += fixP->fx_where + fixP->fx_frag->fr_address;
12431 #endif
12432 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12433       if (IS_ELF)
12434         {
12435           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
12436
12437           if ((sym_seg == seg
12438                || (symbol_section_p (fixP->fx_addsy)
12439                    && sym_seg != absolute_section))
12440               && !generic_force_reloc (fixP))
12441             {
12442               /* Yes, we add the values in twice.  This is because
12443                  bfd_install_relocation subtracts them out again.  I think
12444                  bfd_install_relocation is broken, but I don't dare change
12445                  it.  FIXME.  */
12446               value += fixP->fx_where + fixP->fx_frag->fr_address;
12447             }
12448         }
12449 #endif
12450 #if defined (OBJ_COFF) && defined (TE_PE)
12451       /* For some reason, the PE format does not store a
12452          section address offset for a PC relative symbol.  */
12453       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
12454           || S_IS_WEAK (fixP->fx_addsy))
12455         value += md_pcrel_from (fixP);
12456 #endif
12457     }
12458 #if defined (OBJ_COFF) && defined (TE_PE)
12459   if (fixP->fx_addsy != NULL
12460       && S_IS_WEAK (fixP->fx_addsy)
12461       /* PR 16858: Do not modify weak function references.  */
12462       && ! fixP->fx_pcrel)
12463     {
12464 #if !defined (TE_PEP)
12465       /* For x86 PE weak function symbols are neither PC-relative
12466          nor do they set S_IS_FUNCTION.  So the only reliable way
12467          to detect them is to check the flags of their containing
12468          section.  */
12469       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
12470           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
12471         ;
12472       else
12473 #endif
12474       value -= S_GET_VALUE (fixP->fx_addsy);
12475     }
12476 #endif
12477
12478   /* Fix a few things - the dynamic linker expects certain values here,
12479      and we must not disappoint it.  */
12480 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12481   if (IS_ELF && fixP->fx_addsy)
12482     switch (fixP->fx_r_type)
12483       {
12484       case BFD_RELOC_386_PLT32:
12485       case BFD_RELOC_X86_64_PLT32:
12486         /* Make the jump instruction point to the address of the operand.
12487            At runtime we merely add the offset to the actual PLT entry.
12488            NB: Subtract the offset size only for jump instructions.  */
12489         if (fixP->fx_pcrel)
12490           value = -4;
12491         break;
12492
12493       case BFD_RELOC_386_TLS_GD:
12494       case BFD_RELOC_386_TLS_LDM:
12495       case BFD_RELOC_386_TLS_IE_32:
12496       case BFD_RELOC_386_TLS_IE:
12497       case BFD_RELOC_386_TLS_GOTIE:
12498       case BFD_RELOC_386_TLS_GOTDESC:
12499       case BFD_RELOC_X86_64_TLSGD:
12500       case BFD_RELOC_X86_64_TLSLD:
12501       case BFD_RELOC_X86_64_GOTTPOFF:
12502       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12503         value = 0; /* Fully resolved at runtime.  No addend.  */
12504         /* Fallthrough */
12505       case BFD_RELOC_386_TLS_LE:
12506       case BFD_RELOC_386_TLS_LDO_32:
12507       case BFD_RELOC_386_TLS_LE_32:
12508       case BFD_RELOC_X86_64_DTPOFF32:
12509       case BFD_RELOC_X86_64_DTPOFF64:
12510       case BFD_RELOC_X86_64_TPOFF32:
12511       case BFD_RELOC_X86_64_TPOFF64:
12512         S_SET_THREAD_LOCAL (fixP->fx_addsy);
12513         break;
12514
12515       case BFD_RELOC_386_TLS_DESC_CALL:
12516       case BFD_RELOC_X86_64_TLSDESC_CALL:
12517         value = 0; /* Fully resolved at runtime.  No addend.  */
12518         S_SET_THREAD_LOCAL (fixP->fx_addsy);
12519         fixP->fx_done = 0;
12520         return;
12521
12522       case BFD_RELOC_VTABLE_INHERIT:
12523       case BFD_RELOC_VTABLE_ENTRY:
12524         fixP->fx_done = 0;
12525         return;
12526
12527       default:
12528         break;
12529       }
12530 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
12531   *valP = value;
12532 #endif /* !defined (TE_Mach)  */
12533
12534   /* Are we finished with this relocation now?  */
12535   if (fixP->fx_addsy == NULL)
12536     fixP->fx_done = 1;
12537 #if defined (OBJ_COFF) && defined (TE_PE)
12538   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
12539     {
12540       fixP->fx_done = 0;
12541       /* Remember value for tc_gen_reloc.  */
12542       fixP->fx_addnumber = value;
12543       /* Clear out the frag for now.  */
12544       value = 0;
12545     }
12546 #endif
12547   else if (use_rela_relocations)
12548     {
12549       fixP->fx_no_overflow = 1;
12550       /* Remember value for tc_gen_reloc.  */
12551       fixP->fx_addnumber = value;
12552       value = 0;
12553     }
12554
12555   md_number_to_chars (p, value, fixP->fx_size);
12556 }
12557 \f
12558 const char *
12559 md_atof (int type, char *litP, int *sizeP)
12560 {
12561   /* This outputs the LITTLENUMs in REVERSE order;
12562      in accord with the bigendian 386.  */
12563   return ieee_md_atof (type, litP, sizeP, FALSE);
12564 }
12565 \f
12566 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
12567
12568 static char *
12569 output_invalid (int c)
12570 {
12571   if (ISPRINT (c))
12572     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
12573               "'%c'", c);
12574   else
12575     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
12576               "(0x%x)", (unsigned char) c);
12577   return output_invalid_buf;
12578 }
12579
12580 /* Verify that @r can be used in the current context.  */
12581
12582 static bfd_boolean check_register (const reg_entry *r)
12583 {
12584   if (allow_pseudo_reg)
12585     return TRUE;
12586
12587   if (operand_type_all_zero (&r->reg_type))
12588     return FALSE;
12589
12590   if ((r->reg_type.bitfield.dword
12591        || (r->reg_type.bitfield.class == SReg && r->reg_num > 3)
12592        || r->reg_type.bitfield.class == RegCR
12593        || r->reg_type.bitfield.class == RegDR)
12594       && !cpu_arch_flags.bitfield.cpui386)
12595     return FALSE;
12596
12597   if (r->reg_type.bitfield.class == RegTR
12598       && (flag_code == CODE_64BIT
12599           || !cpu_arch_flags.bitfield.cpui386
12600           || cpu_arch_isa_flags.bitfield.cpui586
12601           || cpu_arch_isa_flags.bitfield.cpui686))
12602     return FALSE;
12603
12604   if (r->reg_type.bitfield.class == RegMMX && !cpu_arch_flags.bitfield.cpummx)
12605     return FALSE;
12606
12607   if (!cpu_arch_flags.bitfield.cpuavx512f)
12608     {
12609       if (r->reg_type.bitfield.zmmword
12610           || r->reg_type.bitfield.class == RegMask)
12611         return FALSE;
12612
12613       if (!cpu_arch_flags.bitfield.cpuavx)
12614         {
12615           if (r->reg_type.bitfield.ymmword)
12616             return FALSE;
12617
12618           if (!cpu_arch_flags.bitfield.cpusse && r->reg_type.bitfield.xmmword)
12619             return FALSE;
12620         }
12621     }
12622
12623   if (r->reg_type.bitfield.tmmword
12624       && (!cpu_arch_flags.bitfield.cpuamx_tile
12625           || flag_code != CODE_64BIT))
12626     return FALSE;
12627
12628   if (r->reg_type.bitfield.class == RegBND && !cpu_arch_flags.bitfield.cpumpx)
12629     return FALSE;
12630
12631   /* Don't allow fake index register unless allow_index_reg isn't 0. */
12632   if (!allow_index_reg && r->reg_num == RegIZ)
12633     return FALSE;
12634
12635   /* Upper 16 vector registers are only available with VREX in 64bit
12636      mode, and require EVEX encoding.  */
12637   if (r->reg_flags & RegVRex)
12638     {
12639       if (!cpu_arch_flags.bitfield.cpuavx512f
12640           || flag_code != CODE_64BIT)
12641         return FALSE;
12642
12643       if (i.vec_encoding == vex_encoding_default)
12644         i.vec_encoding = vex_encoding_evex;
12645       else if (i.vec_encoding != vex_encoding_evex)
12646         i.vec_encoding = vex_encoding_error;
12647     }
12648
12649   if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword)
12650       && (!cpu_arch_flags.bitfield.cpulm || r->reg_type.bitfield.class != RegCR)
12651       && flag_code != CODE_64BIT)
12652     return FALSE;
12653
12654   if (r->reg_type.bitfield.class == SReg && r->reg_num == RegFlat
12655       && !intel_syntax)
12656     return FALSE;
12657
12658   return TRUE;
12659 }
12660
12661 /* REG_STRING starts *before* REGISTER_PREFIX.  */
12662
12663 static const reg_entry *
12664 parse_real_register (char *reg_string, char **end_op)
12665 {
12666   char *s = reg_string;
12667   char *p;
12668   char reg_name_given[MAX_REG_NAME_SIZE + 1];
12669   const reg_entry *r;
12670
12671   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
12672   if (*s == REGISTER_PREFIX)
12673     ++s;
12674
12675   if (is_space_char (*s))
12676     ++s;
12677
12678   p = reg_name_given;
12679   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
12680     {
12681       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
12682         return (const reg_entry *) NULL;
12683       s++;
12684     }
12685
12686   /* For naked regs, make sure that we are not dealing with an identifier.
12687      This prevents confusing an identifier like `eax_var' with register
12688      `eax'.  */
12689   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
12690     return (const reg_entry *) NULL;
12691
12692   *end_op = s;
12693
12694   r = (const reg_entry *) str_hash_find (reg_hash, reg_name_given);
12695
12696   /* Handle floating point regs, allowing spaces in the (i) part.  */
12697   if (r == i386_regtab /* %st is first entry of table  */)
12698     {
12699       if (!cpu_arch_flags.bitfield.cpu8087
12700           && !cpu_arch_flags.bitfield.cpu287
12701           && !cpu_arch_flags.bitfield.cpu387
12702           && !allow_pseudo_reg)
12703         return (const reg_entry *) NULL;
12704
12705       if (is_space_char (*s))
12706         ++s;
12707       if (*s == '(')
12708         {
12709           ++s;
12710           if (is_space_char (*s))
12711             ++s;
12712           if (*s >= '0' && *s <= '7')
12713             {
12714               int fpr = *s - '0';
12715               ++s;
12716               if (is_space_char (*s))
12717                 ++s;
12718               if (*s == ')')
12719                 {
12720                   *end_op = s + 1;
12721                   r = (const reg_entry *) str_hash_find (reg_hash, "st(0)");
12722                   know (r);
12723                   return r + fpr;
12724                 }
12725             }
12726           /* We have "%st(" then garbage.  */
12727           return (const reg_entry *) NULL;
12728         }
12729     }
12730
12731   return r && check_register (r) ? r : NULL;
12732 }
12733
12734 /* REG_STRING starts *before* REGISTER_PREFIX.  */
12735
12736 static const reg_entry *
12737 parse_register (char *reg_string, char **end_op)
12738 {
12739   const reg_entry *r;
12740
12741   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
12742     r = parse_real_register (reg_string, end_op);
12743   else
12744     r = NULL;
12745   if (!r)
12746     {
12747       char *save = input_line_pointer;
12748       char c;
12749       symbolS *symbolP;
12750
12751       input_line_pointer = reg_string;
12752       c = get_symbol_name (&reg_string);
12753       symbolP = symbol_find (reg_string);
12754       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
12755         {
12756           const expressionS *e = symbol_get_value_expression (symbolP);
12757
12758           know (e->X_op == O_register);
12759           know (e->X_add_number >= 0
12760                 && (valueT) e->X_add_number < i386_regtab_size);
12761           r = i386_regtab + e->X_add_number;
12762           if (!check_register (r))
12763             {
12764               as_bad (_("register '%s%s' cannot be used here"),
12765                       register_prefix, r->reg_name);
12766               r = &bad_reg;
12767             }
12768           *end_op = input_line_pointer;
12769         }
12770       *input_line_pointer = c;
12771       input_line_pointer = save;
12772     }
12773   return r;
12774 }
12775
12776 int
12777 i386_parse_name (char *name, expressionS *e, char *nextcharP)
12778 {
12779   const reg_entry *r;
12780   char *end = input_line_pointer;
12781
12782   *end = *nextcharP;
12783   r = parse_register (name, &input_line_pointer);
12784   if (r && end <= input_line_pointer)
12785     {
12786       *nextcharP = *input_line_pointer;
12787       *input_line_pointer = 0;
12788       if (r != &bad_reg)
12789         {
12790           e->X_op = O_register;
12791           e->X_add_number = r - i386_regtab;
12792         }
12793       else
12794           e->X_op = O_illegal;
12795       return 1;
12796     }
12797   input_line_pointer = end;
12798   *end = 0;
12799   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
12800 }
12801
12802 void
12803 md_operand (expressionS *e)
12804 {
12805   char *end;
12806   const reg_entry *r;
12807
12808   switch (*input_line_pointer)
12809     {
12810     case REGISTER_PREFIX:
12811       r = parse_real_register (input_line_pointer, &end);
12812       if (r)
12813         {
12814           e->X_op = O_register;
12815           e->X_add_number = r - i386_regtab;
12816           input_line_pointer = end;
12817         }
12818       break;
12819
12820     case '[':
12821       gas_assert (intel_syntax);
12822       end = input_line_pointer++;
12823       expression (e);
12824       if (*input_line_pointer == ']')
12825         {
12826           ++input_line_pointer;
12827           e->X_op_symbol = make_expr_symbol (e);
12828           e->X_add_symbol = NULL;
12829           e->X_add_number = 0;
12830           e->X_op = O_index;
12831         }
12832       else
12833         {
12834           e->X_op = O_absent;
12835           input_line_pointer = end;
12836         }
12837       break;
12838     }
12839 }
12840
12841 \f
12842 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12843 const char *md_shortopts = "kVQ:sqnO::";
12844 #else
12845 const char *md_shortopts = "qnO::";
12846 #endif
12847
12848 #define OPTION_32 (OPTION_MD_BASE + 0)
12849 #define OPTION_64 (OPTION_MD_BASE + 1)
12850 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
12851 #define OPTION_MARCH (OPTION_MD_BASE + 3)
12852 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
12853 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
12854 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
12855 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
12856 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
12857 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 9)
12858 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
12859 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
12860 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
12861 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
12862 #define OPTION_X32 (OPTION_MD_BASE + 14)
12863 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
12864 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
12865 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
12866 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
12867 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
12868 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
12869 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
12870 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
12871 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
12872 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
12873 #define OPTION_X86_USED_NOTE (OPTION_MD_BASE + 25)
12874 #define OPTION_MVEXWIG (OPTION_MD_BASE + 26)
12875 #define OPTION_MALIGN_BRANCH_BOUNDARY (OPTION_MD_BASE + 27)
12876 #define OPTION_MALIGN_BRANCH_PREFIX_SIZE (OPTION_MD_BASE + 28)
12877 #define OPTION_MALIGN_BRANCH (OPTION_MD_BASE + 29)
12878 #define OPTION_MBRANCHES_WITH_32B_BOUNDARIES (OPTION_MD_BASE + 30)
12879 #define OPTION_MLFENCE_AFTER_LOAD (OPTION_MD_BASE + 31)
12880 #define OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH (OPTION_MD_BASE + 32)
12881 #define OPTION_MLFENCE_BEFORE_RET (OPTION_MD_BASE + 33)
12882
12883 struct option md_longopts[] =
12884 {
12885   {"32", no_argument, NULL, OPTION_32},
12886 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
12887      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
12888   {"64", no_argument, NULL, OPTION_64},
12889 #endif
12890 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12891   {"x32", no_argument, NULL, OPTION_X32},
12892   {"mshared", no_argument, NULL, OPTION_MSHARED},
12893   {"mx86-used-note", required_argument, NULL, OPTION_X86_USED_NOTE},
12894 #endif
12895   {"divide", no_argument, NULL, OPTION_DIVIDE},
12896   {"march", required_argument, NULL, OPTION_MARCH},
12897   {"mtune", required_argument, NULL, OPTION_MTUNE},
12898   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
12899   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
12900   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
12901   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
12902   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
12903   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
12904   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
12905   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
12906   {"mvexwig", required_argument, NULL, OPTION_MVEXWIG},
12907   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
12908   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
12909   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
12910 # if defined (TE_PE) || defined (TE_PEP)
12911   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
12912 #endif
12913   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
12914   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
12915   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
12916   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
12917   {"malign-branch-boundary", required_argument, NULL, OPTION_MALIGN_BRANCH_BOUNDARY},
12918   {"malign-branch-prefix-size", required_argument, NULL, OPTION_MALIGN_BRANCH_PREFIX_SIZE},
12919   {"malign-branch", required_argument, NULL, OPTION_MALIGN_BRANCH},
12920   {"mbranches-within-32B-boundaries", no_argument, NULL, OPTION_MBRANCHES_WITH_32B_BOUNDARIES},
12921   {"mlfence-after-load", required_argument, NULL, OPTION_MLFENCE_AFTER_LOAD},
12922   {"mlfence-before-indirect-branch", required_argument, NULL,
12923    OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH},
12924   {"mlfence-before-ret", required_argument, NULL, OPTION_MLFENCE_BEFORE_RET},
12925   {"mamd64", no_argument, NULL, OPTION_MAMD64},
12926   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
12927   {NULL, no_argument, NULL, 0}
12928 };
12929 size_t md_longopts_size = sizeof (md_longopts);
12930
12931 int
12932 md_parse_option (int c, const char *arg)
12933 {
12934   unsigned int j;
12935   char *arch, *next, *saved, *type;
12936
12937   switch (c)
12938     {
12939     case 'n':
12940       optimize_align_code = 0;
12941       break;
12942
12943     case 'q':
12944       quiet_warnings = 1;
12945       break;
12946
12947 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12948       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
12949          should be emitted or not.  FIXME: Not implemented.  */
12950     case 'Q':
12951       if ((arg[0] != 'y' && arg[0] != 'n') || arg[1])
12952         return 0;
12953       break;
12954
12955       /* -V: SVR4 argument to print version ID.  */
12956     case 'V':
12957       print_version_id ();
12958       break;
12959
12960       /* -k: Ignore for FreeBSD compatibility.  */
12961     case 'k':
12962       break;
12963
12964     case 's':
12965       /* -s: On i386 Solaris, this tells the native assembler to use
12966          .stab instead of .stab.excl.  We always use .stab anyhow.  */
12967       break;
12968
12969     case OPTION_MSHARED:
12970       shared = 1;
12971       break;
12972
12973     case OPTION_X86_USED_NOTE:
12974       if (strcasecmp (arg, "yes") == 0)
12975         x86_used_note = 1;
12976       else if (strcasecmp (arg, "no") == 0)
12977         x86_used_note = 0;
12978       else
12979         as_fatal (_("invalid -mx86-used-note= option: `%s'"), arg);
12980       break;
12981
12982
12983 #endif
12984 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
12985      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
12986     case OPTION_64:
12987       {
12988         const char **list, **l;
12989
12990         list = bfd_target_list ();
12991         for (l = list; *l != NULL; l++)
12992           if (CONST_STRNEQ (*l, "elf64-x86-64")
12993               || strcmp (*l, "coff-x86-64") == 0
12994               || strcmp (*l, "pe-x86-64") == 0
12995               || strcmp (*l, "pei-x86-64") == 0
12996               || strcmp (*l, "mach-o-x86-64") == 0)
12997             {
12998               default_arch = "x86_64";
12999               break;
13000             }
13001         if (*l == NULL)
13002           as_fatal (_("no compiled in support for x86_64"));
13003         free (list);
13004       }
13005       break;
13006 #endif
13007
13008 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13009     case OPTION_X32:
13010       if (IS_ELF)
13011         {
13012           const char **list, **l;
13013
13014           list = bfd_target_list ();
13015           for (l = list; *l != NULL; l++)
13016             if (CONST_STRNEQ (*l, "elf32-x86-64"))
13017               {
13018                 default_arch = "x86_64:32";
13019                 break;
13020               }
13021           if (*l == NULL)
13022             as_fatal (_("no compiled in support for 32bit x86_64"));
13023           free (list);
13024         }
13025       else
13026         as_fatal (_("32bit x86_64 is only supported for ELF"));
13027       break;
13028 #endif
13029
13030     case OPTION_32:
13031       default_arch = "i386";
13032       break;
13033
13034     case OPTION_DIVIDE:
13035 #ifdef SVR4_COMMENT_CHARS
13036       {
13037         char *n, *t;
13038         const char *s;
13039
13040         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
13041         t = n;
13042         for (s = i386_comment_chars; *s != '\0'; s++)
13043           if (*s != '/')
13044             *t++ = *s;
13045         *t = '\0';
13046         i386_comment_chars = n;
13047       }
13048 #endif
13049       break;
13050
13051     case OPTION_MARCH:
13052       saved = xstrdup (arg);
13053       arch = saved;
13054       /* Allow -march=+nosse.  */
13055       if (*arch == '+')
13056         arch++;
13057       do
13058         {
13059           if (*arch == '.')
13060             as_fatal (_("invalid -march= option: `%s'"), arg);
13061           next = strchr (arch, '+');
13062           if (next)
13063             *next++ = '\0';
13064           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13065             {
13066               if (strcmp (arch, cpu_arch [j].name) == 0)
13067                 {
13068                   /* Processor.  */
13069                   if (! cpu_arch[j].flags.bitfield.cpui386)
13070                     continue;
13071
13072                   cpu_arch_name = cpu_arch[j].name;
13073                   cpu_sub_arch_name = NULL;
13074                   cpu_arch_flags = cpu_arch[j].flags;
13075                   cpu_arch_isa = cpu_arch[j].type;
13076                   cpu_arch_isa_flags = cpu_arch[j].flags;
13077                   if (!cpu_arch_tune_set)
13078                     {
13079                       cpu_arch_tune = cpu_arch_isa;
13080                       cpu_arch_tune_flags = cpu_arch_isa_flags;
13081                     }
13082                   break;
13083                 }
13084               else if (*cpu_arch [j].name == '.'
13085                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
13086                 {
13087                   /* ISA extension.  */
13088                   i386_cpu_flags flags;
13089
13090                   flags = cpu_flags_or (cpu_arch_flags,
13091                                         cpu_arch[j].flags);
13092
13093                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
13094                     {
13095                       if (cpu_sub_arch_name)
13096                         {
13097                           char *name = cpu_sub_arch_name;
13098                           cpu_sub_arch_name = concat (name,
13099                                                       cpu_arch[j].name,
13100                                                       (const char *) NULL);
13101                           free (name);
13102                         }
13103                       else
13104                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
13105                       cpu_arch_flags = flags;
13106                       cpu_arch_isa_flags = flags;
13107                     }
13108                   else
13109                     cpu_arch_isa_flags
13110                       = cpu_flags_or (cpu_arch_isa_flags,
13111                                       cpu_arch[j].flags);
13112                   break;
13113                 }
13114             }
13115
13116           if (j >= ARRAY_SIZE (cpu_arch))
13117             {
13118               /* Disable an ISA extension.  */
13119               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
13120                 if (strcmp (arch, cpu_noarch [j].name) == 0)
13121                   {
13122                     i386_cpu_flags flags;
13123
13124                     flags = cpu_flags_and_not (cpu_arch_flags,
13125                                                cpu_noarch[j].flags);
13126                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
13127                       {
13128                         if (cpu_sub_arch_name)
13129                           {
13130                             char *name = cpu_sub_arch_name;
13131                             cpu_sub_arch_name = concat (arch,
13132                                                         (const char *) NULL);
13133                             free (name);
13134                           }
13135                         else
13136                           cpu_sub_arch_name = xstrdup (arch);
13137                         cpu_arch_flags = flags;
13138                         cpu_arch_isa_flags = flags;
13139                       }
13140                     break;
13141                   }
13142
13143               if (j >= ARRAY_SIZE (cpu_noarch))
13144                 j = ARRAY_SIZE (cpu_arch);
13145             }
13146
13147           if (j >= ARRAY_SIZE (cpu_arch))
13148             as_fatal (_("invalid -march= option: `%s'"), arg);
13149
13150           arch = next;
13151         }
13152       while (next != NULL);
13153       free (saved);
13154       break;
13155
13156     case OPTION_MTUNE:
13157       if (*arg == '.')
13158         as_fatal (_("invalid -mtune= option: `%s'"), arg);
13159       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13160         {
13161           if (strcmp (arg, cpu_arch [j].name) == 0)
13162             {
13163               cpu_arch_tune_set = 1;
13164               cpu_arch_tune = cpu_arch [j].type;
13165               cpu_arch_tune_flags = cpu_arch[j].flags;
13166               break;
13167             }
13168         }
13169       if (j >= ARRAY_SIZE (cpu_arch))
13170         as_fatal (_("invalid -mtune= option: `%s'"), arg);
13171       break;
13172
13173     case OPTION_MMNEMONIC:
13174       if (strcasecmp (arg, "att") == 0)
13175         intel_mnemonic = 0;
13176       else if (strcasecmp (arg, "intel") == 0)
13177         intel_mnemonic = 1;
13178       else
13179         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
13180       break;
13181
13182     case OPTION_MSYNTAX:
13183       if (strcasecmp (arg, "att") == 0)
13184         intel_syntax = 0;
13185       else if (strcasecmp (arg, "intel") == 0)
13186         intel_syntax = 1;
13187       else
13188         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
13189       break;
13190
13191     case OPTION_MINDEX_REG:
13192       allow_index_reg = 1;
13193       break;
13194
13195     case OPTION_MNAKED_REG:
13196       allow_naked_reg = 1;
13197       break;
13198
13199     case OPTION_MSSE2AVX:
13200       sse2avx = 1;
13201       break;
13202
13203     case OPTION_MSSE_CHECK:
13204       if (strcasecmp (arg, "error") == 0)
13205         sse_check = check_error;
13206       else if (strcasecmp (arg, "warning") == 0)
13207         sse_check = check_warning;
13208       else if (strcasecmp (arg, "none") == 0)
13209         sse_check = check_none;
13210       else
13211         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
13212       break;
13213
13214     case OPTION_MOPERAND_CHECK:
13215       if (strcasecmp (arg, "error") == 0)
13216         operand_check = check_error;
13217       else if (strcasecmp (arg, "warning") == 0)
13218         operand_check = check_warning;
13219       else if (strcasecmp (arg, "none") == 0)
13220         operand_check = check_none;
13221       else
13222         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
13223       break;
13224
13225     case OPTION_MAVXSCALAR:
13226       if (strcasecmp (arg, "128") == 0)
13227         avxscalar = vex128;
13228       else if (strcasecmp (arg, "256") == 0)
13229         avxscalar = vex256;
13230       else
13231         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
13232       break;
13233
13234     case OPTION_MVEXWIG:
13235       if (strcmp (arg, "0") == 0)
13236         vexwig = vexw0;
13237       else if (strcmp (arg, "1") == 0)
13238         vexwig = vexw1;
13239       else
13240         as_fatal (_("invalid -mvexwig= option: `%s'"), arg);
13241       break;
13242
13243     case OPTION_MADD_BND_PREFIX:
13244       add_bnd_prefix = 1;
13245       break;
13246
13247     case OPTION_MEVEXLIG:
13248       if (strcmp (arg, "128") == 0)
13249         evexlig = evexl128;
13250       else if (strcmp (arg, "256") == 0)
13251         evexlig = evexl256;
13252       else  if (strcmp (arg, "512") == 0)
13253         evexlig = evexl512;
13254       else
13255         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
13256       break;
13257
13258     case OPTION_MEVEXRCIG:
13259       if (strcmp (arg, "rne") == 0)
13260         evexrcig = rne;
13261       else if (strcmp (arg, "rd") == 0)
13262         evexrcig = rd;
13263       else if (strcmp (arg, "ru") == 0)
13264         evexrcig = ru;
13265       else if (strcmp (arg, "rz") == 0)
13266         evexrcig = rz;
13267       else
13268         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
13269       break;
13270
13271     case OPTION_MEVEXWIG:
13272       if (strcmp (arg, "0") == 0)
13273         evexwig = evexw0;
13274       else if (strcmp (arg, "1") == 0)
13275         evexwig = evexw1;
13276       else
13277         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
13278       break;
13279
13280 # if defined (TE_PE) || defined (TE_PEP)
13281     case OPTION_MBIG_OBJ:
13282       use_big_obj = 1;
13283       break;
13284 #endif
13285
13286     case OPTION_MOMIT_LOCK_PREFIX:
13287       if (strcasecmp (arg, "yes") == 0)
13288         omit_lock_prefix = 1;
13289       else if (strcasecmp (arg, "no") == 0)
13290         omit_lock_prefix = 0;
13291       else
13292         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
13293       break;
13294
13295     case OPTION_MFENCE_AS_LOCK_ADD:
13296       if (strcasecmp (arg, "yes") == 0)
13297         avoid_fence = 1;
13298       else if (strcasecmp (arg, "no") == 0)
13299         avoid_fence = 0;
13300       else
13301         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
13302       break;
13303
13304     case OPTION_MLFENCE_AFTER_LOAD:
13305       if (strcasecmp (arg, "yes") == 0)
13306         lfence_after_load = 1;
13307       else if (strcasecmp (arg, "no") == 0)
13308         lfence_after_load = 0;
13309       else
13310         as_fatal (_("invalid -mlfence-after-load= option: `%s'"), arg);
13311       break;
13312
13313     case OPTION_MLFENCE_BEFORE_INDIRECT_BRANCH:
13314       if (strcasecmp (arg, "all") == 0)
13315         {
13316           lfence_before_indirect_branch = lfence_branch_all;
13317           if (lfence_before_ret == lfence_before_ret_none)
13318             lfence_before_ret = lfence_before_ret_shl;
13319         }
13320       else if (strcasecmp (arg, "memory") == 0)
13321         lfence_before_indirect_branch = lfence_branch_memory;
13322       else if (strcasecmp (arg, "register") == 0)
13323         lfence_before_indirect_branch = lfence_branch_register;
13324       else if (strcasecmp (arg, "none") == 0)
13325         lfence_before_indirect_branch = lfence_branch_none;
13326       else
13327         as_fatal (_("invalid -mlfence-before-indirect-branch= option: `%s'"),
13328                   arg);
13329       break;
13330
13331     case OPTION_MLFENCE_BEFORE_RET:
13332       if (strcasecmp (arg, "or") == 0)
13333         lfence_before_ret = lfence_before_ret_or;
13334       else if (strcasecmp (arg, "not") == 0)
13335         lfence_before_ret = lfence_before_ret_not;
13336       else if (strcasecmp (arg, "shl") == 0 || strcasecmp (arg, "yes") == 0)
13337         lfence_before_ret = lfence_before_ret_shl;
13338       else if (strcasecmp (arg, "none") == 0)
13339         lfence_before_ret = lfence_before_ret_none;
13340       else
13341         as_fatal (_("invalid -mlfence-before-ret= option: `%s'"),
13342                   arg);
13343       break;
13344
13345     case OPTION_MRELAX_RELOCATIONS:
13346       if (strcasecmp (arg, "yes") == 0)
13347         generate_relax_relocations = 1;
13348       else if (strcasecmp (arg, "no") == 0)
13349         generate_relax_relocations = 0;
13350       else
13351         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
13352       break;
13353
13354     case OPTION_MALIGN_BRANCH_BOUNDARY:
13355       {
13356         char *end;
13357         long int align = strtoul (arg, &end, 0);
13358         if (*end == '\0')
13359           {
13360             if (align == 0)
13361               {
13362                 align_branch_power = 0;
13363                 break;
13364               }
13365             else if (align >= 16)
13366               {
13367                 int align_power;
13368                 for (align_power = 0;
13369                      (align & 1) == 0;
13370                      align >>= 1, align_power++)
13371                   continue;
13372                 /* Limit alignment power to 31.  */
13373                 if (align == 1 && align_power < 32)
13374                   {
13375                     align_branch_power = align_power;
13376                     break;
13377                   }
13378               }
13379           }
13380         as_fatal (_("invalid -malign-branch-boundary= value: %s"), arg);
13381       }
13382       break;
13383
13384     case OPTION_MALIGN_BRANCH_PREFIX_SIZE:
13385       {
13386         char *end;
13387         int align = strtoul (arg, &end, 0);
13388         /* Some processors only support 5 prefixes.  */
13389         if (*end == '\0' && align >= 0 && align < 6)
13390           {
13391             align_branch_prefix_size = align;
13392             break;
13393           }
13394         as_fatal (_("invalid -malign-branch-prefix-size= value: %s"),
13395                   arg);
13396       }
13397       break;
13398
13399     case OPTION_MALIGN_BRANCH:
13400       align_branch = 0;
13401       saved = xstrdup (arg);
13402       type = saved;
13403       do
13404         {
13405           next = strchr (type, '+');
13406           if (next)
13407             *next++ = '\0';
13408           if (strcasecmp (type, "jcc") == 0)
13409             align_branch |= align_branch_jcc_bit;
13410           else if (strcasecmp (type, "fused") == 0)
13411             align_branch |= align_branch_fused_bit;
13412           else if (strcasecmp (type, "jmp") == 0)
13413             align_branch |= align_branch_jmp_bit;
13414           else if (strcasecmp (type, "call") == 0)
13415             align_branch |= align_branch_call_bit;
13416           else if (strcasecmp (type, "ret") == 0)
13417             align_branch |= align_branch_ret_bit;
13418           else if (strcasecmp (type, "indirect") == 0)
13419             align_branch |= align_branch_indirect_bit;
13420           else
13421             as_fatal (_("invalid -malign-branch= option: `%s'"), arg);
13422           type = next;
13423         }
13424       while (next != NULL);
13425       free (saved);
13426       break;
13427
13428     case OPTION_MBRANCHES_WITH_32B_BOUNDARIES:
13429       align_branch_power = 5;
13430       align_branch_prefix_size = 5;
13431       align_branch = (align_branch_jcc_bit
13432                       | align_branch_fused_bit
13433                       | align_branch_jmp_bit);
13434       break;
13435
13436     case OPTION_MAMD64:
13437       isa64 = amd64;
13438       break;
13439
13440     case OPTION_MINTEL64:
13441       isa64 = intel64;
13442       break;
13443
13444     case 'O':
13445       if (arg == NULL)
13446         {
13447           optimize = 1;
13448           /* Turn off -Os.  */
13449           optimize_for_space = 0;
13450         }
13451       else if (*arg == 's')
13452         {
13453           optimize_for_space = 1;
13454           /* Turn on all encoding optimizations.  */
13455           optimize = INT_MAX;
13456         }
13457       else
13458         {
13459           optimize = atoi (arg);
13460           /* Turn off -Os.  */
13461           optimize_for_space = 0;
13462         }
13463       break;
13464
13465     default:
13466       return 0;
13467     }
13468   return 1;
13469 }
13470
13471 #define MESSAGE_TEMPLATE \
13472 "                                                                                "
13473
13474 static char *
13475 output_message (FILE *stream, char *p, char *message, char *start,
13476                 int *left_p, const char *name, int len)
13477 {
13478   int size = sizeof (MESSAGE_TEMPLATE);
13479   int left = *left_p;
13480
13481   /* Reserve 2 spaces for ", " or ",\0" */
13482   left -= len + 2;
13483
13484   /* Check if there is any room.  */
13485   if (left >= 0)
13486     {
13487       if (p != start)
13488         {
13489           *p++ = ',';
13490           *p++ = ' ';
13491         }
13492       p = mempcpy (p, name, len);
13493     }
13494   else
13495     {
13496       /* Output the current message now and start a new one.  */
13497       *p++ = ',';
13498       *p = '\0';
13499       fprintf (stream, "%s\n", message);
13500       p = start;
13501       left = size - (start - message) - len - 2;
13502
13503       gas_assert (left >= 0);
13504
13505       p = mempcpy (p, name, len);
13506     }
13507
13508   *left_p = left;
13509   return p;
13510 }
13511
13512 static void
13513 show_arch (FILE *stream, int ext, int check)
13514 {
13515   static char message[] = MESSAGE_TEMPLATE;
13516   char *start = message + 27;
13517   char *p;
13518   int size = sizeof (MESSAGE_TEMPLATE);
13519   int left;
13520   const char *name;
13521   int len;
13522   unsigned int j;
13523
13524   p = start;
13525   left = size - (start - message);
13526   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
13527     {
13528       /* Should it be skipped?  */
13529       if (cpu_arch [j].skip)
13530         continue;
13531
13532       name = cpu_arch [j].name;
13533       len = cpu_arch [j].len;
13534       if (*name == '.')
13535         {
13536           /* It is an extension.  Skip if we aren't asked to show it.  */
13537           if (ext)
13538             {
13539               name++;
13540               len--;
13541             }
13542           else
13543             continue;
13544         }
13545       else if (ext)
13546         {
13547           /* It is an processor.  Skip if we show only extension.  */
13548           continue;
13549         }
13550       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
13551         {
13552           /* It is an impossible processor - skip.  */
13553           continue;
13554         }
13555
13556       p = output_message (stream, p, message, start, &left, name, len);
13557     }
13558
13559   /* Display disabled extensions.  */
13560   if (ext)
13561     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
13562       {
13563         name = cpu_noarch [j].name;
13564         len = cpu_noarch [j].len;
13565         p = output_message (stream, p, message, start, &left, name,
13566                             len);
13567       }
13568
13569   *p = '\0';
13570   fprintf (stream, "%s\n", message);
13571 }
13572
13573 void
13574 md_show_usage (FILE *stream)
13575 {
13576 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13577   fprintf (stream, _("\
13578   -Qy, -Qn                ignored\n\
13579   -V                      print assembler version number\n\
13580   -k                      ignored\n"));
13581 #endif
13582   fprintf (stream, _("\
13583   -n                      Do not optimize code alignment\n\
13584   -q                      quieten some warnings\n"));
13585 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13586   fprintf (stream, _("\
13587   -s                      ignored\n"));
13588 #endif
13589 #if defined BFD64 && (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
13590                       || defined (TE_PE) || defined (TE_PEP))
13591   fprintf (stream, _("\
13592   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
13593 #endif
13594 #ifdef SVR4_COMMENT_CHARS
13595   fprintf (stream, _("\
13596   --divide                do not treat `/' as a comment character\n"));
13597 #else
13598   fprintf (stream, _("\
13599   --divide                ignored\n"));
13600 #endif
13601   fprintf (stream, _("\
13602   -march=CPU[,+EXTENSION...]\n\
13603                           generate code for CPU and EXTENSION, CPU is one of:\n"));
13604   show_arch (stream, 0, 1);
13605   fprintf (stream, _("\
13606                           EXTENSION is combination of:\n"));
13607   show_arch (stream, 1, 0);
13608   fprintf (stream, _("\
13609   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
13610   show_arch (stream, 0, 0);
13611   fprintf (stream, _("\
13612   -msse2avx               encode SSE instructions with VEX prefix\n"));
13613   fprintf (stream, _("\
13614   -msse-check=[none|error|warning] (default: warning)\n\
13615                           check SSE instructions\n"));
13616   fprintf (stream, _("\
13617   -moperand-check=[none|error|warning] (default: warning)\n\
13618                           check operand combinations for validity\n"));
13619   fprintf (stream, _("\
13620   -mavxscalar=[128|256] (default: 128)\n\
13621                           encode scalar AVX instructions with specific vector\n\
13622                            length\n"));
13623   fprintf (stream, _("\
13624   -mvexwig=[0|1] (default: 0)\n\
13625                           encode VEX instructions with specific VEX.W value\n\
13626                            for VEX.W bit ignored instructions\n"));
13627   fprintf (stream, _("\
13628   -mevexlig=[128|256|512] (default: 128)\n\
13629                           encode scalar EVEX instructions with specific vector\n\
13630                            length\n"));
13631   fprintf (stream, _("\
13632   -mevexwig=[0|1] (default: 0)\n\
13633                           encode EVEX instructions with specific EVEX.W value\n\
13634                            for EVEX.W bit ignored instructions\n"));
13635   fprintf (stream, _("\
13636   -mevexrcig=[rne|rd|ru|rz] (default: rne)\n\
13637                           encode EVEX instructions with specific EVEX.RC value\n\
13638                            for SAE-only ignored instructions\n"));
13639   fprintf (stream, _("\
13640   -mmnemonic=[att|intel] "));
13641   if (SYSV386_COMPAT)
13642     fprintf (stream, _("(default: att)\n"));
13643   else
13644     fprintf (stream, _("(default: intel)\n"));
13645   fprintf (stream, _("\
13646                           use AT&T/Intel mnemonic\n"));
13647   fprintf (stream, _("\
13648   -msyntax=[att|intel] (default: att)\n\
13649                           use AT&T/Intel syntax\n"));
13650   fprintf (stream, _("\
13651   -mindex-reg             support pseudo index registers\n"));
13652   fprintf (stream, _("\
13653   -mnaked-reg             don't require `%%' prefix for registers\n"));
13654   fprintf (stream, _("\
13655   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
13656 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13657   fprintf (stream, _("\
13658   -mshared                disable branch optimization for shared code\n"));
13659   fprintf (stream, _("\
13660   -mx86-used-note=[no|yes] "));
13661   if (DEFAULT_X86_USED_NOTE)
13662     fprintf (stream, _("(default: yes)\n"));
13663   else
13664     fprintf (stream, _("(default: no)\n"));
13665   fprintf (stream, _("\
13666                           generate x86 used ISA and feature properties\n"));
13667 #endif
13668 #if defined (TE_PE) || defined (TE_PEP)
13669   fprintf (stream, _("\
13670   -mbig-obj               generate big object files\n"));
13671 #endif
13672   fprintf (stream, _("\
13673   -momit-lock-prefix=[no|yes] (default: no)\n\
13674                           strip all lock prefixes\n"));
13675   fprintf (stream, _("\
13676   -mfence-as-lock-add=[no|yes] (default: no)\n\
13677                           encode lfence, mfence and sfence as\n\
13678                            lock addl $0x0, (%%{re}sp)\n"));
13679   fprintf (stream, _("\
13680   -mrelax-relocations=[no|yes] "));
13681   if (DEFAULT_GENERATE_X86_RELAX_RELOCATIONS)
13682     fprintf (stream, _("(default: yes)\n"));
13683   else
13684     fprintf (stream, _("(default: no)\n"));
13685   fprintf (stream, _("\
13686                           generate relax relocations\n"));
13687   fprintf (stream, _("\
13688   -malign-branch-boundary=NUM (default: 0)\n\
13689                           align branches within NUM byte boundary\n"));
13690   fprintf (stream, _("\
13691   -malign-branch=TYPE[+TYPE...] (default: jcc+fused+jmp)\n\
13692                           TYPE is combination of jcc, fused, jmp, call, ret,\n\
13693                            indirect\n\
13694                           specify types of branches to align\n"));
13695   fprintf (stream, _("\
13696   -malign-branch-prefix-size=NUM (default: 5)\n\
13697                           align branches with NUM prefixes per instruction\n"));
13698   fprintf (stream, _("\
13699   -mbranches-within-32B-boundaries\n\
13700                           align branches within 32 byte boundary\n"));
13701   fprintf (stream, _("\
13702   -mlfence-after-load=[no|yes] (default: no)\n\
13703                           generate lfence after load\n"));
13704   fprintf (stream, _("\
13705   -mlfence-before-indirect-branch=[none|all|register|memory] (default: none)\n\
13706                           generate lfence before indirect near branch\n"));
13707   fprintf (stream, _("\
13708   -mlfence-before-ret=[none|or|not|shl|yes] (default: none)\n\
13709                           generate lfence before ret\n"));
13710   fprintf (stream, _("\
13711   -mamd64                 accept only AMD64 ISA [default]\n"));
13712   fprintf (stream, _("\
13713   -mintel64               accept only Intel64 ISA\n"));
13714 }
13715
13716 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
13717      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
13718      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
13719
13720 /* Pick the target format to use.  */
13721
13722 const char *
13723 i386_target_format (void)
13724 {
13725   if (!strncmp (default_arch, "x86_64", 6))
13726     {
13727       update_code_flag (CODE_64BIT, 1);
13728       if (default_arch[6] == '\0')
13729         x86_elf_abi = X86_64_ABI;
13730       else
13731         x86_elf_abi = X86_64_X32_ABI;
13732     }
13733   else if (!strcmp (default_arch, "i386"))
13734     update_code_flag (CODE_32BIT, 1);
13735   else if (!strcmp (default_arch, "iamcu"))
13736     {
13737       update_code_flag (CODE_32BIT, 1);
13738       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
13739         {
13740           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
13741           cpu_arch_name = "iamcu";
13742           cpu_sub_arch_name = NULL;
13743           cpu_arch_flags = iamcu_flags;
13744           cpu_arch_isa = PROCESSOR_IAMCU;
13745           cpu_arch_isa_flags = iamcu_flags;
13746           if (!cpu_arch_tune_set)
13747             {
13748               cpu_arch_tune = cpu_arch_isa;
13749               cpu_arch_tune_flags = cpu_arch_isa_flags;
13750             }
13751         }
13752       else if (cpu_arch_isa != PROCESSOR_IAMCU)
13753         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
13754                   cpu_arch_name);
13755     }
13756   else
13757     as_fatal (_("unknown architecture"));
13758
13759   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
13760     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
13761   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
13762     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
13763
13764   switch (OUTPUT_FLAVOR)
13765     {
13766 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
13767     case bfd_target_aout_flavour:
13768       return AOUT_TARGET_FORMAT;
13769 #endif
13770 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
13771 # if defined (TE_PE) || defined (TE_PEP)
13772     case bfd_target_coff_flavour:
13773       if (flag_code == CODE_64BIT)
13774         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
13775       else
13776         return use_big_obj ? "pe-bigobj-i386" : "pe-i386";
13777 # elif defined (TE_GO32)
13778     case bfd_target_coff_flavour:
13779       return "coff-go32";
13780 # else
13781     case bfd_target_coff_flavour:
13782       return "coff-i386";
13783 # endif
13784 #endif
13785 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
13786     case bfd_target_elf_flavour:
13787       {
13788         const char *format;
13789
13790         switch (x86_elf_abi)
13791           {
13792           default:
13793             format = ELF_TARGET_FORMAT;
13794 #ifndef TE_SOLARIS
13795             tls_get_addr = "___tls_get_addr";
13796 #endif
13797             break;
13798           case X86_64_ABI:
13799             use_rela_relocations = 1;
13800             object_64bit = 1;
13801 #ifndef TE_SOLARIS
13802             tls_get_addr = "__tls_get_addr";
13803 #endif
13804             format = ELF_TARGET_FORMAT64;
13805             break;
13806           case X86_64_X32_ABI:
13807             use_rela_relocations = 1;
13808             object_64bit = 1;
13809 #ifndef TE_SOLARIS
13810             tls_get_addr = "__tls_get_addr";
13811 #endif
13812             disallow_64bit_reloc = 1;
13813             format = ELF_TARGET_FORMAT32;
13814             break;
13815           }
13816         if (cpu_arch_isa == PROCESSOR_L1OM)
13817           {
13818             if (x86_elf_abi != X86_64_ABI)
13819               as_fatal (_("Intel L1OM is 64bit only"));
13820             return ELF_TARGET_L1OM_FORMAT;
13821           }
13822         else if (cpu_arch_isa == PROCESSOR_K1OM)
13823           {
13824             if (x86_elf_abi != X86_64_ABI)
13825               as_fatal (_("Intel K1OM is 64bit only"));
13826             return ELF_TARGET_K1OM_FORMAT;
13827           }
13828         else if (cpu_arch_isa == PROCESSOR_IAMCU)
13829           {
13830             if (x86_elf_abi != I386_ABI)
13831               as_fatal (_("Intel MCU is 32bit only"));
13832             return ELF_TARGET_IAMCU_FORMAT;
13833           }
13834         else
13835           return format;
13836       }
13837 #endif
13838 #if defined (OBJ_MACH_O)
13839     case bfd_target_mach_o_flavour:
13840       if (flag_code == CODE_64BIT)
13841         {
13842           use_rela_relocations = 1;
13843           object_64bit = 1;
13844           return "mach-o-x86-64";
13845         }
13846       else
13847         return "mach-o-i386";
13848 #endif
13849     default:
13850       abort ();
13851       return NULL;
13852     }
13853 }
13854
13855 #endif /* OBJ_MAYBE_ more than one  */
13856 \f
13857 symbolS *
13858 md_undefined_symbol (char *name)
13859 {
13860   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
13861       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
13862       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
13863       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
13864     {
13865       if (!GOT_symbol)
13866         {
13867           if (symbol_find (name))
13868             as_bad (_("GOT already in symbol table"));
13869           GOT_symbol = symbol_new (name, undefined_section,
13870                                    &zero_address_frag, 0);
13871         };
13872       return GOT_symbol;
13873     }
13874   return 0;
13875 }
13876
13877 /* Round up a section size to the appropriate boundary.  */
13878
13879 valueT
13880 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
13881 {
13882 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
13883   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
13884     {
13885       /* For a.out, force the section size to be aligned.  If we don't do
13886          this, BFD will align it for us, but it will not write out the
13887          final bytes of the section.  This may be a bug in BFD, but it is
13888          easier to fix it here since that is how the other a.out targets
13889          work.  */
13890       int align;
13891
13892       align = bfd_section_alignment (segment);
13893       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
13894     }
13895 #endif
13896
13897   return size;
13898 }
13899
13900 /* On the i386, PC-relative offsets are relative to the start of the
13901    next instruction.  That is, the address of the offset, plus its
13902    size, since the offset is always the last part of the insn.  */
13903
13904 long
13905 md_pcrel_from (fixS *fixP)
13906 {
13907   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
13908 }
13909
13910 #ifndef I386COFF
13911
13912 static void
13913 s_bss (int ignore ATTRIBUTE_UNUSED)
13914 {
13915   int temp;
13916
13917 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13918   if (IS_ELF)
13919     obj_elf_section_change_hook ();
13920 #endif
13921   temp = get_absolute_expression ();
13922   subseg_set (bss_section, (subsegT) temp);
13923   demand_empty_rest_of_line ();
13924 }
13925
13926 #endif
13927
13928 /* Remember constant directive.  */
13929
13930 void
13931 i386_cons_align (int ignore ATTRIBUTE_UNUSED)
13932 {
13933   if (last_insn.kind != last_insn_directive
13934       && (bfd_section_flags (now_seg) & SEC_CODE))
13935     {
13936       last_insn.seg = now_seg;
13937       last_insn.kind = last_insn_directive;
13938       last_insn.name = "constant directive";
13939       last_insn.file = as_where (&last_insn.line);
13940       if (lfence_before_ret != lfence_before_ret_none)
13941         {
13942           if (lfence_before_indirect_branch != lfence_branch_none)
13943             as_warn (_("constant directive skips -mlfence-before-ret "
13944                        "and -mlfence-before-indirect-branch"));
13945           else
13946             as_warn (_("constant directive skips -mlfence-before-ret"));
13947         }
13948       else if (lfence_before_indirect_branch != lfence_branch_none)
13949         as_warn (_("constant directive skips -mlfence-before-indirect-branch"));
13950     }
13951 }
13952
13953 void
13954 i386_validate_fix (fixS *fixp)
13955 {
13956   if (fixp->fx_subsy)
13957     {
13958       if (fixp->fx_subsy == GOT_symbol)
13959         {
13960           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
13961             {
13962               if (!object_64bit)
13963                 abort ();
13964 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13965               if (fixp->fx_tcbit2)
13966                 fixp->fx_r_type = (fixp->fx_tcbit
13967                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
13968                                    : BFD_RELOC_X86_64_GOTPCRELX);
13969               else
13970 #endif
13971                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
13972             }
13973           else
13974             {
13975               if (!object_64bit)
13976                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
13977               else
13978                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
13979             }
13980           fixp->fx_subsy = 0;
13981         }
13982     }
13983 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
13984   else
13985     {
13986       /* NB: Commit 292676c1 resolved PLT32 reloc aganst local symbol
13987          to section.  Since PLT32 relocation must be against symbols,
13988          turn such PLT32 relocation into PC32 relocation.  */
13989       if (fixp->fx_addsy
13990           && (fixp->fx_r_type == BFD_RELOC_386_PLT32
13991               || fixp->fx_r_type == BFD_RELOC_X86_64_PLT32)
13992           && symbol_section_p (fixp->fx_addsy))
13993         fixp->fx_r_type = BFD_RELOC_32_PCREL;
13994       if (!object_64bit)
13995         {
13996           if (fixp->fx_r_type == BFD_RELOC_386_GOT32
13997               && fixp->fx_tcbit2)
13998             fixp->fx_r_type = BFD_RELOC_386_GOT32X;
13999         }
14000     }
14001 #endif
14002 }
14003
14004 arelent *
14005 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
14006 {
14007   arelent *rel;
14008   bfd_reloc_code_real_type code;
14009
14010   switch (fixp->fx_r_type)
14011     {
14012 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
14013     case BFD_RELOC_SIZE32:
14014     case BFD_RELOC_SIZE64:
14015       if (S_IS_DEFINED (fixp->fx_addsy)
14016           && !S_IS_EXTERNAL (fixp->fx_addsy))
14017         {
14018           /* Resolve size relocation against local symbol to size of
14019              the symbol plus addend.  */
14020           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
14021           if (fixp->fx_r_type == BFD_RELOC_SIZE32
14022               && !fits_in_unsigned_long (value))
14023             as_bad_where (fixp->fx_file, fixp->fx_line,
14024                           _("symbol size computation overflow"));
14025           fixp->fx_addsy = NULL;
14026           fixp->fx_subsy = NULL;
14027           md_apply_fix (fixp, (valueT *) &value, NULL);
14028           return NULL;
14029         }
14030 #endif
14031       /* Fall through.  */
14032
14033     case BFD_RELOC_X86_64_PLT32:
14034     case BFD_RELOC_X86_64_GOT32:
14035     case BFD_RELOC_X86_64_GOTPCREL:
14036     case BFD_RELOC_X86_64_GOTPCRELX:
14037     case BFD_RELOC_X86_64_REX_GOTPCRELX:
14038     case BFD_RELOC_386_PLT32:
14039     case BFD_RELOC_386_GOT32:
14040     case BFD_RELOC_386_GOT32X:
14041     case BFD_RELOC_386_GOTOFF:
14042     case BFD_RELOC_386_GOTPC:
14043     case BFD_RELOC_386_TLS_GD:
14044     case BFD_RELOC_386_TLS_LDM:
14045     case BFD_RELOC_386_TLS_LDO_32:
14046     case BFD_RELOC_386_TLS_IE_32:
14047     case BFD_RELOC_386_TLS_IE:
14048     case BFD_RELOC_386_TLS_GOTIE:
14049     case BFD_RELOC_386_TLS_LE_32:
14050     case BFD_RELOC_386_TLS_LE:
14051     case BFD_RELOC_386_TLS_GOTDESC:
14052     case BFD_RELOC_386_TLS_DESC_CALL:
14053     case BFD_RELOC_X86_64_TLSGD:
14054     case BFD_RELOC_X86_64_TLSLD:
14055     case BFD_RELOC_X86_64_DTPOFF32:
14056     case BFD_RELOC_X86_64_DTPOFF64:
14057     case BFD_RELOC_X86_64_GOTTPOFF:
14058     case BFD_RELOC_X86_64_TPOFF32:
14059     case BFD_RELOC_X86_64_TPOFF64:
14060     case BFD_RELOC_X86_64_GOTOFF64:
14061     case BFD_RELOC_X86_64_GOTPC32:
14062     case BFD_RELOC_X86_64_GOT64:
14063     case BFD_RELOC_X86_64_GOTPCREL64:
14064     case BFD_RELOC_X86_64_GOTPC64:
14065     case BFD_RELOC_X86_64_GOTPLT64:
14066     case BFD_RELOC_X86_64_PLTOFF64:
14067     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
14068     case BFD_RELOC_X86_64_TLSDESC_CALL:
14069     case BFD_RELOC_RVA:
14070     case BFD_RELOC_VTABLE_ENTRY:
14071     case BFD_RELOC_VTABLE_INHERIT:
14072 #ifdef TE_PE
14073     case BFD_RELOC_32_SECREL:
14074 #endif
14075       code = fixp->fx_r_type;
14076       break;
14077     case BFD_RELOC_X86_64_32S:
14078       if (!fixp->fx_pcrel)
14079         {
14080           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
14081           code = fixp->fx_r_type;
14082           break;
14083         }
14084       /* Fall through.  */
14085     default:
14086       if (fixp->fx_pcrel)
14087         {
14088           switch (fixp->fx_size)
14089             {
14090             default:
14091               as_bad_where (fixp->fx_file, fixp->fx_line,
14092                             _("can not do %d byte pc-relative relocation"),
14093                             fixp->fx_size);
14094               code = BFD_RELOC_32_PCREL;
14095               break;
14096             case 1: code = BFD_RELOC_8_PCREL;  break;
14097             case 2: code = BFD_RELOC_16_PCREL; break;
14098             case 4: code = BFD_RELOC_32_PCREL; break;
14099 #ifdef BFD64
14100             case 8: code = BFD_RELOC_64_PCREL; break;
14101 #endif
14102             }
14103         }
14104       else
14105         {
14106           switch (fixp->fx_size)
14107             {
14108             default:
14109               as_bad_where (fixp->fx_file, fixp->fx_line,
14110                             _("can not do %d byte relocation"),
14111                             fixp->fx_size);
14112               code = BFD_RELOC_32;
14113               break;
14114             case 1: code = BFD_RELOC_8;  break;
14115             case 2: code = BFD_RELOC_16; break;
14116             case 4: code = BFD_RELOC_32; break;
14117 #ifdef BFD64
14118             case 8: code = BFD_RELOC_64; break;
14119 #endif
14120             }
14121         }
14122       break;
14123     }
14124
14125   if ((code == BFD_RELOC_32
14126        || code == BFD_RELOC_32_PCREL
14127        || code == BFD_RELOC_X86_64_32S)
14128       && GOT_symbol
14129       && fixp->fx_addsy == GOT_symbol)
14130     {
14131       if (!object_64bit)
14132         code = BFD_RELOC_386_GOTPC;
14133       else
14134         code = BFD_RELOC_X86_64_GOTPC32;
14135     }
14136   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
14137       && GOT_symbol
14138       && fixp->fx_addsy == GOT_symbol)
14139     {
14140       code = BFD_RELOC_X86_64_GOTPC64;
14141     }
14142
14143   rel = XNEW (arelent);
14144   rel->sym_ptr_ptr = XNEW (asymbol *);
14145   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
14146
14147   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
14148
14149   if (!use_rela_relocations)
14150     {
14151       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
14152          vtable entry to be used in the relocation's section offset.  */
14153       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
14154         rel->address = fixp->fx_offset;
14155 #if defined (OBJ_COFF) && defined (TE_PE)
14156       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
14157         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
14158       else
14159 #endif
14160       rel->addend = 0;
14161     }
14162   /* Use the rela in 64bit mode.  */
14163   else
14164     {
14165       if (disallow_64bit_reloc)
14166         switch (code)
14167           {
14168           case BFD_RELOC_X86_64_DTPOFF64:
14169           case BFD_RELOC_X86_64_TPOFF64:
14170           case BFD_RELOC_64_PCREL:
14171           case BFD_RELOC_X86_64_GOTOFF64:
14172           case BFD_RELOC_X86_64_GOT64:
14173           case BFD_RELOC_X86_64_GOTPCREL64:
14174           case BFD_RELOC_X86_64_GOTPC64:
14175           case BFD_RELOC_X86_64_GOTPLT64:
14176           case BFD_RELOC_X86_64_PLTOFF64:
14177             as_bad_where (fixp->fx_file, fixp->fx_line,
14178                           _("cannot represent relocation type %s in x32 mode"),
14179                           bfd_get_reloc_code_name (code));
14180             break;
14181           default:
14182             break;
14183           }
14184
14185       if (!fixp->fx_pcrel)
14186         rel->addend = fixp->fx_offset;
14187       else
14188         switch (code)
14189           {
14190           case BFD_RELOC_X86_64_PLT32:
14191           case BFD_RELOC_X86_64_GOT32:
14192           case BFD_RELOC_X86_64_GOTPCREL:
14193           case BFD_RELOC_X86_64_GOTPCRELX:
14194           case BFD_RELOC_X86_64_REX_GOTPCRELX:
14195           case BFD_RELOC_X86_64_TLSGD:
14196           case BFD_RELOC_X86_64_TLSLD:
14197           case BFD_RELOC_X86_64_GOTTPOFF:
14198           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
14199           case BFD_RELOC_X86_64_TLSDESC_CALL:
14200             rel->addend = fixp->fx_offset - fixp->fx_size;
14201             break;
14202           default:
14203             rel->addend = (section->vma
14204                            - fixp->fx_size
14205                            + fixp->fx_addnumber
14206                            + md_pcrel_from (fixp));
14207             break;
14208           }
14209     }
14210
14211   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
14212   if (rel->howto == NULL)
14213     {
14214       as_bad_where (fixp->fx_file, fixp->fx_line,
14215                     _("cannot represent relocation type %s"),
14216                     bfd_get_reloc_code_name (code));
14217       /* Set howto to a garbage value so that we can keep going.  */
14218       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
14219       gas_assert (rel->howto != NULL);
14220     }
14221
14222   return rel;
14223 }
14224
14225 #include "tc-i386-intel.c"
14226
14227 void
14228 tc_x86_parse_to_dw2regnum (expressionS *exp)
14229 {
14230   int saved_naked_reg;
14231   char saved_register_dot;
14232
14233   saved_naked_reg = allow_naked_reg;
14234   allow_naked_reg = 1;
14235   saved_register_dot = register_chars['.'];
14236   register_chars['.'] = '.';
14237   allow_pseudo_reg = 1;
14238   expression_and_evaluate (exp);
14239   allow_pseudo_reg = 0;
14240   register_chars['.'] = saved_register_dot;
14241   allow_naked_reg = saved_naked_reg;
14242
14243   if (exp->X_op == O_register && exp->X_add_number >= 0)
14244     {
14245       if ((addressT) exp->X_add_number < i386_regtab_size)
14246         {
14247           exp->X_op = O_constant;
14248           exp->X_add_number = i386_regtab[exp->X_add_number]
14249                               .dw2_regnum[flag_code >> 1];
14250         }
14251       else
14252         exp->X_op = O_illegal;
14253     }
14254 }
14255
14256 void
14257 tc_x86_frame_initial_instructions (void)
14258 {
14259   static unsigned int sp_regno[2];
14260
14261   if (!sp_regno[flag_code >> 1])
14262     {
14263       char *saved_input = input_line_pointer;
14264       char sp[][4] = {"esp", "rsp"};
14265       expressionS exp;
14266
14267       input_line_pointer = sp[flag_code >> 1];
14268       tc_x86_parse_to_dw2regnum (&exp);
14269       gas_assert (exp.X_op == O_constant);
14270       sp_regno[flag_code >> 1] = exp.X_add_number;
14271       input_line_pointer = saved_input;
14272     }
14273
14274   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
14275   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
14276 }
14277
14278 int
14279 x86_dwarf2_addr_size (void)
14280 {
14281 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
14282   if (x86_elf_abi == X86_64_X32_ABI)
14283     return 4;
14284 #endif
14285   return bfd_arch_bits_per_address (stdoutput) / 8;
14286 }
14287
14288 int
14289 i386_elf_section_type (const char *str, size_t len)
14290 {
14291   if (flag_code == CODE_64BIT
14292       && len == sizeof ("unwind") - 1
14293       && strncmp (str, "unwind", 6) == 0)
14294     return SHT_X86_64_UNWIND;
14295
14296   return -1;
14297 }
14298
14299 #ifdef TE_SOLARIS
14300 void
14301 i386_solaris_fix_up_eh_frame (segT sec)
14302 {
14303   if (flag_code == CODE_64BIT)
14304     elf_section_type (sec) = SHT_X86_64_UNWIND;
14305 }
14306 #endif
14307
14308 #ifdef TE_PE
14309 void
14310 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
14311 {
14312   expressionS exp;
14313
14314   exp.X_op = O_secrel;
14315   exp.X_add_symbol = symbol;
14316   exp.X_add_number = 0;
14317   emit_expr (&exp, size);
14318 }
14319 #endif
14320
14321 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
14322 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
14323
14324 bfd_vma
14325 x86_64_section_letter (int letter, const char **ptr_msg)
14326 {
14327   if (flag_code == CODE_64BIT)
14328     {
14329       if (letter == 'l')
14330         return SHF_X86_64_LARGE;
14331
14332       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
14333     }
14334   else
14335     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
14336   return -1;
14337 }
14338
14339 bfd_vma
14340 x86_64_section_word (char *str, size_t len)
14341 {
14342   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
14343     return SHF_X86_64_LARGE;
14344
14345   return -1;
14346 }
14347
14348 static void
14349 handle_large_common (int small ATTRIBUTE_UNUSED)
14350 {
14351   if (flag_code != CODE_64BIT)
14352     {
14353       s_comm_internal (0, elf_common_parse);
14354       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
14355     }
14356   else
14357     {
14358       static segT lbss_section;
14359       asection *saved_com_section_ptr = elf_com_section_ptr;
14360       asection *saved_bss_section = bss_section;
14361
14362       if (lbss_section == NULL)
14363         {
14364           flagword applicable;
14365           segT seg = now_seg;
14366           subsegT subseg = now_subseg;
14367
14368           /* The .lbss section is for local .largecomm symbols.  */
14369           lbss_section = subseg_new (".lbss", 0);
14370           applicable = bfd_applicable_section_flags (stdoutput);
14371           bfd_set_section_flags (lbss_section, applicable & SEC_ALLOC);
14372           seg_info (lbss_section)->bss = 1;
14373
14374           subseg_set (seg, subseg);
14375         }
14376
14377       elf_com_section_ptr = &_bfd_elf_large_com_section;
14378       bss_section = lbss_section;
14379
14380       s_comm_internal (0, elf_common_parse);
14381
14382       elf_com_section_ptr = saved_com_section_ptr;
14383       bss_section = saved_bss_section;
14384     }
14385 }
14386 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */