gas/config/tc-i386.c

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