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