gas/config/tc-i386.c

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