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 (intel_syntax)
4679             operand_ok =
4680               i386_intel_operand (token_start,
4681                                   intel_float_operand (mnemonic));
4682           else
4683             operand_ok = i386_att_operand (token_start);
4684
4685           RESTORE_END_STRING (l);
4686           if (!operand_ok)
4687             return NULL;
4688         }
4689       else
4690         {
4691           if (expecting_operand)
4692             {
4693             expecting_operand_after_comma:
4694               as_bad (_("expecting operand after ','; got nothing"));
4695               return NULL;
4696             }
4697           if (*l == ',')
4698             {
4699               as_bad (_("expecting operand before ','; got nothing"));
4700               return NULL;
4701             }
4702         }
4703
4704       /* Now *l must be either ',' or END_OF_INSN.  */
4705       if (*l == ',')
4706         {
4707           if (*++l == END_OF_INSN)
4708             {
4709               /* Just skip it, if it's \n complain.  */
4710               goto expecting_operand_after_comma;
4711             }
4712           expecting_operand = 1;
4713         }
4714     }
4715   return l;
4716 }
4717
4718 static void
4719 swap_2_operands (int xchg1, int xchg2)
4720 {
4721   union i386_op temp_op;
4722   i386_operand_type temp_type;
4723   enum bfd_reloc_code_real temp_reloc;
4724
4725   temp_type = i.types[xchg2];
4726   i.types[xchg2] = i.types[xchg1];
4727   i.types[xchg1] = temp_type;
4728   temp_op = i.op[xchg2];
4729   i.op[xchg2] = i.op[xchg1];
4730   i.op[xchg1] = temp_op;
4731   temp_reloc = i.reloc[xchg2];
4732   i.reloc[xchg2] = i.reloc[xchg1];
4733   i.reloc[xchg1] = temp_reloc;
4734
4735   if (i.mask)
4736     {
4737       if (i.mask->operand == xchg1)
4738         i.mask->operand = xchg2;
4739       else if (i.mask->operand == xchg2)
4740         i.mask->operand = xchg1;
4741     }
4742   if (i.broadcast)
4743     {
4744       if (i.broadcast->operand == xchg1)
4745         i.broadcast->operand = xchg2;
4746       else if (i.broadcast->operand == xchg2)
4747         i.broadcast->operand = xchg1;
4748     }
4749   if (i.rounding)
4750     {
4751       if (i.rounding->operand == xchg1)
4752         i.rounding->operand = xchg2;
4753       else if (i.rounding->operand == xchg2)
4754         i.rounding->operand = xchg1;
4755     }
4756 }
4757
4758 static void
4759 swap_operands (void)
4760 {
4761   switch (i.operands)
4762     {
4763     case 5:
4764     case 4:
4765       swap_2_operands (1, i.operands - 2);
4766       /* Fall through.  */
4767     case 3:
4768     case 2:
4769       swap_2_operands (0, i.operands - 1);
4770       break;
4771     default:
4772       abort ();
4773     }
4774
4775   if (i.mem_operands == 2)
4776     {
4777       const seg_entry *temp_seg;
4778       temp_seg = i.seg[0];
4779       i.seg[0] = i.seg[1];
4780       i.seg[1] = temp_seg;
4781     }
4782 }
4783
4784 /* Try to ensure constant immediates are represented in the smallest
4785    opcode possible.  */
4786 static void
4787 optimize_imm (void)
4788 {
4789   char guess_suffix = 0;
4790   int op;
4791
4792   if (i.suffix)
4793     guess_suffix = i.suffix;
4794   else if (i.reg_operands)
4795     {
4796       /* Figure out a suffix from the last register operand specified.
4797          We can't do this properly yet, ie. excluding InOutPortReg,
4798          but the following works for instructions with immediates.
4799          In any case, we can't set i.suffix yet.  */
4800       for (op = i.operands; --op >= 0;)
4801         if (i.types[op].bitfield.reg && i.types[op].bitfield.byte)
4802           {
4803             guess_suffix = BYTE_MNEM_SUFFIX;
4804             break;
4805           }
4806         else if (i.types[op].bitfield.reg && i.types[op].bitfield.word)
4807           {
4808             guess_suffix = WORD_MNEM_SUFFIX;
4809             break;
4810           }
4811         else if (i.types[op].bitfield.reg && i.types[op].bitfield.dword)
4812           {
4813             guess_suffix = LONG_MNEM_SUFFIX;
4814             break;
4815           }
4816         else if (i.types[op].bitfield.reg && i.types[op].bitfield.qword)
4817           {
4818             guess_suffix = QWORD_MNEM_SUFFIX;
4819             break;
4820           }
4821     }
4822   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
4823     guess_suffix = WORD_MNEM_SUFFIX;
4824
4825   for (op = i.operands; --op >= 0;)
4826     if (operand_type_check (i.types[op], imm))
4827       {
4828         switch (i.op[op].imms->X_op)
4829           {
4830           case O_constant:
4831             /* If a suffix is given, this operand may be shortened.  */
4832             switch (guess_suffix)
4833               {
4834               case LONG_MNEM_SUFFIX:
4835                 i.types[op].bitfield.imm32 = 1;
4836                 i.types[op].bitfield.imm64 = 1;
4837                 break;
4838               case WORD_MNEM_SUFFIX:
4839                 i.types[op].bitfield.imm16 = 1;
4840                 i.types[op].bitfield.imm32 = 1;
4841                 i.types[op].bitfield.imm32s = 1;
4842                 i.types[op].bitfield.imm64 = 1;
4843                 break;
4844               case BYTE_MNEM_SUFFIX:
4845                 i.types[op].bitfield.imm8 = 1;
4846                 i.types[op].bitfield.imm8s = 1;
4847                 i.types[op].bitfield.imm16 = 1;
4848                 i.types[op].bitfield.imm32 = 1;
4849                 i.types[op].bitfield.imm32s = 1;
4850                 i.types[op].bitfield.imm64 = 1;
4851                 break;
4852               }
4853
4854             /* If this operand is at most 16 bits, convert it
4855                to a signed 16 bit number before trying to see
4856                whether it will fit in an even smaller size.
4857                This allows a 16-bit operand such as $0xffe0 to
4858                be recognised as within Imm8S range.  */
4859             if ((i.types[op].bitfield.imm16)
4860                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
4861               {
4862                 i.op[op].imms->X_add_number =
4863                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
4864               }
4865 #ifdef BFD64
4866             /* Store 32-bit immediate in 64-bit for 64-bit BFD.  */
4867             if ((i.types[op].bitfield.imm32)
4868                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
4869                     == 0))
4870               {
4871                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
4872                                                 ^ ((offsetT) 1 << 31))
4873                                                - ((offsetT) 1 << 31));
4874               }
4875 #endif
4876             i.types[op]
4877               = operand_type_or (i.types[op],
4878                                  smallest_imm_type (i.op[op].imms->X_add_number));
4879
4880             /* We must avoid matching of Imm32 templates when 64bit
4881                only immediate is available.  */
4882             if (guess_suffix == QWORD_MNEM_SUFFIX)
4883               i.types[op].bitfield.imm32 = 0;
4884             break;
4885
4886           case O_absent:
4887           case O_register:
4888             abort ();
4889
4890             /* Symbols and expressions.  */
4891           default:
4892             /* Convert symbolic operand to proper sizes for matching, but don't
4893                prevent matching a set of insns that only supports sizes other
4894                than those matching the insn suffix.  */
4895             {
4896               i386_operand_type mask, allowed;
4897               const insn_template *t;
4898
4899               operand_type_set (&mask, 0);
4900               operand_type_set (&allowed, 0);
4901
4902               for (t = current_templates->start;
4903                    t < current_templates->end;
4904                    ++t)
4905                 allowed = operand_type_or (allowed,
4906                                            t->operand_types[op]);
4907               switch (guess_suffix)
4908                 {
4909                 case QWORD_MNEM_SUFFIX:
4910                   mask.bitfield.imm64 = 1;
4911                   mask.bitfield.imm32s = 1;
4912                   break;
4913                 case LONG_MNEM_SUFFIX:
4914                   mask.bitfield.imm32 = 1;
4915                   break;
4916                 case WORD_MNEM_SUFFIX:
4917                   mask.bitfield.imm16 = 1;
4918                   break;
4919                 case BYTE_MNEM_SUFFIX:
4920                   mask.bitfield.imm8 = 1;
4921                   break;
4922                 default:
4923                   break;
4924                 }
4925               allowed = operand_type_and (mask, allowed);
4926               if (!operand_type_all_zero (&allowed))
4927                 i.types[op] = operand_type_and (i.types[op], mask);
4928             }
4929             break;
4930           }
4931       }
4932 }
4933
4934 /* Try to use the smallest displacement type too.  */
4935 static void
4936 optimize_disp (void)
4937 {
4938   int op;
4939
4940   for (op = i.operands; --op >= 0;)
4941     if (operand_type_check (i.types[op], disp))
4942       {
4943         if (i.op[op].disps->X_op == O_constant)
4944           {
4945             offsetT op_disp = i.op[op].disps->X_add_number;
4946
4947             if (i.types[op].bitfield.disp16
4948                 && (op_disp & ~(offsetT) 0xffff) == 0)
4949               {
4950                 /* If this operand is at most 16 bits, convert
4951                    to a signed 16 bit number and don't use 64bit
4952                    displacement.  */
4953                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
4954                 i.types[op].bitfield.disp64 = 0;
4955               }
4956 #ifdef BFD64
4957             /* Optimize 64-bit displacement to 32-bit for 64-bit BFD.  */
4958             if (i.types[op].bitfield.disp32
4959                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
4960               {
4961                 /* If this operand is at most 32 bits, convert
4962                    to a signed 32 bit number and don't use 64bit
4963                    displacement.  */
4964                 op_disp &= (((offsetT) 2 << 31) - 1);
4965                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
4966                 i.types[op].bitfield.disp64 = 0;
4967               }
4968 #endif
4969             if (!op_disp && i.types[op].bitfield.baseindex)
4970               {
4971                 i.types[op].bitfield.disp8 = 0;
4972                 i.types[op].bitfield.disp16 = 0;
4973                 i.types[op].bitfield.disp32 = 0;
4974                 i.types[op].bitfield.disp32s = 0;
4975                 i.types[op].bitfield.disp64 = 0;
4976                 i.op[op].disps = 0;
4977                 i.disp_operands--;
4978               }
4979             else if (flag_code == CODE_64BIT)
4980               {
4981                 if (fits_in_signed_long (op_disp))
4982                   {
4983                     i.types[op].bitfield.disp64 = 0;
4984                     i.types[op].bitfield.disp32s = 1;
4985                   }
4986                 if (i.prefix[ADDR_PREFIX]
4987                     && fits_in_unsigned_long (op_disp))
4988                   i.types[op].bitfield.disp32 = 1;
4989               }
4990             if ((i.types[op].bitfield.disp32
4991                  || i.types[op].bitfield.disp32s
4992                  || i.types[op].bitfield.disp16)
4993                 && fits_in_disp8 (op_disp))
4994               i.types[op].bitfield.disp8 = 1;
4995           }
4996         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
4997                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
4998           {
4999             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
5000                          i.op[op].disps, 0, i.reloc[op]);
5001             i.types[op].bitfield.disp8 = 0;
5002             i.types[op].bitfield.disp16 = 0;
5003             i.types[op].bitfield.disp32 = 0;
5004             i.types[op].bitfield.disp32s = 0;
5005             i.types[op].bitfield.disp64 = 0;
5006           }
5007         else
5008           /* We only support 64bit displacement on constants.  */
5009           i.types[op].bitfield.disp64 = 0;
5010       }
5011 }
5012
5013 /* Return 1 if there is a match in broadcast bytes between operand
5014    GIVEN and instruction template T.   */
5015
5016 static INLINE int
5017 match_broadcast_size (const insn_template *t, unsigned int given)
5018 {
5019   return ((t->opcode_modifier.broadcast == BYTE_BROADCAST
5020            && i.types[given].bitfield.byte)
5021           || (t->opcode_modifier.broadcast == WORD_BROADCAST
5022               && i.types[given].bitfield.word)
5023           || (t->opcode_modifier.broadcast == DWORD_BROADCAST
5024               && i.types[given].bitfield.dword)
5025           || (t->opcode_modifier.broadcast == QWORD_BROADCAST
5026               && i.types[given].bitfield.qword));
5027 }
5028
5029 /* Check if operands are valid for the instruction.  */
5030
5031 static int
5032 check_VecOperands (const insn_template *t)
5033 {
5034   unsigned int op;
5035   i386_cpu_flags cpu;
5036   static const i386_cpu_flags avx512 = CPU_ANY_AVX512F_FLAGS;
5037
5038   /* Templates allowing for ZMMword as well as YMMword and/or XMMword for
5039      any one operand are implicity requiring AVX512VL support if the actual
5040      operand size is YMMword or XMMword.  Since this function runs after
5041      template matching, there's no need to check for YMMword/XMMword in
5042      the template.  */
5043   cpu = cpu_flags_and (t->cpu_flags, avx512);
5044   if (!cpu_flags_all_zero (&cpu)
5045       && !t->cpu_flags.bitfield.cpuavx512vl
5046       && !cpu_arch_flags.bitfield.cpuavx512vl)
5047     {
5048       for (op = 0; op < t->operands; ++op)
5049         {
5050           if (t->operand_types[op].bitfield.zmmword
5051               && (i.types[op].bitfield.ymmword
5052                   || i.types[op].bitfield.xmmword))
5053             {
5054               i.error = unsupported;
5055               return 1;
5056             }
5057         }
5058     }
5059
5060   /* Without VSIB byte, we can't have a vector register for index.  */
5061   if (!t->opcode_modifier.vecsib
5062       && i.index_reg
5063       && (i.index_reg->reg_type.bitfield.xmmword
5064           || i.index_reg->reg_type.bitfield.ymmword
5065           || i.index_reg->reg_type.bitfield.zmmword))
5066     {
5067       i.error = unsupported_vector_index_register;
5068       return 1;
5069     }
5070
5071   /* Check if default mask is allowed.  */
5072   if (t->opcode_modifier.nodefmask
5073       && (!i.mask || i.mask->mask->reg_num == 0))
5074     {
5075       i.error = no_default_mask;
5076       return 1;
5077     }
5078
5079   /* For VSIB byte, we need a vector register for index, and all vector
5080      registers must be distinct.  */
5081   if (t->opcode_modifier.vecsib)
5082     {
5083       if (!i.index_reg
5084           || !((t->opcode_modifier.vecsib == VecSIB128
5085                 && i.index_reg->reg_type.bitfield.xmmword)
5086                || (t->opcode_modifier.vecsib == VecSIB256
5087                    && i.index_reg->reg_type.bitfield.ymmword)
5088                || (t->opcode_modifier.vecsib == VecSIB512
5089                    && i.index_reg->reg_type.bitfield.zmmword)))
5090       {
5091         i.error = invalid_vsib_address;
5092         return 1;
5093       }
5094
5095       gas_assert (i.reg_operands == 2 || i.mask);
5096       if (i.reg_operands == 2 && !i.mask)
5097         {
5098           gas_assert (i.types[0].bitfield.regsimd);
5099           gas_assert (i.types[0].bitfield.xmmword
5100                       || i.types[0].bitfield.ymmword);
5101           gas_assert (i.types[2].bitfield.regsimd);
5102           gas_assert (i.types[2].bitfield.xmmword
5103                       || i.types[2].bitfield.ymmword);
5104           if (operand_check == check_none)
5105             return 0;
5106           if (register_number (i.op[0].regs)
5107               != register_number (i.index_reg)
5108               && register_number (i.op[2].regs)
5109                  != register_number (i.index_reg)
5110               && register_number (i.op[0].regs)
5111                  != register_number (i.op[2].regs))
5112             return 0;
5113           if (operand_check == check_error)
5114             {
5115               i.error = invalid_vector_register_set;
5116               return 1;
5117             }
5118           as_warn (_("mask, index, and destination registers should be distinct"));
5119         }
5120       else if (i.reg_operands == 1 && i.mask)
5121         {
5122           if (i.types[1].bitfield.regsimd
5123               && (i.types[1].bitfield.xmmword
5124                   || i.types[1].bitfield.ymmword
5125                   || i.types[1].bitfield.zmmword)
5126               && (register_number (i.op[1].regs)
5127                   == register_number (i.index_reg)))
5128             {
5129               if (operand_check == check_error)
5130                 {
5131                   i.error = invalid_vector_register_set;
5132                   return 1;
5133                 }
5134               if (operand_check != check_none)
5135                 as_warn (_("index and destination registers should be distinct"));
5136             }
5137         }
5138     }
5139
5140   /* Check if broadcast is supported by the instruction and is applied
5141      to the memory operand.  */
5142   if (i.broadcast)
5143     {
5144       i386_operand_type type, overlap;
5145
5146       /* Check if specified broadcast is supported in this instruction,
5147          and its broadcast bytes match the memory operand.  */
5148       op = i.broadcast->operand;
5149       if (!t->opcode_modifier.broadcast
5150           || !i.types[op].bitfield.mem
5151           || (!i.types[op].bitfield.unspecified
5152               && !match_broadcast_size (t, op)))
5153         {
5154         bad_broadcast:
5155           i.error = unsupported_broadcast;
5156           return 1;
5157         }
5158
5159       i.broadcast->bytes = ((1 << (t->opcode_modifier.broadcast - 1))
5160                             * i.broadcast->type);
5161       operand_type_set (&type, 0);
5162       switch (i.broadcast->bytes)
5163         {
5164         case 2:
5165           type.bitfield.word = 1;
5166           break;
5167         case 4:
5168           type.bitfield.dword = 1;
5169           break;
5170         case 8:
5171           type.bitfield.qword = 1;
5172           break;
5173         case 16:
5174           type.bitfield.xmmword = 1;
5175           break;
5176         case 32:
5177           type.bitfield.ymmword = 1;
5178           break;
5179         case 64:
5180           type.bitfield.zmmword = 1;
5181           break;
5182         default:
5183           goto bad_broadcast;
5184         }
5185
5186       overlap = operand_type_and (type, t->operand_types[op]);
5187       if (operand_type_all_zero (&overlap))
5188           goto bad_broadcast;
5189
5190       if (t->opcode_modifier.checkregsize)
5191         {
5192           unsigned int j;
5193
5194           type.bitfield.baseindex = 1;
5195           for (j = 0; j < i.operands; ++j)
5196             {
5197               if (j != op
5198                   && !operand_type_register_match(i.types[j],
5199                                                   t->operand_types[j],
5200                                                   type,
5201                                                   t->operand_types[op]))
5202                 goto bad_broadcast;
5203             }
5204         }
5205     }
5206   /* If broadcast is supported in this instruction, we need to check if
5207      operand of one-element size isn't specified without broadcast.  */
5208   else if (t->opcode_modifier.broadcast && i.mem_operands)
5209     {
5210       /* Find memory operand.  */
5211       for (op = 0; op < i.operands; op++)
5212         if (operand_type_check (i.types[op], anymem))
5213           break;
5214       gas_assert (op < i.operands);
5215       /* Check size of the memory operand.  */
5216       if (match_broadcast_size (t, op))
5217         {
5218           i.error = broadcast_needed;
5219           return 1;
5220         }
5221     }
5222   else
5223     op = MAX_OPERANDS - 1; /* Avoid uninitialized variable warning.  */
5224
5225   /* Check if requested masking is supported.  */
5226   if (i.mask
5227       && (!t->opcode_modifier.masking
5228           || (i.mask->zeroing
5229               && t->opcode_modifier.masking == MERGING_MASKING)))
5230     {
5231       i.error = unsupported_masking;
5232       return 1;
5233     }
5234
5235   /* Check if masking is applied to dest operand.  */
5236   if (i.mask && (i.mask->operand != (int) (i.operands - 1)))
5237     {
5238       i.error = mask_not_on_destination;
5239       return 1;
5240     }
5241
5242   /* Check RC/SAE.  */
5243   if (i.rounding)
5244     {
5245       if ((i.rounding->type != saeonly
5246            && !t->opcode_modifier.staticrounding)
5247           || (i.rounding->type == saeonly
5248               && (t->opcode_modifier.staticrounding
5249                   || !t->opcode_modifier.sae)))
5250         {
5251           i.error = unsupported_rc_sae;
5252           return 1;
5253         }
5254       /* If the instruction has several immediate operands and one of
5255          them is rounding, the rounding operand should be the last
5256          immediate operand.  */
5257       if (i.imm_operands > 1
5258           && i.rounding->operand != (int) (i.imm_operands - 1))
5259         {
5260           i.error = rc_sae_operand_not_last_imm;
5261           return 1;
5262         }
5263     }
5264
5265   /* Check vector Disp8 operand.  */
5266   if (t->opcode_modifier.disp8memshift
5267       && i.disp_encoding != disp_encoding_32bit)
5268     {
5269       if (i.broadcast)
5270         i.memshift = t->opcode_modifier.broadcast - 1;
5271       else if (t->opcode_modifier.disp8memshift != DISP8_SHIFT_VL)
5272         i.memshift = t->opcode_modifier.disp8memshift;
5273       else
5274         {
5275           const i386_operand_type *type = NULL;
5276
5277           i.memshift = 0;
5278           for (op = 0; op < i.operands; op++)
5279             if (operand_type_check (i.types[op], anymem))
5280               {
5281                 if (t->opcode_modifier.evex == EVEXLIG)
5282                   i.memshift = 2 + (i.suffix == QWORD_MNEM_SUFFIX);
5283                 else if (t->operand_types[op].bitfield.xmmword
5284                          + t->operand_types[op].bitfield.ymmword
5285                          + t->operand_types[op].bitfield.zmmword <= 1)
5286                   type = &t->operand_types[op];
5287                 else if (!i.types[op].bitfield.unspecified)
5288                   type = &i.types[op];
5289               }
5290             else if (i.types[op].bitfield.regsimd
5291                      && t->opcode_modifier.evex != EVEXLIG)
5292               {
5293                 if (i.types[op].bitfield.zmmword)
5294                   i.memshift = 6;
5295                 else if (i.types[op].bitfield.ymmword && i.memshift < 5)
5296                   i.memshift = 5;
5297                 else if (i.types[op].bitfield.xmmword && i.memshift < 4)
5298                   i.memshift = 4;
5299               }
5300
5301           if (type)
5302             {
5303               if (type->bitfield.zmmword)
5304                 i.memshift = 6;
5305               else if (type->bitfield.ymmword)
5306                 i.memshift = 5;
5307               else if (type->bitfield.xmmword)
5308                 i.memshift = 4;
5309             }
5310
5311           /* For the check in fits_in_disp8().  */
5312           if (i.memshift == 0)
5313             i.memshift = -1;
5314         }
5315
5316       for (op = 0; op < i.operands; op++)
5317         if (operand_type_check (i.types[op], disp)
5318             && i.op[op].disps->X_op == O_constant)
5319           {
5320             if (fits_in_disp8 (i.op[op].disps->X_add_number))
5321               {
5322                 i.types[op].bitfield.disp8 = 1;
5323                 return 0;
5324               }
5325             i.types[op].bitfield.disp8 = 0;
5326           }
5327     }
5328
5329   i.memshift = 0;
5330
5331   return 0;
5332 }
5333
5334 /* Check if operands are valid for the instruction.  Update VEX
5335    operand types.  */
5336
5337 static int
5338 VEX_check_operands (const insn_template *t)
5339 {
5340   if (i.vec_encoding == vex_encoding_evex)
5341     {
5342       /* This instruction must be encoded with EVEX prefix.  */
5343       if (!is_evex_encoding (t))
5344         {
5345           i.error = unsupported;
5346           return 1;
5347         }
5348       return 0;
5349     }
5350
5351   if (!t->opcode_modifier.vex)
5352     {
5353       /* This instruction template doesn't have VEX prefix.  */
5354       if (i.vec_encoding != vex_encoding_default)
5355         {
5356           i.error = unsupported;
5357           return 1;
5358         }
5359       return 0;
5360     }
5361
5362   /* Only check VEX_Imm4, which must be the first operand.  */
5363   if (t->operand_types[0].bitfield.vec_imm4)
5364     {
5365       if (i.op[0].imms->X_op != O_constant
5366           || !fits_in_imm4 (i.op[0].imms->X_add_number))
5367         {
5368           i.error = bad_imm4;
5369           return 1;
5370         }
5371
5372       /* Turn off Imm8 so that update_imm won't complain.  */
5373       i.types[0] = vec_imm4;
5374     }
5375
5376   return 0;
5377 }
5378
5379 static const insn_template *
5380 match_template (char mnem_suffix)
5381 {
5382   /* Points to template once we've found it.  */
5383   const insn_template *t;
5384   i386_operand_type overlap0, overlap1, overlap2, overlap3;
5385   i386_operand_type overlap4;
5386   unsigned int found_reverse_match;
5387   i386_opcode_modifier suffix_check, mnemsuf_check;
5388   i386_operand_type operand_types [MAX_OPERANDS];
5389   int addr_prefix_disp;
5390   unsigned int j;
5391   unsigned int found_cpu_match, size_match;
5392   unsigned int check_register;
5393   enum i386_error specific_error = 0;
5394
5395 #if MAX_OPERANDS != 5
5396 # error "MAX_OPERANDS must be 5."
5397 #endif
5398
5399   found_reverse_match = 0;
5400   addr_prefix_disp = -1;
5401
5402   memset (&suffix_check, 0, sizeof (suffix_check));
5403   if (intel_syntax && i.broadcast)
5404     /* nothing */;
5405   else if (i.suffix == BYTE_MNEM_SUFFIX)
5406     suffix_check.no_bsuf = 1;
5407   else if (i.suffix == WORD_MNEM_SUFFIX)
5408     suffix_check.no_wsuf = 1;
5409   else if (i.suffix == SHORT_MNEM_SUFFIX)
5410     suffix_check.no_ssuf = 1;
5411   else if (i.suffix == LONG_MNEM_SUFFIX)
5412     suffix_check.no_lsuf = 1;
5413   else if (i.suffix == QWORD_MNEM_SUFFIX)
5414     suffix_check.no_qsuf = 1;
5415   else if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
5416     suffix_check.no_ldsuf = 1;
5417
5418   memset (&mnemsuf_check, 0, sizeof (mnemsuf_check));
5419   if (intel_syntax)
5420     {
5421       switch (mnem_suffix)
5422         {
5423         case BYTE_MNEM_SUFFIX:  mnemsuf_check.no_bsuf = 1; break;
5424         case WORD_MNEM_SUFFIX:  mnemsuf_check.no_wsuf = 1; break;
5425         case SHORT_MNEM_SUFFIX: mnemsuf_check.no_ssuf = 1; break;
5426         case LONG_MNEM_SUFFIX:  mnemsuf_check.no_lsuf = 1; break;
5427         case QWORD_MNEM_SUFFIX: mnemsuf_check.no_qsuf = 1; break;
5428         }
5429     }
5430
5431   /* Must have right number of operands.  */
5432   i.error = number_of_operands_mismatch;
5433
5434   for (t = current_templates->start; t < current_templates->end; t++)
5435     {
5436       addr_prefix_disp = -1;
5437
5438       if (i.operands != t->operands)
5439         continue;
5440
5441       /* Check processor support.  */
5442       i.error = unsupported;
5443       found_cpu_match = (cpu_flags_match (t)
5444                          == CPU_FLAGS_PERFECT_MATCH);
5445       if (!found_cpu_match)
5446         continue;
5447
5448       /* Check AT&T mnemonic.   */
5449       i.error = unsupported_with_intel_mnemonic;
5450       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
5451         continue;
5452
5453       /* Check AT&T/Intel syntax and Intel64/AMD64 ISA.   */
5454       i.error = unsupported_syntax;
5455       if ((intel_syntax && t->opcode_modifier.attsyntax)
5456           || (!intel_syntax && t->opcode_modifier.intelsyntax)
5457           || (intel64 && t->opcode_modifier.amd64)
5458           || (!intel64 && t->opcode_modifier.intel64))
5459         continue;
5460
5461       /* Check the suffix, except for some instructions in intel mode.  */
5462       i.error = invalid_instruction_suffix;
5463       if ((!intel_syntax || !t->opcode_modifier.ignoresize)
5464           && ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
5465               || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
5466               || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
5467               || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
5468               || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
5469               || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf)))
5470         continue;
5471       /* In Intel mode all mnemonic suffixes must be explicitly allowed.  */
5472       if ((t->opcode_modifier.no_bsuf && mnemsuf_check.no_bsuf)
5473           || (t->opcode_modifier.no_wsuf && mnemsuf_check.no_wsuf)
5474           || (t->opcode_modifier.no_lsuf && mnemsuf_check.no_lsuf)
5475           || (t->opcode_modifier.no_ssuf && mnemsuf_check.no_ssuf)
5476           || (t->opcode_modifier.no_qsuf && mnemsuf_check.no_qsuf)
5477           || (t->opcode_modifier.no_ldsuf && mnemsuf_check.no_ldsuf))
5478         continue;
5479
5480       size_match = operand_size_match (t);
5481       if (!size_match)
5482         continue;
5483
5484       for (j = 0; j < MAX_OPERANDS; j++)
5485         operand_types[j] = t->operand_types[j];
5486
5487       /* In general, don't allow 64-bit operands in 32-bit mode.  */
5488       if (i.suffix == QWORD_MNEM_SUFFIX
5489           && flag_code != CODE_64BIT
5490           && (intel_syntax
5491               ? (!t->opcode_modifier.ignoresize
5492                  && !t->opcode_modifier.broadcast
5493                  && !intel_float_operand (t->name))
5494               : intel_float_operand (t->name) != 2)
5495           && ((!operand_types[0].bitfield.regmmx
5496                && !operand_types[0].bitfield.regsimd)
5497               || (!operand_types[t->operands > 1].bitfield.regmmx
5498                   && !operand_types[t->operands > 1].bitfield.regsimd))
5499           && (t->base_opcode != 0x0fc7
5500               || t->extension_opcode != 1 /* cmpxchg8b */))
5501         continue;
5502
5503       /* In general, don't allow 32-bit operands on pre-386.  */
5504       else if (i.suffix == LONG_MNEM_SUFFIX
5505                && !cpu_arch_flags.bitfield.cpui386
5506                && (intel_syntax
5507                    ? (!t->opcode_modifier.ignoresize
5508                       && !intel_float_operand (t->name))
5509                    : intel_float_operand (t->name) != 2)
5510                && ((!operand_types[0].bitfield.regmmx
5511                     && !operand_types[0].bitfield.regsimd)
5512                    || (!operand_types[t->operands > 1].bitfield.regmmx
5513                        && !operand_types[t->operands > 1].bitfield.regsimd)))
5514         continue;
5515
5516       /* Do not verify operands when there are none.  */
5517       else
5518         {
5519           if (!t->operands)
5520             /* We've found a match; break out of loop.  */
5521             break;
5522         }
5523
5524       /* Address size prefix will turn Disp64/Disp32/Disp16 operand
5525          into Disp32/Disp16/Disp32 operand.  */
5526       if (i.prefix[ADDR_PREFIX] != 0)
5527           {
5528             /* There should be only one Disp operand.  */
5529             switch (flag_code)
5530             {
5531             case CODE_16BIT:
5532               for (j = 0; j < MAX_OPERANDS; j++)
5533                 {
5534                   if (operand_types[j].bitfield.disp16)
5535                     {
5536                       addr_prefix_disp = j;
5537                       operand_types[j].bitfield.disp32 = 1;
5538                       operand_types[j].bitfield.disp16 = 0;
5539                       break;
5540                     }
5541                 }
5542               break;
5543             case CODE_32BIT:
5544               for (j = 0; j < MAX_OPERANDS; j++)
5545                 {
5546                   if (operand_types[j].bitfield.disp32)
5547                     {
5548                       addr_prefix_disp = j;
5549                       operand_types[j].bitfield.disp32 = 0;
5550                       operand_types[j].bitfield.disp16 = 1;
5551                       break;
5552                     }
5553                 }
5554               break;
5555             case CODE_64BIT:
5556               for (j = 0; j < MAX_OPERANDS; j++)
5557                 {
5558                   if (operand_types[j].bitfield.disp64)
5559                     {
5560                       addr_prefix_disp = j;
5561                       operand_types[j].bitfield.disp64 = 0;
5562                       operand_types[j].bitfield.disp32 = 1;
5563                       break;
5564                     }
5565                 }
5566               break;
5567             }
5568           }
5569
5570       /* Force 0x8b encoding for "mov foo@GOT, %eax".  */
5571       if (i.reloc[0] == BFD_RELOC_386_GOT32 && t->base_opcode == 0xa0)
5572         continue;
5573
5574       /* We check register size if needed.  */
5575       if (t->opcode_modifier.checkregsize)
5576         {
5577           check_register = (1 << t->operands) - 1;
5578           if (i.broadcast)
5579             check_register &= ~(1 << i.broadcast->operand);
5580         }
5581       else
5582         check_register = 0;
5583
5584       overlap0 = operand_type_and (i.types[0], operand_types[0]);
5585       switch (t->operands)
5586         {
5587         case 1:
5588           if (!operand_type_match (overlap0, i.types[0]))
5589             continue;
5590           break;
5591         case 2:
5592           /* xchg %eax, %eax is a special case. It is an alias for nop
5593              only in 32bit mode and we can use opcode 0x90.  In 64bit
5594              mode, we can't use 0x90 for xchg %eax, %eax since it should
5595              zero-extend %eax to %rax.  */
5596           if (flag_code == CODE_64BIT
5597               && t->base_opcode == 0x90
5598               && operand_type_equal (&i.types [0], &acc32)
5599               && operand_type_equal (&i.types [1], &acc32))
5600             continue;
5601           /* xrelease mov %eax, <disp> is another special case. It must not
5602              match the accumulator-only encoding of mov.  */
5603           if (flag_code != CODE_64BIT
5604               && i.hle_prefix
5605               && t->base_opcode == 0xa0
5606               && i.types[0].bitfield.acc
5607               && operand_type_check (i.types[1], anymem))
5608             continue;
5609           if (!(size_match & MATCH_STRAIGHT))
5610             goto check_reverse;
5611           /* If we want store form, we reverse direction of operands.  */
5612           if (i.dir_encoding == dir_encoding_store
5613               && t->opcode_modifier.d)
5614             goto check_reverse;
5615           /* Fall through.  */
5616
5617         case 3:
5618           /* If we want store form, we skip the current load.  */
5619           if (i.dir_encoding == dir_encoding_store
5620               && i.mem_operands == 0
5621               && t->opcode_modifier.load)
5622             continue;
5623           /* Fall through.  */
5624         case 4:
5625         case 5:
5626           overlap1 = operand_type_and (i.types[1], operand_types[1]);
5627           if (!operand_type_match (overlap0, i.types[0])
5628               || !operand_type_match (overlap1, i.types[1])
5629               || ((check_register & 3) == 3
5630                   && !operand_type_register_match (i.types[0],
5631                                                    operand_types[0],
5632                                                    i.types[1],
5633                                                    operand_types[1])))
5634             {
5635               /* Check if other direction is valid ...  */
5636               if (!t->opcode_modifier.d)
5637                 continue;
5638
5639 check_reverse:
5640               if (!(size_match & MATCH_REVERSE))
5641                 continue;
5642               /* Try reversing direction of operands.  */
5643               overlap0 = operand_type_and (i.types[0], operand_types[1]);
5644               overlap1 = operand_type_and (i.types[1], operand_types[0]);
5645               if (!operand_type_match (overlap0, i.types[0])
5646                   || !operand_type_match (overlap1, i.types[1])
5647                   || (check_register
5648                       && !operand_type_register_match (i.types[0],
5649                                                        operand_types[1],
5650                                                        i.types[1],
5651                                                        operand_types[0])))
5652                 {
5653                   /* Does not match either direction.  */
5654                   continue;
5655                 }
5656               /* found_reverse_match holds which of D or FloatR
5657                  we've found.  */
5658               if (!t->opcode_modifier.d)
5659                 found_reverse_match = 0;
5660               else if (operand_types[0].bitfield.tbyte)
5661                 found_reverse_match = Opcode_FloatD;
5662               else
5663                 found_reverse_match = Opcode_D;
5664               if (t->opcode_modifier.floatr)
5665                 found_reverse_match |= Opcode_FloatR;
5666             }
5667           else
5668             {
5669               /* Found a forward 2 operand match here.  */
5670               switch (t->operands)
5671                 {
5672                 case 5:
5673                   overlap4 = operand_type_and (i.types[4],
5674                                                operand_types[4]);
5675                   /* Fall through.  */
5676                 case 4:
5677                   overlap3 = operand_type_and (i.types[3],
5678                                                operand_types[3]);
5679                   /* Fall through.  */
5680                 case 3:
5681                   overlap2 = operand_type_and (i.types[2],
5682                                                operand_types[2]);
5683                   break;
5684                 }
5685
5686               switch (t->operands)
5687                 {
5688                 case 5:
5689                   if (!operand_type_match (overlap4, i.types[4])
5690                       || !operand_type_register_match (i.types[3],
5691                                                        operand_types[3],
5692                                                        i.types[4],
5693                                                        operand_types[4]))
5694                     continue;
5695                   /* Fall through.  */
5696                 case 4:
5697                   if (!operand_type_match (overlap3, i.types[3])
5698                       || ((check_register & 0xa) == 0xa
5699                           && !operand_type_register_match (i.types[1],
5700                                                             operand_types[1],
5701                                                             i.types[3],
5702                                                             operand_types[3]))
5703                       || ((check_register & 0xc) == 0xc
5704                           && !operand_type_register_match (i.types[2],
5705                                                             operand_types[2],
5706                                                             i.types[3],
5707                                                             operand_types[3])))
5708                     continue;
5709                   /* Fall through.  */
5710                 case 3:
5711                   /* Here we make use of the fact that there are no
5712                      reverse match 3 operand instructions.  */
5713                   if (!operand_type_match (overlap2, i.types[2])
5714                       || ((check_register & 5) == 5
5715                           && !operand_type_register_match (i.types[0],
5716                                                             operand_types[0],
5717                                                             i.types[2],
5718                                                             operand_types[2]))
5719                       || ((check_register & 6) == 6
5720                           && !operand_type_register_match (i.types[1],
5721                                                             operand_types[1],
5722                                                             i.types[2],
5723                                                             operand_types[2])))
5724                     continue;
5725                   break;
5726                 }
5727             }
5728           /* Found either forward/reverse 2, 3 or 4 operand match here:
5729              slip through to break.  */
5730         }
5731       if (!found_cpu_match)
5732         {
5733           found_reverse_match = 0;
5734           continue;
5735         }
5736
5737       /* Check if vector and VEX operands are valid.  */
5738       if (check_VecOperands (t) || VEX_check_operands (t))
5739         {
5740           specific_error = i.error;
5741           continue;
5742         }
5743
5744       /* We've found a match; break out of loop.  */
5745       break;
5746     }
5747
5748   if (t == current_templates->end)
5749     {
5750       /* We found no match.  */
5751       const char *err_msg;
5752       switch (specific_error ? specific_error : i.error)
5753         {
5754         default:
5755           abort ();
5756         case operand_size_mismatch:
5757           err_msg = _("operand size mismatch");
5758           break;
5759         case operand_type_mismatch:
5760           err_msg = _("operand type mismatch");
5761           break;
5762         case register_type_mismatch:
5763           err_msg = _("register type mismatch");
5764           break;
5765         case number_of_operands_mismatch:
5766           err_msg = _("number of operands mismatch");
5767           break;
5768         case invalid_instruction_suffix:
5769           err_msg = _("invalid instruction suffix");
5770           break;
5771         case bad_imm4:
5772           err_msg = _("constant doesn't fit in 4 bits");
5773           break;
5774         case unsupported_with_intel_mnemonic:
5775           err_msg = _("unsupported with Intel mnemonic");
5776           break;
5777         case unsupported_syntax:
5778           err_msg = _("unsupported syntax");
5779           break;
5780         case unsupported:
5781           as_bad (_("unsupported instruction `%s'"),
5782                   current_templates->start->name);
5783           return NULL;
5784         case invalid_vsib_address:
5785           err_msg = _("invalid VSIB address");
5786           break;
5787         case invalid_vector_register_set:
5788           err_msg = _("mask, index, and destination registers must be distinct");
5789           break;
5790         case unsupported_vector_index_register:
5791           err_msg = _("unsupported vector index register");
5792           break;
5793         case unsupported_broadcast:
5794           err_msg = _("unsupported broadcast");
5795           break;
5796         case broadcast_needed:
5797           err_msg = _("broadcast is needed for operand of such type");
5798           break;
5799         case unsupported_masking:
5800           err_msg = _("unsupported masking");
5801           break;
5802         case mask_not_on_destination:
5803           err_msg = _("mask not on destination operand");
5804           break;
5805         case no_default_mask:
5806           err_msg = _("default mask isn't allowed");
5807           break;
5808         case unsupported_rc_sae:
5809           err_msg = _("unsupported static rounding/sae");
5810           break;
5811         case rc_sae_operand_not_last_imm:
5812           if (intel_syntax)
5813             err_msg = _("RC/SAE operand must precede immediate operands");
5814           else
5815             err_msg = _("RC/SAE operand must follow immediate operands");
5816           break;
5817         case invalid_register_operand:
5818           err_msg = _("invalid register operand");
5819           break;
5820         }
5821       as_bad (_("%s for `%s'"), err_msg,
5822               current_templates->start->name);
5823       return NULL;
5824     }
5825
5826   if (!quiet_warnings)
5827     {
5828       if (!intel_syntax
5829           && (i.types[0].bitfield.jumpabsolute
5830               != operand_types[0].bitfield.jumpabsolute))
5831         {
5832           as_warn (_("indirect %s without `*'"), t->name);
5833         }
5834
5835       if (t->opcode_modifier.isprefix
5836           && t->opcode_modifier.ignoresize)
5837         {
5838           /* Warn them that a data or address size prefix doesn't
5839              affect assembly of the next line of code.  */
5840           as_warn (_("stand-alone `%s' prefix"), t->name);
5841         }
5842     }
5843
5844   /* Copy the template we found.  */
5845   i.tm = *t;
5846
5847   if (addr_prefix_disp != -1)
5848     i.tm.operand_types[addr_prefix_disp]
5849       = operand_types[addr_prefix_disp];
5850
5851   if (found_reverse_match)
5852     {
5853       /* If we found a reverse match we must alter the opcode
5854          direction bit.  found_reverse_match holds bits to change
5855          (different for int & float insns).  */
5856
5857       i.tm.base_opcode ^= found_reverse_match;
5858
5859       i.tm.operand_types[0] = operand_types[1];
5860       i.tm.operand_types[1] = operand_types[0];
5861     }
5862
5863   return t;
5864 }
5865
5866 static int
5867 check_string (void)
5868 {
5869   int mem_op = operand_type_check (i.types[0], anymem) ? 0 : 1;
5870   if (i.tm.operand_types[mem_op].bitfield.esseg)
5871     {
5872       if (i.seg[0] != NULL && i.seg[0] != &es)
5873         {
5874           as_bad (_("`%s' operand %d must use `%ses' segment"),
5875                   i.tm.name,
5876                   mem_op + 1,
5877                   register_prefix);
5878           return 0;
5879         }
5880       /* There's only ever one segment override allowed per instruction.
5881          This instruction possibly has a legal segment override on the
5882          second operand, so copy the segment to where non-string
5883          instructions store it, allowing common code.  */
5884       i.seg[0] = i.seg[1];
5885     }
5886   else if (i.tm.operand_types[mem_op + 1].bitfield.esseg)
5887     {
5888       if (i.seg[1] != NULL && i.seg[1] != &es)
5889         {
5890           as_bad (_("`%s' operand %d must use `%ses' segment"),
5891                   i.tm.name,
5892                   mem_op + 2,
5893                   register_prefix);
5894           return 0;
5895         }
5896     }
5897   return 1;
5898 }
5899
5900 static int
5901 process_suffix (void)
5902 {
5903   /* If matched instruction specifies an explicit instruction mnemonic
5904      suffix, use it.  */
5905   if (i.tm.opcode_modifier.size16)
5906     i.suffix = WORD_MNEM_SUFFIX;
5907   else if (i.tm.opcode_modifier.size32)
5908     i.suffix = LONG_MNEM_SUFFIX;
5909   else if (i.tm.opcode_modifier.size64)
5910     i.suffix = QWORD_MNEM_SUFFIX;
5911   else if (i.reg_operands)
5912     {
5913       /* If there's no instruction mnemonic suffix we try to invent one
5914          based on register operands.  */
5915       if (!i.suffix)
5916         {
5917           /* We take i.suffix from the last register operand specified,
5918              Destination register type is more significant than source
5919              register type.  crc32 in SSE4.2 prefers source register
5920              type. */
5921           if (i.tm.base_opcode == 0xf20f38f1)
5922             {
5923               if (i.types[0].bitfield.reg && i.types[0].bitfield.word)
5924                 i.suffix = WORD_MNEM_SUFFIX;
5925               else if (i.types[0].bitfield.reg && i.types[0].bitfield.dword)
5926                 i.suffix = LONG_MNEM_SUFFIX;
5927               else if (i.types[0].bitfield.reg && i.types[0].bitfield.qword)
5928                 i.suffix = QWORD_MNEM_SUFFIX;
5929             }
5930           else if (i.tm.base_opcode == 0xf20f38f0)
5931             {
5932               if (i.types[0].bitfield.reg && i.types[0].bitfield.byte)
5933                 i.suffix = BYTE_MNEM_SUFFIX;
5934             }
5935
5936           if (!i.suffix)
5937             {
5938               int op;
5939
5940               if (i.tm.base_opcode == 0xf20f38f1
5941                   || i.tm.base_opcode == 0xf20f38f0)
5942                 {
5943                   /* We have to know the operand size for crc32.  */
5944                   as_bad (_("ambiguous memory operand size for `%s`"),
5945                           i.tm.name);
5946                   return 0;
5947                 }
5948
5949               for (op = i.operands; --op >= 0;)
5950                 if (!i.tm.operand_types[op].bitfield.inoutportreg
5951                     && !i.tm.operand_types[op].bitfield.shiftcount)
5952                   {
5953                     if (!i.types[op].bitfield.reg)
5954                       continue;
5955                     if (i.types[op].bitfield.byte)
5956                       i.suffix = BYTE_MNEM_SUFFIX;
5957                     else if (i.types[op].bitfield.word)
5958                       i.suffix = WORD_MNEM_SUFFIX;
5959                     else if (i.types[op].bitfield.dword)
5960                       i.suffix = LONG_MNEM_SUFFIX;
5961                     else if (i.types[op].bitfield.qword)
5962                       i.suffix = QWORD_MNEM_SUFFIX;
5963                     else
5964                       continue;
5965                     break;
5966                   }
5967             }
5968         }
5969       else if (i.suffix == BYTE_MNEM_SUFFIX)
5970         {
5971           if (intel_syntax
5972               && i.tm.opcode_modifier.ignoresize
5973               && i.tm.opcode_modifier.no_bsuf)
5974             i.suffix = 0;
5975           else if (!check_byte_reg ())
5976             return 0;
5977         }
5978       else if (i.suffix == LONG_MNEM_SUFFIX)
5979         {
5980           if (intel_syntax
5981               && i.tm.opcode_modifier.ignoresize
5982               && i.tm.opcode_modifier.no_lsuf
5983               && !i.tm.opcode_modifier.todword
5984               && !i.tm.opcode_modifier.toqword)
5985             i.suffix = 0;
5986           else if (!check_long_reg ())
5987             return 0;
5988         }
5989       else if (i.suffix == QWORD_MNEM_SUFFIX)
5990         {
5991           if (intel_syntax
5992               && i.tm.opcode_modifier.ignoresize
5993               && i.tm.opcode_modifier.no_qsuf
5994               && !i.tm.opcode_modifier.todword
5995               && !i.tm.opcode_modifier.toqword)
5996             i.suffix = 0;
5997           else if (!check_qword_reg ())
5998             return 0;
5999         }
6000       else if (i.suffix == WORD_MNEM_SUFFIX)
6001         {
6002           if (intel_syntax
6003               && i.tm.opcode_modifier.ignoresize
6004               && i.tm.opcode_modifier.no_wsuf)
6005             i.suffix = 0;
6006           else if (!check_word_reg ())
6007             return 0;
6008         }
6009       else if (intel_syntax && i.tm.opcode_modifier.ignoresize)
6010         /* Do nothing if the instruction is going to ignore the prefix.  */
6011         ;
6012       else
6013         abort ();
6014     }
6015   else if (i.tm.opcode_modifier.defaultsize
6016            && !i.suffix
6017            /* exclude fldenv/frstor/fsave/fstenv */
6018            && i.tm.opcode_modifier.no_ssuf)
6019     {
6020       i.suffix = stackop_size;
6021     }
6022   else if (intel_syntax
6023            && !i.suffix
6024            && (i.tm.operand_types[0].bitfield.jumpabsolute
6025                || i.tm.opcode_modifier.jumpbyte
6026                || i.tm.opcode_modifier.jumpintersegment
6027                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
6028                    && i.tm.extension_opcode <= 3)))
6029     {
6030       switch (flag_code)
6031         {
6032         case CODE_64BIT:
6033           if (!i.tm.opcode_modifier.no_qsuf)
6034             {
6035               i.suffix = QWORD_MNEM_SUFFIX;
6036               break;
6037             }
6038           /* Fall through.  */
6039         case CODE_32BIT:
6040           if (!i.tm.opcode_modifier.no_lsuf)
6041             i.suffix = LONG_MNEM_SUFFIX;
6042           break;
6043         case CODE_16BIT:
6044           if (!i.tm.opcode_modifier.no_wsuf)
6045             i.suffix = WORD_MNEM_SUFFIX;
6046           break;
6047         }
6048     }
6049
6050   if (!i.suffix)
6051     {
6052       if (!intel_syntax)
6053         {
6054           if (i.tm.opcode_modifier.w)
6055             {
6056               as_bad (_("no instruction mnemonic suffix given and "
6057                         "no register operands; can't size instruction"));
6058               return 0;
6059             }
6060         }
6061       else
6062         {
6063           unsigned int suffixes;
6064
6065           suffixes = !i.tm.opcode_modifier.no_bsuf;
6066           if (!i.tm.opcode_modifier.no_wsuf)
6067             suffixes |= 1 << 1;
6068           if (!i.tm.opcode_modifier.no_lsuf)
6069             suffixes |= 1 << 2;
6070           if (!i.tm.opcode_modifier.no_ldsuf)
6071             suffixes |= 1 << 3;
6072           if (!i.tm.opcode_modifier.no_ssuf)
6073             suffixes |= 1 << 4;
6074           if (flag_code == CODE_64BIT && !i.tm.opcode_modifier.no_qsuf)
6075             suffixes |= 1 << 5;
6076
6077           /* There are more than suffix matches.  */
6078           if (i.tm.opcode_modifier.w
6079               || ((suffixes & (suffixes - 1))
6080                   && !i.tm.opcode_modifier.defaultsize
6081                   && !i.tm.opcode_modifier.ignoresize))
6082             {
6083               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
6084               return 0;
6085             }
6086         }
6087     }
6088
6089   /* Change the opcode based on the operand size given by i.suffix.  */
6090   switch (i.suffix)
6091     {
6092     /* Size floating point instruction.  */
6093     case LONG_MNEM_SUFFIX:
6094       if (i.tm.opcode_modifier.floatmf)
6095         {
6096           i.tm.base_opcode ^= 4;
6097           break;
6098         }
6099     /* fall through */
6100     case WORD_MNEM_SUFFIX:
6101     case QWORD_MNEM_SUFFIX:
6102       /* It's not a byte, select word/dword operation.  */
6103       if (i.tm.opcode_modifier.w)
6104         {
6105           if (i.tm.opcode_modifier.shortform)
6106             i.tm.base_opcode |= 8;
6107           else
6108             i.tm.base_opcode |= 1;
6109         }
6110     /* fall through */
6111     case SHORT_MNEM_SUFFIX:
6112       /* Now select between word & dword operations via the operand
6113          size prefix, except for instructions that will ignore this
6114          prefix anyway.  */
6115       if (i.reg_operands > 0
6116           && i.types[0].bitfield.reg
6117           && i.tm.opcode_modifier.addrprefixopreg
6118           && (i.tm.opcode_modifier.immext
6119               || i.operands == 1))
6120         {
6121           /* The address size override prefix changes the size of the
6122              first operand.  */
6123           if ((flag_code == CODE_32BIT
6124                && i.op[0].regs->reg_type.bitfield.word)
6125               || (flag_code != CODE_32BIT
6126                   && i.op[0].regs->reg_type.bitfield.dword))
6127             if (!add_prefix (ADDR_PREFIX_OPCODE))
6128               return 0;
6129         }
6130       else if (i.suffix != QWORD_MNEM_SUFFIX
6131                && !i.tm.opcode_modifier.ignoresize
6132                && !i.tm.opcode_modifier.floatmf
6133                && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
6134                    || (flag_code == CODE_64BIT
6135                        && i.tm.opcode_modifier.jumpbyte)))
6136         {
6137           unsigned int prefix = DATA_PREFIX_OPCODE;
6138
6139           if (i.tm.opcode_modifier.jumpbyte) /* jcxz, loop */
6140             prefix = ADDR_PREFIX_OPCODE;
6141
6142           if (!add_prefix (prefix))
6143             return 0;
6144         }
6145
6146       /* Set mode64 for an operand.  */
6147       if (i.suffix == QWORD_MNEM_SUFFIX
6148           && flag_code == CODE_64BIT
6149           && !i.tm.opcode_modifier.norex64
6150           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
6151              need rex64. */
6152           && ! (i.operands == 2
6153                 && i.tm.base_opcode == 0x90
6154                 && i.tm.extension_opcode == None
6155                 && operand_type_equal (&i.types [0], &acc64)
6156                 && operand_type_equal (&i.types [1], &acc64)))
6157         i.rex |= REX_W;
6158
6159       break;
6160     }
6161
6162   if (i.reg_operands != 0
6163       && i.operands > 1
6164       && i.tm.opcode_modifier.addrprefixopreg
6165       && !i.tm.opcode_modifier.immext)
6166     {
6167       /* Check invalid register operand when the address size override
6168          prefix changes the size of register operands.  */
6169       unsigned int op;
6170       enum { need_word, need_dword, need_qword } need;
6171
6172       if (flag_code == CODE_32BIT)
6173         need = i.prefix[ADDR_PREFIX] ? need_word : need_dword;
6174       else
6175         {
6176           if (i.prefix[ADDR_PREFIX])
6177             need = need_dword;
6178           else
6179             need = flag_code == CODE_64BIT ? need_qword : need_word;
6180         }
6181
6182       for (op = 0; op < i.operands; op++)
6183         if (i.types[op].bitfield.reg
6184             && ((need == need_word
6185                  && !i.op[op].regs->reg_type.bitfield.word)
6186                 || (need == need_dword
6187                     && !i.op[op].regs->reg_type.bitfield.dword)
6188                 || (need == need_qword
6189                     && !i.op[op].regs->reg_type.bitfield.qword)))
6190           {
6191             as_bad (_("invalid register operand size for `%s'"),
6192                     i.tm.name);
6193             return 0;
6194           }
6195     }
6196
6197   return 1;
6198 }
6199
6200 static int
6201 check_byte_reg (void)
6202 {
6203   int op;
6204
6205   for (op = i.operands; --op >= 0;)
6206     {
6207       /* Skip non-register operands. */
6208       if (!i.types[op].bitfield.reg)
6209         continue;
6210
6211       /* If this is an eight bit register, it's OK.  If it's the 16 or
6212          32 bit version of an eight bit register, we will just use the
6213          low portion, and that's OK too.  */
6214       if (i.types[op].bitfield.byte)
6215         continue;
6216
6217       /* I/O port address operands are OK too.  */
6218       if (i.tm.operand_types[op].bitfield.inoutportreg)
6219         continue;
6220
6221       /* crc32 doesn't generate this warning.  */
6222       if (i.tm.base_opcode == 0xf20f38f0)
6223         continue;
6224
6225       if ((i.types[op].bitfield.word
6226            || i.types[op].bitfield.dword
6227            || i.types[op].bitfield.qword)
6228           && i.op[op].regs->reg_num < 4
6229           /* Prohibit these changes in 64bit mode, since the lowering
6230              would be more complicated.  */
6231           && flag_code != CODE_64BIT)
6232         {
6233 #if REGISTER_WARNINGS
6234           if (!quiet_warnings)
6235             as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6236                      register_prefix,
6237                      (i.op[op].regs + (i.types[op].bitfield.word
6238                                        ? REGNAM_AL - REGNAM_AX
6239                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
6240                      register_prefix,
6241                      i.op[op].regs->reg_name,
6242                      i.suffix);
6243 #endif
6244           continue;
6245         }
6246       /* Any other register is bad.  */
6247       if (i.types[op].bitfield.reg
6248           || i.types[op].bitfield.regmmx
6249           || i.types[op].bitfield.regsimd
6250           || i.types[op].bitfield.sreg2
6251           || i.types[op].bitfield.sreg3
6252           || i.types[op].bitfield.control
6253           || i.types[op].bitfield.debug
6254           || i.types[op].bitfield.test)
6255         {
6256           as_bad (_("`%s%s' not allowed with `%s%c'"),
6257                   register_prefix,
6258                   i.op[op].regs->reg_name,
6259                   i.tm.name,
6260                   i.suffix);
6261           return 0;
6262         }
6263     }
6264   return 1;
6265 }
6266
6267 static int
6268 check_long_reg (void)
6269 {
6270   int op;
6271
6272   for (op = i.operands; --op >= 0;)
6273     /* Skip non-register operands. */
6274     if (!i.types[op].bitfield.reg)
6275       continue;
6276     /* Reject eight bit registers, except where the template requires
6277        them. (eg. movzb)  */
6278     else if (i.types[op].bitfield.byte
6279              && (i.tm.operand_types[op].bitfield.reg
6280                  || i.tm.operand_types[op].bitfield.acc)
6281              && (i.tm.operand_types[op].bitfield.word
6282                  || i.tm.operand_types[op].bitfield.dword))
6283       {
6284         as_bad (_("`%s%s' not allowed with `%s%c'"),
6285                 register_prefix,
6286                 i.op[op].regs->reg_name,
6287                 i.tm.name,
6288                 i.suffix);
6289         return 0;
6290       }
6291     /* Warn if the e prefix on a general reg is missing.  */
6292     else if ((!quiet_warnings || flag_code == CODE_64BIT)
6293              && i.types[op].bitfield.word
6294              && (i.tm.operand_types[op].bitfield.reg
6295                  || i.tm.operand_types[op].bitfield.acc)
6296              && i.tm.operand_types[op].bitfield.dword)
6297       {
6298         /* Prohibit these changes in the 64bit mode, since the
6299            lowering is more complicated.  */
6300         if (flag_code == CODE_64BIT)
6301           {
6302             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6303                     register_prefix, i.op[op].regs->reg_name,
6304                     i.suffix);
6305             return 0;
6306           }
6307 #if REGISTER_WARNINGS
6308         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6309                  register_prefix,
6310                  (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
6311                  register_prefix, i.op[op].regs->reg_name, i.suffix);
6312 #endif
6313       }
6314     /* Warn if the r prefix on a general reg is present.  */
6315     else if (i.types[op].bitfield.qword
6316              && (i.tm.operand_types[op].bitfield.reg
6317                  || i.tm.operand_types[op].bitfield.acc)
6318              && i.tm.operand_types[op].bitfield.dword)
6319       {
6320         if (intel_syntax
6321             && i.tm.opcode_modifier.toqword
6322             && !i.types[0].bitfield.regsimd)
6323           {
6324             /* Convert to QWORD.  We want REX byte. */
6325             i.suffix = QWORD_MNEM_SUFFIX;
6326           }
6327         else
6328           {
6329             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6330                     register_prefix, i.op[op].regs->reg_name,
6331                     i.suffix);
6332             return 0;
6333           }
6334       }
6335   return 1;
6336 }
6337
6338 static int
6339 check_qword_reg (void)
6340 {
6341   int op;
6342
6343   for (op = i.operands; --op >= 0; )
6344     /* Skip non-register operands. */
6345     if (!i.types[op].bitfield.reg)
6346       continue;
6347     /* Reject eight bit registers, except where the template requires
6348        them. (eg. movzb)  */
6349     else if (i.types[op].bitfield.byte
6350              && (i.tm.operand_types[op].bitfield.reg
6351                  || i.tm.operand_types[op].bitfield.acc)
6352              && (i.tm.operand_types[op].bitfield.word
6353                  || i.tm.operand_types[op].bitfield.dword))
6354       {
6355         as_bad (_("`%s%s' not allowed with `%s%c'"),
6356                 register_prefix,
6357                 i.op[op].regs->reg_name,
6358                 i.tm.name,
6359                 i.suffix);
6360         return 0;
6361       }
6362     /* Warn if the r prefix on a general reg is missing.  */
6363     else if ((i.types[op].bitfield.word
6364               || i.types[op].bitfield.dword)
6365              && (i.tm.operand_types[op].bitfield.reg
6366                  || i.tm.operand_types[op].bitfield.acc)
6367              && i.tm.operand_types[op].bitfield.qword)
6368       {
6369         /* Prohibit these changes in the 64bit mode, since the
6370            lowering is more complicated.  */
6371         if (intel_syntax
6372             && i.tm.opcode_modifier.todword
6373             && !i.types[0].bitfield.regsimd)
6374           {
6375             /* Convert to DWORD.  We don't want REX byte. */
6376             i.suffix = LONG_MNEM_SUFFIX;
6377           }
6378         else
6379           {
6380             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6381                     register_prefix, i.op[op].regs->reg_name,
6382                     i.suffix);
6383             return 0;
6384           }
6385       }
6386   return 1;
6387 }
6388
6389 static int
6390 check_word_reg (void)
6391 {
6392   int op;
6393   for (op = i.operands; --op >= 0;)
6394     /* Skip non-register operands. */
6395     if (!i.types[op].bitfield.reg)
6396       continue;
6397     /* Reject eight bit registers, except where the template requires
6398        them. (eg. movzb)  */
6399     else if (i.types[op].bitfield.byte
6400              && (i.tm.operand_types[op].bitfield.reg
6401                  || i.tm.operand_types[op].bitfield.acc)
6402              && (i.tm.operand_types[op].bitfield.word
6403                  || i.tm.operand_types[op].bitfield.dword))
6404       {
6405         as_bad (_("`%s%s' not allowed with `%s%c'"),
6406                 register_prefix,
6407                 i.op[op].regs->reg_name,
6408                 i.tm.name,
6409                 i.suffix);
6410         return 0;
6411       }
6412     /* Warn if the e or r prefix on a general reg is present.  */
6413     else if ((!quiet_warnings || flag_code == CODE_64BIT)
6414              && (i.types[op].bitfield.dword
6415                  || i.types[op].bitfield.qword)
6416              && (i.tm.operand_types[op].bitfield.reg
6417                  || i.tm.operand_types[op].bitfield.acc)
6418              && i.tm.operand_types[op].bitfield.word)
6419       {
6420         /* Prohibit these changes in the 64bit mode, since the
6421            lowering is more complicated.  */
6422         if (flag_code == CODE_64BIT)
6423           {
6424             as_bad (_("incorrect register `%s%s' used with `%c' suffix"),
6425                     register_prefix, i.op[op].regs->reg_name,
6426                     i.suffix);
6427             return 0;
6428           }
6429 #if REGISTER_WARNINGS
6430         as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
6431                  register_prefix,
6432                  (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
6433                  register_prefix, i.op[op].regs->reg_name, i.suffix);
6434 #endif
6435       }
6436   return 1;
6437 }
6438
6439 static int
6440 update_imm (unsigned int j)
6441 {
6442   i386_operand_type overlap = i.types[j];
6443   if ((overlap.bitfield.imm8
6444        || overlap.bitfield.imm8s
6445        || overlap.bitfield.imm16
6446        || overlap.bitfield.imm32
6447        || overlap.bitfield.imm32s
6448        || overlap.bitfield.imm64)
6449       && !operand_type_equal (&overlap, &imm8)
6450       && !operand_type_equal (&overlap, &imm8s)
6451       && !operand_type_equal (&overlap, &imm16)
6452       && !operand_type_equal (&overlap, &imm32)
6453       && !operand_type_equal (&overlap, &imm32s)
6454       && !operand_type_equal (&overlap, &imm64))
6455     {
6456       if (i.suffix)
6457         {
6458           i386_operand_type temp;
6459
6460           operand_type_set (&temp, 0);
6461           if (i.suffix == BYTE_MNEM_SUFFIX)
6462             {
6463               temp.bitfield.imm8 = overlap.bitfield.imm8;
6464               temp.bitfield.imm8s = overlap.bitfield.imm8s;
6465             }
6466           else if (i.suffix == WORD_MNEM_SUFFIX)
6467             temp.bitfield.imm16 = overlap.bitfield.imm16;
6468           else if (i.suffix == QWORD_MNEM_SUFFIX)
6469             {
6470               temp.bitfield.imm64 = overlap.bitfield.imm64;
6471               temp.bitfield.imm32s = overlap.bitfield.imm32s;
6472             }
6473           else
6474             temp.bitfield.imm32 = overlap.bitfield.imm32;
6475           overlap = temp;
6476         }
6477       else if (operand_type_equal (&overlap, &imm16_32_32s)
6478                || operand_type_equal (&overlap, &imm16_32)
6479                || operand_type_equal (&overlap, &imm16_32s))
6480         {
6481           if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
6482             overlap = imm16;
6483           else
6484             overlap = imm32s;
6485         }
6486       if (!operand_type_equal (&overlap, &imm8)
6487           && !operand_type_equal (&overlap, &imm8s)
6488           && !operand_type_equal (&overlap, &imm16)
6489           && !operand_type_equal (&overlap, &imm32)
6490           && !operand_type_equal (&overlap, &imm32s)
6491           && !operand_type_equal (&overlap, &imm64))
6492         {
6493           as_bad (_("no instruction mnemonic suffix given; "
6494                     "can't determine immediate size"));
6495           return 0;
6496         }
6497     }
6498   i.types[j] = overlap;
6499
6500   return 1;
6501 }
6502
6503 static int
6504 finalize_imm (void)
6505 {
6506   unsigned int j, n;
6507
6508   /* Update the first 2 immediate operands.  */
6509   n = i.operands > 2 ? 2 : i.operands;
6510   if (n)
6511     {
6512       for (j = 0; j < n; j++)
6513         if (update_imm (j) == 0)
6514           return 0;
6515
6516       /* The 3rd operand can't be immediate operand.  */
6517       gas_assert (operand_type_check (i.types[2], imm) == 0);
6518     }
6519
6520   return 1;
6521 }
6522
6523 static int
6524 process_operands (void)
6525 {
6526   /* Default segment register this instruction will use for memory
6527      accesses.  0 means unknown.  This is only for optimizing out
6528      unnecessary segment overrides.  */
6529   const seg_entry *default_seg = 0;
6530
6531   if (i.tm.opcode_modifier.sse2avx && i.tm.opcode_modifier.vexvvvv)
6532     {
6533       unsigned int dupl = i.operands;
6534       unsigned int dest = dupl - 1;
6535       unsigned int j;
6536
6537       /* The destination must be an xmm register.  */
6538       gas_assert (i.reg_operands
6539                   && MAX_OPERANDS > dupl
6540                   && operand_type_equal (&i.types[dest], &regxmm));
6541
6542       if (i.tm.operand_types[0].bitfield.acc
6543           && i.tm.operand_types[0].bitfield.xmmword)
6544         {
6545           if (i.tm.opcode_modifier.vexsources == VEX3SOURCES)
6546             {
6547               /* Keep xmm0 for instructions with VEX prefix and 3
6548                  sources.  */
6549               i.tm.operand_types[0].bitfield.acc = 0;
6550               i.tm.operand_types[0].bitfield.regsimd = 1;
6551               goto duplicate;
6552             }
6553           else
6554             {
6555               /* We remove the first xmm0 and keep the number of
6556                  operands unchanged, which in fact duplicates the
6557                  destination.  */
6558               for (j = 1; j < i.operands; j++)
6559                 {
6560                   i.op[j - 1] = i.op[j];
6561                   i.types[j - 1] = i.types[j];
6562                   i.tm.operand_types[j - 1] = i.tm.operand_types[j];
6563                 }
6564             }
6565         }
6566       else if (i.tm.opcode_modifier.implicit1stxmm0)
6567         {
6568           gas_assert ((MAX_OPERANDS - 1) > dupl
6569                       && (i.tm.opcode_modifier.vexsources
6570                           == VEX3SOURCES));
6571
6572           /* Add the implicit xmm0 for instructions with VEX prefix
6573              and 3 sources.  */
6574           for (j = i.operands; j > 0; j--)
6575             {
6576               i.op[j] = i.op[j - 1];
6577               i.types[j] = i.types[j - 1];
6578               i.tm.operand_types[j] = i.tm.operand_types[j - 1];
6579             }
6580           i.op[0].regs
6581             = (const reg_entry *) hash_find (reg_hash, "xmm0");
6582           i.types[0] = regxmm;
6583           i.tm.operand_types[0] = regxmm;
6584
6585           i.operands += 2;
6586           i.reg_operands += 2;
6587           i.tm.operands += 2;
6588
6589           dupl++;
6590           dest++;
6591           i.op[dupl] = i.op[dest];
6592           i.types[dupl] = i.types[dest];
6593           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6594         }
6595       else
6596         {
6597 duplicate:
6598           i.operands++;
6599           i.reg_operands++;
6600           i.tm.operands++;
6601
6602           i.op[dupl] = i.op[dest];
6603           i.types[dupl] = i.types[dest];
6604           i.tm.operand_types[dupl] = i.tm.operand_types[dest];
6605         }
6606
6607        if (i.tm.opcode_modifier.immext)
6608          process_immext ();
6609     }
6610   else if (i.tm.operand_types[0].bitfield.acc
6611            && i.tm.operand_types[0].bitfield.xmmword)
6612     {
6613       unsigned int j;
6614
6615       for (j = 1; j < i.operands; j++)
6616         {
6617           i.op[j - 1] = i.op[j];
6618           i.types[j - 1] = i.types[j];
6619
6620           /* We need to adjust fields in i.tm since they are used by
6621              build_modrm_byte.  */
6622           i.tm.operand_types [j - 1] = i.tm.operand_types [j];
6623         }
6624
6625       i.operands--;
6626       i.reg_operands--;
6627       i.tm.operands--;
6628     }
6629   else if (i.tm.opcode_modifier.implicitquadgroup)
6630     {
6631       unsigned int regnum, first_reg_in_group, last_reg_in_group;
6632
6633       /* The second operand must be {x,y,z}mmN, where N is a multiple of 4. */
6634       gas_assert (i.operands >= 2 && i.types[1].bitfield.regsimd);
6635       regnum = register_number (i.op[1].regs);
6636       first_reg_in_group = regnum & ~3;
6637       last_reg_in_group = first_reg_in_group + 3;
6638       if (regnum != first_reg_in_group)
6639         as_warn (_("source register `%s%s' implicitly denotes"
6640                    " `%s%.3s%u' to `%s%.3s%u' source group in `%s'"),
6641                  register_prefix, i.op[1].regs->reg_name,
6642                  register_prefix, i.op[1].regs->reg_name, first_reg_in_group,
6643                  register_prefix, i.op[1].regs->reg_name, last_reg_in_group,
6644                  i.tm.name);
6645     }
6646   else if (i.tm.opcode_modifier.regkludge)
6647     {
6648       /* The imul $imm, %reg instruction is converted into
6649          imul $imm, %reg, %reg, and the clr %reg instruction
6650          is converted into xor %reg, %reg.  */
6651
6652       unsigned int first_reg_op;
6653
6654       if (operand_type_check (i.types[0], reg))
6655         first_reg_op = 0;
6656       else
6657         first_reg_op = 1;
6658       /* Pretend we saw the extra register operand.  */
6659       gas_assert (i.reg_operands == 1
6660                   && i.op[first_reg_op + 1].regs == 0);
6661       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
6662       i.types[first_reg_op + 1] = i.types[first_reg_op];
6663       i.operands++;
6664       i.reg_operands++;
6665     }
6666
6667   if (i.tm.opcode_modifier.shortform)
6668     {
6669       if (i.types[0].bitfield.sreg2
6670           || i.types[0].bitfield.sreg3)
6671         {
6672           if (i.tm.base_opcode == POP_SEG_SHORT
6673               && i.op[0].regs->reg_num == 1)
6674             {
6675               as_bad (_("you can't `pop %scs'"), register_prefix);
6676               return 0;
6677             }
6678           i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
6679           if ((i.op[0].regs->reg_flags & RegRex) != 0)
6680             i.rex |= REX_B;
6681         }
6682       else
6683         {
6684           /* The register or float register operand is in operand
6685              0 or 1.  */
6686           unsigned int op;
6687
6688           if ((i.types[0].bitfield.reg && i.types[0].bitfield.tbyte)
6689               || operand_type_check (i.types[0], reg))
6690             op = 0;
6691           else
6692             op = 1;
6693           /* Register goes in low 3 bits of opcode.  */
6694           i.tm.base_opcode |= i.op[op].regs->reg_num;
6695           if ((i.op[op].regs->reg_flags & RegRex) != 0)
6696             i.rex |= REX_B;
6697           if (!quiet_warnings && i.tm.opcode_modifier.ugh)
6698             {
6699               /* Warn about some common errors, but press on regardless.
6700                  The first case can be generated by gcc (<= 2.8.1).  */
6701               if (i.operands == 2)
6702                 {
6703                   /* Reversed arguments on faddp, fsubp, etc.  */
6704                   as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
6705                            register_prefix, i.op[!intel_syntax].regs->reg_name,
6706                            register_prefix, i.op[intel_syntax].regs->reg_name);
6707                 }
6708               else
6709                 {
6710                   /* Extraneous `l' suffix on fp insn.  */
6711                   as_warn (_("translating to `%s %s%s'"), i.tm.name,
6712                            register_prefix, i.op[0].regs->reg_name);
6713                 }
6714             }
6715         }
6716     }
6717   else if (i.tm.opcode_modifier.modrm)
6718     {
6719       /* The opcode is completed (modulo i.tm.extension_opcode which
6720          must be put into the modrm byte).  Now, we make the modrm and
6721          index base bytes based on all the info we've collected.  */
6722
6723       default_seg = build_modrm_byte ();
6724     }
6725   else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
6726     {
6727       default_seg = &ds;
6728     }
6729   else if (i.tm.opcode_modifier.isstring)
6730     {
6731       /* For the string instructions that allow a segment override
6732          on one of their operands, the default segment is ds.  */
6733       default_seg = &ds;
6734     }
6735
6736   if (i.tm.base_opcode == 0x8d /* lea */
6737       && i.seg[0]
6738       && !quiet_warnings)
6739     as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
6740
6741   /* If a segment was explicitly specified, and the specified segment
6742      is not the default, use an opcode prefix to select it.  If we
6743      never figured out what the default segment is, then default_seg
6744      will be zero at this point, and the specified segment prefix will
6745      always be used.  */
6746   if ((i.seg[0]) && (i.seg[0] != default_seg))
6747     {
6748       if (!add_prefix (i.seg[0]->seg_prefix))
6749         return 0;
6750     }
6751   return 1;
6752 }
6753
6754 static const seg_entry *
6755 build_modrm_byte (void)
6756 {
6757   const seg_entry *default_seg = 0;
6758   unsigned int source, dest;
6759   int vex_3_sources;
6760
6761   vex_3_sources = i.tm.opcode_modifier.vexsources == VEX3SOURCES;
6762   if (vex_3_sources)
6763     {
6764       unsigned int nds, reg_slot;
6765       expressionS *exp;
6766
6767       dest = i.operands - 1;
6768       nds = dest - 1;
6769
6770       /* There are 2 kinds of instructions:
6771          1. 5 operands: 4 register operands or 3 register operands
6772          plus 1 memory operand plus one Vec_Imm4 operand, VexXDS, and
6773          VexW0 or VexW1.  The destination must be either XMM, YMM or
6774          ZMM register.
6775          2. 4 operands: 4 register operands or 3 register operands
6776          plus 1 memory operand, with VexXDS.  */
6777       gas_assert ((i.reg_operands == 4
6778                    || (i.reg_operands == 3 && i.mem_operands == 1))
6779                   && i.tm.opcode_modifier.vexvvvv == VEXXDS
6780                   && i.tm.opcode_modifier.vexw
6781                   && i.tm.operand_types[dest].bitfield.regsimd);
6782
6783       /* If VexW1 is set, the first non-immediate operand is the source and
6784          the second non-immediate one is encoded in the immediate operand.  */
6785       if (i.tm.opcode_modifier.vexw == VEXW1)
6786         {
6787           source = i.imm_operands;
6788           reg_slot = i.imm_operands + 1;
6789         }
6790       else
6791         {
6792           source = i.imm_operands + 1;
6793           reg_slot = i.imm_operands;
6794         }
6795
6796       if (i.imm_operands == 0)
6797         {
6798           /* When there is no immediate operand, generate an 8bit
6799              immediate operand to encode the first operand.  */
6800           exp = &im_expressions[i.imm_operands++];
6801           i.op[i.operands].imms = exp;
6802           i.types[i.operands] = imm8;
6803           i.operands++;
6804
6805           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
6806           exp->X_op = O_constant;
6807           exp->X_add_number = register_number (i.op[reg_slot].regs) << 4;
6808           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
6809         }
6810       else
6811         {
6812           unsigned int imm_slot;
6813
6814           gas_assert (i.imm_operands == 1 && i.types[0].bitfield.vec_imm4);
6815
6816           if (i.tm.opcode_modifier.immext)
6817             {
6818               /* When ImmExt is set, the immediate byte is the last
6819                  operand.  */
6820               imm_slot = i.operands - 1;
6821               source--;
6822               reg_slot--;
6823             }
6824           else
6825             {
6826               imm_slot = 0;
6827
6828               /* Turn on Imm8 so that output_imm will generate it.  */
6829               i.types[imm_slot].bitfield.imm8 = 1;
6830             }
6831
6832           gas_assert (i.tm.operand_types[reg_slot].bitfield.regsimd);
6833           i.op[imm_slot].imms->X_add_number
6834               |= register_number (i.op[reg_slot].regs) << 4;
6835           gas_assert ((i.op[reg_slot].regs->reg_flags & RegVRex) == 0);
6836         }
6837
6838       gas_assert (i.tm.operand_types[nds].bitfield.regsimd);
6839       i.vex.register_specifier = i.op[nds].regs;
6840     }
6841   else
6842     source = dest = 0;
6843
6844   /* i.reg_operands MUST be the number of real register operands;
6845      implicit registers do not count.  If there are 3 register
6846      operands, it must be a instruction with VexNDS.  For a
6847      instruction with VexNDD, the destination register is encoded
6848      in VEX prefix.  If there are 4 register operands, it must be
6849      a instruction with VEX prefix and 3 sources.  */
6850   if (i.mem_operands == 0
6851       && ((i.reg_operands == 2
6852            && i.tm.opcode_modifier.vexvvvv <= VEXXDS)
6853           || (i.reg_operands == 3
6854               && i.tm.opcode_modifier.vexvvvv == VEXXDS)
6855           || (i.reg_operands == 4 && vex_3_sources)))
6856     {
6857       switch (i.operands)
6858         {
6859         case 2:
6860           source = 0;
6861           break;
6862         case 3:
6863           /* When there are 3 operands, one of them may be immediate,
6864              which may be the first or the last operand.  Otherwise,
6865              the first operand must be shift count register (cl) or it
6866              is an instruction with VexNDS. */
6867           gas_assert (i.imm_operands == 1
6868                       || (i.imm_operands == 0
6869                           && (i.tm.opcode_modifier.vexvvvv == VEXXDS
6870                               || i.types[0].bitfield.shiftcount)));
6871           if (operand_type_check (i.types[0], imm)
6872               || i.types[0].bitfield.shiftcount)
6873             source = 1;
6874           else
6875             source = 0;
6876           break;
6877         case 4:
6878           /* When there are 4 operands, the first two must be 8bit
6879              immediate operands. The source operand will be the 3rd
6880              one.
6881
6882              For instructions with VexNDS, if the first operand
6883              an imm8, the source operand is the 2nd one.  If the last
6884              operand is imm8, the source operand is the first one.  */
6885           gas_assert ((i.imm_operands == 2
6886                        && i.types[0].bitfield.imm8
6887                        && i.types[1].bitfield.imm8)
6888                       || (i.tm.opcode_modifier.vexvvvv == VEXXDS
6889                           && i.imm_operands == 1
6890                           && (i.types[0].bitfield.imm8
6891                               || i.types[i.operands - 1].bitfield.imm8
6892                               || i.rounding)));
6893           if (i.imm_operands == 2)
6894             source = 2;
6895           else
6896             {
6897               if (i.types[0].bitfield.imm8)
6898                 source = 1;
6899               else
6900                 source = 0;
6901             }
6902           break;
6903         case 5:
6904           if (is_evex_encoding (&i.tm))
6905             {
6906               /* For EVEX instructions, when there are 5 operands, the
6907                  first one must be immediate operand.  If the second one
6908                  is immediate operand, the source operand is the 3th
6909                  one.  If the last one is immediate operand, the source
6910                  operand is the 2nd one.  */
6911               gas_assert (i.imm_operands == 2
6912                           && i.tm.opcode_modifier.sae
6913                           && operand_type_check (i.types[0], imm));
6914               if (operand_type_check (i.types[1], imm))
6915                 source = 2;
6916               else if (operand_type_check (i.types[4], imm))
6917                 source = 1;
6918               else
6919                 abort ();
6920             }
6921           break;
6922         default:
6923           abort ();
6924         }
6925
6926       if (!vex_3_sources)
6927         {
6928           dest = source + 1;
6929
6930           /* RC/SAE operand could be between DEST and SRC.  That happens
6931              when one operand is GPR and the other one is XMM/YMM/ZMM
6932              register.  */
6933           if (i.rounding && i.rounding->operand == (int) dest)
6934             dest++;
6935
6936           if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
6937             {
6938               /* For instructions with VexNDS, the register-only source
6939                  operand must be a 32/64bit integer, XMM, YMM, ZMM, or mask
6940                  register.  It is encoded in VEX prefix.  We need to
6941                  clear RegMem bit before calling operand_type_equal.  */
6942
6943               i386_operand_type op;
6944               unsigned int vvvv;
6945
6946               /* Check register-only source operand when two source
6947                  operands are swapped.  */
6948               if (!i.tm.operand_types[source].bitfield.baseindex
6949                   && i.tm.operand_types[dest].bitfield.baseindex)
6950                 {
6951                   vvvv = source;
6952                   source = dest;
6953                 }
6954               else
6955                 vvvv = dest;
6956
6957               op = i.tm.operand_types[vvvv];
6958               op.bitfield.regmem = 0;
6959               if ((dest + 1) >= i.operands
6960                   || ((!op.bitfield.reg
6961                        || (!op.bitfield.dword && !op.bitfield.qword))
6962                       && !op.bitfield.regsimd
6963                       && !operand_type_equal (&op, &regmask)))
6964                 abort ();
6965               i.vex.register_specifier = i.op[vvvv].regs;
6966               dest++;
6967             }
6968         }
6969
6970       i.rm.mode = 3;
6971       /* One of the register operands will be encoded in the i.tm.reg
6972          field, the other in the combined i.tm.mode and i.tm.regmem
6973          fields.  If no form of this instruction supports a memory
6974          destination operand, then we assume the source operand may
6975          sometimes be a memory operand and so we need to store the
6976          destination in the i.rm.reg field.  */
6977       if (!i.tm.operand_types[dest].bitfield.regmem
6978           && operand_type_check (i.tm.operand_types[dest], anymem) == 0)
6979         {
6980           i.rm.reg = i.op[dest].regs->reg_num;
6981           i.rm.regmem = i.op[source].regs->reg_num;
6982           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
6983             i.rex |= REX_R;
6984           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
6985             i.vrex |= REX_R;
6986           if ((i.op[source].regs->reg_flags & RegRex) != 0)
6987             i.rex |= REX_B;
6988           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
6989             i.vrex |= REX_B;
6990         }
6991       else
6992         {
6993           i.rm.reg = i.op[source].regs->reg_num;
6994           i.rm.regmem = i.op[dest].regs->reg_num;
6995           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
6996             i.rex |= REX_B;
6997           if ((i.op[dest].regs->reg_flags & RegVRex) != 0)
6998             i.vrex |= REX_B;
6999           if ((i.op[source].regs->reg_flags & RegRex) != 0)
7000             i.rex |= REX_R;
7001           if ((i.op[source].regs->reg_flags & RegVRex) != 0)
7002             i.vrex |= REX_R;
7003         }
7004       if (flag_code != CODE_64BIT && (i.rex & REX_R))
7005         {
7006           if (!i.types[i.tm.operand_types[0].bitfield.regmem].bitfield.control)
7007             abort ();
7008           i.rex &= ~REX_R;
7009           add_prefix (LOCK_PREFIX_OPCODE);
7010         }
7011     }
7012   else
7013     {                   /* If it's not 2 reg operands...  */
7014       unsigned int mem;
7015
7016       if (i.mem_operands)
7017         {
7018           unsigned int fake_zero_displacement = 0;
7019           unsigned int op;
7020
7021           for (op = 0; op < i.operands; op++)
7022             if (operand_type_check (i.types[op], anymem))
7023               break;
7024           gas_assert (op < i.operands);
7025
7026           if (i.tm.opcode_modifier.vecsib)
7027             {
7028               if (i.index_reg->reg_num == RegEiz
7029                   || i.index_reg->reg_num == RegRiz)
7030                 abort ();
7031
7032               i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7033               if (!i.base_reg)
7034                 {
7035                   i.sib.base = NO_BASE_REGISTER;
7036                   i.sib.scale = i.log2_scale_factor;
7037                   i.types[op].bitfield.disp8 = 0;
7038                   i.types[op].bitfield.disp16 = 0;
7039                   i.types[op].bitfield.disp64 = 0;
7040                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
7041                     {
7042                       /* Must be 32 bit */
7043                       i.types[op].bitfield.disp32 = 1;
7044                       i.types[op].bitfield.disp32s = 0;
7045                     }
7046                   else
7047                     {
7048                       i.types[op].bitfield.disp32 = 0;
7049                       i.types[op].bitfield.disp32s = 1;
7050                     }
7051                 }
7052               i.sib.index = i.index_reg->reg_num;
7053               if ((i.index_reg->reg_flags & RegRex) != 0)
7054                 i.rex |= REX_X;
7055               if ((i.index_reg->reg_flags & RegVRex) != 0)
7056                 i.vrex |= REX_X;
7057             }
7058
7059           default_seg = &ds;
7060
7061           if (i.base_reg == 0)
7062             {
7063               i.rm.mode = 0;
7064               if (!i.disp_operands)
7065                 fake_zero_displacement = 1;
7066               if (i.index_reg == 0)
7067                 {
7068                   i386_operand_type newdisp;
7069
7070                   gas_assert (!i.tm.opcode_modifier.vecsib);
7071                   /* Operand is just <disp>  */
7072                   if (flag_code == CODE_64BIT)
7073                     {
7074                       /* 64bit mode overwrites the 32bit absolute
7075                          addressing by RIP relative addressing and
7076                          absolute addressing is encoded by one of the
7077                          redundant SIB forms.  */
7078                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7079                       i.sib.base = NO_BASE_REGISTER;
7080                       i.sib.index = NO_INDEX_REGISTER;
7081                       newdisp = (!i.prefix[ADDR_PREFIX] ? disp32s : disp32);
7082                     }
7083                   else if ((flag_code == CODE_16BIT)
7084                            ^ (i.prefix[ADDR_PREFIX] != 0))
7085                     {
7086                       i.rm.regmem = NO_BASE_REGISTER_16;
7087                       newdisp = disp16;
7088                     }
7089                   else
7090                     {
7091                       i.rm.regmem = NO_BASE_REGISTER;
7092                       newdisp = disp32;
7093                     }
7094                   i.types[op] = operand_type_and_not (i.types[op], anydisp);
7095                   i.types[op] = operand_type_or (i.types[op], newdisp);
7096                 }
7097               else if (!i.tm.opcode_modifier.vecsib)
7098                 {
7099                   /* !i.base_reg && i.index_reg  */
7100                   if (i.index_reg->reg_num == RegEiz
7101                       || i.index_reg->reg_num == RegRiz)
7102                     i.sib.index = NO_INDEX_REGISTER;
7103                   else
7104                     i.sib.index = i.index_reg->reg_num;
7105                   i.sib.base = NO_BASE_REGISTER;
7106                   i.sib.scale = i.log2_scale_factor;
7107                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7108                   i.types[op].bitfield.disp8 = 0;
7109                   i.types[op].bitfield.disp16 = 0;
7110                   i.types[op].bitfield.disp64 = 0;
7111                   if (flag_code != CODE_64BIT || i.prefix[ADDR_PREFIX])
7112                     {
7113                       /* Must be 32 bit */
7114                       i.types[op].bitfield.disp32 = 1;
7115                       i.types[op].bitfield.disp32s = 0;
7116                     }
7117                   else
7118                     {
7119                       i.types[op].bitfield.disp32 = 0;
7120                       i.types[op].bitfield.disp32s = 1;
7121                     }
7122                   if ((i.index_reg->reg_flags & RegRex) != 0)
7123                     i.rex |= REX_X;
7124                 }
7125             }
7126           /* RIP addressing for 64bit mode.  */
7127           else if (i.base_reg->reg_num == RegRip ||
7128                    i.base_reg->reg_num == RegEip)
7129             {
7130               gas_assert (!i.tm.opcode_modifier.vecsib);
7131               i.rm.regmem = NO_BASE_REGISTER;
7132               i.types[op].bitfield.disp8 = 0;
7133               i.types[op].bitfield.disp16 = 0;
7134               i.types[op].bitfield.disp32 = 0;
7135               i.types[op].bitfield.disp32s = 1;
7136               i.types[op].bitfield.disp64 = 0;
7137               i.flags[op] |= Operand_PCrel;
7138               if (! i.disp_operands)
7139                 fake_zero_displacement = 1;
7140             }
7141           else if (i.base_reg->reg_type.bitfield.word)
7142             {
7143               gas_assert (!i.tm.opcode_modifier.vecsib);
7144               switch (i.base_reg->reg_num)
7145                 {
7146                 case 3: /* (%bx)  */
7147                   if (i.index_reg == 0)
7148                     i.rm.regmem = 7;
7149                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
7150                     i.rm.regmem = i.index_reg->reg_num - 6;
7151                   break;
7152                 case 5: /* (%bp)  */
7153                   default_seg = &ss;
7154                   if (i.index_reg == 0)
7155                     {
7156                       i.rm.regmem = 6;
7157                       if (operand_type_check (i.types[op], disp) == 0)
7158                         {
7159                           /* fake (%bp) into 0(%bp)  */
7160                           i.types[op].bitfield.disp8 = 1;
7161                           fake_zero_displacement = 1;
7162                         }
7163                     }
7164                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
7165                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
7166                   break;
7167                 default: /* (%si) -> 4 or (%di) -> 5  */
7168                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
7169                 }
7170               i.rm.mode = mode_from_disp_size (i.types[op]);
7171             }
7172           else /* i.base_reg and 32/64 bit mode  */
7173             {
7174               if (flag_code == CODE_64BIT
7175                   && operand_type_check (i.types[op], disp))
7176                 {
7177                   i.types[op].bitfield.disp16 = 0;
7178                   i.types[op].bitfield.disp64 = 0;
7179                   if (i.prefix[ADDR_PREFIX] == 0)
7180                     {
7181                       i.types[op].bitfield.disp32 = 0;
7182                       i.types[op].bitfield.disp32s = 1;
7183                     }
7184                   else
7185                     {
7186                       i.types[op].bitfield.disp32 = 1;
7187                       i.types[op].bitfield.disp32s = 0;
7188                     }
7189                 }
7190
7191               if (!i.tm.opcode_modifier.vecsib)
7192                 i.rm.regmem = i.base_reg->reg_num;
7193               if ((i.base_reg->reg_flags & RegRex) != 0)
7194                 i.rex |= REX_B;
7195               i.sib.base = i.base_reg->reg_num;
7196               /* x86-64 ignores REX prefix bit here to avoid decoder
7197                  complications.  */
7198               if (!(i.base_reg->reg_flags & RegRex)
7199                   && (i.base_reg->reg_num == EBP_REG_NUM
7200                    || i.base_reg->reg_num == ESP_REG_NUM))
7201                   default_seg = &ss;
7202               if (i.base_reg->reg_num == 5 && i.disp_operands == 0)
7203                 {
7204                   fake_zero_displacement = 1;
7205                   i.types[op].bitfield.disp8 = 1;
7206                 }
7207               i.sib.scale = i.log2_scale_factor;
7208               if (i.index_reg == 0)
7209                 {
7210                   gas_assert (!i.tm.opcode_modifier.vecsib);
7211                   /* <disp>(%esp) becomes two byte modrm with no index
7212                      register.  We've already stored the code for esp
7213                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
7214                      Any base register besides %esp will not use the
7215                      extra modrm byte.  */
7216                   i.sib.index = NO_INDEX_REGISTER;
7217                 }
7218               else if (!i.tm.opcode_modifier.vecsib)
7219                 {
7220                   if (i.index_reg->reg_num == RegEiz
7221                       || i.index_reg->reg_num == RegRiz)
7222                     i.sib.index = NO_INDEX_REGISTER;
7223                   else
7224                     i.sib.index = i.index_reg->reg_num;
7225                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
7226                   if ((i.index_reg->reg_flags & RegRex) != 0)
7227                     i.rex |= REX_X;
7228                 }
7229
7230               if (i.disp_operands
7231                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
7232                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
7233                 i.rm.mode = 0;
7234               else
7235                 {
7236                   if (!fake_zero_displacement
7237                       && !i.disp_operands
7238                       && i.disp_encoding)
7239                     {
7240                       fake_zero_displacement = 1;
7241                       if (i.disp_encoding == disp_encoding_8bit)
7242                         i.types[op].bitfield.disp8 = 1;
7243                       else
7244                         i.types[op].bitfield.disp32 = 1;
7245                     }
7246                   i.rm.mode = mode_from_disp_size (i.types[op]);
7247                 }
7248             }
7249
7250           if (fake_zero_displacement)
7251             {
7252               /* Fakes a zero displacement assuming that i.types[op]
7253                  holds the correct displacement size.  */
7254               expressionS *exp;
7255
7256               gas_assert (i.op[op].disps == 0);
7257               exp = &disp_expressions[i.disp_operands++];
7258               i.op[op].disps = exp;
7259               exp->X_op = O_constant;
7260               exp->X_add_number = 0;
7261               exp->X_add_symbol = (symbolS *) 0;
7262               exp->X_op_symbol = (symbolS *) 0;
7263             }
7264
7265           mem = op;
7266         }
7267       else
7268         mem = ~0;
7269
7270       if (i.tm.opcode_modifier.vexsources == XOP2SOURCES)
7271         {
7272           if (operand_type_check (i.types[0], imm))
7273             i.vex.register_specifier = NULL;
7274           else
7275             {
7276               /* VEX.vvvv encodes one of the sources when the first
7277                  operand is not an immediate.  */
7278               if (i.tm.opcode_modifier.vexw == VEXW0)
7279                 i.vex.register_specifier = i.op[0].regs;
7280               else
7281                 i.vex.register_specifier = i.op[1].regs;
7282             }
7283
7284           /* Destination is a XMM register encoded in the ModRM.reg
7285              and VEX.R bit.  */
7286           i.rm.reg = i.op[2].regs->reg_num;
7287           if ((i.op[2].regs->reg_flags & RegRex) != 0)
7288             i.rex |= REX_R;
7289
7290           /* ModRM.rm and VEX.B encodes the other source.  */
7291           if (!i.mem_operands)
7292             {
7293               i.rm.mode = 3;
7294
7295               if (i.tm.opcode_modifier.vexw == VEXW0)
7296                 i.rm.regmem = i.op[1].regs->reg_num;
7297               else
7298                 i.rm.regmem = i.op[0].regs->reg_num;
7299
7300               if ((i.op[1].regs->reg_flags & RegRex) != 0)
7301                 i.rex |= REX_B;
7302             }
7303         }
7304       else if (i.tm.opcode_modifier.vexvvvv == VEXLWP)
7305         {
7306           i.vex.register_specifier = i.op[2].regs;
7307           if (!i.mem_operands)
7308             {
7309               i.rm.mode = 3;
7310               i.rm.regmem = i.op[1].regs->reg_num;
7311               if ((i.op[1].regs->reg_flags & RegRex) != 0)
7312                 i.rex |= REX_B;
7313             }
7314         }
7315       /* Fill in i.rm.reg or i.rm.regmem field with register operand
7316          (if any) based on i.tm.extension_opcode.  Again, we must be
7317          careful to make sure that segment/control/debug/test/MMX
7318          registers are coded into the i.rm.reg field.  */
7319       else if (i.reg_operands)
7320         {
7321           unsigned int op;
7322           unsigned int vex_reg = ~0;
7323
7324           for (op = 0; op < i.operands; op++)
7325             if (i.types[op].bitfield.reg
7326                 || i.types[op].bitfield.regmmx
7327                 || i.types[op].bitfield.regsimd
7328                 || i.types[op].bitfield.regbnd
7329                 || i.types[op].bitfield.regmask
7330                 || i.types[op].bitfield.sreg2
7331                 || i.types[op].bitfield.sreg3
7332                 || i.types[op].bitfield.control
7333                 || i.types[op].bitfield.debug
7334                 || i.types[op].bitfield.test)
7335               break;
7336
7337           if (vex_3_sources)
7338             op = dest;
7339           else if (i.tm.opcode_modifier.vexvvvv == VEXXDS)
7340             {
7341               /* For instructions with VexNDS, the register-only
7342                  source operand is encoded in VEX prefix. */
7343               gas_assert (mem != (unsigned int) ~0);
7344
7345               if (op > mem)
7346                 {
7347                   vex_reg = op++;
7348                   gas_assert (op < i.operands);
7349                 }
7350               else
7351                 {
7352                   /* Check register-only source operand when two source
7353                      operands are swapped.  */
7354                   if (!i.tm.operand_types[op].bitfield.baseindex
7355                       && i.tm.operand_types[op + 1].bitfield.baseindex)
7356                     {
7357                       vex_reg = op;
7358                       op += 2;
7359                       gas_assert (mem == (vex_reg + 1)
7360                                   && op < i.operands);
7361                     }
7362                   else
7363                     {
7364                       vex_reg = op + 1;
7365                       gas_assert (vex_reg < i.operands);
7366                     }
7367                 }
7368             }
7369           else if (i.tm.opcode_modifier.vexvvvv == VEXNDD)
7370             {
7371               /* For instructions with VexNDD, the register destination
7372                  is encoded in VEX prefix.  */
7373               if (i.mem_operands == 0)
7374                 {
7375                   /* There is no memory operand.  */
7376                   gas_assert ((op + 2) == i.operands);
7377                   vex_reg = op + 1;
7378                 }
7379               else
7380                 {
7381                   /* There are only 2 non-immediate operands.  */
7382                   gas_assert (op < i.imm_operands + 2
7383                               && i.operands == i.imm_operands + 2);
7384                   vex_reg = i.imm_operands + 1;
7385                 }
7386             }
7387           else
7388             gas_assert (op < i.operands);
7389
7390           if (vex_reg != (unsigned int) ~0)
7391             {
7392               i386_operand_type *type = &i.tm.operand_types[vex_reg];
7393
7394               if ((!type->bitfield.reg
7395                    || (!type->bitfield.dword && !type->bitfield.qword))
7396                   && !type->bitfield.regsimd
7397                   && !operand_type_equal (type, &regmask))
7398                 abort ();
7399
7400               i.vex.register_specifier = i.op[vex_reg].regs;
7401             }
7402
7403           /* Don't set OP operand twice.  */
7404           if (vex_reg != op)
7405             {
7406               /* If there is an extension opcode to put here, the
7407                  register number must be put into the regmem field.  */
7408               if (i.tm.extension_opcode != None)
7409                 {
7410                   i.rm.regmem = i.op[op].regs->reg_num;
7411                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
7412                     i.rex |= REX_B;
7413                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
7414                     i.vrex |= REX_B;
7415                 }
7416               else
7417                 {
7418                   i.rm.reg = i.op[op].regs->reg_num;
7419                   if ((i.op[op].regs->reg_flags & RegRex) != 0)
7420                     i.rex |= REX_R;
7421                   if ((i.op[op].regs->reg_flags & RegVRex) != 0)
7422                     i.vrex |= REX_R;
7423                 }
7424             }
7425
7426           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
7427              must set it to 3 to indicate this is a register operand
7428              in the regmem field.  */
7429           if (!i.mem_operands)
7430             i.rm.mode = 3;
7431         }
7432
7433       /* Fill in i.rm.reg field with extension opcode (if any).  */
7434       if (i.tm.extension_opcode != None)
7435         i.rm.reg = i.tm.extension_opcode;
7436     }
7437   return default_seg;
7438 }
7439
7440 static void
7441 output_branch (void)
7442 {
7443   char *p;
7444   int size;
7445   int code16;
7446   int prefix;
7447   relax_substateT subtype;
7448   symbolS *sym;
7449   offsetT off;
7450
7451   code16 = flag_code == CODE_16BIT ? CODE16 : 0;
7452   size = i.disp_encoding == disp_encoding_32bit ? BIG : SMALL;
7453
7454   prefix = 0;
7455   if (i.prefix[DATA_PREFIX] != 0)
7456     {
7457       prefix = 1;
7458       i.prefixes -= 1;
7459       code16 ^= CODE16;
7460     }
7461   /* Pentium4 branch hints.  */
7462   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7463       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7464     {
7465       prefix++;
7466       i.prefixes--;
7467     }
7468   if (i.prefix[REX_PREFIX] != 0)
7469     {
7470       prefix++;
7471       i.prefixes--;
7472     }
7473
7474   /* BND prefixed jump.  */
7475   if (i.prefix[BND_PREFIX] != 0)
7476     {
7477       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7478       i.prefixes -= 1;
7479     }
7480
7481   if (i.prefixes != 0 && !intel_syntax)
7482     as_warn (_("skipping prefixes on this instruction"));
7483
7484   /* It's always a symbol;  End frag & setup for relax.
7485      Make sure there is enough room in this frag for the largest
7486      instruction we may generate in md_convert_frag.  This is 2
7487      bytes for the opcode and room for the prefix and largest
7488      displacement.  */
7489   frag_grow (prefix + 2 + 4);
7490   /* Prefix and 1 opcode byte go in fr_fix.  */
7491   p = frag_more (prefix + 1);
7492   if (i.prefix[DATA_PREFIX] != 0)
7493     *p++ = DATA_PREFIX_OPCODE;
7494   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
7495       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
7496     *p++ = i.prefix[SEG_PREFIX];
7497   if (i.prefix[REX_PREFIX] != 0)
7498     *p++ = i.prefix[REX_PREFIX];
7499   *p = i.tm.base_opcode;
7500
7501   if ((unsigned char) *p == JUMP_PC_RELATIVE)
7502     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, size);
7503   else if (cpu_arch_flags.bitfield.cpui386)
7504     subtype = ENCODE_RELAX_STATE (COND_JUMP, size);
7505   else
7506     subtype = ENCODE_RELAX_STATE (COND_JUMP86, size);
7507   subtype |= code16;
7508
7509   sym = i.op[0].disps->X_add_symbol;
7510   off = i.op[0].disps->X_add_number;
7511
7512   if (i.op[0].disps->X_op != O_constant
7513       && i.op[0].disps->X_op != O_symbol)
7514     {
7515       /* Handle complex expressions.  */
7516       sym = make_expr_symbol (i.op[0].disps);
7517       off = 0;
7518     }
7519
7520   /* 1 possible extra opcode + 4 byte displacement go in var part.
7521      Pass reloc in fr_var.  */
7522   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
7523 }
7524
7525 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7526 /* Return TRUE iff PLT32 relocation should be used for branching to
7527    symbol S.  */
7528
7529 static bfd_boolean
7530 need_plt32_p (symbolS *s)
7531 {
7532   /* PLT32 relocation is ELF only.  */
7533   if (!IS_ELF)
7534     return FALSE;
7535
7536   /* Since there is no need to prepare for PLT branch on x86-64, we
7537      can generate R_X86_64_PLT32, instead of R_X86_64_PC32, which can
7538      be used as a marker for 32-bit PC-relative branches.  */
7539   if (!object_64bit)
7540     return FALSE;
7541
7542   /* Weak or undefined symbol need PLT32 relocation.  */
7543   if (S_IS_WEAK (s) || !S_IS_DEFINED (s))
7544     return TRUE;
7545
7546   /* Non-global symbol doesn't need PLT32 relocation.  */
7547   if (! S_IS_EXTERNAL (s))
7548     return FALSE;
7549
7550   /* Other global symbols need PLT32 relocation.  NB: Symbol with
7551      non-default visibilities are treated as normal global symbol
7552      so that PLT32 relocation can be used as a marker for 32-bit
7553      PC-relative branches.  It is useful for linker relaxation.  */
7554   return TRUE;
7555 }
7556 #endif
7557
7558 static void
7559 output_jump (void)
7560 {
7561   char *p;
7562   int size;
7563   fixS *fixP;
7564   bfd_reloc_code_real_type jump_reloc = i.reloc[0];
7565
7566   if (i.tm.opcode_modifier.jumpbyte)
7567     {
7568       /* This is a loop or jecxz type instruction.  */
7569       size = 1;
7570       if (i.prefix[ADDR_PREFIX] != 0)
7571         {
7572           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
7573           i.prefixes -= 1;
7574         }
7575       /* Pentium4 branch hints.  */
7576       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
7577           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
7578         {
7579           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
7580           i.prefixes--;
7581         }
7582     }
7583   else
7584     {
7585       int code16;
7586
7587       code16 = 0;
7588       if (flag_code == CODE_16BIT)
7589         code16 = CODE16;
7590
7591       if (i.prefix[DATA_PREFIX] != 0)
7592         {
7593           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
7594           i.prefixes -= 1;
7595           code16 ^= CODE16;
7596         }
7597
7598       size = 4;
7599       if (code16)
7600         size = 2;
7601     }
7602
7603   if (i.prefix[REX_PREFIX] != 0)
7604     {
7605       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
7606       i.prefixes -= 1;
7607     }
7608
7609   /* BND prefixed jump.  */
7610   if (i.prefix[BND_PREFIX] != 0)
7611     {
7612       FRAG_APPEND_1_CHAR (i.prefix[BND_PREFIX]);
7613       i.prefixes -= 1;
7614     }
7615
7616   if (i.prefixes != 0 && !intel_syntax)
7617     as_warn (_("skipping prefixes on this instruction"));
7618
7619   p = frag_more (i.tm.opcode_length + size);
7620   switch (i.tm.opcode_length)
7621     {
7622     case 2:
7623       *p++ = i.tm.base_opcode >> 8;
7624       /* Fall through.  */
7625     case 1:
7626       *p++ = i.tm.base_opcode;
7627       break;
7628     default:
7629       abort ();
7630     }
7631
7632 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7633   if (size == 4
7634       && jump_reloc == NO_RELOC
7635       && need_plt32_p (i.op[0].disps->X_add_symbol))
7636     jump_reloc = BFD_RELOC_X86_64_PLT32;
7637 #endif
7638
7639   jump_reloc = reloc (size, 1, 1, jump_reloc);
7640
7641   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7642                       i.op[0].disps, 1, jump_reloc);
7643
7644   /* All jumps handled here are signed, but don't use a signed limit
7645      check for 32 and 16 bit jumps as we want to allow wrap around at
7646      4G and 64k respectively.  */
7647   if (size == 1)
7648     fixP->fx_signed = 1;
7649 }
7650
7651 static void
7652 output_interseg_jump (void)
7653 {
7654   char *p;
7655   int size;
7656   int prefix;
7657   int code16;
7658
7659   code16 = 0;
7660   if (flag_code == CODE_16BIT)
7661     code16 = CODE16;
7662
7663   prefix = 0;
7664   if (i.prefix[DATA_PREFIX] != 0)
7665     {
7666       prefix = 1;
7667       i.prefixes -= 1;
7668       code16 ^= CODE16;
7669     }
7670   if (i.prefix[REX_PREFIX] != 0)
7671     {
7672       prefix++;
7673       i.prefixes -= 1;
7674     }
7675
7676   size = 4;
7677   if (code16)
7678     size = 2;
7679
7680   if (i.prefixes != 0 && !intel_syntax)
7681     as_warn (_("skipping prefixes on this instruction"));
7682
7683   /* 1 opcode; 2 segment; offset  */
7684   p = frag_more (prefix + 1 + 2 + size);
7685
7686   if (i.prefix[DATA_PREFIX] != 0)
7687     *p++ = DATA_PREFIX_OPCODE;
7688
7689   if (i.prefix[REX_PREFIX] != 0)
7690     *p++ = i.prefix[REX_PREFIX];
7691
7692   *p++ = i.tm.base_opcode;
7693   if (i.op[1].imms->X_op == O_constant)
7694     {
7695       offsetT n = i.op[1].imms->X_add_number;
7696
7697       if (size == 2
7698           && !fits_in_unsigned_word (n)
7699           && !fits_in_signed_word (n))
7700         {
7701           as_bad (_("16-bit jump out of range"));
7702           return;
7703         }
7704       md_number_to_chars (p, n, size);
7705     }
7706   else
7707     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
7708                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
7709   if (i.op[0].imms->X_op != O_constant)
7710     as_bad (_("can't handle non absolute segment in `%s'"),
7711             i.tm.name);
7712   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
7713 }
7714
7715 static void
7716 output_insn (void)
7717 {
7718   fragS *insn_start_frag;
7719   offsetT insn_start_off;
7720
7721   /* Tie dwarf2 debug info to the address at the start of the insn.
7722      We can't do this after the insn has been output as the current
7723      frag may have been closed off.  eg. by frag_var.  */
7724   dwarf2_emit_insn (0);
7725
7726   insn_start_frag = frag_now;
7727   insn_start_off = frag_now_fix ();
7728
7729   /* Output jumps.  */
7730   if (i.tm.opcode_modifier.jump)
7731     output_branch ();
7732   else if (i.tm.opcode_modifier.jumpbyte
7733            || i.tm.opcode_modifier.jumpdword)
7734     output_jump ();
7735   else if (i.tm.opcode_modifier.jumpintersegment)
7736     output_interseg_jump ();
7737   else
7738     {
7739       /* Output normal instructions here.  */
7740       char *p;
7741       unsigned char *q;
7742       unsigned int j;
7743       unsigned int prefix;
7744
7745       if (avoid_fence
7746          && i.tm.base_opcode == 0xfae
7747          && i.operands == 1
7748          && i.imm_operands == 1
7749          && (i.op[0].imms->X_add_number == 0xe8
7750              || i.op[0].imms->X_add_number == 0xf0
7751              || i.op[0].imms->X_add_number == 0xf8))
7752         {
7753           /* Encode lfence, mfence, and sfence as
7754              f0 83 04 24 00   lock addl $0x0, (%{re}sp).  */
7755           offsetT val = 0x240483f0ULL;
7756           p = frag_more (5);
7757           md_number_to_chars (p, val, 5);
7758           return;
7759         }
7760
7761       /* Some processors fail on LOCK prefix. This options makes
7762          assembler ignore LOCK prefix and serves as a workaround.  */
7763       if (omit_lock_prefix)
7764         {
7765           if (i.tm.base_opcode == LOCK_PREFIX_OPCODE)
7766             return;
7767           i.prefix[LOCK_PREFIX] = 0;
7768         }
7769
7770       /* Since the VEX/EVEX prefix contains the implicit prefix, we
7771          don't need the explicit prefix.  */
7772       if (!i.tm.opcode_modifier.vex && !i.tm.opcode_modifier.evex)
7773         {
7774           switch (i.tm.opcode_length)
7775             {
7776             case 3:
7777               if (i.tm.base_opcode & 0xff000000)
7778                 {
7779                   prefix = (i.tm.base_opcode >> 24) & 0xff;
7780                   add_prefix (prefix);
7781                 }
7782               break;
7783             case 2:
7784               if ((i.tm.base_opcode & 0xff0000) != 0)
7785                 {
7786                   prefix = (i.tm.base_opcode >> 16) & 0xff;
7787                   if (!i.tm.cpu_flags.bitfield.cpupadlock
7788                       || prefix != REPE_PREFIX_OPCODE
7789                       || (i.prefix[REP_PREFIX] != REPE_PREFIX_OPCODE))
7790                     add_prefix (prefix);
7791                 }
7792               break;
7793             case 1:
7794               break;
7795             case 0:
7796               /* Check for pseudo prefixes.  */
7797               as_bad_where (insn_start_frag->fr_file,
7798                             insn_start_frag->fr_line,
7799                              _("pseudo prefix without instruction"));
7800               return;
7801             default:
7802               abort ();
7803             }
7804
7805 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
7806           /* For x32, add a dummy REX_OPCODE prefix for mov/add with
7807              R_X86_64_GOTTPOFF relocation so that linker can safely
7808              perform IE->LE optimization.  */
7809           if (x86_elf_abi == X86_64_X32_ABI
7810               && i.operands == 2
7811               && i.reloc[0] == BFD_RELOC_X86_64_GOTTPOFF
7812               && i.prefix[REX_PREFIX] == 0)
7813             add_prefix (REX_OPCODE);
7814 #endif
7815
7816           /* The prefix bytes.  */
7817           for (j = ARRAY_SIZE (i.prefix), q = i.prefix; j > 0; j--, q++)
7818             if (*q)
7819               FRAG_APPEND_1_CHAR (*q);
7820         }
7821       else
7822         {
7823           for (j = 0, q = i.prefix; j < ARRAY_SIZE (i.prefix); j++, q++)
7824             if (*q)
7825               switch (j)
7826                 {
7827                 case REX_PREFIX:
7828                   /* REX byte is encoded in VEX prefix.  */
7829                   break;
7830                 case SEG_PREFIX:
7831                 case ADDR_PREFIX:
7832                   FRAG_APPEND_1_CHAR (*q);
7833                   break;
7834                 default:
7835                   /* There should be no other prefixes for instructions
7836                      with VEX prefix.  */
7837                   abort ();
7838                 }
7839
7840           /* For EVEX instructions i.vrex should become 0 after
7841              build_evex_prefix.  For VEX instructions upper 16 registers
7842              aren't available, so VREX should be 0.  */
7843           if (i.vrex)
7844             abort ();
7845           /* Now the VEX prefix.  */
7846           p = frag_more (i.vex.length);
7847           for (j = 0; j < i.vex.length; j++)
7848             p[j] = i.vex.bytes[j];
7849         }
7850
7851       /* Now the opcode; be careful about word order here!  */
7852       if (i.tm.opcode_length == 1)
7853         {
7854           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
7855         }
7856       else
7857         {
7858           switch (i.tm.opcode_length)
7859             {
7860             case 4:
7861               p = frag_more (4);
7862               *p++ = (i.tm.base_opcode >> 24) & 0xff;
7863               *p++ = (i.tm.base_opcode >> 16) & 0xff;
7864               break;
7865             case 3:
7866               p = frag_more (3);
7867               *p++ = (i.tm.base_opcode >> 16) & 0xff;
7868               break;
7869             case 2:
7870               p = frag_more (2);
7871               break;
7872             default:
7873               abort ();
7874               break;
7875             }
7876
7877           /* Put out high byte first: can't use md_number_to_chars!  */
7878           *p++ = (i.tm.base_opcode >> 8) & 0xff;
7879           *p = i.tm.base_opcode & 0xff;
7880         }
7881
7882       /* Now the modrm byte and sib byte (if present).  */
7883       if (i.tm.opcode_modifier.modrm)
7884         {
7885           FRAG_APPEND_1_CHAR ((i.rm.regmem << 0
7886                                | i.rm.reg << 3
7887                                | i.rm.mode << 6));
7888           /* If i.rm.regmem == ESP (4)
7889              && i.rm.mode != (Register mode)
7890              && not 16 bit
7891              ==> need second modrm byte.  */
7892           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
7893               && i.rm.mode != 3
7894               && !(i.base_reg && i.base_reg->reg_type.bitfield.word))
7895             FRAG_APPEND_1_CHAR ((i.sib.base << 0
7896                                  | i.sib.index << 3
7897                                  | i.sib.scale << 6));
7898         }
7899
7900       if (i.disp_operands)
7901         output_disp (insn_start_frag, insn_start_off);
7902
7903       if (i.imm_operands)
7904         output_imm (insn_start_frag, insn_start_off);
7905     }
7906
7907 #ifdef DEBUG386
7908   if (flag_debug)
7909     {
7910       pi ("" /*line*/, &i);
7911     }
7912 #endif /* DEBUG386  */
7913 }
7914
7915 /* Return the size of the displacement operand N.  */
7916
7917 static int
7918 disp_size (unsigned int n)
7919 {
7920   int size = 4;
7921
7922   if (i.types[n].bitfield.disp64)
7923     size = 8;
7924   else if (i.types[n].bitfield.disp8)
7925     size = 1;
7926   else if (i.types[n].bitfield.disp16)
7927     size = 2;
7928   return size;
7929 }
7930
7931 /* Return the size of the immediate operand N.  */
7932
7933 static int
7934 imm_size (unsigned int n)
7935 {
7936   int size = 4;
7937   if (i.types[n].bitfield.imm64)
7938     size = 8;
7939   else if (i.types[n].bitfield.imm8 || i.types[n].bitfield.imm8s)
7940     size = 1;
7941   else if (i.types[n].bitfield.imm16)
7942     size = 2;
7943   return size;
7944 }
7945
7946 static void
7947 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
7948 {
7949   char *p;
7950   unsigned int n;
7951
7952   for (n = 0; n < i.operands; n++)
7953     {
7954       if (operand_type_check (i.types[n], disp))
7955         {
7956           if (i.op[n].disps->X_op == O_constant)
7957             {
7958               int size = disp_size (n);
7959               offsetT val = i.op[n].disps->X_add_number;
7960
7961               val = offset_in_range (val >> i.memshift, size);
7962               p = frag_more (size);
7963               md_number_to_chars (p, val, size);
7964             }
7965           else
7966             {
7967               enum bfd_reloc_code_real reloc_type;
7968               int size = disp_size (n);
7969               int sign = i.types[n].bitfield.disp32s;
7970               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
7971               fixS *fixP;
7972
7973               /* We can't have 8 bit displacement here.  */
7974               gas_assert (!i.types[n].bitfield.disp8);
7975
7976               /* The PC relative address is computed relative
7977                  to the instruction boundary, so in case immediate
7978                  fields follows, we need to adjust the value.  */
7979               if (pcrel && i.imm_operands)
7980                 {
7981                   unsigned int n1;
7982                   int sz = 0;
7983
7984                   for (n1 = 0; n1 < i.operands; n1++)
7985                     if (operand_type_check (i.types[n1], imm))
7986                       {
7987                         /* Only one immediate is allowed for PC
7988                            relative address.  */
7989                         gas_assert (sz == 0);
7990                         sz = imm_size (n1);
7991                         i.op[n].disps->X_add_number -= sz;
7992                       }
7993                   /* We should find the immediate.  */
7994                   gas_assert (sz != 0);
7995                 }
7996
7997               p = frag_more (size);
7998               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
7999               if (GOT_symbol
8000                   && GOT_symbol == i.op[n].disps->X_add_symbol
8001                   && (((reloc_type == BFD_RELOC_32
8002                         || reloc_type == BFD_RELOC_X86_64_32S
8003                         || (reloc_type == BFD_RELOC_64
8004                             && object_64bit))
8005                        && (i.op[n].disps->X_op == O_symbol
8006                            || (i.op[n].disps->X_op == O_add
8007                                && ((symbol_get_value_expression
8008                                     (i.op[n].disps->X_op_symbol)->X_op)
8009                                    == O_subtract))))
8010                       || reloc_type == BFD_RELOC_32_PCREL))
8011                 {
8012                   offsetT add;
8013
8014                   if (insn_start_frag == frag_now)
8015                     add = (p - frag_now->fr_literal) - insn_start_off;
8016                   else
8017                     {
8018                       fragS *fr;
8019
8020                       add = insn_start_frag->fr_fix - insn_start_off;
8021                       for (fr = insn_start_frag->fr_next;
8022                            fr && fr != frag_now; fr = fr->fr_next)
8023                         add += fr->fr_fix;
8024                       add += p - frag_now->fr_literal;
8025                     }
8026
8027                   if (!object_64bit)
8028                     {
8029                       reloc_type = BFD_RELOC_386_GOTPC;
8030                       i.op[n].imms->X_add_number += add;
8031                     }
8032                   else if (reloc_type == BFD_RELOC_64)
8033                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
8034                   else
8035                     /* Don't do the adjustment for x86-64, as there
8036                        the pcrel addressing is relative to the _next_
8037                        insn, and that is taken care of in other code.  */
8038                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
8039                 }
8040               fixP = fix_new_exp (frag_now, p - frag_now->fr_literal,
8041                                   size, i.op[n].disps, pcrel,
8042                                   reloc_type);
8043               /* Check for "call/jmp *mem", "mov mem, %reg",
8044                  "test %reg, mem" and "binop mem, %reg" where binop
8045                  is one of adc, add, and, cmp, or, sbb, sub, xor
8046                  instructions.  Always generate R_386_GOT32X for
8047                  "sym*GOT" operand in 32-bit mode.  */
8048               if ((generate_relax_relocations
8049                    || (!object_64bit
8050                        && i.rm.mode == 0
8051                        && i.rm.regmem == 5))
8052                   && (i.rm.mode == 2
8053                       || (i.rm.mode == 0 && i.rm.regmem == 5))
8054                   && ((i.operands == 1
8055                        && i.tm.base_opcode == 0xff
8056                        && (i.rm.reg == 2 || i.rm.reg == 4))
8057                       || (i.operands == 2
8058                           && (i.tm.base_opcode == 0x8b
8059                               || i.tm.base_opcode == 0x85
8060                               || (i.tm.base_opcode & 0xc7) == 0x03))))
8061                 {
8062                   if (object_64bit)
8063                     {
8064                       fixP->fx_tcbit = i.rex != 0;
8065                       if (i.base_reg
8066                           && (i.base_reg->reg_num == RegRip
8067                               || i.base_reg->reg_num == RegEip))
8068                       fixP->fx_tcbit2 = 1;
8069                     }
8070                   else
8071                     fixP->fx_tcbit2 = 1;
8072                 }
8073             }
8074         }
8075     }
8076 }
8077
8078 static void
8079 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
8080 {
8081   char *p;
8082   unsigned int n;
8083
8084   for (n = 0; n < i.operands; n++)
8085     {
8086       /* Skip SAE/RC Imm operand in EVEX.  They are already handled.  */
8087       if (i.rounding && (int) n == i.rounding->operand)
8088         continue;
8089
8090       if (operand_type_check (i.types[n], imm))
8091         {
8092           if (i.op[n].imms->X_op == O_constant)
8093             {
8094               int size = imm_size (n);
8095               offsetT val;
8096
8097               val = offset_in_range (i.op[n].imms->X_add_number,
8098                                      size);
8099               p = frag_more (size);
8100               md_number_to_chars (p, val, size);
8101             }
8102           else
8103             {
8104               /* Not absolute_section.
8105                  Need a 32-bit fixup (don't support 8bit
8106                  non-absolute imms).  Try to support other
8107                  sizes ...  */
8108               enum bfd_reloc_code_real reloc_type;
8109               int size = imm_size (n);
8110               int sign;
8111
8112               if (i.types[n].bitfield.imm32s
8113                   && (i.suffix == QWORD_MNEM_SUFFIX
8114                       || (!i.suffix && i.tm.opcode_modifier.no_lsuf)))
8115                 sign = 1;
8116               else
8117                 sign = 0;
8118
8119               p = frag_more (size);
8120               reloc_type = reloc (size, 0, sign, i.reloc[n]);
8121
8122               /*   This is tough to explain.  We end up with this one if we
8123                * have operands that look like
8124                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
8125                * obtain the absolute address of the GOT, and it is strongly
8126                * preferable from a performance point of view to avoid using
8127                * a runtime relocation for this.  The actual sequence of
8128                * instructions often look something like:
8129                *
8130                *        call    .L66
8131                * .L66:
8132                *        popl    %ebx
8133                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
8134                *
8135                *   The call and pop essentially return the absolute address
8136                * of the label .L66 and store it in %ebx.  The linker itself
8137                * will ultimately change the first operand of the addl so
8138                * that %ebx points to the GOT, but to keep things simple, the
8139                * .o file must have this operand set so that it generates not
8140                * the absolute address of .L66, but the absolute address of
8141                * itself.  This allows the linker itself simply treat a GOTPC
8142                * relocation as asking for a pcrel offset to the GOT to be
8143                * added in, and the addend of the relocation is stored in the
8144                * operand field for the instruction itself.
8145                *
8146                *   Our job here is to fix the operand so that it would add
8147                * the correct offset so that %ebx would point to itself.  The
8148                * thing that is tricky is that .-.L66 will point to the
8149                * beginning of the instruction, so we need to further modify
8150                * the operand so that it will point to itself.  There are
8151                * other cases where you have something like:
8152                *
8153                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
8154                *
8155                * and here no correction would be required.  Internally in
8156                * the assembler we treat operands of this form as not being
8157                * pcrel since the '.' is explicitly mentioned, and I wonder
8158                * whether it would simplify matters to do it this way.  Who
8159                * knows.  In earlier versions of the PIC patches, the
8160                * pcrel_adjust field was used to store the correction, but
8161                * since the expression is not pcrel, I felt it would be
8162                * confusing to do it this way.  */
8163
8164               if ((reloc_type == BFD_RELOC_32
8165                    || reloc_type == BFD_RELOC_X86_64_32S
8166                    || reloc_type == BFD_RELOC_64)
8167                   && GOT_symbol
8168                   && GOT_symbol == i.op[n].imms->X_add_symbol
8169                   && (i.op[n].imms->X_op == O_symbol
8170                       || (i.op[n].imms->X_op == O_add
8171                           && ((symbol_get_value_expression
8172                                (i.op[n].imms->X_op_symbol)->X_op)
8173                               == O_subtract))))
8174                 {
8175                   offsetT add;
8176
8177                   if (insn_start_frag == frag_now)
8178                     add = (p - frag_now->fr_literal) - insn_start_off;
8179                   else
8180                     {
8181                       fragS *fr;
8182
8183                       add = insn_start_frag->fr_fix - insn_start_off;
8184                       for (fr = insn_start_frag->fr_next;
8185                            fr && fr != frag_now; fr = fr->fr_next)
8186                         add += fr->fr_fix;
8187                       add += p - frag_now->fr_literal;
8188                     }
8189
8190                   if (!object_64bit)
8191                     reloc_type = BFD_RELOC_386_GOTPC;
8192                   else if (size == 4)
8193                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
8194                   else if (size == 8)
8195                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
8196                   i.op[n].imms->X_add_number += add;
8197                 }
8198               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
8199                            i.op[n].imms, 0, reloc_type);
8200             }
8201         }
8202     }
8203 }
8204 \f
8205 /* x86_cons_fix_new is called via the expression parsing code when a
8206    reloc is needed.  We use this hook to get the correct .got reloc.  */
8207 static int cons_sign = -1;
8208
8209 void
8210 x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
8211                   expressionS *exp, bfd_reloc_code_real_type r)
8212 {
8213   r = reloc (len, 0, cons_sign, r);
8214
8215 #ifdef TE_PE
8216   if (exp->X_op == O_secrel)
8217     {
8218       exp->X_op = O_symbol;
8219       r = BFD_RELOC_32_SECREL;
8220     }
8221 #endif
8222
8223   fix_new_exp (frag, off, len, exp, 0, r);
8224 }
8225
8226 /* Export the ABI address size for use by TC_ADDRESS_BYTES for the
8227    purpose of the `.dc.a' internal pseudo-op.  */
8228
8229 int
8230 x86_address_bytes (void)
8231 {
8232   if ((stdoutput->arch_info->mach & bfd_mach_x64_32))
8233     return 4;
8234   return stdoutput->arch_info->bits_per_address / 8;
8235 }
8236
8237 #if !(defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (OBJ_MACH_O)) \
8238     || defined (LEX_AT)
8239 # define lex_got(reloc, adjust, types) NULL
8240 #else
8241 /* Parse operands of the form
8242    <symbol>@GOTOFF+<nnn>
8243    and similar .plt or .got references.
8244
8245    If we find one, set up the correct relocation in RELOC and copy the
8246    input string, minus the `@GOTOFF' into a malloc'd buffer for
8247    parsing by the calling routine.  Return this buffer, and if ADJUST
8248    is non-null set it to the length of the string we removed from the
8249    input line.  Otherwise return NULL.  */
8250 static char *
8251 lex_got (enum bfd_reloc_code_real *rel,
8252          int *adjust,
8253          i386_operand_type *types)
8254 {
8255   /* Some of the relocations depend on the size of what field is to
8256      be relocated.  But in our callers i386_immediate and i386_displacement
8257      we don't yet know the operand size (this will be set by insn
8258      matching).  Hence we record the word32 relocation here,
8259      and adjust the reloc according to the real size in reloc().  */
8260   static const struct {
8261     const char *str;
8262     int len;
8263     const enum bfd_reloc_code_real rel[2];
8264     const i386_operand_type types64;
8265   } gotrel[] = {
8266 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8267     { STRING_COMMA_LEN ("SIZE"),      { BFD_RELOC_SIZE32,
8268                                         BFD_RELOC_SIZE32 },
8269       OPERAND_TYPE_IMM32_64 },
8270 #endif
8271     { STRING_COMMA_LEN ("PLTOFF"),   { _dummy_first_bfd_reloc_code_real,
8272                                        BFD_RELOC_X86_64_PLTOFF64 },
8273       OPERAND_TYPE_IMM64 },
8274     { STRING_COMMA_LEN ("PLT"),      { BFD_RELOC_386_PLT32,
8275                                        BFD_RELOC_X86_64_PLT32    },
8276       OPERAND_TYPE_IMM32_32S_DISP32 },
8277     { STRING_COMMA_LEN ("GOTPLT"),   { _dummy_first_bfd_reloc_code_real,
8278                                        BFD_RELOC_X86_64_GOTPLT64 },
8279       OPERAND_TYPE_IMM64_DISP64 },
8280     { STRING_COMMA_LEN ("GOTOFF"),   { BFD_RELOC_386_GOTOFF,
8281                                        BFD_RELOC_X86_64_GOTOFF64 },
8282       OPERAND_TYPE_IMM64_DISP64 },
8283     { STRING_COMMA_LEN ("GOTPCREL"), { _dummy_first_bfd_reloc_code_real,
8284                                        BFD_RELOC_X86_64_GOTPCREL },
8285       OPERAND_TYPE_IMM32_32S_DISP32 },
8286     { STRING_COMMA_LEN ("TLSGD"),    { BFD_RELOC_386_TLS_GD,
8287                                        BFD_RELOC_X86_64_TLSGD    },
8288       OPERAND_TYPE_IMM32_32S_DISP32 },
8289     { STRING_COMMA_LEN ("TLSLDM"),   { BFD_RELOC_386_TLS_LDM,
8290                                        _dummy_first_bfd_reloc_code_real },
8291       OPERAND_TYPE_NONE },
8292     { STRING_COMMA_LEN ("TLSLD"),    { _dummy_first_bfd_reloc_code_real,
8293                                        BFD_RELOC_X86_64_TLSLD    },
8294       OPERAND_TYPE_IMM32_32S_DISP32 },
8295     { STRING_COMMA_LEN ("GOTTPOFF"), { BFD_RELOC_386_TLS_IE_32,
8296                                        BFD_RELOC_X86_64_GOTTPOFF },
8297       OPERAND_TYPE_IMM32_32S_DISP32 },
8298     { STRING_COMMA_LEN ("TPOFF"),    { BFD_RELOC_386_TLS_LE_32,
8299                                        BFD_RELOC_X86_64_TPOFF32  },
8300       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8301     { STRING_COMMA_LEN ("NTPOFF"),   { BFD_RELOC_386_TLS_LE,
8302                                        _dummy_first_bfd_reloc_code_real },
8303       OPERAND_TYPE_NONE },
8304     { STRING_COMMA_LEN ("DTPOFF"),   { BFD_RELOC_386_TLS_LDO_32,
8305                                        BFD_RELOC_X86_64_DTPOFF32 },
8306       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8307     { STRING_COMMA_LEN ("GOTNTPOFF"),{ BFD_RELOC_386_TLS_GOTIE,
8308                                        _dummy_first_bfd_reloc_code_real },
8309       OPERAND_TYPE_NONE },
8310     { STRING_COMMA_LEN ("INDNTPOFF"),{ BFD_RELOC_386_TLS_IE,
8311                                        _dummy_first_bfd_reloc_code_real },
8312       OPERAND_TYPE_NONE },
8313     { STRING_COMMA_LEN ("GOT"),      { BFD_RELOC_386_GOT32,
8314                                        BFD_RELOC_X86_64_GOT32    },
8315       OPERAND_TYPE_IMM32_32S_64_DISP32 },
8316     { STRING_COMMA_LEN ("TLSDESC"),  { BFD_RELOC_386_TLS_GOTDESC,
8317                                        BFD_RELOC_X86_64_GOTPC32_TLSDESC },
8318       OPERAND_TYPE_IMM32_32S_DISP32 },
8319     { STRING_COMMA_LEN ("TLSCALL"),  { BFD_RELOC_386_TLS_DESC_CALL,
8320                                        BFD_RELOC_X86_64_TLSDESC_CALL },
8321       OPERAND_TYPE_IMM32_32S_DISP32 },
8322   };
8323   char *cp;
8324   unsigned int j;
8325
8326 #if defined (OBJ_MAYBE_ELF)
8327   if (!IS_ELF)
8328     return NULL;
8329 #endif
8330
8331   for (cp = input_line_pointer; *cp != '@'; cp++)
8332     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
8333       return NULL;
8334
8335   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
8336     {
8337       int len = gotrel[j].len;
8338       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
8339         {
8340           if (gotrel[j].rel[object_64bit] != 0)
8341             {
8342               int first, second;
8343               char *tmpbuf, *past_reloc;
8344
8345               *rel = gotrel[j].rel[object_64bit];
8346
8347               if (types)
8348                 {
8349                   if (flag_code != CODE_64BIT)
8350                     {
8351                       types->bitfield.imm32 = 1;
8352                       types->bitfield.disp32 = 1;
8353                     }
8354                   else
8355                     *types = gotrel[j].types64;
8356                 }
8357
8358               if (j != 0 && GOT_symbol == NULL)
8359                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
8360
8361               /* The length of the first part of our input line.  */
8362               first = cp - input_line_pointer;
8363
8364               /* The second part goes from after the reloc token until
8365                  (and including) an end_of_line char or comma.  */
8366               past_reloc = cp + 1 + len;
8367               cp = past_reloc;
8368               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
8369                 ++cp;
8370               second = cp + 1 - past_reloc;
8371
8372               /* Allocate and copy string.  The trailing NUL shouldn't
8373                  be necessary, but be safe.  */
8374               tmpbuf = XNEWVEC (char, first + second + 2);
8375               memcpy (tmpbuf, input_line_pointer, first);
8376               if (second != 0 && *past_reloc != ' ')
8377                 /* Replace the relocation token with ' ', so that
8378                    errors like foo@GOTOFF1 will be detected.  */
8379                 tmpbuf[first++] = ' ';
8380               else
8381                 /* Increment length by 1 if the relocation token is
8382                    removed.  */
8383                 len++;
8384               if (adjust)
8385                 *adjust = len;
8386               memcpy (tmpbuf + first, past_reloc, second);
8387               tmpbuf[first + second] = '\0';
8388               return tmpbuf;
8389             }
8390
8391           as_bad (_("@%s reloc is not supported with %d-bit output format"),
8392                   gotrel[j].str, 1 << (5 + object_64bit));
8393           return NULL;
8394         }
8395     }
8396
8397   /* Might be a symbol version string.  Don't as_bad here.  */
8398   return NULL;
8399 }
8400 #endif
8401
8402 #ifdef TE_PE
8403 #ifdef lex_got
8404 #undef lex_got
8405 #endif
8406 /* Parse operands of the form
8407    <symbol>@SECREL32+<nnn>
8408
8409    If we find one, set up the correct relocation in RELOC and copy the
8410    input string, minus the `@SECREL32' into a malloc'd buffer for
8411    parsing by the calling routine.  Return this buffer, and if ADJUST
8412    is non-null set it to the length of the string we removed from the
8413    input line.  Otherwise return NULL.
8414
8415    This function is copied from the ELF version above adjusted for PE targets.  */
8416
8417 static char *
8418 lex_got (enum bfd_reloc_code_real *rel ATTRIBUTE_UNUSED,
8419          int *adjust ATTRIBUTE_UNUSED,
8420          i386_operand_type *types)
8421 {
8422   static const struct
8423   {
8424     const char *str;
8425     int len;
8426     const enum bfd_reloc_code_real rel[2];
8427     const i386_operand_type types64;
8428   }
8429   gotrel[] =
8430   {
8431     { STRING_COMMA_LEN ("SECREL32"),    { BFD_RELOC_32_SECREL,
8432                                           BFD_RELOC_32_SECREL },
8433       OPERAND_TYPE_IMM32_32S_64_DISP32_64 },
8434   };
8435
8436   char *cp;
8437   unsigned j;
8438
8439   for (cp = input_line_pointer; *cp != '@'; cp++)
8440     if (is_end_of_line[(unsigned char) *cp] || *cp == ',')
8441       return NULL;
8442
8443   for (j = 0; j < ARRAY_SIZE (gotrel); j++)
8444     {
8445       int len = gotrel[j].len;
8446
8447       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
8448         {
8449           if (gotrel[j].rel[object_64bit] != 0)
8450             {
8451               int first, second;
8452               char *tmpbuf, *past_reloc;
8453
8454               *rel = gotrel[j].rel[object_64bit];
8455               if (adjust)
8456                 *adjust = len;
8457
8458               if (types)
8459                 {
8460                   if (flag_code != CODE_64BIT)
8461                     {
8462                       types->bitfield.imm32 = 1;
8463                       types->bitfield.disp32 = 1;
8464                     }
8465                   else
8466                     *types = gotrel[j].types64;
8467                 }
8468
8469               /* The length of the first part of our input line.  */
8470               first = cp - input_line_pointer;
8471
8472               /* The second part goes from after the reloc token until
8473                  (and including) an end_of_line char or comma.  */
8474               past_reloc = cp + 1 + len;
8475               cp = past_reloc;
8476               while (!is_end_of_line[(unsigned char) *cp] && *cp != ',')
8477                 ++cp;
8478               second = cp + 1 - past_reloc;
8479
8480               /* Allocate and copy string.  The trailing NUL shouldn't
8481                  be necessary, but be safe.  */
8482               tmpbuf = XNEWVEC (char, first + second + 2);
8483               memcpy (tmpbuf, input_line_pointer, first);
8484               if (second != 0 && *past_reloc != ' ')
8485                 /* Replace the relocation token with ' ', so that
8486                    errors like foo@SECLREL321 will be detected.  */
8487                 tmpbuf[first++] = ' ';
8488               memcpy (tmpbuf + first, past_reloc, second);
8489               tmpbuf[first + second] = '\0';
8490               return tmpbuf;
8491             }
8492
8493           as_bad (_("@%s reloc is not supported with %d-bit output format"),
8494                   gotrel[j].str, 1 << (5 + object_64bit));
8495           return NULL;
8496         }
8497     }
8498
8499   /* Might be a symbol version string.  Don't as_bad here.  */
8500   return NULL;
8501 }
8502
8503 #endif /* TE_PE */
8504
8505 bfd_reloc_code_real_type
8506 x86_cons (expressionS *exp, int size)
8507 {
8508   bfd_reloc_code_real_type got_reloc = NO_RELOC;
8509
8510   intel_syntax = -intel_syntax;
8511
8512   exp->X_md = 0;
8513   if (size == 4 || (object_64bit && size == 8))
8514     {
8515       /* Handle @GOTOFF and the like in an expression.  */
8516       char *save;
8517       char *gotfree_input_line;
8518       int adjust = 0;
8519
8520       save = input_line_pointer;
8521       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
8522       if (gotfree_input_line)
8523         input_line_pointer = gotfree_input_line;
8524
8525       expression (exp);
8526
8527       if (gotfree_input_line)
8528         {
8529           /* expression () has merrily parsed up to the end of line,
8530              or a comma - in the wrong buffer.  Transfer how far
8531              input_line_pointer has moved to the right buffer.  */
8532           input_line_pointer = (save
8533                                 + (input_line_pointer - gotfree_input_line)
8534                                 + adjust);
8535           free (gotfree_input_line);
8536           if (exp->X_op == O_constant
8537               || exp->X_op == O_absent
8538               || exp->X_op == O_illegal
8539               || exp->X_op == O_register
8540               || exp->X_op == O_big)
8541             {
8542               char c = *input_line_pointer;
8543               *input_line_pointer = 0;
8544               as_bad (_("missing or invalid expression `%s'"), save);
8545               *input_line_pointer = c;
8546             }
8547         }
8548     }
8549   else
8550     expression (exp);
8551
8552   intel_syntax = -intel_syntax;
8553
8554   if (intel_syntax)
8555     i386_intel_simplify (exp);
8556
8557   return got_reloc;
8558 }
8559
8560 static void
8561 signed_cons (int size)
8562 {
8563   if (flag_code == CODE_64BIT)
8564     cons_sign = 1;
8565   cons (size);
8566   cons_sign = -1;
8567 }
8568
8569 #ifdef TE_PE
8570 static void
8571 pe_directive_secrel (int dummy ATTRIBUTE_UNUSED)
8572 {
8573   expressionS exp;
8574
8575   do
8576     {
8577       expression (&exp);
8578       if (exp.X_op == O_symbol)
8579         exp.X_op = O_secrel;
8580
8581       emit_expr (&exp, 4);
8582     }
8583   while (*input_line_pointer++ == ',');
8584
8585   input_line_pointer--;
8586   demand_empty_rest_of_line ();
8587 }
8588 #endif
8589
8590 /* Handle Vector operations.  */
8591
8592 static char *
8593 check_VecOperations (char *op_string, char *op_end)
8594 {
8595   const reg_entry *mask;
8596   const char *saved;
8597   char *end_op;
8598
8599   while (*op_string
8600          && (op_end == NULL || op_string < op_end))
8601     {
8602       saved = op_string;
8603       if (*op_string == '{')
8604         {
8605           op_string++;
8606
8607           /* Check broadcasts.  */
8608           if (strncmp (op_string, "1to", 3) == 0)
8609             {
8610               int bcst_type;
8611
8612               if (i.broadcast)
8613                 goto duplicated_vec_op;
8614
8615               op_string += 3;
8616               if (*op_string == '8')
8617                 bcst_type = 8;
8618               else if (*op_string == '4')
8619                 bcst_type = 4;
8620               else if (*op_string == '2')
8621                 bcst_type = 2;
8622               else if (*op_string == '1'
8623                        && *(op_string+1) == '6')
8624                 {
8625                   bcst_type = 16;
8626                   op_string++;
8627                 }
8628               else
8629                 {
8630                   as_bad (_("Unsupported broadcast: `%s'"), saved);
8631                   return NULL;
8632                 }
8633               op_string++;
8634
8635               broadcast_op.type = bcst_type;
8636               broadcast_op.operand = this_operand;
8637               broadcast_op.bytes = 0;
8638               i.broadcast = &broadcast_op;
8639             }
8640           /* Check masking operation.  */
8641           else if ((mask = parse_register (op_string, &end_op)) != NULL)
8642             {
8643               /* k0 can't be used for write mask.  */
8644               if (!mask->reg_type.bitfield.regmask || mask->reg_num == 0)
8645                 {
8646                   as_bad (_("`%s%s' can't be used for write mask"),
8647                           register_prefix, mask->reg_name);
8648                   return NULL;
8649                 }
8650
8651               if (!i.mask)
8652                 {
8653                   mask_op.mask = mask;
8654                   mask_op.zeroing = 0;
8655                   mask_op.operand = this_operand;
8656                   i.mask = &mask_op;
8657                 }
8658               else
8659                 {
8660                   if (i.mask->mask)
8661                     goto duplicated_vec_op;
8662
8663                   i.mask->mask = mask;
8664
8665                   /* Only "{z}" is allowed here.  No need to check
8666                      zeroing mask explicitly.  */
8667                   if (i.mask->operand != this_operand)
8668                     {
8669                       as_bad (_("invalid write mask `%s'"), saved);
8670                       return NULL;
8671                     }
8672                 }
8673
8674               op_string = end_op;
8675             }
8676           /* Check zeroing-flag for masking operation.  */
8677           else if (*op_string == 'z')
8678             {
8679               if (!i.mask)
8680                 {
8681                   mask_op.mask = NULL;
8682                   mask_op.zeroing = 1;
8683                   mask_op.operand = this_operand;
8684                   i.mask = &mask_op;
8685                 }
8686               else
8687                 {
8688                   if (i.mask->zeroing)
8689                     {
8690                     duplicated_vec_op:
8691                       as_bad (_("duplicated `%s'"), saved);
8692                       return NULL;
8693                     }
8694
8695                   i.mask->zeroing = 1;
8696
8697                   /* Only "{%k}" is allowed here.  No need to check mask
8698                      register explicitly.  */
8699                   if (i.mask->operand != this_operand)
8700                     {
8701                       as_bad (_("invalid zeroing-masking `%s'"),
8702                               saved);
8703                       return NULL;
8704                     }
8705                 }
8706
8707               op_string++;
8708             }
8709           else
8710             goto unknown_vec_op;
8711
8712           if (*op_string != '}')
8713             {
8714               as_bad (_("missing `}' in `%s'"), saved);
8715               return NULL;
8716             }
8717           op_string++;
8718
8719           /* Strip whitespace since the addition of pseudo prefixes
8720              changed how the scrubber treats '{'.  */
8721           if (is_space_char (*op_string))
8722             ++op_string;
8723
8724           continue;
8725         }
8726     unknown_vec_op:
8727       /* We don't know this one.  */
8728       as_bad (_("unknown vector operation: `%s'"), saved);
8729       return NULL;
8730     }
8731
8732   if (i.mask && i.mask->zeroing && !i.mask->mask)
8733     {
8734       as_bad (_("zeroing-masking only allowed with write mask"));
8735       return NULL;
8736     }
8737
8738   return op_string;
8739 }
8740
8741 static int
8742 i386_immediate (char *imm_start)
8743 {
8744   char *save_input_line_pointer;
8745   char *gotfree_input_line;
8746   segT exp_seg = 0;
8747   expressionS *exp;
8748   i386_operand_type types;
8749
8750   operand_type_set (&types, ~0);
8751
8752   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
8753     {
8754       as_bad (_("at most %d immediate operands are allowed"),
8755               MAX_IMMEDIATE_OPERANDS);
8756       return 0;
8757     }
8758
8759   exp = &im_expressions[i.imm_operands++];
8760   i.op[this_operand].imms = exp;
8761
8762   if (is_space_char (*imm_start))
8763     ++imm_start;
8764
8765   save_input_line_pointer = input_line_pointer;
8766   input_line_pointer = imm_start;
8767
8768   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
8769   if (gotfree_input_line)
8770     input_line_pointer = gotfree_input_line;
8771
8772   exp_seg = expression (exp);
8773
8774   SKIP_WHITESPACE ();
8775
8776   /* Handle vector operations.  */
8777   if (*input_line_pointer == '{')
8778     {
8779       input_line_pointer = check_VecOperations (input_line_pointer,
8780                                                 NULL);
8781       if (input_line_pointer == NULL)
8782         return 0;
8783     }
8784
8785   if (*input_line_pointer)
8786     as_bad (_("junk `%s' after expression"), input_line_pointer);
8787
8788   input_line_pointer = save_input_line_pointer;
8789   if (gotfree_input_line)
8790     {
8791       free (gotfree_input_line);
8792
8793       if (exp->X_op == O_constant || exp->X_op == O_register)
8794         exp->X_op = O_illegal;
8795     }
8796
8797   return i386_finalize_immediate (exp_seg, exp, types, imm_start);
8798 }
8799
8800 static int
8801 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
8802                          i386_operand_type types, const char *imm_start)
8803 {
8804   if (exp->X_op == O_absent || exp->X_op == O_illegal || exp->X_op == O_big)
8805     {
8806       if (imm_start)
8807         as_bad (_("missing or invalid immediate expression `%s'"),
8808                 imm_start);
8809       return 0;
8810     }
8811   else if (exp->X_op == O_constant)
8812     {
8813       /* Size it properly later.  */
8814       i.types[this_operand].bitfield.imm64 = 1;
8815       /* If not 64bit, sign extend val.  */
8816       if (flag_code != CODE_64BIT
8817           && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
8818         exp->X_add_number
8819           = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
8820     }
8821 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
8822   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
8823            && exp_seg != absolute_section
8824            && exp_seg != text_section
8825            && exp_seg != data_section
8826            && exp_seg != bss_section
8827            && exp_seg != undefined_section
8828            && !bfd_is_com_section (exp_seg))
8829     {
8830       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
8831       return 0;
8832     }
8833 #endif
8834   else if (!intel_syntax && exp_seg == reg_section)
8835     {
8836       if (imm_start)
8837         as_bad (_("illegal immediate register operand %s"), imm_start);
8838       return 0;
8839     }
8840   else
8841     {
8842       /* This is an address.  The size of the address will be
8843          determined later, depending on destination register,
8844          suffix, or the default for the section.  */
8845       i.types[this_operand].bitfield.imm8 = 1;
8846       i.types[this_operand].bitfield.imm16 = 1;
8847       i.types[this_operand].bitfield.imm32 = 1;
8848       i.types[this_operand].bitfield.imm32s = 1;
8849       i.types[this_operand].bitfield.imm64 = 1;
8850       i.types[this_operand] = operand_type_and (i.types[this_operand],
8851                                                 types);
8852     }
8853
8854   return 1;
8855 }
8856
8857 static char *
8858 i386_scale (char *scale)
8859 {
8860   offsetT val;
8861   char *save = input_line_pointer;
8862
8863   input_line_pointer = scale;
8864   val = get_absolute_expression ();
8865
8866   switch (val)
8867     {
8868     case 1:
8869       i.log2_scale_factor = 0;
8870       break;
8871     case 2:
8872       i.log2_scale_factor = 1;
8873       break;
8874     case 4:
8875       i.log2_scale_factor = 2;
8876       break;
8877     case 8:
8878       i.log2_scale_factor = 3;
8879       break;
8880     default:
8881       {
8882         char sep = *input_line_pointer;
8883
8884         *input_line_pointer = '\0';
8885         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
8886                 scale);
8887         *input_line_pointer = sep;
8888         input_line_pointer = save;
8889         return NULL;
8890       }
8891     }
8892   if (i.log2_scale_factor != 0 && i.index_reg == 0)
8893     {
8894       as_warn (_("scale factor of %d without an index register"),
8895                1 << i.log2_scale_factor);
8896       i.log2_scale_factor = 0;
8897     }
8898   scale = input_line_pointer;
8899   input_line_pointer = save;
8900   return scale;
8901 }
8902
8903 static int
8904 i386_displacement (char *disp_start, char *disp_end)
8905 {
8906   expressionS *exp;
8907   segT exp_seg = 0;
8908   char *save_input_line_pointer;
8909   char *gotfree_input_line;
8910   int override;
8911   i386_operand_type bigdisp, types = anydisp;
8912   int ret;
8913
8914   if (i.disp_operands == MAX_MEMORY_OPERANDS)
8915     {
8916       as_bad (_("at most %d displacement operands are allowed"),
8917               MAX_MEMORY_OPERANDS);
8918       return 0;
8919     }
8920
8921   operand_type_set (&bigdisp, 0);
8922   if ((i.types[this_operand].bitfield.jumpabsolute)
8923       || (!current_templates->start->opcode_modifier.jump
8924           && !current_templates->start->opcode_modifier.jumpdword))
8925     {
8926       bigdisp.bitfield.disp32 = 1;
8927       override = (i.prefix[ADDR_PREFIX] != 0);
8928       if (flag_code == CODE_64BIT)
8929         {
8930           if (!override)
8931             {
8932               bigdisp.bitfield.disp32s = 1;
8933               bigdisp.bitfield.disp64 = 1;
8934             }
8935         }
8936       else if ((flag_code == CODE_16BIT) ^ override)
8937         {
8938           bigdisp.bitfield.disp32 = 0;
8939           bigdisp.bitfield.disp16 = 1;
8940         }
8941     }
8942   else
8943     {
8944       /* For PC-relative branches, the width of the displacement
8945          is dependent upon data size, not address size.  */
8946       override = (i.prefix[DATA_PREFIX] != 0);
8947       if (flag_code == CODE_64BIT)
8948         {
8949           if (override || i.suffix == WORD_MNEM_SUFFIX)
8950             bigdisp.bitfield.disp16 = 1;
8951           else
8952             {
8953               bigdisp.bitfield.disp32 = 1;
8954               bigdisp.bitfield.disp32s = 1;
8955             }
8956         }
8957       else
8958         {
8959           if (!override)
8960             override = (i.suffix == (flag_code != CODE_16BIT
8961                                      ? WORD_MNEM_SUFFIX
8962                                      : LONG_MNEM_SUFFIX));
8963           bigdisp.bitfield.disp32 = 1;
8964           if ((flag_code == CODE_16BIT) ^ override)
8965             {
8966               bigdisp.bitfield.disp32 = 0;
8967               bigdisp.bitfield.disp16 = 1;
8968             }
8969         }
8970     }
8971   i.types[this_operand] = operand_type_or (i.types[this_operand],
8972                                            bigdisp);
8973
8974   exp = &disp_expressions[i.disp_operands];
8975   i.op[this_operand].disps = exp;
8976   i.disp_operands++;
8977   save_input_line_pointer = input_line_pointer;
8978   input_line_pointer = disp_start;
8979   END_STRING_AND_SAVE (disp_end);
8980
8981 #ifndef GCC_ASM_O_HACK
8982 #define GCC_ASM_O_HACK 0
8983 #endif
8984 #if GCC_ASM_O_HACK
8985   END_STRING_AND_SAVE (disp_end + 1);
8986   if (i.types[this_operand].bitfield.baseIndex
8987       && displacement_string_end[-1] == '+')
8988     {
8989       /* This hack is to avoid a warning when using the "o"
8990          constraint within gcc asm statements.
8991          For instance:
8992
8993          #define _set_tssldt_desc(n,addr,limit,type) \
8994          __asm__ __volatile__ ( \
8995          "movw %w2,%0\n\t" \
8996          "movw %w1,2+%0\n\t" \
8997          "rorl $16,%1\n\t" \
8998          "movb %b1,4+%0\n\t" \
8999          "movb %4,5+%0\n\t" \
9000          "movb $0,6+%0\n\t" \
9001          "movb %h1,7+%0\n\t" \
9002          "rorl $16,%1" \
9003          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
9004
9005          This works great except that the output assembler ends
9006          up looking a bit weird if it turns out that there is
9007          no offset.  You end up producing code that looks like:
9008
9009          #APP
9010          movw $235,(%eax)
9011          movw %dx,2+(%eax)
9012          rorl $16,%edx
9013          movb %dl,4+(%eax)
9014          movb $137,5+(%eax)
9015          movb $0,6+(%eax)
9016          movb %dh,7+(%eax)
9017          rorl $16,%edx
9018          #NO_APP
9019
9020          So here we provide the missing zero.  */
9021
9022       *displacement_string_end = '0';
9023     }
9024 #endif
9025   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
9026   if (gotfree_input_line)
9027     input_line_pointer = gotfree_input_line;
9028
9029   exp_seg = expression (exp);
9030
9031   SKIP_WHITESPACE ();
9032   if (*input_line_pointer)
9033     as_bad (_("junk `%s' after expression"), input_line_pointer);
9034 #if GCC_ASM_O_HACK
9035   RESTORE_END_STRING (disp_end + 1);
9036 #endif
9037   input_line_pointer = save_input_line_pointer;
9038   if (gotfree_input_line)
9039     {
9040       free (gotfree_input_line);
9041
9042       if (exp->X_op == O_constant || exp->X_op == O_register)
9043         exp->X_op = O_illegal;
9044     }
9045
9046   ret = i386_finalize_displacement (exp_seg, exp, types, disp_start);
9047
9048   RESTORE_END_STRING (disp_end);
9049
9050   return ret;
9051 }
9052
9053 static int
9054 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED, expressionS *exp,
9055                             i386_operand_type types, const char *disp_start)
9056 {
9057   i386_operand_type bigdisp;
9058   int ret = 1;
9059
9060   /* We do this to make sure that the section symbol is in
9061      the symbol table.  We will ultimately change the relocation
9062      to be relative to the beginning of the section.  */
9063   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
9064       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
9065       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
9066     {
9067       if (exp->X_op != O_symbol)
9068         goto inv_disp;
9069
9070       if (S_IS_LOCAL (exp->X_add_symbol)
9071           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section
9072           && S_GET_SEGMENT (exp->X_add_symbol) != expr_section)
9073         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
9074       exp->X_op = O_subtract;
9075       exp->X_op_symbol = GOT_symbol;
9076       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
9077         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
9078       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
9079         i.reloc[this_operand] = BFD_RELOC_64;
9080       else
9081         i.reloc[this_operand] = BFD_RELOC_32;
9082     }
9083
9084   else if (exp->X_op == O_absent
9085            || exp->X_op == O_illegal
9086            || exp->X_op == O_big)
9087     {
9088     inv_disp:
9089       as_bad (_("missing or invalid displacement expression `%s'"),
9090               disp_start);
9091       ret = 0;
9092     }
9093
9094   else if (flag_code == CODE_64BIT
9095            && !i.prefix[ADDR_PREFIX]
9096            && exp->X_op == O_constant)
9097     {
9098       /* Since displacement is signed extended to 64bit, don't allow
9099          disp32 and turn off disp32s if they are out of range.  */
9100       i.types[this_operand].bitfield.disp32 = 0;
9101       if (!fits_in_signed_long (exp->X_add_number))
9102         {
9103           i.types[this_operand].bitfield.disp32s = 0;
9104           if (i.types[this_operand].bitfield.baseindex)
9105             {
9106               as_bad (_("0x%lx out range of signed 32bit displacement"),
9107                       (long) exp->X_add_number);
9108               ret = 0;
9109             }
9110         }
9111     }
9112
9113 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
9114   else if (exp->X_op != O_constant
9115            && OUTPUT_FLAVOR == bfd_target_aout_flavour
9116            && exp_seg != absolute_section
9117            && exp_seg != text_section
9118            && exp_seg != data_section
9119            && exp_seg != bss_section
9120            && exp_seg != undefined_section
9121            && !bfd_is_com_section (exp_seg))
9122     {
9123       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
9124       ret = 0;
9125     }
9126 #endif
9127
9128   /* Check if this is a displacement only operand.  */
9129   bigdisp = i.types[this_operand];
9130   bigdisp.bitfield.disp8 = 0;
9131   bigdisp.bitfield.disp16 = 0;
9132   bigdisp.bitfield.disp32 = 0;
9133   bigdisp.bitfield.disp32s = 0;
9134   bigdisp.bitfield.disp64 = 0;
9135   if (operand_type_all_zero (&bigdisp))
9136     i.types[this_operand] = operand_type_and (i.types[this_operand],
9137                                               types);
9138
9139   return ret;
9140 }
9141
9142 /* Return the active addressing mode, taking address override and
9143    registers forming the address into consideration.  Update the
9144    address override prefix if necessary.  */
9145
9146 static enum flag_code
9147 i386_addressing_mode (void)
9148 {
9149   enum flag_code addr_mode;
9150
9151   if (i.prefix[ADDR_PREFIX])
9152     addr_mode = flag_code == CODE_32BIT ? CODE_16BIT : CODE_32BIT;
9153   else
9154     {
9155       addr_mode = flag_code;
9156
9157 #if INFER_ADDR_PREFIX
9158       if (i.mem_operands == 0)
9159         {
9160           /* Infer address prefix from the first memory operand.  */
9161           const reg_entry *addr_reg = i.base_reg;
9162
9163           if (addr_reg == NULL)
9164             addr_reg = i.index_reg;
9165
9166           if (addr_reg)
9167             {
9168               if (addr_reg->reg_num == RegEip
9169                   || addr_reg->reg_num == RegEiz
9170                   || addr_reg->reg_type.bitfield.dword)
9171                 addr_mode = CODE_32BIT;
9172               else if (flag_code != CODE_64BIT
9173                        && addr_reg->reg_type.bitfield.word)
9174                 addr_mode = CODE_16BIT;
9175
9176               if (addr_mode != flag_code)
9177                 {
9178                   i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
9179                   i.prefixes += 1;
9180                   /* Change the size of any displacement too.  At most one
9181                      of Disp16 or Disp32 is set.
9182                      FIXME.  There doesn't seem to be any real need for
9183                      separate Disp16 and Disp32 flags.  The same goes for
9184                      Imm16 and Imm32.  Removing them would probably clean
9185                      up the code quite a lot.  */
9186                   if (flag_code != CODE_64BIT
9187                       && (i.types[this_operand].bitfield.disp16
9188                           || i.types[this_operand].bitfield.disp32))
9189                     i.types[this_operand]
9190                       = operand_type_xor (i.types[this_operand], disp16_32);
9191                 }
9192             }
9193         }
9194 #endif
9195     }
9196
9197   return addr_mode;
9198 }
9199
9200 /* Make sure the memory operand we've been dealt is valid.
9201    Return 1 on success, 0 on a failure.  */
9202
9203 static int
9204 i386_index_check (const char *operand_string)
9205 {
9206   const char *kind = "base/index";
9207   enum flag_code addr_mode = i386_addressing_mode ();
9208
9209   if (current_templates->start->opcode_modifier.isstring
9210       && !current_templates->start->opcode_modifier.immext
9211       && (current_templates->end[-1].opcode_modifier.isstring
9212           || i.mem_operands))
9213     {
9214       /* Memory operands of string insns are special in that they only allow
9215          a single register (rDI, rSI, or rBX) as their memory address.  */
9216       const reg_entry *expected_reg;
9217       static const char *di_si[][2] =
9218         {
9219           { "esi", "edi" },
9220           { "si", "di" },
9221           { "rsi", "rdi" }
9222         };
9223       static const char *bx[] = { "ebx", "bx", "rbx" };
9224
9225       kind = "string address";
9226
9227       if (current_templates->start->opcode_modifier.repprefixok)
9228         {
9229           i386_operand_type type = current_templates->end[-1].operand_types[0];
9230
9231           if (!type.bitfield.baseindex
9232               || ((!i.mem_operands != !intel_syntax)
9233                   && current_templates->end[-1].operand_types[1]
9234                      .bitfield.baseindex))
9235             type = current_templates->end[-1].operand_types[1];
9236           expected_reg = hash_find (reg_hash,
9237                                     di_si[addr_mode][type.bitfield.esseg]);
9238
9239         }
9240       else
9241         expected_reg = hash_find (reg_hash, bx[addr_mode]);
9242
9243       if (i.base_reg != expected_reg
9244           || i.index_reg
9245           || operand_type_check (i.types[this_operand], disp))
9246         {
9247           /* The second memory operand must have the same size as
9248              the first one.  */
9249           if (i.mem_operands
9250               && i.base_reg
9251               && !((addr_mode == CODE_64BIT
9252                     && i.base_reg->reg_type.bitfield.qword)
9253                    || (addr_mode == CODE_32BIT
9254                        ? i.base_reg->reg_type.bitfield.dword
9255                        : i.base_reg->reg_type.bitfield.word)))
9256             goto bad_address;
9257
9258           as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
9259                    operand_string,
9260                    intel_syntax ? '[' : '(',
9261                    register_prefix,
9262                    expected_reg->reg_name,
9263                    intel_syntax ? ']' : ')');
9264           return 1;
9265         }
9266       else
9267         return 1;
9268
9269 bad_address:
9270       as_bad (_("`%s' is not a valid %s expression"),
9271               operand_string, kind);
9272       return 0;
9273     }
9274   else
9275     {
9276       if (addr_mode != CODE_16BIT)
9277         {
9278           /* 32-bit/64-bit checks.  */
9279           if ((i.base_reg
9280                && (addr_mode == CODE_64BIT
9281                    ? !i.base_reg->reg_type.bitfield.qword
9282                    : !i.base_reg->reg_type.bitfield.dword)
9283                && (i.index_reg
9284                    || (i.base_reg->reg_num
9285                        != (addr_mode == CODE_64BIT ? RegRip : RegEip))))
9286               || (i.index_reg
9287                   && !i.index_reg->reg_type.bitfield.xmmword
9288                   && !i.index_reg->reg_type.bitfield.ymmword
9289                   && !i.index_reg->reg_type.bitfield.zmmword
9290                   && ((addr_mode == CODE_64BIT
9291                        ? !(i.index_reg->reg_type.bitfield.qword
9292                            || i.index_reg->reg_num == RegRiz)
9293                        : !(i.index_reg->reg_type.bitfield.dword
9294                            || i.index_reg->reg_num == RegEiz))
9295                       || !i.index_reg->reg_type.bitfield.baseindex)))
9296             goto bad_address;
9297
9298           /* bndmk, bndldx, and bndstx have special restrictions. */
9299           if (current_templates->start->base_opcode == 0xf30f1b
9300               || (current_templates->start->base_opcode & ~1) == 0x0f1a)
9301             {
9302               /* They cannot use RIP-relative addressing. */
9303               if (i.base_reg && i.base_reg->reg_num == RegRip)
9304                 {
9305                   as_bad (_("`%s' cannot be used here"), operand_string);
9306                   return 0;
9307                 }
9308
9309               /* bndldx and bndstx ignore their scale factor. */
9310               if (current_templates->start->base_opcode != 0xf30f1b
9311                   && i.log2_scale_factor)
9312                 as_warn (_("register scaling is being ignored here"));
9313             }
9314         }
9315       else
9316         {
9317           /* 16-bit checks.  */
9318           if ((i.base_reg
9319                && (!i.base_reg->reg_type.bitfield.word
9320                    || !i.base_reg->reg_type.bitfield.baseindex))
9321               || (i.index_reg
9322                   && (!i.index_reg->reg_type.bitfield.word
9323                       || !i.index_reg->reg_type.bitfield.baseindex
9324                       || !(i.base_reg
9325                            && i.base_reg->reg_num < 6
9326                            && i.index_reg->reg_num >= 6
9327                            && i.log2_scale_factor == 0))))
9328             goto bad_address;
9329         }
9330     }
9331   return 1;
9332 }
9333
9334 /* Handle vector immediates.  */
9335
9336 static int
9337 RC_SAE_immediate (const char *imm_start)
9338 {
9339   unsigned int match_found, j;
9340   const char *pstr = imm_start;
9341   expressionS *exp;
9342
9343   if (*pstr != '{')
9344     return 0;
9345
9346   pstr++;
9347   match_found = 0;
9348   for (j = 0; j < ARRAY_SIZE (RC_NamesTable); j++)
9349     {
9350       if (!strncmp (pstr, RC_NamesTable[j].name, RC_NamesTable[j].len))
9351         {
9352           if (!i.rounding)
9353             {
9354               rc_op.type = RC_NamesTable[j].type;
9355               rc_op.operand = this_operand;
9356               i.rounding = &rc_op;
9357             }
9358           else
9359             {
9360               as_bad (_("duplicated `%s'"), imm_start);
9361               return 0;
9362             }
9363           pstr += RC_NamesTable[j].len;
9364           match_found = 1;
9365           break;
9366         }
9367     }
9368   if (!match_found)
9369     return 0;
9370
9371   if (*pstr++ != '}')
9372     {
9373       as_bad (_("Missing '}': '%s'"), imm_start);
9374       return 0;
9375     }
9376   /* RC/SAE immediate string should contain nothing more.  */;
9377   if (*pstr != 0)
9378     {
9379       as_bad (_("Junk after '}': '%s'"), imm_start);
9380       return 0;
9381     }
9382
9383   exp = &im_expressions[i.imm_operands++];
9384   i.op[this_operand].imms = exp;
9385
9386   exp->X_op = O_constant;
9387   exp->X_add_number = 0;
9388   exp->X_add_symbol = (symbolS *) 0;
9389   exp->X_op_symbol = (symbolS *) 0;
9390
9391   i.types[this_operand].bitfield.imm8 = 1;
9392   return 1;
9393 }
9394
9395 /* Only string instructions can have a second memory operand, so
9396    reduce current_templates to just those if it contains any.  */
9397 static int
9398 maybe_adjust_templates (void)
9399 {
9400   const insn_template *t;
9401
9402   gas_assert (i.mem_operands == 1);
9403
9404   for (t = current_templates->start; t < current_templates->end; ++t)
9405     if (t->opcode_modifier.isstring)
9406       break;
9407
9408   if (t < current_templates->end)
9409     {
9410       static templates aux_templates;
9411       bfd_boolean recheck;
9412
9413       aux_templates.start = t;
9414       for (; t < current_templates->end; ++t)
9415         if (!t->opcode_modifier.isstring)
9416           break;
9417       aux_templates.end = t;
9418
9419       /* Determine whether to re-check the first memory operand.  */
9420       recheck = (aux_templates.start != current_templates->start
9421                  || t != current_templates->end);
9422
9423       current_templates = &aux_templates;
9424
9425       if (recheck)
9426         {
9427           i.mem_operands = 0;
9428           if (i.memop1_string != NULL
9429               && i386_index_check (i.memop1_string) == 0)
9430             return 0;
9431           i.mem_operands = 1;
9432         }
9433     }
9434
9435   return 1;
9436 }
9437
9438 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns zero
9439    on error.  */
9440
9441 static int
9442 i386_att_operand (char *operand_string)
9443 {
9444   const reg_entry *r;
9445   char *end_op;
9446   char *op_string = operand_string;
9447
9448   if (is_space_char (*op_string))
9449     ++op_string;
9450
9451   /* We check for an absolute prefix (differentiating,
9452      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
9453   if (*op_string == ABSOLUTE_PREFIX)
9454     {
9455       ++op_string;
9456       if (is_space_char (*op_string))
9457         ++op_string;
9458       i.types[this_operand].bitfield.jumpabsolute = 1;
9459     }
9460
9461   /* Check if operand is a register.  */
9462   if ((r = parse_register (op_string, &end_op)) != NULL)
9463     {
9464       i386_operand_type temp;
9465
9466       /* Check for a segment override by searching for ':' after a
9467          segment register.  */
9468       op_string = end_op;
9469       if (is_space_char (*op_string))
9470         ++op_string;
9471       if (*op_string == ':'
9472           && (r->reg_type.bitfield.sreg2
9473               || r->reg_type.bitfield.sreg3))
9474         {
9475           switch (r->reg_num)
9476             {
9477             case 0:
9478               i.seg[i.mem_operands] = &es;
9479               break;
9480             case 1:
9481               i.seg[i.mem_operands] = &cs;
9482               break;
9483             case 2:
9484               i.seg[i.mem_operands] = &ss;
9485               break;
9486             case 3:
9487               i.seg[i.mem_operands] = &ds;
9488               break;
9489             case 4:
9490               i.seg[i.mem_operands] = &fs;
9491               break;
9492             case 5:
9493               i.seg[i.mem_operands] = &gs;
9494               break;
9495             }
9496
9497           /* Skip the ':' and whitespace.  */
9498           ++op_string;
9499           if (is_space_char (*op_string))
9500             ++op_string;
9501
9502           if (!is_digit_char (*op_string)
9503               && !is_identifier_char (*op_string)
9504               && *op_string != '('
9505               && *op_string != ABSOLUTE_PREFIX)
9506             {
9507               as_bad (_("bad memory operand `%s'"), op_string);
9508               return 0;
9509             }
9510           /* Handle case of %es:*foo.  */
9511           if (*op_string == ABSOLUTE_PREFIX)
9512             {
9513               ++op_string;
9514               if (is_space_char (*op_string))
9515                 ++op_string;
9516               i.types[this_operand].bitfield.jumpabsolute = 1;
9517             }
9518           goto do_memory_reference;
9519         }
9520
9521       /* Handle vector operations.  */
9522       if (*op_string == '{')
9523         {
9524           op_string = check_VecOperations (op_string, NULL);
9525           if (op_string == NULL)
9526             return 0;
9527         }
9528
9529       if (*op_string)
9530         {
9531           as_bad (_("junk `%s' after register"), op_string);
9532           return 0;
9533         }
9534       temp = r->reg_type;
9535       temp.bitfield.baseindex = 0;
9536       i.types[this_operand] = operand_type_or (i.types[this_operand],
9537                                                temp);
9538       i.types[this_operand].bitfield.unspecified = 0;
9539       i.op[this_operand].regs = r;
9540       i.reg_operands++;
9541     }
9542   else if (*op_string == REGISTER_PREFIX)
9543     {
9544       as_bad (_("bad register name `%s'"), op_string);
9545       return 0;
9546     }
9547   else if (*op_string == IMMEDIATE_PREFIX)
9548     {
9549       ++op_string;
9550       if (i.types[this_operand].bitfield.jumpabsolute)
9551         {
9552           as_bad (_("immediate operand illegal with absolute jump"));
9553           return 0;
9554         }
9555       if (!i386_immediate (op_string))
9556         return 0;
9557     }
9558   else if (RC_SAE_immediate (operand_string))
9559     {
9560       /* If it is a RC or SAE immediate, do nothing.  */
9561       ;
9562     }
9563   else if (is_digit_char (*op_string)
9564            || is_identifier_char (*op_string)
9565            || *op_string == '"'
9566            || *op_string == '(')
9567     {
9568       /* This is a memory reference of some sort.  */
9569       char *base_string;
9570
9571       /* Start and end of displacement string expression (if found).  */
9572       char *displacement_string_start;
9573       char *displacement_string_end;
9574       char *vop_start;
9575
9576     do_memory_reference:
9577       if (i.mem_operands == 1 && !maybe_adjust_templates ())
9578         return 0;
9579       if ((i.mem_operands == 1
9580            && !current_templates->start->opcode_modifier.isstring)
9581           || i.mem_operands == 2)
9582         {
9583           as_bad (_("too many memory references for `%s'"),
9584                   current_templates->start->name);
9585           return 0;
9586         }
9587
9588       /* Check for base index form.  We detect the base index form by
9589          looking for an ')' at the end of the operand, searching
9590          for the '(' matching it, and finding a REGISTER_PREFIX or ','
9591          after the '('.  */
9592       base_string = op_string + strlen (op_string);
9593
9594       /* Handle vector operations.  */
9595       vop_start = strchr (op_string, '{');
9596       if (vop_start && vop_start < base_string)
9597         {
9598           if (check_VecOperations (vop_start, base_string) == NULL)
9599             return 0;
9600           base_string = vop_start;
9601         }
9602
9603       --base_string;
9604       if (is_space_char (*base_string))
9605         --base_string;
9606
9607       /* If we only have a displacement, set-up for it to be parsed later.  */
9608       displacement_string_start = op_string;
9609       displacement_string_end = base_string + 1;
9610
9611       if (*base_string == ')')
9612         {
9613           char *temp_string;
9614           unsigned int parens_balanced = 1;
9615           /* We've already checked that the number of left & right ()'s are
9616              equal, so this loop will not be infinite.  */
9617           do
9618             {
9619               base_string--;
9620               if (*base_string == ')')
9621                 parens_balanced++;
9622               if (*base_string == '(')
9623                 parens_balanced--;
9624             }
9625           while (parens_balanced);
9626
9627           temp_string = base_string;
9628
9629           /* Skip past '(' and whitespace.  */
9630           ++base_string;
9631           if (is_space_char (*base_string))
9632             ++base_string;
9633
9634           if (*base_string == ','
9635               || ((i.base_reg = parse_register (base_string, &end_op))
9636                   != NULL))
9637             {
9638               displacement_string_end = temp_string;
9639
9640               i.types[this_operand].bitfield.baseindex = 1;
9641
9642               if (i.base_reg)
9643                 {
9644                   base_string = end_op;
9645                   if (is_space_char (*base_string))
9646                     ++base_string;
9647                 }
9648
9649               /* There may be an index reg or scale factor here.  */
9650               if (*base_string == ',')
9651                 {
9652                   ++base_string;
9653                   if (is_space_char (*base_string))
9654                     ++base_string;
9655
9656                   if ((i.index_reg = parse_register (base_string, &end_op))
9657                       != NULL)
9658                     {
9659                       base_string = end_op;
9660                       if (is_space_char (*base_string))
9661                         ++base_string;
9662                       if (*base_string == ',')
9663                         {
9664                           ++base_string;
9665                           if (is_space_char (*base_string))
9666                             ++base_string;
9667                         }
9668                       else if (*base_string != ')')
9669                         {
9670                           as_bad (_("expecting `,' or `)' "
9671                                     "after index register in `%s'"),
9672                                   operand_string);
9673                           return 0;
9674                         }
9675                     }
9676                   else if (*base_string == REGISTER_PREFIX)
9677                     {
9678                       end_op = strchr (base_string, ',');
9679                       if (end_op)
9680                         *end_op = '\0';
9681                       as_bad (_("bad register name `%s'"), base_string);
9682                       return 0;
9683                     }
9684
9685                   /* Check for scale factor.  */
9686                   if (*base_string != ')')
9687                     {
9688                       char *end_scale = i386_scale (base_string);
9689
9690                       if (!end_scale)
9691                         return 0;
9692
9693                       base_string = end_scale;
9694                       if (is_space_char (*base_string))
9695                         ++base_string;
9696                       if (*base_string != ')')
9697                         {
9698                           as_bad (_("expecting `)' "
9699                                     "after scale factor in `%s'"),
9700                                   operand_string);
9701                           return 0;
9702                         }
9703                     }
9704                   else if (!i.index_reg)
9705                     {
9706                       as_bad (_("expecting index register or scale factor "
9707                                 "after `,'; got '%c'"),
9708                               *base_string);
9709                       return 0;
9710                     }
9711                 }
9712               else if (*base_string != ')')
9713                 {
9714                   as_bad (_("expecting `,' or `)' "
9715                             "after base register in `%s'"),
9716                           operand_string);
9717                   return 0;
9718                 }
9719             }
9720           else if (*base_string == REGISTER_PREFIX)
9721             {
9722               end_op = strchr (base_string, ',');
9723               if (end_op)
9724                 *end_op = '\0';
9725               as_bad (_("bad register name `%s'"), base_string);
9726               return 0;
9727             }
9728         }
9729
9730       /* If there's an expression beginning the operand, parse it,
9731          assuming displacement_string_start and
9732          displacement_string_end are meaningful.  */
9733       if (displacement_string_start != displacement_string_end)
9734         {
9735           if (!i386_displacement (displacement_string_start,
9736                                   displacement_string_end))
9737             return 0;
9738         }
9739
9740       /* Special case for (%dx) while doing input/output op.  */
9741       if (i.base_reg
9742           && i.base_reg->reg_type.bitfield.inoutportreg
9743           && i.index_reg == 0
9744           && i.log2_scale_factor == 0
9745           && i.seg[i.mem_operands] == 0
9746           && !operand_type_check (i.types[this_operand], disp))
9747         {
9748           i.types[this_operand] = i.base_reg->reg_type;
9749           return 1;
9750         }
9751
9752       if (i386_index_check (operand_string) == 0)
9753         return 0;
9754       i.types[this_operand].bitfield.mem = 1;
9755       if (i.mem_operands == 0)
9756         i.memop1_string = xstrdup (operand_string);
9757       i.mem_operands++;
9758     }
9759   else
9760     {
9761       /* It's not a memory operand; argh!  */
9762       as_bad (_("invalid char %s beginning operand %d `%s'"),
9763               output_invalid (*op_string),
9764               this_operand + 1,
9765               op_string);
9766       return 0;
9767     }
9768   return 1;                     /* Normal return.  */
9769 }
9770 \f
9771 /* Calculate the maximum variable size (i.e., excluding fr_fix)
9772    that an rs_machine_dependent frag may reach.  */
9773
9774 unsigned int
9775 i386_frag_max_var (fragS *frag)
9776 {
9777   /* The only relaxable frags are for jumps.
9778      Unconditional jumps can grow by 4 bytes and others by 5 bytes.  */
9779   gas_assert (frag->fr_type == rs_machine_dependent);
9780   return TYPE_FROM_RELAX_STATE (frag->fr_subtype) == UNCOND_JUMP ? 4 : 5;
9781 }
9782
9783 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9784 static int
9785 elf_symbol_resolved_in_segment_p (symbolS *fr_symbol, offsetT fr_var)
9786 {
9787   /* STT_GNU_IFUNC symbol must go through PLT.  */
9788   if ((symbol_get_bfdsym (fr_symbol)->flags
9789        & BSF_GNU_INDIRECT_FUNCTION) != 0)
9790     return 0;
9791
9792   if (!S_IS_EXTERNAL (fr_symbol))
9793     /* Symbol may be weak or local.  */
9794     return !S_IS_WEAK (fr_symbol);
9795
9796   /* Global symbols with non-default visibility can't be preempted. */
9797   if (ELF_ST_VISIBILITY (S_GET_OTHER (fr_symbol)) != STV_DEFAULT)
9798     return 1;
9799
9800   if (fr_var != NO_RELOC)
9801     switch ((enum bfd_reloc_code_real) fr_var)
9802       {
9803       case BFD_RELOC_386_PLT32:
9804       case BFD_RELOC_X86_64_PLT32:
9805         /* Symbol with PLT relocation may be preempted. */
9806         return 0;
9807       default:
9808         abort ();
9809       }
9810
9811   /* Global symbols with default visibility in a shared library may be
9812      preempted by another definition.  */
9813   return !shared;
9814 }
9815 #endif
9816
9817 /* md_estimate_size_before_relax()
9818
9819    Called just before relax() for rs_machine_dependent frags.  The x86
9820    assembler uses these frags to handle variable size jump
9821    instructions.
9822
9823    Any symbol that is now undefined will not become defined.
9824    Return the correct fr_subtype in the frag.
9825    Return the initial "guess for variable size of frag" to caller.
9826    The guess is actually the growth beyond the fixed part.  Whatever
9827    we do to grow the fixed or variable part contributes to our
9828    returned value.  */
9829
9830 int
9831 md_estimate_size_before_relax (fragS *fragP, segT segment)
9832 {
9833   /* We've already got fragP->fr_subtype right;  all we have to do is
9834      check for un-relaxable symbols.  On an ELF system, we can't relax
9835      an externally visible symbol, because it may be overridden by a
9836      shared library.  */
9837   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
9838 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9839       || (IS_ELF
9840           && !elf_symbol_resolved_in_segment_p (fragP->fr_symbol,
9841                                                 fragP->fr_var))
9842 #endif
9843 #if defined (OBJ_COFF) && defined (TE_PE)
9844       || (OUTPUT_FLAVOR == bfd_target_coff_flavour
9845           && S_IS_WEAK (fragP->fr_symbol))
9846 #endif
9847       )
9848     {
9849       /* Symbol is undefined in this segment, or we need to keep a
9850          reloc so that weak symbols can be overridden.  */
9851       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
9852       enum bfd_reloc_code_real reloc_type;
9853       unsigned char *opcode;
9854       int old_fr_fix;
9855
9856       if (fragP->fr_var != NO_RELOC)
9857         reloc_type = (enum bfd_reloc_code_real) fragP->fr_var;
9858       else if (size == 2)
9859         reloc_type = BFD_RELOC_16_PCREL;
9860 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
9861       else if (need_plt32_p (fragP->fr_symbol))
9862         reloc_type = BFD_RELOC_X86_64_PLT32;
9863 #endif
9864       else
9865         reloc_type = BFD_RELOC_32_PCREL;
9866
9867       old_fr_fix = fragP->fr_fix;
9868       opcode = (unsigned char *) fragP->fr_opcode;
9869
9870       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
9871         {
9872         case UNCOND_JUMP:
9873           /* Make jmp (0xeb) a (d)word displacement jump.  */
9874           opcode[0] = 0xe9;
9875           fragP->fr_fix += size;
9876           fix_new (fragP, old_fr_fix, size,
9877                    fragP->fr_symbol,
9878                    fragP->fr_offset, 1,
9879                    reloc_type);
9880           break;
9881
9882         case COND_JUMP86:
9883           if (size == 2
9884               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
9885             {
9886               /* Negate the condition, and branch past an
9887                  unconditional jump.  */
9888               opcode[0] ^= 1;
9889               opcode[1] = 3;
9890               /* Insert an unconditional jump.  */
9891               opcode[2] = 0xe9;
9892               /* We added two extra opcode bytes, and have a two byte
9893                  offset.  */
9894               fragP->fr_fix += 2 + 2;
9895               fix_new (fragP, old_fr_fix + 2, 2,
9896                        fragP->fr_symbol,
9897                        fragP->fr_offset, 1,
9898                        reloc_type);
9899               break;
9900             }
9901           /* Fall through.  */
9902
9903         case COND_JUMP:
9904           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
9905             {
9906               fixS *fixP;
9907
9908               fragP->fr_fix += 1;
9909               fixP = fix_new (fragP, old_fr_fix, 1,
9910                               fragP->fr_symbol,
9911                               fragP->fr_offset, 1,
9912                               BFD_RELOC_8_PCREL);
9913               fixP->fx_signed = 1;
9914               break;
9915             }
9916
9917           /* This changes the byte-displacement jump 0x7N
9918              to the (d)word-displacement jump 0x0f,0x8N.  */
9919           opcode[1] = opcode[0] + 0x10;
9920           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
9921           /* We've added an opcode byte.  */
9922           fragP->fr_fix += 1 + size;
9923           fix_new (fragP, old_fr_fix + 1, size,
9924                    fragP->fr_symbol,
9925                    fragP->fr_offset, 1,
9926                    reloc_type);
9927           break;
9928
9929         default:
9930           BAD_CASE (fragP->fr_subtype);
9931           break;
9932         }
9933       frag_wane (fragP);
9934       return fragP->fr_fix - old_fr_fix;
9935     }
9936
9937   /* Guess size depending on current relax state.  Initially the relax
9938      state will correspond to a short jump and we return 1, because
9939      the variable part of the frag (the branch offset) is one byte
9940      long.  However, we can relax a section more than once and in that
9941      case we must either set fr_subtype back to the unrelaxed state,
9942      or return the value for the appropriate branch.  */
9943   return md_relax_table[fragP->fr_subtype].rlx_length;
9944 }
9945
9946 /* Called after relax() is finished.
9947
9948    In:  Address of frag.
9949         fr_type == rs_machine_dependent.
9950         fr_subtype is what the address relaxed to.
9951
9952    Out: Any fixSs and constants are set up.
9953         Caller will turn frag into a ".space 0".  */
9954
9955 void
9956 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, segT sec ATTRIBUTE_UNUSED,
9957                  fragS *fragP)
9958 {
9959   unsigned char *opcode;
9960   unsigned char *where_to_put_displacement = NULL;
9961   offsetT target_address;
9962   offsetT opcode_address;
9963   unsigned int extension = 0;
9964   offsetT displacement_from_opcode_start;
9965
9966   opcode = (unsigned char *) fragP->fr_opcode;
9967
9968   /* Address we want to reach in file space.  */
9969   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
9970
9971   /* Address opcode resides at in file space.  */
9972   opcode_address = fragP->fr_address + fragP->fr_fix;
9973
9974   /* Displacement from opcode start to fill into instruction.  */
9975   displacement_from_opcode_start = target_address - opcode_address;
9976
9977   if ((fragP->fr_subtype & BIG) == 0)
9978     {
9979       /* Don't have to change opcode.  */
9980       extension = 1;            /* 1 opcode + 1 displacement  */
9981       where_to_put_displacement = &opcode[1];
9982     }
9983   else
9984     {
9985       if (no_cond_jump_promotion
9986           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
9987         as_warn_where (fragP->fr_file, fragP->fr_line,
9988                        _("long jump required"));
9989
9990       switch (fragP->fr_subtype)
9991         {
9992         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
9993           extension = 4;                /* 1 opcode + 4 displacement  */
9994           opcode[0] = 0xe9;
9995           where_to_put_displacement = &opcode[1];
9996           break;
9997
9998         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
9999           extension = 2;                /* 1 opcode + 2 displacement  */
10000           opcode[0] = 0xe9;
10001           where_to_put_displacement = &opcode[1];
10002           break;
10003
10004         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
10005         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
10006           extension = 5;                /* 2 opcode + 4 displacement  */
10007           opcode[1] = opcode[0] + 0x10;
10008           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10009           where_to_put_displacement = &opcode[2];
10010           break;
10011
10012         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
10013           extension = 3;                /* 2 opcode + 2 displacement  */
10014           opcode[1] = opcode[0] + 0x10;
10015           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
10016           where_to_put_displacement = &opcode[2];
10017           break;
10018
10019         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
10020           extension = 4;
10021           opcode[0] ^= 1;
10022           opcode[1] = 3;
10023           opcode[2] = 0xe9;
10024           where_to_put_displacement = &opcode[3];
10025           break;
10026
10027         default:
10028           BAD_CASE (fragP->fr_subtype);
10029           break;
10030         }
10031     }
10032
10033   /* If size if less then four we are sure that the operand fits,
10034      but if it's 4, then it could be that the displacement is larger
10035      then -/+ 2GB.  */
10036   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
10037       && object_64bit
10038       && ((addressT) (displacement_from_opcode_start - extension
10039                       + ((addressT) 1 << 31))
10040           > (((addressT) 2 << 31) - 1)))
10041     {
10042       as_bad_where (fragP->fr_file, fragP->fr_line,
10043                     _("jump target out of range"));
10044       /* Make us emit 0.  */
10045       displacement_from_opcode_start = extension;
10046     }
10047   /* Now put displacement after opcode.  */
10048   md_number_to_chars ((char *) where_to_put_displacement,
10049                       (valueT) (displacement_from_opcode_start - extension),
10050                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
10051   fragP->fr_fix += extension;
10052 }
10053 \f
10054 /* Apply a fixup (fixP) to segment data, once it has been determined
10055    by our caller that we have all the info we need to fix it up.
10056
10057    Parameter valP is the pointer to the value of the bits.
10058
10059    On the 386, immediates, displacements, and data pointers are all in
10060    the same (little-endian) format, so we don't need to care about which
10061    we are handling.  */
10062
10063 void
10064 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
10065 {
10066   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
10067   valueT value = *valP;
10068
10069 #if !defined (TE_Mach)
10070   if (fixP->fx_pcrel)
10071     {
10072       switch (fixP->fx_r_type)
10073         {
10074         default:
10075           break;
10076
10077         case BFD_RELOC_64:
10078           fixP->fx_r_type = BFD_RELOC_64_PCREL;
10079           break;
10080         case BFD_RELOC_32:
10081         case BFD_RELOC_X86_64_32S:
10082           fixP->fx_r_type = BFD_RELOC_32_PCREL;
10083           break;
10084         case BFD_RELOC_16:
10085           fixP->fx_r_type = BFD_RELOC_16_PCREL;
10086           break;
10087         case BFD_RELOC_8:
10088           fixP->fx_r_type = BFD_RELOC_8_PCREL;
10089           break;
10090         }
10091     }
10092
10093   if (fixP->fx_addsy != NULL
10094       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
10095           || fixP->fx_r_type == BFD_RELOC_64_PCREL
10096           || fixP->fx_r_type == BFD_RELOC_16_PCREL
10097           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
10098       && !use_rela_relocations)
10099     {
10100       /* This is a hack.  There should be a better way to handle this.
10101          This covers for the fact that bfd_install_relocation will
10102          subtract the current location (for partial_inplace, PC relative
10103          relocations); see more below.  */
10104 #ifndef OBJ_AOUT
10105       if (IS_ELF
10106 #ifdef TE_PE
10107           || OUTPUT_FLAVOR == bfd_target_coff_flavour
10108 #endif
10109           )
10110         value += fixP->fx_where + fixP->fx_frag->fr_address;
10111 #endif
10112 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10113       if (IS_ELF)
10114         {
10115           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
10116
10117           if ((sym_seg == seg
10118                || (symbol_section_p (fixP->fx_addsy)
10119                    && sym_seg != absolute_section))
10120               && !generic_force_reloc (fixP))
10121             {
10122               /* Yes, we add the values in twice.  This is because
10123                  bfd_install_relocation subtracts them out again.  I think
10124                  bfd_install_relocation is broken, but I don't dare change
10125                  it.  FIXME.  */
10126               value += fixP->fx_where + fixP->fx_frag->fr_address;
10127             }
10128         }
10129 #endif
10130 #if defined (OBJ_COFF) && defined (TE_PE)
10131       /* For some reason, the PE format does not store a
10132          section address offset for a PC relative symbol.  */
10133       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
10134           || S_IS_WEAK (fixP->fx_addsy))
10135         value += md_pcrel_from (fixP);
10136 #endif
10137     }
10138 #if defined (OBJ_COFF) && defined (TE_PE)
10139   if (fixP->fx_addsy != NULL
10140       && S_IS_WEAK (fixP->fx_addsy)
10141       /* PR 16858: Do not modify weak function references.  */
10142       && ! fixP->fx_pcrel)
10143     {
10144 #if !defined (TE_PEP)
10145       /* For x86 PE weak function symbols are neither PC-relative
10146          nor do they set S_IS_FUNCTION.  So the only reliable way
10147          to detect them is to check the flags of their containing
10148          section.  */
10149       if (S_GET_SEGMENT (fixP->fx_addsy) != NULL
10150           && S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_CODE)
10151         ;
10152       else
10153 #endif
10154       value -= S_GET_VALUE (fixP->fx_addsy);
10155     }
10156 #endif
10157
10158   /* Fix a few things - the dynamic linker expects certain values here,
10159      and we must not disappoint it.  */
10160 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10161   if (IS_ELF && fixP->fx_addsy)
10162     switch (fixP->fx_r_type)
10163       {
10164       case BFD_RELOC_386_PLT32:
10165       case BFD_RELOC_X86_64_PLT32:
10166         /* Make the jump instruction point to the address of the operand.  At
10167            runtime we merely add the offset to the actual PLT entry.  */
10168         value = -4;
10169         break;
10170
10171       case BFD_RELOC_386_TLS_GD:
10172       case BFD_RELOC_386_TLS_LDM:
10173       case BFD_RELOC_386_TLS_IE_32:
10174       case BFD_RELOC_386_TLS_IE:
10175       case BFD_RELOC_386_TLS_GOTIE:
10176       case BFD_RELOC_386_TLS_GOTDESC:
10177       case BFD_RELOC_X86_64_TLSGD:
10178       case BFD_RELOC_X86_64_TLSLD:
10179       case BFD_RELOC_X86_64_GOTTPOFF:
10180       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
10181         value = 0; /* Fully resolved at runtime.  No addend.  */
10182         /* Fallthrough */
10183       case BFD_RELOC_386_TLS_LE:
10184       case BFD_RELOC_386_TLS_LDO_32:
10185       case BFD_RELOC_386_TLS_LE_32:
10186       case BFD_RELOC_X86_64_DTPOFF32:
10187       case BFD_RELOC_X86_64_DTPOFF64:
10188       case BFD_RELOC_X86_64_TPOFF32:
10189       case BFD_RELOC_X86_64_TPOFF64:
10190         S_SET_THREAD_LOCAL (fixP->fx_addsy);
10191         break;
10192
10193       case BFD_RELOC_386_TLS_DESC_CALL:
10194       case BFD_RELOC_X86_64_TLSDESC_CALL:
10195         value = 0; /* Fully resolved at runtime.  No addend.  */
10196         S_SET_THREAD_LOCAL (fixP->fx_addsy);
10197         fixP->fx_done = 0;
10198         return;
10199
10200       case BFD_RELOC_VTABLE_INHERIT:
10201       case BFD_RELOC_VTABLE_ENTRY:
10202         fixP->fx_done = 0;
10203         return;
10204
10205       default:
10206         break;
10207       }
10208 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
10209   *valP = value;
10210 #endif /* !defined (TE_Mach)  */
10211
10212   /* Are we finished with this relocation now?  */
10213   if (fixP->fx_addsy == NULL)
10214     fixP->fx_done = 1;
10215 #if defined (OBJ_COFF) && defined (TE_PE)
10216   else if (fixP->fx_addsy != NULL && S_IS_WEAK (fixP->fx_addsy))
10217     {
10218       fixP->fx_done = 0;
10219       /* Remember value for tc_gen_reloc.  */
10220       fixP->fx_addnumber = value;
10221       /* Clear out the frag for now.  */
10222       value = 0;
10223     }
10224 #endif
10225   else if (use_rela_relocations)
10226     {
10227       fixP->fx_no_overflow = 1;
10228       /* Remember value for tc_gen_reloc.  */
10229       fixP->fx_addnumber = value;
10230       value = 0;
10231     }
10232
10233   md_number_to_chars (p, value, fixP->fx_size);
10234 }
10235 \f
10236 const char *
10237 md_atof (int type, char *litP, int *sizeP)
10238 {
10239   /* This outputs the LITTLENUMs in REVERSE order;
10240      in accord with the bigendian 386.  */
10241   return ieee_md_atof (type, litP, sizeP, FALSE);
10242 }
10243 \f
10244 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
10245
10246 static char *
10247 output_invalid (int c)
10248 {
10249   if (ISPRINT (c))
10250     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
10251               "'%c'", c);
10252   else
10253     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
10254               "(0x%x)", (unsigned char) c);
10255   return output_invalid_buf;
10256 }
10257
10258 /* REG_STRING starts *before* REGISTER_PREFIX.  */
10259
10260 static const reg_entry *
10261 parse_real_register (char *reg_string, char **end_op)
10262 {
10263   char *s = reg_string;
10264   char *p;
10265   char reg_name_given[MAX_REG_NAME_SIZE + 1];
10266   const reg_entry *r;
10267
10268   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
10269   if (*s == REGISTER_PREFIX)
10270     ++s;
10271
10272   if (is_space_char (*s))
10273     ++s;
10274
10275   p = reg_name_given;
10276   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
10277     {
10278       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
10279         return (const reg_entry *) NULL;
10280       s++;
10281     }
10282
10283   /* For naked regs, make sure that we are not dealing with an identifier.
10284      This prevents confusing an identifier like `eax_var' with register
10285      `eax'.  */
10286   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
10287     return (const reg_entry *) NULL;
10288
10289   *end_op = s;
10290
10291   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
10292
10293   /* Handle floating point regs, allowing spaces in the (i) part.  */
10294   if (r == i386_regtab /* %st is first entry of table  */)
10295     {
10296       if (!cpu_arch_flags.bitfield.cpu8087
10297           && !cpu_arch_flags.bitfield.cpu287
10298           && !cpu_arch_flags.bitfield.cpu387)
10299         return (const reg_entry *) NULL;
10300
10301       if (is_space_char (*s))
10302         ++s;
10303       if (*s == '(')
10304         {
10305           ++s;
10306           if (is_space_char (*s))
10307             ++s;
10308           if (*s >= '0' && *s <= '7')
10309             {
10310               int fpr = *s - '0';
10311               ++s;
10312               if (is_space_char (*s))
10313                 ++s;
10314               if (*s == ')')
10315                 {
10316                   *end_op = s + 1;
10317                   r = (const reg_entry *) hash_find (reg_hash, "st(0)");
10318                   know (r);
10319                   return r + fpr;
10320                 }
10321             }
10322           /* We have "%st(" then garbage.  */
10323           return (const reg_entry *) NULL;
10324         }
10325     }
10326
10327   if (r == NULL || allow_pseudo_reg)
10328     return r;
10329
10330   if (operand_type_all_zero (&r->reg_type))
10331     return (const reg_entry *) NULL;
10332
10333   if ((r->reg_type.bitfield.dword
10334        || r->reg_type.bitfield.sreg3
10335        || r->reg_type.bitfield.control
10336        || r->reg_type.bitfield.debug
10337        || r->reg_type.bitfield.test)
10338       && !cpu_arch_flags.bitfield.cpui386)
10339     return (const reg_entry *) NULL;
10340
10341   if (r->reg_type.bitfield.regmmx && !cpu_arch_flags.bitfield.cpummx)
10342     return (const reg_entry *) NULL;
10343
10344   if (!cpu_arch_flags.bitfield.cpuavx512f)
10345     {
10346       if (r->reg_type.bitfield.zmmword || r->reg_type.bitfield.regmask)
10347         return (const reg_entry *) NULL;
10348
10349       if (!cpu_arch_flags.bitfield.cpuavx)
10350         {
10351           if (r->reg_type.bitfield.ymmword)
10352             return (const reg_entry *) NULL;
10353
10354           if (!cpu_arch_flags.bitfield.cpusse && r->reg_type.bitfield.xmmword)
10355             return (const reg_entry *) NULL;
10356         }
10357     }
10358
10359   if (r->reg_type.bitfield.regbnd && !cpu_arch_flags.bitfield.cpumpx)
10360     return (const reg_entry *) NULL;
10361
10362   /* Don't allow fake index register unless allow_index_reg isn't 0. */
10363   if (!allow_index_reg
10364       && (r->reg_num == RegEiz || r->reg_num == RegRiz))
10365     return (const reg_entry *) NULL;
10366
10367   /* Upper 16 vector registers are only available with VREX in 64bit
10368      mode, and require EVEX encoding.  */
10369   if (r->reg_flags & RegVRex)
10370     {
10371       if (!cpu_arch_flags.bitfield.cpuvrex
10372           || flag_code != CODE_64BIT)
10373         return (const reg_entry *) NULL;
10374
10375       i.vec_encoding = vex_encoding_evex;
10376     }
10377
10378   if (((r->reg_flags & (RegRex64 | RegRex)) || r->reg_type.bitfield.qword)
10379       && (!cpu_arch_flags.bitfield.cpulm || !r->reg_type.bitfield.control)
10380       && flag_code != CODE_64BIT)
10381     return (const reg_entry *) NULL;
10382
10383   if (r->reg_type.bitfield.sreg3 && r->reg_num == RegFlat && !intel_syntax)
10384     return (const reg_entry *) NULL;
10385
10386   return r;
10387 }
10388
10389 /* REG_STRING starts *before* REGISTER_PREFIX.  */
10390
10391 static const reg_entry *
10392 parse_register (char *reg_string, char **end_op)
10393 {
10394   const reg_entry *r;
10395
10396   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
10397     r = parse_real_register (reg_string, end_op);
10398   else
10399     r = NULL;
10400   if (!r)
10401     {
10402       char *save = input_line_pointer;
10403       char c;
10404       symbolS *symbolP;
10405
10406       input_line_pointer = reg_string;
10407       c = get_symbol_name (&reg_string);
10408       symbolP = symbol_find (reg_string);
10409       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
10410         {
10411           const expressionS *e = symbol_get_value_expression (symbolP);
10412
10413           know (e->X_op == O_register);
10414           know (e->X_add_number >= 0
10415                 && (valueT) e->X_add_number < i386_regtab_size);
10416           r = i386_regtab + e->X_add_number;
10417           if ((r->reg_flags & RegVRex))
10418             i.vec_encoding = vex_encoding_evex;
10419           *end_op = input_line_pointer;
10420         }
10421       *input_line_pointer = c;
10422       input_line_pointer = save;
10423     }
10424   return r;
10425 }
10426
10427 int
10428 i386_parse_name (char *name, expressionS *e, char *nextcharP)
10429 {
10430   const reg_entry *r;
10431   char *end = input_line_pointer;
10432
10433   *end = *nextcharP;
10434   r = parse_register (name, &input_line_pointer);
10435   if (r && end <= input_line_pointer)
10436     {
10437       *nextcharP = *input_line_pointer;
10438       *input_line_pointer = 0;
10439       e->X_op = O_register;
10440       e->X_add_number = r - i386_regtab;
10441       return 1;
10442     }
10443   input_line_pointer = end;
10444   *end = 0;
10445   return intel_syntax ? i386_intel_parse_name (name, e) : 0;
10446 }
10447
10448 void
10449 md_operand (expressionS *e)
10450 {
10451   char *end;
10452   const reg_entry *r;
10453
10454   switch (*input_line_pointer)
10455     {
10456     case REGISTER_PREFIX:
10457       r = parse_real_register (input_line_pointer, &end);
10458       if (r)
10459         {
10460           e->X_op = O_register;
10461           e->X_add_number = r - i386_regtab;
10462           input_line_pointer = end;
10463         }
10464       break;
10465
10466     case '[':
10467       gas_assert (intel_syntax);
10468       end = input_line_pointer++;
10469       expression (e);
10470       if (*input_line_pointer == ']')
10471         {
10472           ++input_line_pointer;
10473           e->X_op_symbol = make_expr_symbol (e);
10474           e->X_add_symbol = NULL;
10475           e->X_add_number = 0;
10476           e->X_op = O_index;
10477         }
10478       else
10479         {
10480           e->X_op = O_absent;
10481           input_line_pointer = end;
10482         }
10483       break;
10484     }
10485 }
10486
10487 \f
10488 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10489 const char *md_shortopts = "kVQ:sqnO::";
10490 #else
10491 const char *md_shortopts = "qnO::";
10492 #endif
10493
10494 #define OPTION_32 (OPTION_MD_BASE + 0)
10495 #define OPTION_64 (OPTION_MD_BASE + 1)
10496 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
10497 #define OPTION_MARCH (OPTION_MD_BASE + 3)
10498 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
10499 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
10500 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
10501 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
10502 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
10503 #define OPTION_MRELAX_RELOCATIONS (OPTION_MD_BASE + 9)
10504 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
10505 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
10506 #define OPTION_MOPERAND_CHECK (OPTION_MD_BASE + 12)
10507 #define OPTION_MAVXSCALAR (OPTION_MD_BASE + 13)
10508 #define OPTION_X32 (OPTION_MD_BASE + 14)
10509 #define OPTION_MADD_BND_PREFIX (OPTION_MD_BASE + 15)
10510 #define OPTION_MEVEXLIG (OPTION_MD_BASE + 16)
10511 #define OPTION_MEVEXWIG (OPTION_MD_BASE + 17)
10512 #define OPTION_MBIG_OBJ (OPTION_MD_BASE + 18)
10513 #define OPTION_MOMIT_LOCK_PREFIX (OPTION_MD_BASE + 19)
10514 #define OPTION_MEVEXRCIG (OPTION_MD_BASE + 20)
10515 #define OPTION_MSHARED (OPTION_MD_BASE + 21)
10516 #define OPTION_MAMD64 (OPTION_MD_BASE + 22)
10517 #define OPTION_MINTEL64 (OPTION_MD_BASE + 23)
10518 #define OPTION_MFENCE_AS_LOCK_ADD (OPTION_MD_BASE + 24)
10519
10520 struct option md_longopts[] =
10521 {
10522   {"32", no_argument, NULL, OPTION_32},
10523 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
10524      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
10525   {"64", no_argument, NULL, OPTION_64},
10526 #endif
10527 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10528   {"x32", no_argument, NULL, OPTION_X32},
10529   {"mshared", no_argument, NULL, OPTION_MSHARED},
10530 #endif
10531   {"divide", no_argument, NULL, OPTION_DIVIDE},
10532   {"march", required_argument, NULL, OPTION_MARCH},
10533   {"mtune", required_argument, NULL, OPTION_MTUNE},
10534   {"mmnemonic", required_argument, NULL, OPTION_MMNEMONIC},
10535   {"msyntax", required_argument, NULL, OPTION_MSYNTAX},
10536   {"mindex-reg", no_argument, NULL, OPTION_MINDEX_REG},
10537   {"mnaked-reg", no_argument, NULL, OPTION_MNAKED_REG},
10538   {"msse2avx", no_argument, NULL, OPTION_MSSE2AVX},
10539   {"msse-check", required_argument, NULL, OPTION_MSSE_CHECK},
10540   {"moperand-check", required_argument, NULL, OPTION_MOPERAND_CHECK},
10541   {"mavxscalar", required_argument, NULL, OPTION_MAVXSCALAR},
10542   {"madd-bnd-prefix", no_argument, NULL, OPTION_MADD_BND_PREFIX},
10543   {"mevexlig", required_argument, NULL, OPTION_MEVEXLIG},
10544   {"mevexwig", required_argument, NULL, OPTION_MEVEXWIG},
10545 # if defined (TE_PE) || defined (TE_PEP)
10546   {"mbig-obj", no_argument, NULL, OPTION_MBIG_OBJ},
10547 #endif
10548   {"momit-lock-prefix", required_argument, NULL, OPTION_MOMIT_LOCK_PREFIX},
10549   {"mfence-as-lock-add", required_argument, NULL, OPTION_MFENCE_AS_LOCK_ADD},
10550   {"mrelax-relocations", required_argument, NULL, OPTION_MRELAX_RELOCATIONS},
10551   {"mevexrcig", required_argument, NULL, OPTION_MEVEXRCIG},
10552   {"mamd64", no_argument, NULL, OPTION_MAMD64},
10553   {"mintel64", no_argument, NULL, OPTION_MINTEL64},
10554   {NULL, no_argument, NULL, 0}
10555 };
10556 size_t md_longopts_size = sizeof (md_longopts);
10557
10558 int
10559 md_parse_option (int c, const char *arg)
10560 {
10561   unsigned int j;
10562   char *arch, *next, *saved;
10563
10564   switch (c)
10565     {
10566     case 'n':
10567       optimize_align_code = 0;
10568       break;
10569
10570     case 'q':
10571       quiet_warnings = 1;
10572       break;
10573
10574 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10575       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
10576          should be emitted or not.  FIXME: Not implemented.  */
10577     case 'Q':
10578       break;
10579
10580       /* -V: SVR4 argument to print version ID.  */
10581     case 'V':
10582       print_version_id ();
10583       break;
10584
10585       /* -k: Ignore for FreeBSD compatibility.  */
10586     case 'k':
10587       break;
10588
10589     case 's':
10590       /* -s: On i386 Solaris, this tells the native assembler to use
10591          .stab instead of .stab.excl.  We always use .stab anyhow.  */
10592       break;
10593
10594     case OPTION_MSHARED:
10595       shared = 1;
10596       break;
10597 #endif
10598 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
10599      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
10600     case OPTION_64:
10601       {
10602         const char **list, **l;
10603
10604         list = bfd_target_list ();
10605         for (l = list; *l != NULL; l++)
10606           if (CONST_STRNEQ (*l, "elf64-x86-64")
10607               || strcmp (*l, "coff-x86-64") == 0
10608               || strcmp (*l, "pe-x86-64") == 0
10609               || strcmp (*l, "pei-x86-64") == 0
10610               || strcmp (*l, "mach-o-x86-64") == 0)
10611             {
10612               default_arch = "x86_64";
10613               break;
10614             }
10615         if (*l == NULL)
10616           as_fatal (_("no compiled in support for x86_64"));
10617         free (list);
10618       }
10619       break;
10620 #endif
10621
10622 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
10623     case OPTION_X32:
10624       if (IS_ELF)
10625         {
10626           const char **list, **l;
10627
10628           list = bfd_target_list ();
10629           for (l = list; *l != NULL; l++)
10630             if (CONST_STRNEQ (*l, "elf32-x86-64"))
10631               {
10632                 default_arch = "x86_64:32";
10633                 break;
10634               }
10635           if (*l == NULL)
10636             as_fatal (_("no compiled in support for 32bit x86_64"));
10637           free (list);
10638         }
10639       else
10640         as_fatal (_("32bit x86_64 is only supported for ELF"));
10641       break;
10642 #endif
10643
10644     case OPTION_32:
10645       default_arch = "i386";
10646       break;
10647
10648     case OPTION_DIVIDE:
10649 #ifdef SVR4_COMMENT_CHARS
10650       {
10651         char *n, *t;
10652         const char *s;
10653
10654         n = XNEWVEC (char, strlen (i386_comment_chars) + 1);
10655         t = n;
10656         for (s = i386_comment_chars; *s != '\0'; s++)
10657           if (*s != '/')
10658             *t++ = *s;
10659         *t = '\0';
10660         i386_comment_chars = n;
10661       }
10662 #endif
10663       break;
10664
10665     case OPTION_MARCH:
10666       saved = xstrdup (arg);
10667       arch = saved;
10668       /* Allow -march=+nosse.  */
10669       if (*arch == '+')
10670         arch++;
10671       do
10672         {
10673           if (*arch == '.')
10674             as_fatal (_("invalid -march= option: `%s'"), arg);
10675           next = strchr (arch, '+');
10676           if (next)
10677             *next++ = '\0';
10678           for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
10679             {
10680               if (strcmp (arch, cpu_arch [j].name) == 0)
10681                 {
10682                   /* Processor.  */
10683                   if (! cpu_arch[j].flags.bitfield.cpui386)
10684                     continue;
10685
10686                   cpu_arch_name = cpu_arch[j].name;
10687                   cpu_sub_arch_name = NULL;
10688                   cpu_arch_flags = cpu_arch[j].flags;
10689                   cpu_arch_isa = cpu_arch[j].type;
10690                   cpu_arch_isa_flags = cpu_arch[j].flags;
10691                   if (!cpu_arch_tune_set)
10692                     {
10693                       cpu_arch_tune = cpu_arch_isa;
10694                       cpu_arch_tune_flags = cpu_arch_isa_flags;
10695                     }
10696                   break;
10697                 }
10698               else if (*cpu_arch [j].name == '.'
10699                        && strcmp (arch, cpu_arch [j].name + 1) == 0)
10700                 {
10701                   /* ISA extension.  */
10702                   i386_cpu_flags flags;
10703
10704                   flags = cpu_flags_or (cpu_arch_flags,
10705                                         cpu_arch[j].flags);
10706
10707                   if (!cpu_flags_equal (&flags, &cpu_arch_flags))
10708                     {
10709                       if (cpu_sub_arch_name)
10710                         {
10711                           char *name = cpu_sub_arch_name;
10712                           cpu_sub_arch_name = concat (name,
10713                                                       cpu_arch[j].name,
10714                                                       (const char *) NULL);
10715                           free (name);
10716                         }
10717                       else
10718                         cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
10719                       cpu_arch_flags = flags;
10720                       cpu_arch_isa_flags = flags;
10721                     }
10722                   else
10723                     cpu_arch_isa_flags
10724                       = cpu_flags_or (cpu_arch_isa_flags,
10725                                       cpu_arch[j].flags);
10726                   break;
10727                 }
10728             }
10729
10730           if (j >= ARRAY_SIZE (cpu_arch))
10731             {
10732               /* Disable an ISA extension.  */
10733               for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
10734                 if (strcmp (arch, cpu_noarch [j].name) == 0)
10735                   {
10736                     i386_cpu_flags flags;
10737
10738                     flags = cpu_flags_and_not (cpu_arch_flags,
10739                                                cpu_noarch[j].flags);
10740                     if (!cpu_flags_equal (&flags, &cpu_arch_flags))
10741                       {
10742                         if (cpu_sub_arch_name)
10743                           {
10744                             char *name = cpu_sub_arch_name;
10745                             cpu_sub_arch_name = concat (arch,
10746                                                         (const char *) NULL);
10747                             free (name);
10748                           }
10749                         else
10750                           cpu_sub_arch_name = xstrdup (arch);
10751                         cpu_arch_flags = flags;
10752                         cpu_arch_isa_flags = flags;
10753                       }
10754                     break;
10755                   }
10756
10757               if (j >= ARRAY_SIZE (cpu_noarch))
10758                 j = ARRAY_SIZE (cpu_arch);
10759             }
10760
10761           if (j >= ARRAY_SIZE (cpu_arch))
10762             as_fatal (_("invalid -march= option: `%s'"), arg);
10763
10764           arch = next;
10765         }
10766       while (next != NULL);
10767       free (saved);
10768       break;
10769
10770     case OPTION_MTUNE:
10771       if (*arg == '.')
10772         as_fatal (_("invalid -mtune= option: `%s'"), arg);
10773       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
10774         {
10775           if (strcmp (arg, cpu_arch [j].name) == 0)
10776             {
10777               cpu_arch_tune_set = 1;
10778               cpu_arch_tune = cpu_arch [j].type;
10779               cpu_arch_tune_flags = cpu_arch[j].flags;
10780               break;
10781             }
10782         }
10783       if (j >= ARRAY_SIZE (cpu_arch))
10784         as_fatal (_("invalid -mtune= option: `%s'"), arg);
10785       break;
10786
10787     case OPTION_MMNEMONIC:
10788       if (strcasecmp (arg, "att") == 0)
10789         intel_mnemonic = 0;
10790       else if (strcasecmp (arg, "intel") == 0)
10791         intel_mnemonic = 1;
10792       else
10793         as_fatal (_("invalid -mmnemonic= option: `%s'"), arg);
10794       break;
10795
10796     case OPTION_MSYNTAX:
10797       if (strcasecmp (arg, "att") == 0)
10798         intel_syntax = 0;
10799       else if (strcasecmp (arg, "intel") == 0)
10800         intel_syntax = 1;
10801       else
10802         as_fatal (_("invalid -msyntax= option: `%s'"), arg);
10803       break;
10804
10805     case OPTION_MINDEX_REG:
10806       allow_index_reg = 1;
10807       break;
10808
10809     case OPTION_MNAKED_REG:
10810       allow_naked_reg = 1;
10811       break;
10812
10813     case OPTION_MSSE2AVX:
10814       sse2avx = 1;
10815       break;
10816
10817     case OPTION_MSSE_CHECK:
10818       if (strcasecmp (arg, "error") == 0)
10819         sse_check = check_error;
10820       else if (strcasecmp (arg, "warning") == 0)
10821         sse_check = check_warning;
10822       else if (strcasecmp (arg, "none") == 0)
10823         sse_check = check_none;
10824       else
10825         as_fatal (_("invalid -msse-check= option: `%s'"), arg);
10826       break;
10827
10828     case OPTION_MOPERAND_CHECK:
10829       if (strcasecmp (arg, "error") == 0)
10830         operand_check = check_error;
10831       else if (strcasecmp (arg, "warning") == 0)
10832         operand_check = check_warning;
10833       else if (strcasecmp (arg, "none") == 0)
10834         operand_check = check_none;
10835       else
10836         as_fatal (_("invalid -moperand-check= option: `%s'"), arg);
10837       break;
10838
10839     case OPTION_MAVXSCALAR:
10840       if (strcasecmp (arg, "128") == 0)
10841         avxscalar = vex128;
10842       else if (strcasecmp (arg, "256") == 0)
10843         avxscalar = vex256;
10844       else
10845         as_fatal (_("invalid -mavxscalar= option: `%s'"), arg);
10846       break;
10847
10848     case OPTION_MADD_BND_PREFIX:
10849       add_bnd_prefix = 1;
10850       break;
10851
10852     case OPTION_MEVEXLIG:
10853       if (strcmp (arg, "128") == 0)
10854         evexlig = evexl128;
10855       else if (strcmp (arg, "256") == 0)
10856         evexlig = evexl256;
10857       else  if (strcmp (arg, "512") == 0)
10858         evexlig = evexl512;
10859       else
10860         as_fatal (_("invalid -mevexlig= option: `%s'"), arg);
10861       break;
10862
10863     case OPTION_MEVEXRCIG:
10864       if (strcmp (arg, "rne") == 0)
10865         evexrcig = rne;
10866       else if (strcmp (arg, "rd") == 0)
10867         evexrcig = rd;
10868       else if (strcmp (arg, "ru") == 0)
10869         evexrcig = ru;
10870       else if (strcmp (arg, "rz") == 0)
10871         evexrcig = rz;
10872       else
10873         as_fatal (_("invalid -mevexrcig= option: `%s'"), arg);
10874       break;
10875
10876     case OPTION_MEVEXWIG:
10877       if (strcmp (arg, "0") == 0)
10878         evexwig = evexw0;
10879       else if (strcmp (arg, "1") == 0)
10880         evexwig = evexw1;
10881       else
10882         as_fatal (_("invalid -mevexwig= option: `%s'"), arg);
10883       break;
10884
10885 # if defined (TE_PE) || defined (TE_PEP)
10886     case OPTION_MBIG_OBJ:
10887       use_big_obj = 1;
10888       break;
10889 #endif
10890
10891     case OPTION_MOMIT_LOCK_PREFIX:
10892       if (strcasecmp (arg, "yes") == 0)
10893         omit_lock_prefix = 1;
10894       else if (strcasecmp (arg, "no") == 0)
10895         omit_lock_prefix = 0;
10896       else
10897         as_fatal (_("invalid -momit-lock-prefix= option: `%s'"), arg);
10898       break;
10899
10900     case OPTION_MFENCE_AS_LOCK_ADD:
10901       if (strcasecmp (arg, "yes") == 0)
10902         avoid_fence = 1;
10903       else if (strcasecmp (arg, "no") == 0)
10904         avoid_fence = 0;
10905       else
10906         as_fatal (_("invalid -mfence-as-lock-add= option: `%s'"), arg);
10907       break;
10908
10909     case OPTION_MRELAX_RELOCATIONS:
10910       if (strcasecmp (arg, "yes") == 0)
10911         generate_relax_relocations = 1;
10912       else if (strcasecmp (arg, "no") == 0)
10913         generate_relax_relocations = 0;
10914       else
10915         as_fatal (_("invalid -mrelax-relocations= option: `%s'"), arg);
10916       break;
10917
10918     case OPTION_MAMD64:
10919       intel64 = 0;
10920       break;
10921
10922     case OPTION_MINTEL64:
10923       intel64 = 1;
10924       break;
10925
10926     case 'O':
10927       if (arg == NULL)
10928         {
10929           optimize = 1;
10930           /* Turn off -Os.  */
10931           optimize_for_space = 0;
10932         }
10933       else if (*arg == 's')
10934         {
10935           optimize_for_space = 1;
10936           /* Turn on all encoding optimizations.  */
10937           optimize = -1;
10938         }
10939       else
10940         {
10941           optimize = atoi (arg);
10942           /* Turn off -Os.  */
10943           optimize_for_space = 0;
10944         }
10945       break;
10946
10947     default:
10948       return 0;
10949     }
10950   return 1;
10951 }
10952
10953 #define MESSAGE_TEMPLATE \
10954 "                                                                                "
10955
10956 static char *
10957 output_message (FILE *stream, char *p, char *message, char *start,
10958                 int *left_p, const char *name, int len)
10959 {
10960   int size = sizeof (MESSAGE_TEMPLATE);
10961   int left = *left_p;
10962
10963   /* Reserve 2 spaces for ", " or ",\0" */
10964   left -= len + 2;
10965
10966   /* Check if there is any room.  */
10967   if (left >= 0)
10968     {
10969       if (p != start)
10970         {
10971           *p++ = ',';
10972           *p++ = ' ';
10973         }
10974       p = mempcpy (p, name, len);
10975     }
10976   else
10977     {
10978       /* Output the current message now and start a new one.  */
10979       *p++ = ',';
10980       *p = '\0';
10981       fprintf (stream, "%s\n", message);
10982       p = start;
10983       left = size - (start - message) - len - 2;
10984
10985       gas_assert (left >= 0);
10986
10987       p = mempcpy (p, name, len);
10988     }
10989
10990   *left_p = left;
10991   return p;
10992 }
10993
10994 static void
10995 show_arch (FILE *stream, int ext, int check)
10996 {
10997   static char message[] = MESSAGE_TEMPLATE;
10998   char *start = message + 27;
10999   char *p;
11000   int size = sizeof (MESSAGE_TEMPLATE);
11001   int left;
11002   const char *name;
11003   int len;
11004   unsigned int j;
11005
11006   p = start;
11007   left = size - (start - message);
11008   for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
11009     {
11010       /* Should it be skipped?  */
11011       if (cpu_arch [j].skip)
11012         continue;
11013
11014       name = cpu_arch [j].name;
11015       len = cpu_arch [j].len;
11016       if (*name == '.')
11017         {
11018           /* It is an extension.  Skip if we aren't asked to show it.  */
11019           if (ext)
11020             {
11021               name++;
11022               len--;
11023             }
11024           else
11025             continue;
11026         }
11027       else if (ext)
11028         {
11029           /* It is an processor.  Skip if we show only extension.  */
11030           continue;
11031         }
11032       else if (check && ! cpu_arch[j].flags.bitfield.cpui386)
11033         {
11034           /* It is an impossible processor - skip.  */
11035           continue;
11036         }
11037
11038       p = output_message (stream, p, message, start, &left, name, len);
11039     }
11040
11041   /* Display disabled extensions.  */
11042   if (ext)
11043     for (j = 0; j < ARRAY_SIZE (cpu_noarch); j++)
11044       {
11045         name = cpu_noarch [j].name;
11046         len = cpu_noarch [j].len;
11047         p = output_message (stream, p, message, start, &left, name,
11048                             len);
11049       }
11050
11051   *p = '\0';
11052   fprintf (stream, "%s\n", message);
11053 }
11054
11055 void
11056 md_show_usage (FILE *stream)
11057 {
11058 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11059   fprintf (stream, _("\
11060   -Q                      ignored\n\
11061   -V                      print assembler version number\n\
11062   -k                      ignored\n"));
11063 #endif
11064   fprintf (stream, _("\
11065   -n                      Do not optimize code alignment\n\
11066   -q                      quieten some warnings\n"));
11067 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11068   fprintf (stream, _("\
11069   -s                      ignored\n"));
11070 #endif
11071 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11072      || defined (TE_PE) || defined (TE_PEP))
11073   fprintf (stream, _("\
11074   --32/--64/--x32         generate 32bit/64bit/x32 code\n"));
11075 #endif
11076 #ifdef SVR4_COMMENT_CHARS
11077   fprintf (stream, _("\
11078   --divide                do not treat `/' as a comment character\n"));
11079 #else
11080   fprintf (stream, _("\
11081   --divide                ignored\n"));
11082 #endif
11083   fprintf (stream, _("\
11084   -march=CPU[,+EXTENSION...]\n\
11085                           generate code for CPU and EXTENSION, CPU is one of:\n"));
11086   show_arch (stream, 0, 1);
11087   fprintf (stream, _("\
11088                           EXTENSION is combination of:\n"));
11089   show_arch (stream, 1, 0);
11090   fprintf (stream, _("\
11091   -mtune=CPU              optimize for CPU, CPU is one of:\n"));
11092   show_arch (stream, 0, 0);
11093   fprintf (stream, _("\
11094   -msse2avx               encode SSE instructions with VEX prefix\n"));
11095   fprintf (stream, _("\
11096   -msse-check=[none|error|warning]\n\
11097                           check SSE instructions\n"));
11098   fprintf (stream, _("\
11099   -moperand-check=[none|error|warning]\n\
11100                           check operand combinations for validity\n"));
11101   fprintf (stream, _("\
11102   -mavxscalar=[128|256]   encode scalar AVX instructions with specific vector\n\
11103                            length\n"));
11104   fprintf (stream, _("\
11105   -mevexlig=[128|256|512] encode scalar EVEX instructions with specific vector\n\
11106                            length\n"));
11107   fprintf (stream, _("\
11108   -mevexwig=[0|1]         encode EVEX instructions with specific EVEX.W value\n\
11109                            for EVEX.W bit ignored instructions\n"));
11110   fprintf (stream, _("\
11111   -mevexrcig=[rne|rd|ru|rz]\n\
11112                           encode EVEX instructions with specific EVEX.RC value\n\
11113                            for SAE-only ignored instructions\n"));
11114   fprintf (stream, _("\
11115   -mmnemonic=[att|intel]  use AT&T/Intel mnemonic\n"));
11116   fprintf (stream, _("\
11117   -msyntax=[att|intel]    use AT&T/Intel syntax\n"));
11118   fprintf (stream, _("\
11119   -mindex-reg             support pseudo index registers\n"));
11120   fprintf (stream, _("\
11121   -mnaked-reg             don't require `%%' prefix for registers\n"));
11122   fprintf (stream, _("\
11123   -madd-bnd-prefix        add BND prefix for all valid branches\n"));
11124   fprintf (stream, _("\
11125   -mshared                disable branch optimization for shared code\n"));
11126 # if defined (TE_PE) || defined (TE_PEP)
11127   fprintf (stream, _("\
11128   -mbig-obj               generate big object files\n"));
11129 #endif
11130   fprintf (stream, _("\
11131   -momit-lock-prefix=[no|yes]\n\
11132                           strip all lock prefixes\n"));
11133   fprintf (stream, _("\
11134   -mfence-as-lock-add=[no|yes]\n\
11135                           encode lfence, mfence and sfence as\n\
11136                            lock addl $0x0, (%%{re}sp)\n"));
11137   fprintf (stream, _("\
11138   -mrelax-relocations=[no|yes]\n\
11139                           generate relax relocations\n"));
11140   fprintf (stream, _("\
11141   -mamd64                 accept only AMD64 ISA\n"));
11142   fprintf (stream, _("\
11143   -mintel64               accept only Intel64 ISA\n"));
11144 }
11145
11146 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
11147      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
11148      || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
11149
11150 /* Pick the target format to use.  */
11151
11152 const char *
11153 i386_target_format (void)
11154 {
11155   if (!strncmp (default_arch, "x86_64", 6))
11156     {
11157       update_code_flag (CODE_64BIT, 1);
11158       if (default_arch[6] == '\0')
11159         x86_elf_abi = X86_64_ABI;
11160       else
11161         x86_elf_abi = X86_64_X32_ABI;
11162     }
11163   else if (!strcmp (default_arch, "i386"))
11164     update_code_flag (CODE_32BIT, 1);
11165   else if (!strcmp (default_arch, "iamcu"))
11166     {
11167       update_code_flag (CODE_32BIT, 1);
11168       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
11169         {
11170           static const i386_cpu_flags iamcu_flags = CPU_IAMCU_FLAGS;
11171           cpu_arch_name = "iamcu";
11172           cpu_sub_arch_name = NULL;
11173           cpu_arch_flags = iamcu_flags;
11174           cpu_arch_isa = PROCESSOR_IAMCU;
11175           cpu_arch_isa_flags = iamcu_flags;
11176           if (!cpu_arch_tune_set)
11177             {
11178               cpu_arch_tune = cpu_arch_isa;
11179               cpu_arch_tune_flags = cpu_arch_isa_flags;
11180             }
11181         }
11182       else if (cpu_arch_isa != PROCESSOR_IAMCU)
11183         as_fatal (_("Intel MCU doesn't support `%s' architecture"),
11184                   cpu_arch_name);
11185     }
11186   else
11187     as_fatal (_("unknown architecture"));
11188
11189   if (cpu_flags_all_zero (&cpu_arch_isa_flags))
11190     cpu_arch_isa_flags = cpu_arch[flag_code == CODE_64BIT].flags;
11191   if (cpu_flags_all_zero (&cpu_arch_tune_flags))
11192     cpu_arch_tune_flags = cpu_arch[flag_code == CODE_64BIT].flags;
11193
11194   switch (OUTPUT_FLAVOR)
11195     {
11196 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
11197     case bfd_target_aout_flavour:
11198       return AOUT_TARGET_FORMAT;
11199 #endif
11200 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
11201 # if defined (TE_PE) || defined (TE_PEP)
11202     case bfd_target_coff_flavour:
11203       if (flag_code == CODE_64BIT)
11204         return use_big_obj ? "pe-bigobj-x86-64" : "pe-x86-64";
11205       else
11206         return "pe-i386";
11207 # elif defined (TE_GO32)
11208     case bfd_target_coff_flavour:
11209       return "coff-go32";
11210 # else
11211     case bfd_target_coff_flavour:
11212       return "coff-i386";
11213 # endif
11214 #endif
11215 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
11216     case bfd_target_elf_flavour:
11217       {
11218         const char *format;
11219
11220         switch (x86_elf_abi)
11221           {
11222           default:
11223             format = ELF_TARGET_FORMAT;
11224             break;
11225           case X86_64_ABI:
11226             use_rela_relocations = 1;
11227             object_64bit = 1;
11228             format = ELF_TARGET_FORMAT64;
11229             break;
11230           case X86_64_X32_ABI:
11231             use_rela_relocations = 1;
11232             object_64bit = 1;
11233             disallow_64bit_reloc = 1;
11234             format = ELF_TARGET_FORMAT32;
11235             break;
11236           }
11237         if (cpu_arch_isa == PROCESSOR_L1OM)
11238           {
11239             if (x86_elf_abi != X86_64_ABI)
11240               as_fatal (_("Intel L1OM is 64bit only"));
11241             return ELF_TARGET_L1OM_FORMAT;
11242           }
11243         else if (cpu_arch_isa == PROCESSOR_K1OM)
11244           {
11245             if (x86_elf_abi != X86_64_ABI)
11246               as_fatal (_("Intel K1OM is 64bit only"));
11247             return ELF_TARGET_K1OM_FORMAT;
11248           }
11249         else if (cpu_arch_isa == PROCESSOR_IAMCU)
11250           {
11251             if (x86_elf_abi != I386_ABI)
11252               as_fatal (_("Intel MCU is 32bit only"));
11253             return ELF_TARGET_IAMCU_FORMAT;
11254           }
11255         else
11256           return format;
11257       }
11258 #endif
11259 #if defined (OBJ_MACH_O)
11260     case bfd_target_mach_o_flavour:
11261       if (flag_code == CODE_64BIT)
11262         {
11263           use_rela_relocations = 1;
11264           object_64bit = 1;
11265           return "mach-o-x86-64";
11266         }
11267       else
11268         return "mach-o-i386";
11269 #endif
11270     default:
11271       abort ();
11272       return NULL;
11273     }
11274 }
11275
11276 #endif /* OBJ_MAYBE_ more than one  */
11277 \f
11278 symbolS *
11279 md_undefined_symbol (char *name)
11280 {
11281   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
11282       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
11283       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
11284       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
11285     {
11286       if (!GOT_symbol)
11287         {
11288           if (symbol_find (name))
11289             as_bad (_("GOT already in symbol table"));
11290           GOT_symbol = symbol_new (name, undefined_section,
11291                                    (valueT) 0, &zero_address_frag);
11292         };
11293       return GOT_symbol;
11294     }
11295   return 0;
11296 }
11297
11298 /* Round up a section size to the appropriate boundary.  */
11299
11300 valueT
11301 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
11302 {
11303 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
11304   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
11305     {
11306       /* For a.out, force the section size to be aligned.  If we don't do
11307          this, BFD will align it for us, but it will not write out the
11308          final bytes of the section.  This may be a bug in BFD, but it is
11309          easier to fix it here since that is how the other a.out targets
11310          work.  */
11311       int align;
11312
11313       align = bfd_get_section_alignment (stdoutput, segment);
11314       size = ((size + (1 << align) - 1) & (-((valueT) 1 << align)));
11315     }
11316 #endif
11317
11318   return size;
11319 }
11320
11321 /* On the i386, PC-relative offsets are relative to the start of the
11322    next instruction.  That is, the address of the offset, plus its
11323    size, since the offset is always the last part of the insn.  */
11324
11325 long
11326 md_pcrel_from (fixS *fixP)
11327 {
11328   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
11329 }
11330
11331 #ifndef I386COFF
11332
11333 static void
11334 s_bss (int ignore ATTRIBUTE_UNUSED)
11335 {
11336   int temp;
11337
11338 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11339   if (IS_ELF)
11340     obj_elf_section_change_hook ();
11341 #endif
11342   temp = get_absolute_expression ();
11343   subseg_set (bss_section, (subsegT) temp);
11344   demand_empty_rest_of_line ();
11345 }
11346
11347 #endif
11348
11349 void
11350 i386_validate_fix (fixS *fixp)
11351 {
11352   if (fixp->fx_subsy)
11353     {
11354       if (fixp->fx_subsy == GOT_symbol)
11355         {
11356           if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
11357             {
11358               if (!object_64bit)
11359                 abort ();
11360 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11361               if (fixp->fx_tcbit2)
11362                 fixp->fx_r_type = (fixp->fx_tcbit
11363                                    ? BFD_RELOC_X86_64_REX_GOTPCRELX
11364                                    : BFD_RELOC_X86_64_GOTPCRELX);
11365               else
11366 #endif
11367                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
11368             }
11369           else
11370             {
11371               if (!object_64bit)
11372                 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
11373               else
11374                 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
11375             }
11376           fixp->fx_subsy = 0;
11377         }
11378     }
11379 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11380   else if (!object_64bit)
11381     {
11382       if (fixp->fx_r_type == BFD_RELOC_386_GOT32
11383           && fixp->fx_tcbit2)
11384         fixp->fx_r_type = BFD_RELOC_386_GOT32X;
11385     }
11386 #endif
11387 }
11388
11389 arelent *
11390 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
11391 {
11392   arelent *rel;
11393   bfd_reloc_code_real_type code;
11394
11395   switch (fixp->fx_r_type)
11396     {
11397 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11398     case BFD_RELOC_SIZE32:
11399     case BFD_RELOC_SIZE64:
11400       if (S_IS_DEFINED (fixp->fx_addsy)
11401           && !S_IS_EXTERNAL (fixp->fx_addsy))
11402         {
11403           /* Resolve size relocation against local symbol to size of
11404              the symbol plus addend.  */
11405           valueT value = S_GET_SIZE (fixp->fx_addsy) + fixp->fx_offset;
11406           if (fixp->fx_r_type == BFD_RELOC_SIZE32
11407               && !fits_in_unsigned_long (value))
11408             as_bad_where (fixp->fx_file, fixp->fx_line,
11409                           _("symbol size computation overflow"));
11410           fixp->fx_addsy = NULL;
11411           fixp->fx_subsy = NULL;
11412           md_apply_fix (fixp, (valueT *) &value, NULL);
11413           return NULL;
11414         }
11415 #endif
11416       /* Fall through.  */
11417
11418     case BFD_RELOC_X86_64_PLT32:
11419     case BFD_RELOC_X86_64_GOT32:
11420     case BFD_RELOC_X86_64_GOTPCREL:
11421     case BFD_RELOC_X86_64_GOTPCRELX:
11422     case BFD_RELOC_X86_64_REX_GOTPCRELX:
11423     case BFD_RELOC_386_PLT32:
11424     case BFD_RELOC_386_GOT32:
11425     case BFD_RELOC_386_GOT32X:
11426     case BFD_RELOC_386_GOTOFF:
11427     case BFD_RELOC_386_GOTPC:
11428     case BFD_RELOC_386_TLS_GD:
11429     case BFD_RELOC_386_TLS_LDM:
11430     case BFD_RELOC_386_TLS_LDO_32:
11431     case BFD_RELOC_386_TLS_IE_32:
11432     case BFD_RELOC_386_TLS_IE:
11433     case BFD_RELOC_386_TLS_GOTIE:
11434     case BFD_RELOC_386_TLS_LE_32:
11435     case BFD_RELOC_386_TLS_LE:
11436     case BFD_RELOC_386_TLS_GOTDESC:
11437     case BFD_RELOC_386_TLS_DESC_CALL:
11438     case BFD_RELOC_X86_64_TLSGD:
11439     case BFD_RELOC_X86_64_TLSLD:
11440     case BFD_RELOC_X86_64_DTPOFF32:
11441     case BFD_RELOC_X86_64_DTPOFF64:
11442     case BFD_RELOC_X86_64_GOTTPOFF:
11443     case BFD_RELOC_X86_64_TPOFF32:
11444     case BFD_RELOC_X86_64_TPOFF64:
11445     case BFD_RELOC_X86_64_GOTOFF64:
11446     case BFD_RELOC_X86_64_GOTPC32:
11447     case BFD_RELOC_X86_64_GOT64:
11448     case BFD_RELOC_X86_64_GOTPCREL64:
11449     case BFD_RELOC_X86_64_GOTPC64:
11450     case BFD_RELOC_X86_64_GOTPLT64:
11451     case BFD_RELOC_X86_64_PLTOFF64:
11452     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
11453     case BFD_RELOC_X86_64_TLSDESC_CALL:
11454     case BFD_RELOC_RVA:
11455     case BFD_RELOC_VTABLE_ENTRY:
11456     case BFD_RELOC_VTABLE_INHERIT:
11457 #ifdef TE_PE
11458     case BFD_RELOC_32_SECREL:
11459 #endif
11460       code = fixp->fx_r_type;
11461       break;
11462     case BFD_RELOC_X86_64_32S:
11463       if (!fixp->fx_pcrel)
11464         {
11465           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
11466           code = fixp->fx_r_type;
11467           break;
11468         }
11469       /* Fall through.  */
11470     default:
11471       if (fixp->fx_pcrel)
11472         {
11473           switch (fixp->fx_size)
11474             {
11475             default:
11476               as_bad_where (fixp->fx_file, fixp->fx_line,
11477                             _("can not do %d byte pc-relative relocation"),
11478                             fixp->fx_size);
11479               code = BFD_RELOC_32_PCREL;
11480               break;
11481             case 1: code = BFD_RELOC_8_PCREL;  break;
11482             case 2: code = BFD_RELOC_16_PCREL; break;
11483             case 4: code = BFD_RELOC_32_PCREL; break;
11484 #ifdef BFD64
11485             case 8: code = BFD_RELOC_64_PCREL; break;
11486 #endif
11487             }
11488         }
11489       else
11490         {
11491           switch (fixp->fx_size)
11492             {
11493             default:
11494               as_bad_where (fixp->fx_file, fixp->fx_line,
11495                             _("can not do %d byte relocation"),
11496                             fixp->fx_size);
11497               code = BFD_RELOC_32;
11498               break;
11499             case 1: code = BFD_RELOC_8;  break;
11500             case 2: code = BFD_RELOC_16; break;
11501             case 4: code = BFD_RELOC_32; break;
11502 #ifdef BFD64
11503             case 8: code = BFD_RELOC_64; break;
11504 #endif
11505             }
11506         }
11507       break;
11508     }
11509
11510   if ((code == BFD_RELOC_32
11511        || code == BFD_RELOC_32_PCREL
11512        || code == BFD_RELOC_X86_64_32S)
11513       && GOT_symbol
11514       && fixp->fx_addsy == GOT_symbol)
11515     {
11516       if (!object_64bit)
11517         code = BFD_RELOC_386_GOTPC;
11518       else
11519         code = BFD_RELOC_X86_64_GOTPC32;
11520     }
11521   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
11522       && GOT_symbol
11523       && fixp->fx_addsy == GOT_symbol)
11524     {
11525       code = BFD_RELOC_X86_64_GOTPC64;
11526     }
11527
11528   rel = XNEW (arelent);
11529   rel->sym_ptr_ptr = XNEW (asymbol *);
11530   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
11531
11532   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
11533
11534   if (!use_rela_relocations)
11535     {
11536       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
11537          vtable entry to be used in the relocation's section offset.  */
11538       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
11539         rel->address = fixp->fx_offset;
11540 #if defined (OBJ_COFF) && defined (TE_PE)
11541       else if (fixp->fx_addsy && S_IS_WEAK (fixp->fx_addsy))
11542         rel->addend = fixp->fx_addnumber - (S_GET_VALUE (fixp->fx_addsy) * 2);
11543       else
11544 #endif
11545       rel->addend = 0;
11546     }
11547   /* Use the rela in 64bit mode.  */
11548   else
11549     {
11550       if (disallow_64bit_reloc)
11551         switch (code)
11552           {
11553           case BFD_RELOC_X86_64_DTPOFF64:
11554           case BFD_RELOC_X86_64_TPOFF64:
11555           case BFD_RELOC_64_PCREL:
11556           case BFD_RELOC_X86_64_GOTOFF64:
11557           case BFD_RELOC_X86_64_GOT64:
11558           case BFD_RELOC_X86_64_GOTPCREL64:
11559           case BFD_RELOC_X86_64_GOTPC64:
11560           case BFD_RELOC_X86_64_GOTPLT64:
11561           case BFD_RELOC_X86_64_PLTOFF64:
11562             as_bad_where (fixp->fx_file, fixp->fx_line,
11563                           _("cannot represent relocation type %s in x32 mode"),
11564                           bfd_get_reloc_code_name (code));
11565             break;
11566           default:
11567             break;
11568           }
11569
11570       if (!fixp->fx_pcrel)
11571         rel->addend = fixp->fx_offset;
11572       else
11573         switch (code)
11574           {
11575           case BFD_RELOC_X86_64_PLT32:
11576           case BFD_RELOC_X86_64_GOT32:
11577           case BFD_RELOC_X86_64_GOTPCREL:
11578           case BFD_RELOC_X86_64_GOTPCRELX:
11579           case BFD_RELOC_X86_64_REX_GOTPCRELX:
11580           case BFD_RELOC_X86_64_TLSGD:
11581           case BFD_RELOC_X86_64_TLSLD:
11582           case BFD_RELOC_X86_64_GOTTPOFF:
11583           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
11584           case BFD_RELOC_X86_64_TLSDESC_CALL:
11585             rel->addend = fixp->fx_offset - fixp->fx_size;
11586             break;
11587           default:
11588             rel->addend = (section->vma
11589                            - fixp->fx_size
11590                            + fixp->fx_addnumber
11591                            + md_pcrel_from (fixp));
11592             break;
11593           }
11594     }
11595
11596   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
11597   if (rel->howto == NULL)
11598     {
11599       as_bad_where (fixp->fx_file, fixp->fx_line,
11600                     _("cannot represent relocation type %s"),
11601                     bfd_get_reloc_code_name (code));
11602       /* Set howto to a garbage value so that we can keep going.  */
11603       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
11604       gas_assert (rel->howto != NULL);
11605     }
11606
11607   return rel;
11608 }
11609
11610 #include "tc-i386-intel.c"
11611
11612 void
11613 tc_x86_parse_to_dw2regnum (expressionS *exp)
11614 {
11615   int saved_naked_reg;
11616   char saved_register_dot;
11617
11618   saved_naked_reg = allow_naked_reg;
11619   allow_naked_reg = 1;
11620   saved_register_dot = register_chars['.'];
11621   register_chars['.'] = '.';
11622   allow_pseudo_reg = 1;
11623   expression_and_evaluate (exp);
11624   allow_pseudo_reg = 0;
11625   register_chars['.'] = saved_register_dot;
11626   allow_naked_reg = saved_naked_reg;
11627
11628   if (exp->X_op == O_register && exp->X_add_number >= 0)
11629     {
11630       if ((addressT) exp->X_add_number < i386_regtab_size)
11631         {
11632           exp->X_op = O_constant;
11633           exp->X_add_number = i386_regtab[exp->X_add_number]
11634                               .dw2_regnum[flag_code >> 1];
11635         }
11636       else
11637         exp->X_op = O_illegal;
11638     }
11639 }
11640
11641 void
11642 tc_x86_frame_initial_instructions (void)
11643 {
11644   static unsigned int sp_regno[2];
11645
11646   if (!sp_regno[flag_code >> 1])
11647     {
11648       char *saved_input = input_line_pointer;
11649       char sp[][4] = {"esp", "rsp"};
11650       expressionS exp;
11651
11652       input_line_pointer = sp[flag_code >> 1];
11653       tc_x86_parse_to_dw2regnum (&exp);
11654       gas_assert (exp.X_op == O_constant);
11655       sp_regno[flag_code >> 1] = exp.X_add_number;
11656       input_line_pointer = saved_input;
11657     }
11658
11659   cfi_add_CFA_def_cfa (sp_regno[flag_code >> 1], -x86_cie_data_alignment);
11660   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
11661 }
11662
11663 int
11664 x86_dwarf2_addr_size (void)
11665 {
11666 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
11667   if (x86_elf_abi == X86_64_X32_ABI)
11668     return 4;
11669 #endif
11670   return bfd_arch_bits_per_address (stdoutput) / 8;
11671 }
11672
11673 int
11674 i386_elf_section_type (const char *str, size_t len)
11675 {
11676   if (flag_code == CODE_64BIT
11677       && len == sizeof ("unwind") - 1
11678       && strncmp (str, "unwind", 6) == 0)
11679     return SHT_X86_64_UNWIND;
11680
11681   return -1;
11682 }
11683
11684 #ifdef TE_SOLARIS
11685 void
11686 i386_solaris_fix_up_eh_frame (segT sec)
11687 {
11688   if (flag_code == CODE_64BIT)
11689     elf_section_type (sec) = SHT_X86_64_UNWIND;
11690 }
11691 #endif
11692
11693 #ifdef TE_PE
11694 void
11695 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
11696 {
11697   expressionS exp;
11698
11699   exp.X_op = O_secrel;
11700   exp.X_add_symbol = symbol;
11701   exp.X_add_number = 0;
11702   emit_expr (&exp, size);
11703 }
11704 #endif
11705
11706 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
11707 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
11708
11709 bfd_vma
11710 x86_64_section_letter (int letter, const char **ptr_msg)
11711 {
11712   if (flag_code == CODE_64BIT)
11713     {
11714       if (letter == 'l')
11715         return SHF_X86_64_LARGE;
11716
11717       *ptr_msg = _("bad .section directive: want a,l,w,x,M,S,G,T in string");
11718     }
11719   else
11720     *ptr_msg = _("bad .section directive: want a,w,x,M,S,G,T in string");
11721   return -1;
11722 }
11723
11724 bfd_vma
11725 x86_64_section_word (char *str, size_t len)
11726 {
11727   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
11728     return SHF_X86_64_LARGE;
11729
11730   return -1;
11731 }
11732
11733 static void
11734 handle_large_common (int small ATTRIBUTE_UNUSED)
11735 {
11736   if (flag_code != CODE_64BIT)
11737     {
11738       s_comm_internal (0, elf_common_parse);
11739       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
11740     }
11741   else
11742     {
11743       static segT lbss_section;
11744       asection *saved_com_section_ptr = elf_com_section_ptr;
11745       asection *saved_bss_section = bss_section;
11746
11747       if (lbss_section == NULL)
11748         {
11749           flagword applicable;
11750           segT seg = now_seg;
11751           subsegT subseg = now_subseg;
11752
11753           /* The .lbss section is for local .largecomm symbols.  */
11754           lbss_section = subseg_new (".lbss", 0);
11755           applicable = bfd_applicable_section_flags (stdoutput);
11756           bfd_set_section_flags (stdoutput, lbss_section,
11757                                  applicable & SEC_ALLOC);
11758           seg_info (lbss_section)->bss = 1;
11759
11760           subseg_set (seg, subseg);
11761         }
11762
11763       elf_com_section_ptr = &_bfd_elf_large_com_section;
11764       bss_section = lbss_section;
11765
11766       s_comm_internal (0, elf_common_parse);
11767
11768       elf_com_section_ptr = saved_com_section_ptr;
11769       bss_section = saved_bss_section;
11770     }
11771 }
11772 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */