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