gas/config/tc-i386.c

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