gas/config/tc-i386.c

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