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                     || (fits_in_imm7 (i.op[0].imms->X_add_number)
3953                         && i.tm.base_opcode == 0x83
3954                         && i.tm.extension_opcode == 0x4)))
3955                || (i.types[0].bitfield.qword
3956                    && ((i.reg_operands == 2
3957                         && i.op[0].regs == i.op[1].regs
3958                         && ((i.tm.base_opcode == 0x30
3959                              || i.tm.base_opcode == 0x28)
3960                             && i.tm.extension_opcode == None))
3961                        || (i.reg_operands == 1
3962                            && i.operands == 1
3963                            && i.tm.base_opcode == 0x30
3964                            && i.tm.extension_opcode == None)))))
3965     {
3966       /* Optimize: -O:
3967            andq $imm31, %r64   -> andl $imm31, %r32
3968            andq $imm7, %r64    -> andl $imm7, %r32
3969            testq $imm31, %r64  -> testl $imm31, %r32
3970            xorq %r64, %r64     -> xorl %r32, %r32
3971            subq %r64, %r64     -> subl %r32, %r32
3972            movq $imm31, %r64   -> movl $imm31, %r32
3973            movq $imm32, %r64   -> movl $imm32, %r32
3974         */
3975       i.tm.opcode_modifier.norex64 = 1;
3976       if (i.tm.base_opcode == 0xb0 || i.tm.base_opcode == 0xc6)
3977         {
3978           /* Handle
3979                movq $imm31, %r64   -> movl $imm31, %r32
3980                movq $imm32, %r64   -> movl $imm32, %r32
3981            */
3982           i.tm.operand_types[0].bitfield.imm32 = 1;
3983           i.tm.operand_types[0].bitfield.imm32s = 0;
3984           i.tm.operand_types[0].bitfield.imm64 = 0;
3985           i.types[0].bitfield.imm32 = 1;
3986           i.types[0].bitfield.imm32s = 0;
3987           i.types[0].bitfield.imm64 = 0;
3988           i.types[1].bitfield.dword = 1;
3989           i.types[1].bitfield.qword = 0;
3990           if (i.tm.base_opcode == 0xc6)
3991             {
3992               /* Handle
3993                    movq $imm31, %r64   -> movl $imm31, %r32
3994                */
3995               i.tm.base_opcode = 0xb0;
3996               i.tm.extension_opcode = None;
3997               i.tm.opcode_modifier.shortform = 1;
3998               i.tm.opcode_modifier.modrm = 0;
3999             }
4000         }
4001     }
4002   else if (i.reg_operands == 3
4003            && i.op[0].regs == i.op[1].regs
4004            && !i.types[2].bitfield.xmmword
4005            && (i.tm.opcode_modifier.vex
4006                || ((!i.mask || i.mask->zeroing)
4007                    && !i.rounding
4008                    && is_evex_encoding (&i.tm)
4009                    && (i.vec_encoding != vex_encoding_evex
4010                        || cpu_arch_isa_flags.bitfield.cpuavx512vl
4011                        || i.tm.cpu_flags.bitfield.cpuavx512vl
4012                        || (i.tm.operand_types[2].bitfield.zmmword
4013                            && i.types[2].bitfield.ymmword))))
4014            && ((i.tm.base_opcode == 0x55
4015                 || i.tm.base_opcode == 0x6655
4016                 || i.tm.base_opcode == 0x66df
4017                 || i.tm.base_opcode == 0x57
4018                 || i.tm.base_opcode == 0x6657
4019                 || i.tm.base_opcode == 0x66ef
4020                 || i.tm.base_opcode == 0x66f8
4021                 || i.tm.base_opcode == 0x66f9
4022                 || i.tm.base_opcode == 0x66fa
4023                 || i.tm.base_opcode == 0x66fb
4024                 || i.tm.base_opcode == 0x42
4025                 || i.tm.base_opcode == 0x6642
4026                 || i.tm.base_opcode == 0x47
4027                 || i.tm.base_opcode == 0x6647)
4028                && i.tm.extension_opcode == None))
4029     {
4030       /* Optimize: -O1:
4031            VOP, one of vandnps, vandnpd, vxorps, vxorpd, vpsubb, vpsubd,
4032            vpsubq and vpsubw:
4033              EVEX VOP %zmmM, %zmmM, %zmmN
4034                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4035                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4036              EVEX VOP %ymmM, %ymmM, %ymmN
4037                -> VEX VOP %xmmM, %xmmM, %xmmN (M and N < 16)
4038                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4039              VEX VOP %ymmM, %ymmM, %ymmN
4040                -> VEX VOP %xmmM, %xmmM, %xmmN
4041            VOP, one of vpandn and vpxor:
4042              VEX VOP %ymmM, %ymmM, %ymmN
4043                -> VEX VOP %xmmM, %xmmM, %xmmN
4044            VOP, one of vpandnd and vpandnq:
4045              EVEX VOP %zmmM, %zmmM, %zmmN
4046                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4047                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4048              EVEX VOP %ymmM, %ymmM, %ymmN
4049                -> VEX vpandn %xmmM, %xmmM, %xmmN (M and N < 16)
4050                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4051            VOP, one of vpxord and vpxorq:
4052              EVEX VOP %zmmM, %zmmM, %zmmN
4053                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4054                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4055              EVEX VOP %ymmM, %ymmM, %ymmN
4056                -> VEX vpxor %xmmM, %xmmM, %xmmN (M and N < 16)
4057                -> EVEX VOP %xmmM, %xmmM, %xmmN (M || N >= 16) (-O2)
4058            VOP, one of kxord and kxorq:
4059              VEX VOP %kM, %kM, %kN
4060                -> VEX kxorw %kM, %kM, %kN
4061            VOP, one of kandnd and kandnq:
4062              VEX VOP %kM, %kM, %kN
4063                -> VEX kandnw %kM, %kM, %kN
4064        */
4065       if (is_evex_encoding (&i.tm))
4066         {
4067           if (i.vec_encoding != vex_encoding_evex)
4068             {
4069               i.tm.opcode_modifier.vex = VEX128;
4070               i.tm.opcode_modifier.vexw = VEXW0;
4071               i.tm.opcode_modifier.evex = 0;
4072             }
4073           else if (optimize > 1)
4074             i.tm.opcode_modifier.evex = EVEX128;
4075           else
4076             return;
4077         }
4078       else if (i.tm.operand_types[0].bitfield.regmask)
4079         {
4080           i.tm.base_opcode &= 0xff;
4081           i.tm.opcode_modifier.vexw = VEXW0;
4082         }
4083       else
4084         i.tm.opcode_modifier.vex = VEX128;
4085
4086       if (i.tm.opcode_modifier.vex)
4087         for (j = 0; j < 3; j++)
4088           {
4089             i.types[j].bitfield.xmmword = 1;
4090             i.types[j].bitfield.ymmword = 0;
4091           }
4092     }
4093   else if (i.vec_encoding != vex_encoding_evex
4094            && !i.types[0].bitfield.zmmword
4095            && !i.types[1].bitfield.zmmword
4096            && !i.mask
4097            && is_evex_encoding (&i.tm)
4098            && ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0x666f
4099                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf36f
4100                || (i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f)
4101            && i.tm.extension_opcode == None)
4102     {
4103       /* Optimize: -O1:
4104            VOP, one of vmovdqa32, vmovdqa64, vmovdqu8, vmovdqu16,
4105            vmovdqu32 and vmovdqu64:
4106              EVEX VOP %xmmM, %xmmN
4107                -> VEX vmovdqa|vmovdqu %xmmM, %xmmN (M and N < 16)
4108              EVEX VOP %ymmM, %ymmN
4109                -> VEX vmovdqa|vmovdqu %ymmM, %ymmN (M and N < 16)
4110              EVEX VOP %xmmM, mem
4111                -> VEX vmovdqa|vmovdqu %xmmM, mem (M < 16)
4112              EVEX VOP %ymmM, mem
4113                -> VEX vmovdqa|vmovdqu %ymmM, mem (M < 16)
4114              EVEX VOP mem, %xmmN
4115                -> VEX mvmovdqa|vmovdquem, %xmmN (N < 16)
4116              EVEX VOP mem, %ymmN
4117                -> VEX vmovdqa|vmovdqu mem, %ymmN (N < 16)
4118        */
4119       for (j = 0; j < 2; j++)
4120         if (operand_type_check (i.types[j], disp)
4121             && i.op[j].disps->X_op == O_constant)
4122           {
4123             /* Since the VEX prefix has 2 or 3 bytes, the EVEX prefix
4124                has 4 bytes, EVEX Disp8 has 1 byte and VEX Disp32 has 4
4125                bytes, we choose EVEX Disp8 over VEX Disp32.  */
4126             int evex_disp8, vex_disp8;
4127             unsigned int memshift = i.memshift;
4128             offsetT n = i.op[j].disps->X_add_number;
4129
4130             evex_disp8 = fits_in_disp8 (n);
4131             i.memshift = 0;
4132             vex_disp8 = fits_in_disp8 (n);
4133             if (evex_disp8 != vex_disp8)
4134               {
4135                 i.memshift = memshift;
4136                 return;
4137               }
4138
4139             i.types[j].bitfield.disp8 = vex_disp8;
4140             break;
4141           }
4142       if ((i.tm.base_opcode & ~Opcode_SIMD_IntD) == 0xf26f)
4143         i.tm.base_opcode ^= 0xf36f ^ 0xf26f;
4144       i.tm.opcode_modifier.vex
4145         = i.types[0].bitfield.ymmword ? VEX256 : VEX128;
4146       i.tm.opcode_modifier.vexw = VEXW0;
4147       i.tm.opcode_modifier.evex = 0;
4148       i.tm.opcode_modifier.masking = 0;
4149       i.tm.opcode_modifier.disp8memshift = 0;
4150       i.memshift = 0;
4151       for (j = 0; j < 2; j++)
4152         if (operand_type_check (i.types[j], disp)
4153             && i.op[j].disps->X_op == O_constant)
4154           {
4155             i.types[j].bitfield.disp8
4156               = fits_in_disp8 (i.op[j].disps->X_add_number);
4157             break;
4158           }
4159     }
4160 }
4161
4162 /* This is the guts of the machine-dependent assembler.  LINE points to a
4163    machine dependent instruction.  This function is supposed to emit
4164    the frags/bytes it assembles to.  */
4165
4166 void
4167 md_assemble (char *line)
4168 {
4169   unsigned int j;
4170   char mnemonic[MAX_MNEM_SIZE], mnem_suffix;
4171   const insn_template *t;
4172
4173   /* Initialize globals.  */
4174   memset (&i, '\0', sizeof (i));
4175   for (j = 0; j < MAX_OPERANDS; j++)
4176     i.reloc[j] = NO_RELOC;
4177   memset (disp_expressions, '\0', sizeof (disp_expressions));
4178   memset (im_expressions, '\0', sizeof (im_expressions));
4179   save_stack_p = save_stack;
4180
4181   /* First parse an instruction mnemonic & call i386_operand for the operands.
4182      We assume that the scrubber has arranged it so that line[0] is the valid
4183      start of a (possibly prefixed) mnemonic.  */
4184
4185   line = parse_insn (line, mnemonic);
4186   if (line == NULL)
4187     return;
4188   mnem_suffix = i.suffix;
4189
4190   line = parse_operands (line, mnemonic);
4191   this_operand = -1;
4192   xfree (i.memop1_string);
4193   i.memop1_string = NULL;
4194   if (line == NULL)
4195     return;
4196
4197   /* Now we've parsed the mnemonic into a set of templates, and have the
4198      operands at hand.  */
4199
4200   /* All intel opcodes have reversed operands except for "bound" and
4201      "enter".  We also don't reverse intersegment "jmp" and "call"
4202      instructions with 2 immediate operands so that the immediate segment
4203      precedes the offset, as it does when in AT&T mode. */
4204   if (intel_syntax
4205       && i.operands > 1
4206       && (strcmp (mnemonic, "bound") != 0)
4207       && (strcmp (mnemonic, "invlpga") != 0)
4208       && !(operand_type_check (i.types[0], imm)
4209            && operand_type_check (i.types[1], imm)))
4210     swap_operands ();
4211
4212   /* The order of the immediates should be reversed
4213      for 2 immediates extrq and insertq instructions */
4214   if (i.imm_operands == 2
4215       && (strcmp (mnemonic, "extrq") == 0
4216           || strcmp (mnemonic, "insertq") == 0))
4217       swap_2_operands (0, 1);
4218
4219   if (i.imm_operands)
4220     optimize_imm ();
4221
4222   /* Don't optimize displacement for movabs since it only takes 64bit
4223      displacement.  */
4224   if (i.disp_operands
4225       && i.disp_encoding != disp_encoding_32bit
4226       && (flag_code != CODE_64BIT
4227           || strcmp (mnemonic, "movabs") != 0))
4228     optimize_disp ();
4229
4230   /* Next, we find a template that matches the given insn,
4231      making sure the overlap of the given operands types is consistent
4232      with the template operand types.  */
4233
4234   if (!(t = match_template (mnem_suffix)))
4235     return;
4236
4237   if (sse_check != check_none
4238       && !i.tm.opcode_modifier.noavx
4239       && !i.tm.cpu_flags.bitfield.cpuavx
4240       && (i.tm.cpu_flags.bitfield.cpusse
4241           || i.tm.cpu_flags.bitfield.cpusse2
4242           || i.tm.cpu_flags.bitfield.cpusse3
4243           || i.tm.cpu_flags.bitfield.cpussse3
4244           || i.tm.cpu_flags.bitfield.cpusse4_1
4245           || i.tm.cpu_flags.bitfield.cpusse4_2
4246           || i.tm.cpu_flags.bitfield.cpupclmul
4247           || i.tm.cpu_flags.bitfield.cpuaes
4248           || i.tm.cpu_flags.bitfield.cpugfni))
4249     {
4250       (sse_check == check_warning
4251        ? as_warn
4252        : as_bad) (_("SSE instruction `%s' is used"), i.tm.name);
4253     }
4254
4255   /* Zap movzx and movsx suffix.  The suffix has been set from
4256      "word ptr" or "byte ptr" on the source operand in Intel syntax
4257      or extracted from mnemonic in AT&T syntax.  But we'll use
4258      the destination register to choose the suffix for encoding.  */
4259   if ((i.tm.base_opcode & ~9) == 0x0fb6)
4260     {
4261       /* In Intel syntax, there must be a suffix.  In AT&T syntax, if
4262          there is no suffix, the default will be byte extension.  */
4263       if (i.reg_operands != 2
4264           && !i.suffix
4265           && intel_syntax)
4266         as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
4267
4268       i.suffix = 0;
4269     }
4270
4271   if (i.tm.opcode_modifier.fwait)
4272     if (!add_prefix (FWAIT_OPCODE))
4273       return;
4274
4275   /* Check if REP prefix is OK.  */
4276   if (i.rep_prefix && !i.tm.opcode_modifier.repprefixok)
4277     {
4278       as_bad (_("invalid instruction `%s' after `%s'"),
4279                 i.tm.name, i.rep_prefix);
4280       return;
4281     }
4282
4283   /* Check for lock without a lockable instruction.  Destination operand
4284      must be memory unless it is xchg (0x86).  */
4285   if (i.prefix[LOCK_PREFIX]
4286       && (!i.tm.opcode_modifier.islockable
4287           || i.mem_operands == 0
4288           || (i.tm.base_opcode != 0x86
4289               && !operand_type_check (i.types[i.operands - 1], anymem))))
4290     {
4291       as_bad (_("expecting lockable instruction after `lock'"));
4292       return;
4293     }
4294
4295   /* Check for data size prefix on VEX/XOP/EVEX encoded insns.  */
4296   if (i.prefix[DATA_PREFIX] && is_any_vex_encoding (&i.tm))
4297     {
4298       as_bad (_("data size prefix invalid with `%s'"), i.tm.name);
4299       return;
4300     }
4301
4302   /* Check if HLE prefix is OK.  */
4303   if (i.hle_prefix && !check_hle ())
4304     return;
4305
4306   /* Check BND prefix.  */
4307   if (i.bnd_prefix && !i.tm.opcode_modifier.bndprefixok)
4308     as_bad (_("expecting valid branch instruction after `bnd'"));
4309
4310   /* Check NOTRACK prefix.  */
4311   if (i.notrack_prefix && !i.tm.opcode_modifier.notrackprefixok)
4312     as_bad (_("expecting indirect branch instruction after `notrack'"));
4313
4314   if (i.tm.cpu_flags.bitfield.cpumpx)
4315     {
4316       if (flag_code == CODE_64BIT && i.prefix[ADDR_PREFIX])
4317         as_bad (_("32-bit address isn't allowed in 64-bit MPX instructions."));
4318       else if (flag_code != CODE_16BIT
4319                ? i.prefix[ADDR_PREFIX]
4320                : i.mem_operands && !i.prefix[ADDR_PREFIX])
4321         as_bad (_("16-bit address isn't allowed in MPX instructions"));
4322     }
4323
4324   /* Insert BND prefix.  */
4325   if (add_bnd_prefix && i.tm.opcode_modifier.bndprefixok)
4326     {
4327       if (!i.prefix[BND_PREFIX])
4328         add_prefix (BND_PREFIX_OPCODE);
4329       else if (i.prefix[BND_PREFIX] != BND_PREFIX_OPCODE)
4330         {
4331           as_warn (_("replacing `rep'/`repe' prefix by `bnd'"));
4332           i.prefix[BND_PREFIX] = BND_PREFIX_OPCODE;
4333         }
4334     }
4335
4336   /* Check string instruction segment overrides.  */
4337   if (i.tm.opcode_modifier.isstring && i.mem_operands != 0)
4338     {
4339       if (!check_string ())
4340         return;
4341       i.disp_operands = 0;
4342     }
4343
4344   if (optimize && !i.no_optimize && i.tm.opcode_modifier.optimize)
4345     optimize_encoding ();
4346
4347   if (!process_suffix ())
4348     return;
4349
4350   /* Update operand types.  */
4351   for (j = 0; j < i.operands; j++)
4352     i.types[j] = operand_type_and (i.types[j], i.tm.operand_types[j]);
4353
4354   /* Make still unresolved immediate matches conform to size of immediate
4355      given in i.suffix.  */
4356   if (!finalize_imm ())
4357     return;
4358
4359   if (i.types[0].bitfield.imm1)
4360     i.imm_operands = 0; /* kludge for shift insns.  */
4361
4362   /* We only need to check those implicit registers for instructions
4363      with 3 operands or less.  */
4364   if (i.operands <= 3)
4365     for (j = 0; j < i.operands; j++)
4366       if (i.types[j].bitfield.inoutportreg
4367           || i.types[j].bitfield.shiftcount
4368           || (i.types[j].bitfield.acc && !i.types[j].bitfield.xmmword))
4369         i.reg_operands--;
4370
4371   /* ImmExt should be processed after SSE2AVX.  */
4372   if (!i.tm.opcode_modifier.sse2avx
4373       && i.tm.opcode_modifier.immext)
4374     process_immext ();
4375
4376   /* For insns with operands there are more diddles to do to the opcode.  */
4377   if (i.operands)
4378     {
4379       if (!process_operands ())
4380         return;
4381     }
4382   else if (!quiet_warnings && i.tm.opcode_modifier.ugh)
4383     {
4384       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
4385       as_warn (_("translating to `%sp'"), i.tm.name);
4386     }
4387
4388   if (is_any_vex_encoding (&i.tm))
4389     {
4390       if (flag_code == CODE_16BIT)
4391         {
4392           as_bad (_("instruction `%s' isn't supported in 16-bit mode."),
4393                   i.tm.name);
4394           return;
4395         }
4396
4397       if (i.tm.opcode_modifier.vex)
4398         build_vex_prefix (t);
4399       else
4400         build_evex_prefix ();
4401     }
4402
4403   /* Handle conversion of 'int $3' --> special int3 insn.  XOP or FMA4
4404      instructions may define INT_OPCODE as well, so avoid this corner
4405      case for those instructions that use MODRM.  */
4406   if (i.tm.base_opcode == INT_OPCODE
4407       && !i.tm.opcode_modifier.modrm
4408       && i.op[0].imms->X_add_number == 3)
4409     {
4410       i.tm.base_opcode = INT3_OPCODE;
4411       i.imm_operands = 0;
4412     }
4413
4414   if ((i.tm.opcode_modifier.jump
4415        || i.tm.opcode_modifier.jumpbyte
4416        || i.tm.opcode_modifier.jumpdword)
4417       && i.op[0].disps->X_op == O_constant)
4418     {
4419       /* Convert "jmp constant" (and "call constant") to a jump (call) to
4420          the absolute address given by the constant.  Since ix86 jumps and
4421          calls are pc relative, we need to generate a reloc.  */
4422       i.op[0].disps->X_add_symbol = &abs_symbol;
4423       i.op[0].disps->X_op = O_symbol;
4424     }
4425
4426   if (i.tm.opcode_modifier.rex64)
4427     i.rex |= REX_W;
4428
4429   /* For 8 bit registers we need an empty rex prefix.  Also if the
4430      instruction already has a prefix, we need to convert old
4431      registers to new ones.  */
4432
4433   if ((i.types[0].bitfield.reg && i.types[0].bitfield.byte
4434        && (i.op[0].regs->reg_flags & RegRex64) != 0)
4435       || (i.types[1].bitfield.reg && i.types[1].bitfield.byte
4436           && (i.op[1].regs->reg_flags & RegRex64) != 0)
4437       || (((i.types[0].bitfield.reg && i.types[0].bitfield.byte)
4438            || (i.types[1].bitfield.reg && i.types[1].bitfield.byte))
4439           && i.rex != 0))
4440     {
4441       int x;
4442
4443       i.rex |= REX_OPCODE;
4444       for (x = 0; x < 2; x++)
4445         {
4446           /* Look for 8 bit operand that uses old registers.  */
4447           if (i.types[x].bitfield.reg && i.types[x].bitfield.byte
4448               && (i.op[x].regs->reg_flags & RegRex64) == 0)
4449             {
4450               /* In case it is "hi" register, give up.  */
4451               if (i.op[x].regs->reg_num > 3)
4452                 as_bad (_("can't encode register '%s%s' in an "
4453                           "instruction requiring REX prefix."),
4454                         register_prefix, i.op[x].regs->reg_name);
4455
4456               /* Otherwise it is equivalent to the extended register.
4457                  Since the encoding doesn't change this is merely
4458                  cosmetic cleanup for debug output.  */
4459
4460               i.op[x].regs = i.op[x].regs + 8;
4461             }
4462         }
4463     }
4464
4465   if (i.rex == 0 && i.rex_encoding)
4466     {
4467       /* Check if we can add a REX_OPCODE byte.  Look for 8 bit operand
4468          that uses legacy register.  If it is "hi" register, don't add
4469          the REX_OPCODE byte.  */
4470       int x;
4471       for (x = 0; x < 2; x++)
4472         if (i.types[x].bitfield.reg
4473             && i.types[x].bitfield.byte
4474             && (i.op[x].regs->reg_flags & RegRex64) == 0
4475             && i.op[x].regs->reg_num > 3)
4476           {
4477             i.rex_encoding = FALSE;
4478             break;
4479           }
4480
4481       if (i.rex_encoding)
4482         i.rex = REX_OPCODE;
4483     }
4484
4485   if (i.rex != 0)
4486     add_prefix (REX_OPCODE | i.rex);
4487
4488   /* We are ready to output the insn.  */
4489   output_insn ();
4490 }
4491
4492 static char *
4493 parse_insn (char *line, char *mnemonic)
4494 {
4495   char *l = line;
4496   char *token_start = l;
4497   char *mnem_p;
4498   int supported;
4499   const insn_template *t;
4500   char *dot_p = NULL;
4501
4502   while (1)
4503     {
4504       mnem_p = mnemonic;
4505       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
4506         {
4507           if (*mnem_p == '.')
4508             dot_p = mnem_p;
4509           mnem_p++;
4510           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
4511             {
4512               as_bad (_("no such instruction: `%s'"), token_start);
4513               return NULL;
4514             }
4515           l++;
4516         }
4517       if (!is_space_char (*l)
4518           && *l != END_OF_INSN
4519           && (intel_syntax
4520               || (*l != PREFIX_SEPARATOR
4521                   && *l != ',')))
4522         {
4523           as_bad (_("invalid character %s in mnemonic"),
4524                   output_invalid (*l));
4525           return NULL;
4526         }
4527       if (token_start == l)
4528         {
4529           if (!intel_syntax && *l == PREFIX_SEPARATOR)
4530             as_bad (_("expecting prefix; got nothing"));
4531           else
4532             as_bad (_("expecting mnemonic; got nothing"));
4533           return NULL;
4534         }
4535
4536       /* Look up instruction (or prefix) via hash table.  */
4537       current_templates = (const templates *) hash_find (op_hash, mnemonic);
4538
4539       if (*l != END_OF_INSN
4540           && (!is_space_char (*l) || l[1] != END_OF_INSN)
4541           && current_templates
4542           && current_templates->start->opcode_modifier.isprefix)
4543         {
4544           if (!cpu_flags_check_cpu64 (current_templates->start->cpu_flags))
4545             {
4546               as_bad ((flag_code != CODE_64BIT
4547                        ? _("`%s' is only supported in 64-bit mode")
4548                        : _("`%s' is not supported in 64-bit mode")),
4549                       current_templates->start->name);
4550               return NULL;
4551             }
4552           /* If we are in 16-bit mode, do not allow addr16 or data16.
4553              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
4554           if ((current_templates->start->opcode_modifier.size == SIZE16
4555                || current_templates->start->opcode_modifier.size == SIZE32)
4556               && flag_code != CODE_64BIT
4557               && ((current_templates->start->opcode_modifier.size == SIZE32)
4558                   ^ (flag_code == CODE_16BIT)))
4559             {
4560               as_bad (_("redundant %s prefix"),
4561                       current_templates->start->name);
4562               return NULL;
4563             }
4564           if (current_templates->start->opcode_length == 0)
4565             {
4566               /* Handle pseudo prefixes.  */
4567               switch (current_templates->start->base_opcode)
4568                 {
4569                 case 0x0:
4570                   /* {disp8} */
4571                   i.disp_encoding = disp_encoding_8bit;
4572                   break;
4573                 case 0x1:
4574                   /* {disp32} */
4575                   i.disp_encoding = disp_encoding_32bit;
4576                   break;
4577                 case 0x2:
4578                   /* {load} */
4579                   i.dir_encoding = dir_encoding_load;
4580                   break;
4581                 case 0x3:
4582                   /* {store} */
4583                   i.dir_encoding = dir_encoding_store;
4584                   break;
4585                 case 0x4:
4586                   /* {vex2} */
4587                   i.vec_encoding = vex_encoding_vex2;
4588                   break;
4589                 case 0x5:
4590                   /* {vex3} */
4591                   i.vec_encoding = vex_encoding_vex3;
4592                   break;
4593                 case 0x6:
4594                   /* {evex} */
4595                   i.vec_encoding = vex_encoding_evex;
4596                   break;
4597                 case 0x7:
4598                   /* {rex} */
4599                   i.rex_encoding = TRUE;
4600                   break;
4601                 case 0x8:
4602                   /* {nooptimize} */
4603                   i.no_optimize = TRUE;
4604                   break;
4605                 default:
4606                   abort ();
4607                 }
4608             }
4609           else
4610             {
4611               /* Add prefix, checking for repeated prefixes.  */
4612               switch (add_prefix (current_templates->start->base_opcode))
4613                 {
4614                 case PREFIX_EXIST:
4615                   return NULL;
4616                 case PREFIX_DS:
4617                   if (current_templates->start->cpu_flags.bitfield.cpuibt)
4618                     i.notrack_prefix = current_templates->start->name;
4619                   break;
4620                 case PREFIX_REP:
4621                   if (current_templates->start->cpu_flags.bitfield.cpuhle)
4622                     i.hle_prefix = current_templates->start->name;
4623                   else if (current_templates->start->cpu_flags.bitfield.cpumpx)
4624                     i.bnd_prefix = current_templates->start->name;
4625                   else
4626                     i.rep_prefix = current_templates->start->name;
4627                   break;
4628                 default:
4629                   break;
4630                 }
4631             }
4632           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
4633           token_start = ++l;
4634         }
4635       else
4636         break;
4637     }
4638
4639   if (!current_templates)
4640     {
4641       /* Deprecated functionality (new code should use pseudo-prefixes instead):
4642          Check if we should swap operand or force 32bit displacement in
4643          encoding.  */
4644       if (mnem_p - 2 == dot_p && dot_p[1] == 's')
4645         i.dir_encoding = dir_encoding_swap;
4646       else if (mnem_p - 3 == dot_p
4647                && dot_p[1] == 'd'
4648                && dot_p[2] == '8')
4649         i.disp_encoding = disp_encoding_8bit;
4650       else if (mnem_p - 4 == dot_p
4651                && dot_p[1] == 'd'
4652                && dot_p[2] == '3'
4653                && dot_p[3] == '2')
4654         i.disp_encoding = disp_encoding_32bit;
4655       else
4656         goto check_suffix;
4657       mnem_p = dot_p;
4658       *dot_p = '\0';
4659       current_templates = (const templates *) hash_find (op_hash, mnemonic);
4660     }
4661
4662   if (!current_templates)
4663     {
4664 check_suffix:
4665       if (mnem_p > mnemonic)
4666         {
4667           /* See if we can get a match by trimming off a suffix.  */
4668           switch (mnem_p[-1])
4669             {
4670             case WORD_MNEM_SUFFIX:
4671               if (intel_syntax && (intel_float_operand (mnemonic) & 2))
4672                 i.suffix = SHORT_MNEM_SUFFIX;
4673               else
4674                 /* Fall through.  */
4675               case BYTE_MNEM_SUFFIX:
4676               case QWORD_MNEM_SUFFIX:
4677                 i.suffix = mnem_p[-1];
4678               mnem_p[-1] = '\0';
4679               current_templates = (const templates *) hash_find (op_hash,
4680                                                                  mnemonic);
4681               break;
4682             case SHORT_MNEM_SUFFIX:
4683             case LONG_MNEM_SUFFIX:
4684               if (!intel_syntax)
4685                 {
4686                   i.suffix = mnem_p[-1];
4687                   mnem_p[-1] = '\0';
4688                   current_templates = (const templates *) hash_find (op_hash,
4689                                                                      mnemonic);
4690                 }
4691               break;
4692
4693               /* Intel Syntax.  */
4694             case 'd':
4695               if (intel_syntax)
4696                 {
4697                   if (intel_float_operand (mnemonic) == 1)
4698                     i.suffix = SHORT_MNEM_SUFFIX;
4699                   else
4700                     i.suffix = LONG_MNEM_SUFFIX;
4701                   mnem_p[-1] = '\0';
4702                   current_templates = (const templates *) hash_find (op_hash,
4703                                                                      mnemonic);
4704                 }
4705               break;
4706             }
4707         }
4708
4709       if (!current_templates)
4710         {
4711           as_bad (_("no such instruction: `%s'"), token_start);
4712           return NULL;
4713         }
4714     }
4715
4716   if (current_templates->start->opcode_modifier.jump
4717       || current_templates->start->opcode_modifier.jumpbyte)
4718     {
4719       /* Check for a branch hint.  We allow ",pt" and ",pn" for
4720          predict taken and predict not taken respectively.
4721          I'm not sure that branch hints actually do anything on loop
4722          and jcxz insns (JumpByte) for current Pentium4 chips.  They
4723          may work in the future and it doesn't hurt to accept them
4724          now.  */
4725       if (l[0] == ',' && l[1] == 'p')
4726         {
4727           if (l[2] == 't')
4728             {
4729               if (!add_prefix (DS_PREFIX_OPCODE))
4730                 return NULL;
4731               l += 3;
4732             }
4733           else if (l[2] == 'n')
4734             {
4735               if (!add_prefix (CS_PREFIX_OPCODE))
4736                 return NULL;
4737               l += 3;
4738             }
4739         }
4740     }
4741   /* Any other comma loses.  */
4742   if (*l == ',')
4743     {
4744       as_bad (_("invalid character %s in mnemonic"),
4745               output_invalid (*l));
4746       return NULL;
4747     }
4748
4749   /* Check if instruction is supported on specified architecture.  */
4750   supported = 0;
4751   for (t = current_templates->start; t < current_templates->end; ++t)
4752     {
4753       supported |= cpu_flags_match (t);
4754       if (supported == CPU_FLAGS_PERFECT_MATCH)
4755         {
4756           if (!cpu_arch_flags.bitfield.cpui386 && (flag_code != CODE_16BIT))
4757             as_warn (_("use .code16 to ensure correct addressing mode"));
4758
4759           return l;
4760         }
4761     }
4762
4763   if (!(supported & CPU_FLAGS_64BIT_MATCH))
4764     as_bad (flag_code == CODE_64BIT
4765             ? _("`%s' is not supported in 64-bit mode")
4766             : _("`%s' is only supported in 64-bit mode"),
4767             current_templates->start->name);
4768   else
4769     as_bad (_("`%s' is not supported on `%s%s'"),
4770             current_templates->start->name,
4771             cpu_arch_name ? cpu_arch_name : default_arch,
4772             cpu_sub_arch_name ? cpu_sub_arch_name : "");
4773
4774   return NULL;
4775 }
4776
4777 static char *
4778 parse_operands (char *l, const char *mnemonic)
4779 {
4780   char *token_start;
4781
4782   /* 1 if operand is pending after ','.  */
4783   unsigned int expecting_operand = 0;
4784
4785   /* Non-zero if operand parens not balanced.  */
4786   unsigned int paren_not_balanced;
4787
4788   while (*l != END_OF_INSN)
4789     {
4790       /* Skip optional white space before operand.  */
4791       if (is_space_char (*l))
4792         ++l;
4793       if (!is_operand_char (*l) && *l != END_OF_INSN && *l != '"')
4794         {
4795           as_bad (_("invalid character %s before operand %d"),
4796                   output_invalid (*l),
4797                   i.operands + 1);
4798           return NULL;
4799         }
4800       token_start = l;  /* After white space.  */
4801       paren_not_balanced = 0;
4802       while (paren_not_balanced || *l != ',')
4803         {
4804           if (*l == END_OF_INSN)
4805             {
4806               if (paren_not_balanced)
4807                 {
4808                   if (!intel_syntax)
4809                     as_bad (_("unbalanced parenthesis in operand %d."),
4810                             i.operands + 1);
4811                   else
4812                     as_bad (_("unbalanced brackets in operand %d."),
4813                             i.operands + 1);
4814                   return NULL;
4815                 }
4816               else
4817                 break;  /* we are done */
4818             }
4819           else if (!is_operand_char (*l) && !is_space_char (*l) && *l != '"')
4820             {
4821               as_bad (_("invalid character %s in operand %d"),
4822                       output_invalid (*l),
4823                       i.operands + 1);
4824               return NULL;
4825             }
4826           if (!intel_syntax)
4827             {
4828               if (*l == '(')
4829                 ++paren_not_balanced;
4830               if (*l == ')')
4831                 --paren_not_balanced;
4832             }
4833           else
4834             {
4835               if (*l == '[')
4836                 ++paren_not_balanced;
4837               if (*l == ']')
4838                 --paren_not_balanced;
4839             }
4840           l++;
4841         }
4842       if (l != token_start)
4843         {                       /* Yes, we've read in another operand.  */
4844           unsigned int operand_ok;
4845           this_operand = i.operands++;
4846           if (i.operands > MAX_OPERANDS)
4847             {
4848               as_bad (_("spurious operands; (%d operands/instruction max)"),
4849                       MAX_OPERANDS);
4850               return NULL;
4851             }
4852           i.types[this_operand].bitfield.unspecified = 1;
4853           /* Now parse operand adding info to 'i' as we go along.  */
4854           END_STRING_AND_SAVE (l);
4855
4856           if (i.mem_operands > 1)
4857             {
4858               as_bad (_("too many memory references for `%s'"),
4859                       mnemonic);
4860               return 0;
4861             }
4862
4863           if (intel_syntax)
4864             operand_ok =
4865               i386_intel_operand (token_start,
4866                                   intel_float_operand (mnemonic));
4867           else
4868             operand_ok = i386_att_operand (token_start);
4869
4870           RESTORE_END_STRING (l);
4871           if (!operand_ok)
4872             return NULL;
4873         }
4874       else
4875         {
4876           if (expecting_operand)
4877             {
4878             expecting_operand_after_comma:
4879               as_bad (_("expecting operand after ','; got nothing"));
4880               return NULL;
4881             }
4882           if (*l == ',')
4883             {
4884               as_bad (_("expecting operand before ','; got nothing"));
4885               return NULL;
4886             }
4887         }
4888
4889       /* Now *l must be either ',' or END_OF_INSN.  */
4890       if (*l == ',')
4891         {
4892           if (*++l == END_OF_INSN)
4893             {
4894               /* Just skip it, if it's \n complain.  */
4895               goto expecting_operand_after_comma;
4896             }
4897           expecting_operand = 1;
4898         }
4899     }
4900   return l;
4901 }
4902
4903 static void
4904 swap_2_operands (int xchg1, int xchg2)
4905 {
4906   union i386_op temp_op;
4907   i386_operand_type temp_type;
4908   unsigned int temp_flags;
4909   enum bfd_reloc_code_real temp_reloc;
4910
4911   temp_type = i.types[xchg2];
4912   i.types[xchg2] = i.types[xchg1];
4913   i.types[xchg1] = temp_type;
4914
4915   temp_flags = i.flags[xchg2];
4916   i.flags[xchg2] = i.flags[xchg1];
4917   i.flags[xchg1] = temp_flags;
4918
4919   temp_op = i.op[xchg2];
4920   i.op[xchg2] = i.op[xchg1];
4921   i.op[xchg1] = temp_op;
4922
4923   temp_reloc = i.reloc[xchg2];
4924   i.reloc[xchg2] = i.reloc[xchg1];
4925   i.reloc[xchg1] = temp_reloc;
4926
4927   if (i.mask)
4928     {
4929       if (i.mask->operand == xchg1)
4930         i.mask->operand = xchg2;
4931       else if (i.mask->operand == xchg2)
4932         i.mask->operand = xchg1;
4933     }
4934   if (i.broadcast)
4935     {
4936       if (i.broadcast->operand == xchg1)
4937         i.broadcast->operand = xchg2;
4938       else if (i.broadcast->operand == xchg2)
4939         i.broadcast->operand = xchg1;
4940     }
4941   if (i.rounding)
4942     {
4943       if (i.rounding->operand == xchg1)
4944         i.rounding->operand = xchg2;
4945       else if (i.rounding->operand == xchg2)
4946         i.rounding->operand = xchg1;
4947     }
4948 }
4949
4950 static void
4951 swap_operands (void)
4952 {
4953   switch (i.operands)
4954     {
4955     case 5:
4956     case 4:
4957       swap_2_operands (1, i.operands - 2);
4958       /* Fall through.  */
4959     case 3:
4960     case 2:
4961       swap_2_operands (0, i.operands - 1);
4962       break;
4963     default:
4964       abort ();
4965     }
4966
4967   if (i.mem_operands == 2)
4968     {
4969       const seg_entry *temp_seg;
4970       temp_seg = i.seg[0];
4971       i.seg[0] = i.seg[1];
4972       i.seg[1] = temp_seg;
4973     }
4974 }
4975
4976 /* Try to ensure constant immediates are represented in the smallest
4977    opcode possible.  */
4978 static void
4979 optimize_imm (void)
4980 {
4981   char guess_suffix = 0;
4982   int op;
4983
4984   if (i.suffix)
4985     guess_suffix = i.suffix;
4986   else if (i.reg_operands)
4987     {
4988       /* Figure out a suffix from the last register operand specified.
4989          We can't do this properly yet, ie. excluding InOutPortReg,
4990          but the following works for instructions with immediates.
4991          In any case, we can't set i.suffix yet.  */
4992       for (op = i.operands; --op >= 0;)
4993         if (i.types[op].bitfield.reg && i.types[op].bitfield.byte)
4994           {
4995             guess_suffix = BYTE_MNEM_SUFFIX;
4996             break;
4997           }
4998         else if (i.types[op].bitfield.reg && i.types[op].bitfield.word)
4999           {
5000             guess_suffix = WORD_MNEM_SUFFIX;
5001             break;
5002           }
5003         else if (i.types[op].bitfield.reg && i.types[op].bitfield.dword)
5004           {
5005             guess_suffix = LONG_MNEM_SUFFIX;
5006             break;
5007           }
5008         else if (i.types[op].bitfield.reg && i.types[op].bitfield.qword)
5009           {
5010             guess_suffix = QWORD_MNEM_SUFFIX;
5011             break;
5012           }
5013     }
5014   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
5015     guess_suffix = WORD_MNEM_SUFFIX;
5016
5017   for (op = i.operands; --op >= 0;)
5018     if (operand_type_check (i.types[op], imm))
5019       {
5020         switch (i.op[op].imms->X_op)
5021           {
5022           case O_constant:
5023             /* If a suffix is given, this operand may be shortened.  */
5024             switch (guess_suffix)
5025               {
5026               case LONG_MNEM_SUFFIX:
5027                 i.types[op].bitfield.imm32 = 1;
5028                 i.types[op].bitfield.imm64 = 1;
5029                 break;
5030               case WORD_MNEM_SUFFIX:
5031                 i.types[op].bitfield.imm16 = 1;
5032                 i.types[op].bitfield.imm32 = 1;
5033                 i.types[op].bitfield.imm32s = 1;
5034                 i.types[op].bitfield.imm64 = 1;
5035                 break;
5036               case BYTE_MNEM_SUFFIX:
5037                 i.types[op].bitfield.imm8 = 1;
5038                 i.types[op].bitfield.imm8s = 1;
5039                 i.types[op].bitfield.imm16 = 1;
5040                 i.types[op].bitfield.imm32 = 1;
5041                 i.types[op].bitfield.imm32s = 1;
5042                 i.types[op].bitfield.imm64 = 1;
5043                 break;
5044               }
5045
5046             /* If this operand is at most 16 bits, convert it
5047                to a signed 16 bit number before trying to see
5048                whether it will fit in an even smaller size.
5049                This allows a 16-bit operand such as $0xffe0 to
5050                be recognised as within Imm8S range.  */
5051             if ((i.types[op].bitfield.imm16)
5052                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
5053               {
5054                 i.op[op].imms->X_add_number =
5055                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
5056               }
5057 #ifdef BFD64
5058             /* Store 32-bit immediate in 64-bit for 64-bit BFD.  */
5059             if ((i.types[op].bitfield.imm32)
5060                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
5061                     == 0))
5062               {
5063                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
5064                                                 ^ ((offsetT) 1 << 31))
5065                                                - ((offsetT) 1 << 31));
5066               }
5067 #endif
5068             i.types[op]
5069               = operand_type_or (i.types[op],
5070                                  smallest_imm_type (i.op[op].imms->X_add_number));
5071
5072             /* We must avoid matching of Imm32 templates when 64bit
5073                only immediate is available.  */
5074             if (guess_suffix == QWORD_MNEM_SUFFIX)
5075               i.types[op].bitfield.imm32 = 0;
5076             break;
5077
5078           case O_absent:
5079           case O_register:
5080             abort ();
5081
5082             /* Symbols and expressions.  */
5083           default:
5084             /* Convert symbolic operand to proper sizes for matching, but don't
5085                prevent matching a set of insns that only supports sizes other
5086                than those matching the insn suffix.  */
5087             {
5088               i386_operand_type mask, allowed;
5089               const insn_template *t;
5090
5091               operand_type_set (&mask, 0);
5092               operand_type_set (&allowed, 0);
5093
5094               for (t = current_templates->start;
5095                    t < current_templates->end;
5096                    ++t)
5097                 allowed = operand_type_or (allowed,
5098                                            t->operand_types[op]);
5099               switch (guess_suffix)
5100                 {
5101                 case QWORD_MNEM_SUFFIX:
5102                   mask.bitfield.imm64 = 1;
5103                   mask.bitfield.imm32s = 1;
5104                   break;
5105                 case LONG_MNEM_SUFFIX:
5106                   mask.bitfield.imm32 = 1;
5107                   break;
5108                 case WORD_MNEM_SUFFIX:
5109                   mask.bitfield.imm16 = 1;
5110                   break;
5111                 case BYTE_MNEM_SUFFIX:
5112                   mask.bitfield.imm8 = 1;
5113                   break;
5114                 default:
5115                   break;
5116                 }
5117               allowed = operand_type_and (mask, allowed);
5118               if (!operand_type_all_zero (&allowed))
5119                 i.types[op] = operand_type_and (i.types[op], mask);
5120             }
5121             break;
5122           }
5123       }
5124 }
5125
5126 /* Try to use the smallest displacement type too.  */
5127 static void
5128 optimize_disp (void)
5129 {
5130   int op;
5131
5132   for (op = i.operands; --op >= 0;)
5133     if (operand_type_check (i.types[op], disp))
5134       {
5135         if (i.op[op].disps->X_op == O_constant)
5136           {
5137             offsetT op_disp = i.op[op].disps->X_add_number;
5138
5139             if (i.types[op].bitfield.disp16
5140                 && (op_disp & ~(offsetT) 0xffff) == 0)
5141               {
5142                 /* If this operand is at most 16 bits, convert
5143                    to a signed 16 bit number and don't use 64bit
5144                    displacement.  */
5145                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
5146                 i.types[op].bitfield.disp64 = 0;
5147               }
5148 #ifdef BFD64
5149             /* Optimize 64-bit displacement to 32-bit for 64-bit BFD.  */
5150             if (i.types[op].bitfield.disp32
5151                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
5152               {
5153                 /* If this operand is at most 32 bits, convert
5154                    to a signed 32 bit number and don't use 64bit
5155                    displacement.  */
5156                 op_disp &= (((offsetT) 2 << 31) - 1);
5157                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
5158                 i.types[op].bitfield.disp64 = 0;
5159               }
5160 #endif
5161             if (!op_disp && i.types[op].bitfield.baseindex)
5162               {
5163                 i.types[op].bitfield.disp8 = 0;
5164                 i.types[op].bitfield.disp16 = 0;
5165                 i.types[op].bitfield.disp32 = 0;
5166                 i.types[op].bitfield.disp32s = 0;
5167                 i.types[op].bitfield.disp64 = 0;
5168                 i.op[op].disps = 0;
5169                 i.disp_operands--;
5170               }
5171             else if (flag_code == CODE_64BIT)
5172               {
5173                 if (fits_in_signed_long (op_disp))
5174                   {
5175                     i.types[op].bitfield.disp64 = 0;
5176                     i.types[op].bitfield.disp32s = 1;
5177                   }
5178                 if (i.prefix[ADDR_PREFIX]
5179                     && fits_in_unsigned_long (op_disp))
5180                   i.types[op].bitfield.disp32 = 1;
5181               }
5182             if ((i.types[op].bitfield.disp32
5183                  || i.types[op].bitfield.disp32s
5184                  || i.types[op].bitfield.disp16)
5185                 && fits_in_disp8 (op_disp))
5186               i.types[op].bitfield.disp8 = 1;
5187           }
5188         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
5189                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
5190           {
5191             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
5192                          i.op[op].disps, 0, i.reloc[op]);
5193             i.types[op].bitfield.disp8 = 0;
5194             i.types[op].bitfield.disp16 = 0;
5195             i.types[op].bitfield.disp32 = 0;
5196             i.types[op].bitfield.disp32s = 0;
5197             i.types[op].bitfield.disp64 = 0;
5198           }
5199         else
5200           /* We only support 64bit displacement on constants.  */
5201           i.types[op].bitfield.disp64 = 0;
5202       }
5203 }
5204
5205 /* Return 1 if there is a match in broadcast bytes between operand
5206    GIVEN and instruction template T.   */
5207
5208 static INLINE int
5209 match_broadcast_size (const insn_template *t, unsigned int given)
5210 {
5211   return ((t->opcode_modifier.broadcast == BYTE_BROADCAST
5212            && i.types[given].bitfield.byte)
5213           || (t->opcode_modifier.broadcast == WORD_BROADCAST
5214               && i.types[given].bitfield.word)
5215           || (t->opcode_modifier.broadcast == DWORD_BROADCAST
5216               && i.types[given].bitfield.dword)
5217           || (t->opcode_modifier.broadcast == QWORD_BROADCAST
5218               && i.types[given].bitfield.qword));
5219 }
5220
5221 /* Check if operands are valid for the instruction.  */
5222
5223 static int
5224 check_VecOperands (const insn_template *t)
5225 {
5226   unsigned int op;
5227   i386_cpu_flags cpu;
5228   static const i386_cpu_flags avx512 = CPU_ANY_AVX512F_FLAGS;
5229
5230   /* Templates allowing for ZMMword as well as YMMword and/or XMMword for
5231      any one operand are implicity requiring AVX512VL support if the actual
5232      operand size is YMMword or XMMword.  Since this function runs after
5233      template matching, there's no need to check for YMMword/XMMword in
5234      the template.  */
5235   cpu = cpu_flags_and (t->cpu_flags, avx512);
5236   if (!cpu_flags_all_zero (&cpu)
5237       && !t->cpu_flags.bitfield.cpuavx512vl
5238       && !cpu_arch_flags.bitfield.cpuavx512vl)
5239     {
5240       for (op = 0; op < t->operands; ++op)
5241         {
5242           if (t->operand_types[op].bitfield.zmmword
5243               && (i.types[op].bitfield.ymmword
5244                   || i.types[op].bitfield.xmmword))
5245             {
5246               i.error = unsupported;
5247               return 1;
5248             }
5249         }
5250     }
5251
5252   /* Without VSIB byte, we can't have a vector register for index.  */
5253   if (!t->opcode_modifier.vecsib
5254       && i.index_reg
5255       && (i.index_reg->reg_type.bitfield.xmmword
5256           || i.index_reg->reg_type.bitfield.ymmword
5257           || i.index_reg->reg_type.bitfield.zmmword))
5258     {
5259       i.error = unsupported_vector_index_register;
5260       return 1;
5261     }
5262
5263   /* Check if default mask is allowed.  */
5264   if (t->opcode_modifier.nodefmask
5265       && (!i.mask || i.mask->mask->reg_num == 0))
5266     {
5267       i.error = no_default_mask;
5268       return 1;
5269     }
5270
5271   /* For VSIB byte, we need a vector register for index, and all vector
5272      registers must be distinct.  */
5273   if (t->opcode_modifier.vecsib)
5274     {
5275       if (!i.index_reg
5276           || !((t->opcode_modifier.vecsib == VecSIB128
5277                 && i.index_reg->reg_type.bitfield.xmmword)
5278                || (t->opcode_modifier.vecsib == VecSIB256
5279                    && i.index_reg->reg_type.bitfield.ymmword)
5280                || (t->opcode_modifier.vecsib == VecSIB512
5281                    && i.index_reg->reg_type.bitfield.zmmword)))
5282       {
5283         i.error = invalid_vsib_address;
5284         return 1;
5285       }
5286
5287       gas_assert (i.reg_operands == 2 || i.mask);
5288       if (i.reg_operands == 2 && !i.mask)
5289         {
5290           gas_assert (i.types[0].bitfield.regsimd);
5291           gas_assert (i.types[0].bitfield.xmmword
5292                       || i.types[0].bitfield.ymmword);
5293           gas_assert (i.types[2].bitfield.regsimd);
5294           gas_assert (i.types[2].bitfield.xmmword
5295                       || i.types[2].bitfield.ymmword);
5296           if (operand_check == check_none)
5297             return 0;
5298           if (register_number (i.op[0].regs)
5299               != register_number (i.index_reg)
5300               && register_number (i.op[2].regs)
5301                  != register_number (i.index_reg)
5302               && register_number (i.op[0].regs)
5303                  != register_number (i.op[2].regs))
5304             return 0;
5305           if (operand_check == check_error)
5306             {
5307               i.error = invalid_vector_register_set;
5308               return 1;
5309             }
5310           as_warn (_("mask, index, and destination registers should be distinct"));
5311         }
5312       else if (i.reg_operands == 1 && i.mask)
5313         {
5314           if (i.types[1].bitfield.regsimd
5315               && (i.types[1].bitfield.xmmword
5316                   || i.types[1].bitfield.ymmword
5317                   || i.types[1].bitfield.zmmword)
5318               && (register_number (i.op[1].regs)
5319                   == register_number (i.index_reg)))
5320             {
5321               if (operand_check == check_error)
5322                 {
5323                   i.error = invalid_vector_register_set;
5324                   return 1;
5325                 }
5326               if (operand_check != check_none)
5327                 as_warn (_("index and destination registers should be distinct"));
5328             }
5329         }
5330     }
5331
5332   /* Check if broadcast is supported by the instruction and is applied
5333      to the memory operand.  */
5334   if (i.broadcast)
5335     {
5336       i386_operand_type type, overlap;
5337
5338       /* Check if specified broadcast is supported in this instruction,
5339          and its broadcast bytes match the memory operand.  */
5340       op = i.broadcast->operand;
5341       if (!t->opcode_modifier.broadcast
5342           || !(i.flags[op] & Operand_Mem)
5343           || (!i.types[op].bitfield.unspecified
5344               && !match_broadcast_size (t, op)))
5345         {
5346         bad_broadcast:
5347           i.error = unsupported_broadcast;
5348           return 1;
5349         }
5350
5351       i.broadcast->bytes = ((1 << (t->opcode_modifier.broadcast - 1))
5352                             * i.broadcast->type);
5353       operand_type_set (&type, 0);
5354       switch (i.broadcast->bytes)
5355         {
5356         case 2:
5357           type.bitfield.word = 1;
5358           break;
5359         case 4:
5360           type.bitfield.dword = 1;
5361           break;
5362         case 8:
5363           type.bitfield.qword = 1;
5364           break;
5365         case 16:
5366           type.bitfield.xmmword = 1;
5367           break;
5368         case 32:
5369           type.bitfield.ymmword = 1;
5370           break;
5371         case 64:
5372           type.bitfield.zmmword = 1;
5373           break;
5374         default:
5375           goto bad_broadcast;
5376         }
5377
5378       overlap = operand_type_and (type, t->operand_types[op]);
5379       if (operand_type_all_zero (&overlap))
5380           goto bad_broadcast;
5381
5382       if (t->opcode_modifier.checkregsize)
5383         {
5384           unsigned int j;
5385
5386           type.bitfield.baseindex = 1;
5387           for (j = 0; j < i.operands; ++j)
5388             {
5389               if (j != op
5390                   && !operand_type_register_match(i.types[j],
5391                                                   t->operand_types[j],
5392                                                   type,
5393                                                   t->operand_types[op]))
5394                 goto bad_broadcast;
5395             }
5396         }
5397     }
5398   /* If broadcast is supported in this instruction, we need to check if
5399      operand of one-element size isn't specified without broadcast.  */
5400   else if (t->opcode_modifier.broadcast && i.mem_operands)
5401     {
5402       /* Find memory operand.  */
5403       for (op = 0; op < i.operands; op++)
5404         if (operand_type_check (i.types[op], anymem))
5405           break;
5406       gas_assert (op < i.operands);
5407       /* Check size of the memory operand.  */
5408       if (match_broadcast_size (t, op))
5409         {
5410           i.error = broadcast_needed;
5411           return 1;
5412         }
5413     }
5414   else
5415     op = MAX_OPERANDS - 1; /* Avoid uninitialized variable warning.  */
5416
5417   /* Check if requested masking is supported.  */
5418   if (i.mask)
5419     {
5420       switch (t->opcode_modifier.masking)
5421         {
5422         case BOTH_MASKING:
5423           break;
5424         case MERGING_MASKING:
5425           if (i.mask->zeroing)
5426             {
5427         case 0:
5428               i.error = unsupported_masking;
5429               return 1;
5430             }
5431           break;
5432         case DYNAMIC_MASKING:
5433           /* Memory destinations allow only merging masking.  */
5434           if (i.mask->zeroing && i.mem_operands)
5435             {
5436               /* Find memory operand.  */
5437               for (op = 0; op < i.operands; op++)
5438                 if (i.flags[op] & Operand_Mem)
5439                   break;
5440               gas_assert (op < i.operands);
5441               if (op == i.operands - 1)
5442                 {
5443                   i.error = unsupported_masking;
5444                   return 1;
5445                 }
5446             }
5447           break;
5448         default:
5449           abort ();
5450         }
5451     }
5452
5453   /* Check if masking is applied to dest operand.  */
5454   if (i.mask && (i.mask->operand != (int) (i.operands - 1)))
5455     {
5456       i.error = mask_not_on_destination;
5457       return 1;
5458     }
5459
5460   /* Check RC/SAE.  */
5461   if (i.rounding)
5462     {
5463       if ((i.rounding->type != saeonly
5464            && !t->opcode_modifier.staticrounding)
5465           || (i.rounding->type == saeonly
5466               && (t->opcode_modifier.staticrounding
5467                   || !t->opcode_modifier.sae)))
5468         {
5469           i.error = unsupported_rc_sae;
5470           return 1;
5471         }
5472       /* If the instruction has several immediate operands and one of
5473          them is rounding, the rounding operand should be the last
5474          immediate operand.  */
5475       if (i.imm_operands > 1
5476           && i.rounding->operand != (int) (i.imm_operands - 1))
5477         {
5478           i.error = rc_sae_operand_not_last_imm;
5479           return 1;
5480         }
5481     }
5482
5483   /* Check vector Disp8 operand.  */
5484   if (t->opcode_modifier.disp8memshift
5485       && i.disp_encoding != disp_encoding_32bit)
5486     {
5487       if (i.broadcast)
5488         i.memshift = t->opcode_modifier.broadcast - 1;
5489       else if (t->opcode_modifier.disp8memshift != DISP8_SHIFT_VL)
5490         i.memshift = t->opcode_modifier.disp8memshift;
5491       else
5492         {
5493           const i386_operand_type *type = NULL;
5494
5495           i.memshift = 0;
5496           for (op = 0; op < i.operands; op++)
5497             if (operand_type_check (i.types[op], anymem))
5498               {
5499                 if (t->opcode_modifier.evex == EVEXLIG)
5500                   i.memshift = 2 + (i.suffix == QWORD_MNEM_SUFFIX);
5501                 else if (t->operand_types[op].bitfield.xmmword
5502                          + t->operand_types[op].bitfield.ymmword
5503                          + t->operand_types[op].bitfield.zmmword <= 1)
5504                   type = &t->operand_types[op];
5505                 else if (!i.types[op].bitfield.unspecified)
5506                   type = &i.types[op];
5507               }
5508             else if (i.types[op].bitfield.regsimd
5509                      && t->opcode_modifier.evex != EVEXLIG)
5510               {
5511                 if (i.types[op].bitfield.zmmword)
5512                   i.memshift = 6;
5513                 else if (i.types[op].bitfield.ymmword && i.memshift < 5)
5514                   i.memshift = 5;
5515                 else if (i.types[op].bitfield.xmmword && i.memshift < 4)
5516                   i.memshift = 4;
5517               }
5518
5519           if (type)
5520             {
5521               if (type->bitfield.zmmword)
5522                 i.memshift = 6;
5523               else if (type->bitfield.ymmword)
5524                 i.memshift = 5;
5525               else if (type->bitfield.xmmword)
5526                 i.memshift = 4;
5527             }
5528
5529           /* For the check in fits_in_disp8().  */
5530           if (i.memshift == 0)
5531             i.memshift = -1;
5532         }
5533
5534       for (op = 0; op < i.operands; op++)
5535         if (operand_type_check (i.types[op], disp)
5536             && i.op[op].disps->X_op == O_constant)
5537           {
5538             if (fits_in_disp8 (i.op[op].disps->X_add_number))
5539               {
5540                 i.types[op].bitfield.disp8 = 1;
5541                 return 0;
5542               }
5543             i.types[op].bitfield.disp8 = 0;
5544           }
5545     }
5546
5547   i.memshift = 0;
5548
5549   return 0;
5550 }
5551
5552 /* Check if operands are valid for the instruction.  Update VEX
5553    operand types.  */
5554
5555 static int
5556 VEX_check_operands (const insn_template *t)
5557 {
5558   if (i.vec_encoding == vex_encoding_evex)
5559     {
5560       /* This instruction must be encoded with EVEX prefix.  */
5561       if (!is_evex_encoding (t))
5562         {
5563           i.error = unsupported;
5564           return 1;
5565         }
5566       return 0;
5567     }
5568
5569   if (!t->opcode_modifier.vex)
5570     {
5571       /* This instruction template doesn't have VEX prefix.  */
5572       if (i.vec_encoding != vex_encoding_default)
5573         {
5574           i.error = unsupported;
5575           return 1;
5576         }
5577       return 0;
5578     }
5579
5580   /* Only check VEX_Imm4, which must be the first operand.  */
5581   if (t->operand_types[0].bitfield.vec_imm4)
5582     {
5583       if (i.op[0].imms->X_op != O_constant
5584           || !fits_in_imm4 (i.op[0].imms->X_add_number))
5585         {
5586           i.error = bad_imm4;
5587           return 1;
5588         }
5589
5590       /* Turn off Imm8 so that update_imm won't complain.  */
5591       i.types[0] = vec_imm4;
5592     }
5593
5594   return 0;
5595 }
5596
5597 static const insn_template *
5598 match_template (char mnem_suffix)
5599 {
5600   /* Points to template once we've found it.  */
5601   const insn_template *t;
5602   i386_operand_type overlap0, overlap1, overlap2, overlap3;
5603   i386_operand_type overlap4;
5604   unsigned int found_reverse_match;
5605   i386_opcode_modifier suffix_check, mnemsuf_check;
5606   i386_operand_type operand_types [MAX_OPERANDS];
5607   int addr_prefix_disp;
5608   unsigned int j;
5609   unsigned int found_cpu_match, size_match;
5610   unsigned int check_register;
5611   enum i386_error specific_error = 0;
5612
5613 #if MAX_OPERANDS != 5
5614 # error "MAX_OPERANDS must be 5."
5615 #endif
5616
5617   found_reverse_match = 0;
5618   addr_prefix_disp = -1;
5619
5620   memset (&suffix_check, 0, sizeof (suffix_check));
5621   if (intel_syntax && i.broadcast)
5622     /* nothing */;
5623   else if (i.suffix == BYTE_MNEM_SUFFIX)
5624     suffix_check.no_bsuf = 1;
5625   else if (i.suffix == WORD_MNEM_SUFFIX)
5626     suffix_check.no_wsuf = 1;
5627   else if (i.suffix == SHORT_MNEM_SUFFIX)
5628     suffix_check.no_ssuf = 1;
5629   else if (i.suffix == LONG_MNEM_SUFFIX)
5630     suffix_check.no_lsuf = 1;
5631   else if (i.suffix == QWORD_MNEM_SUFFIX)
5632     suffix_check.no_qsuf = 1;
5633   else if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
5634     suffix_check.no_ldsuf = 1;
5635
5636   memset (&mnemsuf_check, 0, sizeof (mnemsuf_check));
5637   if (intel_syntax)
5638     {
5639       switch (mnem_suffix)
5640         {
5641         case BYTE_MNEM_SUFFIX:  mnemsuf_check.no_bsuf = 1; break;
5642         case WORD_MNEM_SUFFIX:  mnemsuf_check.no_wsuf = 1; break;
5643         case SHORT_MNEM_SUFFIX: mnemsuf_check.no_ssuf = 1; break;
5644         case LONG_MNEM_SUFFIX:  mnemsuf_check.no_lsuf = 1; break;
5645         case QWORD_MNEM_SUFFIX: mnemsuf_check.no_qsuf = 1; break;
5646         }
5647     }
5648
5649   /* Must have right number of operands.  */
5650   i.error = number_of_operands_mismatch;
5651
5652   for (t = current_templates->start; t < current_templates->end; t++)
5653     {
5654       addr_prefix_disp = -1;
5655       found_reverse_match = 0;
5656
5657       if (i.operands != t->operands)
5658         continue;
5659
5660       /* Check processor support.  */
5661       i.error = unsupported;
5662       found_cpu_match = (cpu_flags_match (t)
5663                          == CPU_FLAGS_PERFECT_MATCH);
5664       if (!found_cpu_match)
5665         continue;
5666
5667       /* Check AT&T mnemonic.   */
5668       i.error = unsupported_with_intel_mnemonic;
5669       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
5670         continue;
5671
5672       /* Check AT&T/Intel syntax and Intel64/AMD64 ISA.   */
5673       i.error = unsupported_syntax;
5674       if ((intel_syntax && t->opcode_modifier.attsyntax)
5675           || (!intel_syntax && t->opcode_modifier.intelsyntax)
5676           || (intel64 && t->opcode_modifier.amd64)
5677           || (!intel64 && t->opcode_modifier.intel64))
5678         continue;
5679
5680       /* Check the suffix, except for some instructions in intel mode.  */
5681       i.error = invalid_instruction_suffix;
5682       if ((!intel_syntax || !t->opcode_modifier.ignoresize)
5683           && ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
5684               || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
5685               || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
5686               || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
5687               || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
5688               || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf)))
5689         continue;
5690       /* In Intel mode all mnemonic suffixes must be explicitly allowed.  */
5691       if ((t->opcode_modifier.no_bsuf && mnemsuf_check.no_bsuf)
5692           || (t->opcode_modifier.no_wsuf && mnemsuf_check.no_wsuf)
5693           || (t->opcode_modifier.no_lsuf && mnemsuf_check.no_lsuf)
5694           || (t->opcode_modifier.no_ssuf && mnemsuf_check.no_ssuf)
5695           || (t->opcode_modifier.no_qsuf && mnemsuf_check.no_qsuf)
5696           || (t->opcode_modifier.no_ldsuf && mnemsuf_check.no_ldsuf))
5697         continue;
5698
5699       size_match = operand_size_match (t);
5700       if (!size_match)
5701         continue;
5702
5703       for (j = 0; j < MAX_OPERANDS; j++)
5704         operand_types[j] = t->operand_types[j];
5705
5706       /* In general, don't allow 64-bit operands in 32-bit mode.  */
5707       if (i.suffix == QWORD_MNEM_SUFFIX
5708           && flag_code != CODE_64BIT
5709           && (intel_syntax
5710               ? (!t->opcode_modifier.ignoresize
5711                  && !t->opcode_modifier.broadcast
5712                  && !intel_float_operand (t->name))
5713               : intel_float_operand (t->name) != 2)
5714           && ((!operand_types[0].bitfield.regmmx
5715                && !operand_types[0].bitfield.regsimd)
5716               || (!operand_types[t->operands > 1].bitfield.regmmx
5717                   && !operand_types[t->operands > 1].bitfield.regsimd))
5718           && (t->base_opcode != 0x0fc7
5719               || t->extension_opcode != 1 /* cmpxchg8b */))
5720         continue;
5721
5722       /* In general, don't allow 32-bit operands on pre-386.  */
5723       else if (i.suffix == LONG_MNEM_SUFFIX
5724                && !cpu_arch_flags.bitfield.cpui386
5725                && (intel_syntax
5726                    ? (!t->opcode_modifier.ignoresize
5727                       && !intel_float_operand (t->name))
5728                    : intel_float_operand (t->name) != 2)
5729                && ((!operand_types[0].bitfield.regmmx
5730                     && !operand_types[0].bitfield.regsimd)
5731                    || (!operand_types[t->operands > 1].bitfield.regmmx
5732                        && !operand_types[t->operands > 1].bitfield.regsimd)))
5733         continue;
5734
5735       /* Do not verify operands when there are none.  */
5736       else
5737         {
5738           if (!t->operands)
5739             /* We've found a match; break out of loop.  */
5740             break;
5741         }
5742
5743       /* Address size prefix will turn Disp64/Disp32/Disp16 operand
5744          into Disp32/Disp16/Disp32 operand.  */
5745       if (i.prefix[ADDR_PREFIX] != 0)
5746           {
5747             /* There should be only one Disp operand.  */
5748             switch (flag_code)
5749             {
5750             case CODE_16BIT:
5751               for (j = 0; j < MAX_OPERANDS; j++)
5752                 {
5753                   if (operand_types[j].bitfield.disp16)
5754                     {
5755                       addr_prefix_disp = j;
5756                       operand_types[j].bitfield.disp32 = 1;
5757                       operand_types[j].bitfield.disp16 = 0;
5758                       break;
5759                     }
5760                 }
5761               break;
5762             case CODE_32BIT:
5763               for (j = 0; j < MAX_OPERANDS; j++)
5764                 {
5765                   if (operand_types[j].bitfield.disp32)
5766                     {
5767                       addr_prefix_disp = j;
5768                       operand_types[j].bitfield.disp32 = 0;
5769                       operand_types[j].bitfield.disp16 = 1;
5770                       break;
5771                     }
5772                 }
5773               break;
5774             case CODE_64BIT:
5775               for (j = 0; j < MAX_OPERANDS; j++)
5776                 {
5777                   if (operand_types[j].bitfield.disp64)
5778                     {
5779                       addr_prefix_disp = j;
5780                       operand_types[j].bitfield.disp64 = 0;
5781                       operand_types[j].bitfield.disp32 = 1;
5782                       break;
5783                     }
5784                 }
5785               break;
5786             }
5787           }
5788
5789       /* Force 0x8b encoding for "mov foo@GOT, %eax".  */
5790       if (i.reloc[0] == BFD_RELOC_386_GOT32 && t->base_opcode == 0xa0)
5791         continue;
5792
5793       /* We check register size if needed.  */
5794       if (t->opcode_modifier.checkregsize)
5795         {
5796           check_register = (1 << t->operands) - 1;
5797           if (i.broadcast)
5798             check_register &= ~(1 << i.broadcast->operand);
5799         }
5800       else
5801         check_register = 0;
5802
5803       overlap0 = operand_type_and (i.types[0], operand_types[0]);
5804       switch (t->operands)
5805         {
5806         case 1:
5807           if (!operand_type_match (overlap0, i.types[0]))
5808             continue;
5809           break;
5810         case 2:
5811           /* xchg %eax, %eax is a special case. It is an alias for nop
5812              only in 32bit mode and we can use opcode 0x90.  In 64bit
5813              mode, we can't use 0x90 for xchg %eax, %eax since it should
5814              zero-extend %eax to %rax.  */
5815           if (flag_code == CODE_64BIT
5816               && t->base_opcode == 0x90
5817               && operand_type_equal (&i.types [0], &acc32)
5818               && operand_type_equal (&i.types [1], &acc32))
5819             continue;
5820           /* xrelease mov %eax, <disp> is another special case. It must not
5821              match the accumulator-only encoding of mov.  */
5822           if (flag_code != CODE_64BIT
5823               && i.hle_prefix
5824               && t->base_opcode == 0xa0
5825               && i.types[0].bitfield.acc
5826               && operand_type_check (i.types[1], anymem))
5827             continue;
5828           /* Fall through.  */
5829
5830         case 3:
5831           if (!(size_match & MATCH_STRAIGHT))
5832             goto check_reverse;
5833           /* Reverse direction of operands if swapping is possible in the first
5834              place (operands need to be symmetric) and
5835              - the load form is requested, and the template is a store form,
5836              - the store form is requested, and the template is a load form,
5837              - the non-default (swapped) form is requested.  */
5838           overlap1 = operand_type_and (operand_types[0], operand_types[1]);
5839           if (t->opcode_modifier.d && i.reg_operands == i.operands
5840               && !operand_type_all_zero (&overlap1))
5841             switch (i.dir_encoding)
5842               {
5843               case dir_encoding_load:
5844                 if (operand_type_check (operand_types[i.operands - 1], anymem)
5845                     || operand_types[i.operands - 1].bitfield.regmem)
5846                   goto check_reverse;
5847                 break;
5848
5849               case dir_encoding_store:
5850                 if (!operand_type_check (operand_types[i.operands - 1], anymem)
5851                     && !operand_types[i.operands - 1].bitfield.regmem)
5852                   goto check_reverse;
5853                 break;
5854
5855               case dir_encoding_swap:
5856                 goto check_reverse;
5857
5858               case dir_encoding_default:
5859                 break;
5860               }
5861           /* If we want store form, we skip the current load.  */
5862           if ((i.dir_encoding == dir_encoding_store
5863                || i.dir_encoding == dir_encoding_swap)
5864               && i.mem_operands == 0
5865               && t->opcode_modifier.load)
5866             continue;
5867           /* Fall through.  */
5868         case 4:
5869         case 5:
5870           overlap1 = operand_type_and (i.types[1], operand_types[1]);
5871           if (!operand_type_match (overlap0, i.types[0])
5872               || !operand_type_match (overlap1, i.types[1])
5873               || ((check_register & 3) == 3
5874                   && !operand_type_register_match (i.types[0],
5875                                                    operand_types[0],
5876                                                    i.types[1],
5877                                                    operand_types[1])))
5878             {
5879               /* Check if other direction is valid ...  */
5880               if (!t->opcode_modifier.d)
5881                 continue;
5882
5883 check_reverse:
5884               if (!(size_match & MATCH_REVERSE))
5885                 continue;
5886               /* Try reversing direction of operands.  */
5887               overlap0 = operand_type_and (i.types[0], operand_types[i.operands - 1]);
5888               overlap1 = operand_type_and (i.types[i.operands - 1], operand_types[0]);
5889               if (!operand_type_match (overlap0, i.types[0])
5890                   || !operand_type_match (overlap1, i.types[i.operands - 1])
5891                   || (check_register
5892                       && !operand_type_register_match (i.types[0],
5893                                                        operand_types[i.operands - 1],
5894                                                        i.types[i.operands - 1],
5895                                                        operand_types[0])))
5896                 {
5897                   /* Does not match either direction.  */
5898                   continue;
5899                 }
5900               /* found_reverse_match holds which of D or FloatR
5901                  we've found.  */
5902               if (!t->opcode_modifier.d)
5903                 found_reverse_match = 0;
5904               else if (operand_types[0].bitfield.tbyte)
5905                 found_reverse_match = Opcode_FloatD;
5906               else if (operand_types[0].bitfield.xmmword
5907                        || operand_types[i.operands - 1].bitfield.xmmword
5908                        || operand_types[0].bitfield.regmmx
5909                        || operand_types[i.operands - 1].bitfield.regmmx
5910                        || is_any_vex_encoding(t))
5911                 found_reverse_match = (t->base_opcode & 0xee) != 0x6e
5912                                       ? Opcode_SIMD_FloatD : Opcode_SIMD_IntD;
5913               else
5914                 found_reverse_match = Opcode_D;
5915               if (t->opcode_modifier.floatr)
5916                 found_reverse_match |= Opcode_FloatR;
5917             }
5918           else
5919             {
5920               /* Found a forward 2 operand match here.  */
5921               switch (t->operands)
5922                 {
5923                 case 5:
5924                   overlap4 = operand_type_and (i.types[4],
5925                                                operand_types[4]);
5926                   /* Fall through.  */
5927                 case 4:
5928                   overlap3 = operand_type_and (i.types[3],
5929                                                operand_types[3]);
5930                   /* Fall through.  */
5931                 case 3:
5932                   overlap2 = operand_type_and (i.types[2],
5933                                                operand_types[2]);
5934                   break;
5935                 }
5936
5937               switch (t->operands)
5938                 {
5939                 case 5:
5940                   if (!operand_type_match (overlap4, i.types[4])
5941                       || !operand_type_register_match (i.types[3],
5942                                                        operand_types[3],
5943                                                        i.types[4],
5944                                                        operand_types[4]))
5945                     continue;
5946                   /* Fall through.  */
5947                 case 4:
5948                   if (!operand_type_match (overlap3, i.types[3])
5949                       || ((check_register & 0xa) == 0xa
5950                           && !operand_type_register_match (i.types[1],
5951                                                             operand_types[1],
5952                                                             i.types[3],
5953                                                             operand_types[3]))
5954                       || ((check_register & 0xc) == 0xc
5955                           && !operand_type_register_match (i.types[2],
5956                                                             operand_types[2],
5957                                                             i.types[3],
5958                                                             operand_types[3])))
5959                     continue;
5960                   /* Fall through.  */
5961                 case 3:
5962                   /* Here we make use of the fact that there are no
5963                      reverse match 3 operand instructions.  */
5964                   if (!operand_type_match (overlap2, i.types[2])
5965                       || ((check_register & 5) == 5
5966                           && !operand_type_register_match (i.types[0],
5967                                                             operand_types[0],
5968                                                             i.types[2],
5969                                                             operand_types[2]))
5970                       || ((check_register & 6) == 6
5971                           && !operand_type_register_match (i.types[1],
5972                                                             operand_types[1],
5973                                                             i.types[2],
5974                                                             operand_types[2])))
5975                     continue;
5976                   break;
5977                 }
5978             }
5979           /* Found either forward/reverse 2, 3 or 4 operand match here:
5980              slip through to break.  */
5981         }
5982       if (!found_cpu_match)
5983         continue;
5984
5985       /* Check if vector and VEX operands are valid.  */
5986       if (check_VecOperands (t) || VEX_check_operands (t))
5987         {
5988           specific_error = i.error;
5989           continue;
5990         }
5991
5992       /* We've found a match; break out of loop.  */
5993       break;
5994     }
5995
5996   if (t == current_templates->end)
5997     {
5998       /* We found no match.  */
5999       const char *err_msg;
6000       switch (specific_error ? specific_error : i.error)
6001         {
6002         default:
6003           abort ();
6004         case operand_size_mismatch:
6005           err_msg = _("operand size mismatch");
6006           break;
6007         case operand_type_mismatch:
6008           err_msg = _("operand type mismatch");
6009           break;
6010         case register_type_mismatch:
6011           err_msg = _("register type mismatch");
6012           break;
6013         case number_of_operands_mismatch:
6014           err_msg = _("number of operands mismatch");
6015           break;
6016         case invalid_instruction_suffix:
6017           err_msg = _("invalid instruction suffix");
6018           break;
6019         case bad_imm4:
6020           err_msg = _("constant doesn't fit in 4 bits");
6021           break;
6022         case unsupported_with_intel_mnemonic:
6023           err_msg = _("unsupported with Intel mnemonic");
6024           break;
6025         case unsupported_syntax:
6026           err_msg = _("unsupported syntax");
6027           break;
6028         case unsupported:
6029           as_bad (_("unsupported instruction `%s'"),
6030                   current_templates->start->name);
6031           return NULL;
6032         case invalid_vsib_address:
6033           err_msg = _("invalid VSIB address");
6034           break;
6035         case invalid_vector_register_set:
6036           err_msg = _("mask, index, and destination registers must be distinct");
6037           break;
6038         case unsupported_vector_index_register:
6039           err_msg = _("unsupported vector index register");
6040           break;
6041         case unsupported_broadcast:
6042           err_msg = _("unsupported broadcast");
6043           break;
6044         case broadcast_needed:
6045           err_msg = _("broadcast is needed for operand of such type");
6046           break;
6047         case unsupported_masking:
6048           err_msg = _("unsupported masking");
6049           break;
6050         case mask_not_on_destination:
6051           err_msg = _("mask not on destination operand");
6052           break;
6053         case no_default_mask:
6054           err_msg = _("default mask isn't allowed");
6055           break;
6056         case unsupported_rc_sae:
6057           err_msg = _("unsupported static rounding/sae");
6058           break;
6059         case rc_sae_operand_not_last_imm:
6060           if (intel_syntax)
6061             err_msg = _("RC/SAE operand must precede immediate operands");
6062           else
6063             err_msg = _("RC/SAE operand must follow immediate operands");
6064           break;
6065         case invalid_register_operand:
6066           err_msg = _("invalid register operand");
6067           break;
6068         }
6069       as_bad (_("%s for `%s'"), err_msg,
6070               current_templates->start->name);
6071       return NULL;
6072     }
6073
6074   if (!quiet_warnings)
6075     {
6076       if (!intel_syntax
6077           && (i.types[0].bitfield.jumpabsolute
6078               != operand_types[0].bitfield.jumpabsolute))
6079         {
6080           as_warn (_("indirect %s without `*'"), t->name);
6081         }
6082
6083       if (t->opcode_modifier.isprefix
6084           && t->opcode_modifier.ignoresize)
6085         {
6086           /* Warn them that a data or address size prefix doesn't
6087              affect assembly of the next line of code.  */
6088           as_warn (_("stand-alone `%s' prefix"), t->name);
6089         }
6090     }
6091
6092   /* Copy the template we found.  */
6093   i.tm = *t;
6094
6095   if (addr_prefix_disp != -1)
6096     i.tm.operand_types[addr_prefix_disp]
6097       = operand_types[addr_prefix_disp];
6098
6099   if (found_reverse_match)
6100     {
6101       /* If we found a reverse match we must alter the opcode
6102          direction bit.  found_reverse_match holds bits to change
6103          (different for int & float insns).  */
6104
6105       i.tm.base_opcode ^= found_reverse_match;
6106
6107       i.tm.operand_types[0] = operand_types[i.operands - 1];
6108       i.tm.operand_types[i.operands - 1] = operand_types[0];
6109     }
6110
6111   return t;
6112 }
6113
6114 static int
6115 check_string (void)
6116 {
6117   int mem_op = operand_type_check (i.types[0], anymem) ? 0 : 1;
6118   if (i.tm.operand_types[mem_op].bitfield.esseg)
6119     {
6120       if (i.seg[0] != NULL && i.seg[0] != &es)
6121         {
6122           as_bad (_("`%s' operand %d must use `%ses' segment"),
6123                   i.tm.name,
6124                   mem_op + 1,
6125                   register_prefix);
6126           return 0;
6127         }
6128       /* There's only ever one segment override allowed per instruction.
6129          This instruction possibly has a legal segment override on the
6130          second operand, so copy the segment to where non-string
6131          instructions store it, allowing common code.  */
6132       i.seg[0] = i.seg[1];
6133     }
6134   else if (i.tm.operand_types[mem_op + 1].bitfield.esseg)
6135     {
6136       if (i.seg[1] != NULL && i.seg[1] != &es)
6137         {
6138           as_bad (_("`%s' operand %d must use `%ses' segment"),
6139                   i.tm.name,
6140                   mem_op + 2,
6141                   register_prefix);
6142           return 0;
6143         }
6144     }
6145   return 1;
6146 }
6147
6148 static int
6149 process_suffix (void)
6150 {
6151   /* If matched instruction specifies an explicit instruction mnemonic
6152      suffix, use it.  */
6153   if (i.tm.opcode_modifier.size == SIZE16)
6154     i.suffix = WORD_MNEM_SUFFIX;
6155   else if (i.tm.opcode_modifier.size == SIZE32)
6156     i.suffix = LONG_MNEM_SUFFIX;
6157   else if (i.tm.opcode_modifier.size == SIZE64)
6158     i.suffix = QWORD_MNEM_SUFFIX;
6159   else if (i.reg_operands)
6160     {
6161       /* If there's no instruction mnemonic suffix we try to invent one
6162          based on register operands.  */
6163       if (!i.suffix)
6164         {
6165           /* We take i.suffix from the last register operand specified,
6166              Destination register type is more significant than source
6167              register type.  crc32 in SSE4.2 prefers source register
6168              type. */
6169           if (i.tm.base_opcode == 0xf20f38f0 && i.types[0].bitfield.reg)
6170             {
6171               if (i.types[0].bitfield.byte)
6172                 i.suffix = BYTE_MNEM_SUFFIX;
6173               else if (i.types[0].bitfield.word)
6174                 i.suffix = WORD_MNEM_SUFFIX;
6175               else if (i.types[0].bitfield.dword)
6176                 i.suffix = LONG_MNEM_SUFFIX;
6177               else if (i.types[0].bitfield.qword)
6178                 i.suffix = QWORD_MNEM_SUFFIX;
6179             }
6180
6181           if (!i.suffix)
6182             {
6183               int op;
6184
6185               if (i.tm.base_opcode == 0xf20f38f0)
6186                 {
6187                   /* We have to know the operand size for crc32.  */
6188                   as_bad (_("ambiguous memory operand size for `%s`"),
6189                           i.tm.name);
6190                   return 0;
6191                 }
6192
6193               for (op = i.operands; --op >= 0;)
6194                 if (!i.tm.operand_types[op].bitfield.inoutportreg
6195                     && !i.tm.operand_types[op].bitfield.shiftcount)
6196                   {
6197                     if (!i.types[op].bitfield.reg)
6198                       continue;
6199                     if (i.types[op].bitfield.byte)
6200                       i.suffix = BYTE_MNEM_SUFFIX;
6201                     else if (i.types[op].bitfield.word)
6202                       i.suffix = WORD_MNEM_SUFFIX;
6203                     else if (i.types[op].bitfield.dword)
6204                       i.suffix = LONG_MNEM_SUFFIX;
6205                     else if (i.types[op].bitfield.qword)
6206                       i.suffix = QWORD_MNEM_SUFFIX;
6207                     else
6208                       continue;
6209                     break;
6210                   }
6211             }
6212         }
6213       else if (i.suffix == BYTE_MNEM_SUFFIX)
6214         {
6215           if (intel_syntax
6216               && i.tm.opcode_modifier.ignoresize
6217               && i.tm.opcode_modifier.no_bsuf)
6218             i.suffix = 0;
6219           else if (!check_byte_reg ())
6220             return 0;
6221         }
6222       else if (i.suffix == LONG_MNEM_SUFFIX)
6223         {
6224           if (intel_syntax
6225               && i.tm.opcode_modifier.ignoresize
6226               && i.tm.opcode_modifier.no_lsuf
6227               && !i.tm.opcode_modifier.todword
6228               && !i.tm.opcode_modifier.toqword)
6229             i.suffix = 0;
6230           else if (!check_long_reg ())
6231             return 0;
6232         }
6233       else if (i.suffix == QWORD_MNEM_SUFFIX)
6234         {
6235           if (intel_syntax
6236               && i.tm.opcode_modifier.ignoresize
6237               && i.tm.opcode_modifier.no_qsuf
6238               && !i.tm.opcode_modifier.todword
6239               && !i.tm.opcode_modifier.toqword)
6240             i.suffix = 0;
6241           else if (!check_qword_reg ())
6242             return 0;
6243         }
6244       else if (i.suffix == WORD_MNEM_SUFFIX)
6245         {
6246           if (intel_syntax
6247               && i.tm.opcode_modifier.ignoresize
6248               && i.tm.opcode_modifier.no_wsuf)
6249             i.suffix = 0;
6250           else if (!check_word_reg ())
6251             return 0;
6252         }
6253       else if (intel_syntax && i.tm.opcode_modifier.ignoresize)
6254         /* Do nothing if the instruction is going to ignore the prefix.  */
6255         ;
6256       else
6257         abort ();
6258     }
6259   else if (i.tm.opcode_modifier.defaultsize
6260            && !i.suffix
6261            /* exclude fldenv/frstor/fsave/fstenv */
6262            && i.tm.opcode_modifier.no_ssuf)
6263     {
6264       if (stackop_size == LONG_MNEM_SUFFIX
6265           && i.tm.base_opcode == 0xcf)
6266         {
6267           /* stackop_size is set to LONG_MNEM_SUFFIX for the
6268              .code16gcc directive to support 16-bit mode with
6269              32-bit address.  For IRET without a suffix, generate
6270              16-bit IRET (opcode 0xcf) to return from an interrupt
6271              handler.  */
6272           i.suffix = WORD_MNEM_SUFFIX;
6273           as_warn (_("generating 16-bit `iret' for .code16gcc directive"));
6274         }
6275       else
6276         i.suffix = stackop_size;
6277     }
6278   else if (intel_syntax
6279            && !i.suffix
6280            && (i.tm.operand_types[0].bitfield.jumpabsolute
6281                || i.tm.opcode_modifier.jumpbyte
6282                || i.tm.opcode_modifier.jumpintersegment
6283                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
6284                    && i.tm.extension_opcode <= 3)))
6285     {
6286       switch (flag_code)
6287         {
6288         case CODE_64BIT:
6289           if (!i.tm.opcode_modifier.no_qsuf)
6290             {
6291               i.suffix = QWORD_MNEM_SUFFIX;
6292               break;
6293             }
6294           /* Fall through.  */
6295         case CODE_32BIT:
6296           if (!i.tm.opcode_modifier.no_lsuf)
6297             i.suffix = LONG_MNEM_SUFFIX;
6298           break;
6299         case CODE_16BIT:
6300           if (!i.tm.opcode_modifier.no_wsuf)
6301             i.suffix = WORD_MNEM_SUFFIX;
6302           break;
6303         }
6304     }
6305
6306   if (!i.suffix)
6307     {
6308       if (!intel_syntax)
6309         {
6310           if (i.tm.opcode_modifier.w)
6311             {
6312               as_bad (_("no instruction mnemonic suffix given and "
6313                         "no register operands; can't size instruction"));
6314               return 0;
6315             }
6316         }
6317       else
6318         {
6319           unsigned int suffixes;
6320
6321           suffixes = !i.tm.opcode_modifier.no_bsuf;
6322           if (!i.tm.opcode_modifier.no_wsuf)
6323             suffixes |= 1 << 1;
6324           if (!i.tm.opcode_modifier.no_lsuf)
6325             suffixes |= 1 << 2;
6326           if (!i.tm.opcode_modifier.no_ldsuf)
6327             suffixes |= 1 << 3;
6328           if (!i.tm.opcode_modifier.no_ssuf)
6329             suffixes |= 1 << 4;
6330           if (flag_code == CODE_64BIT && !i.tm.opcode_modifier.no_qsuf)
6331             suffixes |= 1 << 5;
6332
6333           /* There are more than suffix matches.  */
6334           if (i.tm.opcode_modifier.w
6335               || ((suffixes & (suffixes - 1))
6336                   && !i.tm.opcode_modifier.defaultsize
6337                   && !i.tm.opcode_modifier.ignoresize))
6338             {
6339               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
6340               return 0;
6341             }
6342         }
6343     }
6344
6345   /* Change the opcode based on the operand size given by i.suffix.  */
6346   switch (i.suffix)
6347     {
6348     /* Size floating point instruction.  */
6349     case LONG_MNEM_SUFFIX:
6350       if (i.tm.opcode_modifier.floatmf)
6351         {
6352           i.tm.base_opcode ^= 4;
6353           break;
6354         }
6355     /* fall through */
6356     case WORD_MNEM_SUFFIX:
6357     case QWORD_MNEM_SUFFIX:
6358       /* It's not a byte, select word/dword operation.  */
6359       if (i.tm.opcode_modifier.w)
6360         {
6361           if (i.tm.opcode_modifier.shortform)
6362             i.tm.base_opcode |= 8;
6363           else
6364             i.tm.base_opcode |= 1;
6365         }
6366     /* fall through */
6367     case SHORT_MNEM_SUFFIX:
6368       /* Now select between word & dword operations via the operand
6369          size prefix, except for instructions that will ignore this
6370          prefix anyway.  */
6371       if (i.reg_operands > 0
6372           && i.types[0].bitfield.reg
6373           && i.tm.opcode_modifier.addrprefixopreg
6374           && (i.tm.opcode_modifier.immext
6375               || i.operands == 1))
6376         {
6377           /* The address size override prefix changes the size of the
6378              first operand.  */
6379           if ((flag_code == CODE_32BIT
6380                && i.op[0].regs->reg_type.bitfield.word)
6381               || (flag_code != CODE_32BIT
6382                   && i.op[0].regs->reg_type.bitfield.dword))
6383             if (!add_prefix (ADDR_PREFIX_OPCODE))
6384               return 0;
6385         }
6386       else if (i.suffix != QWORD_MNEM_SUFFIX
6387                && !i.tm.opcode_modifier.ignoresize
6388                && !i.tm.opcode_modifier.floatmf
6389                && !i.tm.opcode_modifier.vex
6390                && !i.tm.opcode_modifier.vexopcode
6391                && !is_evex_encoding (&i.tm)
6392                && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
6393                    || (flag_code == CODE_64BIT
6394                        && i.tm.opcode_modifier.jumpbyte)))
6395         {
6396           unsigned int prefix = DATA_PREFIX_OPCODE;
6397
6398           if (i.tm.opcode_modifier.jumpbyte) /* jcxz, loop */
6399             prefix = ADDR_PREFIX_OPCODE;
6400
6401           if (!add_prefix (prefix))
6402             return 0;
6403         }
6404
6405       /* Set mode64 for an operand.  */
6406       if (i.suffix == QWORD_MNEM_SUFFIX
6407           && flag_code == CODE_64BIT
6408           && !i.tm.opcode_modifier.norex64
6409           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
6410              need rex64. */
6411           && ! (i.operands == 2
6412                 && i.tm.base_opcode == 0x90
6413                 && i.tm.extension_opcode == None
6414                 && operand_type_equal (&i.types [0], &acc64)
6415                 && operand_type_equal (&i.types [1], &acc64)))
6416         i.rex |= REX_W;
6417
6418       break;
6419     }
6420
6421   if (i.reg_operands != 0
6422       && i.operands > 1
6423       && i.tm.opcode_modifier.addrprefixopreg
6424       && !i.tm.opcode_modifier.immext)
6425     {
6426       /* Check invalid register operand when the address size override
6427          prefix changes the size of register operands.  */
6428       unsigned int op;
6429       enum { need_word, need_dword, need_qword } need;
6430
6431       if (flag_code == CODE_32BIT)
6432         need = i.prefix[ADDR_PREFIX] ? need_word : need_dword;
6433       else
6434         {
6435           if (i.prefix[ADDR_PREFIX])
6436             need = need_dword;
6437           else
6438             need = flag_code == CODE_64BIT ? need_qword : need_word;
6439         }
6440
6441       for (op = 0; op < i.operands; op++)
6442         if (i.types[op].bitfield.reg
6443             && ((need == need_word
6444                  && !i.op[op].regs->reg_type.bitfield.word)
6445                 || (need == need_dword
6446                     && !i.op[op].regs->reg_type.bitfield.dword)
6447                 || (need == need_qword
6448                     && !i.op[op].regs->reg_type.bitfield.qword)))
6449           {
6450             as_bad (_("invalid register operand size for `%s'"),
6451                     i.tm.name);
6452             return 0;
6453           }
6454     }
6455
6456   return 1;
6457 }
6458
6459 static int
6460 check_byte_reg (void)
6461 {
6462   int op;
6463
6464   for (op = i.operands; --op >= 0;)
6465     {
6466       /* Skip non-register operands. */
6467       if (!i.types[op].bitfield.reg)
6468         continue;
6469
6470       /* If this is an eight bit register, it's OK.  If it's the 16 or
6471          32 bit version of an eight bit register, we will just use the
6472          low portion, and that's OK too.  */
6473       if (i.types[op].bitfield.byte)
6474         continue;
6475
6476       /* I/O port address operands are OK too.  */
6477       if (i.tm.operand_types[op].bitfield.inoutportreg)
6478         continue;
6479
6480       /* crc32 doesn't generate this warning.  */
6481       if (i.tm.base_opcode == 0xf20f38f0)
6482         continue;
6483
6484       if ((i.types[op].bitfield.word
6485            || i.types[op].bitfield.dword
6486            || i.types[op].bitfield.qword)
6487           && i.op[op].regs->reg_num < 4
6488           /* Prohibit these changes in 64bit mode, since the lowering
6489              would be more complicated.  */
6490           && flag_code != CODE_64BIT)
6491         {
6492 #if REGISTER_WARNINGS
6493           if (!quiet_warnings)
6494             as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6495                      register_prefix,
6496                      (i.op[op].regs + (i.types[op].bitfield.word
6497                                        ? REGNAM_AL - REGNAM_AX
6498                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
6499                      register_prefix,
6500                      i.op[op].regs->reg_name,
6501                      i.suffix);
6502 #endif
6503           continue;
6504         }
6505       /* Any other register is bad.  */
6506       if (i.types[op].bitfield.reg
6507           || i.types[op].bitfield.regmmx
6508           || i.types[op].bitfield.regsimd
6509           || i.types[op].bitfield.sreg2
6510           || i.types[op].bitfield.sreg3
6511           || i.types[op].bitfield.control
6512           || i.types[op].bitfield.debug
6513           || i.types[op].bitfield.test)
6514         {
6515           as_bad (_("`%s%s' not allowed with `%s%c'"),
6516                   register_prefix,
6517                   i.op[op].regs->reg_name,
6518                   i.tm.name,
6519                   i.suffix);
6520           return 0;
6521         }
6522     }
6523   return 1;
6524 }
6525
6526 static int
6527 check_long_reg (void)
6528 {
6529   int op;
6530
6531   for (op = i.operands; --op >= 0;)
6532     /* Skip non-register operands. */
6533     if (!i.types[op].bitfield.reg)
6534       continue;
6535     /* Reject eight bit registers, except where the template requires
6536        them. (eg. movzb)  */
6537     else if (i.types[op].bitfield.byte
6538              && (i.tm.operand_types[op].bitfield.reg
6539                  || i.tm.operand_types[op].bitfield.acc)
6540              && (i.tm.operand_types[op].bitfield.word
6541                  || i.tm.operand_types[op].bitfield.dword))
6542       {
6543         as_bad (_("`%s%s' not allowed with `%s%c'"),
6544                 register_prefix,
6545                 i.op[op].regs->reg_name,
6546                 i.tm.name,
6547                 i.suffix);
6548         return 0;
6549       }
6550     /* Warn if the e prefix on a general reg is missing.  */
6551     else if ((!quiet_warnings || flag_code == CODE_64BIT)
6552              && i.types[op].bitfield.word
6553              && (i.tm.operand_types[op].bitfield.reg
6554                  || i.tm.operand_types[op].bitfield.acc)
6555              && i.tm.operand_types[op].bitfield.dword)
6556       {
6557         /* Prohibit these changes in the 64bit mode, since the
6558            lowering is more complicated.  */
6559         if (flag_code == CODE_64BIT)
6560           {
6561             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6562                     register_prefix, i.op[op].regs->reg_name,
6563                     i.suffix);
6564             return 0;
6565           }
6566 #if REGISTER_WARNINGS
6567         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6568                  register_prefix,
6569                  (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
6570                  register_prefix, i.op[op].regs->reg_name, i.suffix);
6571 #endif
6572       }
6573     /* Warn if the r prefix on a general reg is present.  */
6574     else if (i.types[op].bitfield.qword
6575              && (i.tm.operand_types[op].bitfield.reg
6576                  || i.tm.operand_types[op].bitfield.acc)
6577              && i.tm.operand_types[op].bitfield.dword)
6578       {
6579         if (intel_syntax
6580             && i.tm.opcode_modifier.toqword
6581             && !i.types[0].bitfield.regsimd)
6582           {
6583             /* Convert to QWORD.  We want REX byte. */
6584             i.suffix = QWORD_MNEM_SUFFIX;
6585           }
6586         else
6587           {
6588             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6589                     register_prefix, i.op[op].regs->reg_name,
6590                     i.suffix);
6591             return 0;
6592           }
6593       }
6594   return 1;
6595 }
6596
6597 static int
6598 check_qword_reg (void)
6599 {
6600   int op;
6601
6602   for (op = i.operands; --op >= 0; )
6603     /* Skip non-register operands. */
6604     if (!i.types[op].bitfield.reg)
6605       continue;
6606     /* Reject eight bit registers, except where the template requires
6607        them. (eg. movzb)  */
6608     else if (i.types[op].bitfield.byte
6609              && (i.tm.operand_types[op].bitfield.reg
6610                  || i.tm.operand_types[op].bitfield.acc)
6611              && (i.tm.operand_types[op].bitfield.word
6612                  || i.tm.operand_types[op].bitfield.dword))
6613       {
6614         as_bad (_("`%s%s' not allowed with `%s%c'"),
6615                 register_prefix,
6616                 i.op[op].regs->reg_name,
6617                 i.tm.name,
6618                 i.suffix);
6619         return 0;
6620       }
6621     /* Warn if the r prefix on a general reg is missing.  */
6622     else if ((i.types[op].bitfield.word
6623               || i.types[op].bitfield.dword)
6624              && (i.tm.operand_types[op].bitfield.reg
6625                  || i.tm.operand_types[op].bitfield.acc)
6626              && i.tm.operand_types[op].bitfield.qword)
6627       {
6628         /* Prohibit these changes in the 64bit mode, since the
6629            lowering is more complicated.  */
6630         if (intel_syntax
6631             && i.tm.opcode_modifier.todword
6632             && !i.types[0].bitfield.regsimd)
6633           {
6634             /* Convert to DWORD.  We don't want REX byte. */
6635             i.suffix = LONG_MNEM_SUFFIX;
6636           }
6637         else
6638           {
6639             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6640                     register_prefix, i.op[op].regs->reg_name,
6641                     i.suffix);
6642             return 0;
6643           }
6644       }
6645   return 1;
6646 }
6647
6648 static int
6649 check_word_reg (void)
6650 {
6651   int op;
6652   for (op = i.operands; --op >= 0;)
6653     /* Skip non-register operands. */
6654     if (!i.types[op].bitfield.reg)
6655       continue;
6656     /* Reject eight bit registers, except where the template requires
6657        them. (eg. movzb)  */
6658     else if (i.types[op].bitfield.byte
6659              && (i.tm.operand_types[op].bitfield.reg
6660                  || i.tm.operand_types[op].bitfield.acc)
6661              && (i.tm.operand_types[op].bitfield.word
6662                  || i.tm.operand_types[op].bitfield.dword))
6663       {
6664         as_bad (_("`%s%s' not allowed with `%s%c'"),
6665                 register_prefix,
6666                 i.op[op].regs->reg_name,
6667                 i.tm.name,
6668                 i.suffix);
6669         return 0;
6670       }
6671     /* Warn if the e or r prefix on a general reg is present.  */
6672     else if ((!quiet_warnings || flag_code == CODE_64BIT)
6673              && (i.types[op].bitfield.dword
6674                  || i.types[op].bitfield.qword)
6675              && (i.tm.operand_types[op].bitfield.reg
6676                  || i.tm.operand_types[op].bitfield.acc)
6677              && i.tm.operand_types[op].bitfield.word)
6678       {
6679         /* Prohibit these changes in the 64bit mode, since the
6680            lowering is more complicated.  */
6681         if (flag_code == CODE_64BIT)
6682           {
6683             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6684                     register_prefix, i.op[op].regs->reg_name,
6685                     i.suffix);
6686             return 0;
6687           }
6688 #if REGISTER_WARNINGS
6689         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6690                  register_prefix,
6691                  (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
6692                  register_prefix, i.op[op].regs->reg_name, i.suffix);
6693 #endif
6694       }
6695   return 1;
6696 }
6697
6698 static int
6699 update_imm (unsigned int j)
6700 {
6701   i386_operand_type overlap = i.types[j];
6702   if ((overlap.bitfield.imm8
6703        || overlap.bitfield.imm8s
6704        || overlap.bitfield.imm16
6705        || overlap.bitfield.imm32
6706        || overlap.bitfield.imm32s
6707        || overlap.bitfield.imm64)
6708       && !operand_type_equal (&overlap, &imm8)
6709       && !operand_type_equal (&overlap, &imm8s)
6710       && !operand_type_equal (&overlap, &imm16)
6711       && !operand_type_equal (&overlap, &imm32)
6712       && !operand_type_equal (&overlap, &imm32s)
6713       && !operand_type_equal (&overlap, &imm64))
6714     {
6715       if (i.suffix)
6716         {
6717           i386_operand_type temp;
6718
6719           operand_type_set (&temp, 0);
6720           if (i.suffix == BYTE_MNEM_SUFFIX)
6721             {
6722               temp.bitfield.imm8 = overlap.bitfield.imm8;
6723               temp.bitfield.imm8s = overlap.bitfield.imm8s;
6724             }
6725           else if (i.suffix == WORD_MNEM_SUFFIX)
6726             temp.bitfield.imm16 = overlap.bitfield.imm16;
6727           else if (i.suffix == QWORD_MNEM_SUFFIX)
6728             {
6729               temp.bitfield.imm64 = overlap.bitfield.imm64;
6730               temp.bitfield.imm32s = overlap.bitfield.imm32s;
6731             }
6732           else
6733             temp.bitfield.imm32 = overlap.bitfield.imm32;
6734           overlap = temp;
6735         }
6736       else if (operand_type_equal (&overlap, &imm16_32_32s)
6737                || operand_type_equal (&overlap, &imm16_32)
6738                || operand_type_equal (&overlap, &imm16_32s))
6739         {
6740           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
6741             overlap = imm16;
6742           else
6743             overlap = imm32s;
6744         }
6745       if (!operand_type_equal (&overlap, &imm8)
6746           && !operand_type_equal (&overlap, &imm8s)
6747           && !operand_type_equal (&overlap, &imm16)
6748           && !operand_type_equal (&overlap, &imm32)
6749           && !operand_type_equal (&overlap, &imm32s)
6750           && !operand_type_equal (&overlap, &imm64))
6751         {
6752           as_bad (_("no instruction mnemonic suffix given; "
6753                     "can't determine immediate size"));
6754           return 0;
6755         }
6756     }
6757   i.types[j] = overlap;
6758
6759   return 1;
6760 }
6761
6762 static int
6763 finalize_imm (void)
6764 {
6765   unsigned int j, n;
6766
6767   /* Update the first 2 immediate operands.  */
6768   n = i.operands > 2 ? 2 : i.operands;
6769   if (n)
6770     {
6771       for (j = 0; j < n; j++)
6772         if (update_imm (j) == 0)
6773           return 0;
6774
6775       /* The 3rd operand can't be immediate operand.  */
6776       gas_assert (operand_type_check (i.types[2], imm) == 0);
6777     }
6778
6779   return 1;
6780 }
6781
6782 static int
6783 process_operands (void)
6784 {
6785   /* Default segment register this instruction will use for memory
6786      accesses.  0 means unknown.  This is only for optimizing out
6787      unnecessary segment overrides.  */
6788   const seg_entry *default_seg = 0;
6789
6790   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
6791     {
6792       unsigned int dupl = i.operands;
6793       unsigned int dest = dupl - 1;
6794       unsigned int j;
6795
6796       /* The destination must be an xmm register.  */
6797       gas_assert (i.reg_operands
6798                   && MAX_OPERANDS > dupl
6799                   && operand_type_equal (&i.types[dest], &regxmm));
6800
6801       if (i.tm.operand_types[0].bitfield.acc
6802           && i.tm.operand_types[0].bitfield.xmmword)
6803         {
6804           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
6805             {
6806               /* Keep xmm0 for instructions with VEX prefix and 3
6807                  sources.  */
6808               i.tm.operand_types[0].bitfield.acc = 0;
6809               i.tm.operand_types[0].bitfield.regsimd = 1;
6810               goto duplicate;
6811             }
6812           else
6813             {
6814               /* We remove the first xmm0 and keep the number of
6815                  operands unchanged, which in fact duplicates the
6816                  destination.  */
6817               for (j = 1; j < i.operands; j++)
6818                 {
6819                   i.op[j - 1] = i.op[j];
6820                   i.types[j - 1] = i.types[j];
6821                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
6822                 }
6823             }
6824         }
6825       else if (i.tm.opcode_modifier.implicit1stxmm0)
6826         {
6827           gas_assert ((MAX_OPERANDS - 1) > dupl
6828                       && (i.tm.opcode_modifier.vexsources
6829                           == VEX3SOURCES));
6830
6831           /* Add the implicit xmm0 for instructions with VEX prefix
6832              and 3 sources.  */
6833           for (j = i.operands; j > 0; j--)
6834             {
6835               i.op[j] = i.op[j - 1];
6836               i.types[j] = i.types[j - 1];
6837               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
6838             }
6839           i.op[0].regs
6840             = (const reg_entry *) hash_find (reg_hash, "xmm0");
6841           i.types[0] = regxmm;
6842           i.tm.operand_types[0] = regxmm;
6843
6844           i.operands += 2;
6845           i.reg_operands += 2;
6846           i.tm.operands += 2;
6847
6848           dupl++;
6849           dest++;
6850           i.op[dupl] = i.op[dest];
6851           i.types[dupl] = i.types[dest];
6852           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6853         }
6854       else
6855         {
6856 duplicate:
6857           i.operands++;
6858           i.reg_operands++;
6859           i.tm.operands++;
6860
6861           i.op[dupl] = i.op[dest];
6862           i.types[dupl] = i.types[dest];
6863           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6864         }
6865
6866        if (i.tm.opcode_modifier.immext)
6867          process_immext ();
6868     }
6869   else if (i.tm.operand_types[0].bitfield.acc
6870            && i.tm.operand_types[0].bitfield.xmmword)
6871     {
6872       unsigned int j;
6873
6874       for (j = 1; j < i.operands; j++)
6875         {
6876           i.op[j - 1] = i.op[j];
6877           i.types[j - 1] = i.types[j];
6878
6879           /* We need to adjust fields in i.tm since they are used by
6880              build_modrm_byte.  */
6881           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
6882         }
6883
6884       i.operands--;
6885       i.reg_operands--;
6886       i.tm.operands--;
6887     }
6888   else if (i.tm.opcode_modifier.implicitquadgroup)
6889     {
6890       unsigned int regnum, first_reg_in_group, last_reg_in_group;
6891
6892       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
6893       gas_assert (i.operands >= 2 && i.types[1].bitfield.regsimd);
6894       regnum = register_number (i.op[1].regs);
6895       first_reg_in_group = regnum & ~3;
6896       last_reg_in_group = first_reg_in_group + 3;
6897       if (regnum != first_reg_in_group)
6898         as_warn (_("source register `%s%s' implicitly denotes"
6899                    " `%s%.3s%u' to `%s%.3s%u' source group in `%s'"),
6900                  register_prefix, i.op[1].regs->reg_name,
6901                  register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
6902                  register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
6903                  i.tm.name);
6904     }
6905   else if (i.tm.opcode_modifier.regkludge)
6906     {
6907       /* The imul $imm, %reg instruction is converted into
6908          imul $imm, %reg, %reg, and the clr %reg instruction
6909          is converted into xor %reg, %reg.  */
6910
6911       unsigned int first_reg_op;
6912
6913       if (operand_type_check (i.types[0], reg))
6914         first_reg_op = 0;
6915       else
6916         first_reg_op = 1;
6917       /* Pretend we saw the extra register operand.  */
6918       gas_assert (i.reg_operands == 1
6919                   && i.op[first_reg_op + 1].regs == 0);
6920       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
6921       i.types[first_reg_op + 1] = i.types[first_reg_op];
6922       i.operands++;
6923       i.reg_operands++;
6924     }
6925
6926   if (i.tm.opcode_modifier.shortform)
6927     {
6928       if (i.types[0].bitfield.sreg2
6929           || i.types[0].bitfield.sreg3)
6930         {
6931           if (i.tm.base_opcode == POP_SEG_SHORT
6932               && i.op[0].regs->reg_num == 1)
6933             {
6934               as_bad (_("you can't `pop %scs'"), register_prefix);
6935               return 0;
6936             }
6937           i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
6938           if ((i.op[0].regs->reg_flags & RegRex) != 0)
6939             i.rex |= REX_B;
6940         }
6941       else
6942         {
6943           /* The register or float register operand is in operand
6944              0 or 1.  */
6945           unsigned int op;
6946
6947           if ((i.types[0].bitfield.reg && i.types[0].bitfield.tbyte)
6948               || operand_type_check (i.types[0], reg))
6949             op = 0;
6950           else
6951             op = 1;
6952           /* Register goes in low 3 bits of opcode.  */
6953           i.tm.base_opcode |= i.op[op].regs->reg_num;
6954           if ((i.op[op].regs->reg_flags & RegRex) != 0)
6955             i.rex |= REX_B;
6956           if (!quiet_warnings && i.tm.opcode_modifier.ugh)
6957             {
6958               /* Warn about some common errors, but press on regardless.
6959                  The first case can be generated by gcc (<= 2.8.1).  */
6960               if (i.operands == 2)
6961                 {
6962                   /* Reversed arguments on faddp, fsubp, etc.  */
6963                   as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
6964                            register_prefix, i.op[!intel_syntax].regs->reg_name,
6965                            register_prefix, i.op[intel_syntax].regs->reg_name);
6966                 }
6967               else
6968                 {
6969                   /* Extraneous `l' suffix on fp insn.  */
6970                   as_warn (_("translating to `%s %s%s'"), i.tm.name,
6971                            register_prefix, i.op[0].regs->reg_name);
6972                 }
6973             }
6974         }
6975     }
6976   else if (i.tm.opcode_modifier.modrm)
6977     {
6978       /* The opcode is completed (modulo i.tm.extension_opcode which
6979          must be put into the modrm byte).  Now, we make the modrm and
6980          index base bytes based on all the info we've collected.  */
6981
6982       default_seg = build_modrm_byte ();
6983     }
6984   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
6985     {
6986       default_seg = &ds;
6987     }
6988   else if (i.tm.opcode_modifier.isstring)
6989     {
6990       /* For the string instructions that allow a segment override
6991          on one of their operands, the default segment is ds.  */
6992       default_seg = &ds;
6993     }
6994
6995   if (i.tm.base_opcode == 0x8d /* lea */
6996       && i.seg[0]
6997       && !quiet_warnings)
6998     as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
6999
7000   /* If a segment was explicitly specified, and the specified segment
7001      is not the default, use an opcode prefix to select it.  If we
7002      never figured out what the default segment is, then default_seg
7003      will be zero at this point, and the specified segment prefix will
7004      always be used.  */
7005   if ((i.seg[0]) && (i.seg[0] != default_seg))
7006     {
7007       if (!add_prefix (i.seg[0]->seg_prefix))
7008         return 0;
7009     }
7010   return 1;
7011 }
7012
7013 static const seg_entry *
7014 build_modrm_byte (void)
7015 {
7016   const seg_entry *default_seg = 0;
7017   unsigned int source, dest;
7018   int vex_3_sources;
7019
7020   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
7021   if (vex_3_sources)
7022     {
7023       unsigned int nds, reg_slot;
7024       expressionS *exp;
7025
7026       dest = i.operands - 1;
7027       nds = dest - 1;
7028
7029       /* There are 2 kinds of instructions:
7030          1. 5 operands: 4 register operands or 3 register operands
7031          plus 1 memory operand plus one Vec_Imm4 operand, VexXDS, and
7032          VexW0 or VexW1.  The destination must be either XMM, YMM or
7033          ZMM register.
7034          2. 4 operands: 4 register operands or 3 register operands
7035          plus 1 memory operand, with VexXDS.  */
7036       gas_assert ((i.reg_operands == 4
7037                    || (i.reg_operands == 3 && i.mem_operands == 1))
7038                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
7039                   && i.tm.opcode_modifier.vexw
7040                   && i.tm.operand_types[dest].bitfield.regsimd);
7041
7042       /* If VexW1 is set, the first non-immediate operand is the source and
7043          the second non-immediate one is encoded in the immediate operand.  */
7044       if (i.tm.opcode_modifier.vexw == VEXW1)
7045         {
7046           source = i.imm_operands;
7047           reg_slot = i.imm_operands + 1;
7048         }
7049       else
7050         {
7051           source = i.imm_operands + 1;
7052           reg_slot = i.imm_operands;
7053         }
7054
7055       if (i.imm_operands == 0)
7056         {
7057           /* When there is no immediate operand, generate an 8bit
7058              immediate operand to encode the first operand.  */
7059           exp = &im_expressions[i.imm_operands++];
7060           i.op[i.operands].imms = exp;
7061           i.types[i.operands] = imm8;
7062           i.operands++;
7063
7064           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
7065           exp->X_op = O_constant;
7066           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
7067           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7068         }
7069       else
7070         {
7071           unsigned int imm_slot;
7072
7073           gas_assert (i.imm_operands == 1 && i.types[0].bitfield.vec_imm4);
7074
7075           if (i.tm.opcode_modifier.immext)
7076             {
7077               /* When ImmExt is set, the immediate byte is the last
7078                  operand.  */
7079               imm_slot = i.operands - 1;
7080               source--;
7081               reg_slot--;
7082             }
7083           else
7084             {
7085               imm_slot = 0;
7086
7087               /* Turn on Imm8 so that output_imm will generate it.  */
7088               i.types[imm_slot].bitfield.imm8 = 1;
7089             }
7090
7091           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
7092           i.op[imm_slot].imms->X_add_number
7093               |= register_number (i.op[reg_slot].regs) << 4;
7094           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7095         }
7096
7097       gas_assert (i.tm.operand_types[nds].bitfield.regsimd);
7098       i.vex.register_specifier = i.op[nds].regs;
7099     }
7100   else
7101     source = dest = 0;
7102
7103   /* i.reg_operands MUST be the number of real register operands;
7104      implicit registers do not count.  If there are 3 register
7105      operands, it must be a instruction with VexNDS.  For a
7106      instruction with VexNDD, the destination register is encoded
7107      in VEX prefix.  If there are 4 register operands, it must be
7108      a instruction with VEX prefix and 3 sources.  */
7109   if (i.mem_operands == 0
7110       && ((i.reg_operands == 2
7111            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
7112           || (i.reg_operands == 3
7113               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
7114           || (i.reg_operands == 4 && vex_3_sources)))
7115     {
7116       switch (i.operands)
7117         {
7118         case 2:
7119           source = 0;
7120           break;
7121         case 3:
7122           /* When there are 3 operands, one of them may be immediate,
7123              which may be the first or the last operand.  Otherwise,
7124              the first operand must be shift count register (cl) or it
7125              is an instruction with VexNDS. */
7126           gas_assert (i.imm_operands == 1
7127                       || (i.imm_operands == 0
7128                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
7129                               || i.types[0].bitfield.shiftcount)));
7130           if (operand_type_check (i.types[0], imm)
7131               || i.types[0].bitfield.shiftcount)
7132             source = 1;
7133           else
7134             source = 0;
7135           break;
7136         case 4:
7137           /* When there are 4 operands, the first two must be 8bit
7138              immediate operands. The source operand will be the 3rd
7139              one.
7140
7141              For instructions with VexNDS, if the first operand
7142              an imm8, the source operand is the 2nd one.  If the last
7143              operand is imm8, the source operand is the first one.  */
7144           gas_assert ((i.imm_operands == 2
7145                        && i.types[0].bitfield.imm8
7146                        && i.types[1].bitfield.imm8)
7147                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
7148                           && i.imm_operands == 1
7149                           && (i.types[0].bitfield.imm8
7150                               || i.types[i.operands - 1].bitfield.imm8
7151                               || i.rounding)));
7152           if (i.imm_operands == 2)
7153             source = 2;
7154           else
7155             {
7156               if (i.types[0].bitfield.imm8)
7157                 source = 1;
7158               else
7159                 source = 0;
7160             }
7161           break;
7162         case 5:
7163           if (is_evex_encoding (&i.tm))
7164             {
7165               /* For EVEX instructions, when there are 5 operands, the
7166                  first one must be immediate operand.  If the second one
7167                  is immediate operand, the source operand is the 3th
7168                  one.  If the last one is immediate operand, the source
7169                  operand is the 2nd one.  */
7170               gas_assert (i.imm_operands == 2
7171                           && i.tm.opcode_modifier.sae
7172                           && operand_type_check (i.types[0], imm));
7173               if (operand_type_check (i.types[1], imm))
7174                 source = 2;
7175               else if (operand_type_check (i.types[4], imm))
7176                 source = 1;
7177               else
7178                 abort ();
7179             }
7180           break;
7181         default:
7182           abort ();
7183         }
7184
7185       if (!vex_3_sources)
7186         {
7187           dest = source + 1;
7188
7189           /* RC/SAE operand could be between DEST and SRC.  That happens
7190              when one operand is GPR and the other one is XMM/YMM/ZMM
7191              register.  */
7192           if (i.rounding && i.rounding->operand == (int) dest)
7193             dest++;
7194
7195           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7196             {
7197               /* For instructions with VexNDS, the register-only source
7198                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
7199                  register.  It is encoded in VEX prefix.  We need to
7200                  clear RegMem bit before calling operand_type_equal.  */
7201
7202               i386_operand_type op;
7203               unsigned int vvvv;
7204
7205               /* Check register-only source operand when two source
7206                  operands are swapped.  */
7207               if (!i.tm.operand_types[source].bitfield.baseindex
7208                   && i.tm.operand_types[dest].bitfield.baseindex)
7209                 {
7210                   vvvv = source;
7211                   source = dest;
7212                 }
7213               else
7214                 vvvv = dest;
7215
7216               op = i.tm.operand_types[vvvv];
7217               op.bitfield.regmem = 0;
7218               if ((dest + 1) >= i.operands
7219                   || ((!op.bitfield.reg
7220                        || (!op.bitfield.dword && !op.bitfield.qword))
7221                       && !op.bitfield.regsimd
7222                       && !operand_type_equal (&op, &regmask)))
7223                 abort ();
7224               i.vex.register_specifier = i.op[vvvv].regs;
7225               dest++;
7226             }
7227         }
7228
7229       i.rm.mode = 3;
7230       /* One of the register operands will be encoded in the i.tm.reg
7231          field, the other in the combined i.tm.mode and i.tm.regmem
7232          fields.  If no form of this instruction supports a memory
7233          destination operand, then we assume the source operand may
7234          sometimes be a memory operand and so we need to store the
7235          destination in the i.rm.reg field.  */
7236       if (!i.tm.operand_types[dest].bitfield.regmem
7237           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
7238         {
7239           i.rm.reg = i.op[dest].regs->reg_num;
7240           i.rm.regmem = i.op[source].regs->reg_num;
7241           if (i.op[dest].regs->reg_type.bitfield.regmmx
7242                || i.op[source].regs->reg_type.bitfield.regmmx)
7243             i.has_regmmx = TRUE;
7244           else if (i.op[dest].regs->reg_type.bitfield.regsimd
7245                    || i.op[source].regs->reg_type.bitfield.regsimd)
7246             {
7247               if (i.types[dest].bitfield.zmmword
7248                   || i.types[source].bitfield.zmmword)
7249                 i.has_regzmm = TRUE;
7250               else if (i.types[dest].bitfield.ymmword
7251                        || i.types[source].bitfield.ymmword)
7252                 i.has_regymm = TRUE;
7253               else
7254                 i.has_regxmm = TRUE;
7255             }
7256           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
7257             i.rex |= REX_R;
7258           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
7259             i.vrex |= REX_R;
7260           if ((i.op[source].regs->reg_flags & RegRex) != 0)
7261             i.rex |= REX_B;
7262           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
7263             i.vrex |= REX_B;
7264         }
7265       else
7266         {
7267           i.rm.reg = i.op[source].regs->reg_num;
7268           i.rm.regmem = i.op[dest].regs->reg_num;
7269           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
7270             i.rex |= REX_B;
7271           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
7272             i.vrex |= REX_B;
7273           if ((i.op[source].regs->reg_flags & RegRex) != 0)
7274             i.rex |= REX_R;
7275           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
7276             i.vrex |= REX_R;
7277         }
7278       if (flag_code != CODE_64BIT && (i.rex & REX_R))
7279         {
7280           if (!i.types[i.tm.operand_types[0].bitfield.regmem].bitfield.control)
7281             abort ();
7282           i.rex &= ~REX_R;
7283           add_prefix (LOCK_PREFIX_OPCODE);
7284         }
7285     }
7286   else
7287     {                   /* If it's not 2 reg operands...  */
7288       unsigned int mem;
7289
7290       if (i.mem_operands)
7291         {
7292           unsigned int fake_zero_displacement = 0;
7293           unsigned int op;
7294
7295           for (op = 0; op < i.operands; op++)
7296             if (operand_type_check (i.types[op], anymem))
7297               break;
7298           gas_assert (op < i.operands);
7299
7300           if (i.tm.opcode_modifier.vecsib)
7301             {
7302               if (i.index_reg->reg_num == RegIZ)
7303                 abort ();
7304
7305               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7306               if (!i.base_reg)
7307                 {
7308                   i.sib.base = NO_BASE_REGISTER;
7309                   i.sib.scale = i.log2_scale_factor;
7310                   i.types[op].bitfield.disp8 = 0;
7311                   i.types[op].bitfield.disp16 = 0;
7312                   i.types[op].bitfield.disp64 = 0;
7313                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
7314                     {
7315                       /* Must be 32 bit */
7316                       i.types[op].bitfield.disp32 = 1;
7317                       i.types[op].bitfield.disp32s = 0;
7318                     }
7319                   else
7320                     {
7321                       i.types[op].bitfield.disp32 = 0;
7322                       i.types[op].bitfield.disp32s = 1;
7323                     }
7324                 }
7325               i.sib.index = i.index_reg->reg_num;
7326               if ((i.index_reg->reg_flags & RegRex) != 0)
7327                 i.rex |= REX_X;
7328               if ((i.index_reg->reg_flags & RegVRex) != 0)
7329                 i.vrex |= REX_X;
7330             }
7331
7332           default_seg = &ds;
7333
7334           if (i.base_reg == 0)
7335             {
7336               i.rm.mode = 0;
7337               if (!i.disp_operands)
7338                 fake_zero_displacement = 1;
7339               if (i.index_reg == 0)
7340                 {
7341                   i386_operand_type newdisp;
7342
7343                   gas_assert (!i.tm.opcode_modifier.vecsib);
7344                   /* Operand is just <disp>  */
7345                   if (flag_code == CODE_64BIT)
7346                     {
7347                       /* 64bit mode overwrites the 32bit absolute
7348                          addressing by RIP relative addressing and
7349                          absolute addressing is encoded by one of the
7350                          redundant SIB forms.  */
7351                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7352                       i.sib.base = NO_BASE_REGISTER;
7353                       i.sib.index = NO_INDEX_REGISTER;
7354                       newdisp = (!i.prefix[ADDR_PREFIX] ? disp32s : disp32);
7355                     }
7356                   else if ((flag_code == CODE_16BIT)
7357                            ^ (i.prefix[ADDR_PREFIX] != 0))
7358                     {
7359                       i.rm.regmem = NO_BASE_REGISTER_16;
7360                       newdisp = disp16;
7361                     }
7362                   else
7363                     {
7364                       i.rm.regmem = NO_BASE_REGISTER;
7365                       newdisp = disp32;
7366                     }
7367                   i.types[op] = operand_type_and_not (i.types[op], anydisp);
7368                   i.types[op] = operand_type_or (i.types[op], newdisp);
7369                 }
7370               else if (!i.tm.opcode_modifier.vecsib)
7371                 {
7372                   /* !i.base_reg && i.index_reg  */
7373                   if (i.index_reg->reg_num == RegIZ)
7374                     i.sib.index = NO_INDEX_REGISTER;
7375                   else
7376                     i.sib.index = i.index_reg->reg_num;
7377                   i.sib.base = NO_BASE_REGISTER;
7378                   i.sib.scale = i.log2_scale_factor;
7379                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7380                   i.types[op].bitfield.disp8 = 0;
7381                   i.types[op].bitfield.disp16 = 0;
7382                   i.types[op].bitfield.disp64 = 0;
7383                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
7384                     {
7385                       /* Must be 32 bit */
7386                       i.types[op].bitfield.disp32 = 1;
7387                       i.types[op].bitfield.disp32s = 0;
7388                     }
7389                   else
7390                     {
7391                       i.types[op].bitfield.disp32 = 0;
7392                       i.types[op].bitfield.disp32s = 1;
7393                     }
7394                   if ((i.index_reg->reg_flags & RegRex) != 0)
7395                     i.rex |= REX_X;
7396                 }
7397             }
7398           /* RIP addressing for 64bit mode.  */
7399           else if (i.base_reg->reg_num == RegIP)
7400             {
7401               gas_assert (!i.tm.opcode_modifier.vecsib);
7402               i.rm.regmem = NO_BASE_REGISTER;
7403               i.types[op].bitfield.disp8 = 0;
7404               i.types[op].bitfield.disp16 = 0;
7405               i.types[op].bitfield.disp32 = 0;
7406               i.types[op].bitfield.disp32s = 1;
7407               i.types[op].bitfield.disp64 = 0;
7408               i.flags[op] |= Operand_PCrel;
7409               if (! i.disp_operands)
7410                 fake_zero_displacement = 1;
7411             }
7412           else if (i.base_reg->reg_type.bitfield.word)
7413             {
7414               gas_assert (!i.tm.opcode_modifier.vecsib);
7415               switch (i.base_reg->reg_num)
7416                 {
7417                 case 3: /* (%bx)  */
7418                   if (i.index_reg == 0)
7419                     i.rm.regmem = 7;
7420                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
7421                     i.rm.regmem = i.index_reg->reg_num - 6;
7422                   break;
7423                 case 5: /* (%bp)  */
7424                   default_seg = &ss;
7425                   if (i.index_reg == 0)
7426                     {
7427                       i.rm.regmem = 6;
7428                       if (operand_type_check (i.types[op], disp) == 0)
7429                         {
7430                           /* fake (%bp) into 0(%bp)  */
7431                           i.types[op].bitfield.disp8 = 1;
7432                           fake_zero_displacement = 1;
7433                         }
7434                     }
7435                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
7436                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
7437                   break;
7438                 default: /* (%si) -> 4 or (%di) -> 5  */
7439                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
7440                 }
7441               i.rm.mode = mode_from_disp_size (i.types[op]);
7442             }
7443           else /* i.base_reg and 32/64 bit mode  */
7444             {
7445               if (flag_code == CODE_64BIT
7446                   && operand_type_check (i.types[op], disp))
7447                 {
7448                   i.types[op].bitfield.disp16 = 0;
7449                   i.types[op].bitfield.disp64 = 0;
7450                   if (i.prefix[ADDR_PREFIX] == 0)
7451                     {
7452                       i.types[op].bitfield.disp32 = 0;
7453                       i.types[op].bitfield.disp32s = 1;
7454                     }
7455                   else
7456                     {
7457                       i.types[op].bitfield.disp32 = 1;
7458                       i.types[op].bitfield.disp32s = 0;
7459                     }
7460                 }
7461
7462               if (!i.tm.opcode_modifier.vecsib)
7463                 i.rm.regmem = i.base_reg->reg_num;
7464               if ((i.base_reg->reg_flags & RegRex) != 0)
7465                 i.rex |= REX_B;
7466               i.sib.base = i.base_reg->reg_num;
7467               /* x86-64 ignores REX prefix bit here to avoid decoder
7468                  complications.  */
7469               if (!(i.base_reg->reg_flags & RegRex)
7470                   && (i.base_reg->reg_num == EBP_REG_NUM
7471                    || i.base_reg->reg_num == ESP_REG_NUM))
7472                   default_seg = &ss;
7473               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
7474                 {
7475                   fake_zero_displacement = 1;
7476                   i.types[op].bitfield.disp8 = 1;
7477                 }
7478               i.sib.scale = i.log2_scale_factor;
7479               if (i.index_reg == 0)
7480                 {
7481                   gas_assert (!i.tm.opcode_modifier.vecsib);
7482                   /* <disp>(%esp) becomes two byte modrm with no index
7483                      register.  We've already stored the code for esp
7484                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
7485                      Any base register besides %esp will not use the
7486                      extra modrm byte.  */
7487                   i.sib.index = NO_INDEX_REGISTER;
7488                 }
7489               else if (!i.tm.opcode_modifier.vecsib)
7490                 {
7491                   if (i.index_reg->reg_num == RegIZ)
7492                     i.sib.index = NO_INDEX_REGISTER;
7493                   else
7494                     i.sib.index = i.index_reg->reg_num;
7495                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7496                   if ((i.index_reg->reg_flags & RegRex) != 0)
7497                     i.rex |= REX_X;
7498                 }
7499
7500               if (i.disp_operands
7501                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
7502                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
7503                 i.rm.mode = 0;
7504               else
7505                 {
7506                   if (!fake_zero_displacement
7507                       && !i.disp_operands
7508                       && i.disp_encoding)
7509                     {
7510                       fake_zero_displacement = 1;
7511                       if (i.disp_encoding == disp_encoding_8bit)
7512                         i.types[op].bitfield.disp8 = 1;
7513                       else
7514                         i.types[op].bitfield.disp32 = 1;
7515                     }
7516                   i.rm.mode = mode_from_disp_size (i.types[op]);
7517                 }
7518             }
7519
7520           if (fake_zero_displacement)
7521             {
7522               /* Fakes a zero displacement assuming that i.types[op]
7523                  holds the correct displacement size.  */
7524               expressionS *exp;
7525
7526               gas_assert (i.op[op].disps == 0);
7527               exp = &disp_expressions[i.disp_operands++];
7528               i.op[op].disps = exp;
7529               exp->X_op = O_constant;
7530               exp->X_add_number = 0;
7531               exp->X_add_symbol = (symbolS *) 0;
7532               exp->X_op_symbol = (symbolS *) 0;
7533             }
7534
7535           mem = op;
7536         }
7537       else
7538         mem = ~0;
7539
7540       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
7541         {
7542           if (operand_type_check (i.types[0], imm))
7543             i.vex.register_specifier = NULL;
7544           else
7545             {
7546               /* VEX.vvvv encodes one of the sources when the first
7547                  operand is not an immediate.  */
7548               if (i.tm.opcode_modifier.vexw == VEXW0)
7549                 i.vex.register_specifier = i.op[0].regs;
7550               else
7551                 i.vex.register_specifier = i.op[1].regs;
7552             }
7553
7554           /* Destination is a XMM register encoded in the ModRM.reg
7555              and VEX.R bit.  */
7556           i.rm.reg = i.op[2].regs->reg_num;
7557           if ((i.op[2].regs->reg_flags & RegRex) != 0)
7558             i.rex |= REX_R;
7559
7560           /* ModRM.rm and VEX.B encodes the other source.  */
7561           if (!i.mem_operands)
7562             {
7563               i.rm.mode = 3;
7564
7565               if (i.tm.opcode_modifier.vexw == VEXW0)
7566                 i.rm.regmem = i.op[1].regs->reg_num;
7567               else
7568                 i.rm.regmem = i.op[0].regs->reg_num;
7569
7570               if ((i.op[1].regs->reg_flags & RegRex) != 0)
7571                 i.rex |= REX_B;
7572             }
7573         }
7574       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
7575         {
7576           i.vex.register_specifier = i.op[2].regs;
7577           if (!i.mem_operands)
7578             {
7579               i.rm.mode = 3;
7580               i.rm.regmem = i.op[1].regs->reg_num;
7581               if ((i.op[1].regs->reg_flags & RegRex) != 0)
7582                 i.rex |= REX_B;
7583             }
7584         }
7585       /* Fill in i.rm.reg or i.rm.regmem field with register operand
7586          (if any) based on i.tm.extension_opcode.  Again, we must be
7587          careful to make sure that segment/control/debug/test/MMX
7588          registers are coded into the i.rm.reg field.  */
7589       else if (i.reg_operands)
7590         {
7591           unsigned int op;
7592           unsigned int vex_reg = ~0;
7593
7594           for (op = 0; op < i.operands; op++)
7595             {
7596               if (i.types[op].bitfield.reg
7597                   || i.types[op].bitfield.regbnd
7598                   || i.types[op].bitfield.regmask
7599                   || i.types[op].bitfield.sreg2
7600                   || i.types[op].bitfield.sreg3
7601                   || i.types[op].bitfield.control
7602                   || i.types[op].bitfield.debug
7603                   || i.types[op].bitfield.test)
7604                 break;
7605               if (i.types[op].bitfield.regsimd)
7606                 {
7607                   if (i.types[op].bitfield.zmmword)
7608                     i.has_regzmm = TRUE;
7609                   else if (i.types[op].bitfield.ymmword)
7610                     i.has_regymm = TRUE;
7611                   else
7612                     i.has_regxmm = TRUE;
7613                   break;
7614                 }
7615               if (i.types[op].bitfield.regmmx)
7616                 {
7617                   i.has_regmmx = TRUE;
7618                   break;
7619                 }
7620             }
7621
7622           if (vex_3_sources)
7623             op = dest;
7624           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7625             {
7626               /* For instructions with VexNDS, the register-only
7627                  source operand is encoded in VEX prefix. */
7628               gas_assert (mem != (unsigned int) ~0);
7629
7630               if (op > mem)
7631                 {
7632                   vex_reg = op++;
7633                   gas_assert (op < i.operands);
7634                 }
7635               else
7636                 {
7637                   /* Check register-only source operand when two source
7638                      operands are swapped.  */
7639                   if (!i.tm.operand_types[op].bitfield.baseindex
7640                       && i.tm.operand_types[op + 1].bitfield.baseindex)
7641                     {
7642                       vex_reg = op;
7643                       op += 2;
7644                       gas_assert (mem == (vex_reg + 1)
7645                                   && op < i.operands);
7646                     }
7647                   else
7648                     {
7649                       vex_reg = op + 1;
7650                       gas_assert (vex_reg < i.operands);
7651                     }
7652                 }
7653             }
7654           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
7655             {
7656               /* For instructions with VexNDD, the register destination
7657                  is encoded in VEX prefix.  */
7658               if (i.mem_operands == 0)
7659                 {
7660                   /* There is no memory operand.  */
7661                   gas_assert ((op + 2) == i.operands);
7662                   vex_reg = op + 1;
7663                 }
7664               else
7665                 {
7666                   /* There are only 2 non-immediate operands.  */
7667                   gas_assert (op < i.imm_operands + 2
7668                               && i.operands == i.imm_operands + 2);
7669                   vex_reg = i.imm_operands + 1;
7670                 }
7671             }
7672           else
7673             gas_assert (op < i.operands);
7674
7675           if (vex_reg != (unsigned int) ~0)
7676             {
7677               i386_operand_type *type = &i.tm.operand_types[vex_reg];
7678
7679               if ((!type->bitfield.reg
7680                    || (!type->bitfield.dword && !type->bitfield.qword))
7681                   && !type->bitfield.regsimd
7682                   && !operand_type_equal (type, &regmask))
7683                 abort ();
7684
7685               i.vex.register_specifier = i.op[vex_reg].regs;
7686             }
7687
7688           /* Don't set OP operand twice.  */
7689           if (vex_reg != op)
7690             {
7691               /* If there is an extension opcode to put here, the
7692                  register number must be put into the regmem field.  */
7693               if (i.tm.extension_opcode != None)
7694                 {
7695                   i.rm.regmem = i.op[op].regs->reg_num;
7696                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
7697                     i.rex |= REX_B;
7698                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
7699                     i.vrex |= REX_B;
7700                 }
7701               else
7702                 {
7703                   i.rm.reg = i.op[op].regs->reg_num;
7704                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
7705                     i.rex |= REX_R;
7706                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
7707                     i.vrex |= REX_R;
7708                 }
7709             }
7710
7711           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
7712              must set it to 3 to indicate this is a register operand
7713              in the regmem field.  */
7714           if (!i.mem_operands)
7715             i.rm.mode = 3;
7716         }
7717
7718       /* Fill in i.rm.reg field with extension opcode (if any).  */
7719       if (i.tm.extension_opcode != None)
7720         i.rm.reg = i.tm.extension_opcode;
7721     }
7722   return default_seg;
7723 }
7724
7725 static void
7726 output_branch (void)
7727 {
7728   char *p;
7729   int size;
7730   int code16;
7731   int prefix;
7732   relax_substateT subtype;
7733   symbolS *sym;
7734   offsetT off;
7735
7736   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
7737   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
7738
7739   prefix = 0;
7740   if (i.prefix[DATA_PREFIX] != 0)
7741     {
7742       prefix = 1;
7743       i.prefixes -= 1;
7744       code16 ^= CODE16;
7745     }
7746   /* Pentium4 branch hints.  */
7747   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7748       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7749     {
7750       prefix++;
7751       i.prefixes--;
7752     }
7753   if (i.prefix[REX_PREFIX] != 0)
7754     {
7755       prefix++;
7756       i.prefixes--;
7757     }
7758
7759   /* BND prefixed jump.  */
7760   if (i.prefix[BND_PREFIX] != 0)
7761     {
7762       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7763       i.prefixes -= 1;
7764     }
7765
7766   if (i.prefixes != 0 && !intel_syntax)
7767     as_warn (_("skipping prefixes on this instruction"));
7768
7769   /* It's always a symbol;  End frag & setup for relax.
7770      Make sure there is enough room in this frag for the largest
7771      instruction we may generate in md_convert_frag.  This is 2
7772      bytes for the opcode and room for the prefix and largest
7773      displacement.  */
7774   frag_grow (prefix + 2 + 4);
7775   /* Prefix and 1 opcode byte go in fr_fix.  */
7776   p = frag_more (prefix + 1);
7777   if (i.prefix[DATA_PREFIX] != 0)
7778     *p++ = DATA_PREFIX_OPCODE;
7779   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
7780       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
7781     *p++ = i.prefix[SEG_PREFIX];
7782   if (i.prefix[REX_PREFIX] != 0)
7783     *p++ = i.prefix[REX_PREFIX];
7784   *p = i.tm.base_opcode;
7785
7786   if ((unsigned char) *p == JUMP_PC_RELATIVE)
7787     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
7788   else if (cpu_arch_flags.bitfield.cpui386)
7789     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
7790   else
7791     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
7792   subtype |= code16;
7793
7794   sym = i.op[0].disps->X_add_symbol;
7795   off = i.op[0].disps->X_add_number;
7796
7797   if (i.op[0].disps->X_op != O_constant
7798       && i.op[0].disps->X_op != O_symbol)
7799     {
7800       /* Handle complex expressions.  */
7801       sym = make_expr_symbol (i.op[0].disps);
7802       off = 0;
7803     }
7804
7805   /* 1 possible extra opcode + 4 byte displacement go in var part.
7806      Pass reloc in fr_var.  */
7807   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
7808 }
7809
7810 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7811 /* Return TRUE iff PLT32 relocation should be used for branching to
7812    symbol S.  */
7813
7814 static bfd_boolean
7815 need_plt32_p (symbolS *s)
7816 {
7817   /* PLT32 relocation is ELF only.  */
7818   if (!IS_ELF)
7819     return FALSE;
7820
7821 #ifdef TE_SOLARIS
7822   /* Don't emit PLT32 relocation on Solaris: neither native linker nor
7823      krtld support it.  */
7824   return FALSE;
7825 #endif
7826
7827   /* Since there is no need to prepare for PLT branch on x86-64, we
7828      can generate R_X86_64_PLT32, instead of R_X86_64_PC32, which can
7829      be used as a marker for 32-bit PC-relative branches.  */
7830   if (!object_64bit)
7831     return FALSE;
7832
7833   /* Weak or undefined symbol need PLT32 relocation.  */
7834   if (S_IS_WEAK (s) || !S_IS_DEFINED (s))
7835     return TRUE;
7836
7837   /* Non-global symbol doesn't need PLT32 relocation.  */
7838   if (! S_IS_EXTERNAL (s))
7839     return FALSE;
7840
7841   /* Other global symbols need PLT32 relocation.  NB: Symbol with
7842      non-default visibilities are treated as normal global symbol
7843      so that PLT32 relocation can be used as a marker for 32-bit
7844      PC-relative branches.  It is useful for linker relaxation.  */
7845   return TRUE;
7846 }
7847 #endif
7848
7849 static void
7850 output_jump (void)
7851 {
7852   char *p;
7853   int size;
7854   fixS *fixP;
7855   bfd_reloc_code_real_type jump_reloc = i.reloc[0];
7856
7857   if (i.tm.opcode_modifier.jumpbyte)
7858     {
7859       /* This is a loop or jecxz type instruction.  */
7860       size = 1;
7861       if (i.prefix[ADDR_PREFIX] != 0)
7862         {
7863           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
7864           i.prefixes -= 1;
7865         }
7866       /* Pentium4 branch hints.  */
7867       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7868           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7869         {
7870           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
7871           i.prefixes--;
7872         }
7873     }
7874   else
7875     {
7876       int code16;
7877
7878       code16 = 0;
7879       if (flag_code == CODE_16BIT)
7880         code16 = CODE16;
7881
7882       if (i.prefix[DATA_PREFIX] != 0)
7883         {
7884           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
7885           i.prefixes -= 1;
7886           code16 ^= CODE16;
7887         }
7888
7889       size = 4;
7890       if (code16)
7891         size = 2;
7892     }
7893
7894   if (i.prefix[REX_PREFIX] != 0)
7895     {
7896       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
7897       i.prefixes -= 1;
7898     }
7899
7900   /* BND prefixed jump.  */
7901   if (i.prefix[BND_PREFIX] != 0)
7902     {
7903       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7904       i.prefixes -= 1;
7905     }
7906
7907   if (i.prefixes != 0 && !intel_syntax)
7908     as_warn (_("skipping prefixes on this instruction"));
7909
7910   p = frag_more (i.tm.opcode_length + size);
7911   switch (i.tm.opcode_length)
7912     {
7913     case 2:
7914       *p++ = i.tm.base_opcode >> 8;
7915       /* Fall through.  */
7916     case 1:
7917       *p++ = i.tm.base_opcode;
7918       break;
7919     default:
7920       abort ();
7921     }
7922
7923 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7924   if (size == 4
7925       && jump_reloc == NO_RELOC
7926       && need_plt32_p (i.op[0].disps->X_add_symbol))
7927     jump_reloc = BFD_RELOC_X86_64_PLT32;
7928 #endif
7929
7930   jump_reloc = reloc (size, 1, 1, jump_reloc);
7931
7932   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7933                       i.op[0].disps, 1, jump_reloc);
7934
7935   /* All jumps handled here are signed, but don't use a signed limit
7936      check for 32 and 16 bit jumps as we want to allow wrap around at
7937      4G and 64k respectively.  */
7938   if (size == 1)
7939     fixP->fx_signed = 1;
7940 }
7941
7942 static void
7943 output_interseg_jump (void)
7944 {
7945   char *p;
7946   int size;
7947   int prefix;
7948   int code16;
7949
7950   code16 = 0;
7951   if (flag_code == CODE_16BIT)
7952     code16 = CODE16;
7953
7954   prefix = 0;
7955   if (i.prefix[DATA_PREFIX] != 0)
7956     {
7957       prefix = 1;
7958       i.prefixes -= 1;
7959       code16 ^= CODE16;
7960     }
7961   if (i.prefix[REX_PREFIX] != 0)
7962     {
7963       prefix++;
7964       i.prefixes -= 1;
7965     }
7966
7967   size = 4;
7968   if (code16)
7969     size = 2;
7970
7971   if (i.prefixes != 0 && !intel_syntax)
7972     as_warn (_("skipping prefixes on this instruction"));
7973
7974   /* 1 opcode; 2 segment; offset  */
7975   p = frag_more (prefix + 1 + 2 + size);
7976
7977   if (i.prefix[DATA_PREFIX] != 0)
7978     *p++ = DATA_PREFIX_OPCODE;
7979
7980   if (i.prefix[REX_PREFIX] != 0)
7981     *p++ = i.prefix[REX_PREFIX];
7982
7983   *p++ = i.tm.base_opcode;
7984   if (i.op[1].imms->X_op == O_constant)
7985     {
7986       offsetT n = i.op[1].imms->X_add_number;
7987
7988       if (size == 2
7989           && !fits_in_unsigned_word (n)
7990           && !fits_in_signed_word (n))
7991         {
7992           as_bad (_("16-bit jump out of range"));
7993           return;
7994         }
7995       md_number_to_chars (p, n, size);
7996     }
7997   else
7998     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7999                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
8000   if (i.op[0].imms->X_op != O_constant)
8001     as_bad (_("can't handle non absolute segment in `%s'"),
8002             i.tm.name);
8003   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
8004 }
8005
8006 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8007 void
8008 x86_cleanup (void)
8009 {
8010   char *p;
8011   asection *seg = now_seg;
8012   subsegT subseg = now_subseg;
8013   asection *sec;
8014   unsigned int alignment, align_size_1;
8015   unsigned int isa_1_descsz, feature_2_descsz, descsz;
8016   unsigned int isa_1_descsz_raw, feature_2_descsz_raw;
8017   unsigned int padding;
8018
8019   if (!IS_ELF || !x86_used_note)
8020     return;
8021
8022   x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X86;
8023
8024   /* The .note.gnu.property section layout:
8025
8026      Field      Length          Contents
8027      ----       ----            ----
8028      n_namsz    4               4
8029      n_descsz   4               The note descriptor size
8030      n_type     4               NT_GNU_PROPERTY_TYPE_0
8031      n_name     4               "GNU"
8032      n_desc     n_descsz        The program property array
8033      ....       ....            ....
8034    */
8035
8036   /* Create the .note.gnu.property section.  */
8037   sec = subseg_new (NOTE_GNU_PROPERTY_SECTION_NAME, 0);
8038   bfd_set_section_flags (stdoutput, sec,
8039                          (SEC_ALLOC
8040                           | SEC_LOAD
8041                           | SEC_DATA
8042                           | SEC_HAS_CONTENTS
8043                           | SEC_READONLY));
8044
8045   if (get_elf_backend_data (stdoutput)->s->elfclass == ELFCLASS64)
8046     {
8047       align_size_1 = 7;
8048       alignment = 3;
8049     }
8050   else
8051     {
8052       align_size_1 = 3;
8053       alignment = 2;
8054     }
8055
8056   bfd_set_section_alignment (stdoutput, sec, alignment);
8057   elf_section_type (sec) = SHT_NOTE;
8058
8059   /* GNU_PROPERTY_X86_ISA_1_USED: 4-byte type + 4-byte data size
8060                                   + 4-byte data  */
8061   isa_1_descsz_raw = 4 + 4 + 4;
8062   /* Align GNU_PROPERTY_X86_ISA_1_USED.  */
8063   isa_1_descsz = (isa_1_descsz_raw + align_size_1) & ~align_size_1;
8064
8065   feature_2_descsz_raw = isa_1_descsz;
8066   /* GNU_PROPERTY_X86_FEATURE_2_USED: 4-byte type + 4-byte data size
8067                                       + 4-byte data  */
8068   feature_2_descsz_raw += 4 + 4 + 4;
8069   /* Align GNU_PROPERTY_X86_FEATURE_2_USED.  */
8070   feature_2_descsz = ((feature_2_descsz_raw + align_size_1)
8071                       & ~align_size_1);
8072
8073   descsz = feature_2_descsz;
8074   /* Section size: n_namsz + n_descsz + n_type + n_name + n_descsz.  */
8075   p = frag_more (4 + 4 + 4 + 4 + descsz);
8076
8077   /* Write n_namsz.  */
8078   md_number_to_chars (p, (valueT) 4, 4);
8079
8080   /* Write n_descsz.  */
8081   md_number_to_chars (p + 4, (valueT) descsz, 4);
8082
8083   /* Write n_type.  */
8084   md_number_to_chars (p + 4 * 2, (valueT) NT_GNU_PROPERTY_TYPE_0, 4);
8085
8086   /* Write n_name.  */
8087   memcpy (p + 4 * 3, "GNU", 4);
8088
8089   /* Write 4-byte type.  */
8090   md_number_to_chars (p + 4 * 4,
8091                       (valueT) GNU_PROPERTY_X86_ISA_1_USED, 4);
8092
8093   /* Write 4-byte data size.  */
8094   md_number_to_chars (p + 4 * 5, (valueT) 4, 4);
8095
8096   /* Write 4-byte data.  */
8097   md_number_to_chars (p + 4 * 6, (valueT) x86_isa_1_used, 4);
8098
8099   /* Zero out paddings.  */
8100   padding = isa_1_descsz - isa_1_descsz_raw;
8101   if (padding)
8102     memset (p + 4 * 7, 0, padding);
8103
8104   /* Write 4-byte type.  */
8105   md_number_to_chars (p + isa_1_descsz + 4 * 4,
8106                       (valueT) GNU_PROPERTY_X86_FEATURE_2_USED, 4);
8107
8108   /* Write 4-byte data size.  */
8109   md_number_to_chars (p + isa_1_descsz + 4 * 5, (valueT) 4, 4);
8110
8111   /* Write 4-byte data.  */
8112   md_number_to_chars (p + isa_1_descsz + 4 * 6,
8113                       (valueT) x86_feature_2_used, 4);
8114
8115   /* Zero out paddings.  */
8116   padding = feature_2_descsz - feature_2_descsz_raw;
8117   if (padding)
8118     memset (p + isa_1_descsz + 4 * 7, 0, padding);
8119
8120   /* We probably can't restore the current segment, for there likely
8121      isn't one yet...  */
8122   if (seg && subseg)
8123     subseg_set (seg, subseg);
8124 }
8125 #endif
8126
8127 static void
8128 output_insn (void)
8129 {
8130   fragS *insn_start_frag;
8131   offsetT insn_start_off;
8132
8133 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8134   if (IS_ELF && x86_used_note)
8135     {
8136       if (i.tm.cpu_flags.bitfield.cpucmov)
8137         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_CMOV;
8138       if (i.tm.cpu_flags.bitfield.cpusse)
8139         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE;
8140       if (i.tm.cpu_flags.bitfield.cpusse2)
8141         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE2;
8142       if (i.tm.cpu_flags.bitfield.cpusse3)
8143         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE3;
8144       if (i.tm.cpu_flags.bitfield.cpussse3)
8145         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSSE3;
8146       if (i.tm.cpu_flags.bitfield.cpusse4_1)
8147         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_1;
8148       if (i.tm.cpu_flags.bitfield.cpusse4_2)
8149         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_2;
8150       if (i.tm.cpu_flags.bitfield.cpuavx)
8151         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX;
8152       if (i.tm.cpu_flags.bitfield.cpuavx2)
8153         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX2;
8154       if (i.tm.cpu_flags.bitfield.cpufma)
8155         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_FMA;
8156       if (i.tm.cpu_flags.bitfield.cpuavx512f)
8157         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512F;
8158       if (i.tm.cpu_flags.bitfield.cpuavx512cd)
8159         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512CD;
8160       if (i.tm.cpu_flags.bitfield.cpuavx512er)
8161         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512ER;
8162       if (i.tm.cpu_flags.bitfield.cpuavx512pf)
8163         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512PF;
8164       if (i.tm.cpu_flags.bitfield.cpuavx512vl)
8165         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512VL;
8166       if (i.tm.cpu_flags.bitfield.cpuavx512dq)
8167         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512DQ;
8168       if (i.tm.cpu_flags.bitfield.cpuavx512bw)
8169         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512BW;
8170       if (i.tm.cpu_flags.bitfield.cpuavx512_4fmaps)
8171         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS;
8172       if (i.tm.cpu_flags.bitfield.cpuavx512_4vnniw)
8173         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW;
8174       if (i.tm.cpu_flags.bitfield.cpuavx512_bitalg)
8175         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BITALG;
8176       if (i.tm.cpu_flags.bitfield.cpuavx512ifma)
8177         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_IFMA;
8178       if (i.tm.cpu_flags.bitfield.cpuavx512vbmi)
8179         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI;
8180       if (i.tm.cpu_flags.bitfield.cpuavx512_vbmi2)
8181         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2;
8182       if (i.tm.cpu_flags.bitfield.cpuavx512_vnni)
8183         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VNNI;
8184       if (i.tm.cpu_flags.bitfield.cpuavx512_bf16)
8185         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BF16;
8186
8187       if (i.tm.cpu_flags.bitfield.cpu8087
8188           || i.tm.cpu_flags.bitfield.cpu287
8189           || i.tm.cpu_flags.bitfield.cpu387
8190           || i.tm.cpu_flags.bitfield.cpu687
8191           || i.tm.cpu_flags.bitfield.cpufisttp)
8192         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X87;
8193       /* Don't set GNU_PROPERTY_X86_FEATURE_2_MMX for prefetchtXXX nor
8194          Xfence instructions.  */
8195       if (i.tm.base_opcode != 0xf18
8196           && i.tm.base_opcode != 0xf0d
8197           && i.tm.base_opcode != 0xfae
8198           && (i.has_regmmx
8199               || i.tm.cpu_flags.bitfield.cpummx
8200               || i.tm.cpu_flags.bitfield.cpua3dnow
8201               || i.tm.cpu_flags.bitfield.cpua3dnowa))
8202         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_MMX;
8203       if (i.has_regxmm)
8204         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XMM;
8205       if (i.has_regymm)
8206         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_YMM;
8207       if (i.has_regzmm)
8208         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_ZMM;
8209       if (i.tm.cpu_flags.bitfield.cpufxsr)
8210         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_FXSR;
8211       if (i.tm.cpu_flags.bitfield.cpuxsave)
8212         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVE;
8213       if (i.tm.cpu_flags.bitfield.cpuxsaveopt)
8214         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT;
8215       if (i.tm.cpu_flags.bitfield.cpuxsavec)
8216         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEC;
8217     }
8218 #endif
8219
8220   /* Tie dwarf2 debug info to the address at the start of the insn.
8221      We can't do this after the insn has been output as the current
8222      frag may have been closed off.  eg. by frag_var.  */
8223   dwarf2_emit_insn (0);
8224
8225   insn_start_frag = frag_now;
8226   insn_start_off = frag_now_fix ();
8227
8228   /* Output jumps.  */
8229   if (i.tm.opcode_modifier.jump)
8230     output_branch ();
8231   else if (i.tm.opcode_modifier.jumpbyte
8232            || i.tm.opcode_modifier.jumpdword)
8233     output_jump ();
8234   else if (i.tm.opcode_modifier.jumpintersegment)
8235     output_interseg_jump ();
8236   else
8237     {
8238       /* Output normal instructions here.  */
8239       char *p;
8240       unsigned char *q;
8241       unsigned int j;
8242       unsigned int prefix;
8243
8244       if (avoid_fence
8245          && i.tm.base_opcode == 0xfae
8246          && i.operands == 1
8247          && i.imm_operands == 1
8248          && (i.op[0].imms->X_add_number == 0xe8
8249              || i.op[0].imms->X_add_number == 0xf0
8250              || i.op[0].imms->X_add_number == 0xf8))
8251         {
8252           /* Encode lfence, mfence, and sfence as
8253              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
8254           offsetT val = 0x240483f0ULL;
8255           p = frag_more (5);
8256           md_number_to_chars (p, val, 5);
8257           return;
8258         }
8259
8260       /* Some processors fail on LOCK prefix. This options makes
8261          assembler ignore LOCK prefix and serves as a workaround.  */
8262       if (omit_lock_prefix)
8263         {
8264           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
8265             return;
8266           i.prefix[LOCK_PREFIX] = 0;
8267         }
8268
8269       /* Since the VEX/EVEX prefix contains the implicit prefix, we
8270          don't need the explicit prefix.  */
8271       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
8272         {
8273           switch (i.tm.opcode_length)
8274             {
8275             case 3:
8276               if (i.tm.base_opcode & 0xff000000)
8277                 {
8278                   prefix = (i.tm.base_opcode >> 24) & 0xff;
8279                   add_prefix (prefix);
8280                 }
8281               break;
8282             case 2:
8283               if ((i.tm.base_opcode & 0xff0000) != 0)
8284                 {
8285                   prefix = (i.tm.base_opcode >> 16) & 0xff;
8286                   if (!i.tm.cpu_flags.bitfield.cpupadlock
8287                       || prefix != REPE_PREFIX_OPCODE
8288                       || (i.prefix[REP_PREFIX] != REPE_PREFIX_OPCODE))
8289                     add_prefix (prefix);
8290                 }
8291               break;
8292             case 1:
8293               break;
8294             case 0:
8295               /* Check for pseudo prefixes.  */
8296               as_bad_where (insn_start_frag->fr_file,
8297                             insn_start_frag->fr_line,
8298                              _("pseudo prefix without instruction"));
8299               return;
8300             default:
8301               abort ();
8302             }
8303
8304 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
8305           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
8306              R_X86_64_GOTTPOFF relocation so that linker can safely
8307              perform IE->LE optimization.  */
8308           if (x86_elf_abi == X86_64_X32_ABI
8309               && i.operands == 2
8310               && i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
8311               && i.prefix[REX_PREFIX] == 0)
8312             add_prefix (REX_OPCODE);
8313 #endif
8314
8315           /* The prefix bytes.  */
8316           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
8317             if (*q)
8318               FRAG_APPEND_1_CHAR (*q);
8319         }
8320       else
8321         {
8322           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
8323             if (*q)
8324               switch (j)
8325                 {
8326                 case REX_PREFIX:
8327                   /* REX byte is encoded in VEX prefix.  */
8328                   break;
8329                 case SEG_PREFIX:
8330                 case ADDR_PREFIX:
8331                   FRAG_APPEND_1_CHAR (*q);
8332                   break;
8333                 default:
8334                   /* There should be no other prefixes for instructions
8335                      with VEX prefix.  */
8336                   abort ();
8337                 }
8338
8339           /* For EVEX instructions i.vrex should become 0 after
8340              build_evex_prefix.  For VEX instructions upper 16 registers
8341              aren't available, so VREX should be 0.  */
8342           if (i.vrex)
8343             abort ();
8344           /* Now the VEX prefix.  */
8345           p = frag_more (i.vex.length);
8346           for (j = 0; j < i.vex.length; j++)
8347             p[j] = i.vex.bytes[j];
8348         }
8349
8350       /* Now the opcode; be careful about word order here!  */
8351       if (i.tm.opcode_length == 1)
8352         {
8353           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
8354         }
8355       else
8356         {
8357           switch (i.tm.opcode_length)
8358             {
8359             case 4:
8360               p = frag_more (4);
8361               *p++ = (i.tm.base_opcode >> 24) & 0xff;
8362               *p++ = (i.tm.base_opcode >> 16) & 0xff;
8363               break;
8364             case 3:
8365               p = frag_more (3);
8366               *p++ = (i.tm.base_opcode >> 16) & 0xff;
8367               break;
8368             case 2:
8369               p = frag_more (2);
8370               break;
8371             default:
8372               abort ();
8373               break;
8374             }
8375
8376           /* Put out high byte first: can't use md_number_to_chars!  */
8377           *p++ = (i.tm.base_opcode >> 8) & 0xff;
8378           *p = i.tm.base_opcode & 0xff;
8379         }
8380
8381       /* Now the modrm byte and sib byte (if present).  */
8382       if (i.tm.opcode_modifier.modrm)
8383         {
8384           FRAG_APPEND_1_CHAR ((i.rm.regmem << 0
8385                                | i.rm.reg << 3
8386                                | i.rm.mode << 6));
8387           /* If i.rm.regmem == ESP (4)
8388              && i.rm.mode != (Register mode)
8389              && not 16 bit
8390              ==> need second modrm byte.  */
8391           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
8392               && i.rm.mode != 3
8393               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
8394             FRAG_APPEND_1_CHAR ((i.sib.base << 0
8395                                  | i.sib.index << 3
8396                                  | i.sib.scale << 6));
8397         }
8398
8399       if (i.disp_operands)
8400         output_disp (insn_start_frag, insn_start_off);
8401
8402       if (i.imm_operands)
8403         output_imm (insn_start_frag, insn_start_off);
8404     }
8405
8406 #ifdef DEBUG386
8407   if (flag_debug)
8408     {
8409       pi ("" /*line*/, &i);
8410     }
8411 #endif /* DEBUG386  */
8412 }
8413
8414 /* Return the size of the displacement operand N.  */
8415
8416 static int
8417 disp_size (unsigned int n)
8418 {
8419   int size = 4;
8420
8421   if (i.types[n].bitfield.disp64)
8422     size = 8;
8423   else if (i.types[n].bitfield.disp8)
8424     size = 1;
8425   else if (i.types[n].bitfield.disp16)
8426     size = 2;
8427   return size;
8428 }
8429
8430 /* Return the size of the immediate operand N.  */
8431
8432 static int
8433 imm_size (unsigned int n)
8434 {
8435   int size = 4;
8436   if (i.types[n].bitfield.imm64)
8437     size = 8;
8438   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
8439     size = 1;
8440   else if (i.types[n].bitfield.imm16)
8441     size = 2;
8442   return size;
8443 }
8444
8445 static void
8446 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
8447 {
8448   char *p;
8449   unsigned int n;
8450
8451   for (n = 0; n < i.operands; n++)
8452     {
8453       if (operand_type_check (i.types[n], disp))
8454         {
8455           if (i.op[n].disps->X_op == O_constant)
8456             {
8457               int size = disp_size (n);
8458               offsetT val = i.op[n].disps->X_add_number;
8459
8460               val = offset_in_range (val >> (size == 1 ? i.memshift : 0),
8461                                      size);
8462               p = frag_more (size);
8463               md_number_to_chars (p, val, size);
8464             }
8465           else
8466             {
8467               enum bfd_reloc_code_real reloc_type;
8468               int size = disp_size (n);
8469               int sign = i.types[n].bitfield.disp32s;
8470               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
8471               fixS *fixP;
8472
8473               /* We can't have 8 bit displacement here.  */
8474               gas_assert (!i.types[n].bitfield.disp8);
8475
8476               /* The PC relative address is computed relative
8477                  to the instruction boundary, so in case immediate
8478                  fields follows, we need to adjust the value.  */
8479               if (pcrel && i.imm_operands)
8480                 {
8481                   unsigned int n1;
8482                   int sz = 0;
8483
8484                   for (n1 = 0; n1 < i.operands; n1++)
8485                     if (operand_type_check (i.types[n1], imm))
8486                       {
8487                         /* Only one immediate is allowed for PC
8488                            relative address.  */
8489                         gas_assert (sz == 0);
8490                         sz = imm_size (n1);
8491                         i.op[n].disps->X_add_number -= sz;
8492                       }
8493                   /* We should find the immediate.  */
8494                   gas_assert (sz != 0);
8495                 }
8496
8497               p = frag_more (size);
8498               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
8499               if (GOT_symbol
8500                   && GOT_symbol == i.op[n].disps->X_add_symbol
8501                   && (((reloc_type == BFD_RELOC_32
8502                         || reloc_type == BFD_RELOC_X86_64_32S
8503                         || (reloc_type == BFD_RELOC_64
8504                             && object_64bit))
8505                        && (i.op[n].disps->X_op == O_symbol
8506                            || (i.op[n].disps->X_op == O_add
8507                                && ((symbol_get_value_expression
8508                                     (i.op[n].disps->X_op_symbol)->X_op)
8509                                    == O_subtract))))
8510                       || reloc_type == BFD_RELOC_32_PCREL))
8511                 {
8512                   offsetT add;
8513
8514                   if (insn_start_frag == frag_now)
8515                     add = (p - frag_now->fr_literal) - insn_start_off;
8516                   else
8517                     {
8518                       fragS *fr;
8519
8520                       add = insn_start_frag->fr_fix - insn_start_off;
8521                       for (fr = insn_start_frag->fr_next;
8522                            fr && fr != frag_now; fr = fr->fr_next)
8523                         add += fr->fr_fix;
8524                       add += p - frag_now->fr_literal;
8525                     }
8526
8527                   if (!object_64bit)
8528                     {
8529                       reloc_type = BFD_RELOC_386_GOTPC;
8530                       i.op[n].imms->X_add_number += add;
8531                     }
8532                   else if (reloc_type == BFD_RELOC_64)
8533                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
8534                   else
8535                     /* Don't do the adjustment for x86-64, as there
8536                        the pcrel addressing is relative to the _next_
8537                        insn, and that is taken care of in other code.  */
8538                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
8539                 }
8540               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
8541                                   size, i.op[n].disps, pcrel,
8542                                   reloc_type);
8543               /* Check for "call/jmp *mem", "mov mem, %reg",
8544                  "test %reg, mem" and "binop mem, %reg" where binop
8545                  is one of adc, add, and, cmp, or, sbb, sub, xor
8546                  instructions without data prefix.  Always generate
8547                  R_386_GOT32X for "sym*GOT" operand in 32-bit mode.  */
8548               if (i.prefix[DATA_PREFIX] == 0
8549                   && (generate_relax_relocations
8550                       || (!object_64bit
8551                           && i.rm.mode == 0
8552                           && i.rm.regmem == 5))
8553                   && (i.rm.mode == 2
8554                       || (i.rm.mode == 0 && i.rm.regmem == 5))
8555                   && ((i.operands == 1
8556                        && i.tm.base_opcode == 0xff
8557                        && (i.rm.reg == 2 || i.rm.reg == 4))
8558                       || (i.operands == 2
8559                           && (i.tm.base_opcode == 0x8b
8560                               || i.tm.base_opcode == 0x85
8561                               || (i.tm.base_opcode & 0xc7) == 0x03))))
8562                 {
8563                   if (object_64bit)
8564                     {
8565                       fixP->fx_tcbit = i.rex != 0;
8566                       if (i.base_reg
8567                           && (i.base_reg->reg_num == RegIP))
8568                       fixP->fx_tcbit2 = 1;
8569                     }
8570                   else
8571                     fixP->fx_tcbit2 = 1;
8572                 }
8573             }
8574         }
8575     }
8576 }
8577
8578 static void
8579 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
8580 {
8581   char *p;
8582   unsigned int n;
8583
8584   for (n = 0; n < i.operands; n++)
8585     {
8586       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
8587       if (i.rounding && (int) n == i.rounding->operand)
8588         continue;
8589
8590       if (operand_type_check (i.types[n], imm))
8591         {
8592           if (i.op[n].imms->X_op == O_constant)
8593             {
8594               int size = imm_size (n);
8595               offsetT val;
8596
8597               val = offset_in_range (i.op[n].imms->X_add_number,
8598                                      size);
8599               p = frag_more (size);
8600               md_number_to_chars (p, val, size);
8601             }
8602           else
8603             {
8604               /* Not absolute_section.
8605                  Need a 32-bit fixup (don't support 8bit
8606                  non-absolute imms).  Try to support other
8607                  sizes ...  */
8608               enum bfd_reloc_code_real reloc_type;
8609               int size = imm_size (n);
8610               int sign;
8611
8612               if (i.types[n].bitfield.imm32s
8613                   && (i.suffix == QWORD_MNEM_SUFFIX
8614                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
8615                 sign = 1;
8616               else
8617                 sign = 0;
8618
8619               p = frag_more (size);
8620               reloc_type = reloc (size, 0, sign, i.reloc[n]);
8621
8622               /*   This is tough to explain.  We end up with this one if we
8623                * have operands that look like
8624                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
8625                * obtain the absolute address of the GOT, and it is strongly
8626                * preferable from a performance point of view to avoid using
8627                * a runtime relocation for this.  The actual sequence of
8628                * instructions often look something like:
8629                *
8630                *        call    .L66
8631                * .L66:
8632                *        popl    %ebx
8633                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
8634                *
8635                *   The call and pop essentially return the absolute address
8636                * of the label .L66 and store it in %ebx.  The linker itself
8637                * will ultimately change the first operand of the addl so
8638                * that %ebx points to the GOT, but to keep things simple, the
8639                * .o file must have this operand set so that it generates not
8640                * the absolute address of .L66, but the absolute address of
8641                * itself.  This allows the linker itself simply treat a GOTPC
8642                * relocation as asking for a pcrel offset to the GOT to be
8643                * added in, and the addend of the relocation is stored in the
8644                * operand field for the instruction itself.
8645                *
8646                *   Our job here is to fix the operand so that it would add
8647                * the correct offset so that %ebx would point to itself.  The
8648                * thing that is tricky is that .-.L66 will point to the
8649                * beginning of the instruction, so we need to further modify
8650                * the operand so that it will point to itself.  There are
8651                * other cases where you have something like:
8652                *
8653                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
8654                *
8655                * and here no correction would be required.  Internally in
8656                * the assembler we treat operands of this form as not being
8657                * pcrel since the '.' is explicitly mentioned, and I wonder
8658                * whether it would simplify matters to do it this way.  Who
8659                * knows.  In earlier versions of the PIC patches, the
8660                * pcrel_adjust field was used to store the correction, but
8661                * since the expression is not pcrel, I felt it would be
8662                * confusing to do it this way.  */
8663
8664               if ((reloc_type == BFD_RELOC_32
8665                    || reloc_type == BFD_RELOC_X86_64_32S
8666                    || reloc_type == BFD_RELOC_64)
8667                   && GOT_symbol
8668                   && GOT_symbol == i.op[n].imms->X_add_symbol
8669                   && (i.op[n].imms->X_op == O_symbol
8670                       || (i.op[n].imms->X_op == O_add
8671                           && ((symbol_get_value_expression
8672                                (i.op[n].imms->X_op_symbol)->X_op)
8673                               == O_subtract))))
8674                 {
8675                   offsetT add;
8676
8677                   if (insn_start_frag == frag_now)
8678                     add = (p - frag_now->fr_literal) - insn_start_off;
8679                   else
8680                     {
8681                       fragS *fr;
8682
8683                       add = insn_start_frag->fr_fix - insn_start_off;
8684                       for (fr = insn_start_frag->fr_next;
8685                            fr && fr != frag_now; fr = fr->fr_next)
8686                         add += fr->fr_fix;
8687                       add += p - frag_now->fr_literal;
8688                     }
8689
8690                   if (!object_64bit)
8691                     reloc_type = BFD_RELOC_386_GOTPC;
8692                   else if (size == 4)
8693                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
8694                   else if (size == 8)
8695                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
8696                   i.op[n].imms->X_add_number += add;
8697                 }
8698               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8699                            i.op[n].imms, 0, reloc_type);
8700             }
8701         }
8702     }
8703 }
8704 \f
8705 /* x86_cons_fix_new is called via the expression parsing code when a
8706    reloc is needed.  We use this hook to get the correct .got reloc.  */
8707 static int cons_sign = -1;
8708
8709 void
8710 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
8711                   expressionS *exp, bfd_reloc_code_real_type r)
8712 {
8713   r = reloc (len, 0, cons_sign, r);
8714
8715 #ifdef TE_PE
8716   if (exp->X_op == O_secrel)
8717     {
8718       exp->X_op = O_symbol;
8719       r = BFD_RELOC_32_SECREL;
8720     }
8721 #endif
8722
8723   fix_new_exp (frag, off, len, exp, 0, r);
8724 }
8725
8726 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
8727    purpose of the `.dc.a' internal pseudo-op.  */
8728
8729 int
8730 x86_address_bytes (void)
8731 {
8732   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
8733     return 4;
8734   return stdoutput->arch_info->bits_per_address / 8;
8735 }
8736
8737 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
8738     || defined (LEX_AT)
8739 # define lex_got(reloc, adjust, types) NULL
8740 #else
8741 /* Parse operands of the form
8742    <symbol>@GOTOFF+<nnn>
8743    and similar .plt or .got references.
8744
8745    If we find one, set up the correct relocation in RELOC and copy the
8746    input string, minus the `@GOTOFF' into a malloc'd buffer for
8747    parsing by the calling routine.  Return this buffer, and if ADJUST
8748    is non-null set it to the length of the string we removed from the
8749    input line.  Otherwise return NULL.  */
8750 static char *
8751 lex_got (enum bfd_reloc_code_real *rel,
8752          int *adjust,
8753          i386_operand_type *types)
8754 {
8755   /* Some of the relocations depend on the size of what field is to
8756      be relocated.  But in our callers i386_immediate and i386_displacement
8757      we don't yet know the operand size (this will be set by insn
8758      matching).  Hence we record the word32 relocation here,
8759      and adjust the reloc according to the real size in reloc().  */
8760   static const struct {
8761     const char *str;
8762     int len;
8763     const enum bfd_reloc_code_real rel[2];
8764     const i386_operand_type types64;
8765   } gotrel[] = {
8766 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8767     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
8768                                         BFD_RELOC_SIZE32 },
8769       OPERAND_TYPE_IMM32_64 },
8770 #endif
8771     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
8772                                        BFD_RELOC_X86_64_PLTOFF64 },
8773       OPERAND_TYPE_IMM64 },
8774     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
8775                                        BFD_RELOC_X86_64_PLT32    },
8776       OPERAND_TYPE_IMM32_32S_DISP32 },
8777     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
8778                                        BFD_RELOC_X86_64_GOTPLT64 },
8779       OPERAND_TYPE_IMM64_DISP64 },
8780     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
8781                                        BFD_RELOC_X86_64_GOTOFF64 },
8782       OPERAND_TYPE_IMM64_DISP64 },
8783     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
8784                                        BFD_RELOC_X86_64_GOTPCREL },
8785       OPERAND_TYPE_IMM32_32S_DISP32 },
8786     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
8787                                        BFD_RELOC_X86_64_TLSGD    },
8788       OPERAND_TYPE_IMM32_32S_DISP32 },
8789     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
8790                                        _dummy_first_bfd_reloc_code_real },
8791       OPERAND_TYPE_NONE },
8792     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
8793                                        BFD_RELOC_X86_64_TLSLD    },
8794       OPERAND_TYPE_IMM32_32S_DISP32 },
8795     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
8796                                        BFD_RELOC_X86_64_GOTTPOFF },
8797       OPERAND_TYPE_IMM32_32S_DISP32 },
8798     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
8799                                        BFD_RELOC_X86_64_TPOFF32  },
8800       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8801     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
8802                                        _dummy_first_bfd_reloc_code_real },
8803       OPERAND_TYPE_NONE },
8804     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
8805                                        BFD_RELOC_X86_64_DTPOFF32 },
8806       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8807     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
8808                                        _dummy_first_bfd_reloc_code_real },
8809       OPERAND_TYPE_NONE },
8810     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
8811                                        _dummy_first_bfd_reloc_code_real },
8812       OPERAND_TYPE_NONE },
8813     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
8814                                        BFD_RELOC_X86_64_GOT32    },
8815       OPERAND_TYPE_IMM32_32S_64_DISP32 },
8816     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
8817                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
8818       OPERAND_TYPE_IMM32_32S_DISP32 },
8819     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
8820                                        BFD_RELOC_X86_64_TLSDESC_CALL },
8821       OPERAND_TYPE_IMM32_32S_DISP32 },
8822   };
8823   char *cp;
8824   unsigned int j;
8825
8826 #if defined (OBJ_MAYBE_ELF)
8827   if (!IS_ELF)
8828     return NULL;
8829 #endif
8830
8831   for (cp = input_line_pointer; *cp != '@'; cp++)
8832     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
8833       return NULL;
8834
8835   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
8836     {
8837       int len = gotrel[j].len;
8838       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
8839         {
8840           if (gotrel[j].rel[object_64bit] != 0)
8841             {
8842               int first, second;
8843               char *tmpbuf, *past_reloc;
8844
8845               *rel = gotrel[j].rel[object_64bit];
8846
8847               if (types)
8848                 {
8849                   if (flag_code != CODE_64BIT)
8850                     {
8851                       types->bitfield.imm32 = 1;
8852                       types->bitfield.disp32 = 1;
8853                     }
8854                   else
8855                     *types = gotrel[j].types64;
8856                 }
8857
8858               if (j != 0 && GOT_symbol == NULL)
8859                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
8860
8861               /* The length of the first part of our input line.  */
8862               first = cp - input_line_pointer;
8863
8864               /* The second part goes from after the reloc token until
8865                  (and including) an end_of_line char or comma.  */
8866               past_reloc = cp + 1 + len;
8867               cp = past_reloc;
8868               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
8869                 ++cp;
8870               second = cp + 1 - past_reloc;
8871
8872               /* Allocate and copy string.  The trailing NUL shouldn't
8873                  be necessary, but be safe.  */
8874               tmpbuf = XNEWVEC (char, first + second + 2);
8875               memcpy (tmpbuf, input_line_pointer, first);
8876               if (second != 0 && *past_reloc != ' ')
8877                 /* Replace the relocation token with ' ', so that
8878                    errors like foo@GOTOFF1 will be detected.  */
8879                 tmpbuf[first++] = ' ';
8880               else
8881                 /* Increment length by 1 if the relocation token is
8882                    removed.  */
8883                 len++;
8884               if (adjust)
8885                 *adjust = len;
8886               memcpy (tmpbuf + first, past_reloc, second);
8887               tmpbuf[first + second] = '\0';
8888               return tmpbuf;
8889             }
8890
8891           as_bad (_("@%s reloc is not supported with %d-bit output format"),
8892                   gotrel[j].str, 1 << (5 + object_64bit));
8893           return NULL;
8894         }
8895     }
8896
8897   /* Might be a symbol version string.  Don't as_bad here.  */
8898   return NULL;
8899 }
8900 #endif
8901
8902 #ifdef TE_PE
8903 #ifdef lex_got
8904 #undef lex_got
8905 #endif
8906 /* Parse operands of the form
8907    <symbol>@SECREL32+<nnn>
8908
8909    If we find one, set up the correct relocation in RELOC and copy the
8910    input string, minus the `@SECREL32' into a malloc'd buffer for
8911    parsing by the calling routine.  Return this buffer, and if ADJUST
8912    is non-null set it to the length of the string we removed from the
8913    input line.  Otherwise return NULL.
8914
8915    This function is copied from the ELF version above adjusted for PE targets.  */
8916
8917 static char *
8918 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
8919          int *adjust ATTRIBUTE_UNUSED,
8920          i386_operand_type *types)
8921 {
8922   static const struct
8923   {
8924     const char *str;
8925     int len;
8926     const enum bfd_reloc_code_real rel[2];
8927     const i386_operand_type types64;
8928   }
8929   gotrel[] =
8930   {
8931     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
8932                                           BFD_RELOC_32_SECREL },
8933       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8934   };
8935
8936   char *cp;
8937   unsigned j;
8938
8939   for (cp = input_line_pointer; *cp != '@'; cp++)
8940     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
8941       return NULL;
8942
8943   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
8944     {
8945       int len = gotrel[j].len;
8946
8947       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
8948         {
8949           if (gotrel[j].rel[object_64bit] != 0)
8950             {
8951               int first, second;
8952               char *tmpbuf, *past_reloc;
8953
8954               *rel = gotrel[j].rel[object_64bit];
8955               if (adjust)
8956                 *adjust = len;
8957
8958               if (types)
8959                 {
8960                   if (flag_code != CODE_64BIT)
8961                     {
8962                       types->bitfield.imm32 = 1;
8963                       types->bitfield.disp32 = 1;
8964                     }
8965                   else
8966                     *types = gotrel[j].types64;
8967                 }
8968
8969               /* The length of the first part of our input line.  */
8970               first = cp - input_line_pointer;
8971
8972               /* The second part goes from after the reloc token until
8973                  (and including) an end_of_line char or comma.  */
8974               past_reloc = cp + 1 + len;
8975               cp = past_reloc;
8976               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
8977                 ++cp;
8978               second = cp + 1 - past_reloc;
8979
8980               /* Allocate and copy string.  The trailing NUL shouldn't
8981                  be necessary, but be safe.  */
8982               tmpbuf = XNEWVEC (char, first + second + 2);
8983               memcpy (tmpbuf, input_line_pointer, first);
8984               if (second != 0 && *past_reloc != ' ')
8985                 /* Replace the relocation token with ' ', so that
8986                    errors like foo@SECLREL321 will be detected.  */
8987                 tmpbuf[first++] = ' ';
8988               memcpy (tmpbuf + first, past_reloc, second);
8989               tmpbuf[first + second] = '\0';
8990               return tmpbuf;
8991             }
8992
8993           as_bad (_("@%s reloc is not supported with %d-bit output format"),
8994                   gotrel[j].str, 1 << (5 + object_64bit));
8995           return NULL;
8996         }
8997     }
8998
8999   /* Might be a symbol version string.  Don't as_bad here.  */
9000   return NULL;
9001 }
9002
9003 #endif /* TE_PE */
9004
9005 bfd_reloc_code_real_type
9006 x86_cons (expressionS *exp, int size)
9007 {
9008   bfd_reloc_code_real_type got_reloc = NO_RELOC;
9009
9010   intel_syntax = -intel_syntax;
9011
9012   exp->X_md = 0;
9013   if (size == 4 || (object_64bit && size == 8))
9014     {
9015       /* Handle @GOTOFF and the like in an expression.  */
9016       char *save;
9017       char *gotfree_input_line;
9018       int adjust = 0;
9019
9020       save = input_line_pointer;
9021       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
9022       if (gotfree_input_line)
9023         input_line_pointer = gotfree_input_line;
9024
9025       expression (exp);
9026
9027       if (gotfree_input_line)
9028         {
9029           /* expression () has merrily parsed up to the end of line,
9030              or a comma - in the wrong buffer.  Transfer how far
9031              input_line_pointer has moved to the right buffer.  */
9032           input_line_pointer = (save
9033                                 + (input_line_pointer - gotfree_input_line)
9034                                 + adjust);
9035           free (gotfree_input_line);
9036           if (exp->X_op == O_constant
9037               || exp->X_op == O_absent
9038               || exp->X_op == O_illegal
9039               || exp->X_op == O_register
9040               || exp->X_op == O_big)
9041             {
9042               char c = *input_line_pointer;
9043               *input_line_pointer = 0;
9044               as_bad (_("missing or invalid expression `%s'"), save);
9045               *input_line_pointer = c;
9046             }
9047           else if ((got_reloc == BFD_RELOC_386_PLT32
9048                     || got_reloc == BFD_RELOC_X86_64_PLT32)
9049                    && exp->X_op != O_symbol)
9050             {
9051               char c = *input_line_pointer;
9052               *input_line_pointer = 0;
9053               as_bad (_("invalid PLT expression `%s'"), save);
9054               *input_line_pointer = c;
9055             }
9056         }
9057     }
9058   else
9059     expression (exp);
9060
9061   intel_syntax = -intel_syntax;
9062
9063   if (intel_syntax)
9064     i386_intel_simplify (exp);
9065
9066   return got_reloc;
9067 }
9068
9069 static void
9070 signed_cons (int size)
9071 {
9072   if (flag_code == CODE_64BIT)
9073     cons_sign = 1;
9074   cons (size);
9075   cons_sign = -1;
9076 }
9077
9078 #ifdef TE_PE
9079 static void
9080 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
9081 {
9082   expressionS exp;
9083
9084   do
9085     {
9086       expression (&exp);
9087       if (exp.X_op == O_symbol)
9088         exp.X_op = O_secrel;
9089
9090       emit_expr (&exp, 4);
9091     }
9092   while (*input_line_pointer++ == ',');
9093
9094   input_line_pointer--;
9095   demand_empty_rest_of_line ();
9096 }
9097 #endif
9098
9099 /* Handle Vector operations.  */
9100
9101 static char *
9102 check_VecOperations (char *op_string, char *op_end)
9103 {
9104   const reg_entry *mask;
9105   const char *saved;
9106   char *end_op;
9107
9108   while (*op_string
9109          && (op_end == NULL || op_string < op_end))
9110     {
9111       saved = op_string;
9112       if (*op_string == '{')
9113         {
9114           op_string++;
9115
9116           /* Check broadcasts.  */
9117           if (strncmp (op_string, "1to", 3) == 0)
9118             {
9119               int bcst_type;
9120
9121               if (i.broadcast)
9122                 goto duplicated_vec_op;
9123
9124               op_string += 3;
9125               if (*op_string == '8')
9126                 bcst_type = 8;
9127               else if (*op_string == '4')
9128                 bcst_type = 4;
9129               else if (*op_string == '2')
9130                 bcst_type = 2;
9131               else if (*op_string == '1'
9132                        && *(op_string+1) == '6')
9133                 {
9134                   bcst_type = 16;
9135                   op_string++;
9136                 }
9137               else
9138                 {
9139                   as_bad (_("Unsupported broadcast: `%s'"), saved);
9140                   return NULL;
9141                 }
9142               op_string++;
9143
9144               broadcast_op.type = bcst_type;
9145               broadcast_op.operand = this_operand;
9146               broadcast_op.bytes = 0;
9147               i.broadcast = &broadcast_op;
9148             }
9149           /* Check masking operation.  */
9150           else if ((mask = parse_register (op_string, &end_op)) != NULL)
9151             {
9152               /* k0 can't be used for write mask.  */
9153               if (!mask->reg_type.bitfield.regmask || mask->reg_num == 0)
9154                 {
9155                   as_bad (_("`%s%s' can't be used for write mask"),
9156                           register_prefix, mask->reg_name);
9157                   return NULL;
9158                 }
9159
9160               if (!i.mask)
9161                 {
9162                   mask_op.mask = mask;
9163                   mask_op.zeroing = 0;
9164                   mask_op.operand = this_operand;
9165                   i.mask = &mask_op;
9166                 }
9167               else
9168                 {
9169                   if (i.mask->mask)
9170                     goto duplicated_vec_op;
9171
9172                   i.mask->mask = mask;
9173
9174                   /* Only "{z}" is allowed here.  No need to check
9175                      zeroing mask explicitly.  */
9176                   if (i.mask->operand != this_operand)
9177                     {
9178                       as_bad (_("invalid write mask `%s'"), saved);
9179                       return NULL;
9180                     }
9181                 }
9182
9183               op_string = end_op;
9184             }
9185           /* Check zeroing-flag for masking operation.  */
9186           else if (*op_string == 'z')
9187             {
9188               if (!i.mask)
9189                 {
9190                   mask_op.mask = NULL;
9191                   mask_op.zeroing = 1;
9192                   mask_op.operand = this_operand;
9193                   i.mask = &mask_op;
9194                 }
9195               else
9196                 {
9197                   if (i.mask->zeroing)
9198                     {
9199                     duplicated_vec_op:
9200                       as_bad (_("duplicated `%s'"), saved);
9201                       return NULL;
9202                     }
9203
9204                   i.mask->zeroing = 1;
9205
9206                   /* Only "{%k}" is allowed here.  No need to check mask
9207                      register explicitly.  */
9208                   if (i.mask->operand != this_operand)
9209                     {
9210                       as_bad (_("invalid zeroing-masking `%s'"),
9211                               saved);
9212                       return NULL;
9213                     }
9214                 }
9215
9216               op_string++;
9217             }
9218           else
9219             goto unknown_vec_op;
9220
9221           if (*op_string != '}')
9222             {
9223               as_bad (_("missing `}' in `%s'"), saved);
9224               return NULL;
9225             }
9226           op_string++;
9227
9228           /* Strip whitespace since the addition of pseudo prefixes
9229              changed how the scrubber treats '{'.  */
9230           if (is_space_char (*op_string))
9231             ++op_string;
9232
9233           continue;
9234         }
9235     unknown_vec_op:
9236       /* We don't know this one.  */
9237       as_bad (_("unknown vector operation: `%s'"), saved);
9238       return NULL;
9239     }
9240
9241   if (i.mask && i.mask->zeroing && !i.mask->mask)
9242     {
9243       as_bad (_("zeroing-masking only allowed with write mask"));
9244       return NULL;
9245     }
9246
9247   return op_string;
9248 }
9249
9250 static int
9251 i386_immediate (char *imm_start)
9252 {
9253   char *save_input_line_pointer;
9254   char *gotfree_input_line;
9255   segT exp_seg = 0;
9256   expressionS *exp;
9257   i386_operand_type types;
9258
9259   operand_type_set (&types, ~0);
9260
9261   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
9262     {
9263       as_bad (_("at most %d immediate operands are allowed"),
9264               MAX_IMMEDIATE_OPERANDS);
9265       return 0;
9266     }
9267
9268   exp = &im_expressions[i.imm_operands++];
9269   i.op[this_operand].imms = exp;
9270
9271   if (is_space_char (*imm_start))
9272     ++imm_start;
9273
9274   save_input_line_pointer = input_line_pointer;
9275   input_line_pointer = imm_start;
9276
9277   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
9278   if (gotfree_input_line)
9279     input_line_pointer = gotfree_input_line;
9280
9281   exp_seg = expression (exp);
9282
9283   SKIP_WHITESPACE ();
9284
9285   /* Handle vector operations.  */
9286   if (*input_line_pointer == '{')
9287     {
9288       input_line_pointer = check_VecOperations (input_line_pointer,
9289                                                 NULL);
9290       if (input_line_pointer == NULL)
9291         return 0;
9292     }
9293
9294   if (*input_line_pointer)
9295     as_bad (_("junk `%s' after expression"), input_line_pointer);
9296
9297   input_line_pointer = save_input_line_pointer;
9298   if (gotfree_input_line)
9299     {
9300       free (gotfree_input_line);
9301
9302       if (exp->X_op == O_constant || exp->X_op == O_register)
9303         exp->X_op = O_illegal;
9304     }
9305
9306   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
9307 }
9308
9309 static int
9310 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
9311                          i386_operand_type types, const char *imm_start)
9312 {
9313   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
9314     {
9315       if (imm_start)
9316         as_bad (_("missing or invalid immediate expression `%s'"),
9317                 imm_start);
9318       return 0;
9319     }
9320   else if (exp->X_op == O_constant)
9321     {
9322       /* Size it properly later.  */
9323       i.types[this_operand].bitfield.imm64 = 1;
9324       /* If not 64bit, sign extend val.  */
9325       if (flag_code != CODE_64BIT
9326           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
9327         exp->X_add_number
9328           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
9329     }
9330 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
9331   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
9332            && exp_seg != absolute_section
9333            && exp_seg != text_section
9334            && exp_seg != data_section
9335            && exp_seg != bss_section
9336            && exp_seg != undefined_section
9337            && !bfd_is_com_section (exp_seg))
9338     {
9339       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
9340       return 0;
9341     }
9342 #endif
9343   else if (!intel_syntax && exp_seg == reg_section)
9344     {
9345       if (imm_start)
9346         as_bad (_("illegal immediate register operand %s"), imm_start);
9347       return 0;
9348     }
9349   else
9350     {
9351       /* This is an address.  The size of the address will be
9352          determined later, depending on destination register,
9353          suffix, or the default for the section.  */
9354       i.types[this_operand].bitfield.imm8 = 1;
9355       i.types[this_operand].bitfield.imm16 = 1;
9356       i.types[this_operand].bitfield.imm32 = 1;
9357       i.types[this_operand].bitfield.imm32s = 1;
9358       i.types[this_operand].bitfield.imm64 = 1;
9359       i.types[this_operand] = operand_type_and (i.types[this_operand],
9360                                                 types);
9361     }
9362
9363   return 1;
9364 }
9365
9366 static char *
9367 i386_scale (char *scale)
9368 {
9369   offsetT val;
9370   char *save = input_line_pointer;
9371
9372   input_line_pointer = scale;
9373   val = get_absolute_expression ();
9374
9375   switch (val)
9376     {
9377     case 1:
9378       i.log2_scale_factor = 0;
9379       break;
9380     case 2:
9381       i.log2_scale_factor = 1;
9382       break;
9383     case 4:
9384       i.log2_scale_factor = 2;
9385       break;
9386     case 8:
9387       i.log2_scale_factor = 3;
9388       break;
9389     default:
9390       {
9391         char sep = *input_line_pointer;
9392
9393         *input_line_pointer = '\0';
9394         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
9395                 scale);
9396         *input_line_pointer = sep;
9397         input_line_pointer = save;
9398         return NULL;
9399       }
9400     }
9401   if (i.log2_scale_factor != 0 && i.index_reg == 0)
9402     {
9403       as_warn (_("scale factor of %d without an index register"),
9404                1 << i.log2_scale_factor);
9405       i.log2_scale_factor = 0;
9406     }
9407   scale = input_line_pointer;
9408   input_line_pointer = save;
9409   return scale;
9410 }
9411
9412 static int
9413 i386_displacement (char *disp_start, char *disp_end)
9414 {
9415   expressionS *exp;
9416   segT exp_seg = 0;
9417   char *save_input_line_pointer;
9418   char *gotfree_input_line;
9419   int override;
9420   i386_operand_type bigdisp, types = anydisp;
9421   int ret;
9422
9423   if (i.disp_operands == MAX_MEMORY_OPERANDS)
9424     {
9425       as_bad (_("at most %d displacement operands are allowed"),
9426               MAX_MEMORY_OPERANDS);
9427       return 0;
9428     }
9429
9430   operand_type_set (&bigdisp, 0);
9431   if ((i.types[this_operand].bitfield.jumpabsolute)
9432       || (!current_templates->start->opcode_modifier.jump
9433           && !current_templates->start->opcode_modifier.jumpdword))
9434     {
9435       bigdisp.bitfield.disp32 = 1;
9436       override = (i.prefix[ADDR_PREFIX] != 0);
9437       if (flag_code == CODE_64BIT)
9438         {
9439           if (!override)
9440             {
9441               bigdisp.bitfield.disp32s = 1;
9442               bigdisp.bitfield.disp64 = 1;
9443             }
9444         }
9445       else if ((flag_code == CODE_16BIT) ^ override)
9446         {
9447           bigdisp.bitfield.disp32 = 0;
9448           bigdisp.bitfield.disp16 = 1;
9449         }
9450     }
9451   else
9452     {
9453       /* For PC-relative branches, the width of the displacement
9454          is dependent upon data size, not address size.  */
9455       override = (i.prefix[DATA_PREFIX] != 0);
9456       if (flag_code == CODE_64BIT)
9457         {
9458           if (override || i.suffix == WORD_MNEM_SUFFIX)
9459             bigdisp.bitfield.disp16 = 1;
9460           else
9461             {
9462               bigdisp.bitfield.disp32 = 1;
9463               bigdisp.bitfield.disp32s = 1;
9464             }
9465         }
9466       else
9467         {
9468           if (!override)
9469             override = (i.suffix == (flag_code != CODE_16BIT
9470                                      ? WORD_MNEM_SUFFIX
9471                                      : LONG_MNEM_SUFFIX));
9472           bigdisp.bitfield.disp32 = 1;
9473           if ((flag_code == CODE_16BIT) ^ override)
9474             {
9475               bigdisp.bitfield.disp32 = 0;
9476               bigdisp.bitfield.disp16 = 1;
9477             }
9478         }
9479     }
9480   i.types[this_operand] = operand_type_or (i.types[this_operand],
9481                                            bigdisp);
9482
9483   exp = &disp_expressions[i.disp_operands];
9484   i.op[this_operand].disps = exp;
9485   i.disp_operands++;
9486   save_input_line_pointer = input_line_pointer;
9487   input_line_pointer = disp_start;
9488   END_STRING_AND_SAVE (disp_end);
9489
9490 #ifndef GCC_ASM_O_HACK
9491 #define GCC_ASM_O_HACK 0
9492 #endif
9493 #if GCC_ASM_O_HACK
9494   END_STRING_AND_SAVE (disp_end + 1);
9495   if (i.types[this_operand].bitfield.baseIndex
9496       && displacement_string_end[-1] == '+')
9497     {
9498       /* This hack is to avoid a warning when using the "o"
9499          constraint within gcc asm statements.
9500          For instance:
9501
9502          #define _set_tssldt_desc(n,addr,limit,type) \
9503          __asm__ __volatile__ ( \
9504          "movw %w2,%0\n\t" \
9505          "movw %w1,2+%0\n\t" \
9506          "rorl $16,%1\n\t" \
9507          "movb %b1,4+%0\n\t" \
9508          "movb %4,5+%0\n\t" \
9509          "movb $0,6+%0\n\t" \
9510          "movb %h1,7+%0\n\t" \
9511          "rorl $16,%1" \
9512          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
9513
9514          This works great except that the output assembler ends
9515          up looking a bit weird if it turns out that there is
9516          no offset.  You end up producing code that looks like:
9517
9518          #APP
9519          movw $235,(%eax)
9520          movw %dx,2+(%eax)
9521          rorl $16,%edx
9522          movb %dl,4+(%eax)
9523          movb $137,5+(%eax)
9524          movb $0,6+(%eax)
9525          movb %dh,7+(%eax)
9526          rorl $16,%edx
9527          #NO_APP
9528
9529          So here we provide the missing zero.  */
9530
9531       *displacement_string_end = '0';
9532     }
9533 #endif
9534   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
9535   if (gotfree_input_line)
9536     input_line_pointer = gotfree_input_line;
9537
9538   exp_seg = expression (exp);
9539
9540   SKIP_WHITESPACE ();
9541   if (*input_line_pointer)
9542     as_bad (_("junk `%s' after expression"), input_line_pointer);
9543 #if GCC_ASM_O_HACK
9544   RESTORE_END_STRING (disp_end + 1);
9545 #endif
9546   input_line_pointer = save_input_line_pointer;
9547   if (gotfree_input_line)
9548     {
9549       free (gotfree_input_line);
9550
9551       if (exp->X_op == O_constant || exp->X_op == O_register)
9552         exp->X_op = O_illegal;
9553     }
9554
9555   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
9556
9557   RESTORE_END_STRING (disp_end);
9558
9559   return ret;
9560 }
9561
9562 static int
9563 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
9564                             i386_operand_type types, const char *disp_start)
9565 {
9566   i386_operand_type bigdisp;
9567   int ret = 1;
9568
9569   /* We do this to make sure that the section symbol is in
9570      the symbol table.  We will ultimately change the relocation
9571      to be relative to the beginning of the section.  */
9572   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
9573       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
9574       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
9575     {
9576       if (exp->X_op != O_symbol)
9577         goto inv_disp;
9578
9579       if (S_IS_LOCAL (exp->X_add_symbol)
9580           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
9581           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
9582         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
9583       exp->X_op = O_subtract;
9584       exp->X_op_symbol = GOT_symbol;
9585       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
9586         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
9587       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
9588         i.reloc[this_operand] = BFD_RELOC_64;
9589       else
9590         i.reloc[this_operand] = BFD_RELOC_32;
9591     }
9592
9593   else if (exp->X_op == O_absent
9594            || exp->X_op == O_illegal
9595            || exp->X_op == O_big)
9596     {
9597     inv_disp:
9598       as_bad (_("missing or invalid displacement expression `%s'"),
9599               disp_start);
9600       ret = 0;
9601     }
9602
9603   else if (flag_code == CODE_64BIT
9604            && !i.prefix[ADDR_PREFIX]
9605            && exp->X_op == O_constant)
9606     {
9607       /* Since displacement is signed extended to 64bit, don't allow
9608          disp32 and turn off disp32s if they are out of range.  */
9609       i.types[this_operand].bitfield.disp32 = 0;
9610       if (!fits_in_signed_long (exp->X_add_number))
9611         {
9612           i.types[this_operand].bitfield.disp32s = 0;
9613           if (i.types[this_operand].bitfield.baseindex)
9614             {
9615               as_bad (_("0x%lx out range of signed 32bit displacement"),
9616                       (long) exp->X_add_number);
9617               ret = 0;
9618             }
9619         }
9620     }
9621
9622 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
9623   else if (exp->X_op != O_constant
9624            && OUTPUT_FLAVOR == bfd_target_aout_flavour
9625            && exp_seg != absolute_section
9626            && exp_seg != text_section
9627            && exp_seg != data_section
9628            && exp_seg != bss_section
9629            && exp_seg != undefined_section
9630            && !bfd_is_com_section (exp_seg))
9631     {
9632       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
9633       ret = 0;
9634     }
9635 #endif
9636
9637   /* Check if this is a displacement only operand.  */
9638   bigdisp = i.types[this_operand];
9639   bigdisp.bitfield.disp8 = 0;
9640   bigdisp.bitfield.disp16 = 0;
9641   bigdisp.bitfield.disp32 = 0;
9642   bigdisp.bitfield.disp32s = 0;
9643   bigdisp.bitfield.disp64 = 0;
9644   if (operand_type_all_zero (&bigdisp))
9645     i.types[this_operand] = operand_type_and (i.types[this_operand],
9646                                               types);
9647
9648   return ret;
9649 }
9650
9651 /* Return the active addressing mode, taking address override and
9652    registers forming the address into consideration.  Update the
9653    address override prefix if necessary.  */
9654
9655 static enum flag_code
9656 i386_addressing_mode (void)
9657 {
9658   enum flag_code addr_mode;
9659
9660   if (i.prefix[ADDR_PREFIX])
9661     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
9662   else
9663     {
9664       addr_mode = flag_code;
9665
9666 #if INFER_ADDR_PREFIX
9667       if (i.mem_operands == 0)
9668         {
9669           /* Infer address prefix from the first memory operand.  */
9670           const reg_entry *addr_reg = i.base_reg;
9671
9672           if (addr_reg == NULL)
9673             addr_reg = i.index_reg;
9674
9675           if (addr_reg)
9676             {
9677               if (addr_reg->reg_type.bitfield.dword)
9678                 addr_mode = CODE_32BIT;
9679               else if (flag_code != CODE_64BIT
9680                        && addr_reg->reg_type.bitfield.word)
9681                 addr_mode = CODE_16BIT;
9682
9683               if (addr_mode != flag_code)
9684                 {
9685                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
9686                   i.prefixes += 1;
9687                   /* Change the size of any displacement too.  At most one
9688                      of Disp16 or Disp32 is set.
9689                      FIXME.  There doesn't seem to be any real need for
9690                      separate Disp16 and Disp32 flags.  The same goes for
9691                      Imm16 and Imm32.  Removing them would probably clean
9692                      up the code quite a lot.  */
9693                   if (flag_code != CODE_64BIT
9694                       && (i.types[this_operand].bitfield.disp16
9695                           || i.types[this_operand].bitfield.disp32))
9696                     i.types[this_operand]
9697                       = operand_type_xor (i.types[this_operand], disp16_32);
9698                 }
9699             }
9700         }
9701 #endif
9702     }
9703
9704   return addr_mode;
9705 }
9706
9707 /* Make sure the memory operand we've been dealt is valid.
9708    Return 1 on success, 0 on a failure.  */
9709
9710 static int
9711 i386_index_check (const char *operand_string)
9712 {
9713   const char *kind = "base/index";
9714   enum flag_code addr_mode = i386_addressing_mode ();
9715
9716   if (current_templates->start->opcode_modifier.isstring
9717       && !current_templates->start->opcode_modifier.immext
9718       && (current_templates->end[-1].opcode_modifier.isstring
9719           || i.mem_operands))
9720     {
9721       /* Memory operands of string insns are special in that they only allow
9722          a single register (rDI, rSI, or rBX) as their memory address.  */
9723       const reg_entry *expected_reg;
9724       static const char *di_si[][2] =
9725         {
9726           { "esi", "edi" },
9727           { "si", "di" },
9728           { "rsi", "rdi" }
9729         };
9730       static const char *bx[] = { "ebx", "bx", "rbx" };
9731
9732       kind = "string address";
9733
9734       if (current_templates->start->opcode_modifier.repprefixok)
9735         {
9736           i386_operand_type type = current_templates->end[-1].operand_types[0];
9737
9738           if (!type.bitfield.baseindex
9739               || ((!i.mem_operands != !intel_syntax)
9740                   && current_templates->end[-1].operand_types[1]
9741                      .bitfield.baseindex))
9742             type = current_templates->end[-1].operand_types[1];
9743           expected_reg = hash_find (reg_hash,
9744                                     di_si[addr_mode][type.bitfield.esseg]);
9745
9746         }
9747       else
9748         expected_reg = hash_find (reg_hash, bx[addr_mode]);
9749
9750       if (i.base_reg != expected_reg
9751           || i.index_reg
9752           || operand_type_check (i.types[this_operand], disp))
9753         {
9754           /* The second memory operand must have the same size as
9755              the first one.  */
9756           if (i.mem_operands
9757               && i.base_reg
9758               && !((addr_mode == CODE_64BIT
9759                     && i.base_reg->reg_type.bitfield.qword)
9760                    || (addr_mode == CODE_32BIT
9761                        ? i.base_reg->reg_type.bitfield.dword
9762                        : i.base_reg->reg_type.bitfield.word)))
9763             goto bad_address;
9764
9765           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
9766                    operand_string,
9767                    intel_syntax ? '[' : '(',
9768                    register_prefix,
9769                    expected_reg->reg_name,
9770                    intel_syntax ? ']' : ')');
9771           return 1;
9772         }
9773       else
9774         return 1;
9775
9776 bad_address:
9777       as_bad (_("`%s' is not a valid %s expression"),
9778               operand_string, kind);
9779       return 0;
9780     }
9781   else
9782     {
9783       if (addr_mode != CODE_16BIT)
9784         {
9785           /* 32-bit/64-bit checks.  */
9786           if ((i.base_reg
9787                && ((addr_mode == CODE_64BIT
9788                     ? !i.base_reg->reg_type.bitfield.qword
9789                     : !i.base_reg->reg_type.bitfield.dword)
9790                    || (i.index_reg && i.base_reg->reg_num == RegIP)
9791                    || i.base_reg->reg_num == RegIZ))
9792               || (i.index_reg
9793                   && !i.index_reg->reg_type.bitfield.xmmword
9794                   && !i.index_reg->reg_type.bitfield.ymmword
9795                   && !i.index_reg->reg_type.bitfield.zmmword
9796                   && ((addr_mode == CODE_64BIT
9797                        ? !i.index_reg->reg_type.bitfield.qword
9798                        : !i.index_reg->reg_type.bitfield.dword)
9799                       || !i.index_reg->reg_type.bitfield.baseindex)))
9800             goto bad_address;
9801
9802           /* bndmk, bndldx, and bndstx have special restrictions. */
9803           if (current_templates->start->base_opcode == 0xf30f1b
9804               || (current_templates->start->base_opcode & ~1) == 0x0f1a)
9805             {
9806               /* They cannot use RIP-relative addressing. */
9807               if (i.base_reg && i.base_reg->reg_num == RegIP)
9808                 {
9809                   as_bad (_("`%s' cannot be used here"), operand_string);
9810                   return 0;
9811                 }
9812
9813               /* bndldx and bndstx ignore their scale factor. */
9814               if (current_templates->start->base_opcode != 0xf30f1b
9815                   && i.log2_scale_factor)
9816                 as_warn (_("register scaling is being ignored here"));
9817             }
9818         }
9819       else
9820         {
9821           /* 16-bit checks.  */
9822           if ((i.base_reg
9823                && (!i.base_reg->reg_type.bitfield.word
9824                    || !i.base_reg->reg_type.bitfield.baseindex))
9825               || (i.index_reg
9826                   && (!i.index_reg->reg_type.bitfield.word
9827                       || !i.index_reg->reg_type.bitfield.baseindex
9828                       || !(i.base_reg
9829                            && i.base_reg->reg_num < 6
9830                            && i.index_reg->reg_num >= 6
9831                            && i.log2_scale_factor == 0))))
9832             goto bad_address;
9833         }
9834     }
9835   return 1;
9836 }
9837
9838 /* Handle vector immediates.  */
9839
9840 static int
9841 RC_SAE_immediate (const char *imm_start)
9842 {
9843   unsigned int match_found, j;
9844   const char *pstr = imm_start;
9845   expressionS *exp;
9846
9847   if (*pstr != '{')
9848     return 0;
9849
9850   pstr++;
9851   match_found = 0;
9852   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
9853     {
9854       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
9855         {
9856           if (!i.rounding)
9857             {
9858               rc_op.type = RC_NamesTable[j].type;
9859               rc_op.operand = this_operand;
9860               i.rounding = &rc_op;
9861             }
9862           else
9863             {
9864               as_bad (_("duplicated `%s'"), imm_start);
9865               return 0;
9866             }
9867           pstr += RC_NamesTable[j].len;
9868           match_found = 1;
9869           break;
9870         }
9871     }
9872   if (!match_found)
9873     return 0;
9874
9875   if (*pstr++ != '}')
9876     {
9877       as_bad (_("Missing '}': '%s'"), imm_start);
9878       return 0;
9879     }
9880   /* RC/SAE immediate string should contain nothing more.  */;
9881   if (*pstr != 0)
9882     {
9883       as_bad (_("Junk after '}': '%s'"), imm_start);
9884       return 0;
9885     }
9886
9887   exp = &im_expressions[i.imm_operands++];
9888   i.op[this_operand].imms = exp;
9889
9890   exp->X_op = O_constant;
9891   exp->X_add_number = 0;
9892   exp->X_add_symbol = (symbolS *) 0;
9893   exp->X_op_symbol = (symbolS *) 0;
9894
9895   i.types[this_operand].bitfield.imm8 = 1;
9896   return 1;
9897 }
9898
9899 /* Only string instructions can have a second memory operand, so
9900    reduce current_templates to just those if it contains any.  */
9901 static int
9902 maybe_adjust_templates (void)
9903 {
9904   const insn_template *t;
9905
9906   gas_assert (i.mem_operands == 1);
9907
9908   for (t = current_templates->start; t < current_templates->end; ++t)
9909     if (t->opcode_modifier.isstring)
9910       break;
9911
9912   if (t < current_templates->end)
9913     {
9914       static templates aux_templates;
9915       bfd_boolean recheck;
9916
9917       aux_templates.start = t;
9918       for (; t < current_templates->end; ++t)
9919         if (!t->opcode_modifier.isstring)
9920           break;
9921       aux_templates.end = t;
9922
9923       /* Determine whether to re-check the first memory operand.  */
9924       recheck = (aux_templates.start != current_templates->start
9925                  || t != current_templates->end);
9926
9927       current_templates = &aux_templates;
9928
9929       if (recheck)
9930         {
9931           i.mem_operands = 0;
9932           if (i.memop1_string != NULL
9933               && i386_index_check (i.memop1_string) == 0)
9934             return 0;
9935           i.mem_operands = 1;
9936         }
9937     }
9938
9939   return 1;
9940 }
9941
9942 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
9943    on error.  */
9944
9945 static int
9946 i386_att_operand (char *operand_string)
9947 {
9948   const reg_entry *r;
9949   char *end_op;
9950   char *op_string = operand_string;
9951
9952   if (is_space_char (*op_string))
9953     ++op_string;
9954
9955   /* We check for an absolute prefix (differentiating,
9956      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
9957   if (*op_string == ABSOLUTE_PREFIX)
9958     {
9959       ++op_string;
9960       if (is_space_char (*op_string))
9961         ++op_string;
9962       i.types[this_operand].bitfield.jumpabsolute = 1;
9963     }
9964
9965   /* Check if operand is a register.  */
9966   if ((r = parse_register (op_string, &end_op)) != NULL)
9967     {
9968       i386_operand_type temp;
9969
9970       /* Check for a segment override by searching for ':' after a
9971          segment register.  */
9972       op_string = end_op;
9973       if (is_space_char (*op_string))
9974         ++op_string;
9975       if (*op_string == ':'
9976           && (r->reg_type.bitfield.sreg2
9977               || r->reg_type.bitfield.sreg3))
9978         {
9979           switch (r->reg_num)
9980             {
9981             case 0:
9982               i.seg[i.mem_operands] = &es;
9983               break;
9984             case 1:
9985               i.seg[i.mem_operands] = &cs;
9986               break;
9987             case 2:
9988               i.seg[i.mem_operands] = &ss;
9989               break;
9990             case 3:
9991               i.seg[i.mem_operands] = &ds;
9992               break;
9993             case 4:
9994               i.seg[i.mem_operands] = &fs;
9995               break;
9996             case 5:
9997               i.seg[i.mem_operands] = &gs;
9998               break;
9999             }
10000
10001           /* Skip the ':' and whitespace.  */
10002           ++op_string;
10003           if (is_space_char (*op_string))
10004             ++op_string;
10005
10006           if (!is_digit_char (*op_string)
10007               && !is_identifier_char (*op_string)
10008               && *op_string != '('
10009               && *op_string != ABSOLUTE_PREFIX)
10010             {
10011               as_bad (_("bad memory operand `%s'"), op_string);
10012               return 0;
10013             }
10014           /* Handle case of %es:*foo.  */
10015           if (*op_string == ABSOLUTE_PREFIX)
10016             {
10017               ++op_string;
10018               if (is_space_char (*op_string))
10019                 ++op_string;
10020               i.types[this_operand].bitfield.jumpabsolute = 1;
10021             }
10022           goto do_memory_reference;
10023         }
10024
10025       /* Handle vector operations.  */
10026       if (*op_string == '{')
10027         {
10028           op_string = check_VecOperations (op_string, NULL);
10029           if (op_string == NULL)
10030             return 0;
10031         }
10032
10033       if (*op_string)
10034         {
10035           as_bad (_("junk `%s' after register"), op_string);
10036           return 0;
10037         }
10038       temp = r->reg_type;
10039       temp.bitfield.baseindex = 0;
10040       i.types[this_operand] = operand_type_or (i.types[this_operand],
10041                                                temp);
10042       i.types[this_operand].bitfield.unspecified = 0;
10043       i.op[this_operand].regs = r;
10044       i.reg_operands++;
10045     }
10046   else if (*op_string == REGISTER_PREFIX)
10047     {
10048       as_bad (_("bad register name `%s'"), op_string);
10049       return 0;
10050     }
10051   else if (*op_string == IMMEDIATE_PREFIX)
10052     {
10053       ++op_string;
10054       if (i.types[this_operand].bitfield.jumpabsolute)
10055         {
10056           as_bad (_("immediate operand illegal with absolute jump"));
10057           return 0;
10058         }
10059       if (!i386_immediate (op_string))
10060         return 0;
10061     }
10062   else if (RC_SAE_immediate (operand_string))
10063     {
10064       /* If it is a RC or SAE immediate, do nothing.  */
10065       ;
10066     }
10067   else if (is_digit_char (*op_string)
10068            || is_identifier_char (*op_string)
10069            || *op_string == '"'
10070            || *op_string == '(')
10071     {
10072       /* This is a memory reference of some sort.  */
10073       char *base_string;
10074
10075       /* Start and end of displacement string expression (if found).  */
10076       char *displacement_string_start;
10077       char *displacement_string_end;
10078       char *vop_start;
10079
10080     do_memory_reference:
10081       if (i.mem_operands == 1 && !maybe_adjust_templates ())
10082         return 0;
10083       if ((i.mem_operands == 1
10084            && !current_templates->start->opcode_modifier.isstring)
10085           || i.mem_operands == 2)
10086         {
10087           as_bad (_("too many memory references for `%s'"),
10088                   current_templates->start->name);
10089           return 0;
10090         }
10091
10092       /* Check for base index form.  We detect the base index form by
10093          looking for an ')' at the end of the operand, searching
10094          for the '(' matching it, and finding a REGISTER_PREFIX or ','
10095          after the '('.  */
10096       base_string = op_string + strlen (op_string);
10097
10098       /* Handle vector operations.  */
10099       vop_start = strchr (op_string, '{');
10100       if (vop_start && vop_start < base_string)
10101         {
10102           if (check_VecOperations (vop_start, base_string) == NULL)
10103             return 0;
10104           base_string = vop_start;
10105         }
10106
10107       --base_string;
10108       if (is_space_char (*base_string))
10109         --base_string;
10110
10111       /* If we only have a displacement, set-up for it to be parsed later.  */
10112       displacement_string_start = op_string;
10113       displacement_string_end = base_string + 1;
10114
10115       if (*base_string == ')')
10116         {
10117           char *temp_string;
10118           unsigned int parens_balanced = 1;
10119           /* We've already checked that the number of left & right ()'s are
10120              equal, so this loop will not be infinite.  */
10121           do
10122             {
10123               base_string--;
10124               if (*base_string == ')')
10125                 parens_balanced++;
10126               if (*base_string == '(')
10127                 parens_balanced--;
10128             }
10129           while (parens_balanced);
10130
10131           temp_string = base_string;
10132
10133           /* Skip past '(' and whitespace.  */
10134           ++base_string;
10135           if (is_space_char (*base_string))
10136             ++base_string;
10137
10138           if (*base_string == ','
10139               || ((i.base_reg = parse_register (base_string, &end_op))
10140                   != NULL))
10141             {
10142               displacement_string_end = temp_string;
10143
10144               i.types[this_operand].bitfield.baseindex = 1;
10145
10146               if (i.base_reg)
10147                 {
10148                   base_string = end_op;
10149                   if (is_space_char (*base_string))
10150                     ++base_string;
10151                 }
10152
10153               /* There may be an index reg or scale factor here.  */
10154               if (*base_string == ',')
10155                 {
10156                   ++base_string;
10157                   if (is_space_char (*base_string))
10158                     ++base_string;
10159
10160                   if ((i.index_reg = parse_register (base_string, &end_op))
10161                       != NULL)
10162                     {
10163                       base_string = end_op;
10164                       if (is_space_char (*base_string))
10165                         ++base_string;
10166                       if (*base_string == ',')
10167                         {
10168                           ++base_string;
10169                           if (is_space_char (*base_string))
10170                             ++base_string;
10171                         }
10172                       else if (*base_string != ')')
10173                         {
10174                           as_bad (_("expecting `,' or `)' "
10175                                     "after index register in `%s'"),
10176                                   operand_string);
10177                           return 0;
10178                         }
10179                     }
10180                   else if (*base_string == REGISTER_PREFIX)
10181                     {
10182                       end_op = strchr (base_string, ',');
10183                       if (end_op)
10184                         *end_op = '\0';
10185                       as_bad (_("bad register name `%s'"), base_string);
10186                       return 0;
10187                     }
10188
10189                   /* Check for scale factor.  */
10190                   if (*base_string != ')')
10191                     {
10192                       char *end_scale = i386_scale (base_string);
10193
10194                       if (!end_scale)
10195                         return 0;
10196
10197                       base_string = end_scale;
10198                       if (is_space_char (*base_string))
10199                         ++base_string;
10200                       if (*base_string != ')')
10201                         {
10202                           as_bad (_("expecting `)' "
10203                                     "after scale factor in `%s'"),
10204                                   operand_string);
10205                           return 0;
10206                         }
10207                     }
10208                   else if (!i.index_reg)
10209                     {
10210                       as_bad (_("expecting index register or scale factor "
10211                                 "after `,'; got '%c'"),
10212                               *base_string);
10213                       return 0;
10214                     }
10215                 }
10216               else if (*base_string != ')')
10217                 {
10218                   as_bad (_("expecting `,' or `)' "
10219                             "after base register in `%s'"),
10220                           operand_string);
10221                   return 0;
10222                 }
10223             }
10224           else if (*base_string == REGISTER_PREFIX)
10225             {
10226               end_op = strchr (base_string, ',');
10227               if (end_op)
10228                 *end_op = '\0';
10229               as_bad (_("bad register name `%s'"), base_string);
10230               return 0;
10231             }
10232         }
10233
10234       /* If there's an expression beginning the operand, parse it,
10235          assuming displacement_string_start and
10236          displacement_string_end are meaningful.  */
10237       if (displacement_string_start != displacement_string_end)
10238         {
10239           if (!i386_displacement (displacement_string_start,
10240                                   displacement_string_end))
10241             return 0;
10242         }
10243
10244       /* Special case for (%dx) while doing input/output op.  */
10245       if (i.base_reg
10246           && i.base_reg->reg_type.bitfield.inoutportreg
10247           && i.index_reg == 0
10248           && i.log2_scale_factor == 0
10249           && i.seg[i.mem_operands] == 0
10250           && !operand_type_check (i.types[this_operand], disp))
10251         {
10252           i.types[this_operand] = i.base_reg->reg_type;
10253           return 1;
10254         }
10255
10256       if (i386_index_check (operand_string) == 0)
10257         return 0;
10258       i.flags[this_operand] |= Operand_Mem;
10259       if (i.mem_operands == 0)
10260         i.memop1_string = xstrdup (operand_string);
10261       i.mem_operands++;
10262     }
10263   else
10264     {
10265       /* It's not a memory operand; argh!  */
10266       as_bad (_("invalid char %s beginning operand %d `%s'"),
10267               output_invalid (*op_string),
10268               this_operand + 1,
10269               op_string);
10270       return 0;
10271     }
10272   return 1;                     /* Normal return.  */
10273 }
10274 \f
10275 /* Calculate the maximum variable size (i.e., excluding fr_fix)
10276    that an rs_machine_dependent frag may reach.  */
10277
10278 unsigned int
10279 i386_frag_max_var (fragS *frag)
10280 {
10281   /* The only relaxable frags are for jumps.
10282      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
10283   gas_assert (frag->fr_type == rs_machine_dependent);
10284   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
10285 }
10286
10287 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10288 static int
10289 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
10290 {
10291   /* STT_GNU_IFUNC symbol must go through PLT.  */
10292   if ((symbol_get_bfdsym (fr_symbol)->flags
10293        & BSF_GNU_INDIRECT_FUNCTION) != 0)
10294     return 0;
10295
10296   if (!S_IS_EXTERNAL (fr_symbol))
10297     /* Symbol may be weak or local.  */
10298     return !S_IS_WEAK (fr_symbol);
10299
10300   /* Global symbols with non-default visibility can't be preempted. */
10301   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
10302     return 1;
10303
10304   if (fr_var != NO_RELOC)
10305     switch ((enum bfd_reloc_code_real) fr_var)
10306       {
10307       case BFD_RELOC_386_PLT32:
10308       case BFD_RELOC_X86_64_PLT32:
10309         /* Symbol with PLT relocation may be preempted. */
10310         return 0;
10311       default:
10312         abort ();
10313       }
10314
10315   /* Global symbols with default visibility in a shared library may be
10316      preempted by another definition.  */
10317   return !shared;
10318 }
10319 #endif
10320
10321 /* md_estimate_size_before_relax()
10322
10323    Called just before relax() for rs_machine_dependent frags.  The x86
10324    assembler uses these frags to handle variable size jump
10325    instructions.
10326
10327    Any symbol that is now undefined will not become defined.
10328    Return the correct fr_subtype in the frag.
10329    Return the initial "guess for variable size of frag" to caller.
10330    The guess is actually the growth beyond the fixed part.  Whatever
10331    we do to grow the fixed or variable part contributes to our
10332    returned value.  */
10333
10334 int
10335 md_estimate_size_before_relax (fragS *fragP, segT segment)
10336 {
10337   /* We've already got fragP->fr_subtype right;  all we have to do is
10338      check for un-relaxable symbols.  On an ELF system, we can't relax
10339      an externally visible symbol, because it may be overridden by a
10340      shared library.  */
10341   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
10342 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10343       || (IS_ELF
10344           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
10345                                                 fragP->fr_var))
10346 #endif
10347 #if defined (OBJ_COFF) && defined (TE_PE)
10348       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
10349           && S_IS_WEAK (fragP->fr_symbol))
10350 #endif
10351       )
10352     {
10353       /* Symbol is undefined in this segment, or we need to keep a
10354          reloc so that weak symbols can be overridden.  */
10355       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
10356       enum bfd_reloc_code_real reloc_type;
10357       unsigned char *opcode;
10358       int old_fr_fix;
10359
10360       if (fragP->fr_var != NO_RELOC)
10361         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
10362       else if (size == 2)
10363         reloc_type = BFD_RELOC_16_PCREL;
10364 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10365       else if (need_plt32_p (fragP->fr_symbol))
10366         reloc_type = BFD_RELOC_X86_64_PLT32;
10367 #endif
10368       else
10369         reloc_type = BFD_RELOC_32_PCREL;
10370
10371       old_fr_fix = fragP->fr_fix;
10372       opcode = (unsigned char *) fragP->fr_opcode;
10373
10374       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
10375         {
10376         case UNCOND_JUMP:
10377           /* Make jmp (0xeb) a (d)word displacement jump.  */
10378           opcode[0] = 0xe9;
10379           fragP->fr_fix += size;
10380           fix_new (fragP, old_fr_fix, size,
10381                    fragP->fr_symbol,
10382                    fragP->fr_offset, 1,
10383                    reloc_type);
10384           break;
10385
10386         case COND_JUMP86:
10387           if (size == 2
10388               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
10389             {
10390               /* Negate the condition, and branch past an
10391                  unconditional jump.  */
10392               opcode[0] ^= 1;
10393               opcode[1] = 3;
10394               /* Insert an unconditional jump.  */
10395               opcode[2] = 0xe9;
10396               /* We added two extra opcode bytes, and have a two byte
10397                  offset.  */
10398               fragP->fr_fix += 2 + 2;
10399               fix_new (fragP, old_fr_fix + 2, 2,
10400                        fragP->fr_symbol,
10401                        fragP->fr_offset, 1,
10402                        reloc_type);
10403               break;
10404             }
10405           /* Fall through.  */
10406
10407         case COND_JUMP:
10408           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
10409             {
10410               fixS *fixP;
10411
10412               fragP->fr_fix += 1;
10413               fixP = fix_new (fragP, old_fr_fix, 1,
10414                               fragP->fr_symbol,
10415                               fragP->fr_offset, 1,
10416                               BFD_RELOC_8_PCREL);
10417               fixP->fx_signed = 1;
10418               break;
10419             }
10420
10421           /* This changes the byte-displacement jump 0x7N
10422              to the (d)word-displacement jump 0x0f,0x8N.  */
10423           opcode[1] = opcode[0] + 0x10;
10424           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10425           /* We've added an opcode byte.  */
10426           fragP->fr_fix += 1 + size;
10427           fix_new (fragP, old_fr_fix + 1, size,
10428                    fragP->fr_symbol,
10429                    fragP->fr_offset, 1,
10430                    reloc_type);
10431           break;
10432
10433         default:
10434           BAD_CASE (fragP->fr_subtype);
10435           break;
10436         }
10437       frag_wane (fragP);
10438       return fragP->fr_fix - old_fr_fix;
10439     }
10440
10441   /* Guess size depending on current relax state.  Initially the relax
10442      state will correspond to a short jump and we return 1, because
10443      the variable part of the frag (the branch offset) is one byte
10444      long.  However, we can relax a section more than once and in that
10445      case we must either set fr_subtype back to the unrelaxed state,
10446      or return the value for the appropriate branch.  */
10447   return md_relax_table[fragP->fr_subtype].rlx_length;
10448 }
10449
10450 /* Called after relax() is finished.
10451
10452    In:  Address of frag.
10453         fr_type == rs_machine_dependent.
10454         fr_subtype is what the address relaxed to.
10455
10456    Out: Any fixSs and constants are set up.
10457         Caller will turn frag into a ".space 0".  */
10458
10459 void
10460 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
10461                  fragS *fragP)
10462 {
10463   unsigned char *opcode;
10464   unsigned char *where_to_put_displacement = NULL;
10465   offsetT target_address;
10466   offsetT opcode_address;
10467   unsigned int extension = 0;
10468   offsetT displacement_from_opcode_start;
10469
10470   opcode = (unsigned char *) fragP->fr_opcode;
10471
10472   /* Address we want to reach in file space.  */
10473   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
10474
10475   /* Address opcode resides at in file space.  */
10476   opcode_address = fragP->fr_address + fragP->fr_fix;
10477
10478   /* Displacement from opcode start to fill into instruction.  */
10479   displacement_from_opcode_start = target_address - opcode_address;
10480
10481   if ((fragP->fr_subtype & BIG) == 0)
10482     {
10483       /* Don't have to change opcode.  */
10484       extension = 1;            /* 1 opcode + 1 displacement  */
10485       where_to_put_displacement = &opcode[1];
10486     }
10487   else
10488     {
10489       if (no_cond_jump_promotion
10490           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
10491         as_warn_where (fragP->fr_file, fragP->fr_line,
10492                        _("long jump required"));
10493
10494       switch (fragP->fr_subtype)
10495         {
10496         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
10497           extension = 4;                /* 1 opcode + 4 displacement  */
10498           opcode[0] = 0xe9;
10499           where_to_put_displacement = &opcode[1];
10500           break;
10501
10502         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
10503           extension = 2;                /* 1 opcode + 2 displacement  */
10504           opcode[0] = 0xe9;
10505           where_to_put_displacement = &opcode[1];
10506           break;
10507
10508         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
10509         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
10510           extension = 5;                /* 2 opcode + 4 displacement  */
10511           opcode[1] = opcode[0] + 0x10;
10512           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10513           where_to_put_displacement = &opcode[2];
10514           break;
10515
10516         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
10517           extension = 3;                /* 2 opcode + 2 displacement  */
10518           opcode[1] = opcode[0] + 0x10;
10519           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10520           where_to_put_displacement = &opcode[2];
10521           break;
10522
10523         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
10524           extension = 4;
10525           opcode[0] ^= 1;
10526           opcode[1] = 3;
10527           opcode[2] = 0xe9;
10528           where_to_put_displacement = &opcode[3];
10529           break;
10530
10531         default:
10532           BAD_CASE (fragP->fr_subtype);
10533           break;
10534         }
10535     }
10536
10537   /* If size if less then four we are sure that the operand fits,
10538      but if it's 4, then it could be that the displacement is larger
10539      then -/+ 2GB.  */
10540   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
10541       && object_64bit
10542       && ((addressT) (displacement_from_opcode_start - extension
10543                       + ((addressT) 1 << 31))
10544           > (((addressT) 2 << 31) - 1)))
10545     {
10546       as_bad_where (fragP->fr_file, fragP->fr_line,
10547                     _("jump target out of range"));
10548       /* Make us emit 0.  */
10549       displacement_from_opcode_start = extension;
10550     }
10551   /* Now put displacement after opcode.  */
10552   md_number_to_chars ((char *) where_to_put_displacement,
10553                       (valueT) (displacement_from_opcode_start - extension),
10554                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
10555   fragP->fr_fix += extension;
10556 }
10557 \f
10558 /* Apply a fixup (fixP) to segment data, once it has been determined
10559    by our caller that we have all the info we need to fix it up.
10560
10561    Parameter valP is the pointer to the value of the bits.
10562
10563    On the 386, immediates, displacements, and data pointers are all in
10564    the same (little-endian) format, so we don't need to care about which
10565    we are handling.  */
10566
10567 void
10568 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
10569 {
10570   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
10571   valueT value = *valP;
10572
10573 #if !defined (TE_Mach)
10574   if (fixP->fx_pcrel)
10575     {
10576       switch (fixP->fx_r_type)
10577         {
10578         default:
10579           break;
10580
10581         case BFD_RELOC_64:
10582           fixP->fx_r_type = BFD_RELOC_64_PCREL;
10583           break;
10584         case BFD_RELOC_32:
10585         case BFD_RELOC_X86_64_32S:
10586           fixP->fx_r_type = BFD_RELOC_32_PCREL;
10587           break;
10588         case BFD_RELOC_16:
10589           fixP->fx_r_type = BFD_RELOC_16_PCREL;
10590           break;
10591         case BFD_RELOC_8:
10592           fixP->fx_r_type = BFD_RELOC_8_PCREL;
10593           break;
10594         }
10595     }
10596
10597   if (fixP->fx_addsy != NULL
10598       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
10599           || fixP->fx_r_type == BFD_RELOC_64_PCREL
10600           || fixP->fx_r_type == BFD_RELOC_16_PCREL
10601           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
10602       && !use_rela_relocations)
10603     {
10604       /* This is a hack.  There should be a better way to handle this.
10605          This covers for the fact that bfd_install_relocation will
10606          subtract the current location (for partial_inplace, PC relative
10607          relocations); see more below.  */
10608 #ifndef OBJ_AOUT
10609       if (IS_ELF
10610 #ifdef TE_PE
10611           || OUTPUT_FLAVOR == bfd_target_coff_flavour
10612 #endif
10613           )
10614         value += fixP->fx_where + fixP->fx_frag->fr_address;
10615 #endif
10616 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10617       if (IS_ELF)
10618         {
10619           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
10620
10621           if ((sym_seg == seg
10622                || (symbol_section_p (fixP->fx_addsy)
10623                    && sym_seg != absolute_section))
10624               && !generic_force_reloc (fixP))
10625             {
10626               /* Yes, we add the values in twice.  This is because
10627                  bfd_install_relocation subtracts them out again.  I think
10628                  bfd_install_relocation is broken, but I don't dare change
10629                  it.  FIXME.  */
10630               value += fixP->fx_where + fixP->fx_frag->fr_address;
10631             }
10632         }
10633 #endif
10634 #if defined (OBJ_COFF) && defined (TE_PE)
10635       /* For some reason, the PE format does not store a
10636          section address offset for a PC relative symbol.  */
10637       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
10638           || S_IS_WEAK (fixP->fx_addsy))
10639         value += md_pcrel_from (fixP);
10640 #endif
10641     }
10642 #if defined (OBJ_COFF) && defined (TE_PE)
10643   if (fixP->fx_addsy != NULL
10644       && S_IS_WEAK (fixP->fx_addsy)
10645       /* PR 16858: Do not modify weak function references.  */
10646       && ! fixP->fx_pcrel)
10647     {
10648 #if !defined (TE_PEP)
10649       /* For x86 PE weak function symbols are neither PC-relative
10650          nor do they set S_IS_FUNCTION.  So the only reliable way
10651          to detect them is to check the flags of their containing
10652          section.  */
10653       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
10654           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
10655         ;
10656       else
10657 #endif
10658       value -= S_GET_VALUE (fixP->fx_addsy);
10659     }
10660 #endif
10661
10662   /* Fix a few things - the dynamic linker expects certain values here,
10663      and we must not disappoint it.  */
10664 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10665   if (IS_ELF && fixP->fx_addsy)
10666     switch (fixP->fx_r_type)
10667       {
10668       case BFD_RELOC_386_PLT32:
10669       case BFD_RELOC_X86_64_PLT32:
10670         /* Make the jump instruction point to the address of the operand.
10671            At runtime we merely add the offset to the actual PLT entry.
10672            NB: Subtract the offset size only for jump instructions.  */
10673         if (fixP->fx_pcrel)
10674           value = -4;
10675         break;
10676
10677       case BFD_RELOC_386_TLS_GD:
10678       case BFD_RELOC_386_TLS_LDM:
10679       case BFD_RELOC_386_TLS_IE_32:
10680       case BFD_RELOC_386_TLS_IE:
10681       case BFD_RELOC_386_TLS_GOTIE:
10682       case BFD_RELOC_386_TLS_GOTDESC:
10683       case BFD_RELOC_X86_64_TLSGD:
10684       case BFD_RELOC_X86_64_TLSLD:
10685       case BFD_RELOC_X86_64_GOTTPOFF:
10686       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
10687         value = 0; /* Fully resolved at runtime.  No addend.  */
10688         /* Fallthrough */
10689       case BFD_RELOC_386_TLS_LE:
10690       case BFD_RELOC_386_TLS_LDO_32:
10691       case BFD_RELOC_386_TLS_LE_32:
10692       case BFD_RELOC_X86_64_DTPOFF32:
10693       case BFD_RELOC_X86_64_DTPOFF64:
10694       case BFD_RELOC_X86_64_TPOFF32:
10695       case BFD_RELOC_X86_64_TPOFF64:
10696         S_SET_THREAD_LOCAL (fixP->fx_addsy);
10697         break;
10698
10699       case BFD_RELOC_386_TLS_DESC_CALL:
10700       case BFD_RELOC_X86_64_TLSDESC_CALL:
10701         value = 0; /* Fully resolved at runtime.  No addend.  */
10702         S_SET_THREAD_LOCAL (fixP->fx_addsy);
10703         fixP->fx_done = 0;
10704         return;
10705
10706       case BFD_RELOC_VTABLE_INHERIT:
10707       case BFD_RELOC_VTABLE_ENTRY:
10708         fixP->fx_done = 0;
10709         return;
10710
10711       default:
10712         break;
10713       }
10714 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
10715   *valP = value;
10716 #endif /* !defined (TE_Mach)  */
10717
10718   /* Are we finished with this relocation now?  */
10719   if (fixP->fx_addsy == NULL)
10720     fixP->fx_done = 1;
10721 #if defined (OBJ_COFF) && defined (TE_PE)
10722   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
10723     {
10724       fixP->fx_done = 0;
10725       /* Remember value for tc_gen_reloc.  */
10726       fixP->fx_addnumber = value;
10727       /* Clear out the frag for now.  */
10728       value = 0;
10729     }
10730 #endif
10731   else if (use_rela_relocations)
10732     {
10733       fixP->fx_no_overflow = 1;
10734       /* Remember value for tc_gen_reloc.  */
10735       fixP->fx_addnumber = value;
10736       value = 0;
10737     }
10738
10739   md_number_to_chars (p, value, fixP->fx_size);
10740 }
10741 \f
10742 const char *
10743 md_atof (int type, char *litP, int *sizeP)
10744 {
10745   /* This outputs the LITTLENUMs in REVERSE order;
10746      in accord with the bigendian 386.  */
10747   return ieee_md_atof (type, litP, sizeP, FALSE);
10748 }
10749 \f
10750 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
10751
10752 static char *
10753 output_invalid (int c)
10754 {
10755   if (ISPRINT (c))
10756     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
10757               "'%c'", c);
10758   else
10759     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
10760               "(0x%x)", (unsigned char) c);
10761   return output_invalid_buf;
10762 }
10763
10764 /* REG_STRING starts *before* REGISTER_PREFIX.  */
10765
10766 static const reg_entry *
10767 parse_real_register (char *reg_string, char **end_op)
10768 {
10769   char *s = reg_string;
10770   char *p;
10771   char reg_name_given[MAX_REG_NAME_SIZE + 1];
10772   const reg_entry *r;
10773
10774   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
10775   if (*s == REGISTER_PREFIX)
10776     ++s;
10777
10778   if (is_space_char (*s))
10779     ++s;
10780
10781   p = reg_name_given;
10782   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
10783     {
10784       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
10785         return (const reg_entry *) NULL;
10786       s++;
10787     }
10788
10789   /* For naked regs, make sure that we are not dealing with an identifier.
10790      This prevents confusing an identifier like `eax_var' with register
10791      `eax'.  */
10792   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
10793     return (const reg_entry *) NULL;
10794
10795   *end_op = s;
10796
10797   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
10798
10799   /* Handle floating point regs, allowing spaces in the (i) part.  */
10800   if (r == i386_regtab /* %st is first entry of table  */)
10801     {
10802       if (!cpu_arch_flags.bitfield.cpu8087
10803           && !cpu_arch_flags.bitfield.cpu287
10804           && !cpu_arch_flags.bitfield.cpu387)
10805         return (const reg_entry *) NULL;
10806
10807       if (is_space_char (*s))
10808         ++s;
10809       if (*s == '(')
10810         {
10811           ++s;
10812           if (is_space_char (*s))
10813             ++s;
10814           if (*s >= '0' && *s <= '7')
10815             {
10816               int fpr = *s - '0';
10817               ++s;
10818               if (is_space_char (*s))
10819                 ++s;
10820               if (*s == ')')
10821                 {
10822                   *end_op = s + 1;
10823                   r = (const reg_entry *) hash_find (reg_hash, "st(0)");
10824                   know (r);
10825                   return r + fpr;
10826                 }
10827             }
10828           /* We have "%st(" then garbage.  */
10829           return (const reg_entry *) NULL;
10830         }
10831     }
10832
10833   if (r == NULL || allow_pseudo_reg)
10834     return r;
10835
10836   if (operand_type_all_zero (&r->reg_type))
10837     return (const reg_entry *) NULL;
10838
10839   if ((r->reg_type.bitfield.dword
10840        || r->reg_type.bitfield.sreg3
10841        || r->reg_type.bitfield.control
10842        || r->reg_type.bitfield.debug
10843        || r->reg_type.bitfield.test)
10844       && !cpu_arch_flags.bitfield.cpui386)
10845     return (const reg_entry *) NULL;
10846
10847   if (r->reg_type.bitfield.regmmx && !cpu_arch_flags.bitfield.cpummx)
10848     return (const reg_entry *) NULL;
10849
10850   if (!cpu_arch_flags.bitfield.cpuavx512f)
10851     {
10852       if (r->reg_type.bitfield.zmmword || r->reg_type.bitfield.regmask)
10853         return (const reg_entry *) NULL;
10854
10855       if (!cpu_arch_flags.bitfield.cpuavx)
10856         {
10857           if (r->reg_type.bitfield.ymmword)
10858             return (const reg_entry *) NULL;
10859
10860           if (!cpu_arch_flags.bitfield.cpusse && r->reg_type.bitfield.xmmword)
10861             return (const reg_entry *) NULL;
10862         }
10863     }
10864
10865   if (r->reg_type.bitfield.regbnd && !cpu_arch_flags.bitfield.cpumpx)
10866     return (const reg_entry *) NULL;
10867
10868   /* Don't allow fake index register unless allow_index_reg isn't 0. */
10869   if (!allow_index_reg && r->reg_num == RegIZ)
10870     return (const reg_entry *) NULL;
10871
10872   /* Upper 16 vector registers are only available with VREX in 64bit
10873      mode, and require EVEX encoding.  */
10874   if (r->reg_flags & RegVRex)
10875     {
10876       if (!cpu_arch_flags.bitfield.cpuavx512f
10877           || flag_code != CODE_64BIT)
10878         return (const reg_entry *) NULL;
10879
10880       i.vec_encoding = vex_encoding_evex;
10881     }
10882
10883   if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword)
10884       && (!cpu_arch_flags.bitfield.cpulm || !r->reg_type.bitfield.control)
10885       && flag_code != CODE_64BIT)
10886     return (const reg_entry *) NULL;
10887
10888   if (r->reg_type.bitfield.sreg3 && r->reg_num == RegFlat && !intel_syntax)
10889     return (const reg_entry *) NULL;
10890
10891   return r;
10892 }
10893
10894 /* REG_STRING starts *before* REGISTER_PREFIX.  */
10895
10896 static const reg_entry *
10897 parse_register (char *reg_string, char **end_op)
10898 {
10899   const reg_entry *r;
10900
10901   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
10902     r = parse_real_register (reg_string, end_op);
10903   else
10904     r = NULL;
10905   if (!r)
10906     {
10907       char *save = input_line_pointer;
10908       char c;
10909       symbolS *symbolP;
10910
10911       input_line_pointer = reg_string;
10912       c = get_symbol_name (&reg_string);
10913       symbolP = symbol_find (reg_string);
10914       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
10915         {
10916           const expressionS *e = symbol_get_value_expression (symbolP);
10917
10918           know (e->X_op == O_register);
10919           know (e->X_add_number >= 0
10920                 && (valueT) e->X_add_number < i386_regtab_size);
10921           r = i386_regtab + e->X_add_number;
10922           if ((r->reg_flags & RegVRex))
10923             i.vec_encoding = vex_encoding_evex;
10924           *end_op = input_line_pointer;
10925         }
10926       *input_line_pointer = c;
10927       input_line_pointer = save;
10928     }
10929   return r;
10930 }
10931
10932 int
10933 i386_parse_name (char *name, expressionS *e, char *nextcharP)
10934 {
10935   const reg_entry *r;
10936   char *end = input_line_pointer;
10937
10938   *end = *nextcharP;
10939   r = parse_register (name, &input_line_pointer);
10940   if (r && end <= input_line_pointer)
10941     {
10942       *nextcharP = *input_line_pointer;
10943       *input_line_pointer = 0;
10944       e->X_op = O_register;
10945       e->X_add_number = r - i386_regtab;
10946       return 1;
10947     }
10948   input_line_pointer = end;
10949   *end = 0;
10950   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
10951 }
10952
10953 void
10954 md_operand (expressionS *e)
10955 {
10956   char *end;
10957   const reg_entry *r;
10958
10959   switch (*input_line_pointer)
10960     {
10961     case REGISTER_PREFIX:
10962       r = parse_real_register (input_line_pointer, &end);
10963       if (r)
10964         {
10965           e->X_op = O_register;
10966           e->X_add_number = r - i386_regtab;
10967           input_line_pointer = end;
10968         }
10969       break;
10970
10971     case '[':
10972       gas_assert (intel_syntax);
10973       end = input_line_pointer++;
10974       expression (e);
10975       if (*input_line_pointer == ']')
10976         {
10977           ++input_line_pointer;
10978           e->X_op_symbol = make_expr_symbol (e);
10979           e->X_add_symbol = NULL;
10980           e->X_add_number = 0;
10981           e->X_op = O_index;
10982         }
10983       else
10984         {
10985           e->X_op = O_absent;
10986           input_line_pointer = end;
10987         }
10988       break;
10989     }
10990 }
10991
10992 \f
10993 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10994 const char *md_shortopts = "kVQ:sqnO::";
10995 #else
10996 const char *md_shortopts = "qnO::";
10997 #endif
10998
10999 #define OPTION_32 (OPTION_MD_BASE + 0)
11000 #define OPTION_64 (OPTION_MD_BASE + 1)
11001 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
11002 #define OPTION_MARCH (OPTION_MD_BASE + 3)
11003 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
11004 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
11005 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
11006 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
11007 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
11008 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 9)
11009 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
11010 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
11011 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
11012 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
11013 #define OPTION_X32 (OPTION_MD_BASE + 14)
11014 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
11015 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
11016 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
11017 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
11018 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
11019 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
11020 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
11021 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
11022 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
11023 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
11024 #define OPTION_X86_USED_NOTE (OPTION_MD_BASE + 25)
11025 #define OPTION_MVEXWIG (OPTION_MD_BASE + 26)
11026
11027 struct option md_longopts[] =
11028 {
11029   {"32", no_argument, NULL, OPTION_32},
11030 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11031      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11032   {"64", no_argument, NULL, OPTION_64},
11033 #endif
11034 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11035   {"x32", no_argument, NULL, OPTION_X32},
11036   {"mshared", no_argument, NULL, OPTION_MSHARED},
11037   {"mx86-used-note", required_argument, NULL, OPTION_X86_USED_NOTE},
11038 #endif
11039   {"divide", no_argument, NULL, OPTION_DIVIDE},
11040   {"march", required_argument, NULL, OPTION_MARCH},
11041   {"mtune", required_argument, NULL, OPTION_MTUNE},
11042   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
11043   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
11044   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
11045   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
11046   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
11047   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
11048   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
11049   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
11050   {"mvexwig", required_argument, NULL, OPTION_MVEXWIG},
11051   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
11052   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
11053   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
11054 # if defined (TE_PE) || defined (TE_PEP)
11055   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
11056 #endif
11057   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
11058   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
11059   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
11060   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
11061   {"mamd64", no_argument, NULL, OPTION_MAMD64},
11062   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
11063   {NULL, no_argument, NULL, 0}
11064 };
11065 size_t md_longopts_size = sizeof (md_longopts);
11066
11067 int
11068 md_parse_option (int c, const char *arg)
11069 {
11070   unsigned int j;
11071   char *arch, *next, *saved;
11072
11073   switch (c)
11074     {
11075     case 'n':
11076       optimize_align_code = 0;
11077       break;
11078
11079     case 'q':
11080       quiet_warnings = 1;
11081       break;
11082
11083 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11084       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
11085          should be emitted or not.  FIXME: Not implemented.  */
11086     case 'Q':
11087       break;
11088
11089       /* -V: SVR4 argument to print version ID.  */
11090     case 'V':
11091       print_version_id ();
11092       break;
11093
11094       /* -k: Ignore for FreeBSD compatibility.  */
11095     case 'k':
11096       break;
11097
11098     case 's':
11099       /* -s: On i386 Solaris, this tells the native assembler to use
11100          .stab instead of .stab.excl.  We always use .stab anyhow.  */
11101       break;
11102
11103     case OPTION_MSHARED:
11104       shared = 1;
11105       break;
11106
11107     case OPTION_X86_USED_NOTE:
11108       if (strcasecmp (arg, "yes") == 0)
11109         x86_used_note = 1;
11110       else if (strcasecmp (arg, "no") == 0)
11111         x86_used_note = 0;
11112       else
11113         as_fatal (_("invalid -mx86-used-note= option: `%s'"), arg);
11114       break;
11115
11116
11117 #endif
11118 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11119      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11120     case OPTION_64:
11121       {
11122         const char **list, **l;
11123
11124         list = bfd_target_list ();
11125         for (l = list; *l != NULL; l++)
11126           if (CONST_STRNEQ (*l, "elf64-x86-64")
11127               || strcmp (*l, "coff-x86-64") == 0
11128               || strcmp (*l, "pe-x86-64") == 0
11129               || strcmp (*l, "pei-x86-64") == 0
11130               || strcmp (*l, "mach-o-x86-64") == 0)
11131             {
11132               default_arch = "x86_64";
11133               break;
11134             }
11135         if (*l == NULL)
11136           as_fatal (_("no compiled in support for x86_64"));
11137         free (list);
11138       }
11139       break;
11140 #endif
11141
11142 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11143     case OPTION_X32:
11144       if (IS_ELF)
11145         {
11146           const char **list, **l;
11147
11148           list = bfd_target_list ();
11149           for (l = list; *l != NULL; l++)
11150             if (CONST_STRNEQ (*l, "elf32-x86-64"))
11151               {
11152                 default_arch = "x86_64:32";
11153                 break;
11154               }
11155           if (*l == NULL)
11156             as_fatal (_("no compiled in support for 32bit x86_64"));
11157           free (list);
11158         }
11159       else
11160         as_fatal (_("32bit x86_64 is only supported for ELF"));
11161       break;
11162 #endif
11163
11164     case OPTION_32:
11165       default_arch = "i386";
11166       break;
11167
11168     case OPTION_DIVIDE:
11169 #ifdef SVR4_COMMENT_CHARS
11170       {
11171         char *n, *t;
11172         const char *s;
11173
11174         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
11175         t = n;
11176         for (s = i386_comment_chars; *s != '\0'; s++)
11177           if (*s != '/')
11178             *t++ = *s;
11179         *t = '\0';
11180         i386_comment_chars = n;
11181       }
11182 #endif
11183       break;
11184
11185     case OPTION_MARCH:
11186       saved = xstrdup (arg);
11187       arch = saved;
11188       /* Allow -march=+nosse.  */
11189       if (*arch == '+')
11190         arch++;
11191       do
11192         {
11193           if (*arch == '.')
11194             as_fatal (_("invalid -march= option: `%s'"), arg);
11195           next = strchr (arch, '+');
11196           if (next)
11197             *next++ = '\0';
11198           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11199             {
11200               if (strcmp (arch, cpu_arch [j].name) == 0)
11201                 {
11202                   /* Processor.  */
11203                   if (! cpu_arch[j].flags.bitfield.cpui386)
11204                     continue;
11205
11206                   cpu_arch_name = cpu_arch[j].name;
11207                   cpu_sub_arch_name = NULL;
11208                   cpu_arch_flags = cpu_arch[j].flags;
11209                   cpu_arch_isa = cpu_arch[j].type;
11210                   cpu_arch_isa_flags = cpu_arch[j].flags;
11211                   if (!cpu_arch_tune_set)
11212                     {
11213                       cpu_arch_tune = cpu_arch_isa;
11214                       cpu_arch_tune_flags = cpu_arch_isa_flags;
11215                     }
11216                   break;
11217                 }
11218               else if (*cpu_arch [j].name == '.'
11219                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
11220                 {
11221                   /* ISA extension.  */
11222                   i386_cpu_flags flags;
11223
11224                   flags = cpu_flags_or (cpu_arch_flags,
11225                                         cpu_arch[j].flags);
11226
11227                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
11228                     {
11229                       if (cpu_sub_arch_name)
11230                         {
11231                           char *name = cpu_sub_arch_name;
11232                           cpu_sub_arch_name = concat (name,
11233                                                       cpu_arch[j].name,
11234                                                       (const char *) NULL);
11235                           free (name);
11236                         }
11237                       else
11238                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
11239                       cpu_arch_flags = flags;
11240                       cpu_arch_isa_flags = flags;
11241                     }
11242                   else
11243                     cpu_arch_isa_flags
11244                       = cpu_flags_or (cpu_arch_isa_flags,
11245                                       cpu_arch[j].flags);
11246                   break;
11247                 }
11248             }
11249
11250           if (j >= ARRAY_SIZE (cpu_arch))
11251             {
11252               /* Disable an ISA extension.  */
11253               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
11254                 if (strcmp (arch, cpu_noarch [j].name) == 0)
11255                   {
11256                     i386_cpu_flags flags;
11257
11258                     flags = cpu_flags_and_not (cpu_arch_flags,
11259                                                cpu_noarch[j].flags);
11260                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
11261                       {
11262                         if (cpu_sub_arch_name)
11263                           {
11264                             char *name = cpu_sub_arch_name;
11265                             cpu_sub_arch_name = concat (arch,
11266                                                         (const char *) NULL);
11267                             free (name);
11268                           }
11269                         else
11270                           cpu_sub_arch_name = xstrdup (arch);
11271                         cpu_arch_flags = flags;
11272                         cpu_arch_isa_flags = flags;
11273                       }
11274                     break;
11275                   }
11276
11277               if (j >= ARRAY_SIZE (cpu_noarch))
11278                 j = ARRAY_SIZE (cpu_arch);
11279             }
11280
11281           if (j >= ARRAY_SIZE (cpu_arch))
11282             as_fatal (_("invalid -march= option: `%s'"), arg);
11283
11284           arch = next;
11285         }
11286       while (next != NULL);
11287       free (saved);
11288       break;
11289
11290     case OPTION_MTUNE:
11291       if (*arg == '.')
11292         as_fatal (_("invalid -mtune= option: `%s'"), arg);
11293       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11294         {
11295           if (strcmp (arg, cpu_arch [j].name) == 0)
11296             {
11297               cpu_arch_tune_set = 1;
11298               cpu_arch_tune = cpu_arch [j].type;
11299               cpu_arch_tune_flags = cpu_arch[j].flags;
11300               break;
11301             }
11302         }
11303       if (j >= ARRAY_SIZE (cpu_arch))
11304         as_fatal (_("invalid -mtune= option: `%s'"), arg);
11305       break;
11306
11307     case OPTION_MMNEMONIC:
11308       if (strcasecmp (arg, "att") == 0)
11309         intel_mnemonic = 0;
11310       else if (strcasecmp (arg, "intel") == 0)
11311         intel_mnemonic = 1;
11312       else
11313         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
11314       break;
11315
11316     case OPTION_MSYNTAX:
11317       if (strcasecmp (arg, "att") == 0)
11318         intel_syntax = 0;
11319       else if (strcasecmp (arg, "intel") == 0)
11320         intel_syntax = 1;
11321       else
11322         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
11323       break;
11324
11325     case OPTION_MINDEX_REG:
11326       allow_index_reg = 1;
11327       break;
11328
11329     case OPTION_MNAKED_REG:
11330       allow_naked_reg = 1;
11331       break;
11332
11333     case OPTION_MSSE2AVX:
11334       sse2avx = 1;
11335       break;
11336
11337     case OPTION_MSSE_CHECK:
11338       if (strcasecmp (arg, "error") == 0)
11339         sse_check = check_error;
11340       else if (strcasecmp (arg, "warning") == 0)
11341         sse_check = check_warning;
11342       else if (strcasecmp (arg, "none") == 0)
11343         sse_check = check_none;
11344       else
11345         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
11346       break;
11347
11348     case OPTION_MOPERAND_CHECK:
11349       if (strcasecmp (arg, "error") == 0)
11350         operand_check = check_error;
11351       else if (strcasecmp (arg, "warning") == 0)
11352         operand_check = check_warning;
11353       else if (strcasecmp (arg, "none") == 0)
11354         operand_check = check_none;
11355       else
11356         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
11357       break;
11358
11359     case OPTION_MAVXSCALAR:
11360       if (strcasecmp (arg, "128") == 0)
11361         avxscalar = vex128;
11362       else if (strcasecmp (arg, "256") == 0)
11363         avxscalar = vex256;
11364       else
11365         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
11366       break;
11367
11368     case OPTION_MVEXWIG:
11369       if (strcmp (arg, "0") == 0)
11370         vexwig = evexw0;
11371       else if (strcmp (arg, "1") == 0)
11372         vexwig = evexw1;
11373       else
11374         as_fatal (_("invalid -mvexwig= option: `%s'"), arg);
11375       break;
11376
11377     case OPTION_MADD_BND_PREFIX:
11378       add_bnd_prefix = 1;
11379       break;
11380
11381     case OPTION_MEVEXLIG:
11382       if (strcmp (arg, "128") == 0)
11383         evexlig = evexl128;
11384       else if (strcmp (arg, "256") == 0)
11385         evexlig = evexl256;
11386       else  if (strcmp (arg, "512") == 0)
11387         evexlig = evexl512;
11388       else
11389         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
11390       break;
11391
11392     case OPTION_MEVEXRCIG:
11393       if (strcmp (arg, "rne") == 0)
11394         evexrcig = rne;
11395       else if (strcmp (arg, "rd") == 0)
11396         evexrcig = rd;
11397       else if (strcmp (arg, "ru") == 0)
11398         evexrcig = ru;
11399       else if (strcmp (arg, "rz") == 0)
11400         evexrcig = rz;
11401       else
11402         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
11403       break;
11404
11405     case OPTION_MEVEXWIG:
11406       if (strcmp (arg, "0") == 0)
11407         evexwig = evexw0;
11408       else if (strcmp (arg, "1") == 0)
11409         evexwig = evexw1;
11410       else
11411         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
11412       break;
11413
11414 # if defined (TE_PE) || defined (TE_PEP)
11415     case OPTION_MBIG_OBJ:
11416       use_big_obj = 1;
11417       break;
11418 #endif
11419
11420     case OPTION_MOMIT_LOCK_PREFIX:
11421       if (strcasecmp (arg, "yes") == 0)
11422         omit_lock_prefix = 1;
11423       else if (strcasecmp (arg, "no") == 0)
11424         omit_lock_prefix = 0;
11425       else
11426         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
11427       break;
11428
11429     case OPTION_MFENCE_AS_LOCK_ADD:
11430       if (strcasecmp (arg, "yes") == 0)
11431         avoid_fence = 1;
11432       else if (strcasecmp (arg, "no") == 0)
11433         avoid_fence = 0;
11434       else
11435         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
11436       break;
11437
11438     case OPTION_MRELAX_RELOCATIONS:
11439       if (strcasecmp (arg, "yes") == 0)
11440         generate_relax_relocations = 1;
11441       else if (strcasecmp (arg, "no") == 0)
11442         generate_relax_relocations = 0;
11443       else
11444         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
11445       break;
11446
11447     case OPTION_MAMD64:
11448       intel64 = 0;
11449       break;
11450
11451     case OPTION_MINTEL64:
11452       intel64 = 1;
11453       break;
11454
11455     case 'O':
11456       if (arg == NULL)
11457         {
11458           optimize = 1;
11459           /* Turn off -Os.  */
11460           optimize_for_space = 0;
11461         }
11462       else if (*arg == 's')
11463         {
11464           optimize_for_space = 1;
11465           /* Turn on all encoding optimizations.  */
11466           optimize = INT_MAX;
11467         }
11468       else
11469         {
11470           optimize = atoi (arg);
11471           /* Turn off -Os.  */
11472           optimize_for_space = 0;
11473         }
11474       break;
11475
11476     default:
11477       return 0;
11478     }
11479   return 1;
11480 }
11481
11482 #define MESSAGE_TEMPLATE \
11483 "                                                                                "
11484
11485 static char *
11486 output_message (FILE *stream, char *p, char *message, char *start,
11487                 int *left_p, const char *name, int len)
11488 {
11489   int size = sizeof (MESSAGE_TEMPLATE);
11490   int left = *left_p;
11491
11492   /* Reserve 2 spaces for ", " or ",\0" */
11493   left -= len + 2;
11494
11495   /* Check if there is any room.  */
11496   if (left >= 0)
11497     {
11498       if (p != start)
11499         {
11500           *p++ = ',';
11501           *p++ = ' ';
11502         }
11503       p = mempcpy (p, name, len);
11504     }
11505   else
11506     {
11507       /* Output the current message now and start a new one.  */
11508       *p++ = ',';
11509       *p = '\0';
11510       fprintf (stream, "%s\n", message);
11511       p = start;
11512       left = size - (start - message) - len - 2;
11513
11514       gas_assert (left >= 0);
11515
11516       p = mempcpy (p, name, len);
11517     }
11518
11519   *left_p = left;
11520   return p;
11521 }
11522
11523 static void
11524 show_arch (FILE *stream, int ext, int check)
11525 {
11526   static char message[] = MESSAGE_TEMPLATE;
11527   char *start = message + 27;
11528   char *p;
11529   int size = sizeof (MESSAGE_TEMPLATE);
11530   int left;
11531   const char *name;
11532   int len;
11533   unsigned int j;
11534
11535   p = start;
11536   left = size - (start - message);
11537   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11538     {
11539       /* Should it be skipped?  */
11540       if (cpu_arch [j].skip)
11541         continue;
11542
11543       name = cpu_arch [j].name;
11544       len = cpu_arch [j].len;
11545       if (*name == '.')
11546         {
11547           /* It is an extension.  Skip if we aren't asked to show it.  */
11548           if (ext)
11549             {
11550               name++;
11551               len--;
11552             }
11553           else
11554             continue;
11555         }
11556       else if (ext)
11557         {
11558           /* It is an processor.  Skip if we show only extension.  */
11559           continue;
11560         }
11561       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
11562         {
11563           /* It is an impossible processor - skip.  */
11564           continue;
11565         }
11566
11567       p = output_message (stream, p, message, start, &left, name, len);
11568     }
11569
11570   /* Display disabled extensions.  */
11571   if (ext)
11572     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
11573       {
11574         name = cpu_noarch [j].name;
11575         len = cpu_noarch [j].len;
11576         p = output_message (stream, p, message, start, &left, name,
11577                             len);
11578       }
11579
11580   *p = '\0';
11581   fprintf (stream, "%s\n", message);
11582 }
11583
11584 void
11585 md_show_usage (FILE *stream)
11586 {
11587 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11588   fprintf (stream, _("\
11589   -Q                      ignored\n\
11590   -V                      print assembler version number\n\
11591   -k                      ignored\n"));
11592 #endif
11593   fprintf (stream, _("\
11594   -n                      Do not optimize code alignment\n\
11595   -q                      quieten some warnings\n"));
11596 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11597   fprintf (stream, _("\
11598   -s                      ignored\n"));
11599 #endif
11600 #if defined BFD64 && (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11601                       || defined (TE_PE) || defined (TE_PEP))
11602   fprintf (stream, _("\
11603   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
11604 #endif
11605 #ifdef SVR4_COMMENT_CHARS
11606   fprintf (stream, _("\
11607   --divide                do not treat `/' as a comment character\n"));
11608 #else
11609   fprintf (stream, _("\
11610   --divide                ignored\n"));
11611 #endif
11612   fprintf (stream, _("\
11613   -march=CPU[,+EXTENSION...]\n\
11614                           generate code for CPU and EXTENSION, CPU is one of:\n"));
11615   show_arch (stream, 0, 1);
11616   fprintf (stream, _("\
11617                           EXTENSION is combination of:\n"));
11618   show_arch (stream, 1, 0);
11619   fprintf (stream, _("\
11620   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
11621   show_arch (stream, 0, 0);
11622   fprintf (stream, _("\
11623   -msse2avx               encode SSE instructions with VEX prefix\n"));
11624   fprintf (stream, _("\
11625   -msse-check=[none|error|warning] (default: warning)\n\
11626                           check SSE instructions\n"));
11627   fprintf (stream, _("\
11628   -moperand-check=[none|error|warning] (default: warning)\n\
11629                           check operand combinations for validity\n"));
11630   fprintf (stream, _("\
11631   -mavxscalar=[128|256] (default: 128)\n\
11632                           encode scalar AVX instructions with specific vector\n\
11633                            length\n"));
11634   fprintf (stream, _("\
11635   -mvexwig=[0|1] (default: 0)\n\
11636                           encode VEX instructions with specific VEX.W value\n\
11637                            for VEX.W bit ignored instructions\n"));
11638   fprintf (stream, _("\
11639   -mevexlig=[128|256|512] (default: 128)\n\
11640                           encode scalar EVEX instructions with specific vector\n\
11641                            length\n"));
11642   fprintf (stream, _("\
11643   -mevexwig=[0|1] (default: 0)\n\
11644                           encode EVEX instructions with specific EVEX.W value\n\
11645                            for EVEX.W bit ignored instructions\n"));
11646   fprintf (stream, _("\
11647   -mevexrcig=[rne|rd|ru|rz] (default: rne)\n\
11648                           encode EVEX instructions with specific EVEX.RC value\n\
11649                            for SAE-only ignored instructions\n"));
11650   fprintf (stream, _("\
11651   -mmnemonic=[att|intel] "));
11652   if (SYSV386_COMPAT)
11653     fprintf (stream, _("(default: att)\n"));
11654   else
11655     fprintf (stream, _("(default: intel)\n"));
11656   fprintf (stream, _("\
11657                           use AT&T/Intel mnemonic\n"));
11658   fprintf (stream, _("\
11659   -msyntax=[att|intel] (default: att)\n\
11660                           use AT&T/Intel syntax\n"));
11661   fprintf (stream, _("\
11662   -mindex-reg             support pseudo index registers\n"));
11663   fprintf (stream, _("\
11664   -mnaked-reg             don't require `%%' prefix for registers\n"));
11665   fprintf (stream, _("\
11666   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
11667 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11668   fprintf (stream, _("\
11669   -mshared                disable branch optimization for shared code\n"));
11670   fprintf (stream, _("\
11671   -mx86-used-note=[no|yes] "));
11672   if (DEFAULT_X86_USED_NOTE)
11673     fprintf (stream, _("(default: yes)\n"));
11674   else
11675     fprintf (stream, _("(default: no)\n"));
11676   fprintf (stream, _("\
11677                           generate x86 used ISA and feature properties\n"));
11678 #endif
11679 #if defined (TE_PE) || defined (TE_PEP)
11680   fprintf (stream, _("\
11681   -mbig-obj               generate big object files\n"));
11682 #endif
11683   fprintf (stream, _("\
11684   -momit-lock-prefix=[no|yes] (default: no)\n\
11685                           strip all lock prefixes\n"));
11686   fprintf (stream, _("\
11687   -mfence-as-lock-add=[no|yes] (default: no)\n\
11688                           encode lfence, mfence and sfence as\n\
11689                            lock addl $0x0, (%%{re}sp)\n"));
11690   fprintf (stream, _("\
11691   -mrelax-relocations=[no|yes] "));
11692   if (DEFAULT_GENERATE_X86_RELAX_RELOCATIONS)
11693     fprintf (stream, _("(default: yes)\n"));
11694   else
11695     fprintf (stream, _("(default: no)\n"));
11696   fprintf (stream, _("\
11697                           generate relax relocations\n"));
11698   fprintf (stream, _("\
11699   -mamd64                 accept only AMD64 ISA [default]\n"));
11700   fprintf (stream, _("\
11701   -mintel64               accept only Intel64 ISA\n"));
11702 }
11703
11704 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
11705      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11706      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11707
11708 /* Pick the target format to use.  */
11709
11710 const char *
11711 i386_target_format (void)
11712 {
11713   if (!strncmp (default_arch, "x86_64", 6))
11714     {
11715       update_code_flag (CODE_64BIT, 1);
11716       if (default_arch[6] == '\0')
11717         x86_elf_abi = X86_64_ABI;
11718       else
11719         x86_elf_abi = X86_64_X32_ABI;
11720     }
11721   else if (!strcmp (default_arch, "i386"))
11722     update_code_flag (CODE_32BIT, 1);
11723   else if (!strcmp (default_arch, "iamcu"))
11724     {
11725       update_code_flag (CODE_32BIT, 1);
11726       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
11727         {
11728           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
11729           cpu_arch_name = "iamcu";
11730           cpu_sub_arch_name = NULL;
11731           cpu_arch_flags = iamcu_flags;
11732           cpu_arch_isa = PROCESSOR_IAMCU;
11733           cpu_arch_isa_flags = iamcu_flags;
11734           if (!cpu_arch_tune_set)
11735             {
11736               cpu_arch_tune = cpu_arch_isa;
11737               cpu_arch_tune_flags = cpu_arch_isa_flags;
11738             }
11739         }
11740       else if (cpu_arch_isa != PROCESSOR_IAMCU)
11741         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
11742                   cpu_arch_name);
11743     }
11744   else
11745     as_fatal (_("unknown architecture"));
11746
11747   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
11748     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
11749   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
11750     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
11751
11752   switch (OUTPUT_FLAVOR)
11753     {
11754 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
11755     case bfd_target_aout_flavour:
11756       return AOUT_TARGET_FORMAT;
11757 #endif
11758 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
11759 # if defined (TE_PE) || defined (TE_PEP)
11760     case bfd_target_coff_flavour:
11761       if (flag_code == CODE_64BIT)
11762         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
11763       else
11764         return "pe-i386";
11765 # elif defined (TE_GO32)
11766     case bfd_target_coff_flavour:
11767       return "coff-go32";
11768 # else
11769     case bfd_target_coff_flavour:
11770       return "coff-i386";
11771 # endif
11772 #endif
11773 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
11774     case bfd_target_elf_flavour:
11775       {
11776         const char *format;
11777
11778         switch (x86_elf_abi)
11779           {
11780           default:
11781             format = ELF_TARGET_FORMAT;
11782             break;
11783           case X86_64_ABI:
11784             use_rela_relocations = 1;
11785             object_64bit = 1;
11786             format = ELF_TARGET_FORMAT64;
11787             break;
11788           case X86_64_X32_ABI:
11789             use_rela_relocations = 1;
11790             object_64bit = 1;
11791             disallow_64bit_reloc = 1;
11792             format = ELF_TARGET_FORMAT32;
11793             break;
11794           }
11795         if (cpu_arch_isa == PROCESSOR_L1OM)
11796           {
11797             if (x86_elf_abi != X86_64_ABI)
11798               as_fatal (_("Intel L1OM is 64bit only"));
11799             return ELF_TARGET_L1OM_FORMAT;
11800           }
11801         else if (cpu_arch_isa == PROCESSOR_K1OM)
11802           {
11803             if (x86_elf_abi != X86_64_ABI)
11804               as_fatal (_("Intel K1OM is 64bit only"));
11805             return ELF_TARGET_K1OM_FORMAT;
11806           }
11807         else if (cpu_arch_isa == PROCESSOR_IAMCU)
11808           {
11809             if (x86_elf_abi != I386_ABI)
11810               as_fatal (_("Intel MCU is 32bit only"));
11811             return ELF_TARGET_IAMCU_FORMAT;
11812           }
11813         else
11814           return format;
11815       }
11816 #endif
11817 #if defined (OBJ_MACH_O)
11818     case bfd_target_mach_o_flavour:
11819       if (flag_code == CODE_64BIT)
11820         {
11821           use_rela_relocations = 1;
11822           object_64bit = 1;
11823           return "mach-o-x86-64";
11824         }
11825       else
11826         return "mach-o-i386";
11827 #endif
11828     default:
11829       abort ();
11830       return NULL;
11831     }
11832 }
11833
11834 #endif /* OBJ_MAYBE_ more than one  */
11835 \f
11836 symbolS *
11837 md_undefined_symbol (char *name)
11838 {
11839   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
11840       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
11841       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
11842       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
11843     {
11844       if (!GOT_symbol)
11845         {
11846           if (symbol_find (name))
11847             as_bad (_("GOT already in symbol table"));
11848           GOT_symbol = symbol_new (name, undefined_section,
11849                                    (valueT) 0, &zero_address_frag);
11850         };
11851       return GOT_symbol;
11852     }
11853   return 0;
11854 }
11855
11856 /* Round up a section size to the appropriate boundary.  */
11857
11858 valueT
11859 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
11860 {
11861 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
11862   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
11863     {
11864       /* For a.out, force the section size to be aligned.  If we don't do
11865          this, BFD will align it for us, but it will not write out the
11866          final bytes of the section.  This may be a bug in BFD, but it is
11867          easier to fix it here since that is how the other a.out targets
11868          work.  */
11869       int align;
11870
11871       align = bfd_get_section_alignment (stdoutput, segment);
11872       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
11873     }
11874 #endif
11875
11876   return size;
11877 }
11878
11879 /* On the i386, PC-relative offsets are relative to the start of the
11880    next instruction.  That is, the address of the offset, plus its
11881    size, since the offset is always the last part of the insn.  */
11882
11883 long
11884 md_pcrel_from (fixS *fixP)
11885 {
11886   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
11887 }
11888
11889 #ifndef I386COFF
11890
11891 static void
11892 s_bss (int ignore ATTRIBUTE_UNUSED)
11893 {
11894   int temp;
11895
11896 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11897   if (IS_ELF)
11898     obj_elf_section_change_hook ();
11899 #endif
11900   temp = get_absolute_expression ();
11901   subseg_set (bss_section, (subsegT) temp);
11902   demand_empty_rest_of_line ();
11903 }
11904
11905 #endif
11906
11907 void
11908 i386_validate_fix (fixS *fixp)
11909 {
11910   if (fixp->fx_subsy)
11911     {
11912       if (fixp->fx_subsy == GOT_symbol)
11913         {
11914           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
11915             {
11916               if (!object_64bit)
11917                 abort ();
11918 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11919               if (fixp->fx_tcbit2)
11920                 fixp->fx_r_type = (fixp->fx_tcbit
11921                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
11922                                    : BFD_RELOC_X86_64_GOTPCRELX);
11923               else
11924 #endif
11925                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
11926             }
11927           else
11928             {
11929               if (!object_64bit)
11930                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
11931               else
11932                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
11933             }
11934           fixp->fx_subsy = 0;
11935         }
11936     }
11937 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11938   else if (!object_64bit)
11939     {
11940       if (fixp->fx_r_type == BFD_RELOC_386_GOT32
11941           && fixp->fx_tcbit2)
11942         fixp->fx_r_type = BFD_RELOC_386_GOT32X;
11943     }
11944 #endif
11945 }
11946
11947 arelent *
11948 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
11949 {
11950   arelent *rel;
11951   bfd_reloc_code_real_type code;
11952
11953   switch (fixp->fx_r_type)
11954     {
11955 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11956     case BFD_RELOC_SIZE32:
11957     case BFD_RELOC_SIZE64:
11958       if (S_IS_DEFINED (fixp->fx_addsy)
11959           && !S_IS_EXTERNAL (fixp->fx_addsy))
11960         {
11961           /* Resolve size relocation against local symbol to size of
11962              the symbol plus addend.  */
11963           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
11964           if (fixp->fx_r_type == BFD_RELOC_SIZE32
11965               && !fits_in_unsigned_long (value))
11966             as_bad_where (fixp->fx_file, fixp->fx_line,
11967                           _("symbol size computation overflow"));
11968           fixp->fx_addsy = NULL;
11969           fixp->fx_subsy = NULL;
11970           md_apply_fix (fixp, (valueT *) &value, NULL);
11971           return NULL;
11972         }
11973 #endif
11974       /* Fall through.  */
11975
11976     case BFD_RELOC_X86_64_PLT32:
11977     case BFD_RELOC_X86_64_GOT32:
11978     case BFD_RELOC_X86_64_GOTPCREL:
11979     case BFD_RELOC_X86_64_GOTPCRELX:
11980     case BFD_RELOC_X86_64_REX_GOTPCRELX:
11981     case BFD_RELOC_386_PLT32:
11982     case BFD_RELOC_386_GOT32:
11983     case BFD_RELOC_386_GOT32X:
11984     case BFD_RELOC_386_GOTOFF:
11985     case BFD_RELOC_386_GOTPC:
11986     case BFD_RELOC_386_TLS_GD:
11987     case BFD_RELOC_386_TLS_LDM:
11988     case BFD_RELOC_386_TLS_LDO_32:
11989     case BFD_RELOC_386_TLS_IE_32:
11990     case BFD_RELOC_386_TLS_IE:
11991     case BFD_RELOC_386_TLS_GOTIE:
11992     case BFD_RELOC_386_TLS_LE_32:
11993     case BFD_RELOC_386_TLS_LE:
11994     case BFD_RELOC_386_TLS_GOTDESC:
11995     case BFD_RELOC_386_TLS_DESC_CALL:
11996     case BFD_RELOC_X86_64_TLSGD:
11997     case BFD_RELOC_X86_64_TLSLD:
11998     case BFD_RELOC_X86_64_DTPOFF32:
11999     case BFD_RELOC_X86_64_DTPOFF64:
12000     case BFD_RELOC_X86_64_GOTTPOFF:
12001     case BFD_RELOC_X86_64_TPOFF32:
12002     case BFD_RELOC_X86_64_TPOFF64:
12003     case BFD_RELOC_X86_64_GOTOFF64:
12004     case BFD_RELOC_X86_64_GOTPC32:
12005     case BFD_RELOC_X86_64_GOT64:
12006     case BFD_RELOC_X86_64_GOTPCREL64:
12007     case BFD_RELOC_X86_64_GOTPC64:
12008     case BFD_RELOC_X86_64_GOTPLT64:
12009     case BFD_RELOC_X86_64_PLTOFF64:
12010     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12011     case BFD_RELOC_X86_64_TLSDESC_CALL:
12012     case BFD_RELOC_RVA:
12013     case BFD_RELOC_VTABLE_ENTRY:
12014     case BFD_RELOC_VTABLE_INHERIT:
12015 #ifdef TE_PE
12016     case BFD_RELOC_32_SECREL:
12017 #endif
12018       code = fixp->fx_r_type;
12019       break;
12020     case BFD_RELOC_X86_64_32S:
12021       if (!fixp->fx_pcrel)
12022         {
12023           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
12024           code = fixp->fx_r_type;
12025           break;
12026         }
12027       /* Fall through.  */
12028     default:
12029       if (fixp->fx_pcrel)
12030         {
12031           switch (fixp->fx_size)
12032             {
12033             default:
12034               as_bad_where (fixp->fx_file, fixp->fx_line,
12035                             _("can not do %d byte pc-relative relocation"),
12036                             fixp->fx_size);
12037               code = BFD_RELOC_32_PCREL;
12038               break;
12039             case 1: code = BFD_RELOC_8_PCREL;  break;
12040             case 2: code = BFD_RELOC_16_PCREL; break;
12041             case 4: code = BFD_RELOC_32_PCREL; break;
12042 #ifdef BFD64
12043             case 8: code = BFD_RELOC_64_PCREL; break;
12044 #endif
12045             }
12046         }
12047       else
12048         {
12049           switch (fixp->fx_size)
12050             {
12051             default:
12052               as_bad_where (fixp->fx_file, fixp->fx_line,
12053                             _("can not do %d byte relocation"),
12054                             fixp->fx_size);
12055               code = BFD_RELOC_32;
12056               break;
12057             case 1: code = BFD_RELOC_8;  break;
12058             case 2: code = BFD_RELOC_16; break;
12059             case 4: code = BFD_RELOC_32; break;
12060 #ifdef BFD64
12061             case 8: code = BFD_RELOC_64; break;
12062 #endif
12063             }
12064         }
12065       break;
12066     }
12067
12068   if ((code == BFD_RELOC_32
12069        || code == BFD_RELOC_32_PCREL
12070        || code == BFD_RELOC_X86_64_32S)
12071       && GOT_symbol
12072       && fixp->fx_addsy == GOT_symbol)
12073     {
12074       if (!object_64bit)
12075         code = BFD_RELOC_386_GOTPC;
12076       else
12077         code = BFD_RELOC_X86_64_GOTPC32;
12078     }
12079   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
12080       && GOT_symbol
12081       && fixp->fx_addsy == GOT_symbol)
12082     {
12083       code = BFD_RELOC_X86_64_GOTPC64;
12084     }
12085
12086   rel = XNEW (arelent);
12087   rel->sym_ptr_ptr = XNEW (asymbol *);
12088   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
12089
12090   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
12091
12092   if (!use_rela_relocations)
12093     {
12094       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
12095          vtable entry to be used in the relocation's section offset.  */
12096       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
12097         rel->address = fixp->fx_offset;
12098 #if defined (OBJ_COFF) && defined (TE_PE)
12099       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
12100         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
12101       else
12102 #endif
12103       rel->addend = 0;
12104     }
12105   /* Use the rela in 64bit mode.  */
12106   else
12107     {
12108       if (disallow_64bit_reloc)
12109         switch (code)
12110           {
12111           case BFD_RELOC_X86_64_DTPOFF64:
12112           case BFD_RELOC_X86_64_TPOFF64:
12113           case BFD_RELOC_64_PCREL:
12114           case BFD_RELOC_X86_64_GOTOFF64:
12115           case BFD_RELOC_X86_64_GOT64:
12116           case BFD_RELOC_X86_64_GOTPCREL64:
12117           case BFD_RELOC_X86_64_GOTPC64:
12118           case BFD_RELOC_X86_64_GOTPLT64:
12119           case BFD_RELOC_X86_64_PLTOFF64:
12120             as_bad_where (fixp->fx_file, fixp->fx_line,
12121                           _("cannot represent relocation type %s in x32 mode"),
12122                           bfd_get_reloc_code_name (code));
12123             break;
12124           default:
12125             break;
12126           }
12127
12128       if (!fixp->fx_pcrel)
12129         rel->addend = fixp->fx_offset;
12130       else
12131         switch (code)
12132           {
12133           case BFD_RELOC_X86_64_PLT32:
12134           case BFD_RELOC_X86_64_GOT32:
12135           case BFD_RELOC_X86_64_GOTPCREL:
12136           case BFD_RELOC_X86_64_GOTPCRELX:
12137           case BFD_RELOC_X86_64_REX_GOTPCRELX:
12138           case BFD_RELOC_X86_64_TLSGD:
12139           case BFD_RELOC_X86_64_TLSLD:
12140           case BFD_RELOC_X86_64_GOTTPOFF:
12141           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12142           case BFD_RELOC_X86_64_TLSDESC_CALL:
12143             rel->addend = fixp->fx_offset - fixp->fx_size;
12144             break;
12145           default:
12146             rel->addend = (section->vma
12147                            - fixp->fx_size
12148                            + fixp->fx_addnumber
12149                            + md_pcrel_from (fixp));
12150             break;
12151           }
12152     }
12153
12154   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
12155   if (rel->howto == NULL)
12156     {
12157       as_bad_where (fixp->fx_file, fixp->fx_line,
12158                     _("cannot represent relocation type %s"),
12159                     bfd_get_reloc_code_name (code));
12160       /* Set howto to a garbage value so that we can keep going.  */
12161       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
12162       gas_assert (rel->howto != NULL);
12163     }
12164
12165   return rel;
12166 }
12167
12168 #include "tc-i386-intel.c"
12169
12170 void
12171 tc_x86_parse_to_dw2regnum (expressionS *exp)
12172 {
12173   int saved_naked_reg;
12174   char saved_register_dot;
12175
12176   saved_naked_reg = allow_naked_reg;
12177   allow_naked_reg = 1;
12178   saved_register_dot = register_chars['.'];
12179   register_chars['.'] = '.';
12180   allow_pseudo_reg = 1;
12181   expression_and_evaluate (exp);
12182   allow_pseudo_reg = 0;
12183   register_chars['.'] = saved_register_dot;
12184   allow_naked_reg = saved_naked_reg;
12185
12186   if (exp->X_op == O_register && exp->X_add_number >= 0)
12187     {
12188       if ((addressT) exp->X_add_number < i386_regtab_size)
12189         {
12190           exp->X_op = O_constant;
12191           exp->X_add_number = i386_regtab[exp->X_add_number]
12192                               .dw2_regnum[flag_code >> 1];
12193         }
12194       else
12195         exp->X_op = O_illegal;
12196     }
12197 }
12198
12199 void
12200 tc_x86_frame_initial_instructions (void)
12201 {
12202   static unsigned int sp_regno[2];
12203
12204   if (!sp_regno[flag_code >> 1])
12205     {
12206       char *saved_input = input_line_pointer;
12207       char sp[][4] = {"esp", "rsp"};
12208       expressionS exp;
12209
12210       input_line_pointer = sp[flag_code >> 1];
12211       tc_x86_parse_to_dw2regnum (&exp);
12212       gas_assert (exp.X_op == O_constant);
12213       sp_regno[flag_code >> 1] = exp.X_add_number;
12214       input_line_pointer = saved_input;
12215     }
12216
12217   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
12218   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
12219 }
12220
12221 int
12222 x86_dwarf2_addr_size (void)
12223 {
12224 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
12225   if (x86_elf_abi == X86_64_X32_ABI)
12226     return 4;
12227 #endif
12228   return bfd_arch_bits_per_address (stdoutput) / 8;
12229 }
12230
12231 int
12232 i386_elf_section_type (const char *str, size_t len)
12233 {
12234   if (flag_code == CODE_64BIT
12235       && len == sizeof ("unwind") - 1
12236       && strncmp (str, "unwind", 6) == 0)
12237     return SHT_X86_64_UNWIND;
12238
12239   return -1;
12240 }
12241
12242 #ifdef TE_SOLARIS
12243 void
12244 i386_solaris_fix_up_eh_frame (segT sec)
12245 {
12246   if (flag_code == CODE_64BIT)
12247     elf_section_type (sec) = SHT_X86_64_UNWIND;
12248 }
12249 #endif
12250
12251 #ifdef TE_PE
12252 void
12253 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
12254 {
12255   expressionS exp;
12256
12257   exp.X_op = O_secrel;
12258   exp.X_add_symbol = symbol;
12259   exp.X_add_number = 0;
12260   emit_expr (&exp, size);
12261 }
12262 #endif
12263
12264 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12265 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
12266
12267 bfd_vma
12268 x86_64_section_letter (int letter, const char **ptr_msg)
12269 {
12270   if (flag_code == CODE_64BIT)
12271     {
12272       if (letter == 'l')
12273         return SHF_X86_64_LARGE;
12274
12275       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
12276     }
12277   else
12278     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
12279   return -1;
12280 }
12281
12282 bfd_vma
12283 x86_64_section_word (char *str, size_t len)
12284 {
12285   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
12286     return SHF_X86_64_LARGE;
12287
12288   return -1;
12289 }
12290
12291 static void
12292 handle_large_common (int small ATTRIBUTE_UNUSED)
12293 {
12294   if (flag_code != CODE_64BIT)
12295     {
12296       s_comm_internal (0, elf_common_parse);
12297       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
12298     }
12299   else
12300     {
12301       static segT lbss_section;
12302       asection *saved_com_section_ptr = elf_com_section_ptr;
12303       asection *saved_bss_section = bss_section;
12304
12305       if (lbss_section == NULL)
12306         {
12307           flagword applicable;
12308           segT seg = now_seg;
12309           subsegT subseg = now_subseg;
12310
12311           /* The .lbss section is for local .largecomm symbols.  */
12312           lbss_section = subseg_new (".lbss", 0);
12313           applicable = bfd_applicable_section_flags (stdoutput);
12314           bfd_set_section_flags (stdoutput, lbss_section,
12315                                  applicable & SEC_ALLOC);
12316           seg_info (lbss_section)->bss = 1;
12317
12318           subseg_set (seg, subseg);
12319         }
12320
12321       elf_com_section_ptr = &_bfd_elf_large_com_section;
12322       bss_section = lbss_section;
12323
12324       s_comm_internal (0, elf_common_parse);
12325
12326       elf_com_section_ptr = saved_com_section_ptr;
12327       bss_section = saved_bss_section;
12328     }
12329 }
12330 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */