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                && !is_any_vex_encoding (&i.tm)
6390                && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
6391                    || (flag_code == CODE_64BIT
6392                        && i.tm.opcode_modifier.jumpbyte)))
6393         {
6394           unsigned int prefix = DATA_PREFIX_OPCODE;
6395
6396           if (i.tm.opcode_modifier.jumpbyte) /* jcxz, loop */
6397             prefix = ADDR_PREFIX_OPCODE;
6398
6399           if (!add_prefix (prefix))
6400             return 0;
6401         }
6402
6403       /* Set mode64 for an operand.  */
6404       if (i.suffix == QWORD_MNEM_SUFFIX
6405           && flag_code == CODE_64BIT
6406           && !i.tm.opcode_modifier.norex64
6407           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
6408              need rex64. */
6409           && ! (i.operands == 2
6410                 && i.tm.base_opcode == 0x90
6411                 && i.tm.extension_opcode == None
6412                 && operand_type_equal (&i.types [0], &acc64)
6413                 && operand_type_equal (&i.types [1], &acc64)))
6414         i.rex |= REX_W;
6415
6416       break;
6417     }
6418
6419   if (i.reg_operands != 0
6420       && i.operands > 1
6421       && i.tm.opcode_modifier.addrprefixopreg
6422       && !i.tm.opcode_modifier.immext)
6423     {
6424       /* Check invalid register operand when the address size override
6425          prefix changes the size of register operands.  */
6426       unsigned int op;
6427       enum { need_word, need_dword, need_qword } need;
6428
6429       if (flag_code == CODE_32BIT)
6430         need = i.prefix[ADDR_PREFIX] ? need_word : need_dword;
6431       else
6432         {
6433           if (i.prefix[ADDR_PREFIX])
6434             need = need_dword;
6435           else
6436             need = flag_code == CODE_64BIT ? need_qword : need_word;
6437         }
6438
6439       for (op = 0; op < i.operands; op++)
6440         if (i.types[op].bitfield.reg
6441             && ((need == need_word
6442                  && !i.op[op].regs->reg_type.bitfield.word)
6443                 || (need == need_dword
6444                     && !i.op[op].regs->reg_type.bitfield.dword)
6445                 || (need == need_qword
6446                     && !i.op[op].regs->reg_type.bitfield.qword)))
6447           {
6448             as_bad (_("invalid register operand size for `%s'"),
6449                     i.tm.name);
6450             return 0;
6451           }
6452     }
6453
6454   return 1;
6455 }
6456
6457 static int
6458 check_byte_reg (void)
6459 {
6460   int op;
6461
6462   for (op = i.operands; --op >= 0;)
6463     {
6464       /* Skip non-register operands. */
6465       if (!i.types[op].bitfield.reg)
6466         continue;
6467
6468       /* If this is an eight bit register, it's OK.  If it's the 16 or
6469          32 bit version of an eight bit register, we will just use the
6470          low portion, and that's OK too.  */
6471       if (i.types[op].bitfield.byte)
6472         continue;
6473
6474       /* I/O port address operands are OK too.  */
6475       if (i.tm.operand_types[op].bitfield.inoutportreg)
6476         continue;
6477
6478       /* crc32 doesn't generate this warning.  */
6479       if (i.tm.base_opcode == 0xf20f38f0)
6480         continue;
6481
6482       if ((i.types[op].bitfield.word
6483            || i.types[op].bitfield.dword
6484            || i.types[op].bitfield.qword)
6485           && i.op[op].regs->reg_num < 4
6486           /* Prohibit these changes in 64bit mode, since the lowering
6487              would be more complicated.  */
6488           && flag_code != CODE_64BIT)
6489         {
6490 #if REGISTER_WARNINGS
6491           if (!quiet_warnings)
6492             as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6493                      register_prefix,
6494                      (i.op[op].regs + (i.types[op].bitfield.word
6495                                        ? REGNAM_AL - REGNAM_AX
6496                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
6497                      register_prefix,
6498                      i.op[op].regs->reg_name,
6499                      i.suffix);
6500 #endif
6501           continue;
6502         }
6503       /* Any other register is bad.  */
6504       if (i.types[op].bitfield.reg
6505           || i.types[op].bitfield.regmmx
6506           || i.types[op].bitfield.regsimd
6507           || i.types[op].bitfield.sreg2
6508           || i.types[op].bitfield.sreg3
6509           || i.types[op].bitfield.control
6510           || i.types[op].bitfield.debug
6511           || i.types[op].bitfield.test)
6512         {
6513           as_bad (_("`%s%s' not allowed with `%s%c'"),
6514                   register_prefix,
6515                   i.op[op].regs->reg_name,
6516                   i.tm.name,
6517                   i.suffix);
6518           return 0;
6519         }
6520     }
6521   return 1;
6522 }
6523
6524 static int
6525 check_long_reg (void)
6526 {
6527   int op;
6528
6529   for (op = i.operands; --op >= 0;)
6530     /* Skip non-register operands. */
6531     if (!i.types[op].bitfield.reg)
6532       continue;
6533     /* Reject eight bit registers, except where the template requires
6534        them. (eg. movzb)  */
6535     else if (i.types[op].bitfield.byte
6536              && (i.tm.operand_types[op].bitfield.reg
6537                  || i.tm.operand_types[op].bitfield.acc)
6538              && (i.tm.operand_types[op].bitfield.word
6539                  || i.tm.operand_types[op].bitfield.dword))
6540       {
6541         as_bad (_("`%s%s' not allowed with `%s%c'"),
6542                 register_prefix,
6543                 i.op[op].regs->reg_name,
6544                 i.tm.name,
6545                 i.suffix);
6546         return 0;
6547       }
6548     /* Warn if the e prefix on a general reg is missing.  */
6549     else if ((!quiet_warnings || flag_code == CODE_64BIT)
6550              && i.types[op].bitfield.word
6551              && (i.tm.operand_types[op].bitfield.reg
6552                  || i.tm.operand_types[op].bitfield.acc)
6553              && i.tm.operand_types[op].bitfield.dword)
6554       {
6555         /* Prohibit these changes in the 64bit mode, since the
6556            lowering is more complicated.  */
6557         if (flag_code == CODE_64BIT)
6558           {
6559             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6560                     register_prefix, i.op[op].regs->reg_name,
6561                     i.suffix);
6562             return 0;
6563           }
6564 #if REGISTER_WARNINGS
6565         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6566                  register_prefix,
6567                  (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
6568                  register_prefix, i.op[op].regs->reg_name, i.suffix);
6569 #endif
6570       }
6571     /* Warn if the r prefix on a general reg is present.  */
6572     else if (i.types[op].bitfield.qword
6573              && (i.tm.operand_types[op].bitfield.reg
6574                  || i.tm.operand_types[op].bitfield.acc)
6575              && i.tm.operand_types[op].bitfield.dword)
6576       {
6577         if (intel_syntax
6578             && i.tm.opcode_modifier.toqword
6579             && !i.types[0].bitfield.regsimd)
6580           {
6581             /* Convert to QWORD.  We want REX byte. */
6582             i.suffix = QWORD_MNEM_SUFFIX;
6583           }
6584         else
6585           {
6586             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6587                     register_prefix, i.op[op].regs->reg_name,
6588                     i.suffix);
6589             return 0;
6590           }
6591       }
6592   return 1;
6593 }
6594
6595 static int
6596 check_qword_reg (void)
6597 {
6598   int op;
6599
6600   for (op = i.operands; --op >= 0; )
6601     /* Skip non-register operands. */
6602     if (!i.types[op].bitfield.reg)
6603       continue;
6604     /* Reject eight bit registers, except where the template requires
6605        them. (eg. movzb)  */
6606     else if (i.types[op].bitfield.byte
6607              && (i.tm.operand_types[op].bitfield.reg
6608                  || i.tm.operand_types[op].bitfield.acc)
6609              && (i.tm.operand_types[op].bitfield.word
6610                  || i.tm.operand_types[op].bitfield.dword))
6611       {
6612         as_bad (_("`%s%s' not allowed with `%s%c'"),
6613                 register_prefix,
6614                 i.op[op].regs->reg_name,
6615                 i.tm.name,
6616                 i.suffix);
6617         return 0;
6618       }
6619     /* Warn if the r prefix on a general reg is missing.  */
6620     else if ((i.types[op].bitfield.word
6621               || i.types[op].bitfield.dword)
6622              && (i.tm.operand_types[op].bitfield.reg
6623                  || i.tm.operand_types[op].bitfield.acc)
6624              && i.tm.operand_types[op].bitfield.qword)
6625       {
6626         /* Prohibit these changes in the 64bit mode, since the
6627            lowering is more complicated.  */
6628         if (intel_syntax
6629             && i.tm.opcode_modifier.todword
6630             && !i.types[0].bitfield.regsimd)
6631           {
6632             /* Convert to DWORD.  We don't want REX byte. */
6633             i.suffix = LONG_MNEM_SUFFIX;
6634           }
6635         else
6636           {
6637             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6638                     register_prefix, i.op[op].regs->reg_name,
6639                     i.suffix);
6640             return 0;
6641           }
6642       }
6643   return 1;
6644 }
6645
6646 static int
6647 check_word_reg (void)
6648 {
6649   int op;
6650   for (op = i.operands; --op >= 0;)
6651     /* Skip non-register operands. */
6652     if (!i.types[op].bitfield.reg)
6653       continue;
6654     /* Reject eight bit registers, except where the template requires
6655        them. (eg. movzb)  */
6656     else if (i.types[op].bitfield.byte
6657              && (i.tm.operand_types[op].bitfield.reg
6658                  || i.tm.operand_types[op].bitfield.acc)
6659              && (i.tm.operand_types[op].bitfield.word
6660                  || i.tm.operand_types[op].bitfield.dword))
6661       {
6662         as_bad (_("`%s%s' not allowed with `%s%c'"),
6663                 register_prefix,
6664                 i.op[op].regs->reg_name,
6665                 i.tm.name,
6666                 i.suffix);
6667         return 0;
6668       }
6669     /* Warn if the e or r prefix on a general reg is present.  */
6670     else if ((!quiet_warnings || flag_code == CODE_64BIT)
6671              && (i.types[op].bitfield.dword
6672                  || i.types[op].bitfield.qword)
6673              && (i.tm.operand_types[op].bitfield.reg
6674                  || i.tm.operand_types[op].bitfield.acc)
6675              && i.tm.operand_types[op].bitfield.word)
6676       {
6677         /* Prohibit these changes in the 64bit mode, since the
6678            lowering is more complicated.  */
6679         if (flag_code == CODE_64BIT)
6680           {
6681             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6682                     register_prefix, i.op[op].regs->reg_name,
6683                     i.suffix);
6684             return 0;
6685           }
6686 #if REGISTER_WARNINGS
6687         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6688                  register_prefix,
6689                  (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
6690                  register_prefix, i.op[op].regs->reg_name, i.suffix);
6691 #endif
6692       }
6693   return 1;
6694 }
6695
6696 static int
6697 update_imm (unsigned int j)
6698 {
6699   i386_operand_type overlap = i.types[j];
6700   if ((overlap.bitfield.imm8
6701        || overlap.bitfield.imm8s
6702        || overlap.bitfield.imm16
6703        || overlap.bitfield.imm32
6704        || overlap.bitfield.imm32s
6705        || overlap.bitfield.imm64)
6706       && !operand_type_equal (&overlap, &imm8)
6707       && !operand_type_equal (&overlap, &imm8s)
6708       && !operand_type_equal (&overlap, &imm16)
6709       && !operand_type_equal (&overlap, &imm32)
6710       && !operand_type_equal (&overlap, &imm32s)
6711       && !operand_type_equal (&overlap, &imm64))
6712     {
6713       if (i.suffix)
6714         {
6715           i386_operand_type temp;
6716
6717           operand_type_set (&temp, 0);
6718           if (i.suffix == BYTE_MNEM_SUFFIX)
6719             {
6720               temp.bitfield.imm8 = overlap.bitfield.imm8;
6721               temp.bitfield.imm8s = overlap.bitfield.imm8s;
6722             }
6723           else if (i.suffix == WORD_MNEM_SUFFIX)
6724             temp.bitfield.imm16 = overlap.bitfield.imm16;
6725           else if (i.suffix == QWORD_MNEM_SUFFIX)
6726             {
6727               temp.bitfield.imm64 = overlap.bitfield.imm64;
6728               temp.bitfield.imm32s = overlap.bitfield.imm32s;
6729             }
6730           else
6731             temp.bitfield.imm32 = overlap.bitfield.imm32;
6732           overlap = temp;
6733         }
6734       else if (operand_type_equal (&overlap, &imm16_32_32s)
6735                || operand_type_equal (&overlap, &imm16_32)
6736                || operand_type_equal (&overlap, &imm16_32s))
6737         {
6738           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
6739             overlap = imm16;
6740           else
6741             overlap = imm32s;
6742         }
6743       if (!operand_type_equal (&overlap, &imm8)
6744           && !operand_type_equal (&overlap, &imm8s)
6745           && !operand_type_equal (&overlap, &imm16)
6746           && !operand_type_equal (&overlap, &imm32)
6747           && !operand_type_equal (&overlap, &imm32s)
6748           && !operand_type_equal (&overlap, &imm64))
6749         {
6750           as_bad (_("no instruction mnemonic suffix given; "
6751                     "can't determine immediate size"));
6752           return 0;
6753         }
6754     }
6755   i.types[j] = overlap;
6756
6757   return 1;
6758 }
6759
6760 static int
6761 finalize_imm (void)
6762 {
6763   unsigned int j, n;
6764
6765   /* Update the first 2 immediate operands.  */
6766   n = i.operands > 2 ? 2 : i.operands;
6767   if (n)
6768     {
6769       for (j = 0; j < n; j++)
6770         if (update_imm (j) == 0)
6771           return 0;
6772
6773       /* The 3rd operand can't be immediate operand.  */
6774       gas_assert (operand_type_check (i.types[2], imm) == 0);
6775     }
6776
6777   return 1;
6778 }
6779
6780 static int
6781 process_operands (void)
6782 {
6783   /* Default segment register this instruction will use for memory
6784      accesses.  0 means unknown.  This is only for optimizing out
6785      unnecessary segment overrides.  */
6786   const seg_entry *default_seg = 0;
6787
6788   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
6789     {
6790       unsigned int dupl = i.operands;
6791       unsigned int dest = dupl - 1;
6792       unsigned int j;
6793
6794       /* The destination must be an xmm register.  */
6795       gas_assert (i.reg_operands
6796                   && MAX_OPERANDS > dupl
6797                   && operand_type_equal (&i.types[dest], &regxmm));
6798
6799       if (i.tm.operand_types[0].bitfield.acc
6800           && i.tm.operand_types[0].bitfield.xmmword)
6801         {
6802           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
6803             {
6804               /* Keep xmm0 for instructions with VEX prefix and 3
6805                  sources.  */
6806               i.tm.operand_types[0].bitfield.acc = 0;
6807               i.tm.operand_types[0].bitfield.regsimd = 1;
6808               goto duplicate;
6809             }
6810           else
6811             {
6812               /* We remove the first xmm0 and keep the number of
6813                  operands unchanged, which in fact duplicates the
6814                  destination.  */
6815               for (j = 1; j < i.operands; j++)
6816                 {
6817                   i.op[j - 1] = i.op[j];
6818                   i.types[j - 1] = i.types[j];
6819                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
6820                 }
6821             }
6822         }
6823       else if (i.tm.opcode_modifier.implicit1stxmm0)
6824         {
6825           gas_assert ((MAX_OPERANDS - 1) > dupl
6826                       && (i.tm.opcode_modifier.vexsources
6827                           == VEX3SOURCES));
6828
6829           /* Add the implicit xmm0 for instructions with VEX prefix
6830              and 3 sources.  */
6831           for (j = i.operands; j > 0; j--)
6832             {
6833               i.op[j] = i.op[j - 1];
6834               i.types[j] = i.types[j - 1];
6835               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
6836             }
6837           i.op[0].regs
6838             = (const reg_entry *) hash_find (reg_hash, "xmm0");
6839           i.types[0] = regxmm;
6840           i.tm.operand_types[0] = regxmm;
6841
6842           i.operands += 2;
6843           i.reg_operands += 2;
6844           i.tm.operands += 2;
6845
6846           dupl++;
6847           dest++;
6848           i.op[dupl] = i.op[dest];
6849           i.types[dupl] = i.types[dest];
6850           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6851         }
6852       else
6853         {
6854 duplicate:
6855           i.operands++;
6856           i.reg_operands++;
6857           i.tm.operands++;
6858
6859           i.op[dupl] = i.op[dest];
6860           i.types[dupl] = i.types[dest];
6861           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6862         }
6863
6864        if (i.tm.opcode_modifier.immext)
6865          process_immext ();
6866     }
6867   else if (i.tm.operand_types[0].bitfield.acc
6868            && i.tm.operand_types[0].bitfield.xmmword)
6869     {
6870       unsigned int j;
6871
6872       for (j = 1; j < i.operands; j++)
6873         {
6874           i.op[j - 1] = i.op[j];
6875           i.types[j - 1] = i.types[j];
6876
6877           /* We need to adjust fields in i.tm since they are used by
6878              build_modrm_byte.  */
6879           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
6880         }
6881
6882       i.operands--;
6883       i.reg_operands--;
6884       i.tm.operands--;
6885     }
6886   else if (i.tm.opcode_modifier.implicitquadgroup)
6887     {
6888       unsigned int regnum, first_reg_in_group, last_reg_in_group;
6889
6890       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
6891       gas_assert (i.operands >= 2 && i.types[1].bitfield.regsimd);
6892       regnum = register_number (i.op[1].regs);
6893       first_reg_in_group = regnum & ~3;
6894       last_reg_in_group = first_reg_in_group + 3;
6895       if (regnum != first_reg_in_group)
6896         as_warn (_("source register `%s%s' implicitly denotes"
6897                    " `%s%.3s%u' to `%s%.3s%u' source group in `%s'"),
6898                  register_prefix, i.op[1].regs->reg_name,
6899                  register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
6900                  register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
6901                  i.tm.name);
6902     }
6903   else if (i.tm.opcode_modifier.regkludge)
6904     {
6905       /* The imul $imm, %reg instruction is converted into
6906          imul $imm, %reg, %reg, and the clr %reg instruction
6907          is converted into xor %reg, %reg.  */
6908
6909       unsigned int first_reg_op;
6910
6911       if (operand_type_check (i.types[0], reg))
6912         first_reg_op = 0;
6913       else
6914         first_reg_op = 1;
6915       /* Pretend we saw the extra register operand.  */
6916       gas_assert (i.reg_operands == 1
6917                   && i.op[first_reg_op + 1].regs == 0);
6918       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
6919       i.types[first_reg_op + 1] = i.types[first_reg_op];
6920       i.operands++;
6921       i.reg_operands++;
6922     }
6923
6924   if (i.tm.opcode_modifier.shortform)
6925     {
6926       if (i.types[0].bitfield.sreg2
6927           || i.types[0].bitfield.sreg3)
6928         {
6929           if (i.tm.base_opcode == POP_SEG_SHORT
6930               && i.op[0].regs->reg_num == 1)
6931             {
6932               as_bad (_("you can't `pop %scs'"), register_prefix);
6933               return 0;
6934             }
6935           i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
6936           if ((i.op[0].regs->reg_flags & RegRex) != 0)
6937             i.rex |= REX_B;
6938         }
6939       else
6940         {
6941           /* The register or float register operand is in operand
6942              0 or 1.  */
6943           unsigned int op;
6944
6945           if ((i.types[0].bitfield.reg && i.types[0].bitfield.tbyte)
6946               || operand_type_check (i.types[0], reg))
6947             op = 0;
6948           else
6949             op = 1;
6950           /* Register goes in low 3 bits of opcode.  */
6951           i.tm.base_opcode |= i.op[op].regs->reg_num;
6952           if ((i.op[op].regs->reg_flags & RegRex) != 0)
6953             i.rex |= REX_B;
6954           if (!quiet_warnings && i.tm.opcode_modifier.ugh)
6955             {
6956               /* Warn about some common errors, but press on regardless.
6957                  The first case can be generated by gcc (<= 2.8.1).  */
6958               if (i.operands == 2)
6959                 {
6960                   /* Reversed arguments on faddp, fsubp, etc.  */
6961                   as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
6962                            register_prefix, i.op[!intel_syntax].regs->reg_name,
6963                            register_prefix, i.op[intel_syntax].regs->reg_name);
6964                 }
6965               else
6966                 {
6967                   /* Extraneous `l' suffix on fp insn.  */
6968                   as_warn (_("translating to `%s %s%s'"), i.tm.name,
6969                            register_prefix, i.op[0].regs->reg_name);
6970                 }
6971             }
6972         }
6973     }
6974   else if (i.tm.opcode_modifier.modrm)
6975     {
6976       /* The opcode is completed (modulo i.tm.extension_opcode which
6977          must be put into the modrm byte).  Now, we make the modrm and
6978          index base bytes based on all the info we've collected.  */
6979
6980       default_seg = build_modrm_byte ();
6981     }
6982   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
6983     {
6984       default_seg = &ds;
6985     }
6986   else if (i.tm.opcode_modifier.isstring)
6987     {
6988       /* For the string instructions that allow a segment override
6989          on one of their operands, the default segment is ds.  */
6990       default_seg = &ds;
6991     }
6992
6993   if (i.tm.base_opcode == 0x8d /* lea */
6994       && i.seg[0]
6995       && !quiet_warnings)
6996     as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
6997
6998   /* If a segment was explicitly specified, and the specified segment
6999      is not the default, use an opcode prefix to select it.  If we
7000      never figured out what the default segment is, then default_seg
7001      will be zero at this point, and the specified segment prefix will
7002      always be used.  */
7003   if ((i.seg[0]) && (i.seg[0] != default_seg))
7004     {
7005       if (!add_prefix (i.seg[0]->seg_prefix))
7006         return 0;
7007     }
7008   return 1;
7009 }
7010
7011 static const seg_entry *
7012 build_modrm_byte (void)
7013 {
7014   const seg_entry *default_seg = 0;
7015   unsigned int source, dest;
7016   int vex_3_sources;
7017
7018   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
7019   if (vex_3_sources)
7020     {
7021       unsigned int nds, reg_slot;
7022       expressionS *exp;
7023
7024       dest = i.operands - 1;
7025       nds = dest - 1;
7026
7027       /* There are 2 kinds of instructions:
7028          1. 5 operands: 4 register operands or 3 register operands
7029          plus 1 memory operand plus one Vec_Imm4 operand, VexXDS, and
7030          VexW0 or VexW1.  The destination must be either XMM, YMM or
7031          ZMM register.
7032          2. 4 operands: 4 register operands or 3 register operands
7033          plus 1 memory operand, with VexXDS.  */
7034       gas_assert ((i.reg_operands == 4
7035                    || (i.reg_operands == 3 && i.mem_operands == 1))
7036                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
7037                   && i.tm.opcode_modifier.vexw
7038                   && i.tm.operand_types[dest].bitfield.regsimd);
7039
7040       /* If VexW1 is set, the first non-immediate operand is the source and
7041          the second non-immediate one is encoded in the immediate operand.  */
7042       if (i.tm.opcode_modifier.vexw == VEXW1)
7043         {
7044           source = i.imm_operands;
7045           reg_slot = i.imm_operands + 1;
7046         }
7047       else
7048         {
7049           source = i.imm_operands + 1;
7050           reg_slot = i.imm_operands;
7051         }
7052
7053       if (i.imm_operands == 0)
7054         {
7055           /* When there is no immediate operand, generate an 8bit
7056              immediate operand to encode the first operand.  */
7057           exp = &im_expressions[i.imm_operands++];
7058           i.op[i.operands].imms = exp;
7059           i.types[i.operands] = imm8;
7060           i.operands++;
7061
7062           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
7063           exp->X_op = O_constant;
7064           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
7065           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7066         }
7067       else
7068         {
7069           unsigned int imm_slot;
7070
7071           gas_assert (i.imm_operands == 1 && i.types[0].bitfield.vec_imm4);
7072
7073           if (i.tm.opcode_modifier.immext)
7074             {
7075               /* When ImmExt is set, the immediate byte is the last
7076                  operand.  */
7077               imm_slot = i.operands - 1;
7078               source--;
7079               reg_slot--;
7080             }
7081           else
7082             {
7083               imm_slot = 0;
7084
7085               /* Turn on Imm8 so that output_imm will generate it.  */
7086               i.types[imm_slot].bitfield.imm8 = 1;
7087             }
7088
7089           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
7090           i.op[imm_slot].imms->X_add_number
7091               |= register_number (i.op[reg_slot].regs) << 4;
7092           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
7093         }
7094
7095       gas_assert (i.tm.operand_types[nds].bitfield.regsimd);
7096       i.vex.register_specifier = i.op[nds].regs;
7097     }
7098   else
7099     source = dest = 0;
7100
7101   /* i.reg_operands MUST be the number of real register operands;
7102      implicit registers do not count.  If there are 3 register
7103      operands, it must be a instruction with VexNDS.  For a
7104      instruction with VexNDD, the destination register is encoded
7105      in VEX prefix.  If there are 4 register operands, it must be
7106      a instruction with VEX prefix and 3 sources.  */
7107   if (i.mem_operands == 0
7108       && ((i.reg_operands == 2
7109            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
7110           || (i.reg_operands == 3
7111               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
7112           || (i.reg_operands == 4 && vex_3_sources)))
7113     {
7114       switch (i.operands)
7115         {
7116         case 2:
7117           source = 0;
7118           break;
7119         case 3:
7120           /* When there are 3 operands, one of them may be immediate,
7121              which may be the first or the last operand.  Otherwise,
7122              the first operand must be shift count register (cl) or it
7123              is an instruction with VexNDS. */
7124           gas_assert (i.imm_operands == 1
7125                       || (i.imm_operands == 0
7126                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
7127                               || i.types[0].bitfield.shiftcount)));
7128           if (operand_type_check (i.types[0], imm)
7129               || i.types[0].bitfield.shiftcount)
7130             source = 1;
7131           else
7132             source = 0;
7133           break;
7134         case 4:
7135           /* When there are 4 operands, the first two must be 8bit
7136              immediate operands. The source operand will be the 3rd
7137              one.
7138
7139              For instructions with VexNDS, if the first operand
7140              an imm8, the source operand is the 2nd one.  If the last
7141              operand is imm8, the source operand is the first one.  */
7142           gas_assert ((i.imm_operands == 2
7143                        && i.types[0].bitfield.imm8
7144                        && i.types[1].bitfield.imm8)
7145                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
7146                           && i.imm_operands == 1
7147                           && (i.types[0].bitfield.imm8
7148                               || i.types[i.operands - 1].bitfield.imm8
7149                               || i.rounding)));
7150           if (i.imm_operands == 2)
7151             source = 2;
7152           else
7153             {
7154               if (i.types[0].bitfield.imm8)
7155                 source = 1;
7156               else
7157                 source = 0;
7158             }
7159           break;
7160         case 5:
7161           if (is_evex_encoding (&i.tm))
7162             {
7163               /* For EVEX instructions, when there are 5 operands, the
7164                  first one must be immediate operand.  If the second one
7165                  is immediate operand, the source operand is the 3th
7166                  one.  If the last one is immediate operand, the source
7167                  operand is the 2nd one.  */
7168               gas_assert (i.imm_operands == 2
7169                           && i.tm.opcode_modifier.sae
7170                           && operand_type_check (i.types[0], imm));
7171               if (operand_type_check (i.types[1], imm))
7172                 source = 2;
7173               else if (operand_type_check (i.types[4], imm))
7174                 source = 1;
7175               else
7176                 abort ();
7177             }
7178           break;
7179         default:
7180           abort ();
7181         }
7182
7183       if (!vex_3_sources)
7184         {
7185           dest = source + 1;
7186
7187           /* RC/SAE operand could be between DEST and SRC.  That happens
7188              when one operand is GPR and the other one is XMM/YMM/ZMM
7189              register.  */
7190           if (i.rounding && i.rounding->operand == (int) dest)
7191             dest++;
7192
7193           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7194             {
7195               /* For instructions with VexNDS, the register-only source
7196                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
7197                  register.  It is encoded in VEX prefix.  We need to
7198                  clear RegMem bit before calling operand_type_equal.  */
7199
7200               i386_operand_type op;
7201               unsigned int vvvv;
7202
7203               /* Check register-only source operand when two source
7204                  operands are swapped.  */
7205               if (!i.tm.operand_types[source].bitfield.baseindex
7206                   && i.tm.operand_types[dest].bitfield.baseindex)
7207                 {
7208                   vvvv = source;
7209                   source = dest;
7210                 }
7211               else
7212                 vvvv = dest;
7213
7214               op = i.tm.operand_types[vvvv];
7215               op.bitfield.regmem = 0;
7216               if ((dest + 1) >= i.operands
7217                   || ((!op.bitfield.reg
7218                        || (!op.bitfield.dword && !op.bitfield.qword))
7219                       && !op.bitfield.regsimd
7220                       && !operand_type_equal (&op, &regmask)))
7221                 abort ();
7222               i.vex.register_specifier = i.op[vvvv].regs;
7223               dest++;
7224             }
7225         }
7226
7227       i.rm.mode = 3;
7228       /* One of the register operands will be encoded in the i.tm.reg
7229          field, the other in the combined i.tm.mode and i.tm.regmem
7230          fields.  If no form of this instruction supports a memory
7231          destination operand, then we assume the source operand may
7232          sometimes be a memory operand and so we need to store the
7233          destination in the i.rm.reg field.  */
7234       if (!i.tm.operand_types[dest].bitfield.regmem
7235           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
7236         {
7237           i.rm.reg = i.op[dest].regs->reg_num;
7238           i.rm.regmem = i.op[source].regs->reg_num;
7239           if (i.op[dest].regs->reg_type.bitfield.regmmx
7240                || i.op[source].regs->reg_type.bitfield.regmmx)
7241             i.has_regmmx = TRUE;
7242           else if (i.op[dest].regs->reg_type.bitfield.regsimd
7243                    || i.op[source].regs->reg_type.bitfield.regsimd)
7244             {
7245               if (i.types[dest].bitfield.zmmword
7246                   || i.types[source].bitfield.zmmword)
7247                 i.has_regzmm = TRUE;
7248               else if (i.types[dest].bitfield.ymmword
7249                        || i.types[source].bitfield.ymmword)
7250                 i.has_regymm = TRUE;
7251               else
7252                 i.has_regxmm = TRUE;
7253             }
7254           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
7255             i.rex |= REX_R;
7256           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
7257             i.vrex |= REX_R;
7258           if ((i.op[source].regs->reg_flags & RegRex) != 0)
7259             i.rex |= REX_B;
7260           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
7261             i.vrex |= REX_B;
7262         }
7263       else
7264         {
7265           i.rm.reg = i.op[source].regs->reg_num;
7266           i.rm.regmem = i.op[dest].regs->reg_num;
7267           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
7268             i.rex |= REX_B;
7269           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
7270             i.vrex |= REX_B;
7271           if ((i.op[source].regs->reg_flags & RegRex) != 0)
7272             i.rex |= REX_R;
7273           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
7274             i.vrex |= REX_R;
7275         }
7276       if (flag_code != CODE_64BIT && (i.rex & REX_R))
7277         {
7278           if (!i.types[i.tm.operand_types[0].bitfield.regmem].bitfield.control)
7279             abort ();
7280           i.rex &= ~REX_R;
7281           add_prefix (LOCK_PREFIX_OPCODE);
7282         }
7283     }
7284   else
7285     {                   /* If it's not 2 reg operands...  */
7286       unsigned int mem;
7287
7288       if (i.mem_operands)
7289         {
7290           unsigned int fake_zero_displacement = 0;
7291           unsigned int op;
7292
7293           for (op = 0; op < i.operands; op++)
7294             if (operand_type_check (i.types[op], anymem))
7295               break;
7296           gas_assert (op < i.operands);
7297
7298           if (i.tm.opcode_modifier.vecsib)
7299             {
7300               if (i.index_reg->reg_num == RegIZ)
7301                 abort ();
7302
7303               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7304               if (!i.base_reg)
7305                 {
7306                   i.sib.base = NO_BASE_REGISTER;
7307                   i.sib.scale = i.log2_scale_factor;
7308                   i.types[op].bitfield.disp8 = 0;
7309                   i.types[op].bitfield.disp16 = 0;
7310                   i.types[op].bitfield.disp64 = 0;
7311                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
7312                     {
7313                       /* Must be 32 bit */
7314                       i.types[op].bitfield.disp32 = 1;
7315                       i.types[op].bitfield.disp32s = 0;
7316                     }
7317                   else
7318                     {
7319                       i.types[op].bitfield.disp32 = 0;
7320                       i.types[op].bitfield.disp32s = 1;
7321                     }
7322                 }
7323               i.sib.index = i.index_reg->reg_num;
7324               if ((i.index_reg->reg_flags & RegRex) != 0)
7325                 i.rex |= REX_X;
7326               if ((i.index_reg->reg_flags & RegVRex) != 0)
7327                 i.vrex |= REX_X;
7328             }
7329
7330           default_seg = &ds;
7331
7332           if (i.base_reg == 0)
7333             {
7334               i.rm.mode = 0;
7335               if (!i.disp_operands)
7336                 fake_zero_displacement = 1;
7337               if (i.index_reg == 0)
7338                 {
7339                   i386_operand_type newdisp;
7340
7341                   gas_assert (!i.tm.opcode_modifier.vecsib);
7342                   /* Operand is just <disp>  */
7343                   if (flag_code == CODE_64BIT)
7344                     {
7345                       /* 64bit mode overwrites the 32bit absolute
7346                          addressing by RIP relative addressing and
7347                          absolute addressing is encoded by one of the
7348                          redundant SIB forms.  */
7349                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7350                       i.sib.base = NO_BASE_REGISTER;
7351                       i.sib.index = NO_INDEX_REGISTER;
7352                       newdisp = (!i.prefix[ADDR_PREFIX] ? disp32s : disp32);
7353                     }
7354                   else if ((flag_code == CODE_16BIT)
7355                            ^ (i.prefix[ADDR_PREFIX] != 0))
7356                     {
7357                       i.rm.regmem = NO_BASE_REGISTER_16;
7358                       newdisp = disp16;
7359                     }
7360                   else
7361                     {
7362                       i.rm.regmem = NO_BASE_REGISTER;
7363                       newdisp = disp32;
7364                     }
7365                   i.types[op] = operand_type_and_not (i.types[op], anydisp);
7366                   i.types[op] = operand_type_or (i.types[op], newdisp);
7367                 }
7368               else if (!i.tm.opcode_modifier.vecsib)
7369                 {
7370                   /* !i.base_reg && i.index_reg  */
7371                   if (i.index_reg->reg_num == RegIZ)
7372                     i.sib.index = NO_INDEX_REGISTER;
7373                   else
7374                     i.sib.index = i.index_reg->reg_num;
7375                   i.sib.base = NO_BASE_REGISTER;
7376                   i.sib.scale = i.log2_scale_factor;
7377                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7378                   i.types[op].bitfield.disp8 = 0;
7379                   i.types[op].bitfield.disp16 = 0;
7380                   i.types[op].bitfield.disp64 = 0;
7381                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
7382                     {
7383                       /* Must be 32 bit */
7384                       i.types[op].bitfield.disp32 = 1;
7385                       i.types[op].bitfield.disp32s = 0;
7386                     }
7387                   else
7388                     {
7389                       i.types[op].bitfield.disp32 = 0;
7390                       i.types[op].bitfield.disp32s = 1;
7391                     }
7392                   if ((i.index_reg->reg_flags & RegRex) != 0)
7393                     i.rex |= REX_X;
7394                 }
7395             }
7396           /* RIP addressing for 64bit mode.  */
7397           else if (i.base_reg->reg_num == RegIP)
7398             {
7399               gas_assert (!i.tm.opcode_modifier.vecsib);
7400               i.rm.regmem = NO_BASE_REGISTER;
7401               i.types[op].bitfield.disp8 = 0;
7402               i.types[op].bitfield.disp16 = 0;
7403               i.types[op].bitfield.disp32 = 0;
7404               i.types[op].bitfield.disp32s = 1;
7405               i.types[op].bitfield.disp64 = 0;
7406               i.flags[op] |= Operand_PCrel;
7407               if (! i.disp_operands)
7408                 fake_zero_displacement = 1;
7409             }
7410           else if (i.base_reg->reg_type.bitfield.word)
7411             {
7412               gas_assert (!i.tm.opcode_modifier.vecsib);
7413               switch (i.base_reg->reg_num)
7414                 {
7415                 case 3: /* (%bx)  */
7416                   if (i.index_reg == 0)
7417                     i.rm.regmem = 7;
7418                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
7419                     i.rm.regmem = i.index_reg->reg_num - 6;
7420                   break;
7421                 case 5: /* (%bp)  */
7422                   default_seg = &ss;
7423                   if (i.index_reg == 0)
7424                     {
7425                       i.rm.regmem = 6;
7426                       if (operand_type_check (i.types[op], disp) == 0)
7427                         {
7428                           /* fake (%bp) into 0(%bp)  */
7429                           i.types[op].bitfield.disp8 = 1;
7430                           fake_zero_displacement = 1;
7431                         }
7432                     }
7433                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
7434                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
7435                   break;
7436                 default: /* (%si) -> 4 or (%di) -> 5  */
7437                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
7438                 }
7439               i.rm.mode = mode_from_disp_size (i.types[op]);
7440             }
7441           else /* i.base_reg and 32/64 bit mode  */
7442             {
7443               if (flag_code == CODE_64BIT
7444                   && operand_type_check (i.types[op], disp))
7445                 {
7446                   i.types[op].bitfield.disp16 = 0;
7447                   i.types[op].bitfield.disp64 = 0;
7448                   if (i.prefix[ADDR_PREFIX] == 0)
7449                     {
7450                       i.types[op].bitfield.disp32 = 0;
7451                       i.types[op].bitfield.disp32s = 1;
7452                     }
7453                   else
7454                     {
7455                       i.types[op].bitfield.disp32 = 1;
7456                       i.types[op].bitfield.disp32s = 0;
7457                     }
7458                 }
7459
7460               if (!i.tm.opcode_modifier.vecsib)
7461                 i.rm.regmem = i.base_reg->reg_num;
7462               if ((i.base_reg->reg_flags & RegRex) != 0)
7463                 i.rex |= REX_B;
7464               i.sib.base = i.base_reg->reg_num;
7465               /* x86-64 ignores REX prefix bit here to avoid decoder
7466                  complications.  */
7467               if (!(i.base_reg->reg_flags & RegRex)
7468                   && (i.base_reg->reg_num == EBP_REG_NUM
7469                    || i.base_reg->reg_num == ESP_REG_NUM))
7470                   default_seg = &ss;
7471               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
7472                 {
7473                   fake_zero_displacement = 1;
7474                   i.types[op].bitfield.disp8 = 1;
7475                 }
7476               i.sib.scale = i.log2_scale_factor;
7477               if (i.index_reg == 0)
7478                 {
7479                   gas_assert (!i.tm.opcode_modifier.vecsib);
7480                   /* <disp>(%esp) becomes two byte modrm with no index
7481                      register.  We've already stored the code for esp
7482                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
7483                      Any base register besides %esp will not use the
7484                      extra modrm byte.  */
7485                   i.sib.index = NO_INDEX_REGISTER;
7486                 }
7487               else if (!i.tm.opcode_modifier.vecsib)
7488                 {
7489                   if (i.index_reg->reg_num == RegIZ)
7490                     i.sib.index = NO_INDEX_REGISTER;
7491                   else
7492                     i.sib.index = i.index_reg->reg_num;
7493                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7494                   if ((i.index_reg->reg_flags & RegRex) != 0)
7495                     i.rex |= REX_X;
7496                 }
7497
7498               if (i.disp_operands
7499                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
7500                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
7501                 i.rm.mode = 0;
7502               else
7503                 {
7504                   if (!fake_zero_displacement
7505                       && !i.disp_operands
7506                       && i.disp_encoding)
7507                     {
7508                       fake_zero_displacement = 1;
7509                       if (i.disp_encoding == disp_encoding_8bit)
7510                         i.types[op].bitfield.disp8 = 1;
7511                       else
7512                         i.types[op].bitfield.disp32 = 1;
7513                     }
7514                   i.rm.mode = mode_from_disp_size (i.types[op]);
7515                 }
7516             }
7517
7518           if (fake_zero_displacement)
7519             {
7520               /* Fakes a zero displacement assuming that i.types[op]
7521                  holds the correct displacement size.  */
7522               expressionS *exp;
7523
7524               gas_assert (i.op[op].disps == 0);
7525               exp = &disp_expressions[i.disp_operands++];
7526               i.op[op].disps = exp;
7527               exp->X_op = O_constant;
7528               exp->X_add_number = 0;
7529               exp->X_add_symbol = (symbolS *) 0;
7530               exp->X_op_symbol = (symbolS *) 0;
7531             }
7532
7533           mem = op;
7534         }
7535       else
7536         mem = ~0;
7537
7538       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
7539         {
7540           if (operand_type_check (i.types[0], imm))
7541             i.vex.register_specifier = NULL;
7542           else
7543             {
7544               /* VEX.vvvv encodes one of the sources when the first
7545                  operand is not an immediate.  */
7546               if (i.tm.opcode_modifier.vexw == VEXW0)
7547                 i.vex.register_specifier = i.op[0].regs;
7548               else
7549                 i.vex.register_specifier = i.op[1].regs;
7550             }
7551
7552           /* Destination is a XMM register encoded in the ModRM.reg
7553              and VEX.R bit.  */
7554           i.rm.reg = i.op[2].regs->reg_num;
7555           if ((i.op[2].regs->reg_flags & RegRex) != 0)
7556             i.rex |= REX_R;
7557
7558           /* ModRM.rm and VEX.B encodes the other source.  */
7559           if (!i.mem_operands)
7560             {
7561               i.rm.mode = 3;
7562
7563               if (i.tm.opcode_modifier.vexw == VEXW0)
7564                 i.rm.regmem = i.op[1].regs->reg_num;
7565               else
7566                 i.rm.regmem = i.op[0].regs->reg_num;
7567
7568               if ((i.op[1].regs->reg_flags & RegRex) != 0)
7569                 i.rex |= REX_B;
7570             }
7571         }
7572       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
7573         {
7574           i.vex.register_specifier = i.op[2].regs;
7575           if (!i.mem_operands)
7576             {
7577               i.rm.mode = 3;
7578               i.rm.regmem = i.op[1].regs->reg_num;
7579               if ((i.op[1].regs->reg_flags & RegRex) != 0)
7580                 i.rex |= REX_B;
7581             }
7582         }
7583       /* Fill in i.rm.reg or i.rm.regmem field with register operand
7584          (if any) based on i.tm.extension_opcode.  Again, we must be
7585          careful to make sure that segment/control/debug/test/MMX
7586          registers are coded into the i.rm.reg field.  */
7587       else if (i.reg_operands)
7588         {
7589           unsigned int op;
7590           unsigned int vex_reg = ~0;
7591
7592           for (op = 0; op < i.operands; op++)
7593             {
7594               if (i.types[op].bitfield.reg
7595                   || i.types[op].bitfield.regbnd
7596                   || i.types[op].bitfield.regmask
7597                   || i.types[op].bitfield.sreg2
7598                   || i.types[op].bitfield.sreg3
7599                   || i.types[op].bitfield.control
7600                   || i.types[op].bitfield.debug
7601                   || i.types[op].bitfield.test)
7602                 break;
7603               if (i.types[op].bitfield.regsimd)
7604                 {
7605                   if (i.types[op].bitfield.zmmword)
7606                     i.has_regzmm = TRUE;
7607                   else if (i.types[op].bitfield.ymmword)
7608                     i.has_regymm = TRUE;
7609                   else
7610                     i.has_regxmm = TRUE;
7611                   break;
7612                 }
7613               if (i.types[op].bitfield.regmmx)
7614                 {
7615                   i.has_regmmx = TRUE;
7616                   break;
7617                 }
7618             }
7619
7620           if (vex_3_sources)
7621             op = dest;
7622           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7623             {
7624               /* For instructions with VexNDS, the register-only
7625                  source operand is encoded in VEX prefix. */
7626               gas_assert (mem != (unsigned int) ~0);
7627
7628               if (op > mem)
7629                 {
7630                   vex_reg = op++;
7631                   gas_assert (op < i.operands);
7632                 }
7633               else
7634                 {
7635                   /* Check register-only source operand when two source
7636                      operands are swapped.  */
7637                   if (!i.tm.operand_types[op].bitfield.baseindex
7638                       && i.tm.operand_types[op + 1].bitfield.baseindex)
7639                     {
7640                       vex_reg = op;
7641                       op += 2;
7642                       gas_assert (mem == (vex_reg + 1)
7643                                   && op < i.operands);
7644                     }
7645                   else
7646                     {
7647                       vex_reg = op + 1;
7648                       gas_assert (vex_reg < i.operands);
7649                     }
7650                 }
7651             }
7652           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
7653             {
7654               /* For instructions with VexNDD, the register destination
7655                  is encoded in VEX prefix.  */
7656               if (i.mem_operands == 0)
7657                 {
7658                   /* There is no memory operand.  */
7659                   gas_assert ((op + 2) == i.operands);
7660                   vex_reg = op + 1;
7661                 }
7662               else
7663                 {
7664                   /* There are only 2 non-immediate operands.  */
7665                   gas_assert (op < i.imm_operands + 2
7666                               && i.operands == i.imm_operands + 2);
7667                   vex_reg = i.imm_operands + 1;
7668                 }
7669             }
7670           else
7671             gas_assert (op < i.operands);
7672
7673           if (vex_reg != (unsigned int) ~0)
7674             {
7675               i386_operand_type *type = &i.tm.operand_types[vex_reg];
7676
7677               if ((!type->bitfield.reg
7678                    || (!type->bitfield.dword && !type->bitfield.qword))
7679                   && !type->bitfield.regsimd
7680                   && !operand_type_equal (type, &regmask))
7681                 abort ();
7682
7683               i.vex.register_specifier = i.op[vex_reg].regs;
7684             }
7685
7686           /* Don't set OP operand twice.  */
7687           if (vex_reg != op)
7688             {
7689               /* If there is an extension opcode to put here, the
7690                  register number must be put into the regmem field.  */
7691               if (i.tm.extension_opcode != None)
7692                 {
7693                   i.rm.regmem = i.op[op].regs->reg_num;
7694                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
7695                     i.rex |= REX_B;
7696                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
7697                     i.vrex |= REX_B;
7698                 }
7699               else
7700                 {
7701                   i.rm.reg = i.op[op].regs->reg_num;
7702                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
7703                     i.rex |= REX_R;
7704                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
7705                     i.vrex |= REX_R;
7706                 }
7707             }
7708
7709           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
7710              must set it to 3 to indicate this is a register operand
7711              in the regmem field.  */
7712           if (!i.mem_operands)
7713             i.rm.mode = 3;
7714         }
7715
7716       /* Fill in i.rm.reg field with extension opcode (if any).  */
7717       if (i.tm.extension_opcode != None)
7718         i.rm.reg = i.tm.extension_opcode;
7719     }
7720   return default_seg;
7721 }
7722
7723 static void
7724 output_branch (void)
7725 {
7726   char *p;
7727   int size;
7728   int code16;
7729   int prefix;
7730   relax_substateT subtype;
7731   symbolS *sym;
7732   offsetT off;
7733
7734   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
7735   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
7736
7737   prefix = 0;
7738   if (i.prefix[DATA_PREFIX] != 0)
7739     {
7740       prefix = 1;
7741       i.prefixes -= 1;
7742       code16 ^= CODE16;
7743     }
7744   /* Pentium4 branch hints.  */
7745   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7746       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7747     {
7748       prefix++;
7749       i.prefixes--;
7750     }
7751   if (i.prefix[REX_PREFIX] != 0)
7752     {
7753       prefix++;
7754       i.prefixes--;
7755     }
7756
7757   /* BND prefixed jump.  */
7758   if (i.prefix[BND_PREFIX] != 0)
7759     {
7760       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7761       i.prefixes -= 1;
7762     }
7763
7764   if (i.prefixes != 0 && !intel_syntax)
7765     as_warn (_("skipping prefixes on this instruction"));
7766
7767   /* It's always a symbol;  End frag & setup for relax.
7768      Make sure there is enough room in this frag for the largest
7769      instruction we may generate in md_convert_frag.  This is 2
7770      bytes for the opcode and room for the prefix and largest
7771      displacement.  */
7772   frag_grow (prefix + 2 + 4);
7773   /* Prefix and 1 opcode byte go in fr_fix.  */
7774   p = frag_more (prefix + 1);
7775   if (i.prefix[DATA_PREFIX] != 0)
7776     *p++ = DATA_PREFIX_OPCODE;
7777   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
7778       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
7779     *p++ = i.prefix[SEG_PREFIX];
7780   if (i.prefix[REX_PREFIX] != 0)
7781     *p++ = i.prefix[REX_PREFIX];
7782   *p = i.tm.base_opcode;
7783
7784   if ((unsigned char) *p == JUMP_PC_RELATIVE)
7785     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
7786   else if (cpu_arch_flags.bitfield.cpui386)
7787     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
7788   else
7789     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
7790   subtype |= code16;
7791
7792   sym = i.op[0].disps->X_add_symbol;
7793   off = i.op[0].disps->X_add_number;
7794
7795   if (i.op[0].disps->X_op != O_constant
7796       && i.op[0].disps->X_op != O_symbol)
7797     {
7798       /* Handle complex expressions.  */
7799       sym = make_expr_symbol (i.op[0].disps);
7800       off = 0;
7801     }
7802
7803   /* 1 possible extra opcode + 4 byte displacement go in var part.
7804      Pass reloc in fr_var.  */
7805   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
7806 }
7807
7808 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7809 /* Return TRUE iff PLT32 relocation should be used for branching to
7810    symbol S.  */
7811
7812 static bfd_boolean
7813 need_plt32_p (symbolS *s)
7814 {
7815   /* PLT32 relocation is ELF only.  */
7816   if (!IS_ELF)
7817     return FALSE;
7818
7819 #ifdef TE_SOLARIS
7820   /* Don't emit PLT32 relocation on Solaris: neither native linker nor
7821      krtld support it.  */
7822   return FALSE;
7823 #endif
7824
7825   /* Since there is no need to prepare for PLT branch on x86-64, we
7826      can generate R_X86_64_PLT32, instead of R_X86_64_PC32, which can
7827      be used as a marker for 32-bit PC-relative branches.  */
7828   if (!object_64bit)
7829     return FALSE;
7830
7831   /* Weak or undefined symbol need PLT32 relocation.  */
7832   if (S_IS_WEAK (s) || !S_IS_DEFINED (s))
7833     return TRUE;
7834
7835   /* Non-global symbol doesn't need PLT32 relocation.  */
7836   if (! S_IS_EXTERNAL (s))
7837     return FALSE;
7838
7839   /* Other global symbols need PLT32 relocation.  NB: Symbol with
7840      non-default visibilities are treated as normal global symbol
7841      so that PLT32 relocation can be used as a marker for 32-bit
7842      PC-relative branches.  It is useful for linker relaxation.  */
7843   return TRUE;
7844 }
7845 #endif
7846
7847 static void
7848 output_jump (void)
7849 {
7850   char *p;
7851   int size;
7852   fixS *fixP;
7853   bfd_reloc_code_real_type jump_reloc = i.reloc[0];
7854
7855   if (i.tm.opcode_modifier.jumpbyte)
7856     {
7857       /* This is a loop or jecxz type instruction.  */
7858       size = 1;
7859       if (i.prefix[ADDR_PREFIX] != 0)
7860         {
7861           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
7862           i.prefixes -= 1;
7863         }
7864       /* Pentium4 branch hints.  */
7865       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7866           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7867         {
7868           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
7869           i.prefixes--;
7870         }
7871     }
7872   else
7873     {
7874       int code16;
7875
7876       code16 = 0;
7877       if (flag_code == CODE_16BIT)
7878         code16 = CODE16;
7879
7880       if (i.prefix[DATA_PREFIX] != 0)
7881         {
7882           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
7883           i.prefixes -= 1;
7884           code16 ^= CODE16;
7885         }
7886
7887       size = 4;
7888       if (code16)
7889         size = 2;
7890     }
7891
7892   if (i.prefix[REX_PREFIX] != 0)
7893     {
7894       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
7895       i.prefixes -= 1;
7896     }
7897
7898   /* BND prefixed jump.  */
7899   if (i.prefix[BND_PREFIX] != 0)
7900     {
7901       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7902       i.prefixes -= 1;
7903     }
7904
7905   if (i.prefixes != 0 && !intel_syntax)
7906     as_warn (_("skipping prefixes on this instruction"));
7907
7908   p = frag_more (i.tm.opcode_length + size);
7909   switch (i.tm.opcode_length)
7910     {
7911     case 2:
7912       *p++ = i.tm.base_opcode >> 8;
7913       /* Fall through.  */
7914     case 1:
7915       *p++ = i.tm.base_opcode;
7916       break;
7917     default:
7918       abort ();
7919     }
7920
7921 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7922   if (size == 4
7923       && jump_reloc == NO_RELOC
7924       && need_plt32_p (i.op[0].disps->X_add_symbol))
7925     jump_reloc = BFD_RELOC_X86_64_PLT32;
7926 #endif
7927
7928   jump_reloc = reloc (size, 1, 1, jump_reloc);
7929
7930   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7931                       i.op[0].disps, 1, jump_reloc);
7932
7933   /* All jumps handled here are signed, but don't use a signed limit
7934      check for 32 and 16 bit jumps as we want to allow wrap around at
7935      4G and 64k respectively.  */
7936   if (size == 1)
7937     fixP->fx_signed = 1;
7938 }
7939
7940 static void
7941 output_interseg_jump (void)
7942 {
7943   char *p;
7944   int size;
7945   int prefix;
7946   int code16;
7947
7948   code16 = 0;
7949   if (flag_code == CODE_16BIT)
7950     code16 = CODE16;
7951
7952   prefix = 0;
7953   if (i.prefix[DATA_PREFIX] != 0)
7954     {
7955       prefix = 1;
7956       i.prefixes -= 1;
7957       code16 ^= CODE16;
7958     }
7959   if (i.prefix[REX_PREFIX] != 0)
7960     {
7961       prefix++;
7962       i.prefixes -= 1;
7963     }
7964
7965   size = 4;
7966   if (code16)
7967     size = 2;
7968
7969   if (i.prefixes != 0 && !intel_syntax)
7970     as_warn (_("skipping prefixes on this instruction"));
7971
7972   /* 1 opcode; 2 segment; offset  */
7973   p = frag_more (prefix + 1 + 2 + size);
7974
7975   if (i.prefix[DATA_PREFIX] != 0)
7976     *p++ = DATA_PREFIX_OPCODE;
7977
7978   if (i.prefix[REX_PREFIX] != 0)
7979     *p++ = i.prefix[REX_PREFIX];
7980
7981   *p++ = i.tm.base_opcode;
7982   if (i.op[1].imms->X_op == O_constant)
7983     {
7984       offsetT n = i.op[1].imms->X_add_number;
7985
7986       if (size == 2
7987           && !fits_in_unsigned_word (n)
7988           && !fits_in_signed_word (n))
7989         {
7990           as_bad (_("16-bit jump out of range"));
7991           return;
7992         }
7993       md_number_to_chars (p, n, size);
7994     }
7995   else
7996     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7997                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
7998   if (i.op[0].imms->X_op != O_constant)
7999     as_bad (_("can't handle non absolute segment in `%s'"),
8000             i.tm.name);
8001   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
8002 }
8003
8004 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8005 void
8006 x86_cleanup (void)
8007 {
8008   char *p;
8009   asection *seg = now_seg;
8010   subsegT subseg = now_subseg;
8011   asection *sec;
8012   unsigned int alignment, align_size_1;
8013   unsigned int isa_1_descsz, feature_2_descsz, descsz;
8014   unsigned int isa_1_descsz_raw, feature_2_descsz_raw;
8015   unsigned int padding;
8016
8017   if (!IS_ELF || !x86_used_note)
8018     return;
8019
8020   x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X86;
8021
8022   /* The .note.gnu.property section layout:
8023
8024      Field      Length          Contents
8025      ----       ----            ----
8026      n_namsz    4               4
8027      n_descsz   4               The note descriptor size
8028      n_type     4               NT_GNU_PROPERTY_TYPE_0
8029      n_name     4               "GNU"
8030      n_desc     n_descsz        The program property array
8031      ....       ....            ....
8032    */
8033
8034   /* Create the .note.gnu.property section.  */
8035   sec = subseg_new (NOTE_GNU_PROPERTY_SECTION_NAME, 0);
8036   bfd_set_section_flags (stdoutput, sec,
8037                          (SEC_ALLOC
8038                           | SEC_LOAD
8039                           | SEC_DATA
8040                           | SEC_HAS_CONTENTS
8041                           | SEC_READONLY));
8042
8043   if (get_elf_backend_data (stdoutput)->s->elfclass == ELFCLASS64)
8044     {
8045       align_size_1 = 7;
8046       alignment = 3;
8047     }
8048   else
8049     {
8050       align_size_1 = 3;
8051       alignment = 2;
8052     }
8053
8054   bfd_set_section_alignment (stdoutput, sec, alignment);
8055   elf_section_type (sec) = SHT_NOTE;
8056
8057   /* GNU_PROPERTY_X86_ISA_1_USED: 4-byte type + 4-byte data size
8058                                   + 4-byte data  */
8059   isa_1_descsz_raw = 4 + 4 + 4;
8060   /* Align GNU_PROPERTY_X86_ISA_1_USED.  */
8061   isa_1_descsz = (isa_1_descsz_raw + align_size_1) & ~align_size_1;
8062
8063   feature_2_descsz_raw = isa_1_descsz;
8064   /* GNU_PROPERTY_X86_FEATURE_2_USED: 4-byte type + 4-byte data size
8065                                       + 4-byte data  */
8066   feature_2_descsz_raw += 4 + 4 + 4;
8067   /* Align GNU_PROPERTY_X86_FEATURE_2_USED.  */
8068   feature_2_descsz = ((feature_2_descsz_raw + align_size_1)
8069                       & ~align_size_1);
8070
8071   descsz = feature_2_descsz;
8072   /* Section size: n_namsz + n_descsz + n_type + n_name + n_descsz.  */
8073   p = frag_more (4 + 4 + 4 + 4 + descsz);
8074
8075   /* Write n_namsz.  */
8076   md_number_to_chars (p, (valueT) 4, 4);
8077
8078   /* Write n_descsz.  */
8079   md_number_to_chars (p + 4, (valueT) descsz, 4);
8080
8081   /* Write n_type.  */
8082   md_number_to_chars (p + 4 * 2, (valueT) NT_GNU_PROPERTY_TYPE_0, 4);
8083
8084   /* Write n_name.  */
8085   memcpy (p + 4 * 3, "GNU", 4);
8086
8087   /* Write 4-byte type.  */
8088   md_number_to_chars (p + 4 * 4,
8089                       (valueT) GNU_PROPERTY_X86_ISA_1_USED, 4);
8090
8091   /* Write 4-byte data size.  */
8092   md_number_to_chars (p + 4 * 5, (valueT) 4, 4);
8093
8094   /* Write 4-byte data.  */
8095   md_number_to_chars (p + 4 * 6, (valueT) x86_isa_1_used, 4);
8096
8097   /* Zero out paddings.  */
8098   padding = isa_1_descsz - isa_1_descsz_raw;
8099   if (padding)
8100     memset (p + 4 * 7, 0, padding);
8101
8102   /* Write 4-byte type.  */
8103   md_number_to_chars (p + isa_1_descsz + 4 * 4,
8104                       (valueT) GNU_PROPERTY_X86_FEATURE_2_USED, 4);
8105
8106   /* Write 4-byte data size.  */
8107   md_number_to_chars (p + isa_1_descsz + 4 * 5, (valueT) 4, 4);
8108
8109   /* Write 4-byte data.  */
8110   md_number_to_chars (p + isa_1_descsz + 4 * 6,
8111                       (valueT) x86_feature_2_used, 4);
8112
8113   /* Zero out paddings.  */
8114   padding = feature_2_descsz - feature_2_descsz_raw;
8115   if (padding)
8116     memset (p + isa_1_descsz + 4 * 7, 0, padding);
8117
8118   /* We probably can't restore the current segment, for there likely
8119      isn't one yet...  */
8120   if (seg && subseg)
8121     subseg_set (seg, subseg);
8122 }
8123 #endif
8124
8125 static void
8126 output_insn (void)
8127 {
8128   fragS *insn_start_frag;
8129   offsetT insn_start_off;
8130
8131 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8132   if (IS_ELF && x86_used_note)
8133     {
8134       if (i.tm.cpu_flags.bitfield.cpucmov)
8135         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_CMOV;
8136       if (i.tm.cpu_flags.bitfield.cpusse)
8137         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE;
8138       if (i.tm.cpu_flags.bitfield.cpusse2)
8139         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE2;
8140       if (i.tm.cpu_flags.bitfield.cpusse3)
8141         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE3;
8142       if (i.tm.cpu_flags.bitfield.cpussse3)
8143         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSSE3;
8144       if (i.tm.cpu_flags.bitfield.cpusse4_1)
8145         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_1;
8146       if (i.tm.cpu_flags.bitfield.cpusse4_2)
8147         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_SSE4_2;
8148       if (i.tm.cpu_flags.bitfield.cpuavx)
8149         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX;
8150       if (i.tm.cpu_flags.bitfield.cpuavx2)
8151         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX2;
8152       if (i.tm.cpu_flags.bitfield.cpufma)
8153         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_FMA;
8154       if (i.tm.cpu_flags.bitfield.cpuavx512f)
8155         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512F;
8156       if (i.tm.cpu_flags.bitfield.cpuavx512cd)
8157         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512CD;
8158       if (i.tm.cpu_flags.bitfield.cpuavx512er)
8159         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512ER;
8160       if (i.tm.cpu_flags.bitfield.cpuavx512pf)
8161         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512PF;
8162       if (i.tm.cpu_flags.bitfield.cpuavx512vl)
8163         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512VL;
8164       if (i.tm.cpu_flags.bitfield.cpuavx512dq)
8165         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512DQ;
8166       if (i.tm.cpu_flags.bitfield.cpuavx512bw)
8167         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512BW;
8168       if (i.tm.cpu_flags.bitfield.cpuavx512_4fmaps)
8169         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS;
8170       if (i.tm.cpu_flags.bitfield.cpuavx512_4vnniw)
8171         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW;
8172       if (i.tm.cpu_flags.bitfield.cpuavx512_bitalg)
8173         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BITALG;
8174       if (i.tm.cpu_flags.bitfield.cpuavx512ifma)
8175         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_IFMA;
8176       if (i.tm.cpu_flags.bitfield.cpuavx512vbmi)
8177         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI;
8178       if (i.tm.cpu_flags.bitfield.cpuavx512_vbmi2)
8179         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2;
8180       if (i.tm.cpu_flags.bitfield.cpuavx512_vnni)
8181         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_VNNI;
8182       if (i.tm.cpu_flags.bitfield.cpuavx512_bf16)
8183         x86_isa_1_used |= GNU_PROPERTY_X86_ISA_1_AVX512_BF16;
8184
8185       if (i.tm.cpu_flags.bitfield.cpu8087
8186           || i.tm.cpu_flags.bitfield.cpu287
8187           || i.tm.cpu_flags.bitfield.cpu387
8188           || i.tm.cpu_flags.bitfield.cpu687
8189           || i.tm.cpu_flags.bitfield.cpufisttp)
8190         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_X87;
8191       /* Don't set GNU_PROPERTY_X86_FEATURE_2_MMX for prefetchtXXX nor
8192          Xfence instructions.  */
8193       if (i.tm.base_opcode != 0xf18
8194           && i.tm.base_opcode != 0xf0d
8195           && i.tm.base_opcode != 0xfae
8196           && (i.has_regmmx
8197               || i.tm.cpu_flags.bitfield.cpummx
8198               || i.tm.cpu_flags.bitfield.cpua3dnow
8199               || i.tm.cpu_flags.bitfield.cpua3dnowa))
8200         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_MMX;
8201       if (i.has_regxmm)
8202         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XMM;
8203       if (i.has_regymm)
8204         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_YMM;
8205       if (i.has_regzmm)
8206         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_ZMM;
8207       if (i.tm.cpu_flags.bitfield.cpufxsr)
8208         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_FXSR;
8209       if (i.tm.cpu_flags.bitfield.cpuxsave)
8210         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVE;
8211       if (i.tm.cpu_flags.bitfield.cpuxsaveopt)
8212         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT;
8213       if (i.tm.cpu_flags.bitfield.cpuxsavec)
8214         x86_feature_2_used |= GNU_PROPERTY_X86_FEATURE_2_XSAVEC;
8215     }
8216 #endif
8217
8218   /* Tie dwarf2 debug info to the address at the start of the insn.
8219      We can't do this after the insn has been output as the current
8220      frag may have been closed off.  eg. by frag_var.  */
8221   dwarf2_emit_insn (0);
8222
8223   insn_start_frag = frag_now;
8224   insn_start_off = frag_now_fix ();
8225
8226   /* Output jumps.  */
8227   if (i.tm.opcode_modifier.jump)
8228     output_branch ();
8229   else if (i.tm.opcode_modifier.jumpbyte
8230            || i.tm.opcode_modifier.jumpdword)
8231     output_jump ();
8232   else if (i.tm.opcode_modifier.jumpintersegment)
8233     output_interseg_jump ();
8234   else
8235     {
8236       /* Output normal instructions here.  */
8237       char *p;
8238       unsigned char *q;
8239       unsigned int j;
8240       unsigned int prefix;
8241
8242       if (avoid_fence
8243          && i.tm.base_opcode == 0xfae
8244          && i.operands == 1
8245          && i.imm_operands == 1
8246          && (i.op[0].imms->X_add_number == 0xe8
8247              || i.op[0].imms->X_add_number == 0xf0
8248              || i.op[0].imms->X_add_number == 0xf8))
8249         {
8250           /* Encode lfence, mfence, and sfence as
8251              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
8252           offsetT val = 0x240483f0ULL;
8253           p = frag_more (5);
8254           md_number_to_chars (p, val, 5);
8255           return;
8256         }
8257
8258       /* Some processors fail on LOCK prefix. This options makes
8259          assembler ignore LOCK prefix and serves as a workaround.  */
8260       if (omit_lock_prefix)
8261         {
8262           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
8263             return;
8264           i.prefix[LOCK_PREFIX] = 0;
8265         }
8266
8267       /* Since the VEX/EVEX prefix contains the implicit prefix, we
8268          don't need the explicit prefix.  */
8269       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
8270         {
8271           switch (i.tm.opcode_length)
8272             {
8273             case 3:
8274               if (i.tm.base_opcode & 0xff000000)
8275                 {
8276                   prefix = (i.tm.base_opcode >> 24) & 0xff;
8277                   add_prefix (prefix);
8278                 }
8279               break;
8280             case 2:
8281               if ((i.tm.base_opcode & 0xff0000) != 0)
8282                 {
8283                   prefix = (i.tm.base_opcode >> 16) & 0xff;
8284                   if (!i.tm.cpu_flags.bitfield.cpupadlock
8285                       || prefix != REPE_PREFIX_OPCODE
8286                       || (i.prefix[REP_PREFIX] != REPE_PREFIX_OPCODE))
8287                     add_prefix (prefix);
8288                 }
8289               break;
8290             case 1:
8291               break;
8292             case 0:
8293               /* Check for pseudo prefixes.  */
8294               as_bad_where (insn_start_frag->fr_file,
8295                             insn_start_frag->fr_line,
8296                              _("pseudo prefix without instruction"));
8297               return;
8298             default:
8299               abort ();
8300             }
8301
8302 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
8303           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
8304              R_X86_64_GOTTPOFF relocation so that linker can safely
8305              perform IE->LE optimization.  */
8306           if (x86_elf_abi == X86_64_X32_ABI
8307               && i.operands == 2
8308               && i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
8309               && i.prefix[REX_PREFIX] == 0)
8310             add_prefix (REX_OPCODE);
8311 #endif
8312
8313           /* The prefix bytes.  */
8314           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
8315             if (*q)
8316               FRAG_APPEND_1_CHAR (*q);
8317         }
8318       else
8319         {
8320           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
8321             if (*q)
8322               switch (j)
8323                 {
8324                 case REX_PREFIX:
8325                   /* REX byte is encoded in VEX prefix.  */
8326                   break;
8327                 case SEG_PREFIX:
8328                 case ADDR_PREFIX:
8329                   FRAG_APPEND_1_CHAR (*q);
8330                   break;
8331                 default:
8332                   /* There should be no other prefixes for instructions
8333                      with VEX prefix.  */
8334                   abort ();
8335                 }
8336
8337           /* For EVEX instructions i.vrex should become 0 after
8338              build_evex_prefix.  For VEX instructions upper 16 registers
8339              aren't available, so VREX should be 0.  */
8340           if (i.vrex)
8341             abort ();
8342           /* Now the VEX prefix.  */
8343           p = frag_more (i.vex.length);
8344           for (j = 0; j < i.vex.length; j++)
8345             p[j] = i.vex.bytes[j];
8346         }
8347
8348       /* Now the opcode; be careful about word order here!  */
8349       if (i.tm.opcode_length == 1)
8350         {
8351           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
8352         }
8353       else
8354         {
8355           switch (i.tm.opcode_length)
8356             {
8357             case 4:
8358               p = frag_more (4);
8359               *p++ = (i.tm.base_opcode >> 24) & 0xff;
8360               *p++ = (i.tm.base_opcode >> 16) & 0xff;
8361               break;
8362             case 3:
8363               p = frag_more (3);
8364               *p++ = (i.tm.base_opcode >> 16) & 0xff;
8365               break;
8366             case 2:
8367               p = frag_more (2);
8368               break;
8369             default:
8370               abort ();
8371               break;
8372             }
8373
8374           /* Put out high byte first: can't use md_number_to_chars!  */
8375           *p++ = (i.tm.base_opcode >> 8) & 0xff;
8376           *p = i.tm.base_opcode & 0xff;
8377         }
8378
8379       /* Now the modrm byte and sib byte (if present).  */
8380       if (i.tm.opcode_modifier.modrm)
8381         {
8382           FRAG_APPEND_1_CHAR ((i.rm.regmem << 0
8383                                | i.rm.reg << 3
8384                                | i.rm.mode << 6));
8385           /* If i.rm.regmem == ESP (4)
8386              && i.rm.mode != (Register mode)
8387              && not 16 bit
8388              ==> need second modrm byte.  */
8389           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
8390               && i.rm.mode != 3
8391               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
8392             FRAG_APPEND_1_CHAR ((i.sib.base << 0
8393                                  | i.sib.index << 3
8394                                  | i.sib.scale << 6));
8395         }
8396
8397       if (i.disp_operands)
8398         output_disp (insn_start_frag, insn_start_off);
8399
8400       if (i.imm_operands)
8401         output_imm (insn_start_frag, insn_start_off);
8402     }
8403
8404 #ifdef DEBUG386
8405   if (flag_debug)
8406     {
8407       pi ("" /*line*/, &i);
8408     }
8409 #endif /* DEBUG386  */
8410 }
8411
8412 /* Return the size of the displacement operand N.  */
8413
8414 static int
8415 disp_size (unsigned int n)
8416 {
8417   int size = 4;
8418
8419   if (i.types[n].bitfield.disp64)
8420     size = 8;
8421   else if (i.types[n].bitfield.disp8)
8422     size = 1;
8423   else if (i.types[n].bitfield.disp16)
8424     size = 2;
8425   return size;
8426 }
8427
8428 /* Return the size of the immediate operand N.  */
8429
8430 static int
8431 imm_size (unsigned int n)
8432 {
8433   int size = 4;
8434   if (i.types[n].bitfield.imm64)
8435     size = 8;
8436   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
8437     size = 1;
8438   else if (i.types[n].bitfield.imm16)
8439     size = 2;
8440   return size;
8441 }
8442
8443 static void
8444 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
8445 {
8446   char *p;
8447   unsigned int n;
8448
8449   for (n = 0; n < i.operands; n++)
8450     {
8451       if (operand_type_check (i.types[n], disp))
8452         {
8453           if (i.op[n].disps->X_op == O_constant)
8454             {
8455               int size = disp_size (n);
8456               offsetT val = i.op[n].disps->X_add_number;
8457
8458               val = offset_in_range (val >> (size == 1 ? i.memshift : 0),
8459                                      size);
8460               p = frag_more (size);
8461               md_number_to_chars (p, val, size);
8462             }
8463           else
8464             {
8465               enum bfd_reloc_code_real reloc_type;
8466               int size = disp_size (n);
8467               int sign = i.types[n].bitfield.disp32s;
8468               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
8469               fixS *fixP;
8470
8471               /* We can't have 8 bit displacement here.  */
8472               gas_assert (!i.types[n].bitfield.disp8);
8473
8474               /* The PC relative address is computed relative
8475                  to the instruction boundary, so in case immediate
8476                  fields follows, we need to adjust the value.  */
8477               if (pcrel && i.imm_operands)
8478                 {
8479                   unsigned int n1;
8480                   int sz = 0;
8481
8482                   for (n1 = 0; n1 < i.operands; n1++)
8483                     if (operand_type_check (i.types[n1], imm))
8484                       {
8485                         /* Only one immediate is allowed for PC
8486                            relative address.  */
8487                         gas_assert (sz == 0);
8488                         sz = imm_size (n1);
8489                         i.op[n].disps->X_add_number -= sz;
8490                       }
8491                   /* We should find the immediate.  */
8492                   gas_assert (sz != 0);
8493                 }
8494
8495               p = frag_more (size);
8496               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
8497               if (GOT_symbol
8498                   && GOT_symbol == i.op[n].disps->X_add_symbol
8499                   && (((reloc_type == BFD_RELOC_32
8500                         || reloc_type == BFD_RELOC_X86_64_32S
8501                         || (reloc_type == BFD_RELOC_64
8502                             && object_64bit))
8503                        && (i.op[n].disps->X_op == O_symbol
8504                            || (i.op[n].disps->X_op == O_add
8505                                && ((symbol_get_value_expression
8506                                     (i.op[n].disps->X_op_symbol)->X_op)
8507                                    == O_subtract))))
8508                       || reloc_type == BFD_RELOC_32_PCREL))
8509                 {
8510                   offsetT add;
8511
8512                   if (insn_start_frag == frag_now)
8513                     add = (p - frag_now->fr_literal) - insn_start_off;
8514                   else
8515                     {
8516                       fragS *fr;
8517
8518                       add = insn_start_frag->fr_fix - insn_start_off;
8519                       for (fr = insn_start_frag->fr_next;
8520                            fr && fr != frag_now; fr = fr->fr_next)
8521                         add += fr->fr_fix;
8522                       add += p - frag_now->fr_literal;
8523                     }
8524
8525                   if (!object_64bit)
8526                     {
8527                       reloc_type = BFD_RELOC_386_GOTPC;
8528                       i.op[n].imms->X_add_number += add;
8529                     }
8530                   else if (reloc_type == BFD_RELOC_64)
8531                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
8532                   else
8533                     /* Don't do the adjustment for x86-64, as there
8534                        the pcrel addressing is relative to the _next_
8535                        insn, and that is taken care of in other code.  */
8536                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
8537                 }
8538               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
8539                                   size, i.op[n].disps, pcrel,
8540                                   reloc_type);
8541               /* Check for "call/jmp *mem", "mov mem, %reg",
8542                  "test %reg, mem" and "binop mem, %reg" where binop
8543                  is one of adc, add, and, cmp, or, sbb, sub, xor
8544                  instructions without data prefix.  Always generate
8545                  R_386_GOT32X for "sym*GOT" operand in 32-bit mode.  */
8546               if (i.prefix[DATA_PREFIX] == 0
8547                   && (generate_relax_relocations
8548                       || (!object_64bit
8549                           && i.rm.mode == 0
8550                           && i.rm.regmem == 5))
8551                   && (i.rm.mode == 2
8552                       || (i.rm.mode == 0 && i.rm.regmem == 5))
8553                   && ((i.operands == 1
8554                        && i.tm.base_opcode == 0xff
8555                        && (i.rm.reg == 2 || i.rm.reg == 4))
8556                       || (i.operands == 2
8557                           && (i.tm.base_opcode == 0x8b
8558                               || i.tm.base_opcode == 0x85
8559                               || (i.tm.base_opcode & 0xc7) == 0x03))))
8560                 {
8561                   if (object_64bit)
8562                     {
8563                       fixP->fx_tcbit = i.rex != 0;
8564                       if (i.base_reg
8565                           && (i.base_reg->reg_num == RegIP))
8566                       fixP->fx_tcbit2 = 1;
8567                     }
8568                   else
8569                     fixP->fx_tcbit2 = 1;
8570                 }
8571             }
8572         }
8573     }
8574 }
8575
8576 static void
8577 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
8578 {
8579   char *p;
8580   unsigned int n;
8581
8582   for (n = 0; n < i.operands; n++)
8583     {
8584       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
8585       if (i.rounding && (int) n == i.rounding->operand)
8586         continue;
8587
8588       if (operand_type_check (i.types[n], imm))
8589         {
8590           if (i.op[n].imms->X_op == O_constant)
8591             {
8592               int size = imm_size (n);
8593               offsetT val;
8594
8595               val = offset_in_range (i.op[n].imms->X_add_number,
8596                                      size);
8597               p = frag_more (size);
8598               md_number_to_chars (p, val, size);
8599             }
8600           else
8601             {
8602               /* Not absolute_section.
8603                  Need a 32-bit fixup (don't support 8bit
8604                  non-absolute imms).  Try to support other
8605                  sizes ...  */
8606               enum bfd_reloc_code_real reloc_type;
8607               int size = imm_size (n);
8608               int sign;
8609
8610               if (i.types[n].bitfield.imm32s
8611                   && (i.suffix == QWORD_MNEM_SUFFIX
8612                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
8613                 sign = 1;
8614               else
8615                 sign = 0;
8616
8617               p = frag_more (size);
8618               reloc_type = reloc (size, 0, sign, i.reloc[n]);
8619
8620               /*   This is tough to explain.  We end up with this one if we
8621                * have operands that look like
8622                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
8623                * obtain the absolute address of the GOT, and it is strongly
8624                * preferable from a performance point of view to avoid using
8625                * a runtime relocation for this.  The actual sequence of
8626                * instructions often look something like:
8627                *
8628                *        call    .L66
8629                * .L66:
8630                *        popl    %ebx
8631                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
8632                *
8633                *   The call and pop essentially return the absolute address
8634                * of the label .L66 and store it in %ebx.  The linker itself
8635                * will ultimately change the first operand of the addl so
8636                * that %ebx points to the GOT, but to keep things simple, the
8637                * .o file must have this operand set so that it generates not
8638                * the absolute address of .L66, but the absolute address of
8639                * itself.  This allows the linker itself simply treat a GOTPC
8640                * relocation as asking for a pcrel offset to the GOT to be
8641                * added in, and the addend of the relocation is stored in the
8642                * operand field for the instruction itself.
8643                *
8644                *   Our job here is to fix the operand so that it would add
8645                * the correct offset so that %ebx would point to itself.  The
8646                * thing that is tricky is that .-.L66 will point to the
8647                * beginning of the instruction, so we need to further modify
8648                * the operand so that it will point to itself.  There are
8649                * other cases where you have something like:
8650                *
8651                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
8652                *
8653                * and here no correction would be required.  Internally in
8654                * the assembler we treat operands of this form as not being
8655                * pcrel since the '.' is explicitly mentioned, and I wonder
8656                * whether it would simplify matters to do it this way.  Who
8657                * knows.  In earlier versions of the PIC patches, the
8658                * pcrel_adjust field was used to store the correction, but
8659                * since the expression is not pcrel, I felt it would be
8660                * confusing to do it this way.  */
8661
8662               if ((reloc_type == BFD_RELOC_32
8663                    || reloc_type == BFD_RELOC_X86_64_32S
8664                    || reloc_type == BFD_RELOC_64)
8665                   && GOT_symbol
8666                   && GOT_symbol == i.op[n].imms->X_add_symbol
8667                   && (i.op[n].imms->X_op == O_symbol
8668                       || (i.op[n].imms->X_op == O_add
8669                           && ((symbol_get_value_expression
8670                                (i.op[n].imms->X_op_symbol)->X_op)
8671                               == O_subtract))))
8672                 {
8673                   offsetT add;
8674
8675                   if (insn_start_frag == frag_now)
8676                     add = (p - frag_now->fr_literal) - insn_start_off;
8677                   else
8678                     {
8679                       fragS *fr;
8680
8681                       add = insn_start_frag->fr_fix - insn_start_off;
8682                       for (fr = insn_start_frag->fr_next;
8683                            fr && fr != frag_now; fr = fr->fr_next)
8684                         add += fr->fr_fix;
8685                       add += p - frag_now->fr_literal;
8686                     }
8687
8688                   if (!object_64bit)
8689                     reloc_type = BFD_RELOC_386_GOTPC;
8690                   else if (size == 4)
8691                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
8692                   else if (size == 8)
8693                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
8694                   i.op[n].imms->X_add_number += add;
8695                 }
8696               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8697                            i.op[n].imms, 0, reloc_type);
8698             }
8699         }
8700     }
8701 }
8702 \f
8703 /* x86_cons_fix_new is called via the expression parsing code when a
8704    reloc is needed.  We use this hook to get the correct .got reloc.  */
8705 static int cons_sign = -1;
8706
8707 void
8708 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
8709                   expressionS *exp, bfd_reloc_code_real_type r)
8710 {
8711   r = reloc (len, 0, cons_sign, r);
8712
8713 #ifdef TE_PE
8714   if (exp->X_op == O_secrel)
8715     {
8716       exp->X_op = O_symbol;
8717       r = BFD_RELOC_32_SECREL;
8718     }
8719 #endif
8720
8721   fix_new_exp (frag, off, len, exp, 0, r);
8722 }
8723
8724 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
8725    purpose of the `.dc.a' internal pseudo-op.  */
8726
8727 int
8728 x86_address_bytes (void)
8729 {
8730   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
8731     return 4;
8732   return stdoutput->arch_info->bits_per_address / 8;
8733 }
8734
8735 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
8736     || defined (LEX_AT)
8737 # define lex_got(reloc, adjust, types) NULL
8738 #else
8739 /* Parse operands of the form
8740    <symbol>@GOTOFF+<nnn>
8741    and similar .plt or .got references.
8742
8743    If we find one, set up the correct relocation in RELOC and copy the
8744    input string, minus the `@GOTOFF' into a malloc'd buffer for
8745    parsing by the calling routine.  Return this buffer, and if ADJUST
8746    is non-null set it to the length of the string we removed from the
8747    input line.  Otherwise return NULL.  */
8748 static char *
8749 lex_got (enum bfd_reloc_code_real *rel,
8750          int *adjust,
8751          i386_operand_type *types)
8752 {
8753   /* Some of the relocations depend on the size of what field is to
8754      be relocated.  But in our callers i386_immediate and i386_displacement
8755      we don't yet know the operand size (this will be set by insn
8756      matching).  Hence we record the word32 relocation here,
8757      and adjust the reloc according to the real size in reloc().  */
8758   static const struct {
8759     const char *str;
8760     int len;
8761     const enum bfd_reloc_code_real rel[2];
8762     const i386_operand_type types64;
8763   } gotrel[] = {
8764 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8765     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
8766                                         BFD_RELOC_SIZE32 },
8767       OPERAND_TYPE_IMM32_64 },
8768 #endif
8769     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
8770                                        BFD_RELOC_X86_64_PLTOFF64 },
8771       OPERAND_TYPE_IMM64 },
8772     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
8773                                        BFD_RELOC_X86_64_PLT32    },
8774       OPERAND_TYPE_IMM32_32S_DISP32 },
8775     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
8776                                        BFD_RELOC_X86_64_GOTPLT64 },
8777       OPERAND_TYPE_IMM64_DISP64 },
8778     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
8779                                        BFD_RELOC_X86_64_GOTOFF64 },
8780       OPERAND_TYPE_IMM64_DISP64 },
8781     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
8782                                        BFD_RELOC_X86_64_GOTPCREL },
8783       OPERAND_TYPE_IMM32_32S_DISP32 },
8784     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
8785                                        BFD_RELOC_X86_64_TLSGD    },
8786       OPERAND_TYPE_IMM32_32S_DISP32 },
8787     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
8788                                        _dummy_first_bfd_reloc_code_real },
8789       OPERAND_TYPE_NONE },
8790     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
8791                                        BFD_RELOC_X86_64_TLSLD    },
8792       OPERAND_TYPE_IMM32_32S_DISP32 },
8793     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
8794                                        BFD_RELOC_X86_64_GOTTPOFF },
8795       OPERAND_TYPE_IMM32_32S_DISP32 },
8796     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
8797                                        BFD_RELOC_X86_64_TPOFF32  },
8798       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8799     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
8800                                        _dummy_first_bfd_reloc_code_real },
8801       OPERAND_TYPE_NONE },
8802     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
8803                                        BFD_RELOC_X86_64_DTPOFF32 },
8804       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8805     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
8806                                        _dummy_first_bfd_reloc_code_real },
8807       OPERAND_TYPE_NONE },
8808     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
8809                                        _dummy_first_bfd_reloc_code_real },
8810       OPERAND_TYPE_NONE },
8811     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
8812                                        BFD_RELOC_X86_64_GOT32    },
8813       OPERAND_TYPE_IMM32_32S_64_DISP32 },
8814     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
8815                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
8816       OPERAND_TYPE_IMM32_32S_DISP32 },
8817     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
8818                                        BFD_RELOC_X86_64_TLSDESC_CALL },
8819       OPERAND_TYPE_IMM32_32S_DISP32 },
8820   };
8821   char *cp;
8822   unsigned int j;
8823
8824 #if defined (OBJ_MAYBE_ELF)
8825   if (!IS_ELF)
8826     return NULL;
8827 #endif
8828
8829   for (cp = input_line_pointer; *cp != '@'; cp++)
8830     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
8831       return NULL;
8832
8833   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
8834     {
8835       int len = gotrel[j].len;
8836       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
8837         {
8838           if (gotrel[j].rel[object_64bit] != 0)
8839             {
8840               int first, second;
8841               char *tmpbuf, *past_reloc;
8842
8843               *rel = gotrel[j].rel[object_64bit];
8844
8845               if (types)
8846                 {
8847                   if (flag_code != CODE_64BIT)
8848                     {
8849                       types->bitfield.imm32 = 1;
8850                       types->bitfield.disp32 = 1;
8851                     }
8852                   else
8853                     *types = gotrel[j].types64;
8854                 }
8855
8856               if (j != 0 && GOT_symbol == NULL)
8857                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
8858
8859               /* The length of the first part of our input line.  */
8860               first = cp - input_line_pointer;
8861
8862               /* The second part goes from after the reloc token until
8863                  (and including) an end_of_line char or comma.  */
8864               past_reloc = cp + 1 + len;
8865               cp = past_reloc;
8866               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
8867                 ++cp;
8868               second = cp + 1 - past_reloc;
8869
8870               /* Allocate and copy string.  The trailing NUL shouldn't
8871                  be necessary, but be safe.  */
8872               tmpbuf = XNEWVEC (char, first + second + 2);
8873               memcpy (tmpbuf, input_line_pointer, first);
8874               if (second != 0 && *past_reloc != ' ')
8875                 /* Replace the relocation token with ' ', so that
8876                    errors like foo@GOTOFF1 will be detected.  */
8877                 tmpbuf[first++] = ' ';
8878               else
8879                 /* Increment length by 1 if the relocation token is
8880                    removed.  */
8881                 len++;
8882               if (adjust)
8883                 *adjust = len;
8884               memcpy (tmpbuf + first, past_reloc, second);
8885               tmpbuf[first + second] = '\0';
8886               return tmpbuf;
8887             }
8888
8889           as_bad (_("@%s reloc is not supported with %d-bit output format"),
8890                   gotrel[j].str, 1 << (5 + object_64bit));
8891           return NULL;
8892         }
8893     }
8894
8895   /* Might be a symbol version string.  Don't as_bad here.  */
8896   return NULL;
8897 }
8898 #endif
8899
8900 #ifdef TE_PE
8901 #ifdef lex_got
8902 #undef lex_got
8903 #endif
8904 /* Parse operands of the form
8905    <symbol>@SECREL32+<nnn>
8906
8907    If we find one, set up the correct relocation in RELOC and copy the
8908    input string, minus the `@SECREL32' into a malloc'd buffer for
8909    parsing by the calling routine.  Return this buffer, and if ADJUST
8910    is non-null set it to the length of the string we removed from the
8911    input line.  Otherwise return NULL.
8912
8913    This function is copied from the ELF version above adjusted for PE targets.  */
8914
8915 static char *
8916 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
8917          int *adjust ATTRIBUTE_UNUSED,
8918          i386_operand_type *types)
8919 {
8920   static const struct
8921   {
8922     const char *str;
8923     int len;
8924     const enum bfd_reloc_code_real rel[2];
8925     const i386_operand_type types64;
8926   }
8927   gotrel[] =
8928   {
8929     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
8930                                           BFD_RELOC_32_SECREL },
8931       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8932   };
8933
8934   char *cp;
8935   unsigned j;
8936
8937   for (cp = input_line_pointer; *cp != '@'; cp++)
8938     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
8939       return NULL;
8940
8941   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
8942     {
8943       int len = gotrel[j].len;
8944
8945       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
8946         {
8947           if (gotrel[j].rel[object_64bit] != 0)
8948             {
8949               int first, second;
8950               char *tmpbuf, *past_reloc;
8951
8952               *rel = gotrel[j].rel[object_64bit];
8953               if (adjust)
8954                 *adjust = len;
8955
8956               if (types)
8957                 {
8958                   if (flag_code != CODE_64BIT)
8959                     {
8960                       types->bitfield.imm32 = 1;
8961                       types->bitfield.disp32 = 1;
8962                     }
8963                   else
8964                     *types = gotrel[j].types64;
8965                 }
8966
8967               /* The length of the first part of our input line.  */
8968               first = cp - input_line_pointer;
8969
8970               /* The second part goes from after the reloc token until
8971                  (and including) an end_of_line char or comma.  */
8972               past_reloc = cp + 1 + len;
8973               cp = past_reloc;
8974               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
8975                 ++cp;
8976               second = cp + 1 - past_reloc;
8977
8978               /* Allocate and copy string.  The trailing NUL shouldn't
8979                  be necessary, but be safe.  */
8980               tmpbuf = XNEWVEC (char, first + second + 2);
8981               memcpy (tmpbuf, input_line_pointer, first);
8982               if (second != 0 && *past_reloc != ' ')
8983                 /* Replace the relocation token with ' ', so that
8984                    errors like foo@SECLREL321 will be detected.  */
8985                 tmpbuf[first++] = ' ';
8986               memcpy (tmpbuf + first, past_reloc, second);
8987               tmpbuf[first + second] = '\0';
8988               return tmpbuf;
8989             }
8990
8991           as_bad (_("@%s reloc is not supported with %d-bit output format"),
8992                   gotrel[j].str, 1 << (5 + object_64bit));
8993           return NULL;
8994         }
8995     }
8996
8997   /* Might be a symbol version string.  Don't as_bad here.  */
8998   return NULL;
8999 }
9000
9001 #endif /* TE_PE */
9002
9003 bfd_reloc_code_real_type
9004 x86_cons (expressionS *exp, int size)
9005 {
9006   bfd_reloc_code_real_type got_reloc = NO_RELOC;
9007
9008   intel_syntax = -intel_syntax;
9009
9010   exp->X_md = 0;
9011   if (size == 4 || (object_64bit && size == 8))
9012     {
9013       /* Handle @GOTOFF and the like in an expression.  */
9014       char *save;
9015       char *gotfree_input_line;
9016       int adjust = 0;
9017
9018       save = input_line_pointer;
9019       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
9020       if (gotfree_input_line)
9021         input_line_pointer = gotfree_input_line;
9022
9023       expression (exp);
9024
9025       if (gotfree_input_line)
9026         {
9027           /* expression () has merrily parsed up to the end of line,
9028              or a comma - in the wrong buffer.  Transfer how far
9029              input_line_pointer has moved to the right buffer.  */
9030           input_line_pointer = (save
9031                                 + (input_line_pointer - gotfree_input_line)
9032                                 + adjust);
9033           free (gotfree_input_line);
9034           if (exp->X_op == O_constant
9035               || exp->X_op == O_absent
9036               || exp->X_op == O_illegal
9037               || exp->X_op == O_register
9038               || exp->X_op == O_big)
9039             {
9040               char c = *input_line_pointer;
9041               *input_line_pointer = 0;
9042               as_bad (_("missing or invalid expression `%s'"), save);
9043               *input_line_pointer = c;
9044             }
9045           else if ((got_reloc == BFD_RELOC_386_PLT32
9046                     || got_reloc == BFD_RELOC_X86_64_PLT32)
9047                    && exp->X_op != O_symbol)
9048             {
9049               char c = *input_line_pointer;
9050               *input_line_pointer = 0;
9051               as_bad (_("invalid PLT expression `%s'"), save);
9052               *input_line_pointer = c;
9053             }
9054         }
9055     }
9056   else
9057     expression (exp);
9058
9059   intel_syntax = -intel_syntax;
9060
9061   if (intel_syntax)
9062     i386_intel_simplify (exp);
9063
9064   return got_reloc;
9065 }
9066
9067 static void
9068 signed_cons (int size)
9069 {
9070   if (flag_code == CODE_64BIT)
9071     cons_sign = 1;
9072   cons (size);
9073   cons_sign = -1;
9074 }
9075
9076 #ifdef TE_PE
9077 static void
9078 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
9079 {
9080   expressionS exp;
9081
9082   do
9083     {
9084       expression (&exp);
9085       if (exp.X_op == O_symbol)
9086         exp.X_op = O_secrel;
9087
9088       emit_expr (&exp, 4);
9089     }
9090   while (*input_line_pointer++ == ',');
9091
9092   input_line_pointer--;
9093   demand_empty_rest_of_line ();
9094 }
9095 #endif
9096
9097 /* Handle Vector operations.  */
9098
9099 static char *
9100 check_VecOperations (char *op_string, char *op_end)
9101 {
9102   const reg_entry *mask;
9103   const char *saved;
9104   char *end_op;
9105
9106   while (*op_string
9107          && (op_end == NULL || op_string < op_end))
9108     {
9109       saved = op_string;
9110       if (*op_string == '{')
9111         {
9112           op_string++;
9113
9114           /* Check broadcasts.  */
9115           if (strncmp (op_string, "1to", 3) == 0)
9116             {
9117               int bcst_type;
9118
9119               if (i.broadcast)
9120                 goto duplicated_vec_op;
9121
9122               op_string += 3;
9123               if (*op_string == '8')
9124                 bcst_type = 8;
9125               else if (*op_string == '4')
9126                 bcst_type = 4;
9127               else if (*op_string == '2')
9128                 bcst_type = 2;
9129               else if (*op_string == '1'
9130                        && *(op_string+1) == '6')
9131                 {
9132                   bcst_type = 16;
9133                   op_string++;
9134                 }
9135               else
9136                 {
9137                   as_bad (_("Unsupported broadcast: `%s'"), saved);
9138                   return NULL;
9139                 }
9140               op_string++;
9141
9142               broadcast_op.type = bcst_type;
9143               broadcast_op.operand = this_operand;
9144               broadcast_op.bytes = 0;
9145               i.broadcast = &broadcast_op;
9146             }
9147           /* Check masking operation.  */
9148           else if ((mask = parse_register (op_string, &end_op)) != NULL)
9149             {
9150               /* k0 can't be used for write mask.  */
9151               if (!mask->reg_type.bitfield.regmask || mask->reg_num == 0)
9152                 {
9153                   as_bad (_("`%s%s' can't be used for write mask"),
9154                           register_prefix, mask->reg_name);
9155                   return NULL;
9156                 }
9157
9158               if (!i.mask)
9159                 {
9160                   mask_op.mask = mask;
9161                   mask_op.zeroing = 0;
9162                   mask_op.operand = this_operand;
9163                   i.mask = &mask_op;
9164                 }
9165               else
9166                 {
9167                   if (i.mask->mask)
9168                     goto duplicated_vec_op;
9169
9170                   i.mask->mask = mask;
9171
9172                   /* Only "{z}" is allowed here.  No need to check
9173                      zeroing mask explicitly.  */
9174                   if (i.mask->operand != this_operand)
9175                     {
9176                       as_bad (_("invalid write mask `%s'"), saved);
9177                       return NULL;
9178                     }
9179                 }
9180
9181               op_string = end_op;
9182             }
9183           /* Check zeroing-flag for masking operation.  */
9184           else if (*op_string == 'z')
9185             {
9186               if (!i.mask)
9187                 {
9188                   mask_op.mask = NULL;
9189                   mask_op.zeroing = 1;
9190                   mask_op.operand = this_operand;
9191                   i.mask = &mask_op;
9192                 }
9193               else
9194                 {
9195                   if (i.mask->zeroing)
9196                     {
9197                     duplicated_vec_op:
9198                       as_bad (_("duplicated `%s'"), saved);
9199                       return NULL;
9200                     }
9201
9202                   i.mask->zeroing = 1;
9203
9204                   /* Only "{%k}" is allowed here.  No need to check mask
9205                      register explicitly.  */
9206                   if (i.mask->operand != this_operand)
9207                     {
9208                       as_bad (_("invalid zeroing-masking `%s'"),
9209                               saved);
9210                       return NULL;
9211                     }
9212                 }
9213
9214               op_string++;
9215             }
9216           else
9217             goto unknown_vec_op;
9218
9219           if (*op_string != '}')
9220             {
9221               as_bad (_("missing `}' in `%s'"), saved);
9222               return NULL;
9223             }
9224           op_string++;
9225
9226           /* Strip whitespace since the addition of pseudo prefixes
9227              changed how the scrubber treats '{'.  */
9228           if (is_space_char (*op_string))
9229             ++op_string;
9230
9231           continue;
9232         }
9233     unknown_vec_op:
9234       /* We don't know this one.  */
9235       as_bad (_("unknown vector operation: `%s'"), saved);
9236       return NULL;
9237     }
9238
9239   if (i.mask && i.mask->zeroing && !i.mask->mask)
9240     {
9241       as_bad (_("zeroing-masking only allowed with write mask"));
9242       return NULL;
9243     }
9244
9245   return op_string;
9246 }
9247
9248 static int
9249 i386_immediate (char *imm_start)
9250 {
9251   char *save_input_line_pointer;
9252   char *gotfree_input_line;
9253   segT exp_seg = 0;
9254   expressionS *exp;
9255   i386_operand_type types;
9256
9257   operand_type_set (&types, ~0);
9258
9259   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
9260     {
9261       as_bad (_("at most %d immediate operands are allowed"),
9262               MAX_IMMEDIATE_OPERANDS);
9263       return 0;
9264     }
9265
9266   exp = &im_expressions[i.imm_operands++];
9267   i.op[this_operand].imms = exp;
9268
9269   if (is_space_char (*imm_start))
9270     ++imm_start;
9271
9272   save_input_line_pointer = input_line_pointer;
9273   input_line_pointer = imm_start;
9274
9275   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
9276   if (gotfree_input_line)
9277     input_line_pointer = gotfree_input_line;
9278
9279   exp_seg = expression (exp);
9280
9281   SKIP_WHITESPACE ();
9282
9283   /* Handle vector operations.  */
9284   if (*input_line_pointer == '{')
9285     {
9286       input_line_pointer = check_VecOperations (input_line_pointer,
9287                                                 NULL);
9288       if (input_line_pointer == NULL)
9289         return 0;
9290     }
9291
9292   if (*input_line_pointer)
9293     as_bad (_("junk `%s' after expression"), input_line_pointer);
9294
9295   input_line_pointer = save_input_line_pointer;
9296   if (gotfree_input_line)
9297     {
9298       free (gotfree_input_line);
9299
9300       if (exp->X_op == O_constant || exp->X_op == O_register)
9301         exp->X_op = O_illegal;
9302     }
9303
9304   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
9305 }
9306
9307 static int
9308 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
9309                          i386_operand_type types, const char *imm_start)
9310 {
9311   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
9312     {
9313       if (imm_start)
9314         as_bad (_("missing or invalid immediate expression `%s'"),
9315                 imm_start);
9316       return 0;
9317     }
9318   else if (exp->X_op == O_constant)
9319     {
9320       /* Size it properly later.  */
9321       i.types[this_operand].bitfield.imm64 = 1;
9322       /* If not 64bit, sign extend val.  */
9323       if (flag_code != CODE_64BIT
9324           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
9325         exp->X_add_number
9326           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
9327     }
9328 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
9329   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
9330            && exp_seg != absolute_section
9331            && exp_seg != text_section
9332            && exp_seg != data_section
9333            && exp_seg != bss_section
9334            && exp_seg != undefined_section
9335            && !bfd_is_com_section (exp_seg))
9336     {
9337       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
9338       return 0;
9339     }
9340 #endif
9341   else if (!intel_syntax && exp_seg == reg_section)
9342     {
9343       if (imm_start)
9344         as_bad (_("illegal immediate register operand %s"), imm_start);
9345       return 0;
9346     }
9347   else
9348     {
9349       /* This is an address.  The size of the address will be
9350          determined later, depending on destination register,
9351          suffix, or the default for the section.  */
9352       i.types[this_operand].bitfield.imm8 = 1;
9353       i.types[this_operand].bitfield.imm16 = 1;
9354       i.types[this_operand].bitfield.imm32 = 1;
9355       i.types[this_operand].bitfield.imm32s = 1;
9356       i.types[this_operand].bitfield.imm64 = 1;
9357       i.types[this_operand] = operand_type_and (i.types[this_operand],
9358                                                 types);
9359     }
9360
9361   return 1;
9362 }
9363
9364 static char *
9365 i386_scale (char *scale)
9366 {
9367   offsetT val;
9368   char *save = input_line_pointer;
9369
9370   input_line_pointer = scale;
9371   val = get_absolute_expression ();
9372
9373   switch (val)
9374     {
9375     case 1:
9376       i.log2_scale_factor = 0;
9377       break;
9378     case 2:
9379       i.log2_scale_factor = 1;
9380       break;
9381     case 4:
9382       i.log2_scale_factor = 2;
9383       break;
9384     case 8:
9385       i.log2_scale_factor = 3;
9386       break;
9387     default:
9388       {
9389         char sep = *input_line_pointer;
9390
9391         *input_line_pointer = '\0';
9392         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
9393                 scale);
9394         *input_line_pointer = sep;
9395         input_line_pointer = save;
9396         return NULL;
9397       }
9398     }
9399   if (i.log2_scale_factor != 0 && i.index_reg == 0)
9400     {
9401       as_warn (_("scale factor of %d without an index register"),
9402                1 << i.log2_scale_factor);
9403       i.log2_scale_factor = 0;
9404     }
9405   scale = input_line_pointer;
9406   input_line_pointer = save;
9407   return scale;
9408 }
9409
9410 static int
9411 i386_displacement (char *disp_start, char *disp_end)
9412 {
9413   expressionS *exp;
9414   segT exp_seg = 0;
9415   char *save_input_line_pointer;
9416   char *gotfree_input_line;
9417   int override;
9418   i386_operand_type bigdisp, types = anydisp;
9419   int ret;
9420
9421   if (i.disp_operands == MAX_MEMORY_OPERANDS)
9422     {
9423       as_bad (_("at most %d displacement operands are allowed"),
9424               MAX_MEMORY_OPERANDS);
9425       return 0;
9426     }
9427
9428   operand_type_set (&bigdisp, 0);
9429   if ((i.types[this_operand].bitfield.jumpabsolute)
9430       || (!current_templates->start->opcode_modifier.jump
9431           && !current_templates->start->opcode_modifier.jumpdword))
9432     {
9433       bigdisp.bitfield.disp32 = 1;
9434       override = (i.prefix[ADDR_PREFIX] != 0);
9435       if (flag_code == CODE_64BIT)
9436         {
9437           if (!override)
9438             {
9439               bigdisp.bitfield.disp32s = 1;
9440               bigdisp.bitfield.disp64 = 1;
9441             }
9442         }
9443       else if ((flag_code == CODE_16BIT) ^ override)
9444         {
9445           bigdisp.bitfield.disp32 = 0;
9446           bigdisp.bitfield.disp16 = 1;
9447         }
9448     }
9449   else
9450     {
9451       /* For PC-relative branches, the width of the displacement
9452          is dependent upon data size, not address size.  */
9453       override = (i.prefix[DATA_PREFIX] != 0);
9454       if (flag_code == CODE_64BIT)
9455         {
9456           if (override || i.suffix == WORD_MNEM_SUFFIX)
9457             bigdisp.bitfield.disp16 = 1;
9458           else
9459             {
9460               bigdisp.bitfield.disp32 = 1;
9461               bigdisp.bitfield.disp32s = 1;
9462             }
9463         }
9464       else
9465         {
9466           if (!override)
9467             override = (i.suffix == (flag_code != CODE_16BIT
9468                                      ? WORD_MNEM_SUFFIX
9469                                      : LONG_MNEM_SUFFIX));
9470           bigdisp.bitfield.disp32 = 1;
9471           if ((flag_code == CODE_16BIT) ^ override)
9472             {
9473               bigdisp.bitfield.disp32 = 0;
9474               bigdisp.bitfield.disp16 = 1;
9475             }
9476         }
9477     }
9478   i.types[this_operand] = operand_type_or (i.types[this_operand],
9479                                            bigdisp);
9480
9481   exp = &disp_expressions[i.disp_operands];
9482   i.op[this_operand].disps = exp;
9483   i.disp_operands++;
9484   save_input_line_pointer = input_line_pointer;
9485   input_line_pointer = disp_start;
9486   END_STRING_AND_SAVE (disp_end);
9487
9488 #ifndef GCC_ASM_O_HACK
9489 #define GCC_ASM_O_HACK 0
9490 #endif
9491 #if GCC_ASM_O_HACK
9492   END_STRING_AND_SAVE (disp_end + 1);
9493   if (i.types[this_operand].bitfield.baseIndex
9494       && displacement_string_end[-1] == '+')
9495     {
9496       /* This hack is to avoid a warning when using the "o"
9497          constraint within gcc asm statements.
9498          For instance:
9499
9500          #define _set_tssldt_desc(n,addr,limit,type) \
9501          __asm__ __volatile__ ( \
9502          "movw %w2,%0\n\t" \
9503          "movw %w1,2+%0\n\t" \
9504          "rorl $16,%1\n\t" \
9505          "movb %b1,4+%0\n\t" \
9506          "movb %4,5+%0\n\t" \
9507          "movb $0,6+%0\n\t" \
9508          "movb %h1,7+%0\n\t" \
9509          "rorl $16,%1" \
9510          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
9511
9512          This works great except that the output assembler ends
9513          up looking a bit weird if it turns out that there is
9514          no offset.  You end up producing code that looks like:
9515
9516          #APP
9517          movw $235,(%eax)
9518          movw %dx,2+(%eax)
9519          rorl $16,%edx
9520          movb %dl,4+(%eax)
9521          movb $137,5+(%eax)
9522          movb $0,6+(%eax)
9523          movb %dh,7+(%eax)
9524          rorl $16,%edx
9525          #NO_APP
9526
9527          So here we provide the missing zero.  */
9528
9529       *displacement_string_end = '0';
9530     }
9531 #endif
9532   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
9533   if (gotfree_input_line)
9534     input_line_pointer = gotfree_input_line;
9535
9536   exp_seg = expression (exp);
9537
9538   SKIP_WHITESPACE ();
9539   if (*input_line_pointer)
9540     as_bad (_("junk `%s' after expression"), input_line_pointer);
9541 #if GCC_ASM_O_HACK
9542   RESTORE_END_STRING (disp_end + 1);
9543 #endif
9544   input_line_pointer = save_input_line_pointer;
9545   if (gotfree_input_line)
9546     {
9547       free (gotfree_input_line);
9548
9549       if (exp->X_op == O_constant || exp->X_op == O_register)
9550         exp->X_op = O_illegal;
9551     }
9552
9553   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
9554
9555   RESTORE_END_STRING (disp_end);
9556
9557   return ret;
9558 }
9559
9560 static int
9561 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
9562                             i386_operand_type types, const char *disp_start)
9563 {
9564   i386_operand_type bigdisp;
9565   int ret = 1;
9566
9567   /* We do this to make sure that the section symbol is in
9568      the symbol table.  We will ultimately change the relocation
9569      to be relative to the beginning of the section.  */
9570   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
9571       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
9572       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
9573     {
9574       if (exp->X_op != O_symbol)
9575         goto inv_disp;
9576
9577       if (S_IS_LOCAL (exp->X_add_symbol)
9578           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
9579           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
9580         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
9581       exp->X_op = O_subtract;
9582       exp->X_op_symbol = GOT_symbol;
9583       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
9584         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
9585       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
9586         i.reloc[this_operand] = BFD_RELOC_64;
9587       else
9588         i.reloc[this_operand] = BFD_RELOC_32;
9589     }
9590
9591   else if (exp->X_op == O_absent
9592            || exp->X_op == O_illegal
9593            || exp->X_op == O_big)
9594     {
9595     inv_disp:
9596       as_bad (_("missing or invalid displacement expression `%s'"),
9597               disp_start);
9598       ret = 0;
9599     }
9600
9601   else if (flag_code == CODE_64BIT
9602            && !i.prefix[ADDR_PREFIX]
9603            && exp->X_op == O_constant)
9604     {
9605       /* Since displacement is signed extended to 64bit, don't allow
9606          disp32 and turn off disp32s if they are out of range.  */
9607       i.types[this_operand].bitfield.disp32 = 0;
9608       if (!fits_in_signed_long (exp->X_add_number))
9609         {
9610           i.types[this_operand].bitfield.disp32s = 0;
9611           if (i.types[this_operand].bitfield.baseindex)
9612             {
9613               as_bad (_("0x%lx out range of signed 32bit displacement"),
9614                       (long) exp->X_add_number);
9615               ret = 0;
9616             }
9617         }
9618     }
9619
9620 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
9621   else if (exp->X_op != O_constant
9622            && OUTPUT_FLAVOR == bfd_target_aout_flavour
9623            && exp_seg != absolute_section
9624            && exp_seg != text_section
9625            && exp_seg != data_section
9626            && exp_seg != bss_section
9627            && exp_seg != undefined_section
9628            && !bfd_is_com_section (exp_seg))
9629     {
9630       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
9631       ret = 0;
9632     }
9633 #endif
9634
9635   /* Check if this is a displacement only operand.  */
9636   bigdisp = i.types[this_operand];
9637   bigdisp.bitfield.disp8 = 0;
9638   bigdisp.bitfield.disp16 = 0;
9639   bigdisp.bitfield.disp32 = 0;
9640   bigdisp.bitfield.disp32s = 0;
9641   bigdisp.bitfield.disp64 = 0;
9642   if (operand_type_all_zero (&bigdisp))
9643     i.types[this_operand] = operand_type_and (i.types[this_operand],
9644                                               types);
9645
9646   return ret;
9647 }
9648
9649 /* Return the active addressing mode, taking address override and
9650    registers forming the address into consideration.  Update the
9651    address override prefix if necessary.  */
9652
9653 static enum flag_code
9654 i386_addressing_mode (void)
9655 {
9656   enum flag_code addr_mode;
9657
9658   if (i.prefix[ADDR_PREFIX])
9659     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
9660   else
9661     {
9662       addr_mode = flag_code;
9663
9664 #if INFER_ADDR_PREFIX
9665       if (i.mem_operands == 0)
9666         {
9667           /* Infer address prefix from the first memory operand.  */
9668           const reg_entry *addr_reg = i.base_reg;
9669
9670           if (addr_reg == NULL)
9671             addr_reg = i.index_reg;
9672
9673           if (addr_reg)
9674             {
9675               if (addr_reg->reg_type.bitfield.dword)
9676                 addr_mode = CODE_32BIT;
9677               else if (flag_code != CODE_64BIT
9678                        && addr_reg->reg_type.bitfield.word)
9679                 addr_mode = CODE_16BIT;
9680
9681               if (addr_mode != flag_code)
9682                 {
9683                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
9684                   i.prefixes += 1;
9685                   /* Change the size of any displacement too.  At most one
9686                      of Disp16 or Disp32 is set.
9687                      FIXME.  There doesn't seem to be any real need for
9688                      separate Disp16 and Disp32 flags.  The same goes for
9689                      Imm16 and Imm32.  Removing them would probably clean
9690                      up the code quite a lot.  */
9691                   if (flag_code != CODE_64BIT
9692                       && (i.types[this_operand].bitfield.disp16
9693                           || i.types[this_operand].bitfield.disp32))
9694                     i.types[this_operand]
9695                       = operand_type_xor (i.types[this_operand], disp16_32);
9696                 }
9697             }
9698         }
9699 #endif
9700     }
9701
9702   return addr_mode;
9703 }
9704
9705 /* Make sure the memory operand we've been dealt is valid.
9706    Return 1 on success, 0 on a failure.  */
9707
9708 static int
9709 i386_index_check (const char *operand_string)
9710 {
9711   const char *kind = "base/index";
9712   enum flag_code addr_mode = i386_addressing_mode ();
9713
9714   if (current_templates->start->opcode_modifier.isstring
9715       && !current_templates->start->opcode_modifier.immext
9716       && (current_templates->end[-1].opcode_modifier.isstring
9717           || i.mem_operands))
9718     {
9719       /* Memory operands of string insns are special in that they only allow
9720          a single register (rDI, rSI, or rBX) as their memory address.  */
9721       const reg_entry *expected_reg;
9722       static const char *di_si[][2] =
9723         {
9724           { "esi", "edi" },
9725           { "si", "di" },
9726           { "rsi", "rdi" }
9727         };
9728       static const char *bx[] = { "ebx", "bx", "rbx" };
9729
9730       kind = "string address";
9731
9732       if (current_templates->start->opcode_modifier.repprefixok)
9733         {
9734           i386_operand_type type = current_templates->end[-1].operand_types[0];
9735
9736           if (!type.bitfield.baseindex
9737               || ((!i.mem_operands != !intel_syntax)
9738                   && current_templates->end[-1].operand_types[1]
9739                      .bitfield.baseindex))
9740             type = current_templates->end[-1].operand_types[1];
9741           expected_reg = hash_find (reg_hash,
9742                                     di_si[addr_mode][type.bitfield.esseg]);
9743
9744         }
9745       else
9746         expected_reg = hash_find (reg_hash, bx[addr_mode]);
9747
9748       if (i.base_reg != expected_reg
9749           || i.index_reg
9750           || operand_type_check (i.types[this_operand], disp))
9751         {
9752           /* The second memory operand must have the same size as
9753              the first one.  */
9754           if (i.mem_operands
9755               && i.base_reg
9756               && !((addr_mode == CODE_64BIT
9757                     && i.base_reg->reg_type.bitfield.qword)
9758                    || (addr_mode == CODE_32BIT
9759                        ? i.base_reg->reg_type.bitfield.dword
9760                        : i.base_reg->reg_type.bitfield.word)))
9761             goto bad_address;
9762
9763           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
9764                    operand_string,
9765                    intel_syntax ? '[' : '(',
9766                    register_prefix,
9767                    expected_reg->reg_name,
9768                    intel_syntax ? ']' : ')');
9769           return 1;
9770         }
9771       else
9772         return 1;
9773
9774 bad_address:
9775       as_bad (_("`%s' is not a valid %s expression"),
9776               operand_string, kind);
9777       return 0;
9778     }
9779   else
9780     {
9781       if (addr_mode != CODE_16BIT)
9782         {
9783           /* 32-bit/64-bit checks.  */
9784           if ((i.base_reg
9785                && ((addr_mode == CODE_64BIT
9786                     ? !i.base_reg->reg_type.bitfield.qword
9787                     : !i.base_reg->reg_type.bitfield.dword)
9788                    || (i.index_reg && i.base_reg->reg_num == RegIP)
9789                    || i.base_reg->reg_num == RegIZ))
9790               || (i.index_reg
9791                   && !i.index_reg->reg_type.bitfield.xmmword
9792                   && !i.index_reg->reg_type.bitfield.ymmword
9793                   && !i.index_reg->reg_type.bitfield.zmmword
9794                   && ((addr_mode == CODE_64BIT
9795                        ? !i.index_reg->reg_type.bitfield.qword
9796                        : !i.index_reg->reg_type.bitfield.dword)
9797                       || !i.index_reg->reg_type.bitfield.baseindex)))
9798             goto bad_address;
9799
9800           /* bndmk, bndldx, and bndstx have special restrictions. */
9801           if (current_templates->start->base_opcode == 0xf30f1b
9802               || (current_templates->start->base_opcode & ~1) == 0x0f1a)
9803             {
9804               /* They cannot use RIP-relative addressing. */
9805               if (i.base_reg && i.base_reg->reg_num == RegIP)
9806                 {
9807                   as_bad (_("`%s' cannot be used here"), operand_string);
9808                   return 0;
9809                 }
9810
9811               /* bndldx and bndstx ignore their scale factor. */
9812               if (current_templates->start->base_opcode != 0xf30f1b
9813                   && i.log2_scale_factor)
9814                 as_warn (_("register scaling is being ignored here"));
9815             }
9816         }
9817       else
9818         {
9819           /* 16-bit checks.  */
9820           if ((i.base_reg
9821                && (!i.base_reg->reg_type.bitfield.word
9822                    || !i.base_reg->reg_type.bitfield.baseindex))
9823               || (i.index_reg
9824                   && (!i.index_reg->reg_type.bitfield.word
9825                       || !i.index_reg->reg_type.bitfield.baseindex
9826                       || !(i.base_reg
9827                            && i.base_reg->reg_num < 6
9828                            && i.index_reg->reg_num >= 6
9829                            && i.log2_scale_factor == 0))))
9830             goto bad_address;
9831         }
9832     }
9833   return 1;
9834 }
9835
9836 /* Handle vector immediates.  */
9837
9838 static int
9839 RC_SAE_immediate (const char *imm_start)
9840 {
9841   unsigned int match_found, j;
9842   const char *pstr = imm_start;
9843   expressionS *exp;
9844
9845   if (*pstr != '{')
9846     return 0;
9847
9848   pstr++;
9849   match_found = 0;
9850   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
9851     {
9852       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
9853         {
9854           if (!i.rounding)
9855             {
9856               rc_op.type = RC_NamesTable[j].type;
9857               rc_op.operand = this_operand;
9858               i.rounding = &rc_op;
9859             }
9860           else
9861             {
9862               as_bad (_("duplicated `%s'"), imm_start);
9863               return 0;
9864             }
9865           pstr += RC_NamesTable[j].len;
9866           match_found = 1;
9867           break;
9868         }
9869     }
9870   if (!match_found)
9871     return 0;
9872
9873   if (*pstr++ != '}')
9874     {
9875       as_bad (_("Missing '}': '%s'"), imm_start);
9876       return 0;
9877     }
9878   /* RC/SAE immediate string should contain nothing more.  */;
9879   if (*pstr != 0)
9880     {
9881       as_bad (_("Junk after '}': '%s'"), imm_start);
9882       return 0;
9883     }
9884
9885   exp = &im_expressions[i.imm_operands++];
9886   i.op[this_operand].imms = exp;
9887
9888   exp->X_op = O_constant;
9889   exp->X_add_number = 0;
9890   exp->X_add_symbol = (symbolS *) 0;
9891   exp->X_op_symbol = (symbolS *) 0;
9892
9893   i.types[this_operand].bitfield.imm8 = 1;
9894   return 1;
9895 }
9896
9897 /* Only string instructions can have a second memory operand, so
9898    reduce current_templates to just those if it contains any.  */
9899 static int
9900 maybe_adjust_templates (void)
9901 {
9902   const insn_template *t;
9903
9904   gas_assert (i.mem_operands == 1);
9905
9906   for (t = current_templates->start; t < current_templates->end; ++t)
9907     if (t->opcode_modifier.isstring)
9908       break;
9909
9910   if (t < current_templates->end)
9911     {
9912       static templates aux_templates;
9913       bfd_boolean recheck;
9914
9915       aux_templates.start = t;
9916       for (; t < current_templates->end; ++t)
9917         if (!t->opcode_modifier.isstring)
9918           break;
9919       aux_templates.end = t;
9920
9921       /* Determine whether to re-check the first memory operand.  */
9922       recheck = (aux_templates.start != current_templates->start
9923                  || t != current_templates->end);
9924
9925       current_templates = &aux_templates;
9926
9927       if (recheck)
9928         {
9929           i.mem_operands = 0;
9930           if (i.memop1_string != NULL
9931               && i386_index_check (i.memop1_string) == 0)
9932             return 0;
9933           i.mem_operands = 1;
9934         }
9935     }
9936
9937   return 1;
9938 }
9939
9940 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
9941    on error.  */
9942
9943 static int
9944 i386_att_operand (char *operand_string)
9945 {
9946   const reg_entry *r;
9947   char *end_op;
9948   char *op_string = operand_string;
9949
9950   if (is_space_char (*op_string))
9951     ++op_string;
9952
9953   /* We check for an absolute prefix (differentiating,
9954      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
9955   if (*op_string == ABSOLUTE_PREFIX)
9956     {
9957       ++op_string;
9958       if (is_space_char (*op_string))
9959         ++op_string;
9960       i.types[this_operand].bitfield.jumpabsolute = 1;
9961     }
9962
9963   /* Check if operand is a register.  */
9964   if ((r = parse_register (op_string, &end_op)) != NULL)
9965     {
9966       i386_operand_type temp;
9967
9968       /* Check for a segment override by searching for ':' after a
9969          segment register.  */
9970       op_string = end_op;
9971       if (is_space_char (*op_string))
9972         ++op_string;
9973       if (*op_string == ':'
9974           && (r->reg_type.bitfield.sreg2
9975               || r->reg_type.bitfield.sreg3))
9976         {
9977           switch (r->reg_num)
9978             {
9979             case 0:
9980               i.seg[i.mem_operands] = &es;
9981               break;
9982             case 1:
9983               i.seg[i.mem_operands] = &cs;
9984               break;
9985             case 2:
9986               i.seg[i.mem_operands] = &ss;
9987               break;
9988             case 3:
9989               i.seg[i.mem_operands] = &ds;
9990               break;
9991             case 4:
9992               i.seg[i.mem_operands] = &fs;
9993               break;
9994             case 5:
9995               i.seg[i.mem_operands] = &gs;
9996               break;
9997             }
9998
9999           /* Skip the ':' and whitespace.  */
10000           ++op_string;
10001           if (is_space_char (*op_string))
10002             ++op_string;
10003
10004           if (!is_digit_char (*op_string)
10005               && !is_identifier_char (*op_string)
10006               && *op_string != '('
10007               && *op_string != ABSOLUTE_PREFIX)
10008             {
10009               as_bad (_("bad memory operand `%s'"), op_string);
10010               return 0;
10011             }
10012           /* Handle case of %es:*foo.  */
10013           if (*op_string == ABSOLUTE_PREFIX)
10014             {
10015               ++op_string;
10016               if (is_space_char (*op_string))
10017                 ++op_string;
10018               i.types[this_operand].bitfield.jumpabsolute = 1;
10019             }
10020           goto do_memory_reference;
10021         }
10022
10023       /* Handle vector operations.  */
10024       if (*op_string == '{')
10025         {
10026           op_string = check_VecOperations (op_string, NULL);
10027           if (op_string == NULL)
10028             return 0;
10029         }
10030
10031       if (*op_string)
10032         {
10033           as_bad (_("junk `%s' after register"), op_string);
10034           return 0;
10035         }
10036       temp = r->reg_type;
10037       temp.bitfield.baseindex = 0;
10038       i.types[this_operand] = operand_type_or (i.types[this_operand],
10039                                                temp);
10040       i.types[this_operand].bitfield.unspecified = 0;
10041       i.op[this_operand].regs = r;
10042       i.reg_operands++;
10043     }
10044   else if (*op_string == REGISTER_PREFIX)
10045     {
10046       as_bad (_("bad register name `%s'"), op_string);
10047       return 0;
10048     }
10049   else if (*op_string == IMMEDIATE_PREFIX)
10050     {
10051       ++op_string;
10052       if (i.types[this_operand].bitfield.jumpabsolute)
10053         {
10054           as_bad (_("immediate operand illegal with absolute jump"));
10055           return 0;
10056         }
10057       if (!i386_immediate (op_string))
10058         return 0;
10059     }
10060   else if (RC_SAE_immediate (operand_string))
10061     {
10062       /* If it is a RC or SAE immediate, do nothing.  */
10063       ;
10064     }
10065   else if (is_digit_char (*op_string)
10066            || is_identifier_char (*op_string)
10067            || *op_string == '"'
10068            || *op_string == '(')
10069     {
10070       /* This is a memory reference of some sort.  */
10071       char *base_string;
10072
10073       /* Start and end of displacement string expression (if found).  */
10074       char *displacement_string_start;
10075       char *displacement_string_end;
10076       char *vop_start;
10077
10078     do_memory_reference:
10079       if (i.mem_operands == 1 && !maybe_adjust_templates ())
10080         return 0;
10081       if ((i.mem_operands == 1
10082            && !current_templates->start->opcode_modifier.isstring)
10083           || i.mem_operands == 2)
10084         {
10085           as_bad (_("too many memory references for `%s'"),
10086                   current_templates->start->name);
10087           return 0;
10088         }
10089
10090       /* Check for base index form.  We detect the base index form by
10091          looking for an ')' at the end of the operand, searching
10092          for the '(' matching it, and finding a REGISTER_PREFIX or ','
10093          after the '('.  */
10094       base_string = op_string + strlen (op_string);
10095
10096       /* Handle vector operations.  */
10097       vop_start = strchr (op_string, '{');
10098       if (vop_start && vop_start < base_string)
10099         {
10100           if (check_VecOperations (vop_start, base_string) == NULL)
10101             return 0;
10102           base_string = vop_start;
10103         }
10104
10105       --base_string;
10106       if (is_space_char (*base_string))
10107         --base_string;
10108
10109       /* If we only have a displacement, set-up for it to be parsed later.  */
10110       displacement_string_start = op_string;
10111       displacement_string_end = base_string + 1;
10112
10113       if (*base_string == ')')
10114         {
10115           char *temp_string;
10116           unsigned int parens_balanced = 1;
10117           /* We've already checked that the number of left & right ()'s are
10118              equal, so this loop will not be infinite.  */
10119           do
10120             {
10121               base_string--;
10122               if (*base_string == ')')
10123                 parens_balanced++;
10124               if (*base_string == '(')
10125                 parens_balanced--;
10126             }
10127           while (parens_balanced);
10128
10129           temp_string = base_string;
10130
10131           /* Skip past '(' and whitespace.  */
10132           ++base_string;
10133           if (is_space_char (*base_string))
10134             ++base_string;
10135
10136           if (*base_string == ','
10137               || ((i.base_reg = parse_register (base_string, &end_op))
10138                   != NULL))
10139             {
10140               displacement_string_end = temp_string;
10141
10142               i.types[this_operand].bitfield.baseindex = 1;
10143
10144               if (i.base_reg)
10145                 {
10146                   base_string = end_op;
10147                   if (is_space_char (*base_string))
10148                     ++base_string;
10149                 }
10150
10151               /* There may be an index reg or scale factor here.  */
10152               if (*base_string == ',')
10153                 {
10154                   ++base_string;
10155                   if (is_space_char (*base_string))
10156                     ++base_string;
10157
10158                   if ((i.index_reg = parse_register (base_string, &end_op))
10159                       != NULL)
10160                     {
10161                       base_string = end_op;
10162                       if (is_space_char (*base_string))
10163                         ++base_string;
10164                       if (*base_string == ',')
10165                         {
10166                           ++base_string;
10167                           if (is_space_char (*base_string))
10168                             ++base_string;
10169                         }
10170                       else if (*base_string != ')')
10171                         {
10172                           as_bad (_("expecting `,' or `)' "
10173                                     "after index register in `%s'"),
10174                                   operand_string);
10175                           return 0;
10176                         }
10177                     }
10178                   else if (*base_string == REGISTER_PREFIX)
10179                     {
10180                       end_op = strchr (base_string, ',');
10181                       if (end_op)
10182                         *end_op = '\0';
10183                       as_bad (_("bad register name `%s'"), base_string);
10184                       return 0;
10185                     }
10186
10187                   /* Check for scale factor.  */
10188                   if (*base_string != ')')
10189                     {
10190                       char *end_scale = i386_scale (base_string);
10191
10192                       if (!end_scale)
10193                         return 0;
10194
10195                       base_string = end_scale;
10196                       if (is_space_char (*base_string))
10197                         ++base_string;
10198                       if (*base_string != ')')
10199                         {
10200                           as_bad (_("expecting `)' "
10201                                     "after scale factor in `%s'"),
10202                                   operand_string);
10203                           return 0;
10204                         }
10205                     }
10206                   else if (!i.index_reg)
10207                     {
10208                       as_bad (_("expecting index register or scale factor "
10209                                 "after `,'; got '%c'"),
10210                               *base_string);
10211                       return 0;
10212                     }
10213                 }
10214               else if (*base_string != ')')
10215                 {
10216                   as_bad (_("expecting `,' or `)' "
10217                             "after base register in `%s'"),
10218                           operand_string);
10219                   return 0;
10220                 }
10221             }
10222           else if (*base_string == REGISTER_PREFIX)
10223             {
10224               end_op = strchr (base_string, ',');
10225               if (end_op)
10226                 *end_op = '\0';
10227               as_bad (_("bad register name `%s'"), base_string);
10228               return 0;
10229             }
10230         }
10231
10232       /* If there's an expression beginning the operand, parse it,
10233          assuming displacement_string_start and
10234          displacement_string_end are meaningful.  */
10235       if (displacement_string_start != displacement_string_end)
10236         {
10237           if (!i386_displacement (displacement_string_start,
10238                                   displacement_string_end))
10239             return 0;
10240         }
10241
10242       /* Special case for (%dx) while doing input/output op.  */
10243       if (i.base_reg
10244           && i.base_reg->reg_type.bitfield.inoutportreg
10245           && i.index_reg == 0
10246           && i.log2_scale_factor == 0
10247           && i.seg[i.mem_operands] == 0
10248           && !operand_type_check (i.types[this_operand], disp))
10249         {
10250           i.types[this_operand] = i.base_reg->reg_type;
10251           return 1;
10252         }
10253
10254       if (i386_index_check (operand_string) == 0)
10255         return 0;
10256       i.flags[this_operand] |= Operand_Mem;
10257       if (i.mem_operands == 0)
10258         i.memop1_string = xstrdup (operand_string);
10259       i.mem_operands++;
10260     }
10261   else
10262     {
10263       /* It's not a memory operand; argh!  */
10264       as_bad (_("invalid char %s beginning operand %d `%s'"),
10265               output_invalid (*op_string),
10266               this_operand + 1,
10267               op_string);
10268       return 0;
10269     }
10270   return 1;                     /* Normal return.  */
10271 }
10272 \f
10273 /* Calculate the maximum variable size (i.e., excluding fr_fix)
10274    that an rs_machine_dependent frag may reach.  */
10275
10276 unsigned int
10277 i386_frag_max_var (fragS *frag)
10278 {
10279   /* The only relaxable frags are for jumps.
10280      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
10281   gas_assert (frag->fr_type == rs_machine_dependent);
10282   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
10283 }
10284
10285 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10286 static int
10287 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
10288 {
10289   /* STT_GNU_IFUNC symbol must go through PLT.  */
10290   if ((symbol_get_bfdsym (fr_symbol)->flags
10291        & BSF_GNU_INDIRECT_FUNCTION) != 0)
10292     return 0;
10293
10294   if (!S_IS_EXTERNAL (fr_symbol))
10295     /* Symbol may be weak or local.  */
10296     return !S_IS_WEAK (fr_symbol);
10297
10298   /* Global symbols with non-default visibility can't be preempted. */
10299   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
10300     return 1;
10301
10302   if (fr_var != NO_RELOC)
10303     switch ((enum bfd_reloc_code_real) fr_var)
10304       {
10305       case BFD_RELOC_386_PLT32:
10306       case BFD_RELOC_X86_64_PLT32:
10307         /* Symbol with PLT relocation may be preempted. */
10308         return 0;
10309       default:
10310         abort ();
10311       }
10312
10313   /* Global symbols with default visibility in a shared library may be
10314      preempted by another definition.  */
10315   return !shared;
10316 }
10317 #endif
10318
10319 /* md_estimate_size_before_relax()
10320
10321    Called just before relax() for rs_machine_dependent frags.  The x86
10322    assembler uses these frags to handle variable size jump
10323    instructions.
10324
10325    Any symbol that is now undefined will not become defined.
10326    Return the correct fr_subtype in the frag.
10327    Return the initial "guess for variable size of frag" to caller.
10328    The guess is actually the growth beyond the fixed part.  Whatever
10329    we do to grow the fixed or variable part contributes to our
10330    returned value.  */
10331
10332 int
10333 md_estimate_size_before_relax (fragS *fragP, segT segment)
10334 {
10335   /* We've already got fragP->fr_subtype right;  all we have to do is
10336      check for un-relaxable symbols.  On an ELF system, we can't relax
10337      an externally visible symbol, because it may be overridden by a
10338      shared library.  */
10339   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
10340 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10341       || (IS_ELF
10342           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
10343                                                 fragP->fr_var))
10344 #endif
10345 #if defined (OBJ_COFF) && defined (TE_PE)
10346       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
10347           && S_IS_WEAK (fragP->fr_symbol))
10348 #endif
10349       )
10350     {
10351       /* Symbol is undefined in this segment, or we need to keep a
10352          reloc so that weak symbols can be overridden.  */
10353       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
10354       enum bfd_reloc_code_real reloc_type;
10355       unsigned char *opcode;
10356       int old_fr_fix;
10357
10358       if (fragP->fr_var != NO_RELOC)
10359         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
10360       else if (size == 2)
10361         reloc_type = BFD_RELOC_16_PCREL;
10362 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10363       else if (need_plt32_p (fragP->fr_symbol))
10364         reloc_type = BFD_RELOC_X86_64_PLT32;
10365 #endif
10366       else
10367         reloc_type = BFD_RELOC_32_PCREL;
10368
10369       old_fr_fix = fragP->fr_fix;
10370       opcode = (unsigned char *) fragP->fr_opcode;
10371
10372       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
10373         {
10374         case UNCOND_JUMP:
10375           /* Make jmp (0xeb) a (d)word displacement jump.  */
10376           opcode[0] = 0xe9;
10377           fragP->fr_fix += size;
10378           fix_new (fragP, old_fr_fix, size,
10379                    fragP->fr_symbol,
10380                    fragP->fr_offset, 1,
10381                    reloc_type);
10382           break;
10383
10384         case COND_JUMP86:
10385           if (size == 2
10386               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
10387             {
10388               /* Negate the condition, and branch past an
10389                  unconditional jump.  */
10390               opcode[0] ^= 1;
10391               opcode[1] = 3;
10392               /* Insert an unconditional jump.  */
10393               opcode[2] = 0xe9;
10394               /* We added two extra opcode bytes, and have a two byte
10395                  offset.  */
10396               fragP->fr_fix += 2 + 2;
10397               fix_new (fragP, old_fr_fix + 2, 2,
10398                        fragP->fr_symbol,
10399                        fragP->fr_offset, 1,
10400                        reloc_type);
10401               break;
10402             }
10403           /* Fall through.  */
10404
10405         case COND_JUMP:
10406           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
10407             {
10408               fixS *fixP;
10409
10410               fragP->fr_fix += 1;
10411               fixP = fix_new (fragP, old_fr_fix, 1,
10412                               fragP->fr_symbol,
10413                               fragP->fr_offset, 1,
10414                               BFD_RELOC_8_PCREL);
10415               fixP->fx_signed = 1;
10416               break;
10417             }
10418
10419           /* This changes the byte-displacement jump 0x7N
10420              to the (d)word-displacement jump 0x0f,0x8N.  */
10421           opcode[1] = opcode[0] + 0x10;
10422           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10423           /* We've added an opcode byte.  */
10424           fragP->fr_fix += 1 + size;
10425           fix_new (fragP, old_fr_fix + 1, size,
10426                    fragP->fr_symbol,
10427                    fragP->fr_offset, 1,
10428                    reloc_type);
10429           break;
10430
10431         default:
10432           BAD_CASE (fragP->fr_subtype);
10433           break;
10434         }
10435       frag_wane (fragP);
10436       return fragP->fr_fix - old_fr_fix;
10437     }
10438
10439   /* Guess size depending on current relax state.  Initially the relax
10440      state will correspond to a short jump and we return 1, because
10441      the variable part of the frag (the branch offset) is one byte
10442      long.  However, we can relax a section more than once and in that
10443      case we must either set fr_subtype back to the unrelaxed state,
10444      or return the value for the appropriate branch.  */
10445   return md_relax_table[fragP->fr_subtype].rlx_length;
10446 }
10447
10448 /* Called after relax() is finished.
10449
10450    In:  Address of frag.
10451         fr_type == rs_machine_dependent.
10452         fr_subtype is what the address relaxed to.
10453
10454    Out: Any fixSs and constants are set up.
10455         Caller will turn frag into a ".space 0".  */
10456
10457 void
10458 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
10459                  fragS *fragP)
10460 {
10461   unsigned char *opcode;
10462   unsigned char *where_to_put_displacement = NULL;
10463   offsetT target_address;
10464   offsetT opcode_address;
10465   unsigned int extension = 0;
10466   offsetT displacement_from_opcode_start;
10467
10468   opcode = (unsigned char *) fragP->fr_opcode;
10469
10470   /* Address we want to reach in file space.  */
10471   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
10472
10473   /* Address opcode resides at in file space.  */
10474   opcode_address = fragP->fr_address + fragP->fr_fix;
10475
10476   /* Displacement from opcode start to fill into instruction.  */
10477   displacement_from_opcode_start = target_address - opcode_address;
10478
10479   if ((fragP->fr_subtype & BIG) == 0)
10480     {
10481       /* Don't have to change opcode.  */
10482       extension = 1;            /* 1 opcode + 1 displacement  */
10483       where_to_put_displacement = &opcode[1];
10484     }
10485   else
10486     {
10487       if (no_cond_jump_promotion
10488           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
10489         as_warn_where (fragP->fr_file, fragP->fr_line,
10490                        _("long jump required"));
10491
10492       switch (fragP->fr_subtype)
10493         {
10494         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
10495           extension = 4;                /* 1 opcode + 4 displacement  */
10496           opcode[0] = 0xe9;
10497           where_to_put_displacement = &opcode[1];
10498           break;
10499
10500         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
10501           extension = 2;                /* 1 opcode + 2 displacement  */
10502           opcode[0] = 0xe9;
10503           where_to_put_displacement = &opcode[1];
10504           break;
10505
10506         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
10507         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
10508           extension = 5;                /* 2 opcode + 4 displacement  */
10509           opcode[1] = opcode[0] + 0x10;
10510           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10511           where_to_put_displacement = &opcode[2];
10512           break;
10513
10514         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
10515           extension = 3;                /* 2 opcode + 2 displacement  */
10516           opcode[1] = opcode[0] + 0x10;
10517           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10518           where_to_put_displacement = &opcode[2];
10519           break;
10520
10521         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
10522           extension = 4;
10523           opcode[0] ^= 1;
10524           opcode[1] = 3;
10525           opcode[2] = 0xe9;
10526           where_to_put_displacement = &opcode[3];
10527           break;
10528
10529         default:
10530           BAD_CASE (fragP->fr_subtype);
10531           break;
10532         }
10533     }
10534
10535   /* If size if less then four we are sure that the operand fits,
10536      but if it's 4, then it could be that the displacement is larger
10537      then -/+ 2GB.  */
10538   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
10539       && object_64bit
10540       && ((addressT) (displacement_from_opcode_start - extension
10541                       + ((addressT) 1 << 31))
10542           > (((addressT) 2 << 31) - 1)))
10543     {
10544       as_bad_where (fragP->fr_file, fragP->fr_line,
10545                     _("jump target out of range"));
10546       /* Make us emit 0.  */
10547       displacement_from_opcode_start = extension;
10548     }
10549   /* Now put displacement after opcode.  */
10550   md_number_to_chars ((char *) where_to_put_displacement,
10551                       (valueT) (displacement_from_opcode_start - extension),
10552                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
10553   fragP->fr_fix += extension;
10554 }
10555 \f
10556 /* Apply a fixup (fixP) to segment data, once it has been determined
10557    by our caller that we have all the info we need to fix it up.
10558
10559    Parameter valP is the pointer to the value of the bits.
10560
10561    On the 386, immediates, displacements, and data pointers are all in
10562    the same (little-endian) format, so we don't need to care about which
10563    we are handling.  */
10564
10565 void
10566 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
10567 {
10568   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
10569   valueT value = *valP;
10570
10571 #if !defined (TE_Mach)
10572   if (fixP->fx_pcrel)
10573     {
10574       switch (fixP->fx_r_type)
10575         {
10576         default:
10577           break;
10578
10579         case BFD_RELOC_64:
10580           fixP->fx_r_type = BFD_RELOC_64_PCREL;
10581           break;
10582         case BFD_RELOC_32:
10583         case BFD_RELOC_X86_64_32S:
10584           fixP->fx_r_type = BFD_RELOC_32_PCREL;
10585           break;
10586         case BFD_RELOC_16:
10587           fixP->fx_r_type = BFD_RELOC_16_PCREL;
10588           break;
10589         case BFD_RELOC_8:
10590           fixP->fx_r_type = BFD_RELOC_8_PCREL;
10591           break;
10592         }
10593     }
10594
10595   if (fixP->fx_addsy != NULL
10596       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
10597           || fixP->fx_r_type == BFD_RELOC_64_PCREL
10598           || fixP->fx_r_type == BFD_RELOC_16_PCREL
10599           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
10600       && !use_rela_relocations)
10601     {
10602       /* This is a hack.  There should be a better way to handle this.
10603          This covers for the fact that bfd_install_relocation will
10604          subtract the current location (for partial_inplace, PC relative
10605          relocations); see more below.  */
10606 #ifndef OBJ_AOUT
10607       if (IS_ELF
10608 #ifdef TE_PE
10609           || OUTPUT_FLAVOR == bfd_target_coff_flavour
10610 #endif
10611           )
10612         value += fixP->fx_where + fixP->fx_frag->fr_address;
10613 #endif
10614 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10615       if (IS_ELF)
10616         {
10617           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
10618
10619           if ((sym_seg == seg
10620                || (symbol_section_p (fixP->fx_addsy)
10621                    && sym_seg != absolute_section))
10622               && !generic_force_reloc (fixP))
10623             {
10624               /* Yes, we add the values in twice.  This is because
10625                  bfd_install_relocation subtracts them out again.  I think
10626                  bfd_install_relocation is broken, but I don't dare change
10627                  it.  FIXME.  */
10628               value += fixP->fx_where + fixP->fx_frag->fr_address;
10629             }
10630         }
10631 #endif
10632 #if defined (OBJ_COFF) && defined (TE_PE)
10633       /* For some reason, the PE format does not store a
10634          section address offset for a PC relative symbol.  */
10635       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
10636           || S_IS_WEAK (fixP->fx_addsy))
10637         value += md_pcrel_from (fixP);
10638 #endif
10639     }
10640 #if defined (OBJ_COFF) && defined (TE_PE)
10641   if (fixP->fx_addsy != NULL
10642       && S_IS_WEAK (fixP->fx_addsy)
10643       /* PR 16858: Do not modify weak function references.  */
10644       && ! fixP->fx_pcrel)
10645     {
10646 #if !defined (TE_PEP)
10647       /* For x86 PE weak function symbols are neither PC-relative
10648          nor do they set S_IS_FUNCTION.  So the only reliable way
10649          to detect them is to check the flags of their containing
10650          section.  */
10651       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
10652           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
10653         ;
10654       else
10655 #endif
10656       value -= S_GET_VALUE (fixP->fx_addsy);
10657     }
10658 #endif
10659
10660   /* Fix a few things - the dynamic linker expects certain values here,
10661      and we must not disappoint it.  */
10662 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10663   if (IS_ELF && fixP->fx_addsy)
10664     switch (fixP->fx_r_type)
10665       {
10666       case BFD_RELOC_386_PLT32:
10667       case BFD_RELOC_X86_64_PLT32:
10668         /* Make the jump instruction point to the address of the operand.
10669            At runtime we merely add the offset to the actual PLT entry.
10670            NB: Subtract the offset size only for jump instructions.  */
10671         if (fixP->fx_pcrel)
10672           value = -4;
10673         break;
10674
10675       case BFD_RELOC_386_TLS_GD:
10676       case BFD_RELOC_386_TLS_LDM:
10677       case BFD_RELOC_386_TLS_IE_32:
10678       case BFD_RELOC_386_TLS_IE:
10679       case BFD_RELOC_386_TLS_GOTIE:
10680       case BFD_RELOC_386_TLS_GOTDESC:
10681       case BFD_RELOC_X86_64_TLSGD:
10682       case BFD_RELOC_X86_64_TLSLD:
10683       case BFD_RELOC_X86_64_GOTTPOFF:
10684       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
10685         value = 0; /* Fully resolved at runtime.  No addend.  */
10686         /* Fallthrough */
10687       case BFD_RELOC_386_TLS_LE:
10688       case BFD_RELOC_386_TLS_LDO_32:
10689       case BFD_RELOC_386_TLS_LE_32:
10690       case BFD_RELOC_X86_64_DTPOFF32:
10691       case BFD_RELOC_X86_64_DTPOFF64:
10692       case BFD_RELOC_X86_64_TPOFF32:
10693       case BFD_RELOC_X86_64_TPOFF64:
10694         S_SET_THREAD_LOCAL (fixP->fx_addsy);
10695         break;
10696
10697       case BFD_RELOC_386_TLS_DESC_CALL:
10698       case BFD_RELOC_X86_64_TLSDESC_CALL:
10699         value = 0; /* Fully resolved at runtime.  No addend.  */
10700         S_SET_THREAD_LOCAL (fixP->fx_addsy);
10701         fixP->fx_done = 0;
10702         return;
10703
10704       case BFD_RELOC_VTABLE_INHERIT:
10705       case BFD_RELOC_VTABLE_ENTRY:
10706         fixP->fx_done = 0;
10707         return;
10708
10709       default:
10710         break;
10711       }
10712 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
10713   *valP = value;
10714 #endif /* !defined (TE_Mach)  */
10715
10716   /* Are we finished with this relocation now?  */
10717   if (fixP->fx_addsy == NULL)
10718     fixP->fx_done = 1;
10719 #if defined (OBJ_COFF) && defined (TE_PE)
10720   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
10721     {
10722       fixP->fx_done = 0;
10723       /* Remember value for tc_gen_reloc.  */
10724       fixP->fx_addnumber = value;
10725       /* Clear out the frag for now.  */
10726       value = 0;
10727     }
10728 #endif
10729   else if (use_rela_relocations)
10730     {
10731       fixP->fx_no_overflow = 1;
10732       /* Remember value for tc_gen_reloc.  */
10733       fixP->fx_addnumber = value;
10734       value = 0;
10735     }
10736
10737   md_number_to_chars (p, value, fixP->fx_size);
10738 }
10739 \f
10740 const char *
10741 md_atof (int type, char *litP, int *sizeP)
10742 {
10743   /* This outputs the LITTLENUMs in REVERSE order;
10744      in accord with the bigendian 386.  */
10745   return ieee_md_atof (type, litP, sizeP, FALSE);
10746 }
10747 \f
10748 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
10749
10750 static char *
10751 output_invalid (int c)
10752 {
10753   if (ISPRINT (c))
10754     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
10755               "'%c'", c);
10756   else
10757     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
10758               "(0x%x)", (unsigned char) c);
10759   return output_invalid_buf;
10760 }
10761
10762 /* REG_STRING starts *before* REGISTER_PREFIX.  */
10763
10764 static const reg_entry *
10765 parse_real_register (char *reg_string, char **end_op)
10766 {
10767   char *s = reg_string;
10768   char *p;
10769   char reg_name_given[MAX_REG_NAME_SIZE + 1];
10770   const reg_entry *r;
10771
10772   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
10773   if (*s == REGISTER_PREFIX)
10774     ++s;
10775
10776   if (is_space_char (*s))
10777     ++s;
10778
10779   p = reg_name_given;
10780   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
10781     {
10782       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
10783         return (const reg_entry *) NULL;
10784       s++;
10785     }
10786
10787   /* For naked regs, make sure that we are not dealing with an identifier.
10788      This prevents confusing an identifier like `eax_var' with register
10789      `eax'.  */
10790   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
10791     return (const reg_entry *) NULL;
10792
10793   *end_op = s;
10794
10795   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
10796
10797   /* Handle floating point regs, allowing spaces in the (i) part.  */
10798   if (r == i386_regtab /* %st is first entry of table  */)
10799     {
10800       if (!cpu_arch_flags.bitfield.cpu8087
10801           && !cpu_arch_flags.bitfield.cpu287
10802           && !cpu_arch_flags.bitfield.cpu387)
10803         return (const reg_entry *) NULL;
10804
10805       if (is_space_char (*s))
10806         ++s;
10807       if (*s == '(')
10808         {
10809           ++s;
10810           if (is_space_char (*s))
10811             ++s;
10812           if (*s >= '0' && *s <= '7')
10813             {
10814               int fpr = *s - '0';
10815               ++s;
10816               if (is_space_char (*s))
10817                 ++s;
10818               if (*s == ')')
10819                 {
10820                   *end_op = s + 1;
10821                   r = (const reg_entry *) hash_find (reg_hash, "st(0)");
10822                   know (r);
10823                   return r + fpr;
10824                 }
10825             }
10826           /* We have "%st(" then garbage.  */
10827           return (const reg_entry *) NULL;
10828         }
10829     }
10830
10831   if (r == NULL || allow_pseudo_reg)
10832     return r;
10833
10834   if (operand_type_all_zero (&r->reg_type))
10835     return (const reg_entry *) NULL;
10836
10837   if ((r->reg_type.bitfield.dword
10838        || r->reg_type.bitfield.sreg3
10839        || r->reg_type.bitfield.control
10840        || r->reg_type.bitfield.debug
10841        || r->reg_type.bitfield.test)
10842       && !cpu_arch_flags.bitfield.cpui386)
10843     return (const reg_entry *) NULL;
10844
10845   if (r->reg_type.bitfield.regmmx && !cpu_arch_flags.bitfield.cpummx)
10846     return (const reg_entry *) NULL;
10847
10848   if (!cpu_arch_flags.bitfield.cpuavx512f)
10849     {
10850       if (r->reg_type.bitfield.zmmword || r->reg_type.bitfield.regmask)
10851         return (const reg_entry *) NULL;
10852
10853       if (!cpu_arch_flags.bitfield.cpuavx)
10854         {
10855           if (r->reg_type.bitfield.ymmword)
10856             return (const reg_entry *) NULL;
10857
10858           if (!cpu_arch_flags.bitfield.cpusse && r->reg_type.bitfield.xmmword)
10859             return (const reg_entry *) NULL;
10860         }
10861     }
10862
10863   if (r->reg_type.bitfield.regbnd && !cpu_arch_flags.bitfield.cpumpx)
10864     return (const reg_entry *) NULL;
10865
10866   /* Don't allow fake index register unless allow_index_reg isn't 0. */
10867   if (!allow_index_reg && r->reg_num == RegIZ)
10868     return (const reg_entry *) NULL;
10869
10870   /* Upper 16 vector registers are only available with VREX in 64bit
10871      mode, and require EVEX encoding.  */
10872   if (r->reg_flags & RegVRex)
10873     {
10874       if (!cpu_arch_flags.bitfield.cpuavx512f
10875           || flag_code != CODE_64BIT)
10876         return (const reg_entry *) NULL;
10877
10878       i.vec_encoding = vex_encoding_evex;
10879     }
10880
10881   if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword)
10882       && (!cpu_arch_flags.bitfield.cpulm || !r->reg_type.bitfield.control)
10883       && flag_code != CODE_64BIT)
10884     return (const reg_entry *) NULL;
10885
10886   if (r->reg_type.bitfield.sreg3 && r->reg_num == RegFlat && !intel_syntax)
10887     return (const reg_entry *) NULL;
10888
10889   return r;
10890 }
10891
10892 /* REG_STRING starts *before* REGISTER_PREFIX.  */
10893
10894 static const reg_entry *
10895 parse_register (char *reg_string, char **end_op)
10896 {
10897   const reg_entry *r;
10898
10899   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
10900     r = parse_real_register (reg_string, end_op);
10901   else
10902     r = NULL;
10903   if (!r)
10904     {
10905       char *save = input_line_pointer;
10906       char c;
10907       symbolS *symbolP;
10908
10909       input_line_pointer = reg_string;
10910       c = get_symbol_name (&reg_string);
10911       symbolP = symbol_find (reg_string);
10912       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
10913         {
10914           const expressionS *e = symbol_get_value_expression (symbolP);
10915
10916           know (e->X_op == O_register);
10917           know (e->X_add_number >= 0
10918                 && (valueT) e->X_add_number < i386_regtab_size);
10919           r = i386_regtab + e->X_add_number;
10920           if ((r->reg_flags & RegVRex))
10921             i.vec_encoding = vex_encoding_evex;
10922           *end_op = input_line_pointer;
10923         }
10924       *input_line_pointer = c;
10925       input_line_pointer = save;
10926     }
10927   return r;
10928 }
10929
10930 int
10931 i386_parse_name (char *name, expressionS *e, char *nextcharP)
10932 {
10933   const reg_entry *r;
10934   char *end = input_line_pointer;
10935
10936   *end = *nextcharP;
10937   r = parse_register (name, &input_line_pointer);
10938   if (r && end <= input_line_pointer)
10939     {
10940       *nextcharP = *input_line_pointer;
10941       *input_line_pointer = 0;
10942       e->X_op = O_register;
10943       e->X_add_number = r - i386_regtab;
10944       return 1;
10945     }
10946   input_line_pointer = end;
10947   *end = 0;
10948   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
10949 }
10950
10951 void
10952 md_operand (expressionS *e)
10953 {
10954   char *end;
10955   const reg_entry *r;
10956
10957   switch (*input_line_pointer)
10958     {
10959     case REGISTER_PREFIX:
10960       r = parse_real_register (input_line_pointer, &end);
10961       if (r)
10962         {
10963           e->X_op = O_register;
10964           e->X_add_number = r - i386_regtab;
10965           input_line_pointer = end;
10966         }
10967       break;
10968
10969     case '[':
10970       gas_assert (intel_syntax);
10971       end = input_line_pointer++;
10972       expression (e);
10973       if (*input_line_pointer == ']')
10974         {
10975           ++input_line_pointer;
10976           e->X_op_symbol = make_expr_symbol (e);
10977           e->X_add_symbol = NULL;
10978           e->X_add_number = 0;
10979           e->X_op = O_index;
10980         }
10981       else
10982         {
10983           e->X_op = O_absent;
10984           input_line_pointer = end;
10985         }
10986       break;
10987     }
10988 }
10989
10990 \f
10991 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10992 const char *md_shortopts = "kVQ:sqnO::";
10993 #else
10994 const char *md_shortopts = "qnO::";
10995 #endif
10996
10997 #define OPTION_32 (OPTION_MD_BASE + 0)
10998 #define OPTION_64 (OPTION_MD_BASE + 1)
10999 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
11000 #define OPTION_MARCH (OPTION_MD_BASE + 3)
11001 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
11002 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
11003 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
11004 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
11005 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
11006 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 9)
11007 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
11008 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
11009 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
11010 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
11011 #define OPTION_X32 (OPTION_MD_BASE + 14)
11012 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
11013 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
11014 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
11015 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
11016 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
11017 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
11018 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
11019 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
11020 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
11021 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
11022 #define OPTION_X86_USED_NOTE (OPTION_MD_BASE + 25)
11023 #define OPTION_MVEXWIG (OPTION_MD_BASE + 26)
11024
11025 struct option md_longopts[] =
11026 {
11027   {"32", no_argument, NULL, OPTION_32},
11028 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11029      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11030   {"64", no_argument, NULL, OPTION_64},
11031 #endif
11032 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11033   {"x32", no_argument, NULL, OPTION_X32},
11034   {"mshared", no_argument, NULL, OPTION_MSHARED},
11035   {"mx86-used-note", required_argument, NULL, OPTION_X86_USED_NOTE},
11036 #endif
11037   {"divide", no_argument, NULL, OPTION_DIVIDE},
11038   {"march", required_argument, NULL, OPTION_MARCH},
11039   {"mtune", required_argument, NULL, OPTION_MTUNE},
11040   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
11041   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
11042   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
11043   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
11044   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
11045   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
11046   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
11047   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
11048   {"mvexwig", required_argument, NULL, OPTION_MVEXWIG},
11049   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
11050   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
11051   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
11052 # if defined (TE_PE) || defined (TE_PEP)
11053   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
11054 #endif
11055   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
11056   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
11057   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
11058   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
11059   {"mamd64", no_argument, NULL, OPTION_MAMD64},
11060   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
11061   {NULL, no_argument, NULL, 0}
11062 };
11063 size_t md_longopts_size = sizeof (md_longopts);
11064
11065 int
11066 md_parse_option (int c, const char *arg)
11067 {
11068   unsigned int j;
11069   char *arch, *next, *saved;
11070
11071   switch (c)
11072     {
11073     case 'n':
11074       optimize_align_code = 0;
11075       break;
11076
11077     case 'q':
11078       quiet_warnings = 1;
11079       break;
11080
11081 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11082       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
11083          should be emitted or not.  FIXME: Not implemented.  */
11084     case 'Q':
11085       break;
11086
11087       /* -V: SVR4 argument to print version ID.  */
11088     case 'V':
11089       print_version_id ();
11090       break;
11091
11092       /* -k: Ignore for FreeBSD compatibility.  */
11093     case 'k':
11094       break;
11095
11096     case 's':
11097       /* -s: On i386 Solaris, this tells the native assembler to use
11098          .stab instead of .stab.excl.  We always use .stab anyhow.  */
11099       break;
11100
11101     case OPTION_MSHARED:
11102       shared = 1;
11103       break;
11104
11105     case OPTION_X86_USED_NOTE:
11106       if (strcasecmp (arg, "yes") == 0)
11107         x86_used_note = 1;
11108       else if (strcasecmp (arg, "no") == 0)
11109         x86_used_note = 0;
11110       else
11111         as_fatal (_("invalid -mx86-used-note= option: `%s'"), arg);
11112       break;
11113
11114
11115 #endif
11116 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11117      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11118     case OPTION_64:
11119       {
11120         const char **list, **l;
11121
11122         list = bfd_target_list ();
11123         for (l = list; *l != NULL; l++)
11124           if (CONST_STRNEQ (*l, "elf64-x86-64")
11125               || strcmp (*l, "coff-x86-64") == 0
11126               || strcmp (*l, "pe-x86-64") == 0
11127               || strcmp (*l, "pei-x86-64") == 0
11128               || strcmp (*l, "mach-o-x86-64") == 0)
11129             {
11130               default_arch = "x86_64";
11131               break;
11132             }
11133         if (*l == NULL)
11134           as_fatal (_("no compiled in support for x86_64"));
11135         free (list);
11136       }
11137       break;
11138 #endif
11139
11140 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11141     case OPTION_X32:
11142       if (IS_ELF)
11143         {
11144           const char **list, **l;
11145
11146           list = bfd_target_list ();
11147           for (l = list; *l != NULL; l++)
11148             if (CONST_STRNEQ (*l, "elf32-x86-64"))
11149               {
11150                 default_arch = "x86_64:32";
11151                 break;
11152               }
11153           if (*l == NULL)
11154             as_fatal (_("no compiled in support for 32bit x86_64"));
11155           free (list);
11156         }
11157       else
11158         as_fatal (_("32bit x86_64 is only supported for ELF"));
11159       break;
11160 #endif
11161
11162     case OPTION_32:
11163       default_arch = "i386";
11164       break;
11165
11166     case OPTION_DIVIDE:
11167 #ifdef SVR4_COMMENT_CHARS
11168       {
11169         char *n, *t;
11170         const char *s;
11171
11172         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
11173         t = n;
11174         for (s = i386_comment_chars; *s != '\0'; s++)
11175           if (*s != '/')
11176             *t++ = *s;
11177         *t = '\0';
11178         i386_comment_chars = n;
11179       }
11180 #endif
11181       break;
11182
11183     case OPTION_MARCH:
11184       saved = xstrdup (arg);
11185       arch = saved;
11186       /* Allow -march=+nosse.  */
11187       if (*arch == '+')
11188         arch++;
11189       do
11190         {
11191           if (*arch == '.')
11192             as_fatal (_("invalid -march= option: `%s'"), arg);
11193           next = strchr (arch, '+');
11194           if (next)
11195             *next++ = '\0';
11196           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11197             {
11198               if (strcmp (arch, cpu_arch [j].name) == 0)
11199                 {
11200                   /* Processor.  */
11201                   if (! cpu_arch[j].flags.bitfield.cpui386)
11202                     continue;
11203
11204                   cpu_arch_name = cpu_arch[j].name;
11205                   cpu_sub_arch_name = NULL;
11206                   cpu_arch_flags = cpu_arch[j].flags;
11207                   cpu_arch_isa = cpu_arch[j].type;
11208                   cpu_arch_isa_flags = cpu_arch[j].flags;
11209                   if (!cpu_arch_tune_set)
11210                     {
11211                       cpu_arch_tune = cpu_arch_isa;
11212                       cpu_arch_tune_flags = cpu_arch_isa_flags;
11213                     }
11214                   break;
11215                 }
11216               else if (*cpu_arch [j].name == '.'
11217                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
11218                 {
11219                   /* ISA extension.  */
11220                   i386_cpu_flags flags;
11221
11222                   flags = cpu_flags_or (cpu_arch_flags,
11223                                         cpu_arch[j].flags);
11224
11225                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
11226                     {
11227                       if (cpu_sub_arch_name)
11228                         {
11229                           char *name = cpu_sub_arch_name;
11230                           cpu_sub_arch_name = concat (name,
11231                                                       cpu_arch[j].name,
11232                                                       (const char *) NULL);
11233                           free (name);
11234                         }
11235                       else
11236                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
11237                       cpu_arch_flags = flags;
11238                       cpu_arch_isa_flags = flags;
11239                     }
11240                   else
11241                     cpu_arch_isa_flags
11242                       = cpu_flags_or (cpu_arch_isa_flags,
11243                                       cpu_arch[j].flags);
11244                   break;
11245                 }
11246             }
11247
11248           if (j >= ARRAY_SIZE (cpu_arch))
11249             {
11250               /* Disable an ISA extension.  */
11251               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
11252                 if (strcmp (arch, cpu_noarch [j].name) == 0)
11253                   {
11254                     i386_cpu_flags flags;
11255
11256                     flags = cpu_flags_and_not (cpu_arch_flags,
11257                                                cpu_noarch[j].flags);
11258                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
11259                       {
11260                         if (cpu_sub_arch_name)
11261                           {
11262                             char *name = cpu_sub_arch_name;
11263                             cpu_sub_arch_name = concat (arch,
11264                                                         (const char *) NULL);
11265                             free (name);
11266                           }
11267                         else
11268                           cpu_sub_arch_name = xstrdup (arch);
11269                         cpu_arch_flags = flags;
11270                         cpu_arch_isa_flags = flags;
11271                       }
11272                     break;
11273                   }
11274
11275               if (j >= ARRAY_SIZE (cpu_noarch))
11276                 j = ARRAY_SIZE (cpu_arch);
11277             }
11278
11279           if (j >= ARRAY_SIZE (cpu_arch))
11280             as_fatal (_("invalid -march= option: `%s'"), arg);
11281
11282           arch = next;
11283         }
11284       while (next != NULL);
11285       free (saved);
11286       break;
11287
11288     case OPTION_MTUNE:
11289       if (*arg == '.')
11290         as_fatal (_("invalid -mtune= option: `%s'"), arg);
11291       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11292         {
11293           if (strcmp (arg, cpu_arch [j].name) == 0)
11294             {
11295               cpu_arch_tune_set = 1;
11296               cpu_arch_tune = cpu_arch [j].type;
11297               cpu_arch_tune_flags = cpu_arch[j].flags;
11298               break;
11299             }
11300         }
11301       if (j >= ARRAY_SIZE (cpu_arch))
11302         as_fatal (_("invalid -mtune= option: `%s'"), arg);
11303       break;
11304
11305     case OPTION_MMNEMONIC:
11306       if (strcasecmp (arg, "att") == 0)
11307         intel_mnemonic = 0;
11308       else if (strcasecmp (arg, "intel") == 0)
11309         intel_mnemonic = 1;
11310       else
11311         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
11312       break;
11313
11314     case OPTION_MSYNTAX:
11315       if (strcasecmp (arg, "att") == 0)
11316         intel_syntax = 0;
11317       else if (strcasecmp (arg, "intel") == 0)
11318         intel_syntax = 1;
11319       else
11320         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
11321       break;
11322
11323     case OPTION_MINDEX_REG:
11324       allow_index_reg = 1;
11325       break;
11326
11327     case OPTION_MNAKED_REG:
11328       allow_naked_reg = 1;
11329       break;
11330
11331     case OPTION_MSSE2AVX:
11332       sse2avx = 1;
11333       break;
11334
11335     case OPTION_MSSE_CHECK:
11336       if (strcasecmp (arg, "error") == 0)
11337         sse_check = check_error;
11338       else if (strcasecmp (arg, "warning") == 0)
11339         sse_check = check_warning;
11340       else if (strcasecmp (arg, "none") == 0)
11341         sse_check = check_none;
11342       else
11343         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
11344       break;
11345
11346     case OPTION_MOPERAND_CHECK:
11347       if (strcasecmp (arg, "error") == 0)
11348         operand_check = check_error;
11349       else if (strcasecmp (arg, "warning") == 0)
11350         operand_check = check_warning;
11351       else if (strcasecmp (arg, "none") == 0)
11352         operand_check = check_none;
11353       else
11354         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
11355       break;
11356
11357     case OPTION_MAVXSCALAR:
11358       if (strcasecmp (arg, "128") == 0)
11359         avxscalar = vex128;
11360       else if (strcasecmp (arg, "256") == 0)
11361         avxscalar = vex256;
11362       else
11363         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
11364       break;
11365
11366     case OPTION_MVEXWIG:
11367       if (strcmp (arg, "0") == 0)
11368         vexwig = evexw0;
11369       else if (strcmp (arg, "1") == 0)
11370         vexwig = evexw1;
11371       else
11372         as_fatal (_("invalid -mvexwig= option: `%s'"), arg);
11373       break;
11374
11375     case OPTION_MADD_BND_PREFIX:
11376       add_bnd_prefix = 1;
11377       break;
11378
11379     case OPTION_MEVEXLIG:
11380       if (strcmp (arg, "128") == 0)
11381         evexlig = evexl128;
11382       else if (strcmp (arg, "256") == 0)
11383         evexlig = evexl256;
11384       else  if (strcmp (arg, "512") == 0)
11385         evexlig = evexl512;
11386       else
11387         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
11388       break;
11389
11390     case OPTION_MEVEXRCIG:
11391       if (strcmp (arg, "rne") == 0)
11392         evexrcig = rne;
11393       else if (strcmp (arg, "rd") == 0)
11394         evexrcig = rd;
11395       else if (strcmp (arg, "ru") == 0)
11396         evexrcig = ru;
11397       else if (strcmp (arg, "rz") == 0)
11398         evexrcig = rz;
11399       else
11400         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
11401       break;
11402
11403     case OPTION_MEVEXWIG:
11404       if (strcmp (arg, "0") == 0)
11405         evexwig = evexw0;
11406       else if (strcmp (arg, "1") == 0)
11407         evexwig = evexw1;
11408       else
11409         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
11410       break;
11411
11412 # if defined (TE_PE) || defined (TE_PEP)
11413     case OPTION_MBIG_OBJ:
11414       use_big_obj = 1;
11415       break;
11416 #endif
11417
11418     case OPTION_MOMIT_LOCK_PREFIX:
11419       if (strcasecmp (arg, "yes") == 0)
11420         omit_lock_prefix = 1;
11421       else if (strcasecmp (arg, "no") == 0)
11422         omit_lock_prefix = 0;
11423       else
11424         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
11425       break;
11426
11427     case OPTION_MFENCE_AS_LOCK_ADD:
11428       if (strcasecmp (arg, "yes") == 0)
11429         avoid_fence = 1;
11430       else if (strcasecmp (arg, "no") == 0)
11431         avoid_fence = 0;
11432       else
11433         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
11434       break;
11435
11436     case OPTION_MRELAX_RELOCATIONS:
11437       if (strcasecmp (arg, "yes") == 0)
11438         generate_relax_relocations = 1;
11439       else if (strcasecmp (arg, "no") == 0)
11440         generate_relax_relocations = 0;
11441       else
11442         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
11443       break;
11444
11445     case OPTION_MAMD64:
11446       intel64 = 0;
11447       break;
11448
11449     case OPTION_MINTEL64:
11450       intel64 = 1;
11451       break;
11452
11453     case 'O':
11454       if (arg == NULL)
11455         {
11456           optimize = 1;
11457           /* Turn off -Os.  */
11458           optimize_for_space = 0;
11459         }
11460       else if (*arg == 's')
11461         {
11462           optimize_for_space = 1;
11463           /* Turn on all encoding optimizations.  */
11464           optimize = INT_MAX;
11465         }
11466       else
11467         {
11468           optimize = atoi (arg);
11469           /* Turn off -Os.  */
11470           optimize_for_space = 0;
11471         }
11472       break;
11473
11474     default:
11475       return 0;
11476     }
11477   return 1;
11478 }
11479
11480 #define MESSAGE_TEMPLATE \
11481 "                                                                                "
11482
11483 static char *
11484 output_message (FILE *stream, char *p, char *message, char *start,
11485                 int *left_p, const char *name, int len)
11486 {
11487   int size = sizeof (MESSAGE_TEMPLATE);
11488   int left = *left_p;
11489
11490   /* Reserve 2 spaces for ", " or ",\0" */
11491   left -= len + 2;
11492
11493   /* Check if there is any room.  */
11494   if (left >= 0)
11495     {
11496       if (p != start)
11497         {
11498           *p++ = ',';
11499           *p++ = ' ';
11500         }
11501       p = mempcpy (p, name, len);
11502     }
11503   else
11504     {
11505       /* Output the current message now and start a new one.  */
11506       *p++ = ',';
11507       *p = '\0';
11508       fprintf (stream, "%s\n", message);
11509       p = start;
11510       left = size - (start - message) - len - 2;
11511
11512       gas_assert (left >= 0);
11513
11514       p = mempcpy (p, name, len);
11515     }
11516
11517   *left_p = left;
11518   return p;
11519 }
11520
11521 static void
11522 show_arch (FILE *stream, int ext, int check)
11523 {
11524   static char message[] = MESSAGE_TEMPLATE;
11525   char *start = message + 27;
11526   char *p;
11527   int size = sizeof (MESSAGE_TEMPLATE);
11528   int left;
11529   const char *name;
11530   int len;
11531   unsigned int j;
11532
11533   p = start;
11534   left = size - (start - message);
11535   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11536     {
11537       /* Should it be skipped?  */
11538       if (cpu_arch [j].skip)
11539         continue;
11540
11541       name = cpu_arch [j].name;
11542       len = cpu_arch [j].len;
11543       if (*name == '.')
11544         {
11545           /* It is an extension.  Skip if we aren't asked to show it.  */
11546           if (ext)
11547             {
11548               name++;
11549               len--;
11550             }
11551           else
11552             continue;
11553         }
11554       else if (ext)
11555         {
11556           /* It is an processor.  Skip if we show only extension.  */
11557           continue;
11558         }
11559       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
11560         {
11561           /* It is an impossible processor - skip.  */
11562           continue;
11563         }
11564
11565       p = output_message (stream, p, message, start, &left, name, len);
11566     }
11567
11568   /* Display disabled extensions.  */
11569   if (ext)
11570     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
11571       {
11572         name = cpu_noarch [j].name;
11573         len = cpu_noarch [j].len;
11574         p = output_message (stream, p, message, start, &left, name,
11575                             len);
11576       }
11577
11578   *p = '\0';
11579   fprintf (stream, "%s\n", message);
11580 }
11581
11582 void
11583 md_show_usage (FILE *stream)
11584 {
11585 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11586   fprintf (stream, _("\
11587   -Q                      ignored\n\
11588   -V                      print assembler version number\n\
11589   -k                      ignored\n"));
11590 #endif
11591   fprintf (stream, _("\
11592   -n                      Do not optimize code alignment\n\
11593   -q                      quieten some warnings\n"));
11594 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11595   fprintf (stream, _("\
11596   -s                      ignored\n"));
11597 #endif
11598 #if defined BFD64 && (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11599                       || defined (TE_PE) || defined (TE_PEP))
11600   fprintf (stream, _("\
11601   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
11602 #endif
11603 #ifdef SVR4_COMMENT_CHARS
11604   fprintf (stream, _("\
11605   --divide                do not treat `/' as a comment character\n"));
11606 #else
11607   fprintf (stream, _("\
11608   --divide                ignored\n"));
11609 #endif
11610   fprintf (stream, _("\
11611   -march=CPU[,+EXTENSION...]\n\
11612                           generate code for CPU and EXTENSION, CPU is one of:\n"));
11613   show_arch (stream, 0, 1);
11614   fprintf (stream, _("\
11615                           EXTENSION is combination of:\n"));
11616   show_arch (stream, 1, 0);
11617   fprintf (stream, _("\
11618   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
11619   show_arch (stream, 0, 0);
11620   fprintf (stream, _("\
11621   -msse2avx               encode SSE instructions with VEX prefix\n"));
11622   fprintf (stream, _("\
11623   -msse-check=[none|error|warning] (default: warning)\n\
11624                           check SSE instructions\n"));
11625   fprintf (stream, _("\
11626   -moperand-check=[none|error|warning] (default: warning)\n\
11627                           check operand combinations for validity\n"));
11628   fprintf (stream, _("\
11629   -mavxscalar=[128|256] (default: 128)\n\
11630                           encode scalar AVX instructions with specific vector\n\
11631                            length\n"));
11632   fprintf (stream, _("\
11633   -mvexwig=[0|1] (default: 0)\n\
11634                           encode VEX instructions with specific VEX.W value\n\
11635                            for VEX.W bit ignored instructions\n"));
11636   fprintf (stream, _("\
11637   -mevexlig=[128|256|512] (default: 128)\n\
11638                           encode scalar EVEX instructions with specific vector\n\
11639                            length\n"));
11640   fprintf (stream, _("\
11641   -mevexwig=[0|1] (default: 0)\n\
11642                           encode EVEX instructions with specific EVEX.W value\n\
11643                            for EVEX.W bit ignored instructions\n"));
11644   fprintf (stream, _("\
11645   -mevexrcig=[rne|rd|ru|rz] (default: rne)\n\
11646                           encode EVEX instructions with specific EVEX.RC value\n\
11647                            for SAE-only ignored instructions\n"));
11648   fprintf (stream, _("\
11649   -mmnemonic=[att|intel] "));
11650   if (SYSV386_COMPAT)
11651     fprintf (stream, _("(default: att)\n"));
11652   else
11653     fprintf (stream, _("(default: intel)\n"));
11654   fprintf (stream, _("\
11655                           use AT&T/Intel mnemonic\n"));
11656   fprintf (stream, _("\
11657   -msyntax=[att|intel] (default: att)\n\
11658                           use AT&T/Intel syntax\n"));
11659   fprintf (stream, _("\
11660   -mindex-reg             support pseudo index registers\n"));
11661   fprintf (stream, _("\
11662   -mnaked-reg             don't require `%%' prefix for registers\n"));
11663   fprintf (stream, _("\
11664   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
11665 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11666   fprintf (stream, _("\
11667   -mshared                disable branch optimization for shared code\n"));
11668   fprintf (stream, _("\
11669   -mx86-used-note=[no|yes] "));
11670   if (DEFAULT_X86_USED_NOTE)
11671     fprintf (stream, _("(default: yes)\n"));
11672   else
11673     fprintf (stream, _("(default: no)\n"));
11674   fprintf (stream, _("\
11675                           generate x86 used ISA and feature properties\n"));
11676 #endif
11677 #if defined (TE_PE) || defined (TE_PEP)
11678   fprintf (stream, _("\
11679   -mbig-obj               generate big object files\n"));
11680 #endif
11681   fprintf (stream, _("\
11682   -momit-lock-prefix=[no|yes] (default: no)\n\
11683                           strip all lock prefixes\n"));
11684   fprintf (stream, _("\
11685   -mfence-as-lock-add=[no|yes] (default: no)\n\
11686                           encode lfence, mfence and sfence as\n\
11687                            lock addl $0x0, (%%{re}sp)\n"));
11688   fprintf (stream, _("\
11689   -mrelax-relocations=[no|yes] "));
11690   if (DEFAULT_GENERATE_X86_RELAX_RELOCATIONS)
11691     fprintf (stream, _("(default: yes)\n"));
11692   else
11693     fprintf (stream, _("(default: no)\n"));
11694   fprintf (stream, _("\
11695                           generate relax relocations\n"));
11696   fprintf (stream, _("\
11697   -mamd64                 accept only AMD64 ISA [default]\n"));
11698   fprintf (stream, _("\
11699   -mintel64               accept only Intel64 ISA\n"));
11700 }
11701
11702 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
11703      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11704      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11705
11706 /* Pick the target format to use.  */
11707
11708 const char *
11709 i386_target_format (void)
11710 {
11711   if (!strncmp (default_arch, "x86_64", 6))
11712     {
11713       update_code_flag (CODE_64BIT, 1);
11714       if (default_arch[6] == '\0')
11715         x86_elf_abi = X86_64_ABI;
11716       else
11717         x86_elf_abi = X86_64_X32_ABI;
11718     }
11719   else if (!strcmp (default_arch, "i386"))
11720     update_code_flag (CODE_32BIT, 1);
11721   else if (!strcmp (default_arch, "iamcu"))
11722     {
11723       update_code_flag (CODE_32BIT, 1);
11724       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
11725         {
11726           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
11727           cpu_arch_name = "iamcu";
11728           cpu_sub_arch_name = NULL;
11729           cpu_arch_flags = iamcu_flags;
11730           cpu_arch_isa = PROCESSOR_IAMCU;
11731           cpu_arch_isa_flags = iamcu_flags;
11732           if (!cpu_arch_tune_set)
11733             {
11734               cpu_arch_tune = cpu_arch_isa;
11735               cpu_arch_tune_flags = cpu_arch_isa_flags;
11736             }
11737         }
11738       else if (cpu_arch_isa != PROCESSOR_IAMCU)
11739         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
11740                   cpu_arch_name);
11741     }
11742   else
11743     as_fatal (_("unknown architecture"));
11744
11745   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
11746     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
11747   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
11748     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
11749
11750   switch (OUTPUT_FLAVOR)
11751     {
11752 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
11753     case bfd_target_aout_flavour:
11754       return AOUT_TARGET_FORMAT;
11755 #endif
11756 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
11757 # if defined (TE_PE) || defined (TE_PEP)
11758     case bfd_target_coff_flavour:
11759       if (flag_code == CODE_64BIT)
11760         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
11761       else
11762         return "pe-i386";
11763 # elif defined (TE_GO32)
11764     case bfd_target_coff_flavour:
11765       return "coff-go32";
11766 # else
11767     case bfd_target_coff_flavour:
11768       return "coff-i386";
11769 # endif
11770 #endif
11771 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
11772     case bfd_target_elf_flavour:
11773       {
11774         const char *format;
11775
11776         switch (x86_elf_abi)
11777           {
11778           default:
11779             format = ELF_TARGET_FORMAT;
11780             break;
11781           case X86_64_ABI:
11782             use_rela_relocations = 1;
11783             object_64bit = 1;
11784             format = ELF_TARGET_FORMAT64;
11785             break;
11786           case X86_64_X32_ABI:
11787             use_rela_relocations = 1;
11788             object_64bit = 1;
11789             disallow_64bit_reloc = 1;
11790             format = ELF_TARGET_FORMAT32;
11791             break;
11792           }
11793         if (cpu_arch_isa == PROCESSOR_L1OM)
11794           {
11795             if (x86_elf_abi != X86_64_ABI)
11796               as_fatal (_("Intel L1OM is 64bit only"));
11797             return ELF_TARGET_L1OM_FORMAT;
11798           }
11799         else if (cpu_arch_isa == PROCESSOR_K1OM)
11800           {
11801             if (x86_elf_abi != X86_64_ABI)
11802               as_fatal (_("Intel K1OM is 64bit only"));
11803             return ELF_TARGET_K1OM_FORMAT;
11804           }
11805         else if (cpu_arch_isa == PROCESSOR_IAMCU)
11806           {
11807             if (x86_elf_abi != I386_ABI)
11808               as_fatal (_("Intel MCU is 32bit only"));
11809             return ELF_TARGET_IAMCU_FORMAT;
11810           }
11811         else
11812           return format;
11813       }
11814 #endif
11815 #if defined (OBJ_MACH_O)
11816     case bfd_target_mach_o_flavour:
11817       if (flag_code == CODE_64BIT)
11818         {
11819           use_rela_relocations = 1;
11820           object_64bit = 1;
11821           return "mach-o-x86-64";
11822         }
11823       else
11824         return "mach-o-i386";
11825 #endif
11826     default:
11827       abort ();
11828       return NULL;
11829     }
11830 }
11831
11832 #endif /* OBJ_MAYBE_ more than one  */
11833 \f
11834 symbolS *
11835 md_undefined_symbol (char *name)
11836 {
11837   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
11838       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
11839       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
11840       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
11841     {
11842       if (!GOT_symbol)
11843         {
11844           if (symbol_find (name))
11845             as_bad (_("GOT already in symbol table"));
11846           GOT_symbol = symbol_new (name, undefined_section,
11847                                    (valueT) 0, &zero_address_frag);
11848         };
11849       return GOT_symbol;
11850     }
11851   return 0;
11852 }
11853
11854 /* Round up a section size to the appropriate boundary.  */
11855
11856 valueT
11857 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
11858 {
11859 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
11860   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
11861     {
11862       /* For a.out, force the section size to be aligned.  If we don't do
11863          this, BFD will align it for us, but it will not write out the
11864          final bytes of the section.  This may be a bug in BFD, but it is
11865          easier to fix it here since that is how the other a.out targets
11866          work.  */
11867       int align;
11868
11869       align = bfd_get_section_alignment (stdoutput, segment);
11870       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
11871     }
11872 #endif
11873
11874   return size;
11875 }
11876
11877 /* On the i386, PC-relative offsets are relative to the start of the
11878    next instruction.  That is, the address of the offset, plus its
11879    size, since the offset is always the last part of the insn.  */
11880
11881 long
11882 md_pcrel_from (fixS *fixP)
11883 {
11884   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
11885 }
11886
11887 #ifndef I386COFF
11888
11889 static void
11890 s_bss (int ignore ATTRIBUTE_UNUSED)
11891 {
11892   int temp;
11893
11894 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11895   if (IS_ELF)
11896     obj_elf_section_change_hook ();
11897 #endif
11898   temp = get_absolute_expression ();
11899   subseg_set (bss_section, (subsegT) temp);
11900   demand_empty_rest_of_line ();
11901 }
11902
11903 #endif
11904
11905 void
11906 i386_validate_fix (fixS *fixp)
11907 {
11908   if (fixp->fx_subsy)
11909     {
11910       if (fixp->fx_subsy == GOT_symbol)
11911         {
11912           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
11913             {
11914               if (!object_64bit)
11915                 abort ();
11916 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11917               if (fixp->fx_tcbit2)
11918                 fixp->fx_r_type = (fixp->fx_tcbit
11919                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
11920                                    : BFD_RELOC_X86_64_GOTPCRELX);
11921               else
11922 #endif
11923                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
11924             }
11925           else
11926             {
11927               if (!object_64bit)
11928                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
11929               else
11930                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
11931             }
11932           fixp->fx_subsy = 0;
11933         }
11934     }
11935 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11936   else if (!object_64bit)
11937     {
11938       if (fixp->fx_r_type == BFD_RELOC_386_GOT32
11939           && fixp->fx_tcbit2)
11940         fixp->fx_r_type = BFD_RELOC_386_GOT32X;
11941     }
11942 #endif
11943 }
11944
11945 arelent *
11946 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
11947 {
11948   arelent *rel;
11949   bfd_reloc_code_real_type code;
11950
11951   switch (fixp->fx_r_type)
11952     {
11953 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11954     case BFD_RELOC_SIZE32:
11955     case BFD_RELOC_SIZE64:
11956       if (S_IS_DEFINED (fixp->fx_addsy)
11957           && !S_IS_EXTERNAL (fixp->fx_addsy))
11958         {
11959           /* Resolve size relocation against local symbol to size of
11960              the symbol plus addend.  */
11961           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
11962           if (fixp->fx_r_type == BFD_RELOC_SIZE32
11963               && !fits_in_unsigned_long (value))
11964             as_bad_where (fixp->fx_file, fixp->fx_line,
11965                           _("symbol size computation overflow"));
11966           fixp->fx_addsy = NULL;
11967           fixp->fx_subsy = NULL;
11968           md_apply_fix (fixp, (valueT *) &value, NULL);
11969           return NULL;
11970         }
11971 #endif
11972       /* Fall through.  */
11973
11974     case BFD_RELOC_X86_64_PLT32:
11975     case BFD_RELOC_X86_64_GOT32:
11976     case BFD_RELOC_X86_64_GOTPCREL:
11977     case BFD_RELOC_X86_64_GOTPCRELX:
11978     case BFD_RELOC_X86_64_REX_GOTPCRELX:
11979     case BFD_RELOC_386_PLT32:
11980     case BFD_RELOC_386_GOT32:
11981     case BFD_RELOC_386_GOT32X:
11982     case BFD_RELOC_386_GOTOFF:
11983     case BFD_RELOC_386_GOTPC:
11984     case BFD_RELOC_386_TLS_GD:
11985     case BFD_RELOC_386_TLS_LDM:
11986     case BFD_RELOC_386_TLS_LDO_32:
11987     case BFD_RELOC_386_TLS_IE_32:
11988     case BFD_RELOC_386_TLS_IE:
11989     case BFD_RELOC_386_TLS_GOTIE:
11990     case BFD_RELOC_386_TLS_LE_32:
11991     case BFD_RELOC_386_TLS_LE:
11992     case BFD_RELOC_386_TLS_GOTDESC:
11993     case BFD_RELOC_386_TLS_DESC_CALL:
11994     case BFD_RELOC_X86_64_TLSGD:
11995     case BFD_RELOC_X86_64_TLSLD:
11996     case BFD_RELOC_X86_64_DTPOFF32:
11997     case BFD_RELOC_X86_64_DTPOFF64:
11998     case BFD_RELOC_X86_64_GOTTPOFF:
11999     case BFD_RELOC_X86_64_TPOFF32:
12000     case BFD_RELOC_X86_64_TPOFF64:
12001     case BFD_RELOC_X86_64_GOTOFF64:
12002     case BFD_RELOC_X86_64_GOTPC32:
12003     case BFD_RELOC_X86_64_GOT64:
12004     case BFD_RELOC_X86_64_GOTPCREL64:
12005     case BFD_RELOC_X86_64_GOTPC64:
12006     case BFD_RELOC_X86_64_GOTPLT64:
12007     case BFD_RELOC_X86_64_PLTOFF64:
12008     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12009     case BFD_RELOC_X86_64_TLSDESC_CALL:
12010     case BFD_RELOC_RVA:
12011     case BFD_RELOC_VTABLE_ENTRY:
12012     case BFD_RELOC_VTABLE_INHERIT:
12013 #ifdef TE_PE
12014     case BFD_RELOC_32_SECREL:
12015 #endif
12016       code = fixp->fx_r_type;
12017       break;
12018     case BFD_RELOC_X86_64_32S:
12019       if (!fixp->fx_pcrel)
12020         {
12021           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
12022           code = fixp->fx_r_type;
12023           break;
12024         }
12025       /* Fall through.  */
12026     default:
12027       if (fixp->fx_pcrel)
12028         {
12029           switch (fixp->fx_size)
12030             {
12031             default:
12032               as_bad_where (fixp->fx_file, fixp->fx_line,
12033                             _("can not do %d byte pc-relative relocation"),
12034                             fixp->fx_size);
12035               code = BFD_RELOC_32_PCREL;
12036               break;
12037             case 1: code = BFD_RELOC_8_PCREL;  break;
12038             case 2: code = BFD_RELOC_16_PCREL; break;
12039             case 4: code = BFD_RELOC_32_PCREL; break;
12040 #ifdef BFD64
12041             case 8: code = BFD_RELOC_64_PCREL; break;
12042 #endif
12043             }
12044         }
12045       else
12046         {
12047           switch (fixp->fx_size)
12048             {
12049             default:
12050               as_bad_where (fixp->fx_file, fixp->fx_line,
12051                             _("can not do %d byte relocation"),
12052                             fixp->fx_size);
12053               code = BFD_RELOC_32;
12054               break;
12055             case 1: code = BFD_RELOC_8;  break;
12056             case 2: code = BFD_RELOC_16; break;
12057             case 4: code = BFD_RELOC_32; break;
12058 #ifdef BFD64
12059             case 8: code = BFD_RELOC_64; break;
12060 #endif
12061             }
12062         }
12063       break;
12064     }
12065
12066   if ((code == BFD_RELOC_32
12067        || code == BFD_RELOC_32_PCREL
12068        || code == BFD_RELOC_X86_64_32S)
12069       && GOT_symbol
12070       && fixp->fx_addsy == GOT_symbol)
12071     {
12072       if (!object_64bit)
12073         code = BFD_RELOC_386_GOTPC;
12074       else
12075         code = BFD_RELOC_X86_64_GOTPC32;
12076     }
12077   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
12078       && GOT_symbol
12079       && fixp->fx_addsy == GOT_symbol)
12080     {
12081       code = BFD_RELOC_X86_64_GOTPC64;
12082     }
12083
12084   rel = XNEW (arelent);
12085   rel->sym_ptr_ptr = XNEW (asymbol *);
12086   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
12087
12088   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
12089
12090   if (!use_rela_relocations)
12091     {
12092       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
12093          vtable entry to be used in the relocation's section offset.  */
12094       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
12095         rel->address = fixp->fx_offset;
12096 #if defined (OBJ_COFF) && defined (TE_PE)
12097       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
12098         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
12099       else
12100 #endif
12101       rel->addend = 0;
12102     }
12103   /* Use the rela in 64bit mode.  */
12104   else
12105     {
12106       if (disallow_64bit_reloc)
12107         switch (code)
12108           {
12109           case BFD_RELOC_X86_64_DTPOFF64:
12110           case BFD_RELOC_X86_64_TPOFF64:
12111           case BFD_RELOC_64_PCREL:
12112           case BFD_RELOC_X86_64_GOTOFF64:
12113           case BFD_RELOC_X86_64_GOT64:
12114           case BFD_RELOC_X86_64_GOTPCREL64:
12115           case BFD_RELOC_X86_64_GOTPC64:
12116           case BFD_RELOC_X86_64_GOTPLT64:
12117           case BFD_RELOC_X86_64_PLTOFF64:
12118             as_bad_where (fixp->fx_file, fixp->fx_line,
12119                           _("cannot represent relocation type %s in x32 mode"),
12120                           bfd_get_reloc_code_name (code));
12121             break;
12122           default:
12123             break;
12124           }
12125
12126       if (!fixp->fx_pcrel)
12127         rel->addend = fixp->fx_offset;
12128       else
12129         switch (code)
12130           {
12131           case BFD_RELOC_X86_64_PLT32:
12132           case BFD_RELOC_X86_64_GOT32:
12133           case BFD_RELOC_X86_64_GOTPCREL:
12134           case BFD_RELOC_X86_64_GOTPCRELX:
12135           case BFD_RELOC_X86_64_REX_GOTPCRELX:
12136           case BFD_RELOC_X86_64_TLSGD:
12137           case BFD_RELOC_X86_64_TLSLD:
12138           case BFD_RELOC_X86_64_GOTTPOFF:
12139           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
12140           case BFD_RELOC_X86_64_TLSDESC_CALL:
12141             rel->addend = fixp->fx_offset - fixp->fx_size;
12142             break;
12143           default:
12144             rel->addend = (section->vma
12145                            - fixp->fx_size
12146                            + fixp->fx_addnumber
12147                            + md_pcrel_from (fixp));
12148             break;
12149           }
12150     }
12151
12152   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
12153   if (rel->howto == NULL)
12154     {
12155       as_bad_where (fixp->fx_file, fixp->fx_line,
12156                     _("cannot represent relocation type %s"),
12157                     bfd_get_reloc_code_name (code));
12158       /* Set howto to a garbage value so that we can keep going.  */
12159       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
12160       gas_assert (rel->howto != NULL);
12161     }
12162
12163   return rel;
12164 }
12165
12166 #include "tc-i386-intel.c"
12167
12168 void
12169 tc_x86_parse_to_dw2regnum (expressionS *exp)
12170 {
12171   int saved_naked_reg;
12172   char saved_register_dot;
12173
12174   saved_naked_reg = allow_naked_reg;
12175   allow_naked_reg = 1;
12176   saved_register_dot = register_chars['.'];
12177   register_chars['.'] = '.';
12178   allow_pseudo_reg = 1;
12179   expression_and_evaluate (exp);
12180   allow_pseudo_reg = 0;
12181   register_chars['.'] = saved_register_dot;
12182   allow_naked_reg = saved_naked_reg;
12183
12184   if (exp->X_op == O_register && exp->X_add_number >= 0)
12185     {
12186       if ((addressT) exp->X_add_number < i386_regtab_size)
12187         {
12188           exp->X_op = O_constant;
12189           exp->X_add_number = i386_regtab[exp->X_add_number]
12190                               .dw2_regnum[flag_code >> 1];
12191         }
12192       else
12193         exp->X_op = O_illegal;
12194     }
12195 }
12196
12197 void
12198 tc_x86_frame_initial_instructions (void)
12199 {
12200   static unsigned int sp_regno[2];
12201
12202   if (!sp_regno[flag_code >> 1])
12203     {
12204       char *saved_input = input_line_pointer;
12205       char sp[][4] = {"esp", "rsp"};
12206       expressionS exp;
12207
12208       input_line_pointer = sp[flag_code >> 1];
12209       tc_x86_parse_to_dw2regnum (&exp);
12210       gas_assert (exp.X_op == O_constant);
12211       sp_regno[flag_code >> 1] = exp.X_add_number;
12212       input_line_pointer = saved_input;
12213     }
12214
12215   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
12216   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
12217 }
12218
12219 int
12220 x86_dwarf2_addr_size (void)
12221 {
12222 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
12223   if (x86_elf_abi == X86_64_X32_ABI)
12224     return 4;
12225 #endif
12226   return bfd_arch_bits_per_address (stdoutput) / 8;
12227 }
12228
12229 int
12230 i386_elf_section_type (const char *str, size_t len)
12231 {
12232   if (flag_code == CODE_64BIT
12233       && len == sizeof ("unwind") - 1
12234       && strncmp (str, "unwind", 6) == 0)
12235     return SHT_X86_64_UNWIND;
12236
12237   return -1;
12238 }
12239
12240 #ifdef TE_SOLARIS
12241 void
12242 i386_solaris_fix_up_eh_frame (segT sec)
12243 {
12244   if (flag_code == CODE_64BIT)
12245     elf_section_type (sec) = SHT_X86_64_UNWIND;
12246 }
12247 #endif
12248
12249 #ifdef TE_PE
12250 void
12251 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
12252 {
12253   expressionS exp;
12254
12255   exp.X_op = O_secrel;
12256   exp.X_add_symbol = symbol;
12257   exp.X_add_number = 0;
12258   emit_expr (&exp, size);
12259 }
12260 #endif
12261
12262 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12263 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
12264
12265 bfd_vma
12266 x86_64_section_letter (int letter, const char **ptr_msg)
12267 {
12268   if (flag_code == CODE_64BIT)
12269     {
12270       if (letter == 'l')
12271         return SHF_X86_64_LARGE;
12272
12273       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
12274     }
12275   else
12276     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
12277   return -1;
12278 }
12279
12280 bfd_vma
12281 x86_64_section_word (char *str, size_t len)
12282 {
12283   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
12284     return SHF_X86_64_LARGE;
12285
12286   return -1;
12287 }
12288
12289 static void
12290 handle_large_common (int small ATTRIBUTE_UNUSED)
12291 {
12292   if (flag_code != CODE_64BIT)
12293     {
12294       s_comm_internal (0, elf_common_parse);
12295       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
12296     }
12297   else
12298     {
12299       static segT lbss_section;
12300       asection *saved_com_section_ptr = elf_com_section_ptr;
12301       asection *saved_bss_section = bss_section;
12302
12303       if (lbss_section == NULL)
12304         {
12305           flagword applicable;
12306           segT seg = now_seg;
12307           subsegT subseg = now_subseg;
12308
12309           /* The .lbss section is for local .largecomm symbols.  */
12310           lbss_section = subseg_new (".lbss", 0);
12311           applicable = bfd_applicable_section_flags (stdoutput);
12312           bfd_set_section_flags (stdoutput, lbss_section,
12313                                  applicable & SEC_ALLOC);
12314           seg_info (lbss_section)->bss = 1;
12315
12316           subseg_set (seg, subseg);
12317         }
12318
12319       elf_com_section_ptr = &_bfd_elf_large_com_section;
12320       bss_section = lbss_section;
12321
12322       s_comm_internal (0, elf_common_parse);
12323
12324       elf_com_section_ptr = saved_com_section_ptr;
12325       bss_section = saved_bss_section;
12326     }
12327 }
12328 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */