gas/config/tc-i386.c

   1 /* tc-i386.c -- Assemble code for the Intel 80386
   2    Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23 /* Intel 80386 machine specific gas.
  24    Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
  25    x86_64 support by Jan Hubicka (jh@suse.cz)
  26    VIA PadLock support by Michal Ludvig (mludvig@suse.cz)
  27    Bugs & suggestions are completely welcome.  This is free software.
  28    Please help us make it better.  */
  29
  30 #include "as.h"
  31 #include "safe-ctype.h"
  32 #include "subsegs.h"
  33 #include "dwarf2dbg.h"
  34 #include "dw2gencfi.h"
  35 #include "opcode/i386.h"
  36 #include "elf/x86-64.h"
  37
  38 #ifndef REGISTER_WARNINGS
  39 #define REGISTER_WARNINGS 1
  40 #endif
  41
  42 #ifndef INFER_ADDR_PREFIX
  43 #define INFER_ADDR_PREFIX 1
  44 #endif
  45
  46 #ifndef SCALE1_WHEN_NO_INDEX
  47 /* Specifying a scale factor besides 1 when there is no index is
  48    futile.  eg. `mov (%ebx,2),%al' does exactly the same as
  49    `mov (%ebx),%al'.  To slavishly follow what the programmer
  50    specified, set SCALE1_WHEN_NO_INDEX to 0.  */
  51 #define SCALE1_WHEN_NO_INDEX 1
  52 #endif
  53
  54 #ifndef DEFAULT_ARCH
  55 #define DEFAULT_ARCH "i386"
  56 #endif
  57
  58 #ifndef INLINE
  59 #if __GNUC__ >= 2
  60 #define INLINE __inline__
  61 #else
  62 #define INLINE
  63 #endif
  64 #endif
  65
  66 static INLINE unsigned int mode_from_disp_size PARAMS ((unsigned int));
  67 static INLINE int fits_in_signed_byte PARAMS ((offsetT));
  68 static INLINE int fits_in_unsigned_byte PARAMS ((offsetT));
  69 static INLINE int fits_in_unsigned_word PARAMS ((offsetT));
  70 static INLINE int fits_in_signed_word PARAMS ((offsetT));
  71 static INLINE int fits_in_unsigned_long PARAMS ((offsetT));
  72 static INLINE int fits_in_signed_long PARAMS ((offsetT));
  73 static int smallest_imm_type PARAMS ((offsetT));
  74 static offsetT offset_in_range PARAMS ((offsetT, int));
  75 static int add_prefix PARAMS ((unsigned int));
  76 static void set_code_flag PARAMS ((int));
  77 static void set_16bit_gcc_code_flag PARAMS ((int));
  78 static void set_intel_syntax PARAMS ((int));
  79 static void set_cpu_arch PARAMS ((int));
  80 #ifdef TE_PE
  81 static void pe_directive_secrel PARAMS ((int));
  82 #endif
  83 static void signed_cons PARAMS ((int));
  84 static char *output_invalid PARAMS ((int c));
  85 static int i386_operand PARAMS ((char *operand_string));
  86 static int i386_intel_operand PARAMS ((char *operand_string, int got_a_float));
  87 static const reg_entry *parse_register PARAMS ((char *reg_string,
  88                                                 char **end_op));
  89 static char *parse_insn PARAMS ((char *, char *));
  90 static char *parse_operands PARAMS ((char *, const char *));
  91 static void swap_operands PARAMS ((void));
  92 static void swap_imm_operands PARAMS ((void));
  93 static void optimize_imm PARAMS ((void));
  94 static void optimize_disp PARAMS ((void));
  95 static int match_template PARAMS ((void));
  96 static int check_string PARAMS ((void));
  97 static int process_suffix PARAMS ((void));
  98 static int check_byte_reg PARAMS ((void));
  99 static int check_long_reg PARAMS ((void));
 100 static int check_qword_reg PARAMS ((void));
 101 static int check_word_reg PARAMS ((void));
 102 static int finalize_imm PARAMS ((void));
 103 static int process_operands PARAMS ((void));
 104 static const seg_entry *build_modrm_byte PARAMS ((void));
 105 static void output_insn PARAMS ((void));
 106 static void output_branch PARAMS ((void));
 107 static void output_jump PARAMS ((void));
 108 static void output_interseg_jump PARAMS ((void));
 109 static void output_imm PARAMS ((fragS *insn_start_frag,
 110                                 offsetT insn_start_off));
 111 static void output_disp PARAMS ((fragS *insn_start_frag,
 112                                  offsetT insn_start_off));
 113 #ifndef I386COFF
 114 static void s_bss PARAMS ((int));
 115 #endif
 116 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 117 static void handle_large_common (int small ATTRIBUTE_UNUSED);
 118 #endif
 119
 120 static const char *default_arch = DEFAULT_ARCH;
 121
 122 /* 'md_assemble ()' gathers together information and puts it into a
 123    i386_insn.  */
 124
 125 union i386_op
 126   {
 127     expressionS *disps;
 128     expressionS *imms;
 129     const reg_entry *regs;
 130   };
 131
 132 struct _i386_insn
 133   {
 134     /* TM holds the template for the insn were currently assembling.  */
 135     template tm;
 136
 137     /* SUFFIX holds the instruction mnemonic suffix if given.
 138        (e.g. 'l' for 'movl')  */
 139     char suffix;
 140
 141     /* OPERANDS gives the number of given operands.  */
 142     unsigned int operands;
 143
 144     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
 145        of given register, displacement, memory operands and immediate
 146        operands.  */
 147     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
 148
 149     /* TYPES [i] is the type (see above #defines) which tells us how to
 150        use OP[i] for the corresponding operand.  */
 151     unsigned int types[MAX_OPERANDS];
 152
 153     /* Displacement expression, immediate expression, or register for each
 154        operand.  */
 155     union i386_op op[MAX_OPERANDS];
 156
 157     /* Flags for operands.  */
 158     unsigned int flags[MAX_OPERANDS];
 159 #define Operand_PCrel 1
 160
 161     /* Relocation type for operand */
 162     enum bfd_reloc_code_real reloc[MAX_OPERANDS];
 163
 164     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
 165        the base index byte below.  */
 166     const reg_entry *base_reg;
 167     const reg_entry *index_reg;
 168     unsigned int log2_scale_factor;
 169
 170     /* SEG gives the seg_entries of this insn.  They are zero unless
 171        explicit segment overrides are given.  */
 172     const seg_entry *seg[2];
 173
 174     /* PREFIX holds all the given prefix opcodes (usually null).
 175        PREFIXES is the number of prefix opcodes.  */
 176     unsigned int prefixes;
 177     unsigned char prefix[MAX_PREFIXES];
 178
 179     /* RM and SIB are the modrm byte and the sib byte where the
 180        addressing modes of this insn are encoded.  */
 181
 182     modrm_byte rm;
 183     rex_byte rex;
 184     sib_byte sib;
 185   };
 186
 187 typedef struct _i386_insn i386_insn;
 188
 189 /* List of chars besides those in app.c:symbol_chars that can start an
 190    operand.  Used to prevent the scrubber eating vital white-space.  */
 191 const char extra_symbol_chars[] = "*%-(["
 192 #ifdef LEX_AT
 193         "@"
 194 #endif
 195 #ifdef LEX_QM
 196         "?"
 197 #endif
 198         ;
 199
 200 #if (defined (TE_I386AIX)                               \
 201      || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
 202          && !defined (TE_GNU)                           \
 203          && !defined (TE_LINUX)                         \
 204          && !defined (TE_NETWARE)                       \
 205          && !defined (TE_FreeBSD)                       \
 206          && !defined (TE_NetBSD)))
 207 /* This array holds the chars that always start a comment.  If the
 208    pre-processor is disabled, these aren't very useful.  The option
 209    --divide will remove '/' from this list.  */
 210 const char *i386_comment_chars = "#/";
 211 #define SVR4_COMMENT_CHARS 1
 212 #define PREFIX_SEPARATOR '\\'
 213
 214 #else
 215 const char *i386_comment_chars = "#";
 216 #define PREFIX_SEPARATOR '/'
 217 #endif
 218
 219 /* This array holds the chars that only start a comment at the beginning of
 220    a line.  If the line seems to have the form '# 123 filename'
 221    .line and .file directives will appear in the pre-processed output.
 222    Note that input_file.c hand checks for '#' at the beginning of the
 223    first line of the input file.  This is because the compiler outputs
 224    #NO_APP at the beginning of its output.
 225    Also note that comments started like this one will always work if
 226    '/' isn't otherwise defined.  */
 227 const char line_comment_chars[] = "#/";
 228
 229 const char line_separator_chars[] = ";";
 230
 231 /* Chars that can be used to separate mant from exp in floating point
 232    nums.  */
 233 const char EXP_CHARS[] = "eE";
 234
 235 /* Chars that mean this number is a floating point constant
 236    As in 0f12.456
 237    or    0d1.2345e12.  */
 238 const char FLT_CHARS[] = "fFdDxX";
 239
 240 /* Tables for lexical analysis.  */
 241 static char mnemonic_chars[256];
 242 static char register_chars[256];
 243 static char operand_chars[256];
 244 static char identifier_chars[256];
 245 static char digit_chars[256];
 246
 247 /* Lexical macros.  */
 248 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
 249 #define is_operand_char(x) (operand_chars[(unsigned char) x])
 250 #define is_register_char(x) (register_chars[(unsigned char) x])
 251 #define is_space_char(x) ((x) == ' ')
 252 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
 253 #define is_digit_char(x) (digit_chars[(unsigned char) x])
 254
 255 /* All non-digit non-letter characters that may occur in an operand.  */
 256 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
 257
 258 /* md_assemble() always leaves the strings it's passed unaltered.  To
 259    effect this we maintain a stack of saved characters that we've smashed
 260    with '\0's (indicating end of strings for various sub-fields of the
 261    assembler instruction).  */
 262 static char save_stack[32];
 263 static char *save_stack_p;
 264 #define END_STRING_AND_SAVE(s) \
 265         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
 266 #define RESTORE_END_STRING(s) \
 267         do { *(s) = *--save_stack_p; } while (0)
 268
 269 /* The instruction we're assembling.  */
 270 static i386_insn i;
 271
 272 /* Possible templates for current insn.  */
 273 static const templates *current_templates;
 274
 275 /* Per instruction expressionS buffers: max displacements & immediates.  */
 276 static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
 277 static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
 278
 279 /* Current operand we are working on.  */
 280 static int this_operand;
 281
 282 /* We support four different modes.  FLAG_CODE variable is used to distinguish
 283    these.  */
 284
 285 enum flag_code {
 286         CODE_32BIT,
 287         CODE_16BIT,
 288         CODE_64BIT };
 289 #define NUM_FLAG_CODE ((int) CODE_64BIT + 1)
 290
 291 static enum flag_code flag_code;
 292 static unsigned int object_64bit;
 293 static int use_rela_relocations = 0;
 294
 295 /* The names used to print error messages.  */
 296 static const char *flag_code_names[] =
 297   {
 298     "32",
 299     "16",
 300     "64"
 301   };
 302
 303 /* 1 for intel syntax,
 304    0 if att syntax.  */
 305 static int intel_syntax = 0;
 306
 307 /* 1 if register prefix % not required.  */
 308 static int allow_naked_reg = 0;
 309
 310 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
 311    leave, push, and pop instructions so that gcc has the same stack
 312    frame as in 32 bit mode.  */
 313 static char stackop_size = '\0';
 314
 315 /* Non-zero to optimize code alignment.  */
 316 int optimize_align_code = 1;
 317
 318 /* Non-zero to quieten some warnings.  */
 319 static int quiet_warnings = 0;
 320
 321 /* CPU name.  */
 322 static const char *cpu_arch_name = NULL;
 323 static const char *cpu_sub_arch_name = NULL;
 324
 325 /* CPU feature flags.  */
 326 static unsigned int cpu_arch_flags = CpuUnknownFlags | CpuNo64;
 327
 328 /* If we have selected a cpu we are generating instructions for.  */
 329 static int cpu_arch_tune_set = 0;
 330
 331 /* Cpu we are generating instructions for.  */
 332 static enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
 333
 334 /* CPU feature flags of cpu we are generating instructions for.  */
 335 static unsigned int cpu_arch_tune_flags = 0;
 336
 337 /* CPU instruction set architecture used.  */
 338 static enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
 339
 340 /* CPU feature flags of instruction set architecture used.  */
 341 static unsigned int cpu_arch_isa_flags = 0;
 342
 343 /* If set, conditional jumps are not automatically promoted to handle
 344    larger than a byte offset.  */
 345 static unsigned int no_cond_jump_promotion = 0;
 346
 347 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
 348 static symbolS *GOT_symbol;
 349
 350 /* The dwarf2 return column, adjusted for 32 or 64 bit.  */
 351 unsigned int x86_dwarf2_return_column;
 352
 353 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
 354 int x86_cie_data_alignment;
 355
 356 /* Interface to relax_segment.
 357    There are 3 major relax states for 386 jump insns because the
 358    different types of jumps add different sizes to frags when we're
 359    figuring out what sort of jump to choose to reach a given label.  */
 360
 361 /* Types.  */
 362 #define UNCOND_JUMP 0
 363 #define COND_JUMP 1
 364 #define COND_JUMP86 2
 365
 366 /* Sizes.  */
 367 #define CODE16  1
 368 #define SMALL   0
 369 #define SMALL16 (SMALL | CODE16)
 370 #define BIG     2
 371 #define BIG16   (BIG | CODE16)
 372
 373 #ifndef INLINE
 374 #ifdef __GNUC__
 375 #define INLINE __inline__
 376 #else
 377 #define INLINE
 378 #endif
 379 #endif
 380
 381 #define ENCODE_RELAX_STATE(type, size) \
 382   ((relax_substateT) (((type) << 2) | (size)))
 383 #define TYPE_FROM_RELAX_STATE(s) \
 384   ((s) >> 2)
 385 #define DISP_SIZE_FROM_RELAX_STATE(s) \
 386     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
 387
 388 /* This table is used by relax_frag to promote short jumps to long
 389    ones where necessary.  SMALL (short) jumps may be promoted to BIG
 390    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
 391    don't allow a short jump in a 32 bit code segment to be promoted to
 392    a 16 bit offset jump because it's slower (requires data size
 393    prefix), and doesn't work, unless the destination is in the bottom
 394    64k of the code segment (The top 16 bits of eip are zeroed).  */
 395
 396 const relax_typeS md_relax_table[] =
 397 {
 398   /* The fields are:
 399      1) most positive reach of this state,
 400      2) most negative reach of this state,
 401      3) how many bytes this mode will have in the variable part of the frag
 402      4) which index into the table to try if we can't fit into this one.  */
 403
 404   /* UNCOND_JUMP states.  */
 405   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
 406   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
 407   /* dword jmp adds 4 bytes to frag:
 408      0 extra opcode bytes, 4 displacement bytes.  */
 409   {0, 0, 4, 0},
 410   /* word jmp adds 2 byte2 to frag:
 411      0 extra opcode bytes, 2 displacement bytes.  */
 412   {0, 0, 2, 0},
 413
 414   /* COND_JUMP states.  */
 415   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
 416   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
 417   /* dword conditionals adds 5 bytes to frag:
 418      1 extra opcode byte, 4 displacement bytes.  */
 419   {0, 0, 5, 0},
 420   /* word conditionals add 3 bytes to frag:
 421      1 extra opcode byte, 2 displacement bytes.  */
 422   {0, 0, 3, 0},
 423
 424   /* COND_JUMP86 states.  */
 425   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
 426   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
 427   /* dword conditionals adds 5 bytes to frag:
 428      1 extra opcode byte, 4 displacement bytes.  */
 429   {0, 0, 5, 0},
 430   /* word conditionals add 4 bytes to frag:
 431      1 displacement byte and a 3 byte long branch insn.  */
 432   {0, 0, 4, 0}
 433 };
 434
 435 static const arch_entry cpu_arch[] =
 436 {
 437   {"generic32", PROCESSOR_GENERIC32,
 438    Cpu186|Cpu286|Cpu386},
 439   {"generic64", PROCESSOR_GENERIC64,
 440    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 441    |CpuMMX2|CpuSSE|CpuSSE2},
 442   {"i8086", PROCESSOR_UNKNOWN,
 443    0},
 444   {"i186", PROCESSOR_UNKNOWN,
 445    Cpu186},
 446   {"i286", PROCESSOR_UNKNOWN,
 447    Cpu186|Cpu286},
 448   {"i386", PROCESSOR_GENERIC32,
 449    Cpu186|Cpu286|Cpu386},
 450   {"i486", PROCESSOR_I486,
 451    Cpu186|Cpu286|Cpu386|Cpu486},
 452   {"i586", PROCESSOR_PENTIUM,
 453    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586},
 454   {"i686", PROCESSOR_PENTIUMPRO,
 455    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686},
 456   {"pentium", PROCESSOR_PENTIUM,
 457    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586},
 458   {"pentiumpro",PROCESSOR_PENTIUMPRO,
 459    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686},
 460   {"pentiumii", PROCESSOR_PENTIUMPRO,
 461    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX},
 462   {"pentiumiii",PROCESSOR_PENTIUMPRO,
 463    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuMMX2|CpuSSE},
 464   {"pentium4", PROCESSOR_PENTIUM4,
 465    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 466    |CpuMMX2|CpuSSE|CpuSSE2},
 467   {"prescott", PROCESSOR_NOCONA,
 468    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 469    |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
 470   {"nocona", PROCESSOR_NOCONA,
 471    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 472    |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
 473   {"yonah", PROCESSOR_CORE,
 474    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 475    |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
 476   {"core", PROCESSOR_CORE,
 477    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 478    |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
 479   {"merom", PROCESSOR_CORE2,
 480    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 481    |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3},
 482   {"core2", PROCESSOR_CORE2,
 483    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
 484    |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3},
 485   {"k6", PROCESSOR_K6,
 486    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX},
 487   {"k6_2", PROCESSOR_K6,
 488    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX|Cpu3dnow},
 489   {"athlon", PROCESSOR_ATHLON,
 490    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
 491    |CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA},
 492   {"sledgehammer", PROCESSOR_K8,
 493    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
 494    |CpuSledgehammer|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2},
 495   {"opteron", PROCESSOR_K8,
 496    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
 497    |CpuSledgehammer|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2},
 498   {"k8", PROCESSOR_K8,
 499    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
 500    |CpuSledgehammer|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2},
 501   {"amdfam10", PROCESSOR_AMDFAM10,
 502    Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuSledgehammer
 503    |CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a
 504    |CpuABM},
 505   {".mmx", PROCESSOR_UNKNOWN,
 506    CpuMMX},
 507   {".sse", PROCESSOR_UNKNOWN,
 508    CpuMMX|CpuMMX2|CpuSSE},
 509   {".sse2", PROCESSOR_UNKNOWN,
 510    CpuMMX|CpuMMX2|CpuSSE|CpuSSE2},
 511   {".sse3", PROCESSOR_UNKNOWN,
 512    CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
 513   {".ssse3", PROCESSOR_UNKNOWN,
 514    CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3},
 515   {".3dnow", PROCESSOR_UNKNOWN,
 516    CpuMMX|Cpu3dnow},
 517   {".3dnowa", PROCESSOR_UNKNOWN,
 518    CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA},
 519   {".padlock", PROCESSOR_UNKNOWN,
 520    CpuPadLock},
 521   {".pacifica", PROCESSOR_UNKNOWN,
 522    CpuSVME},
 523   {".svme", PROCESSOR_UNKNOWN,
 524    CpuSVME},
 525   {".sse4a", PROCESSOR_UNKNOWN,
 526    CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a},
 527   {".abm", PROCESSOR_UNKNOWN,
 528    CpuABM}
 529 };
 530
 531 const pseudo_typeS md_pseudo_table[] =
 532 {
 533 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
 534   {"align", s_align_bytes, 0},
 535 #else
 536   {"align", s_align_ptwo, 0},
 537 #endif
 538   {"arch", set_cpu_arch, 0},
 539 #ifndef I386COFF
 540   {"bss", s_bss, 0},
 541 #endif
 542   {"ffloat", float_cons, 'f'},
 543   {"dfloat", float_cons, 'd'},
 544   {"tfloat", float_cons, 'x'},
 545   {"value", cons, 2},
 546   {"slong", signed_cons, 4},
 547   {"noopt", s_ignore, 0},
 548   {"optim", s_ignore, 0},
 549   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
 550   {"code16", set_code_flag, CODE_16BIT},
 551   {"code32", set_code_flag, CODE_32BIT},
 552   {"code64", set_code_flag, CODE_64BIT},
 553   {"intel_syntax", set_intel_syntax, 1},
 554   {"att_syntax", set_intel_syntax, 0},
 555 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
 556   {"largecomm", handle_large_common, 0},
 557 #else
 558   {"file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0},
 559   {"loc", dwarf2_directive_loc, 0},
 560   {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
 561 #endif
 562 #ifdef TE_PE
 563   {"secrel32", pe_directive_secrel, 0},
 564 #endif
 565   {0, 0, 0}
 566 };
 567
 568 /* For interface with expression ().  */
 569 extern char *input_line_pointer;
 570
 571 /* Hash table for instruction mnemonic lookup.  */
 572 static struct hash_control *op_hash;
 573
 574 /* Hash table for register lookup.  */
 575 static struct hash_control *reg_hash;
 576 \f
 577 void
 578 i386_align_code (fragP, count)
 579      fragS *fragP;
 580      int count;
 581 {
 582   /* Various efficient no-op patterns for aligning code labels.
 583      Note: Don't try to assemble the instructions in the comments.
 584      0L and 0w are not legal.  */
 585   static const char f32_1[] =
 586     {0x90};                                     /* nop                  */
 587   static const char f32_2[] =
 588     {0x66,0x90};                                /* xchg %ax,%ax */
 589   static const char f32_3[] =
 590     {0x8d,0x76,0x00};                           /* leal 0(%esi),%esi    */
 591   static const char f32_4[] =
 592     {0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
 593   static const char f32_5[] =
 594     {0x90,                                      /* nop                  */
 595      0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
 596   static const char f32_6[] =
 597     {0x8d,0xb6,0x00,0x00,0x00,0x00};            /* leal 0L(%esi),%esi   */
 598   static const char f32_7[] =
 599     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
 600   static const char f32_8[] =
 601     {0x90,                                      /* nop                  */
 602      0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
 603   static const char f32_9[] =
 604     {0x89,0xf6,                                 /* movl %esi,%esi       */
 605      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 606   static const char f32_10[] =
 607     {0x8d,0x76,0x00,                            /* leal 0(%esi),%esi    */
 608      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 609   static const char f32_11[] =
 610     {0x8d,0x74,0x26,0x00,                       /* leal 0(%esi,1),%esi  */
 611      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 612   static const char f32_12[] =
 613     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
 614      0x8d,0xbf,0x00,0x00,0x00,0x00};            /* leal 0L(%edi),%edi   */
 615   static const char f32_13[] =
 616     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
 617      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 618   static const char f32_14[] =
 619     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00,        /* leal 0L(%esi,1),%esi */
 620      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
 621   static const char f32_15[] =
 622     {0xeb,0x0d,0x90,0x90,0x90,0x90,0x90,        /* jmp .+15; lotsa nops */
 623      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
 624   static const char f16_3[] =
 625     {0x8d,0x74,0x00};                           /* lea 0(%esi),%esi     */
 626   static const char f16_4[] =
 627     {0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
 628   static const char f16_5[] =
 629     {0x90,                                      /* nop                  */
 630      0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
 631   static const char f16_6[] =
 632     {0x89,0xf6,                                 /* mov %si,%si          */
 633      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 634   static const char f16_7[] =
 635     {0x8d,0x74,0x00,                            /* lea 0(%si),%si       */
 636      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 637   static const char f16_8[] =
 638     {0x8d,0xb4,0x00,0x00,                       /* lea 0w(%si),%si      */
 639      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
 640   static const char *const f32_patt[] = {
 641     f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
 642     f32_9, f32_10, f32_11, f32_12, f32_13, f32_14, f32_15
 643   };
 644   static const char *const f16_patt[] = {
 645     f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8,
 646     f32_15, f32_15, f32_15, f32_15, f32_15, f32_15, f32_15
 647   };
 648   /* nopl (%[re]ax) */
 649   static const char alt_3[] =
 650     {0x0f,0x1f,0x00};
 651   /* nopl 0(%[re]ax) */
 652   static const char alt_4[] =
 653     {0x0f,0x1f,0x40,0x00};
 654   /* nopl 0(%[re]ax,%[re]ax,1) */
 655   static const char alt_5[] =
 656     {0x0f,0x1f,0x44,0x00,0x00};
 657   /* nopw 0(%[re]ax,%[re]ax,1) */
 658   static const char alt_6[] =
 659     {0x66,0x0f,0x1f,0x44,0x00,0x00};
 660   /* nopl 0L(%[re]ax) */
 661   static const char alt_7[] =
 662     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
 663   /* nopl 0L(%[re]ax,%[re]ax,1) */
 664   static const char alt_8[] =
 665     {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 666   /* nopw 0L(%[re]ax,%[re]ax,1) */
 667   static const char alt_9[] =
 668     {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 669   /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
 670   static const char alt_10[] =
 671     {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 672   /* data16
 673      nopw %cs:0L(%[re]ax,%[re]ax,1) */
 674   static const char alt_long_11[] =
 675     {0x66,
 676      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 677   /* data16
 678      data16
 679      nopw %cs:0L(%[re]ax,%[re]ax,1) */
 680   static const char alt_long_12[] =
 681     {0x66,
 682      0x66,
 683      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 684   /* data16
 685      data16
 686      data16
 687      nopw %cs:0L(%[re]ax,%[re]ax,1) */
 688   static const char alt_long_13[] =
 689     {0x66,
 690      0x66,
 691      0x66,
 692      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 693   /* data16
 694      data16
 695      data16
 696      data16
 697      nopw %cs:0L(%[re]ax,%[re]ax,1) */
 698   static const char alt_long_14[] =
 699     {0x66,
 700      0x66,
 701      0x66,
 702      0x66,
 703      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 704   /* data16
 705      data16
 706      data16
 707      data16
 708      data16
 709      nopw %cs:0L(%[re]ax,%[re]ax,1) */
 710   static const char alt_long_15[] =
 711     {0x66,
 712      0x66,
 713      0x66,
 714      0x66,
 715      0x66,
 716      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 717   /* nopl 0(%[re]ax,%[re]ax,1)
 718      nopw 0(%[re]ax,%[re]ax,1) */
 719   static const char alt_short_11[] =
 720     {0x0f,0x1f,0x44,0x00,0x00,
 721      0x66,0x0f,0x1f,0x44,0x00,0x00};
 722   /* nopw 0(%[re]ax,%[re]ax,1)
 723      nopw 0(%[re]ax,%[re]ax,1) */
 724   static const char alt_short_12[] =
 725     {0x66,0x0f,0x1f,0x44,0x00,0x00,
 726      0x66,0x0f,0x1f,0x44,0x00,0x00};
 727   /* nopw 0(%[re]ax,%[re]ax,1)
 728      nopl 0L(%[re]ax) */
 729   static const char alt_short_13[] =
 730     {0x66,0x0f,0x1f,0x44,0x00,0x00,
 731      0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
 732   /* nopl 0L(%[re]ax)
 733      nopl 0L(%[re]ax) */
 734   static const char alt_short_14[] =
 735     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
 736      0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
 737   /* nopl 0L(%[re]ax)
 738      nopl 0L(%[re]ax,%[re]ax,1) */
 739   static const char alt_short_15[] =
 740     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
 741      0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
 742   static const char *const alt_short_patt[] = {
 743     f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
 744     alt_9, alt_10, alt_short_11, alt_short_12, alt_short_13,
 745     alt_short_14, alt_short_15
 746   };
 747   static const char *const alt_long_patt[] = {
 748     f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
 749     alt_9, alt_10, alt_long_11, alt_long_12, alt_long_13,
 750     alt_long_14, alt_long_15
 751   };
 752
 753   if (count <= 0 || count > 15)
 754     return;
 755
 756   /* We need to decide which NOP sequence to use for 32bit and
 757      64bit. When -mtune= is used:
 758
 759      1. For PROCESSOR_I486, PROCESSOR_PENTIUM and PROCESSOR_GENERIC32,
 760      f32_patt will be used.
 761      2. For PROCESSOR_K8 and PROCESSOR_AMDFAM10 in 64bit, NOPs with 0x66 prefix will be used.
 762      3. For PROCESSOR_CORE2, alt_long_patt will be used.
 763      4. For PROCESSOR_PENTIUMPRO, PROCESSOR_PENTIUM4, PROCESSOR_NOCONA,
 764      PROCESSOR_CORE, PROCESSOR_CORE2, PROCESSOR_K6, PROCESSOR_ATHLON
 765      and PROCESSOR_GENERIC64, alt_short_patt will be used.
 766
 767      When -mtune= isn't used, alt_short_patt will be used if
 768      cpu_arch_isa_flags has Cpu686. Otherwise, f32_patt will be used.
 769
 770      When -march= or .arch is used, we can't use anything beyond
 771      cpu_arch_isa_flags.   */
 772
 773   if (flag_code == CODE_16BIT)
 774     {
 775       memcpy (fragP->fr_literal + fragP->fr_fix,
 776               f16_patt[count - 1], count);
 777       if (count > 8)
 778         /* Adjust jump offset.  */
 779         fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
 780     }
 781   else if (flag_code == CODE_64BIT && cpu_arch_tune == PROCESSOR_K8)
 782     {
 783       int i;
 784       int nnops = (count + 3) / 4;
 785       int len = count / nnops;
 786       int remains = count - nnops * len;
 787       int pos = 0;
 788
 789       /* The recommended way to pad 64bit code is to use NOPs preceded
 790          by maximally four 0x66 prefixes.  Balance the size of nops.  */
 791       for (i = 0; i < remains; i++)
 792         {
 793           memset (fragP->fr_literal + fragP->fr_fix + pos, 0x66, len);
 794           fragP->fr_literal[fragP->fr_fix + pos + len] = 0x90;
 795           pos += len + 1;
 796         }
 797       for (; i < nnops; i++)
 798         {
 799           memset (fragP->fr_literal + fragP->fr_fix + pos, 0x66, len - 1);
 800           fragP->fr_literal[fragP->fr_fix + pos + len - 1] = 0x90;
 801           pos += len;
 802         }
 803     }
 804   else
 805     {
 806       const char *const *patt = NULL;
 807
 808       if (cpu_arch_isa == PROCESSOR_UNKNOWN)
 809         {
 810           /* PROCESSOR_UNKNOWN means that all ISAs may be used.  */
 811           switch (cpu_arch_tune)
 812             {
 813             case PROCESSOR_UNKNOWN:
 814               /* We use cpu_arch_isa_flags to check if we SHOULD
 815                  optimize for Cpu686.  */
 816               if ((cpu_arch_isa_flags & Cpu686) != 0)
 817                 patt = alt_short_patt;
 818               else
 819                 patt = f32_patt;
 820               break;
 821             case PROCESSOR_CORE2:
 822               patt = alt_long_patt;
 823               break;
 824             case PROCESSOR_PENTIUMPRO:
 825             case PROCESSOR_PENTIUM4:
 826             case PROCESSOR_NOCONA:
 827             case PROCESSOR_CORE:
 828             case PROCESSOR_K6:
 829             case PROCESSOR_ATHLON:
 830             case PROCESSOR_K8:
 831             case PROCESSOR_GENERIC64:
 832             case PROCESSOR_AMDFAM10:
 833               patt = alt_short_patt;
 834               break;
 835             case PROCESSOR_I486:
 836             case PROCESSOR_PENTIUM:
 837             case PROCESSOR_GENERIC32:
 838               patt = f32_patt;
 839               break;
 840             }
 841         }
 842       else
 843         {
 844           switch (cpu_arch_tune)
 845             {
 846             case PROCESSOR_UNKNOWN:
 847               /* When cpu_arch_isa is net, cpu_arch_tune shouldn't be
 848                  PROCESSOR_UNKNOWN.  */
 849               abort ();
 850               break;
 851
 852             case PROCESSOR_I486:
 853             case PROCESSOR_PENTIUM:
 854             case PROCESSOR_PENTIUMPRO:
 855             case PROCESSOR_PENTIUM4:
 856             case PROCESSOR_NOCONA:
 857             case PROCESSOR_CORE:
 858             case PROCESSOR_K6:
 859             case PROCESSOR_ATHLON:
 860             case PROCESSOR_K8:
 861             case PROCESSOR_AMDFAM10:
 862             case PROCESSOR_GENERIC32:
 863               /* We use cpu_arch_isa_flags to check if we CAN optimize
 864                  for Cpu686.  */
 865               if ((cpu_arch_isa_flags & Cpu686) != 0)
 866                 patt = alt_short_patt;
 867               else
 868                 patt = f32_patt;
 869               break;
 870             case PROCESSOR_CORE2:
 871               if ((cpu_arch_isa_flags & Cpu686) != 0)
 872                 patt = alt_long_patt;
 873               else
 874                 patt = f32_patt;
 875               break;
 876             case PROCESSOR_GENERIC64:
 877               patt = alt_short_patt;
 878               break;
 879             }
 880         }
 881
 882       memcpy (fragP->fr_literal + fragP->fr_fix,
 883               patt[count - 1], count);
 884     }
 885   fragP->fr_var = count;
 886 }
 887
 888 static INLINE unsigned int
 889 mode_from_disp_size (t)
 890      unsigned int t;
 891 {
 892   return (t & Disp8) ? 1 : (t & (Disp16 | Disp32 | Disp32S)) ? 2 : 0;
 893 }
 894
 895 static INLINE int
 896 fits_in_signed_byte (num)
 897      offsetT num;
 898 {
 899   return (num >= -128) && (num <= 127);
 900 }
 901
 902 static INLINE int
 903 fits_in_unsigned_byte (num)
 904      offsetT num;
 905 {
 906   return (num & 0xff) == num;
 907 }
 908
 909 static INLINE int
 910 fits_in_unsigned_word (num)
 911      offsetT num;
 912 {
 913   return (num & 0xffff) == num;
 914 }
 915
 916 static INLINE int
 917 fits_in_signed_word (num)
 918      offsetT num;
 919 {
 920   return (-32768 <= num) && (num <= 32767);
 921 }
 922
 923 static INLINE int
 924 fits_in_signed_long (num)
 925      offsetT num ATTRIBUTE_UNUSED;
 926 {
 927 #ifndef BFD64
 928   return 1;
 929 #else
 930   return (!(((offsetT) -1 << 31) & num)
 931           || (((offsetT) -1 << 31) & num) == ((offsetT) -1 << 31));
 932 #endif
 933 }                               /* fits_in_signed_long() */
 934
 935 static INLINE int
 936 fits_in_unsigned_long (num)
 937      offsetT num ATTRIBUTE_UNUSED;
 938 {
 939 #ifndef BFD64
 940   return 1;
 941 #else
 942   return (num & (((offsetT) 2 << 31) - 1)) == num;
 943 #endif
 944 }                               /* fits_in_unsigned_long() */
 945
 946 static int
 947 smallest_imm_type (num)
 948      offsetT num;
 949 {
 950   if (cpu_arch_flags != (Cpu186 | Cpu286 | Cpu386 | Cpu486 | CpuNo64))
 951     {
 952       /* This code is disabled on the 486 because all the Imm1 forms
 953          in the opcode table are slower on the i486.  They're the
 954          versions with the implicitly specified single-position
 955          displacement, which has another syntax if you really want to
 956          use that form.  */
 957       if (num == 1)
 958         return Imm1 | Imm8 | Imm8S | Imm16 | Imm32 | Imm32S | Imm64;
 959     }
 960   return (fits_in_signed_byte (num)
 961           ? (Imm8S | Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
 962           : fits_in_unsigned_byte (num)
 963           ? (Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
 964           : (fits_in_signed_word (num) || fits_in_unsigned_word (num))
 965           ? (Imm16 | Imm32 | Imm32S | Imm64)
 966           : fits_in_signed_long (num)
 967           ? (Imm32 | Imm32S | Imm64)
 968           : fits_in_unsigned_long (num)
 969           ? (Imm32 | Imm64)
 970           : Imm64);
 971 }
 972
 973 static offsetT
 974 offset_in_range (val, size)
 975      offsetT val;
 976      int size;
 977 {
 978   addressT mask;
 979
 980   switch (size)
 981     {
 982     case 1: mask = ((addressT) 1 <<  8) - 1; break;
 983     case 2: mask = ((addressT) 1 << 16) - 1; break;
 984     case 4: mask = ((addressT) 2 << 31) - 1; break;
 985 #ifdef BFD64
 986     case 8: mask = ((addressT) 2 << 63) - 1; break;
 987 #endif
 988     default: abort ();
 989     }
 990
 991   /* If BFD64, sign extend val.  */
 992   if (!use_rela_relocations)
 993     if ((val & ~(((addressT) 2 << 31) - 1)) == 0)
 994       val = (val ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
 995
 996   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
 997     {
 998       char buf1[40], buf2[40];
 999
1000       sprint_value (buf1, val);
1001       sprint_value (buf2, val & mask);
1002       as_warn (_("%s shortened to %s"), buf1, buf2);
1003     }
1004   return val & mask;
1005 }
1006
1007 /* Returns 0 if attempting to add a prefix where one from the same
1008    class already exists, 1 if non rep/repne added, 2 if rep/repne
1009    added.  */
1010 static int
1011 add_prefix (prefix)
1012      unsigned int prefix;
1013 {
1014   int ret = 1;
1015   unsigned int q;
1016
1017   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
1018       && flag_code == CODE_64BIT)
1019     {
1020       if ((i.prefix[REX_PREFIX] & prefix & REX_MODE64)
1021           || ((i.prefix[REX_PREFIX] & (REX_EXTX | REX_EXTY | REX_EXTZ))
1022               && (prefix & (REX_EXTX | REX_EXTY | REX_EXTZ))))
1023         ret = 0;
1024       q = REX_PREFIX;
1025     }
1026   else
1027     {
1028       switch (prefix)
1029         {
1030         default:
1031           abort ();
1032
1033         case CS_PREFIX_OPCODE:
1034         case DS_PREFIX_OPCODE:
1035         case ES_PREFIX_OPCODE:
1036         case FS_PREFIX_OPCODE:
1037         case GS_PREFIX_OPCODE:
1038         case SS_PREFIX_OPCODE:
1039           q = SEG_PREFIX;
1040           break;
1041
1042         case REPNE_PREFIX_OPCODE:
1043         case REPE_PREFIX_OPCODE:
1044           ret = 2;
1045           /* fall thru */
1046         case LOCK_PREFIX_OPCODE:
1047           q = LOCKREP_PREFIX;
1048           break;
1049
1050         case FWAIT_OPCODE:
1051           q = WAIT_PREFIX;
1052           break;
1053
1054         case ADDR_PREFIX_OPCODE:
1055           q = ADDR_PREFIX;
1056           break;
1057
1058         case DATA_PREFIX_OPCODE:
1059           q = DATA_PREFIX;
1060           break;
1061         }
1062       if (i.prefix[q] != 0)
1063         ret = 0;
1064     }
1065
1066   if (ret)
1067     {
1068       if (!i.prefix[q])
1069         ++i.prefixes;
1070       i.prefix[q] |= prefix;
1071     }
1072   else
1073     as_bad (_("same type of prefix used twice"));
1074
1075   return ret;
1076 }
1077
1078 static void
1079 set_code_flag (value)
1080      int value;
1081 {
1082   flag_code = value;
1083   cpu_arch_flags &= ~(Cpu64 | CpuNo64);
1084   cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
1085   if (value == CODE_64BIT && !(cpu_arch_flags & CpuSledgehammer))
1086     {
1087       as_bad (_("64bit mode not supported on this CPU."));
1088     }
1089   if (value == CODE_32BIT && !(cpu_arch_flags & Cpu386))
1090     {
1091       as_bad (_("32bit mode not supported on this CPU."));
1092     }
1093   stackop_size = '\0';
1094 }
1095
1096 static void
1097 set_16bit_gcc_code_flag (new_code_flag)
1098      int new_code_flag;
1099 {
1100   flag_code = new_code_flag;
1101   cpu_arch_flags &= ~(Cpu64 | CpuNo64);
1102   cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
1103   stackop_size = LONG_MNEM_SUFFIX;
1104 }
1105
1106 static void
1107 set_intel_syntax (syntax_flag)
1108      int syntax_flag;
1109 {
1110   /* Find out if register prefixing is specified.  */
1111   int ask_naked_reg = 0;
1112
1113   SKIP_WHITESPACE ();
1114   if (!is_end_of_line[(unsigned char) *input_line_pointer])
1115     {
1116       char *string = input_line_pointer;
1117       int e = get_symbol_end ();
1118
1119       if (strcmp (string, "prefix") == 0)
1120         ask_naked_reg = 1;
1121       else if (strcmp (string, "noprefix") == 0)
1122         ask_naked_reg = -1;
1123       else
1124         as_bad (_("bad argument to syntax directive."));
1125       *input_line_pointer = e;
1126     }
1127   demand_empty_rest_of_line ();
1128
1129   intel_syntax = syntax_flag;
1130
1131   if (ask_naked_reg == 0)
1132     allow_naked_reg = (intel_syntax
1133                        && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
1134   else
1135     allow_naked_reg = (ask_naked_reg < 0);
1136
1137   identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
1138   identifier_chars['$'] = intel_syntax ? '$' : 0;
1139 }
1140
1141 static void
1142 set_cpu_arch (dummy)
1143      int dummy ATTRIBUTE_UNUSED;
1144 {
1145   SKIP_WHITESPACE ();
1146
1147   if (!is_end_of_line[(unsigned char) *input_line_pointer])
1148     {
1149       char *string = input_line_pointer;
1150       int e = get_symbol_end ();
1151       unsigned int i;
1152
1153       for (i = 0; i < ARRAY_SIZE (cpu_arch); i++)
1154         {
1155           if (strcmp (string, cpu_arch[i].name) == 0)
1156             {
1157               if (*string != '.')
1158                 {
1159                   cpu_arch_name = cpu_arch[i].name;
1160                   cpu_sub_arch_name = NULL;
1161                   cpu_arch_flags = (cpu_arch[i].flags
1162                                     | (flag_code == CODE_64BIT ? Cpu64 : CpuNo64));
1163                   cpu_arch_isa = cpu_arch[i].type;
1164                   cpu_arch_isa_flags = cpu_arch[i].flags;
1165                   if (!cpu_arch_tune_set)
1166                     {
1167                       cpu_arch_tune = cpu_arch_isa;
1168                       cpu_arch_tune_flags = cpu_arch_isa_flags;
1169                     }
1170                   break;
1171                 }
1172               if ((cpu_arch_flags | cpu_arch[i].flags) != cpu_arch_flags)
1173                 {
1174                   cpu_sub_arch_name = cpu_arch[i].name;
1175                   cpu_arch_flags |= cpu_arch[i].flags;
1176                 }
1177               *input_line_pointer = e;
1178               demand_empty_rest_of_line ();
1179               return;
1180             }
1181         }
1182       if (i >= ARRAY_SIZE (cpu_arch))
1183         as_bad (_("no such architecture: `%s'"), string);
1184
1185       *input_line_pointer = e;
1186     }
1187   else
1188     as_bad (_("missing cpu architecture"));
1189
1190   no_cond_jump_promotion = 0;
1191   if (*input_line_pointer == ','
1192       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
1193     {
1194       char *string = ++input_line_pointer;
1195       int e = get_symbol_end ();
1196
1197       if (strcmp (string, "nojumps") == 0)
1198         no_cond_jump_promotion = 1;
1199       else if (strcmp (string, "jumps") == 0)
1200         ;
1201       else
1202         as_bad (_("no such architecture modifier: `%s'"), string);
1203
1204       *input_line_pointer = e;
1205     }
1206
1207   demand_empty_rest_of_line ();
1208 }
1209
1210 unsigned long
1211 i386_mach ()
1212 {
1213   if (!strcmp (default_arch, "x86_64"))
1214     return bfd_mach_x86_64;
1215   else if (!strcmp (default_arch, "i386"))
1216     return bfd_mach_i386_i386;
1217   else
1218     as_fatal (_("Unknown architecture"));
1219 }
1220 \f
1221 void
1222 md_begin ()
1223 {
1224   const char *hash_err;
1225
1226   /* Initialize op_hash hash table.  */
1227   op_hash = hash_new ();
1228
1229   {
1230     const template *optab;
1231     templates *core_optab;
1232
1233     /* Setup for loop.  */
1234     optab = i386_optab;
1235     core_optab = (templates *) xmalloc (sizeof (templates));
1236     core_optab->start = optab;
1237
1238     while (1)
1239       {
1240         ++optab;
1241         if (optab->name == NULL
1242             || strcmp (optab->name, (optab - 1)->name) != 0)
1243           {
1244             /* different name --> ship out current template list;
1245                add to hash table; & begin anew.  */
1246             core_optab->end = optab;
1247             hash_err = hash_insert (op_hash,
1248                                     (optab - 1)->name,
1249                                     (PTR) core_optab);
1250             if (hash_err)
1251               {
1252                 as_fatal (_("Internal Error:  Can't hash %s: %s"),
1253                           (optab - 1)->name,
1254                           hash_err);
1255               }
1256             if (optab->name == NULL)
1257               break;
1258             core_optab = (templates *) xmalloc (sizeof (templates));
1259             core_optab->start = optab;
1260           }
1261       }
1262   }
1263
1264   /* Initialize reg_hash hash table.  */
1265   reg_hash = hash_new ();
1266   {
1267     const reg_entry *regtab;
1268
1269     for (regtab = i386_regtab;
1270          regtab < i386_regtab + sizeof (i386_regtab) / sizeof (i386_regtab[0]);
1271          regtab++)
1272       {
1273         hash_err = hash_insert (reg_hash, regtab->reg_name, (PTR) regtab);
1274         if (hash_err)
1275           as_fatal (_("Internal Error:  Can't hash %s: %s"),
1276                     regtab->reg_name,
1277                     hash_err);
1278       }
1279   }
1280
1281   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
1282   {
1283     int c;
1284     char *p;
1285
1286     for (c = 0; c < 256; c++)
1287       {
1288         if (ISDIGIT (c))
1289           {
1290             digit_chars[c] = c;
1291             mnemonic_chars[c] = c;
1292             register_chars[c] = c;
1293             operand_chars[c] = c;
1294           }
1295         else if (ISLOWER (c))
1296           {
1297             mnemonic_chars[c] = c;
1298             register_chars[c] = c;
1299             operand_chars[c] = c;
1300           }
1301         else if (ISUPPER (c))
1302           {
1303             mnemonic_chars[c] = TOLOWER (c);
1304             register_chars[c] = mnemonic_chars[c];
1305             operand_chars[c] = c;
1306           }
1307
1308         if (ISALPHA (c) || ISDIGIT (c))
1309           identifier_chars[c] = c;
1310         else if (c >= 128)
1311           {
1312             identifier_chars[c] = c;
1313             operand_chars[c] = c;
1314           }
1315       }
1316
1317 #ifdef LEX_AT
1318     identifier_chars['@'] = '@';
1319 #endif
1320 #ifdef LEX_QM
1321     identifier_chars['?'] = '?';
1322     operand_chars['?'] = '?';
1323 #endif
1324     digit_chars['-'] = '-';
1325     mnemonic_chars['-'] = '-';
1326     identifier_chars['_'] = '_';
1327     identifier_chars['.'] = '.';
1328
1329     for (p = operand_special_chars; *p != '\0'; p++)
1330       operand_chars[(unsigned char) *p] = *p;
1331   }
1332
1333 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1334   if (IS_ELF)
1335     {
1336       record_alignment (text_section, 2);
1337       record_alignment (data_section, 2);
1338       record_alignment (bss_section, 2);
1339     }
1340 #endif
1341
1342   if (flag_code == CODE_64BIT)
1343     {
1344       x86_dwarf2_return_column = 16;
1345       x86_cie_data_alignment = -8;
1346     }
1347   else
1348     {
1349       x86_dwarf2_return_column = 8;
1350       x86_cie_data_alignment = -4;
1351     }
1352 }
1353
1354 void
1355 i386_print_statistics (file)
1356      FILE *file;
1357 {
1358   hash_print_statistics (file, "i386 opcode", op_hash);
1359   hash_print_statistics (file, "i386 register", reg_hash);
1360 }
1361 \f
1362 #ifdef DEBUG386
1363
1364 /* Debugging routines for md_assemble.  */
1365 static void pi PARAMS ((char *, i386_insn *));
1366 static void pte PARAMS ((template *));
1367 static void pt PARAMS ((unsigned int));
1368 static void pe PARAMS ((expressionS *));
1369 static void ps PARAMS ((symbolS *));
1370
1371 static void
1372 pi (line, x)
1373      char *line;
1374      i386_insn *x;
1375 {
1376   unsigned int i;
1377
1378   fprintf (stdout, "%s: template ", line);
1379   pte (&x->tm);
1380   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
1381            x->base_reg ? x->base_reg->reg_name : "none",
1382            x->index_reg ? x->index_reg->reg_name : "none",
1383            x->log2_scale_factor);
1384   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
1385            x->rm.mode, x->rm.reg, x->rm.regmem);
1386   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
1387            x->sib.base, x->sib.index, x->sib.scale);
1388   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
1389            (x->rex & REX_MODE64) != 0,
1390            (x->rex & REX_EXTX) != 0,
1391            (x->rex & REX_EXTY) != 0,
1392            (x->rex & REX_EXTZ) != 0);
1393   for (i = 0; i < x->operands; i++)
1394     {
1395       fprintf (stdout, "    #%d:  ", i + 1);
1396       pt (x->types[i]);
1397       fprintf (stdout, "\n");
1398       if (x->types[i]
1399           & (Reg | SReg2 | SReg3 | Control | Debug | Test | RegMMX | RegXMM))
1400         fprintf (stdout, "%s\n", x->op[i].regs->reg_name);
1401       if (x->types[i] & Imm)
1402         pe (x->op[i].imms);
1403       if (x->types[i] & Disp)
1404         pe (x->op[i].disps);
1405     }
1406 }
1407
1408 static void
1409 pte (t)
1410      template *t;
1411 {
1412   unsigned int i;
1413   fprintf (stdout, " %d operands ", t->operands);
1414   fprintf (stdout, "opcode %x ", t->base_opcode);
1415   if (t->extension_opcode != None)
1416     fprintf (stdout, "ext %x ", t->extension_opcode);
1417   if (t->opcode_modifier & D)
1418     fprintf (stdout, "D");
1419   if (t->opcode_modifier & W)
1420     fprintf (stdout, "W");
1421   fprintf (stdout, "\n");
1422   for (i = 0; i < t->operands; i++)
1423     {
1424       fprintf (stdout, "    #%d type ", i + 1);
1425       pt (t->operand_types[i]);
1426       fprintf (stdout, "\n");
1427     }
1428 }
1429
1430 static void
1431 pe (e)
1432      expressionS *e;
1433 {
1434   fprintf (stdout, "    operation     %d\n", e->X_op);
1435   fprintf (stdout, "    add_number    %ld (%lx)\n",
1436            (long) e->X_add_number, (long) e->X_add_number);
1437   if (e->X_add_symbol)
1438     {
1439       fprintf (stdout, "    add_symbol    ");
1440       ps (e->X_add_symbol);
1441       fprintf (stdout, "\n");
1442     }
1443   if (e->X_op_symbol)
1444     {
1445       fprintf (stdout, "    op_symbol    ");
1446       ps (e->X_op_symbol);
1447       fprintf (stdout, "\n");
1448     }
1449 }
1450
1451 static void
1452 ps (s)
1453      symbolS *s;
1454 {
1455   fprintf (stdout, "%s type %s%s",
1456            S_GET_NAME (s),
1457            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
1458            segment_name (S_GET_SEGMENT (s)));
1459 }
1460
1461 static struct type_name
1462   {
1463     unsigned int mask;
1464     char *tname;
1465   }
1466 const type_names[] =
1467 {
1468   { Reg8, "r8" },
1469   { Reg16, "r16" },
1470   { Reg32, "r32" },
1471   { Reg64, "r64" },
1472   { Imm8, "i8" },
1473   { Imm8S, "i8s" },
1474   { Imm16, "i16" },
1475   { Imm32, "i32" },
1476   { Imm32S, "i32s" },
1477   { Imm64, "i64" },
1478   { Imm1, "i1" },
1479   { BaseIndex, "BaseIndex" },
1480   { Disp8, "d8" },
1481   { Disp16, "d16" },
1482   { Disp32, "d32" },
1483   { Disp32S, "d32s" },
1484   { Disp64, "d64" },
1485   { InOutPortReg, "InOutPortReg" },
1486   { ShiftCount, "ShiftCount" },
1487   { Control, "control reg" },
1488   { Test, "test reg" },
1489   { Debug, "debug reg" },
1490   { FloatReg, "FReg" },
1491   { FloatAcc, "FAcc" },
1492   { SReg2, "SReg2" },
1493   { SReg3, "SReg3" },
1494   { Acc, "Acc" },
1495   { JumpAbsolute, "Jump Absolute" },
1496   { RegMMX, "rMMX" },
1497   { RegXMM, "rXMM" },
1498   { EsSeg, "es" },
1499   { 0, "" }
1500 };
1501
1502 static void
1503 pt (t)
1504      unsigned int t;
1505 {
1506   const struct type_name *ty;
1507
1508   for (ty = type_names; ty->mask; ty++)
1509     if (t & ty->mask)
1510       fprintf (stdout, "%s, ", ty->tname);
1511   fflush (stdout);
1512 }
1513
1514 #endif /* DEBUG386 */
1515 \f
1516 static bfd_reloc_code_real_type
1517 reloc (unsigned int size,
1518        int pcrel,
1519        int sign,
1520        bfd_reloc_code_real_type other)
1521 {
1522   if (other != NO_RELOC)
1523     {
1524       reloc_howto_type *reloc;
1525
1526       if (size == 8)
1527         switch (other)
1528           {
1529           case BFD_RELOC_X86_64_GOT32:
1530             return BFD_RELOC_X86_64_GOT64;
1531             break;
1532           case BFD_RELOC_X86_64_PLTOFF64:
1533             return BFD_RELOC_X86_64_PLTOFF64;
1534             break;
1535           case BFD_RELOC_X86_64_GOTPC32:
1536             other = BFD_RELOC_X86_64_GOTPC64;
1537             break;
1538           case BFD_RELOC_X86_64_GOTPCREL:
1539             other = BFD_RELOC_X86_64_GOTPCREL64;
1540             break;
1541           case BFD_RELOC_X86_64_TPOFF32:
1542             other = BFD_RELOC_X86_64_TPOFF64;
1543             break;
1544           case BFD_RELOC_X86_64_DTPOFF32:
1545             other = BFD_RELOC_X86_64_DTPOFF64;
1546             break;
1547           default:
1548             break;
1549           }
1550
1551       /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless.  */
1552       if (size == 4 && flag_code != CODE_64BIT)
1553         sign = -1;
1554
1555       reloc = bfd_reloc_type_lookup (stdoutput, other);
1556       if (!reloc)
1557         as_bad (_("unknown relocation (%u)"), other);
1558       else if (size != bfd_get_reloc_size (reloc))
1559         as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
1560                 bfd_get_reloc_size (reloc),
1561                 size);
1562       else if (pcrel && !reloc->pc_relative)
1563         as_bad (_("non-pc-relative relocation for pc-relative field"));
1564       else if ((reloc->complain_on_overflow == complain_overflow_signed
1565                 && !sign)
1566                || (reloc->complain_on_overflow == complain_overflow_unsigned
1567                    && sign > 0))
1568         as_bad (_("relocated field and relocation type differ in signedness"));
1569       else
1570         return other;
1571       return NO_RELOC;
1572     }
1573
1574   if (pcrel)
1575     {
1576       if (!sign)
1577         as_bad (_("there are no unsigned pc-relative relocations"));
1578       switch (size)
1579         {
1580         case 1: return BFD_RELOC_8_PCREL;
1581         case 2: return BFD_RELOC_16_PCREL;
1582         case 4: return BFD_RELOC_32_PCREL;
1583         case 8: return BFD_RELOC_64_PCREL;
1584         }
1585       as_bad (_("cannot do %u byte pc-relative relocation"), size);
1586     }
1587   else
1588     {
1589       if (sign > 0)
1590         switch (size)
1591           {
1592           case 4: return BFD_RELOC_X86_64_32S;
1593           }
1594       else
1595         switch (size)
1596           {
1597           case 1: return BFD_RELOC_8;
1598           case 2: return BFD_RELOC_16;
1599           case 4: return BFD_RELOC_32;
1600           case 8: return BFD_RELOC_64;
1601           }
1602       as_bad (_("cannot do %s %u byte relocation"),
1603               sign > 0 ? "signed" : "unsigned", size);
1604     }
1605
1606   abort ();
1607   return BFD_RELOC_NONE;
1608 }
1609
1610 /* Here we decide which fixups can be adjusted to make them relative to
1611    the beginning of the section instead of the symbol.  Basically we need
1612    to make sure that the dynamic relocations are done correctly, so in
1613    some cases we force the original symbol to be used.  */
1614
1615 int
1616 tc_i386_fix_adjustable (fixP)
1617      fixS *fixP ATTRIBUTE_UNUSED;
1618 {
1619 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1620   if (!IS_ELF)
1621     return 1;
1622
1623   /* Don't adjust pc-relative references to merge sections in 64-bit
1624      mode.  */
1625   if (use_rela_relocations
1626       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
1627       && fixP->fx_pcrel)
1628     return 0;
1629
1630   /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
1631      and changed later by validate_fix.  */
1632   if (GOT_symbol && fixP->fx_subsy == GOT_symbol
1633       && fixP->fx_r_type == BFD_RELOC_32_PCREL)
1634     return 0;
1635
1636   /* adjust_reloc_syms doesn't know about the GOT.  */
1637   if (fixP->fx_r_type == BFD_RELOC_386_GOTOFF
1638       || fixP->fx_r_type == BFD_RELOC_386_PLT32
1639       || fixP->fx_r_type == BFD_RELOC_386_GOT32
1640       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
1641       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
1642       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
1643       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
1644       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
1645       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
1646       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
1647       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
1648       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
1649       || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
1650       || fixP->fx_r_type == BFD_RELOC_X86_64_PLT32
1651       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
1652       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
1653       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
1654       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
1655       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
1656       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
1657       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
1658       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
1659       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
1660       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
1661       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
1662       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
1663       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1664       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1665     return 0;
1666 #endif
1667   return 1;
1668 }
1669
1670 static int intel_float_operand PARAMS ((const char *mnemonic));
1671
1672 static int
1673 intel_float_operand (mnemonic)
1674      const char *mnemonic;
1675 {
1676   /* Note that the value returned is meaningful only for opcodes with (memory)
1677      operands, hence the code here is free to improperly handle opcodes that
1678      have no operands (for better performance and smaller code). */
1679
1680   if (mnemonic[0] != 'f')
1681     return 0; /* non-math */
1682
1683   switch (mnemonic[1])
1684     {
1685     /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
1686        the fs segment override prefix not currently handled because no
1687        call path can make opcodes without operands get here */
1688     case 'i':
1689       return 2 /* integer op */;
1690     case 'l':
1691       if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
1692         return 3; /* fldcw/fldenv */
1693       break;
1694     case 'n':
1695       if (mnemonic[2] != 'o' /* fnop */)
1696         return 3; /* non-waiting control op */
1697       break;
1698     case 'r':
1699       if (mnemonic[2] == 's')
1700         return 3; /* frstor/frstpm */
1701       break;
1702     case 's':
1703       if (mnemonic[2] == 'a')
1704         return 3; /* fsave */
1705       if (mnemonic[2] == 't')
1706         {
1707           switch (mnemonic[3])
1708             {
1709             case 'c': /* fstcw */
1710             case 'd': /* fstdw */
1711             case 'e': /* fstenv */
1712             case 's': /* fsts[gw] */
1713               return 3;
1714             }
1715         }
1716       break;
1717     case 'x':
1718       if (mnemonic[2] == 'r' || mnemonic[2] == 's')
1719         return 0; /* fxsave/fxrstor are not really math ops */
1720       break;
1721     }
1722
1723   return 1;
1724 }
1725
1726 /* This is the guts of the machine-dependent assembler.  LINE points to a
1727    machine dependent instruction.  This function is supposed to emit
1728    the frags/bytes it assembles to.  */
1729
1730 void
1731 md_assemble (line)
1732      char *line;
1733 {
1734   int j;
1735   char mnemonic[MAX_MNEM_SIZE];
1736
1737   /* Initialize globals.  */
1738   memset (&i, '\0', sizeof (i));
1739   for (j = 0; j < MAX_OPERANDS; j++)
1740     i.reloc[j] = NO_RELOC;
1741   memset (disp_expressions, '\0', sizeof (disp_expressions));
1742   memset (im_expressions, '\0', sizeof (im_expressions));
1743   save_stack_p = save_stack;
1744
1745   /* First parse an instruction mnemonic & call i386_operand for the operands.
1746      We assume that the scrubber has arranged it so that line[0] is the valid
1747      start of a (possibly prefixed) mnemonic.  */
1748
1749   line = parse_insn (line, mnemonic);
1750   if (line == NULL)
1751     return;
1752
1753   line = parse_operands (line, mnemonic);
1754   if (line == NULL)
1755     return;
1756
1757   /* The order of the immediates should be reversed
1758      for 2 immediates extrq and insertq instructions */
1759   if ((i.imm_operands == 2) &&
1760       ((strcmp (mnemonic, "extrq") == 0)
1761        || (strcmp (mnemonic, "insertq") == 0)))
1762     {
1763       swap_imm_operands ();
1764       /* "extrq" and insertq" are the only two instructions whose operands
1765          have to be reversed even though they have two immediate operands.
1766       */
1767       if (intel_syntax)
1768         swap_operands ();
1769     }
1770
1771   /* Now we've parsed the mnemonic into a set of templates, and have the
1772      operands at hand.  */
1773
1774   /* All intel opcodes have reversed operands except for "bound" and
1775      "enter".  We also don't reverse intersegment "jmp" and "call"
1776      instructions with 2 immediate operands so that the immediate segment
1777      precedes the offset, as it does when in AT&T mode. */
1778   if (intel_syntax && i.operands > 1
1779       && (strcmp (mnemonic, "bound") != 0)
1780       && (strcmp (mnemonic, "invlpga") != 0)
1781       && !((i.types[0] & Imm) && (i.types[1] & Imm)))
1782     swap_operands ();
1783
1784   if (i.imm_operands)
1785     optimize_imm ();
1786
1787   /* Don't optimize displacement for movabs since it only takes 64bit
1788      displacement.  */
1789   if (i.disp_operands
1790       && (flag_code != CODE_64BIT
1791           || strcmp (mnemonic, "movabs") != 0))
1792     optimize_disp ();
1793
1794   /* Next, we find a template that matches the given insn,
1795      making sure the overlap of the given operands types is consistent
1796      with the template operand types.  */
1797
1798   if (!match_template ())
1799     return;
1800
1801   if (intel_syntax)
1802     {
1803       /* Undo SYSV386_COMPAT brokenness when in Intel mode.  See i386.h  */
1804       if (SYSV386_COMPAT
1805           && (i.tm.base_opcode & 0xfffffde0) == 0xdce0)
1806         i.tm.base_opcode ^= FloatR;
1807
1808       /* Zap movzx and movsx suffix.  The suffix may have been set from
1809          "word ptr" or "byte ptr" on the source operand, but we'll use
1810          the suffix later to choose the destination register.  */
1811       if ((i.tm.base_opcode & ~9) == 0x0fb6)
1812         {
1813           if (i.reg_operands < 2
1814               && !i.suffix
1815               && (~i.tm.opcode_modifier
1816                   & (No_bSuf
1817                      | No_wSuf
1818                      | No_lSuf
1819                      | No_sSuf
1820                      | No_xSuf
1821                      | No_qSuf)))
1822             as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
1823
1824           i.suffix = 0;
1825         }
1826     }
1827
1828   if (i.tm.opcode_modifier & FWait)
1829     if (!add_prefix (FWAIT_OPCODE))
1830       return;
1831
1832   /* Check string instruction segment overrides.  */
1833   if ((i.tm.opcode_modifier & IsString) != 0 && i.mem_operands != 0)
1834     {
1835       if (!check_string ())
1836         return;
1837     }
1838
1839   if (!process_suffix ())
1840     return;
1841
1842   /* Make still unresolved immediate matches conform to size of immediate
1843      given in i.suffix.  */
1844   if (!finalize_imm ())
1845     return;
1846
1847   if (i.types[0] & Imm1)
1848     i.imm_operands = 0; /* kludge for shift insns.  */
1849   if (i.types[0] & ImplicitRegister)
1850     i.reg_operands--;
1851   if (i.types[1] & ImplicitRegister)
1852     i.reg_operands--;
1853   if (i.types[2] & ImplicitRegister)
1854     i.reg_operands--;
1855
1856   if (i.tm.opcode_modifier & ImmExt)
1857     {
1858       expressionS *exp;
1859
1860       if ((i.tm.cpu_flags & CpuSSE3) && i.operands > 0)
1861         {
1862           /* Streaming SIMD extensions 3 Instructions have the fixed
1863              operands with an opcode suffix which is coded in the same
1864              place as an 8-bit immediate field would be. Here we check
1865              those operands and remove them afterwards.  */
1866           unsigned int x;
1867
1868           for (x = 0; x < i.operands; x++)
1869             if (i.op[x].regs->reg_num != x)
1870               as_bad (_("can't use register '%%%s' as operand %d in '%s'."),
1871                       i.op[x].regs->reg_name, x + 1, i.tm.name);
1872           i.operands = 0;
1873         }
1874
1875       /* These AMD 3DNow! and Intel Katmai New Instructions have an
1876          opcode suffix which is coded in the same place as an 8-bit
1877          immediate field would be.  Here we fake an 8-bit immediate
1878          operand from the opcode suffix stored in tm.extension_opcode.  */
1879
1880       assert (i.imm_operands == 0 && i.operands <= 2 && 2 < MAX_OPERANDS);
1881
1882       exp = &im_expressions[i.imm_operands++];
1883       i.op[i.operands].imms = exp;
1884       i.types[i.operands++] = Imm8;
1885       exp->X_op = O_constant;
1886       exp->X_add_number = i.tm.extension_opcode;
1887       i.tm.extension_opcode = None;
1888     }
1889
1890   /* For insns with operands there are more diddles to do to the opcode.  */
1891   if (i.operands)
1892     {
1893       if (!process_operands ())
1894         return;
1895     }
1896   else if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
1897     {
1898       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
1899       as_warn (_("translating to `%sp'"), i.tm.name);
1900     }
1901
1902   /* Handle conversion of 'int $3' --> special int3 insn.  */
1903   if (i.tm.base_opcode == INT_OPCODE && i.op[0].imms->X_add_number == 3)
1904     {
1905       i.tm.base_opcode = INT3_OPCODE;
1906       i.imm_operands = 0;
1907     }
1908
1909   if ((i.tm.opcode_modifier & (Jump | JumpByte | JumpDword))
1910       && i.op[0].disps->X_op == O_constant)
1911     {
1912       /* Convert "jmp constant" (and "call constant") to a jump (call) to
1913          the absolute address given by the constant.  Since ix86 jumps and
1914          calls are pc relative, we need to generate a reloc.  */
1915       i.op[0].disps->X_add_symbol = &abs_symbol;
1916       i.op[0].disps->X_op = O_symbol;
1917     }
1918
1919   if ((i.tm.opcode_modifier & Rex64) != 0)
1920     i.rex |= REX_MODE64;
1921
1922   /* For 8 bit registers we need an empty rex prefix.  Also if the
1923      instruction already has a prefix, we need to convert old
1924      registers to new ones.  */
1925
1926   if (((i.types[0] & Reg8) != 0
1927        && (i.op[0].regs->reg_flags & RegRex64) != 0)
1928       || ((i.types[1] & Reg8) != 0
1929           && (i.op[1].regs->reg_flags & RegRex64) != 0)
1930       || (((i.types[0] & Reg8) != 0 || (i.types[1] & Reg8) != 0)
1931           && i.rex != 0))
1932     {
1933       int x;
1934
1935       i.rex |= REX_OPCODE;
1936       for (x = 0; x < 2; x++)
1937         {
1938           /* Look for 8 bit operand that uses old registers.  */
1939           if ((i.types[x] & Reg8) != 0
1940               && (i.op[x].regs->reg_flags & RegRex64) == 0)
1941             {
1942               /* In case it is "hi" register, give up.  */
1943               if (i.op[x].regs->reg_num > 3)
1944                 as_bad (_("can't encode register '%%%s' in an instruction requiring REX prefix."),
1945                         i.op[x].regs->reg_name);
1946
1947               /* Otherwise it is equivalent to the extended register.
1948                  Since the encoding doesn't change this is merely
1949                  cosmetic cleanup for debug output.  */
1950
1951               i.op[x].regs = i.op[x].regs + 8;
1952             }
1953         }
1954     }
1955
1956   if (i.rex != 0)
1957     add_prefix (REX_OPCODE | i.rex);
1958
1959   /* We are ready to output the insn.  */
1960   output_insn ();
1961 }
1962
1963 static char *
1964 parse_insn (line, mnemonic)
1965      char *line;
1966      char *mnemonic;
1967 {
1968   char *l = line;
1969   char *token_start = l;
1970   char *mnem_p;
1971   int supported;
1972   const template *t;
1973
1974   /* Non-zero if we found a prefix only acceptable with string insns.  */
1975   const char *expecting_string_instruction = NULL;
1976
1977   while (1)
1978     {
1979       mnem_p = mnemonic;
1980       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
1981         {
1982           mnem_p++;
1983           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
1984             {
1985               as_bad (_("no such instruction: `%s'"), token_start);
1986               return NULL;
1987             }
1988           l++;
1989         }
1990       if (!is_space_char (*l)
1991           && *l != END_OF_INSN
1992           && (intel_syntax
1993               || (*l != PREFIX_SEPARATOR
1994                   && *l != ',')))
1995         {
1996           as_bad (_("invalid character %s in mnemonic"),
1997                   output_invalid (*l));
1998           return NULL;
1999         }
2000       if (token_start == l)
2001         {
2002           if (!intel_syntax && *l == PREFIX_SEPARATOR)
2003             as_bad (_("expecting prefix; got nothing"));
2004           else
2005             as_bad (_("expecting mnemonic; got nothing"));
2006           return NULL;
2007         }
2008
2009       /* Look up instruction (or prefix) via hash table.  */
2010       current_templates = hash_find (op_hash, mnemonic);
2011
2012       if (*l != END_OF_INSN
2013           && (!is_space_char (*l) || l[1] != END_OF_INSN)
2014           && current_templates
2015           && (current_templates->start->opcode_modifier & IsPrefix))
2016         {
2017           if (current_templates->start->cpu_flags
2018               & (flag_code != CODE_64BIT ? Cpu64 : CpuNo64))
2019             {
2020               as_bad ((flag_code != CODE_64BIT
2021                        ? _("`%s' is only supported in 64-bit mode")
2022                        : _("`%s' is not supported in 64-bit mode")),
2023                       current_templates->start->name);
2024               return NULL;
2025             }
2026           /* If we are in 16-bit mode, do not allow addr16 or data16.
2027              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
2028           if ((current_templates->start->opcode_modifier & (Size16 | Size32))
2029               && flag_code != CODE_64BIT
2030               && (((current_templates->start->opcode_modifier & Size32) != 0)
2031                   ^ (flag_code == CODE_16BIT)))
2032             {
2033               as_bad (_("redundant %s prefix"),
2034                       current_templates->start->name);
2035               return NULL;
2036             }
2037           /* Add prefix, checking for repeated prefixes.  */
2038           switch (add_prefix (current_templates->start->base_opcode))
2039             {
2040             case 0:
2041               return NULL;
2042             case 2:
2043               expecting_string_instruction = current_templates->start->name;
2044               break;
2045             }
2046           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
2047           token_start = ++l;
2048         }
2049       else
2050         break;
2051     }
2052
2053   if (!current_templates)
2054     {
2055       /* See if we can get a match by trimming off a suffix.  */
2056       switch (mnem_p[-1])
2057         {
2058         case WORD_MNEM_SUFFIX:
2059           if (intel_syntax && (intel_float_operand (mnemonic) & 2))
2060             i.suffix = SHORT_MNEM_SUFFIX;
2061           else
2062         case BYTE_MNEM_SUFFIX:
2063         case QWORD_MNEM_SUFFIX:
2064           i.suffix = mnem_p[-1];
2065           mnem_p[-1] = '\0';
2066           current_templates = hash_find (op_hash, mnemonic);
2067           break;
2068         case SHORT_MNEM_SUFFIX:
2069         case LONG_MNEM_SUFFIX:
2070           if (!intel_syntax)
2071             {
2072               i.suffix = mnem_p[-1];
2073               mnem_p[-1] = '\0';
2074               current_templates = hash_find (op_hash, mnemonic);
2075             }
2076           break;
2077
2078           /* Intel Syntax.  */
2079         case 'd':
2080           if (intel_syntax)
2081             {
2082               if (intel_float_operand (mnemonic) == 1)
2083                 i.suffix = SHORT_MNEM_SUFFIX;
2084               else
2085                 i.suffix = LONG_MNEM_SUFFIX;
2086               mnem_p[-1] = '\0';
2087               current_templates = hash_find (op_hash, mnemonic);
2088             }
2089           break;
2090         }
2091       if (!current_templates)
2092         {
2093           as_bad (_("no such instruction: `%s'"), token_start);
2094           return NULL;
2095         }
2096     }
2097
2098   if (current_templates->start->opcode_modifier & (Jump | JumpByte))
2099     {
2100       /* Check for a branch hint.  We allow ",pt" and ",pn" for
2101          predict taken and predict not taken respectively.
2102          I'm not sure that branch hints actually do anything on loop
2103          and jcxz insns (JumpByte) for current Pentium4 chips.  They
2104          may work in the future and it doesn't hurt to accept them
2105          now.  */
2106       if (l[0] == ',' && l[1] == 'p')
2107         {
2108           if (l[2] == 't')
2109             {
2110               if (!add_prefix (DS_PREFIX_OPCODE))
2111                 return NULL;
2112               l += 3;
2113             }
2114           else if (l[2] == 'n')
2115             {
2116               if (!add_prefix (CS_PREFIX_OPCODE))
2117                 return NULL;
2118               l += 3;
2119             }
2120         }
2121     }
2122   /* Any other comma loses.  */
2123   if (*l == ',')
2124     {
2125       as_bad (_("invalid character %s in mnemonic"),
2126               output_invalid (*l));
2127       return NULL;
2128     }
2129
2130   /* Check if instruction is supported on specified architecture.  */
2131   supported = 0;
2132   for (t = current_templates->start; t < current_templates->end; ++t)
2133     {
2134       if (!((t->cpu_flags & ~(Cpu64 | CpuNo64))
2135             & ~(cpu_arch_flags & ~(Cpu64 | CpuNo64))))
2136         supported |= 1;
2137       if (!(t->cpu_flags & (flag_code == CODE_64BIT ? CpuNo64 : Cpu64)))
2138         supported |= 2;
2139     }
2140   if (!(supported & 2))
2141     {
2142       as_bad (flag_code == CODE_64BIT
2143               ? _("`%s' is not supported in 64-bit mode")
2144               : _("`%s' is only supported in 64-bit mode"),
2145               current_templates->start->name);
2146       return NULL;
2147     }
2148   if (!(supported & 1))
2149     {
2150       as_warn (_("`%s' is not supported on `%s%s'"),
2151                current_templates->start->name,
2152                cpu_arch_name,
2153                cpu_sub_arch_name ? cpu_sub_arch_name : "");
2154     }
2155   else if ((Cpu386 & ~cpu_arch_flags) && (flag_code != CODE_16BIT))
2156     {
2157       as_warn (_("use .code16 to ensure correct addressing mode"));
2158     }
2159
2160   /* Check for rep/repne without a string instruction.  */
2161   if (expecting_string_instruction)
2162     {
2163       static templates override;
2164
2165       for (t = current_templates->start; t < current_templates->end; ++t)
2166         if (t->opcode_modifier & IsString)
2167           break;
2168       if (t >= current_templates->end)
2169         {
2170           as_bad (_("expecting string instruction after `%s'"),
2171                   expecting_string_instruction);
2172           return NULL;
2173         }
2174       for (override.start = t; t < current_templates->end; ++t)
2175         if (!(t->opcode_modifier & IsString))
2176           break;
2177       override.end = t;
2178       current_templates = &override;
2179     }
2180
2181   return l;
2182 }
2183
2184 static char *
2185 parse_operands (l, mnemonic)
2186      char *l;
2187      const char *mnemonic;
2188 {
2189   char *token_start;
2190
2191   /* 1 if operand is pending after ','.  */
2192   unsigned int expecting_operand = 0;
2193
2194   /* Non-zero if operand parens not balanced.  */
2195   unsigned int paren_not_balanced;
2196
2197   while (*l != END_OF_INSN)
2198     {
2199       /* Skip optional white space before operand.  */
2200       if (is_space_char (*l))
2201         ++l;
2202       if (!is_operand_char (*l) && *l != END_OF_INSN)
2203         {
2204           as_bad (_("invalid character %s before operand %d"),
2205                   output_invalid (*l),
2206                   i.operands + 1);
2207           return NULL;
2208         }
2209       token_start = l;  /* after white space */
2210       paren_not_balanced = 0;
2211       while (paren_not_balanced || *l != ',')
2212         {
2213           if (*l == END_OF_INSN)
2214             {
2215               if (paren_not_balanced)
2216                 {
2217                   if (!intel_syntax)
2218                     as_bad (_("unbalanced parenthesis in operand %d."),
2219                             i.operands + 1);
2220                   else
2221                     as_bad (_("unbalanced brackets in operand %d."),
2222                             i.operands + 1);
2223                   return NULL;
2224                 }
2225               else
2226                 break;  /* we are done */
2227             }
2228           else if (!is_operand_char (*l) && !is_space_char (*l))
2229             {
2230               as_bad (_("invalid character %s in operand %d"),
2231                       output_invalid (*l),
2232                       i.operands + 1);
2233               return NULL;
2234             }
2235           if (!intel_syntax)
2236             {
2237               if (*l == '(')
2238                 ++paren_not_balanced;
2239               if (*l == ')')
2240                 --paren_not_balanced;
2241             }
2242           else
2243             {
2244               if (*l == '[')
2245                 ++paren_not_balanced;
2246               if (*l == ']')
2247                 --paren_not_balanced;
2248             }
2249           l++;
2250         }
2251       if (l != token_start)
2252         {                       /* Yes, we've read in another operand.  */
2253           unsigned int operand_ok;
2254           this_operand = i.operands++;
2255           if (i.operands > MAX_OPERANDS)
2256             {
2257               as_bad (_("spurious operands; (%d operands/instruction max)"),
2258                       MAX_OPERANDS);
2259               return NULL;
2260             }
2261           /* Now parse operand adding info to 'i' as we go along.  */
2262           END_STRING_AND_SAVE (l);
2263
2264           if (intel_syntax)
2265             operand_ok =
2266               i386_intel_operand (token_start,
2267                                   intel_float_operand (mnemonic));
2268           else
2269             operand_ok = i386_operand (token_start);
2270
2271           RESTORE_END_STRING (l);
2272           if (!operand_ok)
2273             return NULL;
2274         }
2275       else
2276         {
2277           if (expecting_operand)
2278             {
2279             expecting_operand_after_comma:
2280               as_bad (_("expecting operand after ','; got nothing"));
2281               return NULL;
2282             }
2283           if (*l == ',')
2284             {
2285               as_bad (_("expecting operand before ','; got nothing"));
2286               return NULL;
2287             }
2288         }
2289
2290       /* Now *l must be either ',' or END_OF_INSN.  */
2291       if (*l == ',')
2292         {
2293           if (*++l == END_OF_INSN)
2294             {
2295               /* Just skip it, if it's \n complain.  */
2296               goto expecting_operand_after_comma;
2297             }
2298           expecting_operand = 1;
2299         }
2300     }
2301   return l;
2302 }
2303
2304 static void
2305 swap_imm_operands ()
2306 {
2307   union i386_op temp_op;
2308   unsigned int temp_type;
2309   enum bfd_reloc_code_real temp_reloc;
2310   int xchg1 = 0;
2311   int xchg2 = 1;
2312
2313   temp_type = i.types[xchg2];
2314   i.types[xchg2] = i.types[xchg1];
2315   i.types[xchg1] = temp_type;
2316   temp_op = i.op[xchg2];
2317   i.op[xchg2] = i.op[xchg1];
2318   i.op[xchg1] = temp_op;
2319   temp_reloc = i.reloc[xchg2];
2320   i.reloc[xchg2] = i.reloc[xchg1];
2321   i.reloc[xchg1] = temp_reloc;
2322 }
2323
2324
2325 static void
2326 swap_operands ()
2327 {
2328   union i386_op temp_op;
2329   unsigned int temp_type;
2330   enum bfd_reloc_code_real temp_reloc;
2331   int xchg1 = 0;
2332   int xchg2 = 0;
2333
2334   if (i.operands == 4)
2335     /* There will be two exchanges in a 4 operand instruction.
2336        First exchange is the done inside this block.(1st and 4rth operand)
2337        The next exchange is done outside this block.(2nd and 3rd operand) */
2338     {
2339       xchg1 = 0;
2340       xchg2 = 3;
2341       temp_type = i.types[xchg2];
2342       i.types[xchg2] = i.types[xchg1];
2343       i.types[xchg1] = temp_type;
2344       temp_op = i.op[xchg2];
2345       i.op[xchg2] = i.op[xchg1];
2346       i.op[xchg1] = temp_op;
2347       temp_reloc = i.reloc[xchg2];
2348       i.reloc[xchg2] = i.reloc[xchg1];
2349       i.reloc[xchg1] = temp_reloc;
2350       xchg1 = 1;
2351       xchg2 = 2;
2352     }
2353
2354   if (i.operands == 2)
2355     {
2356       xchg1 = 0;
2357       xchg2 = 1;
2358     }
2359   else if (i.operands == 3)
2360     {
2361       xchg1 = 0;
2362       xchg2 = 2;
2363     }
2364   temp_type = i.types[xchg2];
2365   i.types[xchg2] = i.types[xchg1];
2366   i.types[xchg1] = temp_type;
2367   temp_op = i.op[xchg2];
2368   i.op[xchg2] = i.op[xchg1];
2369   i.op[xchg1] = temp_op;
2370   temp_reloc = i.reloc[xchg2];
2371   i.reloc[xchg2] = i.reloc[xchg1];
2372   i.reloc[xchg1] = temp_reloc;
2373
2374   if (i.mem_operands == 2)
2375     {
2376       const seg_entry *temp_seg;
2377       temp_seg = i.seg[0];
2378       i.seg[0] = i.seg[1];
2379       i.seg[1] = temp_seg;
2380     }
2381 }
2382
2383 /* Try to ensure constant immediates are represented in the smallest
2384    opcode possible.  */
2385 static void
2386 optimize_imm ()
2387 {
2388   char guess_suffix = 0;
2389   int op;
2390
2391   if (i.suffix)
2392     guess_suffix = i.suffix;
2393   else if (i.reg_operands)
2394     {
2395       /* Figure out a suffix from the last register operand specified.
2396          We can't do this properly yet, ie. excluding InOutPortReg,
2397          but the following works for instructions with immediates.
2398          In any case, we can't set i.suffix yet.  */
2399       for (op = i.operands; --op >= 0;)
2400         if (i.types[op] & Reg)
2401           {
2402             if (i.types[op] & Reg8)
2403               guess_suffix = BYTE_MNEM_SUFFIX;
2404             else if (i.types[op] & Reg16)
2405               guess_suffix = WORD_MNEM_SUFFIX;
2406             else if (i.types[op] & Reg32)
2407               guess_suffix = LONG_MNEM_SUFFIX;
2408             else if (i.types[op] & Reg64)
2409               guess_suffix = QWORD_MNEM_SUFFIX;
2410             break;
2411           }
2412     }
2413   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
2414     guess_suffix = WORD_MNEM_SUFFIX;
2415
2416   for (op = i.operands; --op >= 0;)
2417     if (i.types[op] & Imm)
2418       {
2419         switch (i.op[op].imms->X_op)
2420           {
2421           case O_constant:
2422             /* If a suffix is given, this operand may be shortened.  */
2423             switch (guess_suffix)
2424               {
2425               case LONG_MNEM_SUFFIX:
2426                 i.types[op] |= Imm32 | Imm64;
2427                 break;
2428               case WORD_MNEM_SUFFIX:
2429                 i.types[op] |= Imm16 | Imm32S | Imm32 | Imm64;
2430                 break;
2431               case BYTE_MNEM_SUFFIX:
2432                 i.types[op] |= Imm16 | Imm8 | Imm8S | Imm32S | Imm32 | Imm64;
2433                 break;
2434               }
2435
2436             /* If this operand is at most 16 bits, convert it
2437                to a signed 16 bit number before trying to see
2438                whether it will fit in an even smaller size.
2439                This allows a 16-bit operand such as $0xffe0 to
2440                be recognised as within Imm8S range.  */
2441             if ((i.types[op] & Imm16)
2442                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
2443               {
2444                 i.op[op].imms->X_add_number =
2445                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
2446               }
2447             if ((i.types[op] & Imm32)
2448                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
2449                     == 0))
2450               {
2451                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
2452                                                 ^ ((offsetT) 1 << 31))
2453                                                - ((offsetT) 1 << 31));
2454               }
2455             i.types[op] |= smallest_imm_type (i.op[op].imms->X_add_number);
2456
2457             /* We must avoid matching of Imm32 templates when 64bit
2458                only immediate is available.  */
2459             if (guess_suffix == QWORD_MNEM_SUFFIX)
2460               i.types[op] &= ~Imm32;
2461             break;
2462
2463           case O_absent:
2464           case O_register:
2465             abort ();
2466
2467             /* Symbols and expressions.  */
2468           default:
2469             /* Convert symbolic operand to proper sizes for matching, but don't
2470                prevent matching a set of insns that only supports sizes other
2471                than those matching the insn suffix.  */
2472             {
2473               unsigned int mask, allowed = 0;
2474               const template *t;
2475
2476               for (t = current_templates->start; t < current_templates->end; ++t)
2477                 allowed |= t->operand_types[op];
2478               switch (guess_suffix)
2479                 {
2480                 case QWORD_MNEM_SUFFIX:
2481                   mask = Imm64 | Imm32S;
2482                   break;
2483                 case LONG_MNEM_SUFFIX:
2484                   mask = Imm32;
2485                   break;
2486                 case WORD_MNEM_SUFFIX:
2487                   mask = Imm16;
2488                   break;
2489                 case BYTE_MNEM_SUFFIX:
2490                   mask = Imm8;
2491                   break;
2492                 default:
2493                   mask = 0;
2494                   break;
2495                 }
2496               if (mask & allowed)
2497                 i.types[op] &= mask;
2498             }
2499             break;
2500           }
2501       }
2502 }
2503
2504 /* Try to use the smallest displacement type too.  */
2505 static void
2506 optimize_disp ()
2507 {
2508   int op;
2509
2510   for (op = i.operands; --op >= 0;)
2511     if (i.types[op] & Disp)
2512       {
2513         if (i.op[op].disps->X_op == O_constant)
2514           {
2515             offsetT disp = i.op[op].disps->X_add_number;
2516
2517             if ((i.types[op] & Disp16)
2518                 && (disp & ~(offsetT) 0xffff) == 0)
2519               {
2520                 /* If this operand is at most 16 bits, convert
2521                    to a signed 16 bit number and don't use 64bit
2522                    displacement.  */
2523                 disp = (((disp & 0xffff) ^ 0x8000) - 0x8000);
2524                 i.types[op] &= ~Disp64;
2525               }
2526             if ((i.types[op] & Disp32)
2527                 && (disp & ~(((offsetT) 2 << 31) - 1)) == 0)
2528               {
2529                 /* If this operand is at most 32 bits, convert
2530                    to a signed 32 bit number and don't use 64bit
2531                    displacement.  */
2532                 disp &= (((offsetT) 2 << 31) - 1);
2533                 disp = (disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
2534                 i.types[op] &= ~Disp64;
2535               }
2536             if (!disp && (i.types[op] & BaseIndex))
2537               {
2538                 i.types[op] &= ~Disp;
2539                 i.op[op].disps = 0;
2540                 i.disp_operands--;
2541               }
2542             else if (flag_code == CODE_64BIT)
2543               {
2544                 if (fits_in_signed_long (disp))
2545                   {
2546                     i.types[op] &= ~Disp64;
2547                     i.types[op] |= Disp32S;
2548                   }
2549                 if (fits_in_unsigned_long (disp))
2550                   i.types[op] |= Disp32;
2551               }
2552             if ((i.types[op] & (Disp32 | Disp32S | Disp16))
2553                 && fits_in_signed_byte (disp))
2554               i.types[op] |= Disp8;
2555           }
2556         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
2557                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
2558           {
2559             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
2560                          i.op[op].disps, 0, i.reloc[op]);
2561             i.types[op] &= ~Disp;
2562           }
2563         else
2564           /* We only support 64bit displacement on constants.  */
2565           i.types[op] &= ~Disp64;
2566       }
2567 }
2568
2569 static int
2570 match_template ()
2571 {
2572   /* Points to template once we've found it.  */
2573   const template *t;
2574   unsigned int overlap0, overlap1, overlap2, overlap3;
2575   unsigned int found_reverse_match;
2576   int suffix_check;
2577   unsigned int operand_types [MAX_OPERANDS];
2578   int addr_prefix_disp;
2579   unsigned int j;
2580
2581 #if MAX_OPERANDS != 4
2582 # error "MAX_OPERANDS must be 4."
2583 #endif
2584
2585 #define MATCH(overlap, given, template)                         \
2586   ((overlap & ~JumpAbsolute)                                    \
2587    && (((given) & (BaseIndex | JumpAbsolute))                   \
2588        == ((overlap) & (BaseIndex | JumpAbsolute))))
2589
2590   /* If given types r0 and r1 are registers they must be of the same type
2591      unless the expected operand type register overlap is null.
2592      Note that Acc in a template matches every size of reg.  */
2593 #define CONSISTENT_REGISTER_MATCH(m0, g0, t0, m1, g1, t1)       \
2594   (((g0) & Reg) == 0 || ((g1) & Reg) == 0                       \
2595    || ((g0) & Reg) == ((g1) & Reg)                              \
2596    || ((((m0) & Acc) ? Reg : (t0)) & (((m1) & Acc) ? Reg : (t1)) & Reg) == 0 )
2597
2598   overlap0 = 0;
2599   overlap1 = 0;
2600   overlap2 = 0;
2601   overlap3 = 0;
2602   found_reverse_match = 0;
2603   for (j = 0; j < MAX_OPERANDS; j++)
2604     operand_types [j] = 0;
2605   addr_prefix_disp = -1;
2606   suffix_check = (i.suffix == BYTE_MNEM_SUFFIX
2607                   ? No_bSuf
2608                   : (i.suffix == WORD_MNEM_SUFFIX
2609                      ? No_wSuf
2610                      : (i.suffix == SHORT_MNEM_SUFFIX
2611                         ? No_sSuf
2612                         : (i.suffix == LONG_MNEM_SUFFIX
2613                            ? No_lSuf
2614                            : (i.suffix == QWORD_MNEM_SUFFIX
2615                               ? No_qSuf
2616                               : (i.suffix == LONG_DOUBLE_MNEM_SUFFIX
2617                                  ? No_xSuf : 0))))));
2618
2619   for (t = current_templates->start; t < current_templates->end; t++)
2620     {
2621       addr_prefix_disp = -1;
2622
2623       /* Must have right number of operands.  */
2624       if (i.operands != t->operands)
2625         continue;
2626
2627       /* Check the suffix, except for some instructions in intel mode.  */
2628       if ((t->opcode_modifier & suffix_check)
2629           && !(intel_syntax
2630                && (t->opcode_modifier & IgnoreSize)))
2631         continue;
2632
2633       for (j = 0; j < MAX_OPERANDS; j++)
2634         operand_types [j] = t->operand_types [j];
2635
2636       /* In general, don't allow 64-bit operands in 32-bit mode.  */
2637       if (i.suffix == QWORD_MNEM_SUFFIX
2638           && flag_code != CODE_64BIT
2639           && (intel_syntax
2640               ? (!(t->opcode_modifier & IgnoreSize)
2641                  && !intel_float_operand (t->name))
2642               : intel_float_operand (t->name) != 2)
2643           && (!(operand_types[0] & (RegMMX | RegXMM))
2644               || !(operand_types[t->operands > 1] & (RegMMX | RegXMM)))
2645           && (t->base_opcode != 0x0fc7
2646               || t->extension_opcode != 1 /* cmpxchg8b */))
2647         continue;
2648
2649       /* Do not verify operands when there are none.  */
2650       else if (!t->operands)
2651         {
2652           if (t->cpu_flags & ~cpu_arch_flags)
2653             continue;
2654           /* We've found a match; break out of loop.  */
2655           break;
2656         }
2657
2658       /* Address size prefix will turn Disp64/Disp32/Disp16 operand
2659          into Disp32/Disp16/Disp32 operand.  */
2660       if (i.prefix[ADDR_PREFIX] != 0)
2661           {
2662             unsigned int DispOn = 0, DispOff = 0;
2663
2664             switch (flag_code)
2665             {
2666             case CODE_16BIT:
2667               DispOn = Disp32;
2668               DispOff = Disp16;
2669               break;
2670             case CODE_32BIT:
2671               DispOn = Disp16;
2672               DispOff = Disp32;
2673               break;
2674             case CODE_64BIT:
2675               DispOn = Disp32;
2676               DispOff = Disp64;
2677               break;
2678             }
2679
2680             for (j = 0; j < MAX_OPERANDS; j++)
2681               {
2682                 /* There should be only one Disp operand.  */
2683                 if ((operand_types[j] & DispOff))
2684                   {
2685                     addr_prefix_disp = j;
2686                     operand_types[j] |= DispOn;
2687                     operand_types[j] &= ~DispOff;
2688                     break;
2689                   }
2690               }
2691           }
2692
2693       overlap0 = i.types[0] & operand_types[0];
2694       switch (t->operands)
2695         {
2696         case 1:
2697           if (!MATCH (overlap0, i.types[0], operand_types[0]))
2698             continue;
2699           break;
2700         case 2:
2701         case 3:
2702         case 4:
2703           overlap1 = i.types[1] & operand_types[1];
2704           if (!MATCH (overlap0, i.types[0], operand_types[0])
2705               || !MATCH (overlap1, i.types[1], operand_types[1])
2706               /* monitor in SSE3 is a very special case.  The first
2707                  register and the second register may have different
2708                  sizes.  */
2709               || !((t->base_opcode == 0x0f01
2710                     && t->extension_opcode == 0xc8)
2711                    || CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
2712                                                  operand_types[0],
2713                                                  overlap1, i.types[1],
2714                                                  operand_types[1])))
2715             {
2716               /* Check if other direction is valid ...  */
2717               if ((t->opcode_modifier & (D | FloatD)) == 0)
2718                 continue;
2719
2720               /* Try reversing direction of operands.  */
2721               overlap0 = i.types[0] & operand_types[1];
2722               overlap1 = i.types[1] & operand_types[0];
2723               if (!MATCH (overlap0, i.types[0], operand_types[1])
2724                   || !MATCH (overlap1, i.types[1], operand_types[0])
2725                   || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
2726                                                  operand_types[1],
2727                                                  overlap1, i.types[1],
2728                                                  operand_types[0]))
2729                 {
2730                   /* Does not match either direction.  */
2731                   continue;
2732                 }
2733               /* found_reverse_match holds which of D or FloatDR
2734                  we've found.  */
2735               found_reverse_match = t->opcode_modifier & (D | FloatDR);
2736             }
2737           else
2738             {
2739               /* Found a forward 2 operand match here.  */
2740               switch (t->operands)
2741                 {
2742                 case 4:
2743                   overlap3 = i.types[3] & operand_types[3];
2744                 case 3:
2745                   overlap2 = i.types[2] & operand_types[2];
2746                   break;
2747                 }
2748
2749               switch (t->operands)
2750                 {
2751                 case 4:
2752                   if (!MATCH (overlap3, i.types[3], operand_types[3])
2753                       || !CONSISTENT_REGISTER_MATCH (overlap2,
2754                                                      i.types[2],
2755                                                      operand_types[2],
2756                                                      overlap3,
2757                                                      i.types[3],
2758                                                      operand_types[3]))
2759                     continue;
2760                 case 3:
2761                   /* Here we make use of the fact that there are no
2762                      reverse match 3 operand instructions, and all 3
2763                      operand instructions only need to be checked for
2764                      register consistency between operands 2 and 3.  */
2765                   if (!MATCH (overlap2, i.types[2], operand_types[2])
2766                       || !CONSISTENT_REGISTER_MATCH (overlap1,
2767                                                      i.types[1],
2768                                                      operand_types[1],
2769                                                      overlap2,
2770                                                      i.types[2],
2771                                                      operand_types[2]))
2772                     continue;
2773                   break;
2774                 }
2775             }
2776           /* Found either forward/reverse 2, 3 or 4 operand match here:
2777              slip through to break.  */
2778         }
2779       if (t->cpu_flags & ~cpu_arch_flags)
2780         {
2781           found_reverse_match = 0;
2782           continue;
2783         }
2784       /* We've found a match; break out of loop.  */
2785       break;
2786     }
2787
2788   if (t == current_templates->end)
2789     {
2790       /* We found no match.  */
2791       as_bad (_("suffix or operands invalid for `%s'"),
2792               current_templates->start->name);
2793       return 0;
2794     }
2795
2796   if (!quiet_warnings)
2797     {
2798       if (!intel_syntax
2799           && ((i.types[0] & JumpAbsolute)
2800               != (operand_types[0] & JumpAbsolute)))
2801         {
2802           as_warn (_("indirect %s without `*'"), t->name);
2803         }
2804
2805       if ((t->opcode_modifier & (IsPrefix | IgnoreSize))
2806           == (IsPrefix | IgnoreSize))
2807         {
2808           /* Warn them that a data or address size prefix doesn't
2809              affect assembly of the next line of code.  */
2810           as_warn (_("stand-alone `%s' prefix"), t->name);
2811         }
2812     }
2813
2814   /* Copy the template we found.  */
2815   i.tm = *t;
2816
2817   if (addr_prefix_disp != -1)
2818     i.tm.operand_types[addr_prefix_disp]
2819       = operand_types[addr_prefix_disp];
2820
2821   if (found_reverse_match)
2822     {
2823       /* If we found a reverse match we must alter the opcode
2824          direction bit.  found_reverse_match holds bits to change
2825          (different for int & float insns).  */
2826
2827       i.tm.base_opcode ^= found_reverse_match;
2828
2829       i.tm.operand_types[0] = operand_types[1];
2830       i.tm.operand_types[1] = operand_types[0];
2831     }
2832
2833   return 1;
2834 }
2835
2836 static int
2837 check_string ()
2838 {
2839   int mem_op = (i.types[0] & AnyMem) ? 0 : 1;
2840   if ((i.tm.operand_types[mem_op] & EsSeg) != 0)
2841     {
2842       if (i.seg[0] != NULL && i.seg[0] != &es)
2843         {
2844           as_bad (_("`%s' operand %d must use `%%es' segment"),
2845                   i.tm.name,
2846                   mem_op + 1);
2847           return 0;
2848         }
2849       /* There's only ever one segment override allowed per instruction.
2850          This instruction possibly has a legal segment override on the
2851          second operand, so copy the segment to where non-string
2852          instructions store it, allowing common code.  */
2853       i.seg[0] = i.seg[1];
2854     }
2855   else if ((i.tm.operand_types[mem_op + 1] & EsSeg) != 0)
2856     {
2857       if (i.seg[1] != NULL && i.seg[1] != &es)
2858         {
2859           as_bad (_("`%s' operand %d must use `%%es' segment"),
2860                   i.tm.name,
2861                   mem_op + 2);
2862           return 0;
2863         }
2864     }
2865   return 1;
2866 }
2867
2868 static int
2869 process_suffix (void)
2870 {
2871   /* If matched instruction specifies an explicit instruction mnemonic
2872      suffix, use it.  */
2873   if (i.tm.opcode_modifier & (Size16 | Size32 | Size64))
2874     {
2875       if (i.tm.opcode_modifier & Size16)
2876         i.suffix = WORD_MNEM_SUFFIX;
2877       else if (i.tm.opcode_modifier & Size64)
2878         i.suffix = QWORD_MNEM_SUFFIX;
2879       else
2880         i.suffix = LONG_MNEM_SUFFIX;
2881     }
2882   else if (i.reg_operands)
2883     {
2884       /* If there's no instruction mnemonic suffix we try to invent one
2885          based on register operands.  */
2886       if (!i.suffix)
2887         {
2888           /* We take i.suffix from the last register operand specified,
2889              Destination register type is more significant than source
2890              register type.  */
2891           int op;
2892
2893           for (op = i.operands; --op >= 0;)
2894             if ((i.types[op] & Reg)
2895                 && !(i.tm.operand_types[op] & InOutPortReg))
2896               {
2897                 i.suffix = ((i.types[op] & Reg8) ? BYTE_MNEM_SUFFIX :
2898                             (i.types[op] & Reg16) ? WORD_MNEM_SUFFIX :
2899                             (i.types[op] & Reg64) ? QWORD_MNEM_SUFFIX :
2900                             LONG_MNEM_SUFFIX);
2901                 break;
2902               }
2903         }
2904       else if (i.suffix == BYTE_MNEM_SUFFIX)
2905         {
2906           if (!check_byte_reg ())
2907             return 0;
2908         }
2909       else if (i.suffix == LONG_MNEM_SUFFIX)
2910         {
2911           if (!check_long_reg ())
2912             return 0;
2913         }
2914       else if (i.suffix == QWORD_MNEM_SUFFIX)
2915         {
2916           if (!check_qword_reg ())
2917             return 0;
2918         }
2919       else if (i.suffix == WORD_MNEM_SUFFIX)
2920         {
2921           if (!check_word_reg ())
2922             return 0;
2923         }
2924       else if (intel_syntax && (i.tm.opcode_modifier & IgnoreSize))
2925         /* Do nothing if the instruction is going to ignore the prefix.  */
2926         ;
2927       else
2928         abort ();
2929     }
2930   else if ((i.tm.opcode_modifier & DefaultSize)
2931            && !i.suffix
2932            /* exclude fldenv/frstor/fsave/fstenv */
2933            && (i.tm.opcode_modifier & No_sSuf))
2934     {
2935       i.suffix = stackop_size;
2936     }
2937   else if (intel_syntax
2938            && !i.suffix
2939            && ((i.tm.operand_types[0] & JumpAbsolute)
2940                || (i.tm.opcode_modifier & (JumpByte|JumpInterSegment))
2941                || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
2942                    && i.tm.extension_opcode <= 3)))
2943     {
2944       switch (flag_code)
2945         {
2946         case CODE_64BIT:
2947           if (!(i.tm.opcode_modifier & No_qSuf))
2948             {
2949               i.suffix = QWORD_MNEM_SUFFIX;
2950               break;
2951             }
2952         case CODE_32BIT:
2953           if (!(i.tm.opcode_modifier & No_lSuf))
2954             i.suffix = LONG_MNEM_SUFFIX;
2955           break;
2956         case CODE_16BIT:
2957           if (!(i.tm.opcode_modifier & No_wSuf))
2958             i.suffix = WORD_MNEM_SUFFIX;
2959           break;
2960         }
2961     }
2962
2963   if (!i.suffix)
2964     {
2965       if (!intel_syntax)
2966         {
2967           if (i.tm.opcode_modifier & W)
2968             {
2969               as_bad (_("no instruction mnemonic suffix given and no register operands; can't size instruction"));
2970               return 0;
2971             }
2972         }
2973       else
2974         {
2975           unsigned int suffixes = (~i.tm.opcode_modifier
2976                                    & (No_bSuf
2977                                       | No_wSuf
2978                                       | No_lSuf
2979                                       | No_sSuf
2980                                       | No_xSuf
2981                                       | No_qSuf));
2982
2983           if ((i.tm.opcode_modifier & W)
2984               || ((suffixes & (suffixes - 1))
2985                   && !(i.tm.opcode_modifier & (DefaultSize | IgnoreSize))))
2986             {
2987               as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
2988               return 0;
2989             }
2990         }
2991     }
2992
2993   /* Change the opcode based on the operand size given by i.suffix;
2994      We don't need to change things for byte insns.  */
2995
2996   if (i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
2997     {
2998       /* It's not a byte, select word/dword operation.  */
2999       if (i.tm.opcode_modifier & W)
3000         {
3001           if (i.tm.opcode_modifier & ShortForm)
3002             i.tm.base_opcode |= 8;
3003           else
3004             i.tm.base_opcode |= 1;
3005         }
3006
3007       /* Now select between word & dword operations via the operand
3008          size prefix, except for instructions that will ignore this
3009          prefix anyway.  */
3010       if (i.tm.base_opcode == 0x0f01 && i.tm.extension_opcode == 0xc8)
3011         {
3012           /* monitor in SSE3 is a very special case. The default size
3013              of AX is the size of mode. The address size override
3014              prefix will change the size of AX.  */
3015           if (i.op->regs[0].reg_type &
3016               (flag_code == CODE_32BIT ? Reg16 : Reg32))
3017             if (!add_prefix (ADDR_PREFIX_OPCODE))
3018               return 0;
3019         }
3020       else if (i.suffix != QWORD_MNEM_SUFFIX
3021                && i.suffix != LONG_DOUBLE_MNEM_SUFFIX
3022                && !(i.tm.opcode_modifier & (IgnoreSize | FloatMF))
3023                && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
3024                    || (flag_code == CODE_64BIT
3025                        && (i.tm.opcode_modifier & JumpByte))))
3026         {
3027           unsigned int prefix = DATA_PREFIX_OPCODE;
3028
3029           if (i.tm.opcode_modifier & JumpByte) /* jcxz, loop */
3030             prefix = ADDR_PREFIX_OPCODE;
3031
3032           if (!add_prefix (prefix))
3033             return 0;
3034         }
3035
3036       /* Set mode64 for an operand.  */
3037       if (i.suffix == QWORD_MNEM_SUFFIX
3038           && flag_code == CODE_64BIT
3039           && (i.tm.opcode_modifier & NoRex64) == 0)
3040         {
3041           /* Special case for xchg %rax,%rax.  It is NOP and doesn't
3042              need rex64.  */
3043           if (i.operands != 2
3044               || i.types [0] != (Acc | Reg64)
3045               || i.types [1] != (Acc | Reg64)
3046               || strcmp (i.tm.name, "xchg") != 0)
3047           i.rex |= REX_MODE64;
3048         }
3049
3050       /* Size floating point instruction.  */
3051       if (i.suffix == LONG_MNEM_SUFFIX)
3052         if (i.tm.opcode_modifier & FloatMF)
3053           i.tm.base_opcode ^= 4;
3054     }
3055
3056   return 1;
3057 }
3058
3059 static int
3060 check_byte_reg (void)
3061 {
3062   int op;
3063
3064   for (op = i.operands; --op >= 0;)
3065     {
3066       /* If this is an eight bit register, it's OK.  If it's the 16 or
3067          32 bit version of an eight bit register, we will just use the
3068          low portion, and that's OK too.  */
3069       if (i.types[op] & Reg8)
3070         continue;
3071
3072       /* movzx and movsx should not generate this warning.  */
3073       if (intel_syntax
3074           && (i.tm.base_opcode == 0xfb7
3075               || i.tm.base_opcode == 0xfb6
3076               || i.tm.base_opcode == 0x63
3077               || i.tm.base_opcode == 0xfbe
3078               || i.tm.base_opcode == 0xfbf))
3079         continue;
3080
3081       if ((i.types[op] & WordReg) && i.op[op].regs->reg_num < 4)
3082         {
3083           /* Prohibit these changes in the 64bit mode, since the
3084              lowering is more complicated.  */
3085           if (flag_code == CODE_64BIT
3086               && (i.tm.operand_types[op] & InOutPortReg) == 0)
3087             {
3088               as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
3089                       i.op[op].regs->reg_name,
3090                       i.suffix);
3091               return 0;
3092             }
3093 #if REGISTER_WARNINGS
3094           if (!quiet_warnings
3095               && (i.tm.operand_types[op] & InOutPortReg) == 0)
3096             as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
3097                      (i.op[op].regs + (i.types[op] & Reg16
3098                                        ? REGNAM_AL - REGNAM_AX
3099                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
3100                      i.op[op].regs->reg_name,
3101                      i.suffix);
3102 #endif
3103           continue;
3104         }
3105       /* Any other register is bad.  */
3106       if (i.types[op] & (Reg | RegMMX | RegXMM
3107                          | SReg2 | SReg3
3108                          | Control | Debug | Test
3109                          | FloatReg | FloatAcc))
3110         {
3111           as_bad (_("`%%%s' not allowed with `%s%c'"),
3112                   i.op[op].regs->reg_name,
3113                   i.tm.name,
3114                   i.suffix);
3115           return 0;
3116         }
3117     }
3118   return 1;
3119 }
3120
3121 static int
3122 check_long_reg ()
3123 {
3124   int op;
3125
3126   for (op = i.operands; --op >= 0;)
3127     /* Reject eight bit registers, except where the template requires
3128        them. (eg. movzb)  */
3129     if ((i.types[op] & Reg8) != 0
3130         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
3131       {
3132         as_bad (_("`%%%s' not allowed with `%s%c'"),
3133                 i.op[op].regs->reg_name,
3134                 i.tm.name,
3135                 i.suffix);
3136         return 0;
3137       }
3138   /* Warn if the e prefix on a general reg is missing.  */
3139     else if ((!quiet_warnings || flag_code == CODE_64BIT)
3140              && (i.types[op] & Reg16) != 0
3141              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
3142       {
3143         /* Prohibit these changes in the 64bit mode, since the
3144            lowering is more complicated.  */
3145         if (flag_code == CODE_64BIT)
3146           {
3147             as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
3148                     i.op[op].regs->reg_name,
3149                     i.suffix);
3150             return 0;
3151           }
3152 #if REGISTER_WARNINGS
3153         else
3154           as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
3155                    (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
3156                    i.op[op].regs->reg_name,
3157                    i.suffix);
3158 #endif
3159       }
3160   /* Warn if the r prefix on a general reg is missing.  */
3161     else if ((i.types[op] & Reg64) != 0
3162              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
3163       {
3164         as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
3165                 i.op[op].regs->reg_name,
3166                 i.suffix);
3167         return 0;
3168       }
3169   return 1;
3170 }
3171
3172 static int
3173 check_qword_reg ()
3174 {
3175   int op;
3176
3177   for (op = i.operands; --op >= 0; )
3178     /* Reject eight bit registers, except where the template requires
3179        them. (eg. movzb)  */
3180     if ((i.types[op] & Reg8) != 0
3181         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
3182       {
3183         as_bad (_("`%%%s' not allowed with `%s%c'"),
3184                 i.op[op].regs->reg_name,
3185                 i.tm.name,
3186                 i.suffix);
3187         return 0;
3188       }
3189   /* Warn if the e prefix on a general reg is missing.  */
3190     else if (((i.types[op] & Reg16) != 0
3191               || (i.types[op] & Reg32) != 0)
3192              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
3193       {
3194         /* Prohibit these changes in the 64bit mode, since the
3195            lowering is more complicated.  */
3196         as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
3197                 i.op[op].regs->reg_name,
3198                 i.suffix);
3199         return 0;
3200       }
3201   return 1;
3202 }
3203
3204 static int
3205 check_word_reg ()
3206 {
3207   int op;
3208   for (op = i.operands; --op >= 0;)
3209     /* Reject eight bit registers, except where the template requires
3210        them. (eg. movzb)  */
3211     if ((i.types[op] & Reg8) != 0
3212         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
3213       {
3214         as_bad (_("`%%%s' not allowed with `%s%c'"),
3215                 i.op[op].regs->reg_name,
3216                 i.tm.name,
3217                 i.suffix);
3218         return 0;
3219       }
3220   /* Warn if the e prefix on a general reg is present.  */
3221     else if ((!quiet_warnings || flag_code == CODE_64BIT)
3222              && (i.types[op] & Reg32) != 0
3223              && (i.tm.operand_types[op] & (Reg16 | Acc)) != 0)
3224       {
3225         /* Prohibit these changes in the 64bit mode, since the
3226            lowering is more complicated.  */
3227         if (flag_code == CODE_64BIT)
3228           {
3229             as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
3230                     i.op[op].regs->reg_name,
3231                     i.suffix);
3232             return 0;
3233           }
3234         else
3235 #if REGISTER_WARNINGS
3236           as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
3237                    (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
3238                    i.op[op].regs->reg_name,
3239                    i.suffix);
3240 #endif
3241       }
3242   return 1;
3243 }
3244
3245 static int
3246 finalize_imm ()
3247 {
3248   unsigned int overlap0, overlap1, overlap2;
3249
3250   overlap0 = i.types[0] & i.tm.operand_types[0];
3251   if ((overlap0 & (Imm8 | Imm8S | Imm16 | Imm32 | Imm32S | Imm64))
3252       && overlap0 != Imm8 && overlap0 != Imm8S
3253       && overlap0 != Imm16 && overlap0 != Imm32S
3254       && overlap0 != Imm32 && overlap0 != Imm64)
3255     {
3256       if (i.suffix)
3257         {
3258           overlap0 &= (i.suffix == BYTE_MNEM_SUFFIX
3259                        ? Imm8 | Imm8S
3260                        : (i.suffix == WORD_MNEM_SUFFIX
3261                           ? Imm16
3262                           : (i.suffix == QWORD_MNEM_SUFFIX
3263                              ? Imm64 | Imm32S
3264                              : Imm32)));
3265         }
3266       else if (overlap0 == (Imm16 | Imm32S | Imm32)
3267                || overlap0 == (Imm16 | Imm32)
3268                || overlap0 == (Imm16 | Imm32S))
3269         {
3270           overlap0 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
3271                       ? Imm16 : Imm32S);
3272         }
3273       if (overlap0 != Imm8 && overlap0 != Imm8S
3274           && overlap0 != Imm16 && overlap0 != Imm32S
3275           && overlap0 != Imm32 && overlap0 != Imm64)
3276         {
3277           as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
3278           return 0;
3279         }
3280     }
3281   i.types[0] = overlap0;
3282
3283   overlap1 = i.types[1] & i.tm.operand_types[1];
3284   if ((overlap1 & (Imm8 | Imm8S | Imm16 | Imm32S | Imm32 | Imm64))
3285       && overlap1 != Imm8 && overlap1 != Imm8S
3286       && overlap1 != Imm16 && overlap1 != Imm32S
3287       && overlap1 != Imm32 && overlap1 != Imm64)
3288     {
3289       if (i.suffix)
3290         {
3291           overlap1 &= (i.suffix == BYTE_MNEM_SUFFIX
3292                        ? Imm8 | Imm8S
3293                        : (i.suffix == WORD_MNEM_SUFFIX
3294                           ? Imm16
3295                           : (i.suffix == QWORD_MNEM_SUFFIX
3296                              ? Imm64 | Imm32S
3297                              : Imm32)));
3298         }
3299       else if (overlap1 == (Imm16 | Imm32 | Imm32S)
3300                || overlap1 == (Imm16 | Imm32)
3301                || overlap1 == (Imm16 | Imm32S))
3302         {
3303           overlap1 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
3304                       ? Imm16 : Imm32S);
3305         }
3306       if (overlap1 != Imm8 && overlap1 != Imm8S
3307           && overlap1 != Imm16 && overlap1 != Imm32S
3308           && overlap1 != Imm32 && overlap1 != Imm64)
3309         {
3310           as_bad (_("no instruction mnemonic suffix given; can't determine immediate size %x %c"),overlap1, i.suffix);
3311           return 0;
3312         }
3313     }
3314   i.types[1] = overlap1;
3315
3316   overlap2 = i.types[2] & i.tm.operand_types[2];
3317   assert ((overlap2 & Imm) == 0);
3318   i.types[2] = overlap2;
3319
3320   return 1;
3321 }
3322
3323 static int
3324 process_operands ()
3325 {
3326   /* Default segment register this instruction will use for memory
3327      accesses.  0 means unknown.  This is only for optimizing out
3328      unnecessary segment overrides.  */
3329   const seg_entry *default_seg = 0;
3330
3331   /* The imul $imm, %reg instruction is converted into
3332      imul $imm, %reg, %reg, and the clr %reg instruction
3333      is converted into xor %reg, %reg.  */
3334   if (i.tm.opcode_modifier & regKludge)
3335     {
3336       unsigned int first_reg_op = (i.types[0] & Reg) ? 0 : 1;
3337       /* Pretend we saw the extra register operand.  */
3338       assert (i.reg_operands == 1
3339               && i.op[first_reg_op + 1].regs == 0);
3340       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
3341       i.types[first_reg_op + 1] = i.types[first_reg_op];
3342       i.operands++;
3343       i.reg_operands++;
3344     }
3345
3346   if (i.tm.opcode_modifier & ShortForm)
3347     {
3348       /* The register or float register operand is in operand 0 or 1.  */
3349       unsigned int op = (i.types[0] & (Reg | FloatReg)) ? 0 : 1;
3350       /* Register goes in low 3 bits of opcode.  */
3351       i.tm.base_opcode |= i.op[op].regs->reg_num;
3352       if ((i.op[op].regs->reg_flags & RegRex) != 0)
3353         i.rex |= REX_EXTZ;
3354       if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
3355         {
3356           /* Warn about some common errors, but press on regardless.
3357              The first case can be generated by gcc (<= 2.8.1).  */
3358           if (i.operands == 2)
3359             {
3360               /* Reversed arguments on faddp, fsubp, etc.  */
3361               as_warn (_("translating to `%s %%%s,%%%s'"), i.tm.name,
3362                        i.op[1].regs->reg_name,
3363                        i.op[0].regs->reg_name);
3364             }
3365           else
3366             {
3367               /* Extraneous `l' suffix on fp insn.  */
3368               as_warn (_("translating to `%s %%%s'"), i.tm.name,
3369                        i.op[0].regs->reg_name);
3370             }
3371         }
3372     }
3373   else if (i.tm.opcode_modifier & Modrm)
3374     {
3375       /* The opcode is completed (modulo i.tm.extension_opcode which
3376          must be put into the modrm byte).  Now, we make the modrm and
3377          index base bytes based on all the info we've collected.  */
3378
3379       default_seg = build_modrm_byte ();
3380     }
3381   else if (i.tm.opcode_modifier & (Seg2ShortForm | Seg3ShortForm))
3382     {
3383       if (i.tm.base_opcode == POP_SEG_SHORT
3384           && i.op[0].regs->reg_num == 1)
3385         {
3386           as_bad (_("you can't `pop %%cs'"));
3387           return 0;
3388         }
3389       i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
3390       if ((i.op[0].regs->reg_flags & RegRex) != 0)
3391         i.rex |= REX_EXTZ;
3392     }
3393   else if ((i.tm.base_opcode & ~(D | W)) == MOV_AX_DISP32)
3394     {
3395       default_seg = &ds;
3396     }
3397   else if ((i.tm.opcode_modifier & IsString) != 0)
3398     {
3399       /* For the string instructions that allow a segment override
3400          on one of their operands, the default segment is ds.  */
3401       default_seg = &ds;
3402     }
3403
3404   if ((i.tm.base_opcode == 0x8d /* lea */
3405        || (i.tm.cpu_flags & CpuSVME))
3406       && i.seg[0] && !quiet_warnings)
3407     as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
3408
3409   /* If a segment was explicitly specified, and the specified segment
3410      is not the default, use an opcode prefix to select it.  If we
3411      never figured out what the default segment is, then default_seg
3412      will be zero at this point, and the specified segment prefix will
3413      always be used.  */
3414   if ((i.seg[0]) && (i.seg[0] != default_seg))
3415     {
3416       if (!add_prefix (i.seg[0]->seg_prefix))
3417         return 0;
3418     }
3419   return 1;
3420 }
3421
3422 static const seg_entry *
3423 build_modrm_byte ()
3424 {
3425   const seg_entry *default_seg = 0;
3426
3427   /* i.reg_operands MUST be the number of real register operands;
3428      implicit registers do not count.  */
3429   if (i.reg_operands == 2)
3430     {
3431       unsigned int source, dest;
3432
3433       switch (i.operands)
3434         {
3435         case 2:
3436           source = 0;
3437           break;
3438         case 3:
3439           /* When there are 3 operands, one of them may be immediate,
3440              which may be the first or the last operand.  Otherwise,
3441              the first operand must be shift count register (cl). */
3442           assert (i.imm_operands == 1
3443                   || (i.imm_operands == 0
3444                       && (i.types[0] & ShiftCount)));
3445           source = (i.types[0] & (Imm | ShiftCount)) ? 1 : 0;
3446           break;
3447         case 4:
3448           /* When there are 4 operands, the first two must be immediate
3449              operands. The source operand will be the 3rd one.  */
3450           assert (i.imm_operands == 2
3451                   && (i.types[0] & Imm)
3452                   && (i.types[1] & Imm));
3453           source = 2;
3454           break;
3455         default:
3456           abort ();
3457         }
3458
3459       dest = source + 1;
3460
3461       i.rm.mode = 3;
3462       /* One of the register operands will be encoded in the i.tm.reg
3463          field, the other in the combined i.tm.mode and i.tm.regmem
3464          fields.  If no form of this instruction supports a memory
3465          destination operand, then we assume the source operand may
3466          sometimes be a memory operand and so we need to store the
3467          destination in the i.rm.reg field.  */
3468       if ((i.tm.operand_types[dest] & AnyMem) == 0)
3469         {
3470           i.rm.reg = i.op[dest].regs->reg_num;
3471           i.rm.regmem = i.op[source].regs->reg_num;
3472           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
3473             i.rex |= REX_EXTX;
3474           if ((i.op[source].regs->reg_flags & RegRex) != 0)
3475             i.rex |= REX_EXTZ;
3476         }
3477       else
3478         {
3479           i.rm.reg = i.op[source].regs->reg_num;
3480           i.rm.regmem = i.op[dest].regs->reg_num;
3481           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
3482             i.rex |= REX_EXTZ;
3483           if ((i.op[source].regs->reg_flags & RegRex) != 0)
3484             i.rex |= REX_EXTX;
3485         }
3486       if (flag_code != CODE_64BIT && (i.rex & (REX_EXTX | REX_EXTZ)))
3487         {
3488           if (!((i.types[0] | i.types[1]) & Control))
3489             abort ();
3490           i.rex &= ~(REX_EXTX | REX_EXTZ);
3491           add_prefix (LOCK_PREFIX_OPCODE);
3492         }
3493     }
3494   else
3495     {                   /* If it's not 2 reg operands...  */
3496       if (i.mem_operands)
3497         {
3498           unsigned int fake_zero_displacement = 0;
3499           unsigned int op = ((i.types[0] & AnyMem)
3500                              ? 0
3501                              : (i.types[1] & AnyMem) ? 1 : 2);
3502
3503           default_seg = &ds;
3504
3505           if (i.base_reg == 0)
3506             {
3507               i.rm.mode = 0;
3508               if (!i.disp_operands)
3509                 fake_zero_displacement = 1;
3510               if (i.index_reg == 0)
3511                 {
3512                   /* Operand is just <disp>  */
3513                   if (flag_code == CODE_64BIT)
3514                     {
3515                       /* 64bit mode overwrites the 32bit absolute
3516                          addressing by RIP relative addressing and
3517                          absolute addressing is encoded by one of the
3518                          redundant SIB forms.  */
3519                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3520                       i.sib.base = NO_BASE_REGISTER;
3521                       i.sib.index = NO_INDEX_REGISTER;
3522                       i.types[op] = ((i.prefix[ADDR_PREFIX] == 0)
3523                                      ? Disp32S : Disp32);
3524                     }
3525                   else if ((flag_code == CODE_16BIT)
3526                            ^ (i.prefix[ADDR_PREFIX] != 0))
3527                     {
3528                       i.rm.regmem = NO_BASE_REGISTER_16;
3529                       i.types[op] = Disp16;
3530                     }
3531                   else
3532                     {
3533                       i.rm.regmem = NO_BASE_REGISTER;
3534                       i.types[op] = Disp32;
3535                     }
3536                 }
3537               else /* !i.base_reg && i.index_reg  */
3538                 {
3539                   i.sib.index = i.index_reg->reg_num;
3540                   i.sib.base = NO_BASE_REGISTER;
3541                   i.sib.scale = i.log2_scale_factor;
3542                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3543                   i.types[op] &= ~Disp;
3544                   if (flag_code != CODE_64BIT)
3545                     i.types[op] |= Disp32;      /* Must be 32 bit */
3546                   else
3547                     i.types[op] |= Disp32S;
3548                   if ((i.index_reg->reg_flags & RegRex) != 0)
3549                     i.rex |= REX_EXTY;
3550                 }
3551             }
3552           /* RIP addressing for 64bit mode.  */
3553           else if (i.base_reg->reg_type == BaseIndex)
3554             {
3555               i.rm.regmem = NO_BASE_REGISTER;
3556               i.types[op] &= ~ Disp;
3557               i.types[op] |= Disp32S;
3558               i.flags[op] |= Operand_PCrel;
3559               if (! i.disp_operands)
3560                 fake_zero_displacement = 1;
3561             }
3562           else if (i.base_reg->reg_type & Reg16)
3563             {
3564               switch (i.base_reg->reg_num)
3565                 {
3566                 case 3: /* (%bx)  */
3567                   if (i.index_reg == 0)
3568                     i.rm.regmem = 7;
3569                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
3570                     i.rm.regmem = i.index_reg->reg_num - 6;
3571                   break;
3572                 case 5: /* (%bp)  */
3573                   default_seg = &ss;
3574                   if (i.index_reg == 0)
3575                     {
3576                       i.rm.regmem = 6;
3577                       if ((i.types[op] & Disp) == 0)
3578                         {
3579                           /* fake (%bp) into 0(%bp)  */
3580                           i.types[op] |= Disp8;
3581                           fake_zero_displacement = 1;
3582                         }
3583                     }
3584                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
3585                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
3586                   break;
3587                 default: /* (%si) -> 4 or (%di) -> 5  */
3588                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
3589                 }
3590               i.rm.mode = mode_from_disp_size (i.types[op]);
3591             }
3592           else /* i.base_reg and 32/64 bit mode  */
3593             {
3594               if (flag_code == CODE_64BIT
3595                   && (i.types[op] & Disp))
3596                 i.types[op] = ((i.types[op] & Disp8)
3597                                | (i.prefix[ADDR_PREFIX] == 0
3598                                   ? Disp32S : Disp32));
3599
3600               i.rm.regmem = i.base_reg->reg_num;
3601               if ((i.base_reg->reg_flags & RegRex) != 0)
3602                 i.rex |= REX_EXTZ;
3603               i.sib.base = i.base_reg->reg_num;
3604               /* x86-64 ignores REX prefix bit here to avoid decoder
3605                  complications.  */
3606               if ((i.base_reg->reg_num & 7) == EBP_REG_NUM)
3607                 {
3608                   default_seg = &ss;
3609                   if (i.disp_operands == 0)
3610                     {
3611                       fake_zero_displacement = 1;
3612                       i.types[op] |= Disp8;
3613                     }
3614                 }
3615               else if (i.base_reg->reg_num == ESP_REG_NUM)
3616                 {
3617                   default_seg = &ss;
3618                 }
3619               i.sib.scale = i.log2_scale_factor;
3620               if (i.index_reg == 0)
3621                 {
3622                   /* <disp>(%esp) becomes two byte modrm with no index
3623                      register.  We've already stored the code for esp
3624                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
3625                      Any base register besides %esp will not use the
3626                      extra modrm byte.  */
3627                   i.sib.index = NO_INDEX_REGISTER;
3628 #if !SCALE1_WHEN_NO_INDEX
3629                   /* Another case where we force the second modrm byte.  */
3630                   if (i.log2_scale_factor)
3631                     i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3632 #endif
3633                 }
3634               else
3635                 {
3636                   i.sib.index = i.index_reg->reg_num;
3637                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3638                   if ((i.index_reg->reg_flags & RegRex) != 0)
3639                     i.rex |= REX_EXTY;
3640                 }
3641
3642               if (i.disp_operands
3643                   && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
3644                       || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
3645                 i.rm.mode = 0;
3646               else
3647                 i.rm.mode = mode_from_disp_size (i.types[op]);
3648             }
3649
3650           if (fake_zero_displacement)
3651             {
3652               /* Fakes a zero displacement assuming that i.types[op]
3653                  holds the correct displacement size.  */
3654               expressionS *exp;
3655
3656               assert (i.op[op].disps == 0);
3657               exp = &disp_expressions[i.disp_operands++];
3658               i.op[op].disps = exp;
3659               exp->X_op = O_constant;
3660               exp->X_add_number = 0;
3661               exp->X_add_symbol = (symbolS *) 0;
3662               exp->X_op_symbol = (symbolS *) 0;
3663             }
3664         }
3665
3666       /* Fill in i.rm.reg or i.rm.regmem field with register operand
3667          (if any) based on i.tm.extension_opcode.  Again, we must be
3668          careful to make sure that segment/control/debug/test/MMX
3669          registers are coded into the i.rm.reg field.  */
3670       if (i.reg_operands)
3671         {
3672           unsigned int op =
3673             ((i.types[0]
3674               & (Reg | RegMMX | RegXMM
3675                  | SReg2 | SReg3
3676                  | Control | Debug | Test))
3677              ? 0
3678              : ((i.types[1]
3679                  & (Reg | RegMMX | RegXMM
3680                     | SReg2 | SReg3
3681                     | Control | Debug | Test))
3682                 ? 1
3683                 : 2));
3684           /* If there is an extension opcode to put here, the register
3685              number must be put into the regmem field.  */
3686           if (i.tm.extension_opcode != None)
3687             {
3688               i.rm.regmem = i.op[op].regs->reg_num;
3689               if ((i.op[op].regs->reg_flags & RegRex) != 0)
3690                 i.rex |= REX_EXTZ;
3691             }
3692           else
3693             {
3694               i.rm.reg = i.op[op].regs->reg_num;
3695               if ((i.op[op].regs->reg_flags & RegRex) != 0)
3696                 i.rex |= REX_EXTX;
3697             }
3698
3699           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
3700              must set it to 3 to indicate this is a register operand
3701              in the regmem field.  */
3702           if (!i.mem_operands)
3703             i.rm.mode = 3;
3704         }
3705
3706       /* Fill in i.rm.reg field with extension opcode (if any).  */
3707       if (i.tm.extension_opcode != None)
3708         i.rm.reg = i.tm.extension_opcode;
3709     }
3710   return default_seg;
3711 }
3712
3713 static void
3714 output_branch ()
3715 {
3716   char *p;
3717   int code16;
3718   int prefix;
3719   relax_substateT subtype;
3720   symbolS *sym;
3721   offsetT off;
3722
3723   code16 = 0;
3724   if (flag_code == CODE_16BIT)
3725     code16 = CODE16;
3726
3727   prefix = 0;
3728   if (i.prefix[DATA_PREFIX] != 0)
3729     {
3730       prefix = 1;
3731       i.prefixes -= 1;
3732       code16 ^= CODE16;
3733     }
3734   /* Pentium4 branch hints.  */
3735   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
3736       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
3737     {
3738       prefix++;
3739       i.prefixes--;
3740     }
3741   if (i.prefix[REX_PREFIX] != 0)
3742     {
3743       prefix++;
3744       i.prefixes--;
3745     }
3746
3747   if (i.prefixes != 0 && !intel_syntax)
3748     as_warn (_("skipping prefixes on this instruction"));
3749
3750   /* It's always a symbol;  End frag & setup for relax.
3751      Make sure there is enough room in this frag for the largest
3752      instruction we may generate in md_convert_frag.  This is 2
3753      bytes for the opcode and room for the prefix and largest
3754      displacement.  */
3755   frag_grow (prefix + 2 + 4);
3756   /* Prefix and 1 opcode byte go in fr_fix.  */
3757   p = frag_more (prefix + 1);
3758   if (i.prefix[DATA_PREFIX] != 0)
3759     *p++ = DATA_PREFIX_OPCODE;
3760   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
3761       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
3762     *p++ = i.prefix[SEG_PREFIX];
3763   if (i.prefix[REX_PREFIX] != 0)
3764     *p++ = i.prefix[REX_PREFIX];
3765   *p = i.tm.base_opcode;
3766
3767   if ((unsigned char) *p == JUMP_PC_RELATIVE)
3768     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL);
3769   else if ((cpu_arch_flags & Cpu386) != 0)
3770     subtype = ENCODE_RELAX_STATE (COND_JUMP, SMALL);
3771   else
3772     subtype = ENCODE_RELAX_STATE (COND_JUMP86, SMALL);
3773   subtype |= code16;
3774
3775   sym = i.op[0].disps->X_add_symbol;
3776   off = i.op[0].disps->X_add_number;
3777
3778   if (i.op[0].disps->X_op != O_constant
3779       && i.op[0].disps->X_op != O_symbol)
3780     {
3781       /* Handle complex expressions.  */
3782       sym = make_expr_symbol (i.op[0].disps);
3783       off = 0;
3784     }
3785
3786   /* 1 possible extra opcode + 4 byte displacement go in var part.
3787      Pass reloc in fr_var.  */
3788   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
3789 }
3790
3791 static void
3792 output_jump ()
3793 {
3794   char *p;
3795   int size;
3796   fixS *fixP;
3797
3798   if (i.tm.opcode_modifier & JumpByte)
3799     {
3800       /* This is a loop or jecxz type instruction.  */
3801       size = 1;
3802       if (i.prefix[ADDR_PREFIX] != 0)
3803         {
3804           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
3805           i.prefixes -= 1;
3806         }
3807       /* Pentium4 branch hints.  */
3808       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
3809           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
3810         {
3811           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
3812           i.prefixes--;
3813         }
3814     }
3815   else
3816     {
3817       int code16;
3818
3819       code16 = 0;
3820       if (flag_code == CODE_16BIT)
3821         code16 = CODE16;
3822
3823       if (i.prefix[DATA_PREFIX] != 0)
3824         {
3825           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
3826           i.prefixes -= 1;
3827           code16 ^= CODE16;
3828         }
3829
3830       size = 4;
3831       if (code16)
3832         size = 2;
3833     }
3834
3835   if (i.prefix[REX_PREFIX] != 0)
3836     {
3837       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
3838       i.prefixes -= 1;
3839     }
3840
3841   if (i.prefixes != 0 && !intel_syntax)
3842     as_warn (_("skipping prefixes on this instruction"));
3843
3844   p = frag_more (1 + size);
3845   *p++ = i.tm.base_opcode;
3846
3847   fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3848                       i.op[0].disps, 1, reloc (size, 1, 1, i.reloc[0]));
3849
3850   /* All jumps handled here are signed, but don't use a signed limit
3851      check for 32 and 16 bit jumps as we want to allow wrap around at
3852      4G and 64k respectively.  */
3853   if (size == 1)
3854     fixP->fx_signed = 1;
3855 }
3856
3857 static void
3858 output_interseg_jump ()
3859 {
3860   char *p;
3861   int size;
3862   int prefix;
3863   int code16;
3864
3865   code16 = 0;
3866   if (flag_code == CODE_16BIT)
3867     code16 = CODE16;
3868
3869   prefix = 0;
3870   if (i.prefix[DATA_PREFIX] != 0)
3871     {
3872       prefix = 1;
3873       i.prefixes -= 1;
3874       code16 ^= CODE16;
3875     }
3876   if (i.prefix[REX_PREFIX] != 0)
3877     {
3878       prefix++;
3879       i.prefixes -= 1;
3880     }
3881
3882   size = 4;
3883   if (code16)
3884     size = 2;
3885
3886   if (i.prefixes != 0 && !intel_syntax)
3887     as_warn (_("skipping prefixes on this instruction"));
3888
3889   /* 1 opcode; 2 segment; offset  */
3890   p = frag_more (prefix + 1 + 2 + size);
3891
3892   if (i.prefix[DATA_PREFIX] != 0)
3893     *p++ = DATA_PREFIX_OPCODE;
3894
3895   if (i.prefix[REX_PREFIX] != 0)
3896     *p++ = i.prefix[REX_PREFIX];
3897
3898   *p++ = i.tm.base_opcode;
3899   if (i.op[1].imms->X_op == O_constant)
3900     {
3901       offsetT n = i.op[1].imms->X_add_number;
3902
3903       if (size == 2
3904           && !fits_in_unsigned_word (n)
3905           && !fits_in_signed_word (n))
3906         {
3907           as_bad (_("16-bit jump out of range"));
3908           return;
3909         }
3910       md_number_to_chars (p, n, size);
3911     }
3912   else
3913     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3914                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
3915   if (i.op[0].imms->X_op != O_constant)
3916     as_bad (_("can't handle non absolute segment in `%s'"),
3917             i.tm.name);
3918   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
3919 }
3920
3921 static void
3922 output_insn ()
3923 {
3924   fragS *insn_start_frag;
3925   offsetT insn_start_off;
3926
3927   /* Tie dwarf2 debug info to the address at the start of the insn.
3928      We can't do this after the insn has been output as the current
3929      frag may have been closed off.  eg. by frag_var.  */
3930   dwarf2_emit_insn (0);
3931
3932   insn_start_frag = frag_now;
3933   insn_start_off = frag_now_fix ();
3934
3935   /* Output jumps.  */
3936   if (i.tm.opcode_modifier & Jump)
3937     output_branch ();
3938   else if (i.tm.opcode_modifier & (JumpByte | JumpDword))
3939     output_jump ();
3940   else if (i.tm.opcode_modifier & JumpInterSegment)
3941     output_interseg_jump ();
3942   else
3943     {
3944       /* Output normal instructions here.  */
3945       char *p;
3946       unsigned char *q;
3947       unsigned int prefix;
3948
3949       /* All opcodes on i386 have either 1 or 2 bytes.  Supplemental
3950          Streaming SIMD extensions 3 Instructions have 3 bytes.  We may
3951          use one more higher byte to specify a prefix the instruction
3952          requires.  */
3953       if ((i.tm.cpu_flags & CpuSSSE3) != 0)
3954         {
3955           if (i.tm.base_opcode & 0xff000000)
3956             {
3957               prefix = (i.tm.base_opcode >> 24) & 0xff;
3958               goto check_prefix;
3959             }
3960         }
3961       else if ((i.tm.base_opcode & 0xff0000) != 0)
3962         {
3963           prefix = (i.tm.base_opcode >> 16) & 0xff;
3964           if ((i.tm.cpu_flags & CpuPadLock) != 0)
3965             {
3966             check_prefix:
3967               if (prefix != REPE_PREFIX_OPCODE
3968                   || i.prefix[LOCKREP_PREFIX] != REPE_PREFIX_OPCODE)
3969                 add_prefix (prefix);
3970             }
3971           else
3972             add_prefix (prefix);
3973         }
3974
3975       /* The prefix bytes.  */
3976       for (q = i.prefix;
3977            q < i.prefix + sizeof (i.prefix) / sizeof (i.prefix[0]);
3978            q++)
3979         {
3980           if (*q)
3981             {
3982               p = frag_more (1);
3983               md_number_to_chars (p, (valueT) *q, 1);
3984             }
3985         }
3986
3987       /* Now the opcode; be careful about word order here!  */
3988       if (fits_in_unsigned_byte (i.tm.base_opcode))
3989         {
3990           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
3991         }
3992       else
3993         {
3994           if ((i.tm.cpu_flags & CpuSSSE3) != 0)
3995             {
3996               p = frag_more (3);
3997               *p++ = (i.tm.base_opcode >> 16) & 0xff;
3998             }
3999           else
4000             p = frag_more (2);
4001
4002           /* Put out high byte first: can't use md_number_to_chars!  */
4003           *p++ = (i.tm.base_opcode >> 8) & 0xff;
4004           *p = i.tm.base_opcode & 0xff;
4005         }
4006
4007       /* Now the modrm byte and sib byte (if present).  */
4008       if (i.tm.opcode_modifier & Modrm)
4009         {
4010           p = frag_more (1);
4011           md_number_to_chars (p,
4012                               (valueT) (i.rm.regmem << 0
4013                                         | i.rm.reg << 3
4014                                         | i.rm.mode << 6),
4015                               1);
4016           /* If i.rm.regmem == ESP (4)
4017              && i.rm.mode != (Register mode)
4018              && not 16 bit
4019              ==> need second modrm byte.  */
4020           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
4021               && i.rm.mode != 3
4022               && !(i.base_reg && (i.base_reg->reg_type & Reg16) != 0))
4023             {
4024               p = frag_more (1);
4025               md_number_to_chars (p,
4026                                   (valueT) (i.sib.base << 0
4027                                             | i.sib.index << 3
4028                                             | i.sib.scale << 6),
4029                                   1);
4030             }
4031         }
4032
4033       if (i.disp_operands)
4034         output_disp (insn_start_frag, insn_start_off);
4035
4036       if (i.imm_operands)
4037         output_imm (insn_start_frag, insn_start_off);
4038     }
4039
4040 #ifdef DEBUG386
4041   if (flag_debug)
4042     {
4043       pi ("" /*line*/, &i);
4044     }
4045 #endif /* DEBUG386  */
4046 }
4047
4048 static void
4049 output_disp (fragS *insn_start_frag, offsetT insn_start_off)
4050 {
4051   char *p;
4052   unsigned int n;
4053
4054   for (n = 0; n < i.operands; n++)
4055     {
4056       if (i.types[n] & Disp)
4057         {
4058           if (i.op[n].disps->X_op == O_constant)
4059             {
4060               int size;
4061               offsetT val;
4062
4063               size = 4;
4064               if (i.types[n] & (Disp8 | Disp16 | Disp64))
4065                 {
4066                   size = 2;
4067                   if (i.types[n] & Disp8)
4068                     size = 1;
4069                   if (i.types[n] & Disp64)
4070                     size = 8;
4071                 }
4072               val = offset_in_range (i.op[n].disps->X_add_number,
4073                                      size);
4074               p = frag_more (size);
4075               md_number_to_chars (p, val, size);
4076             }
4077           else
4078             {
4079               enum bfd_reloc_code_real reloc_type;
4080               int size = 4;
4081               int sign = 0;
4082               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
4083
4084               /* The PC relative address is computed relative
4085                  to the instruction boundary, so in case immediate
4086                  fields follows, we need to adjust the value.  */
4087               if (pcrel && i.imm_operands)
4088                 {
4089                   int imm_size = 4;
4090                   unsigned int n1;
4091
4092                   for (n1 = 0; n1 < i.operands; n1++)
4093                     if (i.types[n1] & Imm)
4094                       {
4095                         if (i.types[n1] & (Imm8 | Imm8S | Imm16 | Imm64))
4096                           {
4097                             imm_size = 2;
4098                             if (i.types[n1] & (Imm8 | Imm8S))
4099                               imm_size = 1;
4100                             if (i.types[n1] & Imm64)
4101                               imm_size = 8;
4102                           }
4103                         break;
4104                       }
4105                   /* We should find the immediate.  */
4106                   if (n1 == i.operands)
4107                     abort ();
4108                   i.op[n].disps->X_add_number -= imm_size;
4109                 }
4110
4111               if (i.types[n] & Disp32S)
4112                 sign = 1;
4113
4114               if (i.types[n] & (Disp16 | Disp64))
4115                 {
4116                   size = 2;
4117                   if (i.types[n] & Disp64)
4118                     size = 8;
4119                 }
4120
4121               p = frag_more (size);
4122               reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
4123               if (GOT_symbol
4124                   && GOT_symbol == i.op[n].disps->X_add_symbol
4125                   && (((reloc_type == BFD_RELOC_32
4126                         || reloc_type == BFD_RELOC_X86_64_32S
4127                         || (reloc_type == BFD_RELOC_64
4128                             && object_64bit))
4129                        && (i.op[n].disps->X_op == O_symbol
4130                            || (i.op[n].disps->X_op == O_add
4131                                && ((symbol_get_value_expression
4132                                     (i.op[n].disps->X_op_symbol)->X_op)
4133                                    == O_subtract))))
4134                       || reloc_type == BFD_RELOC_32_PCREL))
4135                 {
4136                   offsetT add;
4137
4138                   if (insn_start_frag == frag_now)
4139                     add = (p - frag_now->fr_literal) - insn_start_off;
4140                   else
4141                     {
4142                       fragS *fr;
4143
4144                       add = insn_start_frag->fr_fix - insn_start_off;
4145                       for (fr = insn_start_frag->fr_next;
4146                            fr && fr != frag_now; fr = fr->fr_next)
4147                         add += fr->fr_fix;
4148                       add += p - frag_now->fr_literal;
4149                     }
4150
4151                   if (!object_64bit)
4152                     {
4153                       reloc_type = BFD_RELOC_386_GOTPC;
4154                       i.op[n].imms->X_add_number += add;
4155                     }
4156                   else if (reloc_type == BFD_RELOC_64)
4157                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
4158                   else
4159                     /* Don't do the adjustment for x86-64, as there
4160                        the pcrel addressing is relative to the _next_
4161                        insn, and that is taken care of in other code.  */
4162                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
4163                 }
4164               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
4165                            i.op[n].disps, pcrel, reloc_type);
4166             }
4167         }
4168     }
4169 }
4170
4171 static void
4172 output_imm (fragS *insn_start_frag, offsetT insn_start_off)
4173 {
4174   char *p;
4175   unsigned int n;
4176
4177   for (n = 0; n < i.operands; n++)
4178     {
4179       if (i.types[n] & Imm)
4180         {
4181           if (i.op[n].imms->X_op == O_constant)
4182             {
4183               int size;
4184               offsetT val;
4185
4186               size = 4;
4187               if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
4188                 {
4189                   size = 2;
4190                   if (i.types[n] & (Imm8 | Imm8S))
4191                     size = 1;
4192                   else if (i.types[n] & Imm64)
4193                     size = 8;
4194                 }
4195               val = offset_in_range (i.op[n].imms->X_add_number,
4196                                      size);
4197               p = frag_more (size);
4198               md_number_to_chars (p, val, size);
4199             }
4200           else
4201             {
4202               /* Not absolute_section.
4203                  Need a 32-bit fixup (don't support 8bit
4204                  non-absolute imms).  Try to support other
4205                  sizes ...  */
4206               enum bfd_reloc_code_real reloc_type;
4207               int size = 4;
4208               int sign = 0;
4209
4210               if ((i.types[n] & (Imm32S))
4211                   && (i.suffix == QWORD_MNEM_SUFFIX
4212                       || (!i.suffix && (i.tm.opcode_modifier & No_lSuf))))
4213                 sign = 1;
4214               if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
4215                 {
4216                   size = 2;
4217                   if (i.types[n] & (Imm8 | Imm8S))
4218                     size = 1;
4219                   if (i.types[n] & Imm64)
4220                     size = 8;
4221                 }
4222
4223               p = frag_more (size);
4224               reloc_type = reloc (size, 0, sign, i.reloc[n]);
4225
4226               /*   This is tough to explain.  We end up with this one if we
4227                * have operands that look like
4228                * "_GLOBAL_OFFSET_TABLE_+[.-.L284]".  The goal here is to
4229                * obtain the absolute address of the GOT, and it is strongly
4230                * preferable from a performance point of view to avoid using
4231                * a runtime relocation for this.  The actual sequence of
4232                * instructions often look something like:
4233                *
4234                *        call    .L66
4235                * .L66:
4236                *        popl    %ebx
4237                *        addl    $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
4238                *
4239                *   The call and pop essentially return the absolute address
4240                * of the label .L66 and store it in %ebx.  The linker itself
4241                * will ultimately change the first operand of the addl so
4242                * that %ebx points to the GOT, but to keep things simple, the
4243                * .o file must have this operand set so that it generates not
4244                * the absolute address of .L66, but the absolute address of
4245                * itself.  This allows the linker itself simply treat a GOTPC
4246                * relocation as asking for a pcrel offset to the GOT to be
4247                * added in, and the addend of the relocation is stored in the
4248                * operand field for the instruction itself.
4249                *
4250                *   Our job here is to fix the operand so that it would add
4251                * the correct offset so that %ebx would point to itself.  The
4252                * thing that is tricky is that .-.L66 will point to the
4253                * beginning of the instruction, so we need to further modify
4254                * the operand so that it will point to itself.  There are
4255                * other cases where you have something like:
4256                *
4257                *        .long   $_GLOBAL_OFFSET_TABLE_+[.-.L66]
4258                *
4259                * and here no correction would be required.  Internally in
4260                * the assembler we treat operands of this form as not being
4261                * pcrel since the '.' is explicitly mentioned, and I wonder
4262                * whether it would simplify matters to do it this way.  Who
4263                * knows.  In earlier versions of the PIC patches, the
4264                * pcrel_adjust field was used to store the correction, but
4265                * since the expression is not pcrel, I felt it would be
4266                * confusing to do it this way.  */
4267
4268               if ((reloc_type == BFD_RELOC_32
4269                    || reloc_type == BFD_RELOC_X86_64_32S
4270                    || reloc_type == BFD_RELOC_64)
4271                   && GOT_symbol
4272                   && GOT_symbol == i.op[n].imms->X_add_symbol
4273                   && (i.op[n].imms->X_op == O_symbol
4274                       || (i.op[n].imms->X_op == O_add
4275                           && ((symbol_get_value_expression
4276                                (i.op[n].imms->X_op_symbol)->X_op)
4277                               == O_subtract))))
4278                 {
4279                   offsetT add;
4280
4281                   if (insn_start_frag == frag_now)
4282                     add = (p - frag_now->fr_literal) - insn_start_off;
4283                   else
4284                     {
4285                       fragS *fr;
4286
4287                       add = insn_start_frag->fr_fix - insn_start_off;
4288                       for (fr = insn_start_frag->fr_next;
4289                            fr && fr != frag_now; fr = fr->fr_next)
4290                         add += fr->fr_fix;
4291                       add += p - frag_now->fr_literal;
4292                     }
4293
4294                   if (!object_64bit)
4295                     reloc_type = BFD_RELOC_386_GOTPC;
4296                   else if (size == 4)
4297                     reloc_type = BFD_RELOC_X86_64_GOTPC32;
4298                   else if (size == 8)
4299                     reloc_type = BFD_RELOC_X86_64_GOTPC64;
4300                   i.op[n].imms->X_add_number += add;
4301                 }
4302               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
4303                            i.op[n].imms, 0, reloc_type);
4304             }
4305         }
4306     }
4307 }
4308 \f
4309 /* x86_cons_fix_new is called via the expression parsing code when a
4310    reloc is needed.  We use this hook to get the correct .got reloc.  */
4311 static enum bfd_reloc_code_real got_reloc = NO_RELOC;
4312 static int cons_sign = -1;
4313
4314 void
4315 x86_cons_fix_new (fragS *frag,
4316                   unsigned int off,
4317                   unsigned int len,
4318                   expressionS *exp)
4319 {
4320   enum bfd_reloc_code_real r = reloc (len, 0, cons_sign, got_reloc);
4321
4322   got_reloc = NO_RELOC;
4323
4324 #ifdef TE_PE
4325   if (exp->X_op == O_secrel)
4326     {
4327       exp->X_op = O_symbol;
4328       r = BFD_RELOC_32_SECREL;
4329     }
4330 #endif
4331
4332   fix_new_exp (frag, off, len, exp, 0, r);
4333 }
4334
4335 #if (!defined (OBJ_ELF) && !defined (OBJ_MAYBE_ELF)) || defined (LEX_AT)
4336 # define lex_got(reloc, adjust, types) NULL
4337 #else
4338 /* Parse operands of the form
4339    <symbol>@GOTOFF+<nnn>
4340    and similar .plt or .got references.
4341
4342    If we find one, set up the correct relocation in RELOC and copy the
4343    input string, minus the `@GOTOFF' into a malloc'd buffer for
4344    parsing by the calling routine.  Return this buffer, and if ADJUST
4345    is non-null set it to the length of the string we removed from the
4346    input line.  Otherwise return NULL.  */
4347 static char *
4348 lex_got (enum bfd_reloc_code_real *reloc,
4349          int *adjust,
4350          unsigned int *types)
4351 {
4352   /* Some of the relocations depend on the size of what field is to
4353      be relocated.  But in our callers i386_immediate and i386_displacement
4354      we don't yet know the operand size (this will be set by insn
4355      matching).  Hence we record the word32 relocation here,
4356      and adjust the reloc according to the real size in reloc().  */
4357   static const struct {
4358     const char *str;
4359     const enum bfd_reloc_code_real rel[2];
4360     const unsigned int types64;
4361   } gotrel[] = {
4362     { "PLTOFF",   { 0,                        BFD_RELOC_X86_64_PLTOFF64 }, Imm64 },
4363     { "PLT",      { BFD_RELOC_386_PLT32,      BFD_RELOC_X86_64_PLT32    }, Imm32|Imm32S|Disp32 },
4364     { "GOTPLT",   { 0,                        BFD_RELOC_X86_64_GOTPLT64 }, Imm64|Disp64 },
4365     { "GOTOFF",   { BFD_RELOC_386_GOTOFF,     BFD_RELOC_X86_64_GOTOFF64 }, Imm64|Disp64 },
4366     { "GOTPCREL", { 0,                        BFD_RELOC_X86_64_GOTPCREL }, Imm32|Imm32S|Disp32 },
4367     { "TLSGD",    { BFD_RELOC_386_TLS_GD,     BFD_RELOC_X86_64_TLSGD    }, Imm32|Imm32S|Disp32 },
4368     { "TLSLDM",   { BFD_RELOC_386_TLS_LDM,    0                         }, 0 },
4369     { "TLSLD",    { 0,                        BFD_RELOC_X86_64_TLSLD    }, Imm32|Imm32S|Disp32 },
4370     { "GOTTPOFF", { BFD_RELOC_386_TLS_IE_32,  BFD_RELOC_X86_64_GOTTPOFF }, Imm32|Imm32S|Disp32 },
4371     { "TPOFF",    { BFD_RELOC_386_TLS_LE_32,  BFD_RELOC_X86_64_TPOFF32  }, Imm32|Imm32S|Imm64|Disp32|Disp64 },
4372     { "NTPOFF",   { BFD_RELOC_386_TLS_LE,     0                         }, 0 },
4373     { "DTPOFF",   { BFD_RELOC_386_TLS_LDO_32, BFD_RELOC_X86_64_DTPOFF32 }, Imm32|Imm32S|Imm64|Disp32|Disp64 },
4374     { "GOTNTPOFF",{ BFD_RELOC_386_TLS_GOTIE,  0                         }, 0 },
4375     { "INDNTPOFF",{ BFD_RELOC_386_TLS_IE,     0                         }, 0 },
4376     { "GOT",      { BFD_RELOC_386_GOT32,      BFD_RELOC_X86_64_GOT32    }, Imm32|Imm32S|Disp32|Imm64 },
4377     { "TLSDESC",  { BFD_RELOC_386_TLS_GOTDESC, BFD_RELOC_X86_64_GOTPC32_TLSDESC }, Imm32|Imm32S|Disp32 },
4378     { "TLSCALL",  { BFD_RELOC_386_TLS_DESC_CALL, BFD_RELOC_X86_64_TLSDESC_CALL }, Imm32|Imm32S|Disp32 }
4379   };
4380   char *cp;
4381   unsigned int j;
4382
4383   if (!IS_ELF)
4384     return NULL;
4385
4386   for (cp = input_line_pointer; *cp != '@'; cp++)
4387     if (is_end_of_line[(unsigned char) *cp])
4388       return NULL;
4389
4390   for (j = 0; j < sizeof (gotrel) / sizeof (gotrel[0]); j++)
4391     {
4392       int len;
4393
4394       len = strlen (gotrel[j].str);
4395       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
4396         {
4397           if (gotrel[j].rel[object_64bit] != 0)
4398             {
4399               int first, second;
4400               char *tmpbuf, *past_reloc;
4401
4402               *reloc = gotrel[j].rel[object_64bit];
4403               if (adjust)
4404                 *adjust = len;
4405
4406               if (types)
4407                 {
4408                   if (flag_code != CODE_64BIT)
4409                     *types = Imm32|Disp32;
4410                   else
4411                     *types = gotrel[j].types64;
4412                 }
4413
4414               if (GOT_symbol == NULL)
4415                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
4416
4417               /* Replace the relocation token with ' ', so that
4418                  errors like foo@GOTOFF1 will be detected.  */
4419
4420               /* The length of the first part of our input line.  */
4421               first = cp - input_line_pointer;
4422
4423               /* The second part goes from after the reloc token until
4424                  (and including) an end_of_line char.  Don't use strlen
4425                  here as the end_of_line char may not be a NUL.  */
4426               past_reloc = cp + 1 + len;
4427               for (cp = past_reloc; !is_end_of_line[(unsigned char) *cp++]; )
4428                 ;
4429               second = cp - past_reloc;
4430
4431               /* Allocate and copy string.  The trailing NUL shouldn't
4432                  be necessary, but be safe.  */
4433               tmpbuf = xmalloc (first + second + 2);
4434               memcpy (tmpbuf, input_line_pointer, first);
4435               tmpbuf[first] = ' ';
4436               memcpy (tmpbuf + first + 1, past_reloc, second);
4437               tmpbuf[first + second + 1] = '\0';
4438               return tmpbuf;
4439             }
4440
4441           as_bad (_("@%s reloc is not supported with %d-bit output format"),
4442                   gotrel[j].str, 1 << (5 + object_64bit));
4443           return NULL;
4444         }
4445     }
4446
4447   /* Might be a symbol version string.  Don't as_bad here.  */
4448   return NULL;
4449 }
4450
4451 void
4452 x86_cons (exp, size)
4453      expressionS *exp;
4454      int size;
4455 {
4456   if (size == 4 || (object_64bit && size == 8))
4457     {
4458       /* Handle @GOTOFF and the like in an expression.  */
4459       char *save;
4460       char *gotfree_input_line;
4461       int adjust;
4462
4463       save = input_line_pointer;
4464       gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
4465       if (gotfree_input_line)
4466         input_line_pointer = gotfree_input_line;
4467
4468       expression (exp);
4469
4470       if (gotfree_input_line)
4471         {
4472           /* expression () has merrily parsed up to the end of line,
4473              or a comma - in the wrong buffer.  Transfer how far
4474              input_line_pointer has moved to the right buffer.  */
4475           input_line_pointer = (save
4476                                 + (input_line_pointer - gotfree_input_line)
4477                                 + adjust);
4478           free (gotfree_input_line);
4479         }
4480     }
4481   else
4482     expression (exp);
4483 }
4484 #endif
4485
4486 static void signed_cons (int size)
4487 {
4488   if (flag_code == CODE_64BIT)
4489     cons_sign = 1;
4490   cons (size);
4491   cons_sign = -1;
4492 }
4493
4494 #ifdef TE_PE
4495 static void
4496 pe_directive_secrel (dummy)
4497      int dummy ATTRIBUTE_UNUSED;
4498 {
4499   expressionS exp;
4500
4501   do
4502     {
4503       expression (&exp);
4504       if (exp.X_op == O_symbol)
4505         exp.X_op = O_secrel;
4506
4507       emit_expr (&exp, 4);
4508     }
4509   while (*input_line_pointer++ == ',');
4510
4511   input_line_pointer--;
4512   demand_empty_rest_of_line ();
4513 }
4514 #endif
4515
4516 static int
4517 i386_immediate (char *imm_start)
4518 {
4519   char *save_input_line_pointer;
4520   char *gotfree_input_line;
4521   segT exp_seg = 0;
4522   expressionS *exp;
4523   unsigned int types = ~0U;
4524
4525   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
4526     {
4527       as_bad (_("at most %d immediate operands are allowed"),
4528               MAX_IMMEDIATE_OPERANDS);
4529       return 0;
4530     }
4531
4532   exp = &im_expressions[i.imm_operands++];
4533   i.op[this_operand].imms = exp;
4534
4535   if (is_space_char (*imm_start))
4536     ++imm_start;
4537
4538   save_input_line_pointer = input_line_pointer;
4539   input_line_pointer = imm_start;
4540
4541   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
4542   if (gotfree_input_line)
4543     input_line_pointer = gotfree_input_line;
4544
4545   exp_seg = expression (exp);
4546
4547   SKIP_WHITESPACE ();
4548   if (*input_line_pointer)
4549     as_bad (_("junk `%s' after expression"), input_line_pointer);
4550
4551   input_line_pointer = save_input_line_pointer;
4552   if (gotfree_input_line)
4553     free (gotfree_input_line);
4554
4555   if (exp->X_op == O_absent || exp->X_op == O_big)
4556     {
4557       /* Missing or bad expr becomes absolute 0.  */
4558       as_bad (_("missing or invalid immediate expression `%s' taken as 0"),
4559               imm_start);
4560       exp->X_op = O_constant;
4561       exp->X_add_number = 0;
4562       exp->X_add_symbol = (symbolS *) 0;
4563       exp->X_op_symbol = (symbolS *) 0;
4564     }
4565   else if (exp->X_op == O_constant)
4566     {
4567       /* Size it properly later.  */
4568       i.types[this_operand] |= Imm64;
4569       /* If BFD64, sign extend val.  */
4570       if (!use_rela_relocations)
4571         if ((exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
4572           exp->X_add_number = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
4573     }
4574 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
4575   else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
4576            && exp_seg != absolute_section
4577            && exp_seg != text_section
4578            && exp_seg != data_section
4579            && exp_seg != bss_section
4580            && exp_seg != undefined_section
4581            && !bfd_is_com_section (exp_seg))
4582     {
4583       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
4584       return 0;
4585     }
4586 #endif
4587   else if (!intel_syntax && exp->X_op == O_register)
4588     {
4589       as_bad (_("illegal immediate register operand %s"), imm_start);
4590       return 0;
4591     }
4592   else
4593     {
4594       /* This is an address.  The size of the address will be
4595          determined later, depending on destination register,
4596          suffix, or the default for the section.  */
4597       i.types[this_operand] |= Imm8 | Imm16 | Imm32 | Imm32S | Imm64;
4598       i.types[this_operand] &= types;
4599     }
4600
4601   return 1;
4602 }
4603
4604 static char *i386_scale PARAMS ((char *));
4605
4606 static char *
4607 i386_scale (scale)
4608      char *scale;
4609 {
4610   offsetT val;
4611   char *save = input_line_pointer;
4612
4613   input_line_pointer = scale;
4614   val = get_absolute_expression ();
4615
4616   switch (val)
4617     {
4618     case 1:
4619       i.log2_scale_factor = 0;
4620       break;
4621     case 2:
4622       i.log2_scale_factor = 1;
4623       break;
4624     case 4:
4625       i.log2_scale_factor = 2;
4626       break;
4627     case 8:
4628       i.log2_scale_factor = 3;
4629       break;
4630     default:
4631       {
4632         char sep = *input_line_pointer;
4633
4634         *input_line_pointer = '\0';
4635         as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
4636                 scale);
4637         *input_line_pointer = sep;
4638         input_line_pointer = save;
4639         return NULL;
4640       }
4641     }
4642   if (i.log2_scale_factor != 0 && i.index_reg == 0)
4643     {
4644       as_warn (_("scale factor of %d without an index register"),
4645                1 << i.log2_scale_factor);
4646 #if SCALE1_WHEN_NO_INDEX
4647       i.log2_scale_factor = 0;
4648 #endif
4649     }
4650   scale = input_line_pointer;
4651   input_line_pointer = save;
4652   return scale;
4653 }
4654
4655 static int i386_displacement PARAMS ((char *, char *));
4656
4657 static int
4658 i386_displacement (disp_start, disp_end)
4659      char *disp_start;
4660      char *disp_end;
4661 {
4662   expressionS *exp;
4663   segT exp_seg = 0;
4664   char *save_input_line_pointer;
4665   char *gotfree_input_line;
4666   int bigdisp, override;
4667   unsigned int types = Disp;
4668
4669   if (i.disp_operands == MAX_MEMORY_OPERANDS)
4670     {
4671       as_bad (_("at most %d displacement operands are allowed"),
4672               MAX_MEMORY_OPERANDS);
4673       return 0;
4674     }
4675
4676   if ((i.types[this_operand] & JumpAbsolute)
4677       || !(current_templates->start->opcode_modifier & (Jump | JumpDword)))
4678     {
4679       bigdisp = Disp32;
4680       override = (i.prefix[ADDR_PREFIX] != 0);
4681     }
4682   else
4683     {
4684       /* For PC-relative branches, the width of the displacement
4685          is dependent upon data size, not address size.  */
4686       bigdisp = 0;
4687       override = (i.prefix[DATA_PREFIX] != 0);
4688     }
4689   if (flag_code == CODE_64BIT)
4690     {
4691       if (!bigdisp)
4692         bigdisp = ((override || i.suffix == WORD_MNEM_SUFFIX)
4693                    ? Disp16
4694                    : Disp32S | Disp32);
4695       else if (!override)
4696         bigdisp = Disp64 | Disp32S | Disp32;
4697     }
4698   else
4699     {
4700       if (!bigdisp)
4701         {
4702           if (!override)
4703             override = (i.suffix == (flag_code != CODE_16BIT
4704                                      ? WORD_MNEM_SUFFIX
4705                                      : LONG_MNEM_SUFFIX));
4706           bigdisp = Disp32;
4707         }
4708       if ((flag_code == CODE_16BIT) ^ override)
4709         bigdisp = Disp16;
4710     }
4711   i.types[this_operand] |= bigdisp;
4712
4713   exp = &disp_expressions[i.disp_operands];
4714   i.op[this_operand].disps = exp;
4715   i.disp_operands++;
4716   save_input_line_pointer = input_line_pointer;
4717   input_line_pointer = disp_start;
4718   END_STRING_AND_SAVE (disp_end);
4719
4720 #ifndef GCC_ASM_O_HACK
4721 #define GCC_ASM_O_HACK 0
4722 #endif
4723 #if GCC_ASM_O_HACK
4724   END_STRING_AND_SAVE (disp_end + 1);
4725   if ((i.types[this_operand] & BaseIndex) != 0
4726       && displacement_string_end[-1] == '+')
4727     {
4728       /* This hack is to avoid a warning when using the "o"
4729          constraint within gcc asm statements.
4730          For instance:
4731
4732          #define _set_tssldt_desc(n,addr,limit,type) \
4733          __asm__ __volatile__ ( \
4734          "movw %w2,%0\n\t" \
4735          "movw %w1,2+%0\n\t" \
4736          "rorl $16,%1\n\t" \
4737          "movb %b1,4+%0\n\t" \
4738          "movb %4,5+%0\n\t" \
4739          "movb $0,6+%0\n\t" \
4740          "movb %h1,7+%0\n\t" \
4741          "rorl $16,%1" \
4742          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
4743
4744          This works great except that the output assembler ends
4745          up looking a bit weird if it turns out that there is
4746          no offset.  You end up producing code that looks like:
4747
4748          #APP
4749          movw $235,(%eax)
4750          movw %dx,2+(%eax)
4751          rorl $16,%edx
4752          movb %dl,4+(%eax)
4753          movb $137,5+(%eax)
4754          movb $0,6+(%eax)
4755          movb %dh,7+(%eax)
4756          rorl $16,%edx
4757          #NO_APP
4758
4759          So here we provide the missing zero.  */
4760
4761       *displacement_string_end = '0';
4762     }
4763 #endif
4764   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
4765   if (gotfree_input_line)
4766     input_line_pointer = gotfree_input_line;
4767
4768   exp_seg = expression (exp);
4769
4770   SKIP_WHITESPACE ();
4771   if (*input_line_pointer)
4772     as_bad (_("junk `%s' after expression"), input_line_pointer);
4773 #if GCC_ASM_O_HACK
4774   RESTORE_END_STRING (disp_end + 1);
4775 #endif
4776   RESTORE_END_STRING (disp_end);
4777   input_line_pointer = save_input_line_pointer;
4778   if (gotfree_input_line)
4779     free (gotfree_input_line);
4780
4781   /* We do this to make sure that the section symbol is in
4782      the symbol table.  We will ultimately change the relocation
4783      to be relative to the beginning of the section.  */
4784   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
4785       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
4786       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
4787     {
4788       if (exp->X_op != O_symbol)
4789         {
4790           as_bad (_("bad expression used with @%s"),
4791                   (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
4792                    ? "GOTPCREL"
4793                    : "GOTOFF"));
4794           return 0;
4795         }
4796
4797       if (S_IS_LOCAL (exp->X_add_symbol)
4798           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section)
4799         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
4800       exp->X_op = O_subtract;
4801       exp->X_op_symbol = GOT_symbol;
4802       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
4803         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
4804       else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
4805         i.reloc[this_operand] = BFD_RELOC_64;
4806       else
4807         i.reloc[this_operand] = BFD_RELOC_32;
4808     }
4809
4810   if (exp->X_op == O_absent || exp->X_op == O_big)
4811     {
4812       /* Missing or bad expr becomes absolute 0.  */
4813       as_bad (_("missing or invalid displacement expression `%s' taken as 0"),
4814               disp_start);
4815       exp->X_op = O_constant;
4816       exp->X_add_number = 0;
4817       exp->X_add_symbol = (symbolS *) 0;
4818       exp->X_op_symbol = (symbolS *) 0;
4819     }
4820
4821 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
4822   if (exp->X_op != O_constant
4823       && OUTPUT_FLAVOR == bfd_target_aout_flavour
4824       && exp_seg != absolute_section
4825       && exp_seg != text_section
4826       && exp_seg != data_section
4827       && exp_seg != bss_section
4828       && exp_seg != undefined_section
4829       && !bfd_is_com_section (exp_seg))
4830     {
4831       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
4832       return 0;
4833     }
4834 #endif
4835
4836   if (!(i.types[this_operand] & ~Disp))
4837     i.types[this_operand] &= types;
4838
4839   return 1;
4840 }
4841
4842 static int i386_index_check PARAMS ((const char *));
4843
4844 /* Make sure the memory operand we've been dealt is valid.
4845    Return 1 on success, 0 on a failure.  */
4846
4847 static int
4848 i386_index_check (operand_string)
4849      const char *operand_string;
4850 {
4851   int ok;
4852 #if INFER_ADDR_PREFIX
4853   int fudged = 0;
4854
4855  tryprefix:
4856 #endif
4857   ok = 1;
4858   if ((current_templates->start->cpu_flags & CpuSVME)
4859       && current_templates->end[-1].operand_types[0] == AnyMem)
4860     {
4861       /* Memory operands of SVME insns are special in that they only allow
4862          rAX as their memory address and ignore any segment override.  */
4863       unsigned RegXX;
4864
4865       /* SKINIT is even more restrictive: it always requires EAX.  */
4866       if (strcmp (current_templates->start->name, "skinit") == 0)
4867         RegXX = Reg32;
4868       else if (flag_code == CODE_64BIT)
4869         RegXX = i.prefix[ADDR_PREFIX] == 0 ? Reg64 : Reg32;
4870       else
4871         RegXX = ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0)
4872                  ? Reg16
4873                  : Reg32);
4874       if (!i.base_reg
4875           || !(i.base_reg->reg_type & Acc)
4876           || !(i.base_reg->reg_type & RegXX)
4877           || i.index_reg
4878           || (i.types[0] & Disp))
4879         ok = 0;
4880     }
4881   else if (flag_code == CODE_64BIT)
4882     {
4883       unsigned RegXX = (i.prefix[ADDR_PREFIX] == 0 ? Reg64 : Reg32);
4884
4885       if ((i.base_reg
4886            && ((i.base_reg->reg_type & RegXX) == 0)
4887            && (i.base_reg->reg_type != BaseIndex
4888                || i.index_reg))
4889           || (i.index_reg
4890               && ((i.index_reg->reg_type & (RegXX | BaseIndex))
4891                   != (RegXX | BaseIndex))))
4892         ok = 0;
4893     }
4894   else
4895     {
4896       if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0))
4897         {
4898           /* 16bit checks.  */
4899           if ((i.base_reg
4900                && ((i.base_reg->reg_type & (Reg16 | BaseIndex | RegRex))
4901                    != (Reg16 | BaseIndex)))
4902               || (i.index_reg
4903                   && (((i.index_reg->reg_type & (Reg16 | BaseIndex))
4904                        != (Reg16 | BaseIndex))
4905                       || !(i.base_reg
4906                            && i.base_reg->reg_num < 6
4907                            && i.index_reg->reg_num >= 6
4908                            && i.log2_scale_factor == 0))))
4909             ok = 0;
4910         }
4911       else
4912         {
4913           /* 32bit checks.  */
4914           if ((i.base_reg
4915                && (i.base_reg->reg_type & (Reg32 | RegRex)) != Reg32)
4916               || (i.index_reg
4917                   && ((i.index_reg->reg_type & (Reg32 | BaseIndex | RegRex))
4918                       != (Reg32 | BaseIndex))))
4919             ok = 0;
4920         }
4921     }
4922   if (!ok)
4923     {
4924 #if INFER_ADDR_PREFIX
4925       if (i.prefix[ADDR_PREFIX] == 0)
4926         {
4927           i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
4928           i.prefixes += 1;
4929           /* Change the size of any displacement too.  At most one of
4930              Disp16 or Disp32 is set.
4931              FIXME.  There doesn't seem to be any real need for separate
4932              Disp16 and Disp32 flags.  The same goes for Imm16 and Imm32.
4933              Removing them would probably clean up the code quite a lot.  */
4934           if (flag_code != CODE_64BIT && (i.types[this_operand] & (Disp16 | Disp32)))
4935             i.types[this_operand] ^= (Disp16 | Disp32);
4936           fudged = 1;
4937           goto tryprefix;
4938         }
4939       if (fudged)
4940         as_bad (_("`%s' is not a valid base/index expression"),
4941                 operand_string);
4942       else
4943 #endif
4944         as_bad (_("`%s' is not a valid %s bit base/index expression"),
4945                 operand_string,
4946                 flag_code_names[flag_code]);
4947     }
4948   return ok;
4949 }
4950
4951 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns non-zero
4952    on error.  */
4953
4954 static int
4955 i386_operand (operand_string)
4956      char *operand_string;
4957 {
4958   const reg_entry *r;
4959   char *end_op;
4960   char *op_string = operand_string;
4961
4962   if (is_space_char (*op_string))
4963     ++op_string;
4964
4965   /* We check for an absolute prefix (differentiating,
4966      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
4967   if (*op_string == ABSOLUTE_PREFIX)
4968     {
4969       ++op_string;
4970       if (is_space_char (*op_string))
4971         ++op_string;
4972       i.types[this_operand] |= JumpAbsolute;
4973     }
4974
4975   /* Check if operand is a register.  */
4976   if ((r = parse_register (op_string, &end_op)) != NULL)
4977     {
4978       /* Check for a segment override by searching for ':' after a
4979          segment register.  */
4980       op_string = end_op;
4981       if (is_space_char (*op_string))
4982         ++op_string;
4983       if (*op_string == ':' && (r->reg_type & (SReg2 | SReg3)))
4984         {
4985           switch (r->reg_num)
4986             {
4987             case 0:
4988               i.seg[i.mem_operands] = &es;
4989               break;
4990             case 1:
4991               i.seg[i.mem_operands] = &cs;
4992               break;
4993             case 2:
4994               i.seg[i.mem_operands] = &ss;
4995               break;
4996             case 3:
4997               i.seg[i.mem_operands] = &ds;
4998               break;
4999             case 4:
5000               i.seg[i.mem_operands] = &fs;
5001               break;
5002             case 5:
5003               i.seg[i.mem_operands] = &gs;
5004               break;
5005             }
5006
5007           /* Skip the ':' and whitespace.  */
5008           ++op_string;
5009           if (is_space_char (*op_string))
5010             ++op_string;
5011
5012           if (!is_digit_char (*op_string)
5013               && !is_identifier_char (*op_string)
5014               && *op_string != '('
5015               && *op_string != ABSOLUTE_PREFIX)
5016             {
5017               as_bad (_("bad memory operand `%s'"), op_string);
5018               return 0;
5019             }
5020           /* Handle case of %es:*foo.  */
5021           if (*op_string == ABSOLUTE_PREFIX)
5022             {
5023               ++op_string;
5024               if (is_space_char (*op_string))
5025                 ++op_string;
5026               i.types[this_operand] |= JumpAbsolute;
5027             }
5028           goto do_memory_reference;
5029         }
5030       if (*op_string)
5031         {
5032           as_bad (_("junk `%s' after register"), op_string);
5033           return 0;
5034         }
5035       i.types[this_operand] |= r->reg_type & ~BaseIndex;
5036       i.op[this_operand].regs = r;
5037       i.reg_operands++;
5038     }
5039   else if (*op_string == REGISTER_PREFIX)
5040     {
5041       as_bad (_("bad register name `%s'"), op_string);
5042       return 0;
5043     }
5044   else if (*op_string == IMMEDIATE_PREFIX)
5045     {
5046       ++op_string;
5047       if (i.types[this_operand] & JumpAbsolute)
5048         {
5049           as_bad (_("immediate operand illegal with absolute jump"));
5050           return 0;
5051         }
5052       if (!i386_immediate (op_string))
5053         return 0;
5054     }
5055   else if (is_digit_char (*op_string)
5056            || is_identifier_char (*op_string)
5057            || *op_string == '(')
5058     {
5059       /* This is a memory reference of some sort.  */
5060       char *base_string;
5061
5062       /* Start and end of displacement string expression (if found).  */
5063       char *displacement_string_start;
5064       char *displacement_string_end;
5065
5066     do_memory_reference:
5067       if ((i.mem_operands == 1
5068            && (current_templates->start->opcode_modifier & IsString) == 0)
5069           || i.mem_operands == 2)
5070         {
5071           as_bad (_("too many memory references for `%s'"),
5072                   current_templates->start->name);
5073           return 0;
5074         }
5075
5076       /* Check for base index form.  We detect the base index form by
5077          looking for an ')' at the end of the operand, searching
5078          for the '(' matching it, and finding a REGISTER_PREFIX or ','
5079          after the '('.  */
5080       base_string = op_string + strlen (op_string);
5081
5082       --base_string;
5083       if (is_space_char (*base_string))
5084         --base_string;
5085
5086       /* If we only have a displacement, set-up for it to be parsed later.  */
5087       displacement_string_start = op_string;
5088       displacement_string_end = base_string + 1;
5089
5090       if (*base_string == ')')
5091         {
5092           char *temp_string;
5093           unsigned int parens_balanced = 1;
5094           /* We've already checked that the number of left & right ()'s are
5095              equal, so this loop will not be infinite.  */
5096           do
5097             {
5098               base_string--;
5099               if (*base_string == ')')
5100                 parens_balanced++;
5101               if (*base_string == '(')
5102                 parens_balanced--;
5103             }
5104           while (parens_balanced);
5105
5106           temp_string = base_string;
5107
5108           /* Skip past '(' and whitespace.  */
5109           ++base_string;
5110           if (is_space_char (*base_string))
5111             ++base_string;
5112
5113           if (*base_string == ','
5114               || ((i.base_reg = parse_register (base_string, &end_op)) != NULL))
5115             {
5116               displacement_string_end = temp_string;
5117
5118               i.types[this_operand] |= BaseIndex;
5119
5120               if (i.base_reg)
5121                 {
5122                   base_string = end_op;
5123                   if (is_space_char (*base_string))
5124                     ++base_string;
5125                 }
5126
5127               /* There may be an index reg or scale factor here.  */
5128               if (*base_string == ',')
5129                 {
5130                   ++base_string;
5131                   if (is_space_char (*base_string))
5132                     ++base_string;
5133
5134                   if ((i.index_reg = parse_register (base_string, &end_op)) != NULL)
5135                     {
5136                       base_string = end_op;
5137                       if (is_space_char (*base_string))
5138                         ++base_string;
5139                       if (*base_string == ',')
5140                         {
5141                           ++base_string;
5142                           if (is_space_char (*base_string))
5143                             ++base_string;
5144                         }
5145                       else if (*base_string != ')')
5146                         {
5147                           as_bad (_("expecting `,' or `)' after index register in `%s'"),
5148                                   operand_string);
5149                           return 0;
5150                         }
5151                     }
5152                   else if (*base_string == REGISTER_PREFIX)
5153                     {
5154                       as_bad (_("bad register name `%s'"), base_string);
5155                       return 0;
5156                     }
5157
5158                   /* Check for scale factor.  */
5159                   if (*base_string != ')')
5160                     {
5161                       char *end_scale = i386_scale (base_string);
5162
5163                       if (!end_scale)
5164                         return 0;
5165
5166                       base_string = end_scale;
5167                       if (is_space_char (*base_string))
5168                         ++base_string;
5169                       if (*base_string != ')')
5170                         {
5171                           as_bad (_("expecting `)' after scale factor in `%s'"),
5172                                   operand_string);
5173                           return 0;
5174                         }
5175                     }
5176                   else if (!i.index_reg)
5177                     {
5178                       as_bad (_("expecting index register or scale factor after `,'; got '%c'"),
5179                               *base_string);
5180                       return 0;
5181                     }
5182                 }
5183               else if (*base_string != ')')
5184                 {
5185                   as_bad (_("expecting `,' or `)' after base register in `%s'"),
5186                           operand_string);
5187                   return 0;
5188                 }
5189             }
5190           else if (*base_string == REGISTER_PREFIX)
5191             {
5192               as_bad (_("bad register name `%s'"), base_string);
5193               return 0;
5194             }
5195         }
5196
5197       /* If there's an expression beginning the operand, parse it,
5198          assuming displacement_string_start and
5199          displacement_string_end are meaningful.  */
5200       if (displacement_string_start != displacement_string_end)
5201         {
5202           if (!i386_displacement (displacement_string_start,
5203                                   displacement_string_end))
5204             return 0;
5205         }
5206
5207       /* Special case for (%dx) while doing input/output op.  */
5208       if (i.base_reg
5209           && i.base_reg->reg_type == (Reg16 | InOutPortReg)
5210           && i.index_reg == 0
5211           && i.log2_scale_factor == 0
5212           && i.seg[i.mem_operands] == 0
5213           && (i.types[this_operand] & Disp) == 0)
5214         {
5215           i.types[this_operand] = InOutPortReg;
5216           return 1;
5217         }
5218
5219       if (i386_index_check (operand_string) == 0)
5220         return 0;
5221       i.mem_operands++;
5222     }
5223   else
5224     {
5225       /* It's not a memory operand; argh!  */
5226       as_bad (_("invalid char %s beginning operand %d `%s'"),
5227               output_invalid (*op_string),
5228               this_operand + 1,
5229               op_string);
5230       return 0;
5231     }
5232   return 1;                     /* Normal return.  */
5233 }
5234 \f
5235 /* md_estimate_size_before_relax()
5236
5237    Called just before relax() for rs_machine_dependent frags.  The x86
5238    assembler uses these frags to handle variable size jump
5239    instructions.
5240
5241    Any symbol that is now undefined will not become defined.
5242    Return the correct fr_subtype in the frag.
5243    Return the initial "guess for variable size of frag" to caller.
5244    The guess is actually the growth beyond the fixed part.  Whatever
5245    we do to grow the fixed or variable part contributes to our
5246    returned value.  */
5247
5248 int
5249 md_estimate_size_before_relax (fragP, segment)
5250      fragS *fragP;
5251      segT segment;
5252 {
5253   /* We've already got fragP->fr_subtype right;  all we have to do is
5254      check for un-relaxable symbols.  On an ELF system, we can't relax
5255      an externally visible symbol, because it may be overridden by a
5256      shared library.  */
5257   if (S_GET_SEGMENT (fragP->fr_symbol) != segment
5258 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
5259       || (IS_ELF
5260           && (S_IS_EXTERNAL (fragP->fr_symbol)
5261               || S_IS_WEAK (fragP->fr_symbol)))
5262 #endif
5263       )
5264     {
5265       /* Symbol is undefined in this segment, or we need to keep a
5266          reloc so that weak symbols can be overridden.  */
5267       int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
5268       enum bfd_reloc_code_real reloc_type;
5269       unsigned char *opcode;
5270       int old_fr_fix;
5271
5272       if (fragP->fr_var != NO_RELOC)
5273         reloc_type = fragP->fr_var;
5274       else if (size == 2)
5275         reloc_type = BFD_RELOC_16_PCREL;
5276       else
5277         reloc_type = BFD_RELOC_32_PCREL;
5278
5279       old_fr_fix = fragP->fr_fix;
5280       opcode = (unsigned char *) fragP->fr_opcode;
5281
5282       switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
5283         {
5284         case UNCOND_JUMP:
5285           /* Make jmp (0xeb) a (d)word displacement jump.  */
5286           opcode[0] = 0xe9;
5287           fragP->fr_fix += size;
5288           fix_new (fragP, old_fr_fix, size,
5289                    fragP->fr_symbol,
5290                    fragP->fr_offset, 1,
5291                    reloc_type);
5292           break;
5293
5294         case COND_JUMP86:
5295           if (size == 2
5296               && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
5297             {
5298               /* Negate the condition, and branch past an
5299                  unconditional jump.  */
5300               opcode[0] ^= 1;
5301               opcode[1] = 3;
5302               /* Insert an unconditional jump.  */
5303               opcode[2] = 0xe9;
5304               /* We added two extra opcode bytes, and have a two byte
5305                  offset.  */
5306               fragP->fr_fix += 2 + 2;
5307               fix_new (fragP, old_fr_fix + 2, 2,
5308                        fragP->fr_symbol,
5309                        fragP->fr_offset, 1,
5310                        reloc_type);
5311               break;
5312             }
5313           /* Fall through.  */
5314
5315         case COND_JUMP:
5316           if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
5317             {
5318               fixS *fixP;
5319
5320               fragP->fr_fix += 1;
5321               fixP = fix_new (fragP, old_fr_fix, 1,
5322                               fragP->fr_symbol,
5323                               fragP->fr_offset, 1,
5324                               BFD_RELOC_8_PCREL);
5325               fixP->fx_signed = 1;
5326               break;
5327             }
5328
5329           /* This changes the byte-displacement jump 0x7N
5330              to the (d)word-displacement jump 0x0f,0x8N.  */
5331           opcode[1] = opcode[0] + 0x10;
5332           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
5333           /* We've added an opcode byte.  */
5334           fragP->fr_fix += 1 + size;
5335           fix_new (fragP, old_fr_fix + 1, size,
5336                    fragP->fr_symbol,
5337                    fragP->fr_offset, 1,
5338                    reloc_type);
5339           break;
5340
5341         default:
5342           BAD_CASE (fragP->fr_subtype);
5343           break;
5344         }
5345       frag_wane (fragP);
5346       return fragP->fr_fix - old_fr_fix;
5347     }
5348
5349   /* Guess size depending on current relax state.  Initially the relax
5350      state will correspond to a short jump and we return 1, because
5351      the variable part of the frag (the branch offset) is one byte
5352      long.  However, we can relax a section more than once and in that
5353      case we must either set fr_subtype back to the unrelaxed state,
5354      or return the value for the appropriate branch.  */
5355   return md_relax_table[fragP->fr_subtype].rlx_length;
5356 }
5357
5358 /* Called after relax() is finished.
5359
5360    In:  Address of frag.
5361         fr_type == rs_machine_dependent.
5362         fr_subtype is what the address relaxed to.
5363
5364    Out: Any fixSs and constants are set up.
5365         Caller will turn frag into a ".space 0".  */
5366
5367 void
5368 md_convert_frag (abfd, sec, fragP)
5369      bfd *abfd ATTRIBUTE_UNUSED;
5370      segT sec ATTRIBUTE_UNUSED;
5371      fragS *fragP;
5372 {
5373   unsigned char *opcode;
5374   unsigned char *where_to_put_displacement = NULL;
5375   offsetT target_address;
5376   offsetT opcode_address;
5377   unsigned int extension = 0;
5378   offsetT displacement_from_opcode_start;
5379
5380   opcode = (unsigned char *) fragP->fr_opcode;
5381
5382   /* Address we want to reach in file space.  */
5383   target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
5384
5385   /* Address opcode resides at in file space.  */
5386   opcode_address = fragP->fr_address + fragP->fr_fix;
5387
5388   /* Displacement from opcode start to fill into instruction.  */
5389   displacement_from_opcode_start = target_address - opcode_address;
5390
5391   if ((fragP->fr_subtype & BIG) == 0)
5392     {
5393       /* Don't have to change opcode.  */
5394       extension = 1;            /* 1 opcode + 1 displacement  */
5395       where_to_put_displacement = &opcode[1];
5396     }
5397   else
5398     {
5399       if (no_cond_jump_promotion
5400           && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
5401         as_warn_where (fragP->fr_file, fragP->fr_line, _("long jump required"));
5402
5403       switch (fragP->fr_subtype)
5404         {
5405         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
5406           extension = 4;                /* 1 opcode + 4 displacement  */
5407           opcode[0] = 0xe9;
5408           where_to_put_displacement = &opcode[1];
5409           break;
5410
5411         case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
5412           extension = 2;                /* 1 opcode + 2 displacement  */
5413           opcode[0] = 0xe9;
5414           where_to_put_displacement = &opcode[1];
5415           break;
5416
5417         case ENCODE_RELAX_STATE (COND_JUMP, BIG):
5418         case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
5419           extension = 5;                /* 2 opcode + 4 displacement  */
5420           opcode[1] = opcode[0] + 0x10;
5421           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
5422           where_to_put_displacement = &opcode[2];
5423           break;
5424
5425         case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
5426           extension = 3;                /* 2 opcode + 2 displacement  */
5427           opcode[1] = opcode[0] + 0x10;
5428           opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
5429           where_to_put_displacement = &opcode[2];
5430           break;
5431
5432         case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
5433           extension = 4;
5434           opcode[0] ^= 1;
5435           opcode[1] = 3;
5436           opcode[2] = 0xe9;
5437           where_to_put_displacement = &opcode[3];
5438           break;
5439
5440         default:
5441           BAD_CASE (fragP->fr_subtype);
5442           break;
5443         }
5444     }
5445
5446   /* If size if less then four we are sure that the operand fits,
5447      but if it's 4, then it could be that the displacement is larger
5448      then -/+ 2GB.  */
5449   if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
5450       && object_64bit
5451       && ((addressT) (displacement_from_opcode_start - extension
5452                       + ((addressT) 1 << 31))
5453           > (((addressT) 2 << 31) - 1)))
5454     {
5455       as_bad_where (fragP->fr_file, fragP->fr_line,
5456                     _("jump target out of range"));
5457       /* Make us emit 0.  */
5458       displacement_from_opcode_start = extension;
5459     }
5460   /* Now put displacement after opcode.  */
5461   md_number_to_chars ((char *) where_to_put_displacement,
5462                       (valueT) (displacement_from_opcode_start - extension),
5463                       DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
5464   fragP->fr_fix += extension;
5465 }
5466 \f
5467 /* Size of byte displacement jmp.  */
5468 int md_short_jump_size = 2;
5469
5470 /* Size of dword displacement jmp.  */
5471 int md_long_jump_size = 5;
5472
5473 void
5474 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
5475      char *ptr;
5476      addressT from_addr, to_addr;
5477      fragS *frag ATTRIBUTE_UNUSED;
5478      symbolS *to_symbol ATTRIBUTE_UNUSED;
5479 {
5480   offsetT offset;
5481
5482   offset = to_addr - (from_addr + 2);
5483   /* Opcode for byte-disp jump.  */
5484   md_number_to_chars (ptr, (valueT) 0xeb, 1);
5485   md_number_to_chars (ptr + 1, (valueT) offset, 1);
5486 }
5487
5488 void
5489 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
5490      char *ptr;
5491      addressT from_addr, to_addr;
5492      fragS *frag ATTRIBUTE_UNUSED;
5493      symbolS *to_symbol ATTRIBUTE_UNUSED;
5494 {
5495   offsetT offset;
5496
5497   offset = to_addr - (from_addr + 5);
5498   md_number_to_chars (ptr, (valueT) 0xe9, 1);
5499   md_number_to_chars (ptr + 1, (valueT) offset, 4);
5500 }
5501 \f
5502 /* Apply a fixup (fixS) to segment data, once it has been determined
5503    by our caller that we have all the info we need to fix it up.
5504
5505    On the 386, immediates, displacements, and data pointers are all in
5506    the same (little-endian) format, so we don't need to care about which
5507    we are handling.  */
5508
5509 void
5510 md_apply_fix (fixP, valP, seg)
5511      /* The fix we're to put in.  */
5512      fixS *fixP;
5513      /* Pointer to the value of the bits.  */
5514      valueT *valP;
5515      /* Segment fix is from.  */
5516      segT seg ATTRIBUTE_UNUSED;
5517 {
5518   char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
5519   valueT value = *valP;
5520
5521 #if !defined (TE_Mach)
5522   if (fixP->fx_pcrel)
5523     {
5524       switch (fixP->fx_r_type)
5525         {
5526         default:
5527           break;
5528
5529         case BFD_RELOC_64:
5530           fixP->fx_r_type = BFD_RELOC_64_PCREL;
5531           break;
5532         case BFD_RELOC_32:
5533         case BFD_RELOC_X86_64_32S:
5534           fixP->fx_r_type = BFD_RELOC_32_PCREL;
5535           break;
5536         case BFD_RELOC_16:
5537           fixP->fx_r_type = BFD_RELOC_16_PCREL;
5538           break;
5539         case BFD_RELOC_8:
5540           fixP->fx_r_type = BFD_RELOC_8_PCREL;
5541           break;
5542         }
5543     }
5544
5545   if (fixP->fx_addsy != NULL
5546       && (fixP->fx_r_type == BFD_RELOC_32_PCREL
5547           || fixP->fx_r_type == BFD_RELOC_64_PCREL
5548           || fixP->fx_r_type == BFD_RELOC_16_PCREL
5549           || fixP->fx_r_type == BFD_RELOC_8_PCREL)
5550       && !use_rela_relocations)
5551     {
5552       /* This is a hack.  There should be a better way to handle this.
5553          This covers for the fact that bfd_install_relocation will
5554          subtract the current location (for partial_inplace, PC relative
5555          relocations); see more below.  */
5556 #ifndef OBJ_AOUT
5557       if (IS_ELF
5558 #ifdef TE_PE
5559           || OUTPUT_FLAVOR == bfd_target_coff_flavour
5560 #endif
5561           )
5562         value += fixP->fx_where + fixP->fx_frag->fr_address;
5563 #endif
5564 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
5565       if (IS_ELF)
5566         {
5567           segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
5568
5569           if ((sym_seg == seg
5570                || (symbol_section_p (fixP->fx_addsy)
5571                    && sym_seg != absolute_section))
5572               && !generic_force_reloc (fixP))
5573             {
5574               /* Yes, we add the values in twice.  This is because
5575                  bfd_install_relocation subtracts them out again.  I think
5576                  bfd_install_relocation is broken, but I don't dare change
5577                  it.  FIXME.  */
5578               value += fixP->fx_where + fixP->fx_frag->fr_address;
5579             }
5580         }
5581 #endif
5582 #if defined (OBJ_COFF) && defined (TE_PE)
5583       /* For some reason, the PE format does not store a
5584          section address offset for a PC relative symbol.  */
5585       if (S_GET_SEGMENT (fixP->fx_addsy) != seg
5586           || S_IS_WEAK (fixP->fx_addsy))
5587         value += md_pcrel_from (fixP);
5588 #endif
5589     }
5590
5591   /* Fix a few things - the dynamic linker expects certain values here,
5592      and we must not disappoint it.  */
5593 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
5594   if (IS_ELF && fixP->fx_addsy)
5595     switch (fixP->fx_r_type)
5596       {
5597       case BFD_RELOC_386_PLT32:
5598       case BFD_RELOC_X86_64_PLT32:
5599         /* Make the jump instruction point to the address of the operand.  At
5600            runtime we merely add the offset to the actual PLT entry.  */
5601         value = -4;
5602         break;
5603
5604       case BFD_RELOC_386_TLS_GD:
5605       case BFD_RELOC_386_TLS_LDM:
5606       case BFD_RELOC_386_TLS_IE_32:
5607       case BFD_RELOC_386_TLS_IE:
5608       case BFD_RELOC_386_TLS_GOTIE:
5609       case BFD_RELOC_386_TLS_GOTDESC:
5610       case BFD_RELOC_X86_64_TLSGD:
5611       case BFD_RELOC_X86_64_TLSLD:
5612       case BFD_RELOC_X86_64_GOTTPOFF:
5613       case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
5614         value = 0; /* Fully resolved at runtime.  No addend.  */
5615         /* Fallthrough */
5616       case BFD_RELOC_386_TLS_LE:
5617       case BFD_RELOC_386_TLS_LDO_32:
5618       case BFD_RELOC_386_TLS_LE_32:
5619       case BFD_RELOC_X86_64_DTPOFF32:
5620       case BFD_RELOC_X86_64_DTPOFF64:
5621       case BFD_RELOC_X86_64_TPOFF32:
5622       case BFD_RELOC_X86_64_TPOFF64:
5623         S_SET_THREAD_LOCAL (fixP->fx_addsy);
5624         break;
5625
5626       case BFD_RELOC_386_TLS_DESC_CALL:
5627       case BFD_RELOC_X86_64_TLSDESC_CALL:
5628         value = 0; /* Fully resolved at runtime.  No addend.  */
5629         S_SET_THREAD_LOCAL (fixP->fx_addsy);
5630         fixP->fx_done = 0;
5631         return;
5632
5633       case BFD_RELOC_386_GOT32:
5634       case BFD_RELOC_X86_64_GOT32:
5635         value = 0; /* Fully resolved at runtime.  No addend.  */
5636         break;
5637
5638       case BFD_RELOC_VTABLE_INHERIT:
5639       case BFD_RELOC_VTABLE_ENTRY:
5640         fixP->fx_done = 0;
5641         return;
5642
5643       default:
5644         break;
5645       }
5646 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)  */
5647   *valP = value;
5648 #endif /* !defined (TE_Mach)  */
5649
5650   /* Are we finished with this relocation now?  */
5651   if (fixP->fx_addsy == NULL)
5652     fixP->fx_done = 1;
5653   else if (use_rela_relocations)
5654     {
5655       fixP->fx_no_overflow = 1;
5656       /* Remember value for tc_gen_reloc.  */
5657       fixP->fx_addnumber = value;
5658       value = 0;
5659     }
5660
5661   md_number_to_chars (p, value, fixP->fx_size);
5662 }
5663 \f
5664 #define MAX_LITTLENUMS 6
5665
5666 /* Turn the string pointed to by litP into a floating point constant
5667    of type TYPE, and emit the appropriate bytes.  The number of
5668    LITTLENUMS emitted is stored in *SIZEP.  An error message is
5669    returned, or NULL on OK.  */
5670
5671 char *
5672 md_atof (type, litP, sizeP)
5673      int type;
5674      char *litP;
5675      int *sizeP;
5676 {
5677   int prec;
5678   LITTLENUM_TYPE words[MAX_LITTLENUMS];
5679   LITTLENUM_TYPE *wordP;
5680   char *t;
5681
5682   switch (type)
5683     {
5684     case 'f':
5685     case 'F':
5686       prec = 2;
5687       break;
5688
5689     case 'd':
5690     case 'D':
5691       prec = 4;
5692       break;
5693
5694     case 'x':
5695     case 'X':
5696       prec = 5;
5697       break;
5698
5699     default:
5700       *sizeP = 0;
5701       return _("Bad call to md_atof ()");
5702     }
5703   t = atof_ieee (input_line_pointer, type, words);
5704   if (t)
5705     input_line_pointer = t;
5706
5707   *sizeP = prec * sizeof (LITTLENUM_TYPE);
5708   /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
5709      the bigendian 386.  */
5710   for (wordP = words + prec - 1; prec--;)
5711     {
5712       md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
5713       litP += sizeof (LITTLENUM_TYPE);
5714     }
5715   return 0;
5716 }
5717 \f
5718 static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
5719
5720 static char *
5721 output_invalid (c)
5722      int c;
5723 {
5724   if (ISPRINT (c))
5725     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
5726               "'%c'", c);
5727   else
5728     snprintf (output_invalid_buf, sizeof (output_invalid_buf),
5729               "(0x%x)", (unsigned char) c);
5730   return output_invalid_buf;
5731 }
5732
5733 /* REG_STRING starts *before* REGISTER_PREFIX.  */
5734
5735 static const reg_entry *
5736 parse_real_register (char *reg_string, char **end_op)
5737 {
5738   char *s = reg_string;
5739   char *p;
5740   char reg_name_given[MAX_REG_NAME_SIZE + 1];
5741   const reg_entry *r;
5742
5743   /* Skip possible REGISTER_PREFIX and possible whitespace.  */
5744   if (*s == REGISTER_PREFIX)
5745     ++s;
5746
5747   if (is_space_char (*s))
5748     ++s;
5749
5750   p = reg_name_given;
5751   while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
5752     {
5753       if (p >= reg_name_given + MAX_REG_NAME_SIZE)
5754         return (const reg_entry *) NULL;
5755       s++;
5756     }
5757
5758   /* For naked regs, make sure that we are not dealing with an identifier.
5759      This prevents confusing an identifier like `eax_var' with register
5760      `eax'.  */
5761   if (allow_naked_reg && identifier_chars[(unsigned char) *s])
5762     return (const reg_entry *) NULL;
5763
5764   *end_op = s;
5765
5766   r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
5767
5768   /* Handle floating point regs, allowing spaces in the (i) part.  */
5769   if (r == i386_regtab /* %st is first entry of table  */)
5770     {
5771       if (is_space_char (*s))
5772         ++s;
5773       if (*s == '(')
5774         {
5775           ++s;
5776           if (is_space_char (*s))
5777             ++s;
5778           if (*s >= '0' && *s <= '7')
5779             {
5780               r = &i386_float_regtab[*s - '0'];
5781               ++s;
5782               if (is_space_char (*s))
5783                 ++s;
5784               if (*s == ')')
5785                 {
5786                   *end_op = s + 1;
5787                   return r;
5788                 }
5789             }
5790           /* We have "%st(" then garbage.  */
5791           return (const reg_entry *) NULL;
5792         }
5793     }
5794
5795   if (r != NULL
5796       && ((r->reg_flags & (RegRex64 | RegRex)) | (r->reg_type & Reg64)) != 0
5797       && (r->reg_type != Control || !(cpu_arch_flags & CpuSledgehammer))
5798       && flag_code != CODE_64BIT)
5799     return (const reg_entry *) NULL;
5800
5801   return r;
5802 }
5803
5804 /* REG_STRING starts *before* REGISTER_PREFIX.  */
5805
5806 static const reg_entry *
5807 parse_register (char *reg_string, char **end_op)
5808 {
5809   const reg_entry *r;
5810
5811   if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
5812     r = parse_real_register (reg_string, end_op);
5813   else
5814     r = NULL;
5815   if (!r)
5816     {
5817       char *save = input_line_pointer;
5818       char c;
5819       symbolS *symbolP;
5820
5821       input_line_pointer = reg_string;
5822       c = get_symbol_end ();
5823       symbolP = symbol_find (reg_string);
5824       if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
5825         {
5826           const expressionS *e = symbol_get_value_expression (symbolP);
5827
5828           know (e->X_op == O_register);
5829           know (e->X_add_number >= 0 && (valueT) e->X_add_number < ARRAY_SIZE (i386_regtab));
5830           r = i386_regtab + e->X_add_number;
5831           *end_op = input_line_pointer;
5832         }
5833       *input_line_pointer = c;
5834       input_line_pointer = save;
5835     }
5836   return r;
5837 }
5838
5839 int
5840 i386_parse_name (char *name, expressionS *e, char *nextcharP)
5841 {
5842   const reg_entry *r;
5843   char *end = input_line_pointer;
5844
5845   *end = *nextcharP;
5846   r = parse_register (name, &input_line_pointer);
5847   if (r && end <= input_line_pointer)
5848     {
5849       *nextcharP = *input_line_pointer;
5850       *input_line_pointer = 0;
5851       e->X_op = O_register;
5852       e->X_add_number = r - i386_regtab;
5853       return 1;
5854     }
5855   input_line_pointer = end;
5856   *end = 0;
5857   return 0;
5858 }
5859
5860 void
5861 md_operand (expressionS *e)
5862 {
5863   if (*input_line_pointer == REGISTER_PREFIX)
5864     {
5865       char *end;
5866       const reg_entry *r = parse_real_register (input_line_pointer, &end);
5867
5868       if (r)
5869         {
5870           e->X_op = O_register;
5871           e->X_add_number = r - i386_regtab;
5872           input_line_pointer = end;
5873         }
5874     }
5875 }
5876
5877 \f
5878 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
5879 const char *md_shortopts = "kVQ:sqn";
5880 #else
5881 const char *md_shortopts = "qn";
5882 #endif
5883
5884 #define OPTION_32 (OPTION_MD_BASE + 0)
5885 #define OPTION_64 (OPTION_MD_BASE + 1)
5886 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
5887 #define OPTION_MARCH (OPTION_MD_BASE + 3)
5888 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
5889
5890 struct option md_longopts[] =
5891 {
5892   {"32", no_argument, NULL, OPTION_32},
5893 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined(TE_PEP)
5894   {"64", no_argument, NULL, OPTION_64},
5895 #endif
5896   {"divide", no_argument, NULL, OPTION_DIVIDE},
5897   {"march", required_argument, NULL, OPTION_MARCH},
5898   {"mtune", required_argument, NULL, OPTION_MTUNE},
5899   {NULL, no_argument, NULL, 0}
5900 };
5901 size_t md_longopts_size = sizeof (md_longopts);
5902
5903 int
5904 md_parse_option (int c, char *arg)
5905 {
5906   unsigned int i;
5907
5908   switch (c)
5909     {
5910     case 'n':
5911       optimize_align_code = 0;
5912       break;
5913
5914     case 'q':
5915       quiet_warnings = 1;
5916       break;
5917
5918 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
5919       /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
5920          should be emitted or not.  FIXME: Not implemented.  */
5921     case 'Q':
5922       break;
5923
5924       /* -V: SVR4 argument to print version ID.  */
5925     case 'V':
5926       print_version_id ();
5927       break;
5928
5929       /* -k: Ignore for FreeBSD compatibility.  */
5930     case 'k':
5931       break;
5932
5933     case 's':
5934       /* -s: On i386 Solaris, this tells the native assembler to use
5935          .stab instead of .stab.excl.  We always use .stab anyhow.  */
5936       break;
5937 #endif
5938 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined(TE_PEP)
5939     case OPTION_64:
5940       {
5941         const char **list, **l;
5942
5943         list = bfd_target_list ();
5944         for (l = list; *l != NULL; l++)
5945           if (CONST_STRNEQ (*l, "elf64-x86-64")
5946               || strcmp (*l, "coff-x86-64") == 0
5947               || strcmp (*l, "pe-x86-64") == 0
5948               || strcmp (*l, "pei-x86-64") == 0)
5949             {
5950               default_arch = "x86_64";
5951               break;
5952             }
5953         if (*l == NULL)
5954           as_fatal (_("No compiled in support for x86_64"));
5955         free (list);
5956       }
5957       break;
5958 #endif
5959
5960     case OPTION_32:
5961       default_arch = "i386";
5962       break;
5963
5964     case OPTION_DIVIDE:
5965 #ifdef SVR4_COMMENT_CHARS
5966       {
5967         char *n, *t;
5968         const char *s;
5969
5970         n = (char *) xmalloc (strlen (i386_comment_chars) + 1);
5971         t = n;
5972         for (s = i386_comment_chars; *s != '\0'; s++)
5973           if (*s != '/')
5974             *t++ = *s;
5975         *t = '\0';
5976         i386_comment_chars = n;
5977       }
5978 #endif
5979       break;
5980
5981     case OPTION_MARCH:
5982       if (*arg == '.')
5983         as_fatal (_("Invalid -march= option: `%s'"), arg);
5984       for (i = 0; i < ARRAY_SIZE (cpu_arch); i++)
5985         {
5986           if (strcmp (arg, cpu_arch [i].name) == 0)
5987             {
5988               cpu_arch_isa = cpu_arch[i].type;
5989               cpu_arch_isa_flags = cpu_arch[i].flags;
5990               if (!cpu_arch_tune_set)
5991                 {
5992                   cpu_arch_tune = cpu_arch_isa;
5993                   cpu_arch_tune_flags = cpu_arch_isa_flags;
5994                 }
5995               break;
5996             }
5997         }
5998       if (i >= ARRAY_SIZE (cpu_arch))
5999         as_fatal (_("Invalid -march= option: `%s'"), arg);
6000       break;
6001
6002     case OPTION_MTUNE:
6003       if (*arg == '.')
6004         as_fatal (_("Invalid -mtune= option: `%s'"), arg);
6005       for (i = 0; i < ARRAY_SIZE (cpu_arch); i++)
6006         {
6007           if (strcmp (arg, cpu_arch [i].name) == 0)
6008             {
6009               cpu_arch_tune_set = 1;
6010               cpu_arch_tune = cpu_arch [i].type;
6011               cpu_arch_tune_flags = cpu_arch[i].flags;
6012               break;
6013             }
6014         }
6015       if (i >= ARRAY_SIZE (cpu_arch))
6016         as_fatal (_("Invalid -mtune= option: `%s'"), arg);
6017       break;
6018
6019     default:
6020       return 0;
6021     }
6022   return 1;
6023 }
6024
6025 void
6026 md_show_usage (stream)
6027      FILE *stream;
6028 {
6029 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
6030   fprintf (stream, _("\
6031   -Q                      ignored\n\
6032   -V                      print assembler version number\n\
6033   -k                      ignored\n"));
6034 #endif
6035   fprintf (stream, _("\
6036   -n                      Do not optimize code alignment\n\
6037   -q                      quieten some warnings\n"));
6038 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
6039   fprintf (stream, _("\
6040   -s                      ignored\n"));
6041 #endif
6042 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined(TE_PEP)
6043   fprintf (stream, _("\
6044   --32/--64               generate 32bit/64bit code\n"));
6045 #endif
6046 #ifdef SVR4_COMMENT_CHARS
6047   fprintf (stream, _("\
6048   --divide                do not treat `/' as a comment character\n"));
6049 #else
6050   fprintf (stream, _("\
6051   --divide                ignored\n"));
6052 #endif
6053   fprintf (stream, _("\
6054   -march=CPU/-mtune=CPU   generate code/optimize for CPU, where CPU is one of:\n\
6055                            i386, i486, pentium, pentiumpro, pentium4, nocona,\n\
6056                            core, core2, k6, athlon, k8, generic32, generic64\n"));
6057
6058 }
6059
6060 #if defined(TE_PEP)
6061 const char *
6062 x86_64_target_format (void)
6063 {
6064   if (strcmp (default_arch, "x86_64") == 0)
6065     {
6066       set_code_flag (CODE_64BIT);
6067       return COFF_TARGET_FORMAT;
6068     }
6069   else if (strcmp (default_arch, "i386") == 0)
6070     {
6071       set_code_flag (CODE_32BIT);
6072       return "coff-i386";
6073     }
6074
6075   as_fatal (_("Unknown architecture"));
6076   return NULL;
6077 }
6078 #endif
6079
6080 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
6081      || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))
6082
6083 /* Pick the target format to use.  */
6084
6085 const char *
6086 i386_target_format ()
6087 {
6088   if (!strcmp (default_arch, "x86_64"))
6089     {
6090       set_code_flag (CODE_64BIT);
6091       if (cpu_arch_isa_flags == 0)
6092         cpu_arch_isa_flags = Cpu186|Cpu286|Cpu386|Cpu486
6093                              |Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2
6094                              |CpuSSE|CpuSSE2;
6095       if (cpu_arch_tune_flags == 0)
6096         cpu_arch_tune_flags = Cpu186|Cpu286|Cpu386|Cpu486
6097                               |Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2
6098                               |CpuSSE|CpuSSE2;
6099     }
6100   else if (!strcmp (default_arch, "i386"))
6101     {
6102       set_code_flag (CODE_32BIT);
6103       if (cpu_arch_isa_flags == 0)
6104         cpu_arch_isa_flags = Cpu186|Cpu286|Cpu386;
6105       if (cpu_arch_tune_flags == 0)
6106         cpu_arch_tune_flags = Cpu186|Cpu286|Cpu386;
6107     }
6108   else
6109     as_fatal (_("Unknown architecture"));
6110   switch (OUTPUT_FLAVOR)
6111     {
6112 #ifdef OBJ_MAYBE_AOUT
6113     case bfd_target_aout_flavour:
6114       return AOUT_TARGET_FORMAT;
6115 #endif
6116 #ifdef OBJ_MAYBE_COFF
6117     case bfd_target_coff_flavour:
6118       return "coff-i386";
6119 #endif
6120 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
6121     case bfd_target_elf_flavour:
6122       {
6123         if (flag_code == CODE_64BIT)
6124           {
6125             object_64bit = 1;
6126             use_rela_relocations = 1;
6127           }
6128         return flag_code == CODE_64BIT ? ELF_TARGET_FORMAT64 : ELF_TARGET_FORMAT;
6129       }
6130 #endif
6131     default:
6132       abort ();
6133       return NULL;
6134     }
6135 }
6136
6137 #endif /* OBJ_MAYBE_ more than one  */
6138
6139 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))
6140 void i386_elf_emit_arch_note ()
6141 {
6142   if (IS_ELF && cpu_arch_name != NULL)
6143     {
6144       char *p;
6145       asection *seg = now_seg;
6146       subsegT subseg = now_subseg;
6147       Elf_Internal_Note i_note;
6148       Elf_External_Note e_note;
6149       asection *note_secp;
6150       int len;
6151
6152       /* Create the .note section.  */
6153       note_secp = subseg_new (".note", 0);
6154       bfd_set_section_flags (stdoutput,
6155                              note_secp,
6156                              SEC_HAS_CONTENTS | SEC_READONLY);
6157
6158       /* Process the arch string.  */
6159       len = strlen (cpu_arch_name);
6160
6161       i_note.namesz = len + 1;
6162       i_note.descsz = 0;
6163       i_note.type = NT_ARCH;
6164       p = frag_more (sizeof (e_note.namesz));
6165       md_number_to_chars (p, (valueT) i_note.namesz, sizeof (e_note.namesz));
6166       p = frag_more (sizeof (e_note.descsz));
6167       md_number_to_chars (p, (valueT) i_note.descsz, sizeof (e_note.descsz));
6168       p = frag_more (sizeof (e_note.type));
6169       md_number_to_chars (p, (valueT) i_note.type, sizeof (e_note.type));
6170       p = frag_more (len + 1);
6171       strcpy (p, cpu_arch_name);
6172
6173       frag_align (2, 0, 0);
6174
6175       subseg_set (seg, subseg);
6176     }
6177 }
6178 #endif
6179 \f
6180 symbolS *
6181 md_undefined_symbol (name)
6182      char *name;
6183 {
6184   if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
6185       && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
6186       && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
6187       && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
6188     {
6189       if (!GOT_symbol)
6190         {
6191           if (symbol_find (name))
6192             as_bad (_("GOT already in symbol table"));
6193           GOT_symbol = symbol_new (name, undefined_section,
6194                                    (valueT) 0, &zero_address_frag);
6195         };
6196       return GOT_symbol;
6197     }
6198   return 0;
6199 }
6200
6201 /* Round up a section size to the appropriate boundary.  */
6202
6203 valueT
6204 md_section_align (segment, size)
6205      segT segment ATTRIBUTE_UNUSED;
6206      valueT size;
6207 {
6208 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
6209   if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
6210     {
6211       /* For a.out, force the section size to be aligned.  If we don't do
6212          this, BFD will align it for us, but it will not write out the
6213          final bytes of the section.  This may be a bug in BFD, but it is
6214          easier to fix it here since that is how the other a.out targets
6215          work.  */
6216       int align;
6217
6218       align = bfd_get_section_alignment (stdoutput, segment);
6219       size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
6220     }
6221 #endif
6222
6223   return size;
6224 }
6225
6226 /* On the i386, PC-relative offsets are relative to the start of the
6227    next instruction.  That is, the address of the offset, plus its
6228    size, since the offset is always the last part of the insn.  */
6229
6230 long
6231 md_pcrel_from (fixP)
6232      fixS *fixP;
6233 {
6234   return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
6235 }
6236
6237 #ifndef I386COFF
6238
6239 static void
6240 s_bss (ignore)
6241      int ignore ATTRIBUTE_UNUSED;
6242 {
6243   int temp;
6244
6245 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
6246   if (IS_ELF)
6247     obj_elf_section_change_hook ();
6248 #endif
6249   temp = get_absolute_expression ();
6250   subseg_set (bss_section, (subsegT) temp);
6251   demand_empty_rest_of_line ();
6252 }
6253
6254 #endif
6255
6256 void
6257 i386_validate_fix (fixp)
6258      fixS *fixp;
6259 {
6260   if (fixp->fx_subsy && fixp->fx_subsy == GOT_symbol)
6261     {
6262       if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
6263         {
6264           if (!object_64bit)
6265             abort ();
6266           fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
6267         }
6268       else
6269         {
6270           if (!object_64bit)
6271             fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
6272           else
6273             fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
6274         }
6275       fixp->fx_subsy = 0;
6276     }
6277 }
6278
6279 arelent *
6280 tc_gen_reloc (section, fixp)
6281      asection *section ATTRIBUTE_UNUSED;
6282      fixS *fixp;
6283 {
6284   arelent *rel;
6285   bfd_reloc_code_real_type code;
6286
6287   switch (fixp->fx_r_type)
6288     {
6289     case BFD_RELOC_X86_64_PLT32:
6290     case BFD_RELOC_X86_64_GOT32:
6291     case BFD_RELOC_X86_64_GOTPCREL:
6292     case BFD_RELOC_386_PLT32:
6293     case BFD_RELOC_386_GOT32:
6294     case BFD_RELOC_386_GOTOFF:
6295     case BFD_RELOC_386_GOTPC:
6296     case BFD_RELOC_386_TLS_GD:
6297     case BFD_RELOC_386_TLS_LDM:
6298     case BFD_RELOC_386_TLS_LDO_32:
6299     case BFD_RELOC_386_TLS_IE_32:
6300     case BFD_RELOC_386_TLS_IE:
6301     case BFD_RELOC_386_TLS_GOTIE:
6302     case BFD_RELOC_386_TLS_LE_32:
6303     case BFD_RELOC_386_TLS_LE:
6304     case BFD_RELOC_386_TLS_GOTDESC:
6305     case BFD_RELOC_386_TLS_DESC_CALL:
6306     case BFD_RELOC_X86_64_TLSGD:
6307     case BFD_RELOC_X86_64_TLSLD:
6308     case BFD_RELOC_X86_64_DTPOFF32:
6309     case BFD_RELOC_X86_64_DTPOFF64:
6310     case BFD_RELOC_X86_64_GOTTPOFF:
6311     case BFD_RELOC_X86_64_TPOFF32:
6312     case BFD_RELOC_X86_64_TPOFF64:
6313     case BFD_RELOC_X86_64_GOTOFF64:
6314     case BFD_RELOC_X86_64_GOTPC32:
6315     case BFD_RELOC_X86_64_GOT64:
6316     case BFD_RELOC_X86_64_GOTPCREL64:
6317     case BFD_RELOC_X86_64_GOTPC64:
6318     case BFD_RELOC_X86_64_GOTPLT64:
6319     case BFD_RELOC_X86_64_PLTOFF64:
6320     case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
6321     case BFD_RELOC_X86_64_TLSDESC_CALL:
6322     case BFD_RELOC_RVA:
6323     case BFD_RELOC_VTABLE_ENTRY:
6324     case BFD_RELOC_VTABLE_INHERIT:
6325 #ifdef TE_PE
6326     case BFD_RELOC_32_SECREL:
6327 #endif
6328       code = fixp->fx_r_type;
6329       break;
6330     case BFD_RELOC_X86_64_32S:
6331       if (!fixp->fx_pcrel)
6332         {
6333           /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32.  */
6334           code = fixp->fx_r_type;
6335           break;
6336         }
6337     default:
6338       if (fixp->fx_pcrel)
6339         {
6340           switch (fixp->fx_size)
6341             {
6342             default:
6343               as_bad_where (fixp->fx_file, fixp->fx_line,
6344                             _("can not do %d byte pc-relative relocation"),
6345                             fixp->fx_size);
6346               code = BFD_RELOC_32_PCREL;
6347               break;
6348             case 1: code = BFD_RELOC_8_PCREL;  break;
6349             case 2: code = BFD_RELOC_16_PCREL; break;
6350             case 4: code = BFD_RELOC_32_PCREL; break;
6351 #ifdef BFD64
6352             case 8: code = BFD_RELOC_64_PCREL; break;
6353 #endif
6354             }
6355         }
6356       else
6357         {
6358           switch (fixp->fx_size)
6359             {
6360             default:
6361               as_bad_where (fixp->fx_file, fixp->fx_line,
6362                             _("can not do %d byte relocation"),
6363                             fixp->fx_size);
6364               code = BFD_RELOC_32;
6365               break;
6366             case 1: code = BFD_RELOC_8;  break;
6367             case 2: code = BFD_RELOC_16; break;
6368             case 4: code = BFD_RELOC_32; break;
6369 #ifdef BFD64
6370             case 8: code = BFD_RELOC_64; break;
6371 #endif
6372             }
6373         }
6374       break;
6375     }
6376
6377   if ((code == BFD_RELOC_32
6378        || code == BFD_RELOC_32_PCREL
6379        || code == BFD_RELOC_X86_64_32S)
6380       && GOT_symbol
6381       && fixp->fx_addsy == GOT_symbol)
6382     {
6383       if (!object_64bit)
6384         code = BFD_RELOC_386_GOTPC;
6385       else
6386         code = BFD_RELOC_X86_64_GOTPC32;
6387     }
6388   if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
6389       && GOT_symbol
6390       && fixp->fx_addsy == GOT_symbol)
6391     {
6392       code = BFD_RELOC_X86_64_GOTPC64;
6393     }
6394
6395   rel = (arelent *) xmalloc (sizeof (arelent));
6396   rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6397   *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6398
6399   rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
6400
6401   if (!use_rela_relocations)
6402     {
6403       /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
6404          vtable entry to be used in the relocation's section offset.  */
6405       if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
6406         rel->address = fixp->fx_offset;
6407
6408       rel->addend = 0;
6409     }
6410   /* Use the rela in 64bit mode.  */
6411   else
6412     {
6413       if (!fixp->fx_pcrel)
6414         rel->addend = fixp->fx_offset;
6415       else
6416         switch (code)
6417           {
6418           case BFD_RELOC_X86_64_PLT32:
6419           case BFD_RELOC_X86_64_GOT32:
6420           case BFD_RELOC_X86_64_GOTPCREL:
6421           case BFD_RELOC_X86_64_TLSGD:
6422           case BFD_RELOC_X86_64_TLSLD:
6423           case BFD_RELOC_X86_64_GOTTPOFF:
6424           case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
6425           case BFD_RELOC_X86_64_TLSDESC_CALL:
6426             rel->addend = fixp->fx_offset - fixp->fx_size;
6427             break;
6428           default:
6429             rel->addend = (section->vma
6430                            - fixp->fx_size
6431                            + fixp->fx_addnumber
6432                            + md_pcrel_from (fixp));
6433             break;
6434           }
6435     }
6436
6437   rel->howto = bfd_reloc_type_lookup (stdoutput, code);
6438   if (rel->howto == NULL)
6439     {
6440       as_bad_where (fixp->fx_file, fixp->fx_line,
6441                     _("cannot represent relocation type %s"),
6442                     bfd_get_reloc_code_name (code));
6443       /* Set howto to a garbage value so that we can keep going.  */
6444       rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
6445       assert (rel->howto != NULL);
6446     }
6447
6448   return rel;
6449 }
6450
6451 \f
6452 /* Parse operands using Intel syntax. This implements a recursive descent
6453    parser based on the BNF grammar published in Appendix B of the MASM 6.1
6454    Programmer's Guide.
6455
6456    FIXME: We do not recognize the full operand grammar defined in the MASM
6457           documentation.  In particular, all the structure/union and
6458           high-level macro operands are missing.
6459
6460    Uppercase words are terminals, lower case words are non-terminals.
6461    Objects surrounded by double brackets '[[' ']]' are optional. Vertical
6462    bars '|' denote choices. Most grammar productions are implemented in
6463    functions called 'intel_<production>'.
6464
6465    Initial production is 'expr'.
6466
6467     addOp               + | -
6468
6469     alpha               [a-zA-Z]
6470
6471     binOp               & | AND | \| | OR | ^ | XOR
6472
6473     byteRegister        AL | AH | BL | BH | CL | CH | DL | DH
6474
6475     constant            digits [[ radixOverride ]]
6476
6477     dataType            BYTE | WORD | DWORD | FWORD | QWORD | TBYTE | OWORD | XMMWORD
6478
6479     digits              decdigit
6480                         | digits decdigit
6481                         | digits hexdigit
6482
6483     decdigit            [0-9]
6484
6485     e04                 e04 addOp e05
6486                         | e05
6487
6488     e05                 e05 binOp e06
6489                         | e06
6490
6491     e06                 e06 mulOp e09
6492                         | e09
6493
6494     e09                 OFFSET e10
6495                         | SHORT e10
6496                         | + e10
6497                         | - e10
6498                         | ~ e10
6499                         | NOT e10
6500                         | e09 PTR e10
6501                         | e09 : e10
6502                         | e10
6503
6504     e10                 e10 [ expr ]
6505                         | e11
6506
6507     e11                 ( expr )
6508                         | [ expr ]
6509                         | constant
6510                         | dataType
6511                         | id
6512                         | $
6513                         | register
6514
6515  => expr                expr cmpOp e04
6516                         | e04
6517
6518     gpRegister          AX | EAX | BX | EBX | CX | ECX | DX | EDX
6519                         | BP | EBP | SP | ESP | DI | EDI | SI | ESI
6520
6521     hexdigit            a | b | c | d | e | f
6522                         | A | B | C | D | E | F
6523
6524     id                  alpha
6525                         | id alpha
6526                         | id decdigit
6527
6528     mulOp               * | / | % | MOD | << | SHL | >> | SHR
6529
6530     quote               " | '
6531
6532     register            specialRegister
6533                         | gpRegister
6534                         | byteRegister
6535
6536     segmentRegister     CS | DS | ES | FS | GS | SS
6537
6538     specialRegister     CR0 | CR2 | CR3 | CR4
6539                         | DR0 | DR1 | DR2 | DR3 | DR6 | DR7
6540                         | TR3 | TR4 | TR5 | TR6 | TR7
6541
6542     We simplify the grammar in obvious places (e.g., register parsing is
6543     done by calling parse_register) and eliminate immediate left recursion
6544     to implement a recursive-descent parser.
6545
6546     expr        e04 expr'
6547
6548     expr'       cmpOp e04 expr'
6549                 | Empty
6550
6551     e04         e05 e04'
6552
6553     e04'        addOp e05 e04'
6554                 | Empty
6555
6556     e05         e06 e05'
6557
6558     e05'        binOp e06 e05'
6559                 | Empty
6560
6561     e06         e09 e06'
6562
6563     e06'        mulOp e09 e06'
6564                 | Empty
6565
6566     e09         OFFSET e10 e09'
6567                 | SHORT e10'
6568                 | + e10'
6569                 | - e10'
6570                 | ~ e10'
6571                 | NOT e10'
6572                 | e10 e09'
6573
6574     e09'        PTR e10 e09'
6575                 | : e10 e09'
6576                 | Empty
6577
6578     e10         e11 e10'
6579
6580     e10'        [ expr ] e10'
6581                 | Empty
6582
6583     e11         ( expr )
6584                 | [ expr ]
6585                 | BYTE
6586                 | WORD
6587                 | DWORD
6588                 | FWORD
6589                 | QWORD
6590                 | TBYTE
6591                 | OWORD
6592                 | XMMWORD
6593                 | .
6594                 | $
6595                 | register
6596                 | id
6597                 | constant  */
6598
6599 /* Parsing structure for the intel syntax parser. Used to implement the
6600    semantic actions for the operand grammar.  */
6601 struct intel_parser_s
6602   {
6603     char *op_string;            /* The string being parsed.  */
6604     int got_a_float;            /* Whether the operand is a float.  */
6605     int op_modifier;            /* Operand modifier.  */
6606     int is_mem;                 /* 1 if operand is memory reference.  */
6607     int in_offset;                      /* >=1 if parsing operand of offset.  */
6608     int in_bracket;                     /* >=1 if parsing operand in brackets.  */
6609     const reg_entry *reg;       /* Last register reference found.  */
6610     char *disp;                 /* Displacement string being built.  */
6611     char *next_operand;         /* Resume point when splitting operands.  */
6612   };
6613
6614 static struct intel_parser_s intel_parser;
6615
6616 /* Token structure for parsing intel syntax.  */
6617 struct intel_token
6618   {
6619     int code;                   /* Token code.  */
6620     const reg_entry *reg;       /* Register entry for register tokens.  */
6621     char *str;                  /* String representation.  */
6622   };
6623
6624 static struct intel_token cur_token, prev_token;
6625
6626 /* Token codes for the intel parser. Since T_SHORT is already used
6627    by COFF, undefine it first to prevent a warning.  */
6628 #define T_NIL           -1
6629 #define T_CONST         1
6630 #define T_REG           2
6631 #define T_BYTE          3
6632 #define T_WORD          4
6633 #define T_DWORD         5
6634 #define T_FWORD         6
6635 #define T_QWORD         7
6636 #define T_TBYTE         8
6637 #define T_XMMWORD       9
6638 #undef  T_SHORT
6639 #define T_SHORT         10
6640 #define T_OFFSET        11
6641 #define T_PTR           12
6642 #define T_ID            13
6643 #define T_SHL           14
6644 #define T_SHR           15
6645
6646 /* Prototypes for intel parser functions.  */
6647 static int intel_match_token    PARAMS ((int code));
6648 static void intel_get_token     PARAMS ((void));
6649 static void intel_putback_token PARAMS ((void));
6650 static int intel_expr           PARAMS ((void));
6651 static int intel_e04            PARAMS ((void));
6652 static int intel_e05            PARAMS ((void));
6653 static int intel_e06            PARAMS ((void));
6654 static int intel_e09            PARAMS ((void));
6655 static int intel_bracket_expr   PARAMS ((void));
6656 static int intel_e10            PARAMS ((void));
6657 static int intel_e11            PARAMS ((void));
6658
6659 static int
6660 i386_intel_operand (operand_string, got_a_float)
6661      char *operand_string;
6662      int got_a_float;
6663 {
6664   int ret;
6665   char *p;
6666
6667   p = intel_parser.op_string = xstrdup (operand_string);
6668   intel_parser.disp = (char *) xmalloc (strlen (operand_string) + 1);
6669
6670   for (;;)
6671     {
6672       /* Initialize token holders.  */
6673       cur_token.code = prev_token.code = T_NIL;
6674       cur_token.reg = prev_token.reg = NULL;
6675       cur_token.str = prev_token.str = NULL;
6676
6677       /* Initialize parser structure.  */
6678       intel_parser.got_a_float = got_a_float;
6679       intel_parser.op_modifier = 0;
6680       intel_parser.is_mem = 0;
6681       intel_parser.in_offset = 0;
6682       intel_parser.in_bracket = 0;
6683       intel_parser.reg = NULL;
6684       intel_parser.disp[0] = '\0';
6685       intel_parser.next_operand = NULL;
6686
6687       /* Read the first token and start the parser.  */
6688       intel_get_token ();
6689       ret = intel_expr ();
6690
6691       if (!ret)
6692         break;
6693
6694       if (cur_token.code != T_NIL)
6695         {
6696           as_bad (_("invalid operand for '%s' ('%s' unexpected)"),
6697                   current_templates->start->name, cur_token.str);
6698           ret = 0;
6699         }
6700       /* If we found a memory reference, hand it over to i386_displacement
6701          to fill in the rest of the operand fields.  */
6702       else if (intel_parser.is_mem)
6703         {
6704           if ((i.mem_operands == 1
6705                && (current_templates->start->opcode_modifier & IsString) == 0)
6706               || i.mem_operands == 2)
6707             {
6708               as_bad (_("too many memory references for '%s'"),
6709                       current_templates->start->name);
6710               ret = 0;
6711             }
6712           else
6713             {
6714               char *s = intel_parser.disp;
6715               i.mem_operands++;
6716
6717               if (!quiet_warnings && intel_parser.is_mem < 0)
6718                 /* See the comments in intel_bracket_expr.  */
6719                 as_warn (_("Treating `%s' as memory reference"), operand_string);
6720
6721               /* Add the displacement expression.  */
6722               if (*s != '\0')
6723                 ret = i386_displacement (s, s + strlen (s));
6724               if (ret)
6725                 {
6726                   /* Swap base and index in 16-bit memory operands like
6727                      [si+bx]. Since i386_index_check is also used in AT&T
6728                      mode we have to do that here.  */
6729                   if (i.base_reg
6730                       && i.index_reg
6731                       && (i.base_reg->reg_type & Reg16)
6732                       && (i.index_reg->reg_type & Reg16)
6733                       && i.base_reg->reg_num >= 6
6734                       && i.index_reg->reg_num < 6)
6735                     {
6736                       const reg_entry *base = i.index_reg;
6737
6738                       i.index_reg = i.base_reg;
6739                       i.base_reg = base;
6740                     }
6741                   ret = i386_index_check (operand_string);
6742                 }
6743             }
6744         }
6745
6746       /* Constant and OFFSET expressions are handled by i386_immediate.  */
6747       else if ((intel_parser.op_modifier & (1 << T_OFFSET))
6748                || intel_parser.reg == NULL)
6749         ret = i386_immediate (intel_parser.disp);
6750
6751       if (intel_parser.next_operand && this_operand >= MAX_OPERANDS - 1)
6752         ret = 0;
6753       if (!ret || !intel_parser.next_operand)
6754         break;
6755       intel_parser.op_string = intel_parser.next_operand;
6756       this_operand = i.operands++;
6757     }
6758
6759   free (p);
6760   free (intel_parser.disp);
6761
6762   return ret;
6763 }
6764
6765 #define NUM_ADDRESS_REGS (!!i.base_reg + !!i.index_reg)
6766
6767 /* expr e04 expr'
6768
6769    expr'  cmpOp e04 expr'
6770         | Empty  */
6771 static int
6772 intel_expr ()
6773 {
6774   /* XXX Implement the comparison operators.  */
6775   return intel_e04 ();
6776 }
6777
6778 /* e04  e05 e04'
6779
6780    e04' addOp e05 e04'
6781         | Empty  */
6782 static int
6783 intel_e04 ()
6784 {
6785   int nregs = -1;
6786
6787   for (;;)
6788     {
6789       if (!intel_e05())
6790         return 0;
6791
6792       if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
6793         i.base_reg = i386_regtab + REGNAM_AL; /* al is invalid as base */
6794
6795       if (cur_token.code == '+')
6796         nregs = -1;
6797       else if (cur_token.code == '-')
6798         nregs = NUM_ADDRESS_REGS;
6799       else
6800         return 1;
6801
6802       strcat (intel_parser.disp, cur_token.str);
6803       intel_match_token (cur_token.code);
6804     }
6805 }
6806
6807 /* e05  e06 e05'
6808
6809    e05' binOp e06 e05'
6810         | Empty  */
6811 static int
6812 intel_e05 ()
6813 {
6814   int nregs = ~NUM_ADDRESS_REGS;
6815
6816   for (;;)
6817     {
6818       if (!intel_e06())
6819         return 0;
6820
6821       if (cur_token.code == '&' || cur_token.code == '|' || cur_token.code == '^')
6822         {
6823           char str[2];
6824
6825           str[0] = cur_token.code;
6826           str[1] = 0;
6827           strcat (intel_parser.disp, str);
6828         }
6829       else
6830         break;
6831
6832       intel_match_token (cur_token.code);
6833
6834       if (nregs < 0)
6835         nregs = ~nregs;
6836     }
6837   if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
6838     i.base_reg = i386_regtab + REGNAM_AL + 1; /* cl is invalid as base */
6839   return 1;
6840 }
6841
6842 /* e06  e09 e06'
6843
6844    e06' mulOp e09 e06'
6845         | Empty  */
6846 static int
6847 intel_e06 ()
6848 {
6849   int nregs = ~NUM_ADDRESS_REGS;
6850
6851   for (;;)
6852     {
6853       if (!intel_e09())
6854         return 0;
6855
6856       if (cur_token.code == '*' || cur_token.code == '/' || cur_token.code == '%')
6857         {
6858           char str[2];
6859
6860           str[0] = cur_token.code;
6861           str[1] = 0;
6862           strcat (intel_parser.disp, str);
6863         }
6864       else if (cur_token.code == T_SHL)
6865         strcat (intel_parser.disp, "<<");
6866       else if (cur_token.code == T_SHR)
6867         strcat (intel_parser.disp, ">>");
6868       else
6869         break;
6870
6871       intel_match_token (cur_token.code);
6872
6873       if (nregs < 0)
6874         nregs = ~nregs;
6875     }
6876   if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
6877     i.base_reg = i386_regtab + REGNAM_AL + 2; /* dl is invalid as base */
6878   return 1;
6879 }
6880
6881 /* e09  OFFSET e09
6882         | SHORT e09
6883         | + e09
6884         | - e09
6885         | ~ e09
6886         | NOT e09
6887         | e10 e09'
6888
6889    e09' PTR e10 e09'
6890         | : e10 e09'
6891         | Empty */
6892 static int
6893 intel_e09 ()
6894 {
6895   int nregs = ~NUM_ADDRESS_REGS;
6896   int in_offset = 0;
6897
6898   for (;;)
6899     {
6900       /* Don't consume constants here.  */
6901       if (cur_token.code == '+' || cur_token.code == '-')
6902         {
6903           /* Need to look one token ahead - if the next token
6904              is a constant, the current token is its sign.  */
6905           int next_code;
6906
6907           intel_match_token (cur_token.code);
6908           next_code = cur_token.code;
6909           intel_putback_token ();
6910           if (next_code == T_CONST)
6911             break;
6912         }
6913
6914       /* e09  OFFSET e09  */
6915       if (cur_token.code == T_OFFSET)
6916         {
6917           if (!in_offset++)
6918             ++intel_parser.in_offset;
6919         }
6920
6921       /* e09  SHORT e09  */
6922       else if (cur_token.code == T_SHORT)
6923         intel_parser.op_modifier |= 1 << T_SHORT;
6924
6925       /* e09  + e09  */
6926       else if (cur_token.code == '+')
6927         strcat (intel_parser.disp, "+");
6928
6929       /* e09  - e09
6930               | ~ e09
6931               | NOT e09  */
6932       else if (cur_token.code == '-' || cur_token.code == '~')
6933         {
6934           char str[2];
6935
6936           if (nregs < 0)
6937             nregs = ~nregs;
6938           str[0] = cur_token.code;
6939           str[1] = 0;
6940           strcat (intel_parser.disp, str);
6941         }
6942
6943       /* e09  e10 e09'  */
6944       else
6945         break;
6946
6947       intel_match_token (cur_token.code);
6948     }
6949
6950   for (;;)
6951     {
6952       if (!intel_e10 ())
6953         return 0;
6954
6955       /* e09'  PTR e10 e09' */
6956       if (cur_token.code == T_PTR)
6957         {
6958           char suffix;
6959
6960           if (prev_token.code == T_BYTE)
6961             suffix = BYTE_MNEM_SUFFIX;
6962
6963           else if (prev_token.code == T_WORD)
6964             {
6965               if (current_templates->start->name[0] == 'l'
6966                   && current_templates->start->name[2] == 's'
6967                   && current_templates->start->name[3] == 0)
6968                 suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */
6969               else if (intel_parser.got_a_float == 2)   /* "fi..." */
6970                 suffix = SHORT_MNEM_SUFFIX;
6971               else
6972                 suffix = WORD_MNEM_SUFFIX;
6973             }
6974
6975           else if (prev_token.code == T_DWORD)
6976             {
6977               if (current_templates->start->name[0] == 'l'
6978                   && current_templates->start->name[2] == 's'
6979                   && current_templates->start->name[3] == 0)
6980                 suffix = WORD_MNEM_SUFFIX;
6981               else if (flag_code == CODE_16BIT
6982                        && (current_templates->start->opcode_modifier
6983                            & (Jump | JumpDword)))
6984                 suffix = LONG_DOUBLE_MNEM_SUFFIX;
6985               else if (intel_parser.got_a_float == 1)   /* "f..." */
6986                 suffix = SHORT_MNEM_SUFFIX;
6987               else
6988                 suffix = LONG_MNEM_SUFFIX;
6989             }
6990
6991           else if (prev_token.code == T_FWORD)
6992             {
6993               if (current_templates->start->name[0] == 'l'
6994                   && current_templates->start->name[2] == 's'
6995                   && current_templates->start->name[3] == 0)
6996                 suffix = LONG_MNEM_SUFFIX;
6997               else if (!intel_parser.got_a_float)
6998                 {
6999                   if (flag_code == CODE_16BIT)
7000                     add_prefix (DATA_PREFIX_OPCODE);
7001                   suffix = LONG_DOUBLE_MNEM_SUFFIX;
7002                 }
7003               else
7004                 suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */
7005             }
7006
7007           else if (prev_token.code == T_QWORD)
7008             {
7009               if (intel_parser.got_a_float == 1)        /* "f..." */
7010                 suffix = LONG_MNEM_SUFFIX;
7011               else
7012                 suffix = QWORD_MNEM_SUFFIX;
7013             }
7014
7015           else if (prev_token.code == T_TBYTE)
7016             {
7017               if (intel_parser.got_a_float == 1)
7018                 suffix = LONG_DOUBLE_MNEM_SUFFIX;
7019               else
7020                 suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */
7021             }
7022
7023           else if (prev_token.code == T_XMMWORD)
7024             {
7025               /* XXX ignored for now, but accepted since gcc uses it */
7026               suffix = 0;
7027             }
7028
7029           else
7030             {
7031               as_bad (_("Unknown operand modifier `%s'"), prev_token.str);
7032               return 0;
7033             }
7034
7035           /* Operands for jump/call using 'ptr' notation denote absolute
7036              addresses.  */
7037           if (current_templates->start->opcode_modifier & (Jump | JumpDword))
7038             i.types[this_operand] |= JumpAbsolute;
7039
7040           if (current_templates->start->base_opcode == 0x8d /* lea */)
7041             ;
7042           else if (!i.suffix)
7043             i.suffix = suffix;
7044           else if (i.suffix != suffix)
7045             {
7046               as_bad (_("Conflicting operand modifiers"));
7047               return 0;
7048             }
7049
7050         }
7051
7052       /* e09'  : e10 e09'  */
7053       else if (cur_token.code == ':')
7054         {
7055           if (prev_token.code != T_REG)
7056             {
7057               /* While {call,jmp} SSSS:OOOO is MASM syntax only when SSSS is a
7058                  segment/group identifier (which we don't have), using comma
7059                  as the operand separator there is even less consistent, since
7060                  there all branches only have a single operand.  */
7061               if (this_operand != 0
7062                   || intel_parser.in_offset
7063                   || intel_parser.in_bracket
7064                   || (!(current_templates->start->opcode_modifier
7065                         & (Jump|JumpDword|JumpInterSegment))
7066                       && !(current_templates->start->operand_types[0]
7067                            & JumpAbsolute)))
7068                 return intel_match_token (T_NIL);
7069               /* Remember the start of the 2nd operand and terminate 1st
7070                  operand here.
7071                  XXX This isn't right, yet (when SSSS:OOOO is right operand of
7072                  another expression), but it gets at least the simplest case
7073                  (a plain number or symbol on the left side) right.  */
7074               intel_parser.next_operand = intel_parser.op_string;
7075               *--intel_parser.op_string = '\0';
7076               return intel_match_token (':');
7077             }
7078         }
7079
7080       /* e09'  Empty  */
7081       else
7082         break;
7083
7084       intel_match_token (cur_token.code);
7085
7086     }
7087
7088   if (in_offset)
7089     {
7090       --intel_parser.in_offset;
7091       if (nregs < 0)
7092         nregs = ~nregs;
7093       if (NUM_ADDRESS_REGS > nregs)
7094         {
7095           as_bad (_("Invalid operand to `OFFSET'"));
7096           return 0;
7097         }
7098       intel_parser.op_modifier |= 1 << T_OFFSET;
7099     }
7100
7101   if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
7102     i.base_reg = i386_regtab + REGNAM_AL + 3; /* bl is invalid as base */
7103   return 1;
7104 }
7105
7106 static int
7107 intel_bracket_expr ()
7108 {
7109   int was_offset = intel_parser.op_modifier & (1 << T_OFFSET);
7110   const char *start = intel_parser.op_string;
7111   int len;
7112
7113   if (i.op[this_operand].regs)
7114     return intel_match_token (T_NIL);
7115
7116   intel_match_token ('[');
7117
7118   /* Mark as a memory operand only if it's not already known to be an
7119      offset expression.  If it's an offset expression, we need to keep
7120      the brace in.  */
7121   if (!intel_parser.in_offset)
7122     {
7123       ++intel_parser.in_bracket;
7124
7125       /* Operands for jump/call inside brackets denote absolute addresses.  */
7126       if (current_templates->start->opcode_modifier & (Jump | JumpDword))
7127         i.types[this_operand] |= JumpAbsolute;
7128
7129       /* Unfortunately gas always diverged from MASM in a respect that can't
7130          be easily fixed without risking to break code sequences likely to be
7131          encountered (the testsuite even check for this): MASM doesn't consider
7132          an expression inside brackets unconditionally as a memory reference.
7133          When that is e.g. a constant, an offset expression, or the sum of the
7134          two, this is still taken as a constant load. gas, however, always
7135          treated these as memory references. As a compromise, we'll try to make
7136          offset expressions inside brackets work the MASM way (since that's
7137          less likely to be found in real world code), but make constants alone
7138          continue to work the traditional gas way. In either case, issue a
7139          warning.  */
7140       intel_parser.op_modifier &= ~was_offset;
7141     }
7142   else
7143     strcat (intel_parser.disp, "[");
7144
7145   /* Add a '+' to the displacement string if necessary.  */
7146   if (*intel_parser.disp != '\0'
7147       && *(intel_parser.disp + strlen (intel_parser.disp) - 1) != '+')
7148     strcat (intel_parser.disp, "+");
7149
7150   if (intel_expr ()
7151       && (len = intel_parser.op_string - start - 1,
7152           intel_match_token (']')))
7153     {
7154       /* Preserve brackets when the operand is an offset expression.  */
7155       if (intel_parser.in_offset)
7156         strcat (intel_parser.disp, "]");
7157       else
7158         {
7159           --intel_parser.in_bracket;
7160           if (i.base_reg || i.index_reg)
7161             intel_parser.is_mem = 1;
7162           if (!intel_parser.is_mem)
7163             {
7164               if (!(intel_parser.op_modifier & (1 << T_OFFSET)))
7165                 /* Defer the warning until all of the operand was parsed.  */
7166                 intel_parser.is_mem = -1;
7167               else if (!quiet_warnings)
7168                 as_warn (_("`[%.*s]' taken to mean just `%.*s'"), len, start, len, start);
7169             }
7170         }
7171       intel_parser.op_modifier |= was_offset;
7172
7173       return 1;
7174     }
7175   return 0;
7176 }
7177
7178 /* e10  e11 e10'
7179
7180    e10' [ expr ] e10'
7181         | Empty  */
7182 static int
7183 intel_e10 ()
7184 {
7185   if (!intel_e11 ())
7186     return 0;
7187
7188   while (cur_token.code == '[')
7189     {
7190       if (!intel_bracket_expr ())
7191         return 0;
7192     }
7193
7194   return 1;
7195 }
7196
7197 /* e11  ( expr )
7198         | [ expr ]
7199         | BYTE
7200         | WORD
7201         | DWORD
7202         | FWORD
7203         | QWORD
7204         | TBYTE
7205         | OWORD
7206         | XMMWORD
7207         | $
7208         | .
7209         | register
7210         | id
7211         | constant  */
7212 static int
7213 intel_e11 ()
7214 {
7215   switch (cur_token.code)
7216     {
7217     /* e11  ( expr ) */
7218     case '(':
7219       intel_match_token ('(');
7220       strcat (intel_parser.disp, "(");
7221
7222       if (intel_expr () && intel_match_token (')'))
7223         {
7224           strcat (intel_parser.disp, ")");
7225           return 1;
7226         }
7227       return 0;
7228
7229     /* e11  [ expr ] */
7230     case '[':
7231       return intel_bracket_expr ();
7232
7233     /* e11  $
7234             | .  */
7235     case '.':
7236       strcat (intel_parser.disp, cur_token.str);
7237       intel_match_token (cur_token.code);
7238
7239       /* Mark as a memory operand only if it's not already known to be an
7240          offset expression.  */
7241       if (!intel_parser.in_offset)
7242         intel_parser.is_mem = 1;
7243
7244       return 1;
7245
7246     /* e11  register  */
7247     case T_REG:
7248       {
7249         const reg_entry *reg = intel_parser.reg = cur_token.reg;
7250
7251         intel_match_token (T_REG);
7252
7253         /* Check for segment change.  */
7254         if (cur_token.code == ':')
7255           {
7256             if (!(reg->reg_type & (SReg2 | SReg3)))
7257               {
7258                 as_bad (_("`%s' is not a valid segment register"), reg->reg_name);
7259                 return 0;
7260               }
7261             else if (i.seg[i.mem_operands])
7262               as_warn (_("Extra segment override ignored"));
7263             else
7264               {
7265                 if (!intel_parser.in_offset)
7266                   intel_parser.is_mem = 1;
7267                 switch (reg->reg_num)
7268                   {
7269                   case 0:
7270                     i.seg[i.mem_operands] = &es;
7271                     break;
7272                   case 1:
7273                     i.seg[i.mem_operands] = &cs;
7274                     break;
7275                   case 2:
7276                     i.seg[i.mem_operands] = &ss;
7277                     break;
7278                   case 3:
7279                     i.seg[i.mem_operands] = &ds;
7280                     break;
7281                   case 4:
7282                     i.seg[i.mem_operands] = &fs;
7283                     break;
7284                   case 5:
7285                     i.seg[i.mem_operands] = &gs;
7286                     break;
7287                   }
7288               }
7289           }
7290
7291         /* Not a segment register. Check for register scaling.  */
7292         else if (cur_token.code == '*')
7293           {
7294             if (!intel_parser.in_bracket)
7295               {
7296                 as_bad (_("Register scaling only allowed in memory operands"));
7297                 return 0;
7298               }
7299
7300             if (reg->reg_type & Reg16) /* Disallow things like [si*1]. */
7301               reg = i386_regtab + REGNAM_AX + 4; /* sp is invalid as index */
7302             else if (i.index_reg)
7303               reg = i386_regtab + REGNAM_EAX + 4; /* esp is invalid as index */
7304
7305             /* What follows must be a valid scale.  */
7306             intel_match_token ('*');
7307             i.index_reg = reg;
7308             i.types[this_operand] |= BaseIndex;
7309
7310             /* Set the scale after setting the register (otherwise,
7311                i386_scale will complain)  */
7312             if (cur_token.code == '+' || cur_token.code == '-')
7313               {
7314                 char *str, sign = cur_token.code;
7315                 intel_match_token (cur_token.code);
7316                 if (cur_token.code != T_CONST)
7317                   {
7318                     as_bad (_("Syntax error: Expecting a constant, got `%s'"),
7319                             cur_token.str);
7320                     return 0;
7321                   }
7322                 str = (char *) xmalloc (strlen (cur_token.str) + 2);
7323                 strcpy (str + 1, cur_token.str);
7324                 *str = sign;
7325                 if (!i386_scale (str))
7326                   return 0;
7327                 free (str);
7328               }
7329             else if (!i386_scale (cur_token.str))
7330               return 0;
7331             intel_match_token (cur_token.code);
7332           }
7333
7334         /* No scaling. If this is a memory operand, the register is either a
7335            base register (first occurrence) or an index register (second
7336            occurrence).  */
7337         else if (intel_parser.in_bracket)
7338           {
7339
7340             if (!i.base_reg)
7341               i.base_reg = reg;
7342             else if (!i.index_reg)
7343               i.index_reg = reg;
7344             else
7345               {
7346                 as_bad (_("Too many register references in memory operand"));
7347                 return 0;
7348               }
7349
7350             i.types[this_operand] |= BaseIndex;
7351           }
7352
7353         /* It's neither base nor index.  */
7354         else if (!intel_parser.in_offset && !intel_parser.is_mem)
7355           {
7356             i.types[this_operand] |= reg->reg_type & ~BaseIndex;
7357             i.op[this_operand].regs = reg;
7358             i.reg_operands++;
7359           }
7360         else
7361           {
7362             as_bad (_("Invalid use of register"));
7363             return 0;
7364           }
7365
7366         /* Since registers are not part of the displacement string (except
7367            when we're parsing offset operands), we may need to remove any
7368            preceding '+' from the displacement string.  */
7369         if (*intel_parser.disp != '\0'
7370             && !intel_parser.in_offset)
7371           {
7372             char *s = intel_parser.disp;
7373             s += strlen (s) - 1;
7374             if (*s == '+')
7375               *s = '\0';
7376           }
7377
7378         return 1;
7379       }
7380
7381     /* e11  BYTE
7382             | WORD
7383             | DWORD
7384             | FWORD
7385             | QWORD
7386             | TBYTE
7387             | OWORD
7388             | XMMWORD  */
7389     case T_BYTE:
7390     case T_WORD:
7391     case T_DWORD:
7392     case T_FWORD:
7393     case T_QWORD:
7394     case T_TBYTE:
7395     case T_XMMWORD:
7396       intel_match_token (cur_token.code);
7397
7398       if (cur_token.code == T_PTR)
7399         return 1;
7400
7401       /* It must have been an identifier.  */
7402       intel_putback_token ();
7403       cur_token.code = T_ID;
7404       /* FALLTHRU */
7405
7406     /* e11  id
7407             | constant  */
7408     case T_ID:
7409       if (!intel_parser.in_offset && intel_parser.is_mem <= 0)
7410         {
7411           symbolS *symbolP;
7412
7413           /* The identifier represents a memory reference only if it's not
7414              preceded by an offset modifier and if it's not an equate.  */
7415           symbolP = symbol_find(cur_token.str);
7416           if (!symbolP || S_GET_SEGMENT(symbolP) != absolute_section)
7417             intel_parser.is_mem = 1;
7418         }
7419         /* FALLTHRU */
7420
7421     case T_CONST:
7422     case '-':
7423     case '+':
7424       {
7425         char *save_str, sign = 0;
7426
7427         /* Allow constants that start with `+' or `-'.  */
7428         if (cur_token.code == '-' || cur_token.code == '+')
7429           {
7430             sign = cur_token.code;
7431             intel_match_token (cur_token.code);
7432             if (cur_token.code != T_CONST)
7433               {
7434                 as_bad (_("Syntax error: Expecting a constant, got `%s'"),
7435                         cur_token.str);
7436                 return 0;
7437               }
7438           }
7439
7440         save_str = (char *) xmalloc (strlen (cur_token.str) + 2);
7441         strcpy (save_str + !!sign, cur_token.str);
7442         if (sign)
7443           *save_str = sign;
7444
7445         /* Get the next token to check for register scaling.  */
7446         intel_match_token (cur_token.code);
7447
7448         /* Check if this constant is a scaling factor for an index register.  */
7449         if (cur_token.code == '*')
7450           {
7451             if (intel_match_token ('*') && cur_token.code == T_REG)
7452               {
7453                 const reg_entry *reg = cur_token.reg;
7454
7455                 if (!intel_parser.in_bracket)
7456                   {
7457                     as_bad (_("Register scaling only allowed in memory operands"));
7458                     return 0;
7459                   }
7460
7461                 if (reg->reg_type & Reg16) /* Disallow things like [1*si]. */
7462                   reg = i386_regtab + REGNAM_AX + 4; /* sp is invalid as index */
7463                 else if (i.index_reg)
7464                   reg = i386_regtab + REGNAM_EAX + 4; /* esp is invalid as index */
7465
7466                 /* The constant is followed by `* reg', so it must be
7467                    a valid scale.  */
7468                 i.index_reg = reg;
7469                 i.types[this_operand] |= BaseIndex;
7470
7471                 /* Set the scale after setting the register (otherwise,
7472                    i386_scale will complain)  */
7473                 if (!i386_scale (save_str))
7474                   return 0;
7475                 intel_match_token (T_REG);
7476
7477                 /* Since registers are not part of the displacement
7478                    string, we may need to remove any preceding '+' from
7479                    the displacement string.  */
7480                 if (*intel_parser.disp != '\0')
7481                   {
7482                     char *s = intel_parser.disp;
7483                     s += strlen (s) - 1;
7484                     if (*s == '+')
7485                       *s = '\0';
7486                   }
7487
7488                 free (save_str);
7489
7490                 return 1;
7491               }
7492
7493             /* The constant was not used for register scaling. Since we have
7494                already consumed the token following `*' we now need to put it
7495                back in the stream.  */
7496             intel_putback_token ();
7497           }
7498
7499         /* Add the constant to the displacement string.  */
7500         strcat (intel_parser.disp, save_str);
7501         free (save_str);
7502
7503         return 1;
7504       }
7505     }
7506
7507   as_bad (_("Unrecognized token '%s'"), cur_token.str);
7508   return 0;
7509 }
7510
7511 /* Match the given token against cur_token. If they match, read the next
7512    token from the operand string.  */
7513 static int
7514 intel_match_token (code)
7515      int code;
7516 {
7517   if (cur_token.code == code)
7518     {
7519       intel_get_token ();
7520       return 1;
7521     }
7522   else
7523     {
7524       as_bad (_("Unexpected token `%s'"), cur_token.str);
7525       return 0;
7526     }
7527 }
7528
7529 /* Read a new token from intel_parser.op_string and store it in cur_token.  */
7530 static void
7531 intel_get_token ()
7532 {
7533   char *end_op;
7534   const reg_entry *reg;
7535   struct intel_token new_token;
7536
7537   new_token.code = T_NIL;
7538   new_token.reg = NULL;
7539   new_token.str = NULL;
7540
7541   /* Free the memory allocated to the previous token and move
7542      cur_token to prev_token.  */
7543   if (prev_token.str)
7544     free (prev_token.str);
7545
7546   prev_token = cur_token;
7547
7548   /* Skip whitespace.  */
7549   while (is_space_char (*intel_parser.op_string))
7550     intel_parser.op_string++;
7551
7552   /* Return an empty token if we find nothing else on the line.  */
7553   if (*intel_parser.op_string == '\0')
7554     {
7555       cur_token = new_token;
7556       return;
7557     }
7558
7559   /* The new token cannot be larger than the remainder of the operand
7560      string.  */
7561   new_token.str = (char *) xmalloc (strlen (intel_parser.op_string) + 1);
7562   new_token.str[0] = '\0';
7563
7564   if (strchr ("0123456789", *intel_parser.op_string))
7565     {
7566       char *p = new_token.str;
7567       char *q = intel_parser.op_string;
7568       new_token.code = T_CONST;
7569
7570       /* Allow any kind of identifier char to encompass floating point and
7571          hexadecimal numbers.  */
7572       while (is_identifier_char (*q))
7573         *p++ = *q++;
7574       *p = '\0';
7575
7576       /* Recognize special symbol names [0-9][bf].  */
7577       if (strlen (intel_parser.op_string) == 2
7578           && (intel_parser.op_string[1] == 'b'
7579               || intel_parser.op_string[1] == 'f'))
7580         new_token.code = T_ID;
7581     }
7582
7583   else if ((reg = parse_register (intel_parser.op_string, &end_op)) != NULL)
7584     {
7585       size_t len = end_op - intel_parser.op_string;
7586
7587       new_token.code = T_REG;
7588       new_token.reg = reg;
7589
7590       memcpy (new_token.str, intel_parser.op_string, len);
7591       new_token.str[len] = '\0';
7592     }
7593
7594   else if (is_identifier_char (*intel_parser.op_string))
7595     {
7596       char *p = new_token.str;
7597       char *q = intel_parser.op_string;
7598
7599       /* A '.' or '$' followed by an identifier char is an identifier.
7600          Otherwise, it's operator '.' followed by an expression.  */
7601       if ((*q == '.' || *q == '$') && !is_identifier_char (*(q + 1)))
7602         {
7603           new_token.code = '.';
7604           new_token.str[0] = '.';
7605           new_token.str[1] = '\0';
7606         }
7607       else
7608         {
7609           while (is_identifier_char (*q) || *q == '@')
7610             *p++ = *q++;
7611           *p = '\0';
7612
7613           if (strcasecmp (new_token.str, "NOT") == 0)
7614             new_token.code = '~';
7615
7616           else if (strcasecmp (new_token.str, "MOD") == 0)
7617             new_token.code = '%';
7618
7619           else if (strcasecmp (new_token.str, "AND") == 0)
7620             new_token.code = '&';
7621
7622           else if (strcasecmp (new_token.str, "OR") == 0)
7623             new_token.code = '|';
7624
7625           else if (strcasecmp (new_token.str, "XOR") == 0)
7626             new_token.code = '^';
7627
7628           else if (strcasecmp (new_token.str, "SHL") == 0)
7629             new_token.code = T_SHL;
7630
7631           else if (strcasecmp (new_token.str, "SHR") == 0)
7632             new_token.code = T_SHR;
7633
7634           else if (strcasecmp (new_token.str, "BYTE") == 0)
7635             new_token.code = T_BYTE;
7636
7637           else if (strcasecmp (new_token.str, "WORD") == 0)
7638             new_token.code = T_WORD;
7639
7640           else if (strcasecmp (new_token.str, "DWORD") == 0)
7641             new_token.code = T_DWORD;
7642
7643           else if (strcasecmp (new_token.str, "FWORD") == 0)
7644             new_token.code = T_FWORD;
7645
7646           else if (strcasecmp (new_token.str, "QWORD") == 0)
7647             new_token.code = T_QWORD;
7648
7649           else if (strcasecmp (new_token.str, "TBYTE") == 0
7650                    /* XXX remove (gcc still uses it) */
7651                    || strcasecmp (new_token.str, "XWORD") == 0)
7652             new_token.code = T_TBYTE;
7653
7654           else if (strcasecmp (new_token.str, "XMMWORD") == 0
7655                    || strcasecmp (new_token.str, "OWORD") == 0)
7656             new_token.code = T_XMMWORD;
7657
7658           else if (strcasecmp (new_token.str, "PTR") == 0)
7659             new_token.code = T_PTR;
7660
7661           else if (strcasecmp (new_token.str, "SHORT") == 0)
7662             new_token.code = T_SHORT;
7663
7664           else if (strcasecmp (new_token.str, "OFFSET") == 0)
7665             {
7666               new_token.code = T_OFFSET;
7667
7668               /* ??? This is not mentioned in the MASM grammar but gcc
7669                      makes use of it with -mintel-syntax.  OFFSET may be
7670                      followed by FLAT:  */
7671               if (strncasecmp (q, " FLAT:", 6) == 0)
7672                 strcat (new_token.str, " FLAT:");
7673             }
7674
7675           /* ??? This is not mentioned in the MASM grammar.  */
7676           else if (strcasecmp (new_token.str, "FLAT") == 0)
7677             {
7678               new_token.code = T_OFFSET;
7679               if (*q == ':')
7680                 strcat (new_token.str, ":");
7681               else
7682                 as_bad (_("`:' expected"));
7683             }
7684
7685           else
7686             new_token.code = T_ID;
7687         }
7688     }
7689
7690   else if (strchr ("+-/*%|&^:[]()~", *intel_parser.op_string))
7691     {
7692       new_token.code = *intel_parser.op_string;
7693       new_token.str[0] = *intel_parser.op_string;
7694       new_token.str[1] = '\0';
7695     }
7696
7697   else if (strchr ("<>", *intel_parser.op_string)
7698            && *intel_parser.op_string == *(intel_parser.op_string + 1))
7699     {
7700       new_token.code = *intel_parser.op_string == '<' ? T_SHL : T_SHR;
7701       new_token.str[0] = *intel_parser.op_string;
7702       new_token.str[1] = *intel_parser.op_string;
7703       new_token.str[2] = '\0';
7704     }
7705
7706   else
7707     as_bad (_("Unrecognized token `%s'"), intel_parser.op_string);
7708
7709   intel_parser.op_string += strlen (new_token.str);
7710   cur_token = new_token;
7711 }
7712
7713 /* Put cur_token back into the token stream and make cur_token point to
7714    prev_token.  */
7715 static void
7716 intel_putback_token ()
7717 {
7718   if (cur_token.code != T_NIL)
7719     {
7720       intel_parser.op_string -= strlen (cur_token.str);
7721       free (cur_token.str);
7722     }
7723   cur_token = prev_token;
7724
7725   /* Forget prev_token.  */
7726   prev_token.code = T_NIL;
7727   prev_token.reg = NULL;
7728   prev_token.str = NULL;
7729 }
7730
7731 int
7732 tc_x86_regname_to_dw2regnum (char *regname)
7733 {
7734   unsigned int regnum;
7735   unsigned int regnames_count;
7736   static const char *const regnames_32[] =
7737     {
7738       "eax", "ecx", "edx", "ebx",
7739       "esp", "ebp", "esi", "edi",
7740       "eip", "eflags", NULL,
7741       "st0", "st1", "st2", "st3",
7742       "st4", "st5", "st6", "st7",
7743       NULL, NULL,
7744       "xmm0", "xmm1", "xmm2", "xmm3",
7745       "xmm4", "xmm5", "xmm6", "xmm7",
7746       "mm0", "mm1", "mm2", "mm3",
7747       "mm4", "mm5", "mm6", "mm7",
7748       "fcw", "fsw", "mxcsr",
7749       "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
7750       "tr", "ldtr"
7751     };
7752   static const char *const regnames_64[] =
7753     {
7754       "rax", "rdx", "rcx", "rbx",
7755       "rsi", "rdi", "rbp", "rsp",
7756       "r8",  "r9",  "r10", "r11",
7757       "r12", "r13", "r14", "r15",
7758       "rip",
7759       "xmm0",  "xmm1",  "xmm2",  "xmm3",
7760       "xmm4",  "xmm5",  "xmm6",  "xmm7",
7761       "xmm8",  "xmm9",  "xmm10", "xmm11",
7762       "xmm12", "xmm13", "xmm14", "xmm15",
7763       "st0", "st1", "st2", "st3",
7764       "st4", "st5", "st6", "st7",
7765       "mm0", "mm1", "mm2", "mm3",
7766       "mm4", "mm5", "mm6", "mm7",
7767       "rflags",
7768       "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
7769       "fs.base", "gs.base", NULL, NULL,
7770       "tr", "ldtr",
7771       "mxcsr", "fcw", "fsw"
7772     };
7773   const char *const *regnames;
7774
7775   if (flag_code == CODE_64BIT)
7776     {
7777       regnames = regnames_64;
7778       regnames_count = ARRAY_SIZE (regnames_64);
7779     }
7780   else
7781     {
7782       regnames = regnames_32;
7783       regnames_count = ARRAY_SIZE (regnames_32);
7784     }
7785
7786   for (regnum = 0; regnum < regnames_count; regnum++)
7787     if (regnames[regnum] != NULL
7788         && strcmp (regname, regnames[regnum]) == 0)
7789       return regnum;
7790
7791   return -1;
7792 }
7793
7794 void
7795 tc_x86_frame_initial_instructions (void)
7796 {
7797   static unsigned int sp_regno;
7798
7799   if (!sp_regno)
7800     sp_regno = tc_x86_regname_to_dw2regnum (flag_code == CODE_64BIT
7801                                             ? "rsp" : "esp");
7802
7803   cfi_add_CFA_def_cfa (sp_regno, -x86_cie_data_alignment);
7804   cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
7805 }
7806
7807 int
7808 i386_elf_section_type (const char *str, size_t len)
7809 {
7810   if (flag_code == CODE_64BIT
7811       && len == sizeof ("unwind") - 1
7812       && strncmp (str, "unwind", 6) == 0)
7813     return SHT_X86_64_UNWIND;
7814
7815   return -1;
7816 }
7817
7818 #ifdef TE_PE
7819 void
7820 tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
7821 {
7822   expressionS expr;
7823
7824   expr.X_op = O_secrel;
7825   expr.X_add_symbol = symbol;
7826   expr.X_add_number = 0;
7827   emit_expr (&expr, size);
7828 }
7829 #endif
7830
7831 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7832 /* For ELF on x86-64, add support for SHF_X86_64_LARGE.  */
7833
7834 int
7835 x86_64_section_letter (int letter, char **ptr_msg)
7836 {
7837   if (flag_code == CODE_64BIT)
7838     {
7839       if (letter == 'l')
7840         return SHF_X86_64_LARGE;
7841
7842       *ptr_msg = _("Bad .section directive: want a,l,w,x,M,S,G,T in string");
7843     }
7844   else
7845     *ptr_msg = _("Bad .section directive: want a,w,x,M,S,G,T in string");
7846   return -1;
7847 }
7848
7849 int
7850 x86_64_section_word (char *str, size_t len)
7851 {
7852   if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
7853     return SHF_X86_64_LARGE;
7854
7855   return -1;
7856 }
7857
7858 static void
7859 handle_large_common (int small ATTRIBUTE_UNUSED)
7860 {
7861   if (flag_code != CODE_64BIT)
7862     {
7863       s_comm_internal (0, elf_common_parse);
7864       as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
7865     }
7866   else
7867     {
7868       static segT lbss_section;
7869       asection *saved_com_section_ptr = elf_com_section_ptr;
7870       asection *saved_bss_section = bss_section;
7871
7872       if (lbss_section == NULL)
7873         {
7874           flagword applicable;
7875           segT seg = now_seg;
7876           subsegT subseg = now_subseg;
7877
7878           /* The .lbss section is for local .largecomm symbols.  */
7879           lbss_section = subseg_new (".lbss", 0);
7880           applicable = bfd_applicable_section_flags (stdoutput);
7881           bfd_set_section_flags (stdoutput, lbss_section,
7882                                  applicable & SEC_ALLOC);
7883           seg_info (lbss_section)->bss = 1;
7884
7885           subseg_set (seg, subseg);
7886         }
7887
7888       elf_com_section_ptr = &_bfd_elf_large_com_section;
7889       bss_section = lbss_section;
7890
7891       s_comm_internal (0, elf_common_parse);
7892
7893       elf_com_section_ptr = saved_com_section_ptr;
7894       bss_section = saved_bss_section;
7895     }
7896 }
7897 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */