gas/config/tc-i386.c

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