gas/config/tc-i386.c

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