Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / gas / config / tc-i386.c
1 /* tc-i386.c -- Assemble code for the Intel 80386
2    Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 3, 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 "elf/x86-64.h"
36 #include "opcodes/i386-init.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 DEFAULT_ARCH
47 #define DEFAULT_ARCH "i386"
48 #endif
49
50 #ifndef INLINE
51 #if __GNUC__ >= 2
52 #define INLINE __inline__
53 #else
54 #define INLINE
55 #endif
56 #endif
57
58 /* Prefixes will be emitted in the order defined below.
59    WAIT_PREFIX must be the first prefix since FWAIT is really is an
60    instruction, and so must come before any prefixes.
61    The preferred prefix order is SEG_PREFIX, ADDR_PREFIX, DATA_PREFIX,
62    REP_PREFIX, LOCK_PREFIX.  */
63 #define WAIT_PREFIX     0
64 #define SEG_PREFIX      1
65 #define ADDR_PREFIX     2
66 #define DATA_PREFIX     3
67 #define REP_PREFIX      4
68 #define LOCK_PREFIX     5
69 #define REX_PREFIX      6       /* must come last.  */
70 #define MAX_PREFIXES    7       /* max prefixes per opcode */
71
72 /* we define the syntax here (modulo base,index,scale syntax) */
73 #define REGISTER_PREFIX '%'
74 #define IMMEDIATE_PREFIX '$'
75 #define ABSOLUTE_PREFIX '*'
76
77 /* these are the instruction mnemonic suffixes in AT&T syntax or
78    memory operand size in Intel syntax.  */
79 #define WORD_MNEM_SUFFIX  'w'
80 #define BYTE_MNEM_SUFFIX  'b'
81 #define SHORT_MNEM_SUFFIX 's'
82 #define LONG_MNEM_SUFFIX  'l'
83 #define QWORD_MNEM_SUFFIX  'q'
84 #define XMMWORD_MNEM_SUFFIX  'x'
85 #define YMMWORD_MNEM_SUFFIX 'y'
86 /* Intel Syntax.  Use a non-ascii letter since since it never appears
87    in instructions.  */
88 #define LONG_DOUBLE_MNEM_SUFFIX '\1'
89
90 #define END_OF_INSN '\0'
91
92 /*
93   'templates' is for grouping together 'template' structures for opcodes
94   of the same name.  This is only used for storing the insns in the grand
95   ole hash table of insns.
96   The templates themselves start at START and range up to (but not including)
97   END.
98   */
99 typedef struct
100 {
101   const insn_template *start;
102   const insn_template *end;
103 }
104 templates;
105
106 /* 386 operand encoding bytes:  see 386 book for details of this.  */
107 typedef struct
108 {
109   unsigned int regmem;  /* codes register or memory operand */
110   unsigned int reg;     /* codes register operand (or extended opcode) */
111   unsigned int mode;    /* how to interpret regmem & reg */
112 }
113 modrm_byte;
114
115 /* x86-64 extension prefix.  */
116 typedef int rex_byte;
117
118 /* 386 opcode byte to code indirect addressing.  */
119 typedef struct
120 {
121   unsigned base;
122   unsigned index;
123   unsigned scale;
124 }
125 sib_byte;
126
127 /* x86 arch names, types and features */
128 typedef struct
129 {
130   const char *name;             /* arch name */
131   unsigned int len;             /* arch string length */
132   enum processor_type type;     /* arch type */
133   i386_cpu_flags flags;         /* cpu feature flags */
134   unsigned int skip;            /* show_arch should skip this. */
135   unsigned int negated;         /* turn off indicated flags.  */
136 }
137 arch_entry;
138
139 static void update_code_flag (int, int);
140 static void set_code_flag (int);
141 static void set_16bit_gcc_code_flag (int);
142 static void set_intel_syntax (int);
143 static void set_intel_mnemonic (int);
144 static void set_allow_index_reg (int);
145 static void set_sse_check (int);
146 static void set_cpu_arch (int);
147 #ifdef TE_PE
148 static void pe_directive_secrel (int);
149 #endif
150 static void signed_cons (int);
151 static char *output_invalid (int c);
152 static int i386_finalize_immediate (segT, expressionS *, i386_operand_type,
153                                     const char *);
154 static int i386_finalize_displacement (segT, expressionS *, i386_operand_type,
155                                        const char *);
156 static int i386_att_operand (char *);
157 static int i386_intel_operand (char *, int);
158 static int i386_intel_simplify (expressionS *);
159 static int i386_intel_parse_name (const char *, expressionS *);
160 static const reg_entry *parse_register (char *, char **);
161 static char *parse_insn (char *, char *);
162 static char *parse_operands (char *, const char *);
163 static void swap_operands (void);
164 static void swap_2_operands (int, int);
165 static void optimize_imm (void);
166 static void optimize_disp (void);
167 static const insn_template *match_template (void);
168 static int check_string (void);
169 static int process_suffix (void);
170 static int check_byte_reg (void);
171 static int check_long_reg (void);
172 static int check_qword_reg (void);
173 static int check_word_reg (void);
174 static int finalize_imm (void);
175 static int process_operands (void);
176 static const seg_entry *build_modrm_byte (void);
177 static void output_insn (void);
178 static void output_imm (fragS *, offsetT);
179 static void output_disp (fragS *, offsetT);
180 #ifndef I386COFF
181 static void s_bss (int);
182 #endif
183 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
184 static void handle_large_common (int small ATTRIBUTE_UNUSED);
185 #endif
186
187 static const char *default_arch = DEFAULT_ARCH;
188
189 /* VEX prefix.  */
190 typedef struct
191 {
192   /* VEX prefix is either 2 byte or 3 byte.  */
193   unsigned char bytes[3];
194   unsigned int length;
195   /* Destination or source register specifier.  */
196   const reg_entry *register_specifier;
197 } vex_prefix;
198
199 /* 'md_assemble ()' gathers together information and puts it into a
200    i386_insn.  */
201
202 union i386_op
203   {
204     expressionS *disps;
205     expressionS *imms;
206     const reg_entry *regs;
207   };
208
209 enum i386_error
210   {
211     operand_size_mismatch,
212     operand_type_mismatch,
213     register_type_mismatch,
214     number_of_operands_mismatch,
215     invalid_instruction_suffix,
216     bad_imm4,
217     old_gcc_only,
218     unsupported_with_intel_mnemonic,
219     unsupported_syntax,
220     unsupported
221   };
222
223 struct _i386_insn
224   {
225     /* TM holds the template for the insn were currently assembling.  */
226     insn_template tm;
227
228     /* SUFFIX holds the instruction size suffix for byte, word, dword
229        or qword, if given.  */
230     char suffix;
231
232     /* OPERANDS gives the number of given operands.  */
233     unsigned int operands;
234
235     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
236        of given register, displacement, memory operands and immediate
237        operands.  */
238     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
239
240     /* TYPES [i] is the type (see above #defines) which tells us how to
241        use OP[i] for the corresponding operand.  */
242     i386_operand_type types[MAX_OPERANDS];
243
244     /* Displacement expression, immediate expression, or register for each
245        operand.  */
246     union i386_op op[MAX_OPERANDS];
247
248     /* Flags for operands.  */
249     unsigned int flags[MAX_OPERANDS];
250 #define Operand_PCrel 1
251
252     /* Relocation type for operand */
253     enum bfd_reloc_code_real reloc[MAX_OPERANDS];
254
255     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
256        the base index byte below.  */
257     const reg_entry *base_reg;
258     const reg_entry *index_reg;
259     unsigned int log2_scale_factor;
260
261     /* SEG gives the seg_entries of this insn.  They are zero unless
262        explicit segment overrides are given.  */
263     const seg_entry *seg[2];
264
265     /* PREFIX holds all the given prefix opcodes (usually null).
266        PREFIXES is the number of prefix opcodes.  */
267     unsigned int prefixes;
268     unsigned char prefix[MAX_PREFIXES];
269
270     /* RM and SIB are the modrm byte and the sib byte where the
271        addressing modes of this insn are encoded.  */
272     modrm_byte rm;
273     rex_byte rex;
274     sib_byte sib;
275     vex_prefix vex;
276
277     /* Swap operand in encoding.  */
278     unsigned int swap_operand;
279
280     /* Force 32bit displacement in encoding.  */
281     unsigned int disp32_encoding;
282
283     /* Error message.  */
284     enum i386_error error;
285   };
286
287 typedef struct _i386_insn i386_insn;
288
289 /* List of chars besides those in app.c:symbol_chars that can start an
290    operand.  Used to prevent the scrubber eating vital white-space.  */
291 const char extra_symbol_chars[] = "*%-(["
292 #ifdef LEX_AT
293         "@"
294 #endif
295 #ifdef LEX_QM
296         "?"
297 #endif
298         ;
299
300 #if (defined (TE_I386AIX)                               \
301      || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
302          && !defined (TE_GNU)                           \
303          && !defined (TE_LINUX)                         \
304          && !defined (TE_NETWARE)                       \
305          && !defined (TE_FreeBSD)                       \
306          && !defined (TE_DragonFly)                     \
307          && !defined (TE_NetBSD)))
308 /* This array holds the chars that always start a comment.  If the
309    pre-processor is disabled, these aren't very useful.  The option
310    --divide will remove '/' from this list.  */
311 const char *i386_comment_chars = "#/";
312 #define SVR4_COMMENT_CHARS 1
313 #define PREFIX_SEPARATOR '\\'
314
315 #else
316 const char *i386_comment_chars = "#";
317 #define PREFIX_SEPARATOR '/'
318 #endif
319
320 /* This array holds the chars that only start a comment at the beginning of
321    a line.  If the line seems to have the form '# 123 filename'
322    .line and .file directives will appear in the pre-processed output.
323    Note that input_file.c hand checks for '#' at the beginning of the
324    first line of the input file.  This is because the compiler outputs
325    #NO_APP at the beginning of its output.
326    Also note that comments started like this one will always work if
327    '/' isn't otherwise defined.  */
328 const char line_comment_chars[] = "#/";
329
330 const char line_separator_chars[] = ";";
331
332 /* Chars that can be used to separate mant from exp in floating point
333    nums.  */
334 const char EXP_CHARS[] = "eE";
335
336 /* Chars that mean this number is a floating point constant
337    As in 0f12.456
338    or    0d1.2345e12.  */
339 const char FLT_CHARS[] = "fFdDxX";
340
341 /* Tables for lexical analysis.  */
342 static char mnemonic_chars[256];
343 static char register_chars[256];
344 static char operand_chars[256];
345 static char identifier_chars[256];
346 static char digit_chars[256];
347
348 /* Lexical macros.  */
349 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
350 #define is_operand_char(x) (operand_chars[(unsigned char) x])
351 #define is_register_char(x) (register_chars[(unsigned char) x])
352 #define is_space_char(x) ((x) == ' ')
353 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
354 #define is_digit_char(x) (digit_chars[(unsigned char) x])
355
356 /* All non-digit non-letter characters that may occur in an operand.  */
357 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
358
359 /* md_assemble() always leaves the strings it's passed unaltered.  To
360    effect this we maintain a stack of saved characters that we've smashed
361    with '\0's (indicating end of strings for various sub-fields of the
362    assembler instruction).  */
363 static char save_stack[32];
364 static char *save_stack_p;
365 #define END_STRING_AND_SAVE(s) \
366         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
367 #define RESTORE_END_STRING(s) \
368         do { *(s) = *--save_stack_p; } while (0)
369
370 /* The instruction we're assembling.  */
371 static i386_insn i;
372
373 /* Possible templates for current insn.  */
374 static const templates *current_templates;
375
376 /* Per instruction expressionS buffers: max displacements & immediates.  */
377 static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
378 static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
379
380 /* Current operand we are working on.  */
381 static int this_operand = -1;
382
383 /* We support four different modes.  FLAG_CODE variable is used to distinguish
384    these.  */
385
386 enum flag_code {
387         CODE_32BIT,
388         CODE_16BIT,
389         CODE_64BIT };
390
391 static enum flag_code flag_code;
392 static unsigned int object_64bit;
393 static int use_rela_relocations = 0;
394
395 /* The names used to print error messages.  */
396 static const char *flag_code_names[] =
397   {
398     "32",
399     "16",
400     "64"
401   };
402
403 /* 1 for intel syntax,
404    0 if att syntax.  */
405 static int intel_syntax = 0;
406
407 /* 1 for intel mnemonic,
408    0 if att mnemonic.  */
409 static int intel_mnemonic = !SYSV386_COMPAT;
410
411 /* 1 if support old (<= 2.8.1) versions of gcc.  */
412 static int old_gcc = OLDGCC_COMPAT;
413
414 /* 1 if pseudo registers are permitted.  */
415 static int allow_pseudo_reg = 0;
416
417 /* 1 if register prefix % not required.  */
418 static int allow_naked_reg = 0;
419
420 /* 1 if pseudo index register, eiz/riz, is allowed .  */
421 static int allow_index_reg = 0;
422
423 static enum
424   {
425     sse_check_none = 0,
426     sse_check_warning,
427     sse_check_error
428   }
429 sse_check;
430
431 /* Register prefix used for error message.  */
432 static const char *register_prefix = "%";
433
434 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
435    leave, push, and pop instructions so that gcc has the same stack
436    frame as in 32 bit mode.  */
437 static char stackop_size = '\0';
438
439 /* Non-zero to optimize code alignment.  */
440 int optimize_align_code = 1;
441
442 /* Non-zero to quieten some warnings.  */
443 static int quiet_warnings = 0;
444
445 /* CPU name.  */
446 static const char *cpu_arch_name = NULL;
447 static char *cpu_sub_arch_name = NULL;
448
449 /* CPU feature flags.  */
450 static i386_cpu_flags cpu_arch_flags = CPU_UNKNOWN_FLAGS;
451
452 /* If we have selected a cpu we are generating instructions for.  */
453 static int cpu_arch_tune_set = 0;
454
455 /* Cpu we are generating instructions for.  */
456 enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
457
458 /* CPU feature flags of cpu we are generating instructions for.  */
459 static i386_cpu_flags cpu_arch_tune_flags;
460
461 /* CPU instruction set architecture used.  */
462 enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
463
464 /* CPU feature flags of instruction set architecture used.  */
465 i386_cpu_flags cpu_arch_isa_flags;
466
467 /* If set, conditional jumps are not automatically promoted to handle
468    larger than a byte offset.  */
469 static unsigned int no_cond_jump_promotion = 0;
470
471 /* Encode SSE instructions with VEX prefix.  */
472 static unsigned int sse2avx;
473
474 /* Encode scalar AVX instructions with specific vector length.  */
475 static enum
476   {
477     vex128 = 0,
478     vex256
479   } avxscalar;
480
481 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
482 static symbolS *GOT_symbol;
483
484 /* The dwarf2 return column, adjusted for 32 or 64 bit.  */
485 unsigned int x86_dwarf2_return_column;
486
487 /* The dwarf2 data alignment, adjusted for 32 or 64 bit.  */
488 int x86_cie_data_alignment;
489
490 /* Interface to relax_segment.
491    There are 3 major relax states for 386 jump insns because the
492    different types of jumps add different sizes to frags when we're
493    figuring out what sort of jump to choose to reach a given label.  */
494
495 /* Types.  */
496 #define UNCOND_JUMP 0
497 #define COND_JUMP 1
498 #define COND_JUMP86 2
499
500 /* Sizes.  */
501 #define CODE16  1
502 #define SMALL   0
503 #define SMALL16 (SMALL | CODE16)
504 #define BIG     2
505 #define BIG16   (BIG | CODE16)
506
507 #ifndef INLINE
508 #ifdef __GNUC__
509 #define INLINE __inline__
510 #else
511 #define INLINE
512 #endif
513 #endif
514
515 #define ENCODE_RELAX_STATE(type, size) \
516   ((relax_substateT) (((type) << 2) | (size)))
517 #define TYPE_FROM_RELAX_STATE(s) \
518   ((s) >> 2)
519 #define DISP_SIZE_FROM_RELAX_STATE(s) \
520     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
521
522 /* This table is used by relax_frag to promote short jumps to long
523    ones where necessary.  SMALL (short) jumps may be promoted to BIG
524    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
525    don't allow a short jump in a 32 bit code segment to be promoted to
526    a 16 bit offset jump because it's slower (requires data size
527    prefix), and doesn't work, unless the destination is in the bottom
528    64k of the code segment (The top 16 bits of eip are zeroed).  */
529
530 const relax_typeS md_relax_table[] =
531 {
532   /* The fields are:
533      1) most positive reach of this state,
534      2) most negative reach of this state,
535      3) how many bytes this mode will have in the variable part of the frag
536      4) which index into the table to try if we can't fit into this one.  */
537
538   /* UNCOND_JUMP states.  */
539   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
540   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
541   /* dword jmp adds 4 bytes to frag:
542      0 extra opcode bytes, 4 displacement bytes.  */
543   {0, 0, 4, 0},
544   /* word jmp adds 2 byte2 to frag:
545      0 extra opcode bytes, 2 displacement bytes.  */
546   {0, 0, 2, 0},
547
548   /* COND_JUMP states.  */
549   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
550   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
551   /* dword conditionals adds 5 bytes to frag:
552      1 extra opcode byte, 4 displacement bytes.  */
553   {0, 0, 5, 0},
554   /* word conditionals add 3 bytes to frag:
555      1 extra opcode byte, 2 displacement bytes.  */
556   {0, 0, 3, 0},
557
558   /* COND_JUMP86 states.  */
559   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
560   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
561   /* dword conditionals adds 5 bytes to frag:
562      1 extra opcode byte, 4 displacement bytes.  */
563   {0, 0, 5, 0},
564   /* word conditionals add 4 bytes to frag:
565      1 displacement byte and a 3 byte long branch insn.  */
566   {0, 0, 4, 0}
567 };
568
569 static const arch_entry cpu_arch[] =
570 {
571   /* Do not replace the first two entries - i386_target_format()
572      relies on them being there in this order.  */
573   { STRING_COMMA_LEN ("generic32"), PROCESSOR_GENERIC32,
574     CPU_GENERIC32_FLAGS, 0, 0 },
575   { STRING_COMMA_LEN ("generic64"), PROCESSOR_GENERIC64,
576     CPU_GENERIC64_FLAGS, 0, 0 },
577   { STRING_COMMA_LEN ("i8086"), PROCESSOR_UNKNOWN,
578     CPU_NONE_FLAGS, 0, 0 },
579   { STRING_COMMA_LEN ("i186"), PROCESSOR_UNKNOWN,
580     CPU_I186_FLAGS, 0, 0 },
581   { STRING_COMMA_LEN ("i286"), PROCESSOR_UNKNOWN,
582     CPU_I286_FLAGS, 0, 0 },
583   { STRING_COMMA_LEN ("i386"), PROCESSOR_I386,
584     CPU_I386_FLAGS, 0, 0 },
585   { STRING_COMMA_LEN ("i486"), PROCESSOR_I486,
586     CPU_I486_FLAGS, 0, 0 },
587   { STRING_COMMA_LEN ("i586"), PROCESSOR_PENTIUM,
588     CPU_I586_FLAGS, 0, 0 },
589   { STRING_COMMA_LEN ("i686"), PROCESSOR_PENTIUMPRO,
590     CPU_I686_FLAGS, 0, 0 },
591   { STRING_COMMA_LEN ("pentium"), PROCESSOR_PENTIUM,
592     CPU_I586_FLAGS, 0, 0 },
593   { STRING_COMMA_LEN ("pentiumpro"), PROCESSOR_PENTIUMPRO,
594     CPU_PENTIUMPRO_FLAGS, 0, 0 },
595   { STRING_COMMA_LEN ("pentiumii"), PROCESSOR_PENTIUMPRO,
596     CPU_P2_FLAGS, 0, 0 },
597   { STRING_COMMA_LEN ("pentiumiii"),PROCESSOR_PENTIUMPRO,
598     CPU_P3_FLAGS, 0, 0 },
599   { STRING_COMMA_LEN ("pentium4"), PROCESSOR_PENTIUM4,
600     CPU_P4_FLAGS, 0, 0 },
601   { STRING_COMMA_LEN ("prescott"), PROCESSOR_NOCONA,
602     CPU_CORE_FLAGS, 0, 0 },
603   { STRING_COMMA_LEN ("nocona"), PROCESSOR_NOCONA,
604     CPU_NOCONA_FLAGS, 0, 0 },
605   { STRING_COMMA_LEN ("yonah"), PROCESSOR_CORE,
606     CPU_CORE_FLAGS, 1, 0 },
607   { STRING_COMMA_LEN ("core"), PROCESSOR_CORE,
608     CPU_CORE_FLAGS, 0, 0 },
609   { STRING_COMMA_LEN ("merom"), PROCESSOR_CORE2,
610     CPU_CORE2_FLAGS, 1, 0 },
611   { STRING_COMMA_LEN ("core2"), PROCESSOR_CORE2,
612     CPU_CORE2_FLAGS, 0, 0 },
613   { STRING_COMMA_LEN ("corei7"), PROCESSOR_COREI7,
614     CPU_COREI7_FLAGS, 0, 0 },
615   { STRING_COMMA_LEN ("l1om"), PROCESSOR_L1OM,
616     CPU_L1OM_FLAGS, 0, 0 },
617   { STRING_COMMA_LEN ("k6"), PROCESSOR_K6,
618     CPU_K6_FLAGS, 0, 0 },
619   { STRING_COMMA_LEN ("k6_2"), PROCESSOR_K6,
620     CPU_K6_2_FLAGS, 0, 0 },
621   { STRING_COMMA_LEN ("athlon"), PROCESSOR_ATHLON,
622     CPU_ATHLON_FLAGS, 0, 0 },
623   { STRING_COMMA_LEN ("sledgehammer"), PROCESSOR_K8,
624     CPU_K8_FLAGS, 1, 0 },
625   { STRING_COMMA_LEN ("opteron"), PROCESSOR_K8,
626     CPU_K8_FLAGS, 0, 0 },
627   { STRING_COMMA_LEN ("k8"), PROCESSOR_K8,
628     CPU_K8_FLAGS, 0, 0 },
629   { STRING_COMMA_LEN ("amdfam10"), PROCESSOR_AMDFAM10,
630     CPU_AMDFAM10_FLAGS, 0, 0 },
631   { STRING_COMMA_LEN ("bdver1"), PROCESSOR_BDVER1,
632     CPU_BDVER1_FLAGS, 0, 0 },
633   { STRING_COMMA_LEN (".8087"), PROCESSOR_UNKNOWN,
634     CPU_8087_FLAGS, 0, 0 },
635   { STRING_COMMA_LEN (".287"), PROCESSOR_UNKNOWN,
636     CPU_287_FLAGS, 0, 0 },
637   { STRING_COMMA_LEN (".387"), PROCESSOR_UNKNOWN,
638     CPU_387_FLAGS, 0, 0 },
639   { STRING_COMMA_LEN (".no87"), PROCESSOR_UNKNOWN,
640     CPU_ANY87_FLAGS, 0, 1 },
641   { STRING_COMMA_LEN (".mmx"), PROCESSOR_UNKNOWN,
642     CPU_MMX_FLAGS, 0, 0 },
643   { STRING_COMMA_LEN (".nommx"), PROCESSOR_UNKNOWN,
644     CPU_3DNOWA_FLAGS, 0, 1 },
645   { STRING_COMMA_LEN (".sse"), PROCESSOR_UNKNOWN,
646     CPU_SSE_FLAGS, 0, 0 },
647   { STRING_COMMA_LEN (".sse2"), PROCESSOR_UNKNOWN,
648     CPU_SSE2_FLAGS, 0, 0 },
649   { STRING_COMMA_LEN (".sse3"), PROCESSOR_UNKNOWN,
650     CPU_SSE3_FLAGS, 0, 0 },
651   { STRING_COMMA_LEN (".ssse3"), PROCESSOR_UNKNOWN,
652     CPU_SSSE3_FLAGS, 0, 0 },
653   { STRING_COMMA_LEN (".sse4.1"), PROCESSOR_UNKNOWN,
654     CPU_SSE4_1_FLAGS, 0, 0 },
655   { STRING_COMMA_LEN (".sse4.2"), PROCESSOR_UNKNOWN,
656     CPU_SSE4_2_FLAGS, 0, 0 },
657   { STRING_COMMA_LEN (".sse4"), PROCESSOR_UNKNOWN,
658     CPU_SSE4_2_FLAGS, 0, 0 },
659   { STRING_COMMA_LEN (".nosse"), PROCESSOR_UNKNOWN,
660     CPU_ANY_SSE_FLAGS, 0, 1 },
661   { STRING_COMMA_LEN (".avx"), PROCESSOR_UNKNOWN,
662     CPU_AVX_FLAGS, 0, 0 },
663   { STRING_COMMA_LEN (".noavx"), PROCESSOR_UNKNOWN,
664     CPU_ANY_AVX_FLAGS, 0, 1 },
665   { STRING_COMMA_LEN (".vmx"), PROCESSOR_UNKNOWN,
666     CPU_VMX_FLAGS, 0, 0 },
667   { STRING_COMMA_LEN (".smx"), PROCESSOR_UNKNOWN,
668     CPU_SMX_FLAGS, 0, 0 },
669   { STRING_COMMA_LEN (".xsave"), PROCESSOR_UNKNOWN,
670     CPU_XSAVE_FLAGS, 0, 0 },
671   { STRING_COMMA_LEN (".xsaveopt"), PROCESSOR_UNKNOWN,
672     CPU_XSAVEOPT_FLAGS, 0, 0 },
673   { STRING_COMMA_LEN (".aes"), PROCESSOR_UNKNOWN,
674     CPU_AES_FLAGS, 0, 0 },
675   { STRING_COMMA_LEN (".pclmul"), PROCESSOR_UNKNOWN,
676     CPU_PCLMUL_FLAGS, 0, 0 },
677   { STRING_COMMA_LEN (".clmul"), PROCESSOR_UNKNOWN,
678     CPU_PCLMUL_FLAGS, 1, 0 },
679   { STRING_COMMA_LEN (".fsgsbase"), PROCESSOR_UNKNOWN,
680     CPU_FSGSBASE_FLAGS, 0, 0 },
681   { STRING_COMMA_LEN (".rdrnd"), PROCESSOR_UNKNOWN,
682     CPU_RDRND_FLAGS, 0, 0 },
683   { STRING_COMMA_LEN (".f16c"), PROCESSOR_UNKNOWN,
684     CPU_F16C_FLAGS, 0, 0 },
685   { STRING_COMMA_LEN (".fma"), PROCESSOR_UNKNOWN,
686     CPU_FMA_FLAGS, 0, 0 },
687   { STRING_COMMA_LEN (".fma4"), PROCESSOR_UNKNOWN,
688     CPU_FMA4_FLAGS, 0, 0 },
689   { STRING_COMMA_LEN (".xop"), PROCESSOR_UNKNOWN,
690     CPU_XOP_FLAGS, 0, 0 },
691   { STRING_COMMA_LEN (".lwp"), PROCESSOR_UNKNOWN,
692     CPU_LWP_FLAGS, 0, 0 },
693   { STRING_COMMA_LEN (".movbe"), PROCESSOR_UNKNOWN,
694     CPU_MOVBE_FLAGS, 0, 0 },
695   { STRING_COMMA_LEN (".ept"), PROCESSOR_UNKNOWN,
696     CPU_EPT_FLAGS, 0, 0 },
697   { STRING_COMMA_LEN (".clflush"), PROCESSOR_UNKNOWN,
698     CPU_CLFLUSH_FLAGS, 0, 0 },
699   { STRING_COMMA_LEN (".nop"), PROCESSOR_UNKNOWN,
700     CPU_NOP_FLAGS, 0, 0 },
701   { STRING_COMMA_LEN (".syscall"), PROCESSOR_UNKNOWN,
702     CPU_SYSCALL_FLAGS, 0, 0 },
703   { STRING_COMMA_LEN (".rdtscp"), PROCESSOR_UNKNOWN,
704     CPU_RDTSCP_FLAGS, 0, 0 },
705   { STRING_COMMA_LEN (".3dnow"), PROCESSOR_UNKNOWN,
706     CPU_3DNOW_FLAGS, 0, 0 },
707   { STRING_COMMA_LEN (".3dnowa"), PROCESSOR_UNKNOWN,
708     CPU_3DNOWA_FLAGS, 0, 0 },
709   { STRING_COMMA_LEN (".padlock"), PROCESSOR_UNKNOWN,
710     CPU_PADLOCK_FLAGS, 0, 0 },
711   { STRING_COMMA_LEN (".pacifica"), PROCESSOR_UNKNOWN,
712     CPU_SVME_FLAGS, 1, 0 },
713   { STRING_COMMA_LEN (".svme"), PROCESSOR_UNKNOWN,
714     CPU_SVME_FLAGS, 0, 0 },
715   { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN,
716     CPU_SSE4A_FLAGS, 0, 0 },
717   { STRING_COMMA_LEN (".abm"), PROCESSOR_UNKNOWN,
718     CPU_ABM_FLAGS, 0, 0 },
719 };
720
721 #ifdef I386COFF
722 /* Like s_lcomm_internal in gas/read.c but the alignment string
723    is allowed to be optional.  */
724
725 static symbolS *
726 pe_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
727 {
728   addressT align = 0;
729
730   SKIP_WHITESPACE ();
731
732   if (needs_align
733       && *input_line_pointer == ',')
734     {
735       align = parse_align (needs_align - 1);
736
737       if (align == (addressT) -1)
738         return NULL;
739     }
740   else
741     {
742       if (size >= 8)
743         align = 3;
744       else if (size >= 4)
745         align = 2;
746       else if (size >= 2)
747         align = 1;
748       else
749         align = 0;
750     }
751
752   bss_alloc (symbolP, size, align);
753   return symbolP;
754 }
755
756 static void
757 pe_lcomm (int needs_align)
758 {
759   s_comm_internal (needs_align * 2, pe_lcomm_internal);
760 }
761 #endif
762
763 const pseudo_typeS md_pseudo_table[] =
764 {
765 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
766   {"align", s_align_bytes, 0},
767 #else
768   {"align", s_align_ptwo, 0},
769 #endif
770   {"arch", set_cpu_arch, 0},
771 #ifndef I386COFF
772   {"bss", s_bss, 0},
773 #else
774   {"lcomm", pe_lcomm, 1},
775 #endif
776   {"ffloat", float_cons, 'f'},
777   {"dfloat", float_cons, 'd'},
778   {"tfloat", float_cons, 'x'},
779   {"value", cons, 2},
780   {"slong", signed_cons, 4},
781   {"noopt", s_ignore, 0},
782   {"optim", s_ignore, 0},
783   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
784   {"code16", set_code_flag, CODE_16BIT},
785   {"code32", set_code_flag, CODE_32BIT},
786   {"code64", set_code_flag, CODE_64BIT},
787   {"intel_syntax", set_intel_syntax, 1},
788   {"att_syntax", set_intel_syntax, 0},
789   {"intel_mnemonic", set_intel_mnemonic, 1},
790   {"att_mnemonic", set_intel_mnemonic, 0},
791   {"allow_index_reg", set_allow_index_reg, 1},
792   {"disallow_index_reg", set_allow_index_reg, 0},
793   {"sse_check", set_sse_check, 0},
794 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
795   {"largecomm", handle_large_common, 0},
796 #else
797   {"file", (void (*) (int)) dwarf2_directive_file, 0},
798   {"loc", dwarf2_directive_loc, 0},
799   {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
800 #endif
801 #ifdef TE_PE
802   {"secrel32", pe_directive_secrel, 0},
803 #endif
804   {0, 0, 0}
805 };
806
807 /* For interface with expression ().  */
808 extern char *input_line_pointer;
809
810 /* Hash table for instruction mnemonic lookup.  */
811 static struct hash_control *op_hash;
812
813 /* Hash table for register lookup.  */
814 static struct hash_control *reg_hash;
815 \f
816 void
817 i386_align_code (fragS *fragP, int count)
818 {
819   /* Various efficient no-op patterns for aligning code labels.
820      Note: Don't try to assemble the instructions in the comments.
821      0L and 0w are not legal.  */
822   static const char f32_1[] =
823     {0x90};                                     /* nop                  */
824   static const char f32_2[] =
825     {0x66,0x90};                                /* xchg %ax,%ax */
826   static const char f32_3[] =
827     {0x8d,0x76,0x00};                           /* leal 0(%esi),%esi    */
828   static const char f32_4[] =
829     {0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
830   static const char f32_5[] =
831     {0x90,                                      /* nop                  */
832      0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
833   static const char f32_6[] =
834     {0x8d,0xb6,0x00,0x00,0x00,0x00};            /* leal 0L(%esi),%esi   */
835   static const char f32_7[] =
836     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
837   static const char f32_8[] =
838     {0x90,                                      /* nop                  */
839      0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
840   static const char f32_9[] =
841     {0x89,0xf6,                                 /* movl %esi,%esi       */
842      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
843   static const char f32_10[] =
844     {0x8d,0x76,0x00,                            /* leal 0(%esi),%esi    */
845      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
846   static const char f32_11[] =
847     {0x8d,0x74,0x26,0x00,                       /* leal 0(%esi,1),%esi  */
848      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
849   static const char f32_12[] =
850     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
851      0x8d,0xbf,0x00,0x00,0x00,0x00};            /* leal 0L(%edi),%edi   */
852   static const char f32_13[] =
853     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
854      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
855   static const char f32_14[] =
856     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00,        /* leal 0L(%esi,1),%esi */
857      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
858   static const char f16_3[] =
859     {0x8d,0x74,0x00};                           /* lea 0(%esi),%esi     */
860   static const char f16_4[] =
861     {0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
862   static const char f16_5[] =
863     {0x90,                                      /* nop                  */
864      0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
865   static const char f16_6[] =
866     {0x89,0xf6,                                 /* mov %si,%si          */
867      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
868   static const char f16_7[] =
869     {0x8d,0x74,0x00,                            /* lea 0(%si),%si       */
870      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
871   static const char f16_8[] =
872     {0x8d,0xb4,0x00,0x00,                       /* lea 0w(%si),%si      */
873      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
874   static const char jump_31[] =
875     {0xeb,0x1d,0x90,0x90,0x90,0x90,0x90,        /* jmp .+31; lotsa nops */
876      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
877      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
878      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
879   static const char *const f32_patt[] = {
880     f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
881     f32_9, f32_10, f32_11, f32_12, f32_13, f32_14
882   };
883   static const char *const f16_patt[] = {
884     f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8
885   };
886   /* nopl (%[re]ax) */
887   static const char alt_3[] =
888     {0x0f,0x1f,0x00};
889   /* nopl 0(%[re]ax) */
890   static const char alt_4[] =
891     {0x0f,0x1f,0x40,0x00};
892   /* nopl 0(%[re]ax,%[re]ax,1) */
893   static const char alt_5[] =
894     {0x0f,0x1f,0x44,0x00,0x00};
895   /* nopw 0(%[re]ax,%[re]ax,1) */
896   static const char alt_6[] =
897     {0x66,0x0f,0x1f,0x44,0x00,0x00};
898   /* nopl 0L(%[re]ax) */
899   static const char alt_7[] =
900     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
901   /* nopl 0L(%[re]ax,%[re]ax,1) */
902   static const char alt_8[] =
903     {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
904   /* nopw 0L(%[re]ax,%[re]ax,1) */
905   static const char alt_9[] =
906     {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
907   /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
908   static const char alt_10[] =
909     {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
910   /* data16
911      nopw %cs:0L(%[re]ax,%[re]ax,1) */
912   static const char alt_long_11[] =
913     {0x66,
914      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
915   /* data16
916      data16
917      nopw %cs:0L(%[re]ax,%[re]ax,1) */
918   static const char alt_long_12[] =
919     {0x66,
920      0x66,
921      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
922   /* data16
923      data16
924      data16
925      nopw %cs:0L(%[re]ax,%[re]ax,1) */
926   static const char alt_long_13[] =
927     {0x66,
928      0x66,
929      0x66,
930      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
931   /* data16
932      data16
933      data16
934      data16
935      nopw %cs:0L(%[re]ax,%[re]ax,1) */
936   static const char alt_long_14[] =
937     {0x66,
938      0x66,
939      0x66,
940      0x66,
941      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
942   /* data16
943      data16
944      data16
945      data16
946      data16
947      nopw %cs:0L(%[re]ax,%[re]ax,1) */
948   static const char alt_long_15[] =
949     {0x66,
950      0x66,
951      0x66,
952      0x66,
953      0x66,
954      0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
955   /* nopl 0(%[re]ax,%[re]ax,1)
956      nopw 0(%[re]ax,%[re]ax,1) */
957   static const char alt_short_11[] =
958     {0x0f,0x1f,0x44,0x00,0x00,
959      0x66,0x0f,0x1f,0x44,0x00,0x00};
960   /* nopw 0(%[re]ax,%[re]ax,1)
961      nopw 0(%[re]ax,%[re]ax,1) */
962   static const char alt_short_12[] =
963     {0x66,0x0f,0x1f,0x44,0x00,0x00,
964      0x66,0x0f,0x1f,0x44,0x00,0x00};
965   /* nopw 0(%[re]ax,%[re]ax,1)
966      nopl 0L(%[re]ax) */
967   static const char alt_short_13[] =
968     {0x66,0x0f,0x1f,0x44,0x00,0x00,
969      0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
970   /* nopl 0L(%[re]ax)
971      nopl 0L(%[re]ax) */
972   static const char alt_short_14[] =
973     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
974      0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
975   /* nopl 0L(%[re]ax)
976      nopl 0L(%[re]ax,%[re]ax,1) */
977   static const char alt_short_15[] =
978     {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
979      0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
980   static const char *const alt_short_patt[] = {
981     f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
982     alt_9, alt_10, alt_short_11, alt_short_12, alt_short_13,
983     alt_short_14, alt_short_15
984   };
985   static const char *const alt_long_patt[] = {
986     f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
987     alt_9, alt_10, alt_long_11, alt_long_12, alt_long_13,
988     alt_long_14, alt_long_15
989   };
990
991   /* Only align for at least a positive non-zero boundary. */
992   if (count <= 0 || count > MAX_MEM_FOR_RS_ALIGN_CODE)
993     return;
994
995   /* We need to decide which NOP sequence to use for 32bit and
996      64bit. When -mtune= is used:
997
998      1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
999      PROCESSOR_GENERIC32, f32_patt will be used.
1000      2. For PROCESSOR_PENTIUMPRO, PROCESSOR_PENTIUM4, PROCESSOR_NOCONA,
1001      PROCESSOR_CORE, PROCESSOR_CORE2, PROCESSOR_COREI7, and
1002      PROCESSOR_GENERIC64, alt_long_patt will be used.
1003      3. For PROCESSOR_ATHLON, PROCESSOR_K6, PROCESSOR_K8 and
1004      PROCESSOR_AMDFAM10, and PROCESSOR_BDVER1, alt_short_patt
1005      will be used.
1006
1007      When -mtune= isn't used, alt_long_patt will be used if
1008      cpu_arch_isa_flags has CpuNop.  Otherwise, f32_patt will
1009      be used.
1010
1011      When -march= or .arch is used, we can't use anything beyond
1012      cpu_arch_isa_flags.   */
1013
1014   if (flag_code == CODE_16BIT)
1015     {
1016       if (count > 8)
1017         {
1018           memcpy (fragP->fr_literal + fragP->fr_fix,
1019                   jump_31, count);
1020           /* Adjust jump offset.  */
1021           fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
1022         }
1023       else
1024         memcpy (fragP->fr_literal + fragP->fr_fix,
1025                 f16_patt[count - 1], count);
1026     }
1027   else
1028     {
1029       const char *const *patt = NULL;
1030
1031       if (fragP->tc_frag_data.isa == PROCESSOR_UNKNOWN)
1032         {
1033           /* PROCESSOR_UNKNOWN means that all ISAs may be used.  */
1034           switch (cpu_arch_tune)
1035             {
1036             case PROCESSOR_UNKNOWN:
1037               /* We use cpu_arch_isa_flags to check if we SHOULD
1038                  optimize with nops.  */
1039               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1040                 patt = alt_long_patt;
1041               else
1042                 patt = f32_patt;
1043               break;
1044             case PROCESSOR_PENTIUM4:
1045             case PROCESSOR_NOCONA:
1046             case PROCESSOR_CORE:
1047             case PROCESSOR_CORE2:
1048             case PROCESSOR_COREI7:
1049             case PROCESSOR_L1OM:
1050             case PROCESSOR_GENERIC64:
1051               patt = alt_long_patt;
1052               break;
1053             case PROCESSOR_K6:
1054             case PROCESSOR_ATHLON:
1055             case PROCESSOR_K8:
1056             case PROCESSOR_AMDFAM10:
1057             case PROCESSOR_BDVER1:
1058               patt = alt_short_patt;
1059               break;
1060             case PROCESSOR_I386:
1061             case PROCESSOR_I486:
1062             case PROCESSOR_PENTIUM:
1063             case PROCESSOR_PENTIUMPRO:
1064             case PROCESSOR_GENERIC32:
1065               patt = f32_patt;
1066               break;
1067             }
1068         }
1069       else
1070         {
1071           switch (fragP->tc_frag_data.tune)
1072             {
1073             case PROCESSOR_UNKNOWN:
1074               /* When cpu_arch_isa is set, cpu_arch_tune shouldn't be
1075                  PROCESSOR_UNKNOWN.  */
1076               abort ();
1077               break;
1078
1079             case PROCESSOR_I386:
1080             case PROCESSOR_I486:
1081             case PROCESSOR_PENTIUM:
1082             case PROCESSOR_K6:
1083             case PROCESSOR_ATHLON:
1084             case PROCESSOR_K8:
1085             case PROCESSOR_AMDFAM10:
1086             case PROCESSOR_BDVER1:
1087             case PROCESSOR_GENERIC32:
1088               /* We use cpu_arch_isa_flags to check if we CAN optimize
1089                  with nops.  */
1090               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1091                 patt = alt_short_patt;
1092               else
1093                 patt = f32_patt;
1094               break;
1095             case PROCESSOR_PENTIUMPRO:
1096             case PROCESSOR_PENTIUM4:
1097             case PROCESSOR_NOCONA:
1098             case PROCESSOR_CORE:
1099             case PROCESSOR_CORE2:
1100             case PROCESSOR_COREI7:
1101             case PROCESSOR_L1OM:
1102               if (fragP->tc_frag_data.isa_flags.bitfield.cpunop)
1103                 patt = alt_long_patt;
1104               else
1105                 patt = f32_patt;
1106               break;
1107             case PROCESSOR_GENERIC64:
1108               patt = alt_long_patt;
1109               break;
1110             }
1111         }
1112
1113       if (patt == f32_patt)
1114         {
1115           /* If the padding is less than 15 bytes, we use the normal
1116              ones.  Otherwise, we use a jump instruction and adjust
1117              its offset.   */
1118           int limit;
1119
1120           /* For 64bit, the limit is 3 bytes.  */
1121           if (flag_code == CODE_64BIT
1122               && fragP->tc_frag_data.isa_flags.bitfield.cpulm)
1123             limit = 3;
1124           else
1125             limit = 15;
1126           if (count < limit)
1127             memcpy (fragP->fr_literal + fragP->fr_fix,
1128                     patt[count - 1], count);
1129           else
1130             {
1131               memcpy (fragP->fr_literal + fragP->fr_fix,
1132                       jump_31, count);
1133               /* Adjust jump offset.  */
1134               fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
1135             }
1136         }
1137       else
1138         {
1139           /* Maximum length of an instruction is 15 byte.  If the
1140              padding is greater than 15 bytes and we don't use jump,
1141              we have to break it into smaller pieces.  */
1142           int padding = count;
1143           while (padding > 15)
1144             {
1145               padding -= 15;
1146               memcpy (fragP->fr_literal + fragP->fr_fix + padding,
1147                       patt [14], 15);
1148             }
1149
1150           if (padding)
1151             memcpy (fragP->fr_literal + fragP->fr_fix,
1152                     patt [padding - 1], padding);
1153         }
1154     }
1155   fragP->fr_var = count;
1156 }
1157
1158 static INLINE int
1159 operand_type_all_zero (const union i386_operand_type *x)
1160 {
1161   switch (ARRAY_SIZE(x->array))
1162     {
1163     case 3:
1164       if (x->array[2])
1165         return 0;
1166     case 2:
1167       if (x->array[1])
1168         return 0;
1169     case 1:
1170       return !x->array[0];
1171     default:
1172       abort ();
1173     }
1174 }
1175
1176 static INLINE void
1177 operand_type_set (union i386_operand_type *x, unsigned int v)
1178 {
1179   switch (ARRAY_SIZE(x->array))
1180     {
1181     case 3:
1182       x->array[2] = v;
1183     case 2:
1184       x->array[1] = v;
1185     case 1:
1186       x->array[0] = v;
1187       break;
1188     default:
1189       abort ();
1190     }
1191 }
1192
1193 static INLINE int
1194 operand_type_equal (const union i386_operand_type *x,
1195                     const union i386_operand_type *y)
1196 {
1197   switch (ARRAY_SIZE(x->array))
1198     {
1199     case 3:
1200       if (x->array[2] != y->array[2])
1201         return 0;
1202     case 2:
1203       if (x->array[1] != y->array[1])
1204         return 0;
1205     case 1:
1206       return x->array[0] == y->array[0];
1207       break;
1208     default:
1209       abort ();
1210     }
1211 }
1212
1213 static INLINE int
1214 cpu_flags_all_zero (const union i386_cpu_flags *x)
1215 {
1216   switch (ARRAY_SIZE(x->array))
1217     {
1218     case 3:
1219       if (x->array[2])
1220         return 0;
1221     case 2:
1222       if (x->array[1])
1223         return 0;
1224     case 1:
1225       return !x->array[0];
1226     default:
1227       abort ();
1228     }
1229 }
1230
1231 static INLINE void
1232 cpu_flags_set (union i386_cpu_flags *x, unsigned int v)
1233 {
1234   switch (ARRAY_SIZE(x->array))
1235     {
1236     case 3:
1237       x->array[2] = v;
1238     case 2:
1239       x->array[1] = v;
1240     case 1:
1241       x->array[0] = v;
1242       break;
1243     default:
1244       abort ();
1245     }
1246 }
1247
1248 static INLINE int
1249 cpu_flags_equal (const union i386_cpu_flags *x,
1250                  const union i386_cpu_flags *y)
1251 {
1252   switch (ARRAY_SIZE(x->array))
1253     {
1254     case 3:
1255       if (x->array[2] != y->array[2])
1256         return 0;
1257     case 2:
1258       if (x->array[1] != y->array[1])
1259         return 0;
1260     case 1:
1261       return x->array[0] == y->array[0];
1262       break;
1263     default:
1264       abort ();
1265     }
1266 }
1267
1268 static INLINE int
1269 cpu_flags_check_cpu64 (i386_cpu_flags f)
1270 {
1271   return !((flag_code == CODE_64BIT && f.bitfield.cpuno64)
1272            || (flag_code != CODE_64BIT && f.bitfield.cpu64));
1273 }
1274
1275 static INLINE i386_cpu_flags
1276 cpu_flags_and (i386_cpu_flags x, i386_cpu_flags y)
1277 {
1278   switch (ARRAY_SIZE (x.array))
1279     {
1280     case 3:
1281       x.array [2] &= y.array [2];
1282     case 2:
1283       x.array [1] &= y.array [1];
1284     case 1:
1285       x.array [0] &= y.array [0];
1286       break;
1287     default:
1288       abort ();
1289     }
1290   return x;
1291 }
1292
1293 static INLINE i386_cpu_flags
1294 cpu_flags_or (i386_cpu_flags x, i386_cpu_flags y)
1295 {
1296   switch (ARRAY_SIZE (x.array))
1297     {
1298     case 3:
1299       x.array [2] |= y.array [2];
1300     case 2:
1301       x.array [1] |= y.array [1];
1302     case 1:
1303       x.array [0] |= y.array [0];
1304       break;
1305     default:
1306       abort ();
1307     }
1308   return x;
1309 }
1310
1311 static INLINE i386_cpu_flags
1312 cpu_flags_and_not (i386_cpu_flags x, i386_cpu_flags y)
1313 {
1314   switch (ARRAY_SIZE (x.array))
1315     {
1316     case 3:
1317       x.array [2] &= ~y.array [2];
1318     case 2:
1319       x.array [1] &= ~y.array [1];
1320     case 1:
1321       x.array [0] &= ~y.array [0];
1322       break;
1323     default:
1324       abort ();
1325     }
1326   return x;
1327 }
1328
1329 #define CPU_FLAGS_ARCH_MATCH            0x1
1330 #define CPU_FLAGS_64BIT_MATCH           0x2
1331 #define CPU_FLAGS_AES_MATCH             0x4
1332 #define CPU_FLAGS_PCLMUL_MATCH          0x8
1333 #define CPU_FLAGS_AVX_MATCH            0x10
1334
1335 #define CPU_FLAGS_32BIT_MATCH \
1336   (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_AES_MATCH \
1337    | CPU_FLAGS_PCLMUL_MATCH | CPU_FLAGS_AVX_MATCH)
1338 #define CPU_FLAGS_PERFECT_MATCH \
1339   (CPU_FLAGS_32BIT_MATCH | CPU_FLAGS_64BIT_MATCH)
1340
1341 /* Return CPU flags match bits. */
1342
1343 static int
1344 cpu_flags_match (const insn_template *t)
1345 {
1346   i386_cpu_flags x = t->cpu_flags;
1347   int match = cpu_flags_check_cpu64 (x) ? CPU_FLAGS_64BIT_MATCH : 0;
1348
1349   x.bitfield.cpu64 = 0;
1350   x.bitfield.cpuno64 = 0;
1351
1352   if (cpu_flags_all_zero (&x))
1353     {
1354       /* This instruction is available on all archs.  */
1355       match |= CPU_FLAGS_32BIT_MATCH;
1356     }
1357   else
1358     {
1359       /* This instruction is available only on some archs.  */
1360       i386_cpu_flags cpu = cpu_arch_flags;
1361
1362       cpu.bitfield.cpu64 = 0;
1363       cpu.bitfield.cpuno64 = 0;
1364       cpu = cpu_flags_and (x, cpu);
1365       if (!cpu_flags_all_zero (&cpu))
1366         {
1367           if (x.bitfield.cpuavx)
1368             {
1369               /* We only need to check AES/PCLMUL/SSE2AVX with AVX.  */
1370               if (cpu.bitfield.cpuavx)
1371                 {
1372                   /* Check SSE2AVX.  */
1373                   if (!t->opcode_modifier.sse2avx|| sse2avx)
1374                     {
1375                       match |= (CPU_FLAGS_ARCH_MATCH
1376                                 | CPU_FLAGS_AVX_MATCH);
1377                       /* Check AES.  */
1378                       if (!x.bitfield.cpuaes || cpu.bitfield.cpuaes)
1379                         match |= CPU_FLAGS_AES_MATCH;
1380                       /* Check PCLMUL.  */
1381                       if (!x.bitfield.cpupclmul
1382                           || cpu.bitfield.cpupclmul)
1383                         match |= CPU_FLAGS_PCLMUL_MATCH;
1384                     }
1385                 }
1386               else
1387                 match |= CPU_FLAGS_ARCH_MATCH;
1388             }
1389           else
1390             match |= CPU_FLAGS_32BIT_MATCH;
1391         }
1392     }
1393   return match;
1394 }
1395
1396 static INLINE i386_operand_type
1397 operand_type_and (i386_operand_type x, i386_operand_type y)
1398 {
1399   switch (ARRAY_SIZE (x.array))
1400     {
1401     case 3:
1402       x.array [2] &= y.array [2];
1403     case 2:
1404       x.array [1] &= y.array [1];
1405     case 1:
1406       x.array [0] &= y.array [0];
1407       break;
1408     default:
1409       abort ();
1410     }
1411   return x;
1412 }
1413
1414 static INLINE i386_operand_type
1415 operand_type_or (i386_operand_type x, i386_operand_type y)
1416 {
1417   switch (ARRAY_SIZE (x.array))
1418     {
1419     case 3:
1420       x.array [2] |= y.array [2];
1421     case 2:
1422       x.array [1] |= y.array [1];
1423     case 1:
1424       x.array [0] |= y.array [0];
1425       break;
1426     default:
1427       abort ();
1428     }
1429   return x;
1430 }
1431
1432 static INLINE i386_operand_type
1433 operand_type_xor (i386_operand_type x, i386_operand_type y)
1434 {
1435   switch (ARRAY_SIZE (x.array))
1436     {
1437     case 3:
1438       x.array [2] ^= y.array [2];
1439     case 2:
1440       x.array [1] ^= y.array [1];
1441     case 1:
1442       x.array [0] ^= y.array [0];
1443       break;
1444     default:
1445       abort ();
1446     }
1447   return x;
1448 }
1449
1450 static const i386_operand_type acc32 = OPERAND_TYPE_ACC32;
1451 static const i386_operand_type acc64 = OPERAND_TYPE_ACC64;
1452 static const i386_operand_type control = OPERAND_TYPE_CONTROL;
1453 static const i386_operand_type inoutportreg
1454   = OPERAND_TYPE_INOUTPORTREG;
1455 static const i386_operand_type reg16_inoutportreg
1456   = OPERAND_TYPE_REG16_INOUTPORTREG;
1457 static const i386_operand_type disp16 = OPERAND_TYPE_DISP16;
1458 static const i386_operand_type disp32 = OPERAND_TYPE_DISP32;
1459 static const i386_operand_type disp32s = OPERAND_TYPE_DISP32S;
1460 static const i386_operand_type disp16_32 = OPERAND_TYPE_DISP16_32;
1461 static const i386_operand_type anydisp
1462   = OPERAND_TYPE_ANYDISP;
1463 static const i386_operand_type regxmm = OPERAND_TYPE_REGXMM;
1464 static const i386_operand_type regymm = OPERAND_TYPE_REGYMM;
1465 static const i386_operand_type imm8 = OPERAND_TYPE_IMM8;
1466 static const i386_operand_type imm8s = OPERAND_TYPE_IMM8S;
1467 static const i386_operand_type imm16 = OPERAND_TYPE_IMM16;
1468 static const i386_operand_type imm32 = OPERAND_TYPE_IMM32;
1469 static const i386_operand_type imm32s = OPERAND_TYPE_IMM32S;
1470 static const i386_operand_type imm64 = OPERAND_TYPE_IMM64;
1471 static const i386_operand_type imm16_32 = OPERAND_TYPE_IMM16_32;
1472 static const i386_operand_type imm16_32s = OPERAND_TYPE_IMM16_32S;
1473 static const i386_operand_type imm16_32_32s = OPERAND_TYPE_IMM16_32_32S;
1474 static const i386_operand_type vec_imm4 = OPERAND_TYPE_VEC_IMM4;
1475
1476 enum operand_type
1477 {
1478   reg,
1479   imm,
1480   disp,
1481   anymem
1482 };
1483
1484 static INLINE int
1485 operand_type_check (i386_operand_type t, enum operand_type c)
1486 {
1487   switch (c)
1488     {
1489     case reg:
1490       return (t.bitfield.reg8
1491               || t.bitfield.reg16
1492               || t.bitfield.reg32
1493               || t.bitfield.reg64);
1494
1495     case imm:
1496       return (t.bitfield.imm8
1497               || t.bitfield.imm8s
1498               || t.bitfield.imm16
1499               || t.bitfield.imm32
1500               || t.bitfield.imm32s
1501               || t.bitfield.imm64);
1502
1503     case disp:
1504       return (t.bitfield.disp8
1505               || t.bitfield.disp16
1506               || t.bitfield.disp32
1507               || t.bitfield.disp32s
1508               || t.bitfield.disp64);
1509
1510     case anymem:
1511       return (t.bitfield.disp8
1512               || t.bitfield.disp16
1513               || t.bitfield.disp32
1514               || t.bitfield.disp32s
1515               || t.bitfield.disp64
1516               || t.bitfield.baseindex);
1517
1518     default:
1519       abort ();
1520     }
1521
1522   return 0;
1523 }
1524
1525 /* Return 1 if there is no conflict in 8bit/16bit/32bit/64bit on
1526    operand J for instruction template T.  */
1527
1528 static INLINE int
1529 match_reg_size (const insn_template *t, unsigned int j)
1530 {
1531   return !((i.types[j].bitfield.byte
1532             && !t->operand_types[j].bitfield.byte)
1533            || (i.types[j].bitfield.word
1534                && !t->operand_types[j].bitfield.word)
1535            || (i.types[j].bitfield.dword
1536                && !t->operand_types[j].bitfield.dword)
1537            || (i.types[j].bitfield.qword
1538                && !t->operand_types[j].bitfield.qword));
1539 }
1540
1541 /* Return 1 if there is no conflict in any size on operand J for
1542    instruction template T.  */
1543
1544 static INLINE int
1545 match_mem_size (const insn_template *t, unsigned int j)
1546 {
1547   return (match_reg_size (t, j)
1548           && !((i.types[j].bitfield.unspecified
1549                 && !t->operand_types[j].bitfield.unspecified)
1550                || (i.types[j].bitfield.fword
1551                    && !t->operand_types[j].bitfield.fword)
1552                || (i.types[j].bitfield.tbyte
1553                    && !t->operand_types[j].bitfield.tbyte)
1554                || (i.types[j].bitfield.xmmword
1555                    && !t->operand_types[j].bitfield.xmmword)
1556                || (i.types[j].bitfield.ymmword
1557                    && !t->operand_types[j].bitfield.ymmword)));
1558 }
1559
1560 /* Return 1 if there is no size conflict on any operands for
1561    instruction template T.  */
1562
1563 static INLINE int
1564 operand_size_match (const insn_template *t)
1565 {
1566   unsigned int j;
1567   int match = 1;
1568
1569   /* Don't check jump instructions.  */
1570   if (t->opcode_modifier.jump
1571       || t->opcode_modifier.jumpbyte
1572       || t->opcode_modifier.jumpdword
1573       || t->opcode_modifier.jumpintersegment)
1574     return match;
1575
1576   /* Check memory and accumulator operand size.  */
1577   for (j = 0; j < i.operands; j++)
1578     {
1579       if (t->operand_types[j].bitfield.anysize)
1580         continue;
1581
1582       if (t->operand_types[j].bitfield.acc && !match_reg_size (t, j))
1583         {
1584           match = 0;
1585           break;
1586         }
1587
1588       if (i.types[j].bitfield.mem && !match_mem_size (t, j))
1589         {
1590           match = 0;
1591           break;
1592         }
1593     }
1594
1595   if (match)
1596     return match;
1597   else if (!t->opcode_modifier.d && !t->opcode_modifier.floatd)
1598     {
1599 mismatch:
1600       i.error = operand_size_mismatch;
1601       return 0;
1602     }
1603
1604   /* Check reverse.  */
1605   gas_assert (i.operands == 2);
1606
1607   match = 1;
1608   for (j = 0; j < 2; j++)
1609     {
1610       if (t->operand_types[j].bitfield.acc
1611           && !match_reg_size (t, j ? 0 : 1))
1612         goto mismatch;
1613
1614       if (i.types[j].bitfield.mem
1615           && !match_mem_size (t, j ? 0 : 1))
1616         goto mismatch;
1617     }
1618
1619   return match;
1620 }
1621
1622 static INLINE int
1623 operand_type_match (i386_operand_type overlap,
1624                     i386_operand_type given)
1625 {
1626   i386_operand_type temp = overlap;
1627
1628   temp.bitfield.jumpabsolute = 0;
1629   temp.bitfield.unspecified = 0;
1630   temp.bitfield.byte = 0;
1631   temp.bitfield.word = 0;
1632   temp.bitfield.dword = 0;
1633   temp.bitfield.fword = 0;
1634   temp.bitfield.qword = 0;
1635   temp.bitfield.tbyte = 0;
1636   temp.bitfield.xmmword = 0;
1637   temp.bitfield.ymmword = 0;
1638   if (operand_type_all_zero (&temp))
1639     goto mismatch;
1640
1641   if (given.bitfield.baseindex == overlap.bitfield.baseindex
1642       && given.bitfield.jumpabsolute == overlap.bitfield.jumpabsolute)
1643     return 1;
1644
1645 mismatch:
1646   i.error = operand_type_mismatch;
1647   return 0;
1648 }
1649
1650 /* If given types g0 and g1 are registers they must be of the same type
1651    unless the expected operand type register overlap is null.
1652    Note that Acc in a template matches every size of reg.  */
1653
1654 static INLINE int
1655 operand_type_register_match (i386_operand_type m0,
1656                              i386_operand_type g0,
1657                              i386_operand_type t0,
1658                              i386_operand_type m1,
1659                              i386_operand_type g1,
1660                              i386_operand_type t1)
1661 {
1662   if (!operand_type_check (g0, reg))
1663     return 1;
1664
1665   if (!operand_type_check (g1, reg))
1666     return 1;
1667
1668   if (g0.bitfield.reg8 == g1.bitfield.reg8
1669       && g0.bitfield.reg16 == g1.bitfield.reg16
1670       && g0.bitfield.reg32 == g1.bitfield.reg32
1671       && g0.bitfield.reg64 == g1.bitfield.reg64)
1672     return 1;
1673
1674   if (m0.bitfield.acc)
1675     {
1676       t0.bitfield.reg8 = 1;
1677       t0.bitfield.reg16 = 1;
1678       t0.bitfield.reg32 = 1;
1679       t0.bitfield.reg64 = 1;
1680     }
1681
1682   if (m1.bitfield.acc)
1683     {
1684       t1.bitfield.reg8 = 1;
1685       t1.bitfield.reg16 = 1;
1686       t1.bitfield.reg32 = 1;
1687       t1.bitfield.reg64 = 1;
1688     }
1689
1690   if (!(t0.bitfield.reg8 & t1.bitfield.reg8)
1691       && !(t0.bitfield.reg16 & t1.bitfield.reg16)
1692       && !(t0.bitfield.reg32 & t1.bitfield.reg32)
1693       && !(t0.bitfield.reg64 & t1.bitfield.reg64))
1694     return 1;
1695
1696   i.error = register_type_mismatch;
1697
1698   return 0;
1699 }
1700
1701 static INLINE unsigned int
1702 mode_from_disp_size (i386_operand_type t)
1703 {
1704   if (t.bitfield.disp8)
1705     return 1;
1706   else if (t.bitfield.disp16
1707            || t.bitfield.disp32
1708            || t.bitfield.disp32s)
1709     return 2;
1710   else
1711     return 0;
1712 }
1713
1714 static INLINE int
1715 fits_in_signed_byte (offsetT num)
1716 {
1717   return (num >= -128) && (num <= 127);
1718 }
1719
1720 static INLINE int
1721 fits_in_unsigned_byte (offsetT num)
1722 {
1723   return (num & 0xff) == num;
1724 }
1725
1726 static INLINE int
1727 fits_in_unsigned_word (offsetT num)
1728 {
1729   return (num & 0xffff) == num;
1730 }
1731
1732 static INLINE int
1733 fits_in_signed_word (offsetT num)
1734 {
1735   return (-32768 <= num) && (num <= 32767);
1736 }
1737
1738 static INLINE int
1739 fits_in_signed_long (offsetT num ATTRIBUTE_UNUSED)
1740 {
1741 #ifndef BFD64
1742   return 1;
1743 #else
1744   return (!(((offsetT) -1 << 31) & num)
1745           || (((offsetT) -1 << 31) & num) == ((offsetT) -1 << 31));
1746 #endif
1747 }                               /* fits_in_signed_long() */
1748
1749 static INLINE int
1750 fits_in_unsigned_long (offsetT num ATTRIBUTE_UNUSED)
1751 {
1752 #ifndef BFD64
1753   return 1;
1754 #else
1755   return (num & (((offsetT) 2 << 31) - 1)) == num;
1756 #endif
1757 }                               /* fits_in_unsigned_long() */
1758
1759 static INLINE int
1760 fits_in_imm4 (offsetT num)
1761 {
1762   return (num & 0xf) == num;
1763 }
1764
1765 static i386_operand_type
1766 smallest_imm_type (offsetT num)
1767 {
1768   i386_operand_type t;
1769
1770   operand_type_set (&t, 0);
1771   t.bitfield.imm64 = 1;
1772
1773   if (cpu_arch_tune != PROCESSOR_I486 && num == 1)
1774     {
1775       /* This code is disabled on the 486 because all the Imm1 forms
1776          in the opcode table are slower on the i486.  They're the
1777          versions with the implicitly specified single-position
1778          displacement, which has another syntax if you really want to
1779          use that form.  */
1780       t.bitfield.imm1 = 1;
1781       t.bitfield.imm8 = 1;
1782       t.bitfield.imm8s = 1;
1783       t.bitfield.imm16 = 1;
1784       t.bitfield.imm32 = 1;
1785       t.bitfield.imm32s = 1;
1786     }
1787   else if (fits_in_signed_byte (num))
1788     {
1789       t.bitfield.imm8 = 1;
1790       t.bitfield.imm8s = 1;
1791       t.bitfield.imm16 = 1;
1792       t.bitfield.imm32 = 1;
1793       t.bitfield.imm32s = 1;
1794     }
1795   else if (fits_in_unsigned_byte (num))
1796     {
1797       t.bitfield.imm8 = 1;
1798       t.bitfield.imm16 = 1;
1799       t.bitfield.imm32 = 1;
1800       t.bitfield.imm32s = 1;
1801     }
1802   else if (fits_in_signed_word (num) || fits_in_unsigned_word (num))
1803     {
1804       t.bitfield.imm16 = 1;
1805       t.bitfield.imm32 = 1;
1806       t.bitfield.imm32s = 1;
1807     }
1808   else if (fits_in_signed_long (num))
1809     {
1810       t.bitfield.imm32 = 1;
1811       t.bitfield.imm32s = 1;
1812     }
1813   else if (fits_in_unsigned_long (num))
1814     t.bitfield.imm32 = 1;
1815
1816   return t;
1817 }
1818
1819 static offsetT
1820 offset_in_range (offsetT val, int size)
1821 {
1822   addressT mask;
1823
1824   switch (size)
1825     {
1826     case 1: mask = ((addressT) 1 <<  8) - 1; break;
1827     case 2: mask = ((addressT) 1 << 16) - 1; break;
1828     case 4: mask = ((addressT) 2 << 31) - 1; break;
1829 #ifdef BFD64
1830     case 8: mask = ((addressT) 2 << 63) - 1; break;
1831 #endif
1832     default: abort ();
1833     }
1834
1835 #ifdef BFD64
1836   /* If BFD64, sign extend val for 32bit address mode.  */
1837   if (flag_code != CODE_64BIT
1838       || i.prefix[ADDR_PREFIX])
1839     if ((val & ~(((addressT) 2 << 31) - 1)) == 0)
1840       val = (val ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
1841 #endif
1842
1843   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
1844     {
1845       char buf1[40], buf2[40];
1846
1847       sprint_value (buf1, val);
1848       sprint_value (buf2, val & mask);
1849       as_warn (_("%s shortened to %s"), buf1, buf2);
1850     }
1851   return val & mask;
1852 }
1853
1854 enum PREFIX_GROUP
1855 {
1856   PREFIX_EXIST = 0,
1857   PREFIX_LOCK,
1858   PREFIX_REP,
1859   PREFIX_OTHER
1860 };
1861
1862 /* Returns
1863    a. PREFIX_EXIST if attempting to add a prefix where one from the
1864    same class already exists.
1865    b. PREFIX_LOCK if lock prefix is added.
1866    c. PREFIX_REP if rep/repne prefix is added.
1867    d. PREFIX_OTHER if other prefix is added.
1868  */
1869
1870 static enum PREFIX_GROUP
1871 add_prefix (unsigned int prefix)
1872 {
1873   enum PREFIX_GROUP ret = PREFIX_OTHER;
1874   unsigned int q;
1875
1876   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
1877       && flag_code == CODE_64BIT)
1878     {
1879       if ((i.prefix[REX_PREFIX] & prefix & REX_W)
1880           || ((i.prefix[REX_PREFIX] & (REX_R | REX_X | REX_B))
1881               && (prefix & (REX_R | REX_X | REX_B))))
1882         ret = PREFIX_EXIST;
1883       q = REX_PREFIX;
1884     }
1885   else
1886     {
1887       switch (prefix)
1888         {
1889         default:
1890           abort ();
1891
1892         case CS_PREFIX_OPCODE:
1893         case DS_PREFIX_OPCODE:
1894         case ES_PREFIX_OPCODE:
1895         case FS_PREFIX_OPCODE:
1896         case GS_PREFIX_OPCODE:
1897         case SS_PREFIX_OPCODE:
1898           q = SEG_PREFIX;
1899           break;
1900
1901         case REPNE_PREFIX_OPCODE:
1902         case REPE_PREFIX_OPCODE:
1903           q = REP_PREFIX;
1904           ret = PREFIX_REP;
1905           break;
1906
1907         case LOCK_PREFIX_OPCODE:
1908           q = LOCK_PREFIX;
1909           ret = PREFIX_LOCK;
1910           break;
1911
1912         case FWAIT_OPCODE:
1913           q = WAIT_PREFIX;
1914           break;
1915
1916         case ADDR_PREFIX_OPCODE:
1917           q = ADDR_PREFIX;
1918           break;
1919
1920         case DATA_PREFIX_OPCODE:
1921           q = DATA_PREFIX;
1922           break;
1923         }
1924       if (i.prefix[q] != 0)
1925         ret = PREFIX_EXIST;
1926     }
1927
1928   if (ret)
1929     {
1930       if (!i.prefix[q])
1931         ++i.prefixes;
1932       i.prefix[q] |= prefix;
1933     }
1934   else
1935     as_bad (_("same type of prefix used twice"));
1936
1937   return ret;
1938 }
1939
1940 static void
1941 update_code_flag (int value, int check)
1942 {
1943   PRINTF_LIKE ((*as_error));
1944
1945   flag_code = (enum flag_code) value;
1946   if (flag_code == CODE_64BIT)
1947     {
1948       cpu_arch_flags.bitfield.cpu64 = 1;
1949       cpu_arch_flags.bitfield.cpuno64 = 0;
1950     }
1951   else
1952     {
1953       cpu_arch_flags.bitfield.cpu64 = 0;
1954       cpu_arch_flags.bitfield.cpuno64 = 1;
1955     }
1956   if (value == CODE_64BIT && !cpu_arch_flags.bitfield.cpulm )
1957     {
1958       if (check)
1959         as_error = as_fatal;
1960       else
1961         as_error = as_bad;
1962       (*as_error) (_("64bit mode not supported on `%s'."),
1963                    cpu_arch_name ? cpu_arch_name : default_arch);
1964     }
1965   if (value == CODE_32BIT && !cpu_arch_flags.bitfield.cpui386)
1966     {
1967       if (check)
1968         as_error = as_fatal;
1969       else
1970         as_error = as_bad;
1971       (*as_error) (_("32bit mode not supported on `%s'."),
1972                    cpu_arch_name ? cpu_arch_name : default_arch);
1973     }
1974   stackop_size = '\0';
1975 }
1976
1977 static void
1978 set_code_flag (int value)
1979 {
1980   update_code_flag (value, 0);
1981 }
1982
1983 static void
1984 set_16bit_gcc_code_flag (int new_code_flag)
1985 {
1986   flag_code = (enum flag_code) new_code_flag;
1987   if (flag_code != CODE_16BIT)
1988     abort ();
1989   cpu_arch_flags.bitfield.cpu64 = 0;
1990   cpu_arch_flags.bitfield.cpuno64 = 1;
1991   stackop_size = LONG_MNEM_SUFFIX;
1992 }
1993
1994 static void
1995 set_intel_syntax (int syntax_flag)
1996 {
1997   /* Find out if register prefixing is specified.  */
1998   int ask_naked_reg = 0;
1999
2000   SKIP_WHITESPACE ();
2001   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2002     {
2003       char *string = input_line_pointer;
2004       int e = get_symbol_end ();
2005
2006       if (strcmp (string, "prefix") == 0)
2007         ask_naked_reg = 1;
2008       else if (strcmp (string, "noprefix") == 0)
2009         ask_naked_reg = -1;
2010       else
2011         as_bad (_("bad argument to syntax directive."));
2012       *input_line_pointer = e;
2013     }
2014   demand_empty_rest_of_line ();
2015
2016   intel_syntax = syntax_flag;
2017
2018   if (ask_naked_reg == 0)
2019     allow_naked_reg = (intel_syntax
2020                        && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
2021   else
2022     allow_naked_reg = (ask_naked_reg < 0);
2023
2024   expr_set_rank (O_full_ptr, syntax_flag ? 10 : 0);
2025
2026   identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
2027   identifier_chars['$'] = intel_syntax ? '$' : 0;
2028   register_prefix = allow_naked_reg ? "" : "%";
2029 }
2030
2031 static void
2032 set_intel_mnemonic (int mnemonic_flag)
2033 {
2034   intel_mnemonic = mnemonic_flag;
2035 }
2036
2037 static void
2038 set_allow_index_reg (int flag)
2039 {
2040   allow_index_reg = flag;
2041 }
2042
2043 static void
2044 set_sse_check (int dummy ATTRIBUTE_UNUSED)
2045 {
2046   SKIP_WHITESPACE ();
2047
2048   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2049     {
2050       char *string = input_line_pointer;
2051       int e = get_symbol_end ();
2052
2053       if (strcmp (string, "none") == 0)
2054         sse_check = sse_check_none;
2055       else if (strcmp (string, "warning") == 0)
2056         sse_check = sse_check_warning;
2057       else if (strcmp (string, "error") == 0)
2058         sse_check = sse_check_error;
2059       else
2060         as_bad (_("bad argument to sse_check directive."));
2061       *input_line_pointer = e;
2062     }
2063   else
2064     as_bad (_("missing argument for sse_check directive"));
2065
2066   demand_empty_rest_of_line ();
2067 }
2068
2069 static void
2070 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED,
2071                            i386_cpu_flags new_flag ATTRIBUTE_UNUSED)
2072 {
2073 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2074   static const char *arch;
2075
2076   /* Intel LIOM is only supported on ELF.  */
2077   if (!IS_ELF)
2078     return;
2079
2080   if (!arch)
2081     {
2082       /* Use cpu_arch_name if it is set in md_parse_option.  Otherwise
2083          use default_arch.  */
2084       arch = cpu_arch_name;
2085       if (!arch)
2086         arch = default_arch;
2087     }
2088
2089   /* If we are targeting Intel L1OM, we must enable it.  */
2090   if (get_elf_backend_data (stdoutput)->elf_machine_code != EM_L1OM
2091       || new_flag.bitfield.cpul1om)
2092     return;
2093
2094   as_bad (_("`%s' is not supported on `%s'"), name, arch);
2095 #endif
2096 }
2097
2098 static void
2099 set_cpu_arch (int dummy ATTRIBUTE_UNUSED)
2100 {
2101   SKIP_WHITESPACE ();
2102
2103   if (!is_end_of_line[(unsigned char) *input_line_pointer])
2104     {
2105       char *string = input_line_pointer;
2106       int e = get_symbol_end ();
2107       unsigned int j;
2108       i386_cpu_flags flags;
2109
2110       for (j = 0; j < ARRAY_SIZE (cpu_arch); j++)
2111         {
2112           if (strcmp (string, cpu_arch[j].name) == 0)
2113             {
2114               check_cpu_arch_compatible (string, cpu_arch[j].flags);
2115
2116               if (*string != '.')
2117                 {
2118                   cpu_arch_name = cpu_arch[j].name;
2119                   cpu_sub_arch_name = NULL;
2120                   cpu_arch_flags = cpu_arch[j].flags;
2121                   if (flag_code == CODE_64BIT)
2122                     {
2123                       cpu_arch_flags.bitfield.cpu64 = 1;
2124                       cpu_arch_flags.bitfield.cpuno64 = 0;
2125                     }
2126                   else
2127                     {
2128                       cpu_arch_flags.bitfield.cpu64 = 0;
2129                       cpu_arch_flags.bitfield.cpuno64 = 1;
2130                     }
2131                   cpu_arch_isa = cpu_arch[j].type;
2132                   cpu_arch_isa_flags = cpu_arch[j].flags;
2133                   if (!cpu_arch_tune_set)
2134                     {
2135                       cpu_arch_tune = cpu_arch_isa;
2136                       cpu_arch_tune_flags = cpu_arch_isa_flags;
2137                     }
2138                   break;
2139                 }
2140
2141               if (!cpu_arch[j].negated)
2142                 flags = cpu_flags_or (cpu_arch_flags,
2143                                       cpu_arch[j].flags);
2144               else
2145                 flags = cpu_flags_and_not (cpu_arch_flags,
2146                                            cpu_arch[j].flags);
2147               if (!cpu_flags_equal (&flags, &cpu_arch_flags))
2148                 {
2149                   if (cpu_sub_arch_name)
2150                     {
2151                       char *name = cpu_sub_arch_name;
2152                       cpu_sub_arch_name = concat (name,
2153                                                   cpu_arch[j].name,
2154                                                   (const char *) NULL);
2155                       free (name);
2156                     }
2157                   else
2158                     cpu_sub_arch_name = xstrdup (cpu_arch[j].name);
2159                   cpu_arch_flags = flags;
2160                 }
2161               *input_line_pointer = e;
2162               demand_empty_rest_of_line ();
2163               return;
2164             }
2165         }
2166       if (j >= ARRAY_SIZE (cpu_arch))
2167         as_bad (_("no such architecture: `%s'"), string);
2168
2169       *input_line_pointer = e;
2170     }
2171   else
2172     as_bad (_("missing cpu architecture"));
2173
2174   no_cond_jump_promotion = 0;
2175   if (*input_line_pointer == ','
2176       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
2177     {
2178       char *string = ++input_line_pointer;
2179       int e = get_symbol_end ();
2180
2181       if (strcmp (string, "nojumps") == 0)
2182         no_cond_jump_promotion = 1;
2183       else if (strcmp (string, "jumps") == 0)
2184         ;
2185       else
2186         as_bad (_("no such architecture modifier: `%s'"), string);
2187
2188       *input_line_pointer = e;
2189     }
2190
2191   demand_empty_rest_of_line ();
2192 }
2193
2194 enum bfd_architecture
2195 i386_arch (void)
2196 {
2197   if (cpu_arch_isa == PROCESSOR_L1OM)
2198     {
2199       if (OUTPUT_FLAVOR != bfd_target_elf_flavour
2200           || flag_code != CODE_64BIT)
2201         as_fatal (_("Intel L1OM is 64bit ELF only"));
2202       return bfd_arch_l1om;
2203     }
2204   else
2205     return bfd_arch_i386;
2206 }
2207
2208 unsigned long
2209 i386_mach ()
2210 {
2211   if (!strcmp (default_arch, "x86_64"))
2212     {
2213       if (cpu_arch_isa == PROCESSOR_L1OM)
2214         {
2215           if (OUTPUT_FLAVOR != bfd_target_elf_flavour)
2216             as_fatal (_("Intel L1OM is 64bit ELF only"));
2217           return bfd_mach_l1om;
2218         }
2219       else
2220         return bfd_mach_x86_64;
2221     }
2222   else if (!strcmp (default_arch, "i386"))
2223     return bfd_mach_i386_i386;
2224   else
2225     as_fatal (_("Unknown architecture"));
2226 }
2227 \f
2228 void
2229 md_begin ()
2230 {
2231   const char *hash_err;
2232
2233   /* Initialize op_hash hash table.  */
2234   op_hash = hash_new ();
2235
2236   {
2237     const insn_template *optab;
2238     templates *core_optab;
2239
2240     /* Setup for loop.  */
2241     optab = i386_optab;
2242     core_optab = (templates *) xmalloc (sizeof (templates));
2243     core_optab->start = optab;
2244
2245     while (1)
2246       {
2247         ++optab;
2248         if (optab->name == NULL
2249             || strcmp (optab->name, (optab - 1)->name) != 0)
2250           {
2251             /* different name --> ship out current template list;
2252                add to hash table; & begin anew.  */
2253             core_optab->end = optab;
2254             hash_err = hash_insert (op_hash,
2255                                     (optab - 1)->name,
2256                                     (void *) core_optab);
2257             if (hash_err)
2258               {
2259                 as_fatal (_("Internal Error:  Can't hash %s: %s"),
2260                           (optab - 1)->name,
2261                           hash_err);
2262               }
2263             if (optab->name == NULL)
2264               break;
2265             core_optab = (templates *) xmalloc (sizeof (templates));
2266             core_optab->start = optab;
2267           }
2268       }
2269   }
2270
2271   /* Initialize reg_hash hash table.  */
2272   reg_hash = hash_new ();
2273   {
2274     const reg_entry *regtab;
2275     unsigned int regtab_size = i386_regtab_size;
2276
2277     for (regtab = i386_regtab; regtab_size--; regtab++)
2278       {
2279         hash_err = hash_insert (reg_hash, regtab->reg_name, (void *) regtab);
2280         if (hash_err)
2281           as_fatal (_("Internal Error:  Can't hash %s: %s"),
2282                     regtab->reg_name,
2283                     hash_err);
2284       }
2285   }
2286
2287   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
2288   {
2289     int c;
2290     char *p;
2291
2292     for (c = 0; c < 256; c++)
2293       {
2294         if (ISDIGIT (c))
2295           {
2296             digit_chars[c] = c;
2297             mnemonic_chars[c] = c;
2298             register_chars[c] = c;
2299             operand_chars[c] = c;
2300           }
2301         else if (ISLOWER (c))
2302           {
2303             mnemonic_chars[c] = c;
2304             register_chars[c] = c;
2305             operand_chars[c] = c;
2306           }
2307         else if (ISUPPER (c))
2308           {
2309             mnemonic_chars[c] = TOLOWER (c);
2310             register_chars[c] = mnemonic_chars[c];
2311             operand_chars[c] = c;
2312           }
2313
2314         if (ISALPHA (c) || ISDIGIT (c))
2315           identifier_chars[c] = c;
2316         else if (c >= 128)
2317           {
2318             identifier_chars[c] = c;
2319             operand_chars[c] = c;
2320           }
2321       }
2322
2323 #ifdef LEX_AT
2324     identifier_chars['@'] = '@';
2325 #endif
2326 #ifdef LEX_QM
2327     identifier_chars['?'] = '?';
2328     operand_chars['?'] = '?';
2329 #endif
2330     digit_chars['-'] = '-';
2331     mnemonic_chars['_'] = '_';
2332     mnemonic_chars['-'] = '-';
2333     mnemonic_chars['.'] = '.';
2334     identifier_chars['_'] = '_';
2335     identifier_chars['.'] = '.';
2336
2337     for (p = operand_special_chars; *p != '\0'; p++)
2338       operand_chars[(unsigned char) *p] = *p;
2339   }
2340
2341 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2342   if (IS_ELF)
2343     {
2344       record_alignment (text_section, 2);
2345       record_alignment (data_section, 2);
2346       record_alignment (bss_section, 2);
2347     }
2348 #endif
2349
2350   if (flag_code == CODE_64BIT)
2351     {
2352       x86_dwarf2_return_column = 16;
2353       x86_cie_data_alignment = -8;
2354     }
2355   else
2356     {
2357       x86_dwarf2_return_column = 8;
2358       x86_cie_data_alignment = -4;
2359     }
2360 }
2361
2362 void
2363 i386_print_statistics (FILE *file)
2364 {
2365   hash_print_statistics (file, "i386 opcode", op_hash);
2366   hash_print_statistics (file, "i386 register", reg_hash);
2367 }
2368 \f
2369 #ifdef DEBUG386
2370
2371 /* Debugging routines for md_assemble.  */
2372 static void pte (insn_template *);
2373 static void pt (i386_operand_type);
2374 static void pe (expressionS *);
2375 static void ps (symbolS *);
2376
2377 static void
2378 pi (char *line, i386_insn *x)
2379 {
2380   unsigned int j;
2381
2382   fprintf (stdout, "%s: template ", line);
2383   pte (&x->tm);
2384   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
2385            x->base_reg ? x->base_reg->reg_name : "none",
2386            x->index_reg ? x->index_reg->reg_name : "none",
2387            x->log2_scale_factor);
2388   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
2389            x->rm.mode, x->rm.reg, x->rm.regmem);
2390   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
2391            x->sib.base, x->sib.index, x->sib.scale);
2392   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
2393            (x->rex & REX_W) != 0,
2394            (x->rex & REX_R) != 0,
2395            (x->rex & REX_X) != 0,
2396            (x->rex & REX_B) != 0);
2397   for (j = 0; j < x->operands; j++)
2398     {
2399       fprintf (stdout, "    #%d:  ", j + 1);
2400       pt (x->types[j]);
2401       fprintf (stdout, "\n");
2402       if (x->types[j].bitfield.reg8
2403           || x->types[j].bitfield.reg16
2404           || x->types[j].bitfield.reg32
2405           || x->types[j].bitfield.reg64
2406           || x->types[j].bitfield.regmmx
2407           || x->types[j].bitfield.regxmm
2408           || x->types[j].bitfield.regymm
2409           || x->types[j].bitfield.sreg2
2410           || x->types[j].bitfield.sreg3
2411           || x->types[j].bitfield.control
2412           || x->types[j].bitfield.debug
2413           || x->types[j].bitfield.test)
2414         fprintf (stdout, "%s\n", x->op[j].regs->reg_name);
2415       if (operand_type_check (x->types[j], imm))
2416         pe (x->op[j].imms);
2417       if (operand_type_check (x->types[j], disp))
2418         pe (x->op[j].disps);
2419     }
2420 }
2421
2422 static void
2423 pte (insn_template *t)
2424 {
2425   unsigned int j;
2426   fprintf (stdout, " %d operands ", t->operands);
2427   fprintf (stdout, "opcode %x ", t->base_opcode);
2428   if (t->extension_opcode != None)
2429     fprintf (stdout, "ext %x ", t->extension_opcode);
2430   if (t->opcode_modifier.d)
2431     fprintf (stdout, "D");
2432   if (t->opcode_modifier.w)
2433     fprintf (stdout, "W");
2434   fprintf (stdout, "\n");
2435   for (j = 0; j < t->operands; j++)
2436     {
2437       fprintf (stdout, "    #%d type ", j + 1);
2438       pt (t->operand_types[j]);
2439       fprintf (stdout, "\n");
2440     }
2441 }
2442
2443 static void
2444 pe (expressionS *e)
2445 {
2446   fprintf (stdout, "    operation     %d\n", e->X_op);
2447   fprintf (stdout, "    add_number    %ld (%lx)\n",
2448            (long) e->X_add_number, (long) e->X_add_number);
2449   if (e->X_add_symbol)
2450     {
2451       fprintf (stdout, "    add_symbol    ");
2452       ps (e->X_add_symbol);
2453       fprintf (stdout, "\n");
2454     }
2455   if (e->X_op_symbol)
2456     {
2457       fprintf (stdout, "    op_symbol    ");
2458       ps (e->X_op_symbol);
2459       fprintf (stdout, "\n");
2460     }
2461 }
2462
2463 static void
2464 ps (symbolS *s)
2465 {
2466   fprintf (stdout, "%s type %s%s",
2467            S_GET_NAME (s),
2468            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
2469            segment_name (S_GET_SEGMENT (s)));
2470 }
2471
2472 static struct type_name
2473   {
2474     i386_operand_type mask;
2475     const char *name;
2476   }
2477 const type_names[] =
2478 {
2479   { OPERAND_TYPE_REG8, "r8" },
2480   { OPERAND_TYPE_REG16, "r16" },
2481   { OPERAND_TYPE_REG32, "r32" },
2482   { OPERAND_TYPE_REG64, "r64" },
2483   { OPERAND_TYPE_IMM8, "i8" },
2484   { OPERAND_TYPE_IMM8, "i8s" },
2485   { OPERAND_TYPE_IMM16, "i16" },
2486   { OPERAND_TYPE_IMM32, "i32" },
2487   { OPERAND_TYPE_IMM32S, "i32s" },
2488   { OPERAND_TYPE_IMM64, "i64" },
2489   { OPERAND_TYPE_IMM1, "i1" },
2490   { OPERAND_TYPE_BASEINDEX, "BaseIndex" },
2491   { OPERAND_TYPE_DISP8, "d8" },
2492   { OPERAND_TYPE_DISP16, "d16" },
2493   { OPERAND_TYPE_DISP32, "d32" },
2494   { OPERAND_TYPE_DISP32S, "d32s" },
2495   { OPERAND_TYPE_DISP64, "d64" },
2496   { OPERAND_TYPE_INOUTPORTREG, "InOutPortReg" },
2497   { OPERAND_TYPE_SHIFTCOUNT, "ShiftCount" },
2498   { OPERAND_TYPE_CONTROL, "control reg" },
2499   { OPERAND_TYPE_TEST, "test reg" },
2500   { OPERAND_TYPE_DEBUG, "debug reg" },
2501   { OPERAND_TYPE_FLOATREG, "FReg" },
2502   { OPERAND_TYPE_FLOATACC, "FAcc" },
2503   { OPERAND_TYPE_SREG2, "SReg2" },
2504   { OPERAND_TYPE_SREG3, "SReg3" },
2505   { OPERAND_TYPE_ACC, "Acc" },
2506   { OPERAND_TYPE_JUMPABSOLUTE, "Jump Absolute" },
2507   { OPERAND_TYPE_REGMMX, "rMMX" },
2508   { OPERAND_TYPE_REGXMM, "rXMM" },
2509   { OPERAND_TYPE_REGYMM, "rYMM" },
2510   { OPERAND_TYPE_ESSEG, "es" },
2511 };
2512
2513 static void
2514 pt (i386_operand_type t)
2515 {
2516   unsigned int j;
2517   i386_operand_type a;
2518
2519   for (j = 0; j < ARRAY_SIZE (type_names); j++)
2520     {
2521       a = operand_type_and (t, type_names[j].mask);
2522       if (!operand_type_all_zero (&a))
2523         fprintf (stdout, "%s, ",  type_names[j].name);
2524     }
2525   fflush (stdout);
2526 }
2527
2528 #endif /* DEBUG386 */
2529 \f
2530 static bfd_reloc_code_real_type
2531 reloc (unsigned int size,
2532        int pcrel,
2533        int sign,
2534        bfd_reloc_code_real_type other)
2535 {
2536   if (other != NO_RELOC)
2537     {
2538       reloc_howto_type *rel;
2539
2540       if (size == 8)
2541         switch (other)
2542           {
2543           case BFD_RELOC_X86_64_GOT32:
2544             return BFD_RELOC_X86_64_GOT64;
2545             break;
2546           case BFD_RELOC_X86_64_PLTOFF64:
2547             return BFD_RELOC_X86_64_PLTOFF64;
2548             break;
2549           case BFD_RELOC_X86_64_GOTPC32:
2550             other = BFD_RELOC_X86_64_GOTPC64;
2551             break;
2552           case BFD_RELOC_X86_64_GOTPCREL:
2553             other = BFD_RELOC_X86_64_GOTPCREL64;
2554             break;
2555           case BFD_RELOC_X86_64_TPOFF32:
2556             other = BFD_RELOC_X86_64_TPOFF64;
2557             break;
2558           case BFD_RELOC_X86_64_DTPOFF32:
2559             other = BFD_RELOC_X86_64_DTPOFF64;
2560             break;
2561           default:
2562             break;
2563           }
2564
2565       /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless.  */
2566       if (size == 4 && flag_code != CODE_64BIT)
2567         sign = -1;
2568
2569       rel = bfd_reloc_type_lookup (stdoutput, other);
2570       if (!rel)
2571         as_bad (_("unknown relocation (%u)"), other);
2572       else if (size != bfd_get_reloc_size (rel))
2573         as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
2574                 bfd_get_reloc_size (rel),
2575                 size);
2576       else if (pcrel && !rel->pc_relative)
2577         as_bad (_("non-pc-relative relocation for pc-relative field"));
2578       else if ((rel->complain_on_overflow == complain_overflow_signed
2579                 && !sign)
2580                || (rel->complain_on_overflow == complain_overflow_unsigned
2581                    && sign > 0))
2582         as_bad (_("relocated field and relocation type differ in signedness"));
2583       else
2584         return other;
2585       return NO_RELOC;
2586     }
2587
2588   if (pcrel)
2589     {
2590       if (!sign)
2591         as_bad (_("there are no unsigned pc-relative relocations"));
2592       switch (size)
2593         {
2594         case 1: return BFD_RELOC_8_PCREL;
2595         case 2: return BFD_RELOC_16_PCREL;
2596         case 4: return BFD_RELOC_32_PCREL;
2597         case 8: return BFD_RELOC_64_PCREL;
2598         }
2599       as_bad (_("cannot do %u byte pc-relative relocation"), size);
2600     }
2601   else
2602     {
2603       if (sign > 0)
2604         switch (size)
2605           {
2606           case 4: return BFD_RELOC_X86_64_32S;
2607           }
2608       else
2609         switch (size)
2610           {
2611           case 1: return BFD_RELOC_8;
2612           case 2: return BFD_RELOC_16;
2613           case 4: return BFD_RELOC_32;
2614           case 8: return BFD_RELOC_64;
2615           }
2616       as_bad (_("cannot do %s %u byte relocation"),
2617               sign > 0 ? "signed" : "unsigned", size);
2618     }
2619
2620   return NO_RELOC;
2621 }
2622
2623 /* Here we decide which fixups can be adjusted to make them relative to
2624    the beginning of the section instead of the symbol.  Basically we need
2625    to make sure that the dynamic relocations are done correctly, so in
2626    some cases we force the original symbol to be used.  */
2627
2628 int
2629 tc_i386_fix_adjustable (fixS *fixP ATTRIBUTE_UNUSED)
2630 {
2631 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2632   if (!IS_ELF)
2633     return 1;
2634
2635   /* Don't adjust pc-relative references to merge sections in 64-bit
2636      mode.  */
2637   if (use_rela_relocations
2638       && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
2639       && fixP->fx_pcrel)
2640     return 0;
2641
2642   /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
2643      and changed later by validate_fix.  */
2644   if (GOT_symbol && fixP->fx_subsy == GOT_symbol
2645       && fixP->fx_r_type == BFD_RELOC_32_PCREL)
2646     return 0;
2647
2648   /* adjust_reloc_syms doesn't know about the GOT.  */
2649   if (fixP->fx_r_type == BFD_RELOC_386_GOTOFF
2650       || fixP->fx_r_type == BFD_RELOC_386_PLT32
2651       || fixP->fx_r_type == BFD_RELOC_386_GOT32
2652       || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
2653       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
2654       || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
2655       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
2656       || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
2657       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
2658       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
2659       || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
2660       || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
2661       || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
2662       || fixP->fx_r_type == BFD_RELOC_X86_64_PLT32
2663       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
2664       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
2665       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
2666       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
2667       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
2668       || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
2669       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
2670       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
2671       || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
2672       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
2673       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
2674       || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
2675       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
2676       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
2677     return 0;
2678 #endif
2679   return 1;
2680 }
2681
2682 static int
2683 intel_float_operand (const char *mnemonic)
2684 {
2685   /* Note that the value returned is meaningful only for opcodes with (memory)
2686      operands, hence the code here is free to improperly handle opcodes that
2687      have no operands (for better performance and smaller code). */
2688
2689   if (mnemonic[0] != 'f')
2690     return 0; /* non-math */
2691
2692   switch (mnemonic[1])
2693     {
2694     /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
2695        the fs segment override prefix not currently handled because no
2696        call path can make opcodes without operands get here */
2697     case 'i':
2698       return 2 /* integer op */;
2699     case 'l':
2700       if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
2701         return 3; /* fldcw/fldenv */
2702       break;
2703     case 'n':
2704       if (mnemonic[2] != 'o' /* fnop */)
2705         return 3; /* non-waiting control op */
2706       break;
2707     case 'r':
2708       if (mnemonic[2] == 's')
2709         return 3; /* frstor/frstpm */
2710       break;
2711     case 's':
2712       if (mnemonic[2] == 'a')
2713         return 3; /* fsave */
2714       if (mnemonic[2] == 't')
2715         {
2716           switch (mnemonic[3])
2717             {
2718             case 'c': /* fstcw */
2719             case 'd': /* fstdw */
2720             case 'e': /* fstenv */
2721             case 's': /* fsts[gw] */
2722               return 3;
2723             }
2724         }
2725       break;
2726     case 'x':
2727       if (mnemonic[2] == 'r' || mnemonic[2] == 's')
2728         return 0; /* fxsave/fxrstor are not really math ops */
2729       break;
2730     }
2731
2732   return 1;
2733 }
2734
2735 /* Build the VEX prefix.  */
2736
2737 static void
2738 build_vex_prefix (const insn_template *t)
2739 {
2740   unsigned int register_specifier;
2741   unsigned int implied_prefix;
2742   unsigned int vector_length;
2743
2744   /* Check register specifier.  */
2745   if (i.vex.register_specifier)
2746     {
2747       register_specifier = i.vex.register_specifier->reg_num;
2748       if ((i.vex.register_specifier->reg_flags & RegRex))
2749         register_specifier += 8;
2750       register_specifier = ~register_specifier & 0xf;
2751     }
2752   else
2753     register_specifier = 0xf;
2754
2755   /* Use 2-byte VEX prefix by swappping destination and source
2756      operand.  */
2757   if (!i.swap_operand
2758       && i.operands == i.reg_operands
2759       && i.tm.opcode_modifier.vexopcode == VEX0F
2760       && i.tm.opcode_modifier.s
2761       && i.rex == REX_B)
2762     {
2763       unsigned int xchg = i.operands - 1;
2764       union i386_op temp_op;
2765       i386_operand_type temp_type;
2766
2767       temp_type = i.types[xchg];
2768       i.types[xchg] = i.types[0];
2769       i.types[0] = temp_type;
2770       temp_op = i.op[xchg];
2771       i.op[xchg] = i.op[0];
2772       i.op[0] = temp_op;
2773
2774       gas_assert (i.rm.mode == 3);
2775
2776       i.rex = REX_R;
2777       xchg = i.rm.regmem;
2778       i.rm.regmem = i.rm.reg;
2779       i.rm.reg = xchg;
2780
2781       /* Use the next insn.  */
2782       i.tm = t[1];
2783     }
2784
2785   if (i.tm.opcode_modifier.vex == VEXScalar)
2786     vector_length = avxscalar;
2787   else
2788     vector_length = i.tm.opcode_modifier.vex == VEX256 ? 1 : 0;
2789
2790   switch ((i.tm.base_opcode >> 8) & 0xff)
2791     {
2792     case 0:
2793       implied_prefix = 0;
2794       break;
2795     case DATA_PREFIX_OPCODE:
2796       implied_prefix = 1;
2797       break;
2798     case REPE_PREFIX_OPCODE:
2799       implied_prefix = 2;
2800       break;
2801     case REPNE_PREFIX_OPCODE:
2802       implied_prefix = 3;
2803       break;
2804     default:
2805       abort ();
2806     }
2807
2808   /* Use 2-byte VEX prefix if possible.  */
2809   if (i.tm.opcode_modifier.vexopcode == VEX0F
2810       && i.tm.opcode_modifier.vexw != VEXW1
2811       && (i.rex & (REX_W | REX_X | REX_B)) == 0)
2812     {
2813       /* 2-byte VEX prefix.  */
2814       unsigned int r;
2815
2816       i.vex.length = 2;
2817       i.vex.bytes[0] = 0xc5;
2818
2819       /* Check the REX.R bit.  */
2820       r = (i.rex & REX_R) ? 0 : 1;
2821       i.vex.bytes[1] = (r << 7
2822                         | register_specifier << 3
2823                         | vector_length << 2
2824                         | implied_prefix);
2825     }
2826   else
2827     {
2828       /* 3-byte VEX prefix.  */
2829       unsigned int m, w;
2830
2831       i.vex.length = 3;
2832
2833       switch (i.tm.opcode_modifier.vexopcode)
2834         {
2835         case VEX0F:
2836           m = 0x1;
2837           i.vex.bytes[0] = 0xc4;
2838           break;
2839         case VEX0F38:
2840           m = 0x2;
2841           i.vex.bytes[0] = 0xc4;
2842           break;
2843         case VEX0F3A:
2844           m = 0x3;
2845           i.vex.bytes[0] = 0xc4;
2846           break;
2847         case XOP08:
2848           m = 0x8;
2849           i.vex.bytes[0] = 0x8f;
2850           break;
2851         case XOP09:
2852           m = 0x9;
2853           i.vex.bytes[0] = 0x8f;
2854           break;
2855         case XOP0A:
2856           m = 0xa;
2857           i.vex.bytes[0] = 0x8f;
2858           break;
2859         default:
2860           abort ();
2861         }
2862
2863       /* The high 3 bits of the second VEX byte are 1's compliment
2864          of RXB bits from REX.  */
2865       i.vex.bytes[1] = (~i.rex & 0x7) << 5 | m;
2866
2867       /* Check the REX.W bit.  */
2868       w = (i.rex & REX_W) ? 1 : 0;
2869       if (i.tm.opcode_modifier.vexw)
2870         {
2871           if (w)
2872             abort ();
2873
2874           if (i.tm.opcode_modifier.vexw == VEXW1)
2875             w = 1;
2876         }
2877
2878       i.vex.bytes[2] = (w << 7
2879                         | register_specifier << 3
2880                         | vector_length << 2
2881                         | implied_prefix);
2882     }
2883 }
2884
2885 static void
2886 process_immext (void)
2887 {
2888   expressionS *exp;
2889
2890   if (i.tm.cpu_flags.bitfield.cpusse3 && i.operands > 0)
2891     {
2892       /* SSE3 Instructions have the fixed operands with an opcode
2893          suffix which is coded in the same place as an 8-bit immediate
2894          field would be.  Here we check those operands and remove them
2895          afterwards.  */
2896       unsigned int x;
2897
2898       for (x = 0; x < i.operands; x++)
2899         if (i.op[x].regs->reg_num != x)
2900           as_bad (_("can't use register '%s%s' as operand %d in '%s'."),
2901                   register_prefix, i.op[x].regs->reg_name, x + 1,
2902                   i.tm.name);
2903
2904       i.operands = 0;
2905     }
2906
2907   /* These AMD 3DNow! and SSE2 instructions have an opcode suffix
2908      which is coded in the same place as an 8-bit immediate field
2909      would be.  Here we fake an 8-bit immediate operand from the
2910      opcode suffix stored in tm.extension_opcode.
2911
2912      AVX instructions also use this encoding, for some of
2913      3 argument instructions.  */
2914
2915   gas_assert (i.imm_operands == 0
2916               && (i.operands <= 2
2917                   || (i.tm.opcode_modifier.vex
2918                       && i.operands <= 4)));
2919
2920   exp = &im_expressions[i.imm_operands++];
2921   i.op[i.operands].imms = exp;
2922   i.types[i.operands] = imm8;
2923   i.operands++;
2924   exp->X_op = O_constant;
2925   exp->X_add_number = i.tm.extension_opcode;
2926   i.tm.extension_opcode = None;
2927 }
2928
2929 /* This is the guts of the machine-dependent assembler.  LINE points to a
2930    machine dependent instruction.  This function is supposed to emit
2931    the frags/bytes it assembles to.  */
2932
2933 void
2934 md_assemble (char *line)
2935 {
2936   unsigned int j;
2937   char mnemonic[MAX_MNEM_SIZE];
2938   const insn_template *t;
2939
2940   /* Initialize globals.  */
2941   memset (&i, '\0', sizeof (i));
2942   for (j = 0; j < MAX_OPERANDS; j++)
2943     i.reloc[j] = NO_RELOC;
2944   memset (disp_expressions, '\0', sizeof (disp_expressions));
2945   memset (im_expressions, '\0', sizeof (im_expressions));
2946   save_stack_p = save_stack;
2947
2948   /* First parse an instruction mnemonic & call i386_operand for the operands.
2949      We assume that the scrubber has arranged it so that line[0] is the valid
2950      start of a (possibly prefixed) mnemonic.  */
2951
2952   line = parse_insn (line, mnemonic);
2953   if (line == NULL)
2954     return;
2955
2956   line = parse_operands (line, mnemonic);
2957   this_operand = -1;
2958   if (line == NULL)
2959     return;
2960
2961   /* Now we've parsed the mnemonic into a set of templates, and have the
2962      operands at hand.  */
2963
2964   /* All intel opcodes have reversed operands except for "bound" and
2965      "enter".  We also don't reverse intersegment "jmp" and "call"
2966      instructions with 2 immediate operands so that the immediate segment
2967      precedes the offset, as it does when in AT&T mode. */
2968   if (intel_syntax
2969       && i.operands > 1
2970       && (strcmp (mnemonic, "bound") != 0)
2971       && (strcmp (mnemonic, "invlpga") != 0)
2972       && !(operand_type_check (i.types[0], imm)
2973            && operand_type_check (i.types[1], imm)))
2974     swap_operands ();
2975
2976   /* The order of the immediates should be reversed
2977      for 2 immediates extrq and insertq instructions */
2978   if (i.imm_operands == 2
2979       && (strcmp (mnemonic, "extrq") == 0
2980           || strcmp (mnemonic, "insertq") == 0))
2981       swap_2_operands (0, 1);
2982
2983   if (i.imm_operands)
2984     optimize_imm ();
2985
2986   /* Don't optimize displacement for movabs since it only takes 64bit
2987      displacement.  */
2988   if (i.disp_operands
2989       && !i.disp32_encoding
2990       && (flag_code != CODE_64BIT
2991           || strcmp (mnemonic, "movabs") != 0))
2992     optimize_disp ();
2993
2994   /* Next, we find a template that matches the given insn,
2995      making sure the overlap of the given operands types is consistent
2996      with the template operand types.  */
2997
2998   if (!(t = match_template ()))
2999     return;
3000
3001   if (sse_check != sse_check_none
3002       && !i.tm.opcode_modifier.noavx
3003       && (i.tm.cpu_flags.bitfield.cpusse
3004           || i.tm.cpu_flags.bitfield.cpusse2
3005           || i.tm.cpu_flags.bitfield.cpusse3
3006           || i.tm.cpu_flags.bitfield.cpussse3
3007           || i.tm.cpu_flags.bitfield.cpusse4_1
3008           || i.tm.cpu_flags.bitfield.cpusse4_2))
3009     {
3010       (sse_check == sse_check_warning
3011        ? as_warn
3012        : as_bad) (_("SSE instruction `%s' is used"), i.tm.name);
3013     }
3014
3015   /* Zap movzx and movsx suffix.  The suffix has been set from
3016      "word ptr" or "byte ptr" on the source operand in Intel syntax
3017      or extracted from mnemonic in AT&T syntax.  But we'll use
3018      the destination register to choose the suffix for encoding.  */
3019   if ((i.tm.base_opcode & ~9) == 0x0fb6)
3020     {
3021       /* In Intel syntax, there must be a suffix.  In AT&T syntax, if
3022          there is no suffix, the default will be byte extension.  */
3023       if (i.reg_operands != 2
3024           && !i.suffix
3025           && intel_syntax)
3026         as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
3027
3028       i.suffix = 0;
3029     }
3030
3031   if (i.tm.opcode_modifier.fwait)
3032     if (!add_prefix (FWAIT_OPCODE))
3033       return;
3034
3035   /* Check for lock without a lockable instruction.  Destination operand
3036      must be memory unless it is xchg (0x86).  */
3037   if (i.prefix[LOCK_PREFIX]
3038       && (!i.tm.opcode_modifier.islockable
3039           || i.mem_operands == 0
3040           || (i.tm.base_opcode != 0x86
3041               && !operand_type_check (i.types[i.operands - 1], anymem))))
3042     {
3043       as_bad (_("expecting lockable instruction after `lock'"));
3044       return;
3045     }
3046
3047   /* Check string instruction segment overrides.  */
3048   if (i.tm.opcode_modifier.isstring && i.mem_operands != 0)
3049     {
3050       if (!check_string ())
3051         return;
3052       i.disp_operands = 0;
3053     }
3054
3055   if (!process_suffix ())
3056     return;
3057
3058   /* Update operand types.  */
3059   for (j = 0; j < i.operands; j++)
3060     i.types[j] = operand_type_and (i.types[j], i.tm.operand_types[j]);
3061
3062   /* Make still unresolved immediate matches conform to size of immediate
3063      given in i.suffix.  */
3064   if (!finalize_imm ())
3065     return;
3066
3067   if (i.types[0].bitfield.imm1)
3068     i.imm_operands = 0; /* kludge for shift insns.  */
3069
3070   /* We only need to check those implicit registers for instructions
3071      with 3 operands or less.  */
3072   if (i.operands <= 3)
3073     for (j = 0; j < i.operands; j++)
3074       if (i.types[j].bitfield.inoutportreg
3075           || i.types[j].bitfield.shiftcount
3076           || i.types[j].bitfield.acc
3077           || i.types[j].bitfield.floatacc)
3078         i.reg_operands--;
3079
3080   /* ImmExt should be processed after SSE2AVX.  */
3081   if (!i.tm.opcode_modifier.sse2avx
3082       && i.tm.opcode_modifier.immext)
3083     process_immext ();
3084
3085   /* For insns with operands there are more diddles to do to the opcode.  */
3086   if (i.operands)
3087     {
3088       if (!process_operands ())
3089         return;
3090     }
3091   else if (!quiet_warnings && i.tm.opcode_modifier.ugh)
3092     {
3093       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
3094       as_warn (_("translating to `%sp'"), i.tm.name);
3095     }
3096
3097   if (i.tm.opcode_modifier.vex)
3098     build_vex_prefix (t);
3099
3100   /* Handle conversion of 'int $3' --> special int3 insn.  XOP or FMA4
3101      instructions may define INT_OPCODE as well, so avoid this corner
3102      case for those instructions that use MODRM.  */
3103   if (i.tm.base_opcode == INT_OPCODE
3104       && !i.tm.opcode_modifier.modrm
3105       && i.op[0].imms->X_add_number == 3)
3106     {
3107       i.tm.base_opcode = INT3_OPCODE;
3108       i.imm_operands = 0;
3109     }
3110
3111   if ((i.tm.opcode_modifier.jump
3112        || i.tm.opcode_modifier.jumpbyte
3113        || i.tm.opcode_modifier.jumpdword)
3114       && i.op[0].disps->X_op == O_constant)
3115     {
3116       /* Convert "jmp constant" (and "call constant") to a jump (call) to
3117          the absolute address given by the constant.  Since ix86 jumps and
3118          calls are pc relative, we need to generate a reloc.  */
3119       i.op[0].disps->X_add_symbol = &abs_symbol;
3120       i.op[0].disps->X_op = O_symbol;
3121     }
3122
3123   if (i.tm.opcode_modifier.rex64)
3124     i.rex |= REX_W;
3125
3126   /* For 8 bit registers we need an empty rex prefix.  Also if the
3127      instruction already has a prefix, we need to convert old
3128      registers to new ones.  */
3129
3130   if ((i.types[0].bitfield.reg8
3131        && (i.op[0].regs->reg_flags & RegRex64) != 0)
3132       || (i.types[1].bitfield.reg8
3133           && (i.op[1].regs->reg_flags & RegRex64) != 0)
3134       || ((i.types[0].bitfield.reg8
3135            || i.types[1].bitfield.reg8)
3136           && i.rex != 0))
3137     {
3138       int x;
3139
3140       i.rex |= REX_OPCODE;
3141       for (x = 0; x < 2; x++)
3142         {
3143           /* Look for 8 bit operand that uses old registers.  */
3144           if (i.types[x].bitfield.reg8
3145               && (i.op[x].regs->reg_flags & RegRex64) == 0)
3146             {
3147               /* In case it is "hi" register, give up.  */
3148               if (i.op[x].regs->reg_num > 3)
3149                 as_bad (_("can't encode register '%s%s' in an "
3150                           "instruction requiring REX prefix."),
3151                         register_prefix, i.op[x].regs->reg_name);
3152
3153               /* Otherwise it is equivalent to the extended register.
3154                  Since the encoding doesn't change this is merely
3155                  cosmetic cleanup for debug output.  */
3156
3157               i.op[x].regs = i.op[x].regs + 8;
3158             }
3159         }
3160     }
3161
3162   if (i.rex != 0)
3163     add_prefix (REX_OPCODE | i.rex);
3164
3165   /* We are ready to output the insn.  */
3166   output_insn ();
3167 }
3168
3169 static char *
3170 parse_insn (char *line, char *mnemonic)
3171 {
3172   char *l = line;
3173   char *token_start = l;
3174   char *mnem_p;
3175   int supported;
3176   const insn_template *t;
3177   char *dot_p = NULL;
3178
3179   /* Non-zero if we found a prefix only acceptable with string insns.  */
3180   const char *expecting_string_instruction = NULL;
3181
3182   while (1)
3183     {
3184       mnem_p = mnemonic;
3185       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
3186         {
3187           if (*mnem_p == '.')
3188             dot_p = mnem_p;
3189           mnem_p++;
3190           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
3191             {
3192               as_bad (_("no such instruction: `%s'"), token_start);
3193               return NULL;
3194             }
3195           l++;
3196         }
3197       if (!is_space_char (*l)
3198           && *l != END_OF_INSN
3199           && (intel_syntax
3200               || (*l != PREFIX_SEPARATOR
3201                   && *l != ',')))
3202         {
3203           as_bad (_("invalid character %s in mnemonic"),
3204                   output_invalid (*l));
3205           return NULL;
3206         }
3207       if (token_start == l)
3208         {
3209           if (!intel_syntax && *l == PREFIX_SEPARATOR)
3210             as_bad (_("expecting prefix; got nothing"));
3211           else
3212             as_bad (_("expecting mnemonic; got nothing"));
3213           return NULL;
3214         }
3215
3216       /* Look up instruction (or prefix) via hash table.  */
3217       current_templates = (const templates *) hash_find (op_hash, mnemonic);
3218
3219       if (*l != END_OF_INSN
3220           && (!is_space_char (*l) || l[1] != END_OF_INSN)
3221           && current_templates
3222           && current_templates->start->opcode_modifier.isprefix)
3223         {
3224           if (!cpu_flags_check_cpu64 (current_templates->start->cpu_flags))
3225             {
3226               as_bad ((flag_code != CODE_64BIT
3227                        ? _("`%s' is only supported in 64-bit mode")
3228                        : _("`%s' is not supported in 64-bit mode")),
3229                       current_templates->start->name);
3230               return NULL;
3231             }
3232           /* If we are in 16-bit mode, do not allow addr16 or data16.
3233              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
3234           if ((current_templates->start->opcode_modifier.size16
3235                || current_templates->start->opcode_modifier.size32)
3236               && flag_code != CODE_64BIT
3237               && (current_templates->start->opcode_modifier.size32
3238                   ^ (flag_code == CODE_16BIT)))
3239             {
3240               as_bad (_("redundant %s prefix"),
3241                       current_templates->start->name);
3242               return NULL;
3243             }
3244           /* Add prefix, checking for repeated prefixes.  */
3245           switch (add_prefix (current_templates->start->base_opcode))
3246             {
3247             case PREFIX_EXIST:
3248               return NULL;
3249             case PREFIX_REP:
3250               expecting_string_instruction = current_templates->start->name;
3251               break;
3252             default:
3253               break;
3254             }
3255           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
3256           token_start = ++l;
3257         }
3258       else
3259         break;
3260     }
3261
3262   if (!current_templates)
3263     {
3264       /* Check if we should swap operand or force 32bit displacement in
3265          encoding.  */
3266       if (mnem_p - 2 == dot_p && dot_p[1] == 's')
3267         i.swap_operand = 1;
3268       else if (mnem_p - 4 == dot_p 
3269                && dot_p[1] == 'd'
3270                && dot_p[2] == '3'
3271                && dot_p[3] == '2')
3272         i.disp32_encoding = 1;
3273       else
3274         goto check_suffix;
3275       mnem_p = dot_p;
3276       *dot_p = '\0';
3277       current_templates = (const templates *) hash_find (op_hash, mnemonic);
3278     }
3279
3280   if (!current_templates)
3281     {
3282 check_suffix:
3283       /* See if we can get a match by trimming off a suffix.  */
3284       switch (mnem_p[-1])
3285         {
3286         case WORD_MNEM_SUFFIX:
3287           if (intel_syntax && (intel_float_operand (mnemonic) & 2))
3288             i.suffix = SHORT_MNEM_SUFFIX;
3289           else
3290         case BYTE_MNEM_SUFFIX:
3291         case QWORD_MNEM_SUFFIX:
3292           i.suffix = mnem_p[-1];
3293           mnem_p[-1] = '\0';
3294           current_templates = (const templates *) hash_find (op_hash,
3295                                                              mnemonic);
3296           break;
3297         case SHORT_MNEM_SUFFIX:
3298         case LONG_MNEM_SUFFIX:
3299           if (!intel_syntax)
3300             {
3301               i.suffix = mnem_p[-1];
3302               mnem_p[-1] = '\0';
3303               current_templates = (const templates *) hash_find (op_hash,
3304                                                                  mnemonic);
3305             }
3306           break;
3307
3308           /* Intel Syntax.  */
3309         case 'd':
3310           if (intel_syntax)
3311             {
3312               if (intel_float_operand (mnemonic) == 1)
3313                 i.suffix = SHORT_MNEM_SUFFIX;
3314               else
3315                 i.suffix = LONG_MNEM_SUFFIX;
3316               mnem_p[-1] = '\0';
3317               current_templates = (const templates *) hash_find (op_hash,
3318                                                                  mnemonic);
3319             }
3320           break;
3321         }
3322       if (!current_templates)
3323         {
3324           as_bad (_("no such instruction: `%s'"), token_start);
3325           return NULL;
3326         }
3327     }
3328
3329   if (current_templates->start->opcode_modifier.jump
3330       || current_templates->start->opcode_modifier.jumpbyte)
3331     {
3332       /* Check for a branch hint.  We allow ",pt" and ",pn" for
3333          predict taken and predict not taken respectively.
3334          I'm not sure that branch hints actually do anything on loop
3335          and jcxz insns (JumpByte) for current Pentium4 chips.  They
3336          may work in the future and it doesn't hurt to accept them
3337          now.  */
3338       if (l[0] == ',' && l[1] == 'p')
3339         {
3340           if (l[2] == 't')
3341             {
3342               if (!add_prefix (DS_PREFIX_OPCODE))
3343                 return NULL;
3344               l += 3;
3345             }
3346           else if (l[2] == 'n')
3347             {
3348               if (!add_prefix (CS_PREFIX_OPCODE))
3349                 return NULL;
3350               l += 3;
3351             }
3352         }
3353     }
3354   /* Any other comma loses.  */
3355   if (*l == ',')
3356     {
3357       as_bad (_("invalid character %s in mnemonic"),
3358               output_invalid (*l));
3359       return NULL;
3360     }
3361
3362   /* Check if instruction is supported on specified architecture.  */
3363   supported = 0;
3364   for (t = current_templates->start; t < current_templates->end; ++t)
3365     {
3366       supported |= cpu_flags_match (t);
3367       if (supported == CPU_FLAGS_PERFECT_MATCH)
3368         goto skip;
3369     }
3370
3371   if (!(supported & CPU_FLAGS_64BIT_MATCH))
3372     {
3373       as_bad (flag_code == CODE_64BIT
3374               ? _("`%s' is not supported in 64-bit mode")
3375               : _("`%s' is only supported in 64-bit mode"),
3376               current_templates->start->name);
3377       return NULL;
3378     }
3379   if (supported != CPU_FLAGS_PERFECT_MATCH)
3380     {
3381       as_bad (_("`%s' is not supported on `%s%s'"),
3382               current_templates->start->name,
3383               cpu_arch_name ? cpu_arch_name : default_arch,
3384               cpu_sub_arch_name ? cpu_sub_arch_name : "");
3385       return NULL;
3386     }
3387
3388 skip:
3389   if (!cpu_arch_flags.bitfield.cpui386
3390            && (flag_code != CODE_16BIT))
3391     {
3392       as_warn (_("use .code16 to ensure correct addressing mode"));
3393     }
3394
3395   /* Check for rep/repne without a string instruction.  */
3396   if (expecting_string_instruction)
3397     {
3398       static templates override;
3399
3400       for (t = current_templates->start; t < current_templates->end; ++t)
3401         if (t->opcode_modifier.isstring)
3402           break;
3403       if (t >= current_templates->end)
3404         {
3405           as_bad (_("expecting string instruction after `%s'"),
3406                   expecting_string_instruction);
3407           return NULL;
3408         }
3409       for (override.start = t; t < current_templates->end; ++t)
3410         if (!t->opcode_modifier.isstring)
3411           break;
3412       override.end = t;
3413       current_templates = &override;
3414     }
3415
3416   return l;
3417 }
3418
3419 static char *
3420 parse_operands (char *l, const char *mnemonic)
3421 {
3422   char *token_start;
3423
3424   /* 1 if operand is pending after ','.  */
3425   unsigned int expecting_operand = 0;
3426
3427   /* Non-zero if operand parens not balanced.  */
3428   unsigned int paren_not_balanced;
3429
3430   while (*l != END_OF_INSN)
3431     {
3432       /* Skip optional white space before operand.  */
3433       if (is_space_char (*l))
3434         ++l;
3435       if (!is_operand_char (*l) && *l != END_OF_INSN)
3436         {
3437           as_bad (_("invalid character %s before operand %d"),
3438                   output_invalid (*l),
3439                   i.operands + 1);
3440           return NULL;
3441         }
3442       token_start = l;  /* after white space */
3443       paren_not_balanced = 0;
3444       while (paren_not_balanced || *l != ',')
3445         {
3446           if (*l == END_OF_INSN)
3447             {
3448               if (paren_not_balanced)
3449                 {
3450                   if (!intel_syntax)
3451                     as_bad (_("unbalanced parenthesis in operand %d."),
3452                             i.operands + 1);
3453                   else
3454                     as_bad (_("unbalanced brackets in operand %d."),
3455                             i.operands + 1);
3456                   return NULL;
3457                 }
3458               else
3459                 break;  /* we are done */
3460             }
3461           else if (!is_operand_char (*l) && !is_space_char (*l))
3462             {
3463               as_bad (_("invalid character %s in operand %d"),
3464                       output_invalid (*l),
3465                       i.operands + 1);
3466               return NULL;
3467             }
3468           if (!intel_syntax)
3469             {
3470               if (*l == '(')
3471                 ++paren_not_balanced;
3472               if (*l == ')')
3473                 --paren_not_balanced;
3474             }
3475           else
3476             {
3477               if (*l == '[')
3478                 ++paren_not_balanced;
3479               if (*l == ']')
3480                 --paren_not_balanced;
3481             }
3482           l++;
3483         }
3484       if (l != token_start)
3485         {                       /* Yes, we've read in another operand.  */
3486           unsigned int operand_ok;
3487           this_operand = i.operands++;
3488           i.types[this_operand].bitfield.unspecified = 1;
3489           if (i.operands > MAX_OPERANDS)
3490             {
3491               as_bad (_("spurious operands; (%d operands/instruction max)"),
3492                       MAX_OPERANDS);
3493               return NULL;
3494             }
3495           /* Now parse operand adding info to 'i' as we go along.  */
3496           END_STRING_AND_SAVE (l);
3497
3498           if (intel_syntax)
3499             operand_ok =
3500               i386_intel_operand (token_start,
3501                                   intel_float_operand (mnemonic));
3502           else
3503             operand_ok = i386_att_operand (token_start);
3504
3505           RESTORE_END_STRING (l);
3506           if (!operand_ok)
3507             return NULL;
3508         }
3509       else
3510         {
3511           if (expecting_operand)
3512             {
3513             expecting_operand_after_comma:
3514               as_bad (_("expecting operand after ','; got nothing"));
3515               return NULL;
3516             }
3517           if (*l == ',')
3518             {
3519               as_bad (_("expecting operand before ','; got nothing"));
3520               return NULL;
3521             }
3522         }
3523
3524       /* Now *l must be either ',' or END_OF_INSN.  */
3525       if (*l == ',')
3526         {
3527           if (*++l == END_OF_INSN)
3528             {
3529               /* Just skip it, if it's \n complain.  */
3530               goto expecting_operand_after_comma;
3531             }
3532           expecting_operand = 1;
3533         }
3534     }
3535   return l;
3536 }
3537
3538 static void
3539 swap_2_operands (int xchg1, int xchg2)
3540 {
3541   union i386_op temp_op;
3542   i386_operand_type temp_type;
3543   enum bfd_reloc_code_real temp_reloc;
3544
3545   temp_type = i.types[xchg2];
3546   i.types[xchg2] = i.types[xchg1];
3547   i.types[xchg1] = temp_type;
3548   temp_op = i.op[xchg2];
3549   i.op[xchg2] = i.op[xchg1];
3550   i.op[xchg1] = temp_op;
3551   temp_reloc = i.reloc[xchg2];
3552   i.reloc[xchg2] = i.reloc[xchg1];
3553   i.reloc[xchg1] = temp_reloc;
3554 }
3555
3556 static void
3557 swap_operands (void)
3558 {
3559   switch (i.operands)
3560     {
3561     case 5:
3562     case 4:
3563       swap_2_operands (1, i.operands - 2);
3564     case 3:
3565     case 2:
3566       swap_2_operands (0, i.operands - 1);
3567       break;
3568     default:
3569       abort ();
3570     }
3571
3572   if (i.mem_operands == 2)
3573     {
3574       const seg_entry *temp_seg;
3575       temp_seg = i.seg[0];
3576       i.seg[0] = i.seg[1];
3577       i.seg[1] = temp_seg;
3578     }
3579 }
3580
3581 /* Try to ensure constant immediates are represented in the smallest
3582    opcode possible.  */
3583 static void
3584 optimize_imm (void)
3585 {
3586   char guess_suffix = 0;
3587   int op;
3588
3589   if (i.suffix)
3590     guess_suffix = i.suffix;
3591   else if (i.reg_operands)
3592     {
3593       /* Figure out a suffix from the last register operand specified.
3594          We can't do this properly yet, ie. excluding InOutPortReg,
3595          but the following works for instructions with immediates.
3596          In any case, we can't set i.suffix yet.  */
3597       for (op = i.operands; --op >= 0;)
3598         if (i.types[op].bitfield.reg8)
3599           {
3600             guess_suffix = BYTE_MNEM_SUFFIX;
3601             break;
3602           }
3603         else if (i.types[op].bitfield.reg16)
3604           {
3605             guess_suffix = WORD_MNEM_SUFFIX;
3606             break;
3607           }
3608         else if (i.types[op].bitfield.reg32)
3609           {
3610             guess_suffix = LONG_MNEM_SUFFIX;
3611             break;
3612           }
3613         else if (i.types[op].bitfield.reg64)
3614           {
3615             guess_suffix = QWORD_MNEM_SUFFIX;
3616             break;
3617           }
3618     }
3619   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
3620     guess_suffix = WORD_MNEM_SUFFIX;
3621
3622   for (op = i.operands; --op >= 0;)
3623     if (operand_type_check (i.types[op], imm))
3624       {
3625         switch (i.op[op].imms->X_op)
3626           {
3627           case O_constant:
3628             /* If a suffix is given, this operand may be shortened.  */
3629             switch (guess_suffix)
3630               {
3631               case LONG_MNEM_SUFFIX:
3632                 i.types[op].bitfield.imm32 = 1;
3633                 i.types[op].bitfield.imm64 = 1;
3634                 break;
3635               case WORD_MNEM_SUFFIX:
3636                 i.types[op].bitfield.imm16 = 1;
3637                 i.types[op].bitfield.imm32 = 1;
3638                 i.types[op].bitfield.imm32s = 1;
3639                 i.types[op].bitfield.imm64 = 1;
3640                 break;
3641               case BYTE_MNEM_SUFFIX:
3642                 i.types[op].bitfield.imm8 = 1;
3643                 i.types[op].bitfield.imm8s = 1;
3644                 i.types[op].bitfield.imm16 = 1;
3645                 i.types[op].bitfield.imm32 = 1;
3646                 i.types[op].bitfield.imm32s = 1;
3647                 i.types[op].bitfield.imm64 = 1;
3648                 break;
3649               }
3650
3651             /* If this operand is at most 16 bits, convert it
3652                to a signed 16 bit number before trying to see
3653                whether it will fit in an even smaller size.
3654                This allows a 16-bit operand such as $0xffe0 to
3655                be recognised as within Imm8S range.  */
3656             if ((i.types[op].bitfield.imm16)
3657                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
3658               {
3659                 i.op[op].imms->X_add_number =
3660                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
3661               }
3662             if ((i.types[op].bitfield.imm32)
3663                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
3664                     == 0))
3665               {
3666                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
3667                                                 ^ ((offsetT) 1 << 31))
3668                                                - ((offsetT) 1 << 31));
3669               }
3670             i.types[op]
3671               = operand_type_or (i.types[op],
3672                                  smallest_imm_type (i.op[op].imms->X_add_number));
3673
3674             /* We must avoid matching of Imm32 templates when 64bit
3675                only immediate is available.  */
3676             if (guess_suffix == QWORD_MNEM_SUFFIX)
3677               i.types[op].bitfield.imm32 = 0;
3678             break;
3679
3680           case O_absent:
3681           case O_register:
3682             abort ();
3683
3684             /* Symbols and expressions.  */
3685           default:
3686             /* Convert symbolic operand to proper sizes for matching, but don't
3687                prevent matching a set of insns that only supports sizes other
3688                than those matching the insn suffix.  */
3689             {
3690               i386_operand_type mask, allowed;
3691               const insn_template *t;
3692
3693               operand_type_set (&mask, 0);
3694               operand_type_set (&allowed, 0);
3695
3696               for (t = current_templates->start;
3697                    t < current_templates->end;
3698                    ++t)
3699                 allowed = operand_type_or (allowed,
3700                                            t->operand_types[op]);
3701               switch (guess_suffix)
3702                 {
3703                 case QWORD_MNEM_SUFFIX:
3704                   mask.bitfield.imm64 = 1;
3705                   mask.bitfield.imm32s = 1;
3706                   break;
3707                 case LONG_MNEM_SUFFIX:
3708                   mask.bitfield.imm32 = 1;
3709                   break;
3710                 case WORD_MNEM_SUFFIX:
3711                   mask.bitfield.imm16 = 1;
3712                   break;
3713                 case BYTE_MNEM_SUFFIX:
3714                   mask.bitfield.imm8 = 1;
3715                   break;
3716                 default:
3717                   break;
3718                 }
3719               allowed = operand_type_and (mask, allowed);
3720               if (!operand_type_all_zero (&allowed))
3721                 i.types[op] = operand_type_and (i.types[op], mask);
3722             }
3723             break;
3724           }
3725       }
3726 }
3727
3728 /* Try to use the smallest displacement type too.  */
3729 static void
3730 optimize_disp (void)
3731 {
3732   int op;
3733
3734   for (op = i.operands; --op >= 0;)
3735     if (operand_type_check (i.types[op], disp))
3736       {
3737         if (i.op[op].disps->X_op == O_constant)
3738           {
3739             offsetT op_disp = i.op[op].disps->X_add_number;
3740
3741             if (i.types[op].bitfield.disp16
3742                 && (op_disp & ~(offsetT) 0xffff) == 0)
3743               {
3744                 /* If this operand is at most 16 bits, convert
3745                    to a signed 16 bit number and don't use 64bit
3746                    displacement.  */
3747                 op_disp = (((op_disp & 0xffff) ^ 0x8000) - 0x8000);
3748                 i.types[op].bitfield.disp64 = 0;
3749               }
3750             if (i.types[op].bitfield.disp32
3751                 && (op_disp & ~(((offsetT) 2 << 31) - 1)) == 0)
3752               {
3753                 /* If this operand is at most 32 bits, convert
3754                    to a signed 32 bit number and don't use 64bit
3755                    displacement.  */
3756                 op_disp &= (((offsetT) 2 << 31) - 1);
3757                 op_disp = (op_disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
3758                 i.types[op].bitfield.disp64 = 0;
3759               }
3760             if (!op_disp && i.types[op].bitfield.baseindex)
3761               {
3762                 i.types[op].bitfield.disp8 = 0;
3763                 i.types[op].bitfield.disp16 = 0;
3764                 i.types[op].bitfield.disp32 = 0;
3765                 i.types[op].bitfield.disp32s = 0;
3766                 i.types[op].bitfield.disp64 = 0;
3767                 i.op[op].disps = 0;
3768                 i.disp_operands--;
3769               }
3770             else if (flag_code == CODE_64BIT)
3771               {
3772                 if (fits_in_signed_long (op_disp))
3773                   {
3774                     i.types[op].bitfield.disp64 = 0;
3775                     i.types[op].bitfield.disp32s = 1;
3776                   }
3777                 if (i.prefix[ADDR_PREFIX]
3778                     && fits_in_unsigned_long (op_disp))
3779                   i.types[op].bitfield.disp32 = 1;
3780               }
3781             if ((i.types[op].bitfield.disp32
3782                  || i.types[op].bitfield.disp32s
3783                  || i.types[op].bitfield.disp16)
3784                 && fits_in_signed_byte (op_disp))
3785               i.types[op].bitfield.disp8 = 1;
3786           }
3787         else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
3788                  || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
3789           {
3790             fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
3791                          i.op[op].disps, 0, i.reloc[op]);
3792             i.types[op].bitfield.disp8 = 0;
3793             i.types[op].bitfield.disp16 = 0;
3794             i.types[op].bitfield.disp32 = 0;
3795             i.types[op].bitfield.disp32s = 0;
3796             i.types[op].bitfield.disp64 = 0;
3797           }
3798         else
3799           /* We only support 64bit displacement on constants.  */
3800           i.types[op].bitfield.disp64 = 0;
3801       }
3802 }
3803
3804 /* Check if operands are valid for the instruction.  Update VEX
3805    operand types.  */
3806
3807 static int
3808 VEX_check_operands (const insn_template *t)
3809 {
3810   if (!t->opcode_modifier.vex)
3811     return 0;
3812
3813   /* Only check VEX_Imm4, which must be the first operand.  */
3814   if (t->operand_types[0].bitfield.vec_imm4)
3815     {
3816       if (i.op[0].imms->X_op != O_constant
3817           || !fits_in_imm4 (i.op[0].imms->X_add_number))
3818         {
3819           i.error = bad_imm4;
3820           return 1;
3821         }
3822
3823       /* Turn off Imm8 so that update_imm won't complain.  */
3824       i.types[0] = vec_imm4;
3825     }
3826
3827   return 0;
3828 }
3829
3830 static const insn_template *
3831 match_template (void)
3832 {
3833   /* Points to template once we've found it.  */
3834   const insn_template *t;
3835   i386_operand_type overlap0, overlap1, overlap2, overlap3;
3836   i386_operand_type overlap4;
3837   unsigned int found_reverse_match;
3838   i386_opcode_modifier suffix_check;
3839   i386_operand_type operand_types [MAX_OPERANDS];
3840   int addr_prefix_disp;
3841   unsigned int j;
3842   unsigned int found_cpu_match;
3843   unsigned int check_register;
3844
3845 #if MAX_OPERANDS != 5
3846 # error "MAX_OPERANDS must be 5."
3847 #endif
3848
3849   found_reverse_match = 0;
3850   addr_prefix_disp = -1;
3851
3852   memset (&suffix_check, 0, sizeof (suffix_check));
3853   if (i.suffix == BYTE_MNEM_SUFFIX)
3854     suffix_check.no_bsuf = 1;
3855   else if (i.suffix == WORD_MNEM_SUFFIX)
3856     suffix_check.no_wsuf = 1;
3857   else if (i.suffix == SHORT_MNEM_SUFFIX)
3858     suffix_check.no_ssuf = 1;
3859   else if (i.suffix == LONG_MNEM_SUFFIX)
3860     suffix_check.no_lsuf = 1;
3861   else if (i.suffix == QWORD_MNEM_SUFFIX)
3862     suffix_check.no_qsuf = 1;
3863   else if (i.suffix == LONG_DOUBLE_MNEM_SUFFIX)
3864     suffix_check.no_ldsuf = 1;
3865
3866   /* Must have right number of operands.  */
3867   i.error = number_of_operands_mismatch;
3868
3869   for (t = current_templates->start; t < current_templates->end; t++)
3870     {
3871       addr_prefix_disp = -1;
3872
3873       if (i.operands != t->operands)
3874         continue;
3875
3876       /* Check processor support.  */
3877       i.error = unsupported;
3878       found_cpu_match = (cpu_flags_match (t)
3879                          == CPU_FLAGS_PERFECT_MATCH);
3880       if (!found_cpu_match)
3881         continue;
3882
3883       /* Check old gcc support. */
3884       i.error = old_gcc_only;
3885       if (!old_gcc && t->opcode_modifier.oldgcc)
3886         continue;
3887
3888       /* Check AT&T mnemonic.   */
3889       i.error = unsupported_with_intel_mnemonic;
3890       if (intel_mnemonic && t->opcode_modifier.attmnemonic)
3891         continue;
3892
3893       /* Check AT&T/Intel syntax.   */
3894       i.error = unsupported_syntax;
3895       if ((intel_syntax && t->opcode_modifier.attsyntax)
3896           || (!intel_syntax && t->opcode_modifier.intelsyntax))
3897         continue;
3898
3899       /* Check the suffix, except for some instructions in intel mode.  */
3900       i.error = invalid_instruction_suffix;
3901       if ((!intel_syntax || !t->opcode_modifier.ignoresize)
3902           && ((t->opcode_modifier.no_bsuf && suffix_check.no_bsuf)
3903               || (t->opcode_modifier.no_wsuf && suffix_check.no_wsuf)
3904               || (t->opcode_modifier.no_lsuf && suffix_check.no_lsuf)
3905               || (t->opcode_modifier.no_ssuf && suffix_check.no_ssuf)
3906               || (t->opcode_modifier.no_qsuf && suffix_check.no_qsuf)
3907               || (t->opcode_modifier.no_ldsuf && suffix_check.no_ldsuf)))
3908         continue;
3909
3910       if (!operand_size_match (t))
3911         continue;
3912
3913       for (j = 0; j < MAX_OPERANDS; j++)
3914         operand_types[j] = t->operand_types[j];
3915
3916       /* In general, don't allow 64-bit operands in 32-bit mode.  */
3917       if (i.suffix == QWORD_MNEM_SUFFIX
3918           && flag_code != CODE_64BIT
3919           && (intel_syntax
3920               ? (!t->opcode_modifier.ignoresize
3921                  && !intel_float_operand (t->name))
3922               : intel_float_operand (t->name) != 2)
3923           && ((!operand_types[0].bitfield.regmmx
3924                && !operand_types[0].bitfield.regxmm
3925                && !operand_types[0].bitfield.regymm)
3926               || (!operand_types[t->operands > 1].bitfield.regmmx
3927                   && !!operand_types[t->operands > 1].bitfield.regxmm
3928                   && !!operand_types[t->operands > 1].bitfield.regymm))
3929           && (t->base_opcode != 0x0fc7
3930               || t->extension_opcode != 1 /* cmpxchg8b */))
3931         continue;
3932
3933       /* In general, don't allow 32-bit operands on pre-386.  */
3934       else if (i.suffix == LONG_MNEM_SUFFIX
3935                && !cpu_arch_flags.bitfield.cpui386
3936                && (intel_syntax
3937                    ? (!t->opcode_modifier.ignoresize
3938                       && !intel_float_operand (t->name))
3939                    : intel_float_operand (t->name) != 2)
3940                && ((!operand_types[0].bitfield.regmmx
3941                     && !operand_types[0].bitfield.regxmm)
3942                    || (!operand_types[t->operands > 1].bitfield.regmmx
3943                        && !!operand_types[t->operands > 1].bitfield.regxmm)))
3944         continue;
3945
3946       /* Do not verify operands when there are none.  */
3947       else
3948         {
3949           if (!t->operands)
3950             /* We've found a match; break out of loop.  */
3951             break;
3952         }
3953
3954       /* Address size prefix will turn Disp64/Disp32/Disp16 operand
3955          into Disp32/Disp16/Disp32 operand.  */
3956       if (i.prefix[ADDR_PREFIX] != 0)
3957           {
3958             /* There should be only one Disp operand.  */
3959             switch (flag_code)
3960             {
3961             case CODE_16BIT:
3962               for (j = 0; j < MAX_OPERANDS; j++)
3963                 {
3964                   if (operand_types[j].bitfield.disp16)
3965                     {
3966                       addr_prefix_disp = j;
3967                       operand_types[j].bitfield.disp32 = 1;
3968                       operand_types[j].bitfield.disp16 = 0;
3969                       break;
3970                     }
3971                 }
3972               break;
3973             case CODE_32BIT:
3974               for (j = 0; j < MAX_OPERANDS; j++)
3975                 {
3976                   if (operand_types[j].bitfield.disp32)
3977                     {
3978                       addr_prefix_disp = j;
3979                       operand_types[j].bitfield.disp32 = 0;
3980                       operand_types[j].bitfield.disp16 = 1;
3981                       break;
3982                     }
3983                 }
3984               break;
3985             case CODE_64BIT:
3986               for (j = 0; j < MAX_OPERANDS; j++)
3987                 {
3988                   if (operand_types[j].bitfield.disp64)
3989                     {
3990                       addr_prefix_disp = j;
3991                       operand_types[j].bitfield.disp64 = 0;
3992                       operand_types[j].bitfield.disp32 = 1;
3993                       break;
3994                     }
3995                 }
3996               break;
3997             }
3998           }
3999
4000       /* We check register size if needed.  */
4001       check_register = t->opcode_modifier.checkregsize;
4002       overlap0 = operand_type_and (i.types[0], operand_types[0]);
4003       switch (t->operands)
4004         {
4005         case 1:
4006           if (!operand_type_match (overlap0, i.types[0]))
4007             continue;
4008           break;
4009         case 2:
4010           /* xchg %eax, %eax is a special case. It is an aliase for nop
4011              only in 32bit mode and we can use opcode 0x90.  In 64bit
4012              mode, we can't use 0x90 for xchg %eax, %eax since it should
4013              zero-extend %eax to %rax.  */
4014           if (flag_code == CODE_64BIT
4015               && t->base_opcode == 0x90
4016               && operand_type_equal (&i.types [0], &acc32)
4017               && operand_type_equal (&i.types [1], &acc32))
4018             continue;
4019           if (i.swap_operand)
4020             {
4021               /* If we swap operand in encoding, we either match
4022                  the next one or reverse direction of operands.  */
4023               if (t->opcode_modifier.s)
4024                 continue;
4025               else if (t->opcode_modifier.d)
4026                 goto check_reverse;
4027             }
4028
4029         case 3:
4030           /* If we swap operand in encoding, we match the next one.  */
4031           if (i.swap_operand && t->opcode_modifier.s)
4032             continue;
4033         case 4:
4034         case 5:
4035           overlap1 = operand_type_and (i.types[1], operand_types[1]);
4036           if (!operand_type_match (overlap0, i.types[0])
4037               || !operand_type_match (overlap1, i.types[1])
4038               || (check_register
4039                   && !operand_type_register_match (overlap0, i.types[0],
4040                                                    operand_types[0],
4041                                                    overlap1, i.types[1],
4042                                                    operand_types[1])))
4043             {
4044               /* Check if other direction is valid ...  */
4045               if (!t->opcode_modifier.d && !t->opcode_modifier.floatd)
4046                 continue;
4047
4048 check_reverse:
4049               /* Try reversing direction of operands.  */
4050               overlap0 = operand_type_and (i.types[0], operand_types[1]);
4051               overlap1 = operand_type_and (i.types[1], operand_types[0]);
4052               if (!operand_type_match (overlap0, i.types[0])
4053                   || !operand_type_match (overlap1, i.types[1])
4054                   || (check_register
4055                       && !operand_type_register_match (overlap0,
4056                                                        i.types[0],
4057                                                        operand_types[1],
4058                                                        overlap1,
4059                                                        i.types[1],
4060                                                        operand_types[0])))
4061                 {
4062                   /* Does not match either direction.  */
4063                   continue;
4064                 }
4065               /* found_reverse_match holds which of D or FloatDR
4066                  we've found.  */
4067               if (t->opcode_modifier.d)
4068                 found_reverse_match = Opcode_D;
4069               else if (t->opcode_modifier.floatd)
4070                 found_reverse_match = Opcode_FloatD;
4071               else
4072                 found_reverse_match = 0;
4073               if (t->opcode_modifier.floatr)
4074                 found_reverse_match |= Opcode_FloatR;
4075             }
4076           else
4077             {
4078               /* Found a forward 2 operand match here.  */
4079               switch (t->operands)
4080                 {
4081                 case 5:
4082                   overlap4 = operand_type_and (i.types[4],
4083                                                operand_types[4]);
4084                 case 4:
4085                   overlap3 = operand_type_and (i.types[3],
4086                                                operand_types[3]);
4087                 case 3:
4088                   overlap2 = operand_type_and (i.types[2],
4089                                                operand_types[2]);
4090                   break;
4091                 }
4092
4093               switch (t->operands)
4094                 {
4095                 case 5:
4096                   if (!operand_type_match (overlap4, i.types[4])
4097                       || !operand_type_register_match (overlap3,
4098                                                        i.types[3],
4099                                                        operand_types[3],
4100                                                        overlap4,
4101                                                        i.types[4],
4102                                                        operand_types[4]))
4103                     continue;
4104                 case 4:
4105                   if (!operand_type_match (overlap3, i.types[3])
4106                       || (check_register
4107                           && !operand_type_register_match (overlap2,
4108                                                            i.types[2],
4109                                                            operand_types[2],
4110                                                            overlap3,
4111                                                            i.types[3],
4112                                                            operand_types[3])))
4113                     continue;
4114                 case 3:
4115                   /* Here we make use of the fact that there are no
4116                      reverse match 3 operand instructions, and all 3
4117                      operand instructions only need to be checked for
4118                      register consistency between operands 2 and 3.  */
4119                   if (!operand_type_match (overlap2, i.types[2])
4120                       || (check_register
4121                           && !operand_type_register_match (overlap1,
4122