gas/config/tc-i386.c

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