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