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