Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / contrib / binutils / gas / config / tc-i386.c
1 /* i386.c -- Assemble code for the Intel 80386
2    Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2000, 2001, 2002
4    Free Software Foundation, Inc.
5
6    This file is part of GAS, the GNU Assembler.
7
8    GAS is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2, or (at your option)
11    any later version.
12
13    GAS is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GAS; see the file COPYING.  If not, write to the Free
20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
21    02111-1307, USA.  */
22
23
24 /* $FreeBSD: src/contrib/binutils/gas/config/tc-i386.c,v 1.4.2.4 2002/09/01 23:44:03 obrien Exp $ */
25 /* $DragonFly: src/contrib/binutils/gas/config/Attic/tc-i386.c,v 1.2 2003/06/17 04:23:58 dillon Exp $ */
26
27
28 /* Intel 80386 machine specific gas.
29    Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
30    x86_64 support by Jan Hubicka (jh@suse.cz)
31    Bugs & suggestions are completely welcome.  This is free software.
32    Please help us make it better.  */
33
34 #include "as.h"
35 #include "safe-ctype.h"
36 #include "subsegs.h"
37 #include "dwarf2dbg.h"
38 #include "opcode/i386.h"
39
40 #ifndef REGISTER_WARNINGS
41 #define REGISTER_WARNINGS 1
42 #endif
43
44 #ifndef INFER_ADDR_PREFIX
45 #define INFER_ADDR_PREFIX 1
46 #endif
47
48 #ifndef SCALE1_WHEN_NO_INDEX
49 /* Specifying a scale factor besides 1 when there is no index is
50    futile.  eg. `mov (%ebx,2),%al' does exactly the same as
51    `mov (%ebx),%al'.  To slavishly follow what the programmer
52    specified, set SCALE1_WHEN_NO_INDEX to 0.  */
53 #define SCALE1_WHEN_NO_INDEX 1
54 #endif
55
56 #ifdef BFD_ASSEMBLER
57 #define RELOC_ENUM enum bfd_reloc_code_real
58 #else
59 #define RELOC_ENUM int
60 #endif
61
62 #ifndef DEFAULT_ARCH
63 #define DEFAULT_ARCH "i386"
64 #endif
65
66 #ifndef INLINE
67 #if __GNUC__ >= 2
68 #define INLINE __inline__
69 #else
70 #define INLINE
71 #endif
72 #endif
73
74 static INLINE unsigned int mode_from_disp_size PARAMS ((unsigned int));
75 static INLINE int fits_in_signed_byte PARAMS ((offsetT));
76 static INLINE int fits_in_unsigned_byte PARAMS ((offsetT));
77 static INLINE int fits_in_unsigned_word PARAMS ((offsetT));
78 static INLINE int fits_in_signed_word PARAMS ((offsetT));
79 static INLINE int fits_in_unsigned_long PARAMS ((offsetT));
80 static INLINE int fits_in_signed_long PARAMS ((offsetT));
81 static int smallest_imm_type PARAMS ((offsetT));
82 static offsetT offset_in_range PARAMS ((offsetT, int));
83 static int add_prefix PARAMS ((unsigned int));
84 static void set_code_flag PARAMS ((int));
85 static void set_16bit_gcc_code_flag PARAMS ((int));
86 static void set_intel_syntax PARAMS ((int));
87 static void set_cpu_arch PARAMS ((int));
88 static char *output_invalid PARAMS ((int c));
89 static int i386_operand PARAMS ((char *operand_string));
90 static int i386_intel_operand PARAMS ((char *operand_string, int got_a_float));
91 static const reg_entry *parse_register PARAMS ((char *reg_string,
92                                                 char **end_op));
93 static char *parse_insn PARAMS ((char *, char *));
94 static char *parse_operands PARAMS ((char *, const char *));
95 static void swap_operands PARAMS ((void));
96 static void optimize_imm PARAMS ((void));
97 static void optimize_disp PARAMS ((void));
98 static int match_template PARAMS ((void));
99 static int check_string PARAMS ((void));
100 static int process_suffix PARAMS ((void));
101 static int check_byte_reg PARAMS ((void));
102 static int check_long_reg PARAMS ((void));
103 static int check_qword_reg PARAMS ((void));
104 static int check_word_reg PARAMS ((void));
105 static int finalize_imm PARAMS ((void));
106 static int process_operands PARAMS ((void));
107 static const seg_entry *build_modrm_byte PARAMS ((void));
108 static void output_insn PARAMS ((void));
109 static void output_branch PARAMS ((void));
110 static void output_jump PARAMS ((void));
111 static void output_interseg_jump PARAMS ((void));
112 static void output_imm PARAMS ((void));
113 static void output_disp PARAMS ((void));
114 #ifndef I386COFF
115 static void s_bss PARAMS ((int));
116 #endif
117
118 static const char *default_arch = DEFAULT_ARCH;
119
120 /* 'md_assemble ()' gathers together information and puts it into a
121    i386_insn.  */
122
123 union i386_op
124   {
125     expressionS *disps;
126     expressionS *imms;
127     const reg_entry *regs;
128   };
129
130 struct _i386_insn
131   {
132     /* TM holds the template for the insn were currently assembling.  */
133     template tm;
134
135     /* SUFFIX holds the instruction mnemonic suffix if given.
136        (e.g. 'l' for 'movl')  */
137     char suffix;
138
139     /* OPERANDS gives the number of given operands.  */
140     unsigned int operands;
141
142     /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
143        of given register, displacement, memory operands and immediate
144        operands.  */
145     unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
146
147     /* TYPES [i] is the type (see above #defines) which tells us how to
148        use OP[i] for the corresponding operand.  */
149     unsigned int types[MAX_OPERANDS];
150
151     /* Displacement expression, immediate expression, or register for each
152        operand.  */
153     union i386_op op[MAX_OPERANDS];
154
155     /* Flags for operands.  */
156     unsigned int flags[MAX_OPERANDS];
157 #define Operand_PCrel 1
158
159     /* Relocation type for operand */
160     RELOC_ENUM reloc[MAX_OPERANDS];
161
162     /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
163        the base index byte below.  */
164     const reg_entry *base_reg;
165     const reg_entry *index_reg;
166     unsigned int log2_scale_factor;
167
168     /* SEG gives the seg_entries of this insn.  They are zero unless
169        explicit segment overrides are given.  */
170     const seg_entry *seg[2];
171
172     /* PREFIX holds all the given prefix opcodes (usually null).
173        PREFIXES is the number of prefix opcodes.  */
174     unsigned int prefixes;
175     unsigned char prefix[MAX_PREFIXES];
176
177     /* RM and SIB are the modrm byte and the sib byte where the
178        addressing modes of this insn are encoded.  */
179
180     modrm_byte rm;
181     rex_byte rex;
182     sib_byte sib;
183   };
184
185 typedef struct _i386_insn i386_insn;
186
187 /* List of chars besides those in app.c:symbol_chars that can start an
188    operand.  Used to prevent the scrubber eating vital white-space.  */
189 #ifdef LEX_AT
190 const char extra_symbol_chars[] = "*%-(@[";
191 #else
192 const char extra_symbol_chars[] = "*%-([";
193 #endif
194
195 #if (defined (TE_I386AIX)                               \
196      || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
197          && !defined (TE_LINUX)                         \
198          && !defined (TE_FreeBSD)                       \
199          && !defined (TE_NetBSD)))
200 /* This array holds the chars that always start a comment.  If the
201    pre-processor is disabled, these aren't very useful.  */
202 const char comment_chars[] = "#/";
203 #define PREFIX_SEPARATOR '\\'
204
205 /* This array holds the chars that only start a comment at the beginning of
206    a line.  If the line seems to have the form '# 123 filename'
207    .line and .file directives will appear in the pre-processed output.
208    Note that input_file.c hand checks for '#' at the beginning of the
209    first line of the input file.  This is because the compiler outputs
210    #NO_APP at the beginning of its output.
211    Also note that comments started like this one will always work if
212    '/' isn't otherwise defined.  */
213 const char line_comment_chars[] = "";
214
215 #else
216 /* Putting '/' here makes it impossible to use the divide operator.
217    However, we need it for compatibility with SVR4 systems.  */
218 const char comment_chars[] = "#";
219 #define PREFIX_SEPARATOR '/'
220
221 const char line_comment_chars[] = "/";
222 #endif
223
224 const char line_separator_chars[] = ";";
225
226 /* Chars that can be used to separate mant from exp in floating point
227    nums.  */
228 const char EXP_CHARS[] = "eE";
229
230 /* Chars that mean this number is a floating point constant
231    As in 0f12.456
232    or    0d1.2345e12.  */
233 const char FLT_CHARS[] = "fFdDxX";
234
235 /* Tables for lexical analysis.  */
236 static char mnemonic_chars[256];
237 static char register_chars[256];
238 static char operand_chars[256];
239 static char identifier_chars[256];
240 static char digit_chars[256];
241
242 /* Lexical macros.  */
243 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
244 #define is_operand_char(x) (operand_chars[(unsigned char) x])
245 #define is_register_char(x) (register_chars[(unsigned char) x])
246 #define is_space_char(x) ((x) == ' ')
247 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
248 #define is_digit_char(x) (digit_chars[(unsigned char) x])
249
250 /* All non-digit non-letter charcters that may occur in an operand.  */
251 static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
252
253 /* md_assemble() always leaves the strings it's passed unaltered.  To
254    effect this we maintain a stack of saved characters that we've smashed
255    with '\0's (indicating end of strings for various sub-fields of the
256    assembler instruction).  */
257 static char save_stack[32];
258 static char *save_stack_p;
259 #define END_STRING_AND_SAVE(s) \
260         do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
261 #define RESTORE_END_STRING(s) \
262         do { *(s) = *--save_stack_p; } while (0)
263
264 /* The instruction we're assembling.  */
265 static i386_insn i;
266
267 /* Possible templates for current insn.  */
268 static const templates *current_templates;
269
270 /* Per instruction expressionS buffers: 2 displacements & 2 immediate max.  */
271 static expressionS disp_expressions[2], im_expressions[2];
272
273 /* Current operand we are working on.  */
274 static int this_operand;
275
276 /* We support four different modes.  FLAG_CODE variable is used to distinguish
277    these.  */
278
279 enum flag_code {
280         CODE_32BIT,
281         CODE_16BIT,
282         CODE_64BIT };
283 #define NUM_FLAG_CODE ((int) CODE_64BIT + 1)
284
285 static enum flag_code flag_code;
286 static int use_rela_relocations = 0;
287
288 /* The names used to print error messages.  */
289 static const char *flag_code_names[] =
290   {
291     "32",
292     "16",
293     "64"
294   };
295
296 /* 1 for intel syntax,
297    0 if att syntax.  */
298 static int intel_syntax = 0;
299
300 /* 1 if register prefix % not required.  */
301 static int allow_naked_reg = 0;
302
303 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
304    leave, push, and pop instructions so that gcc has the same stack
305    frame as in 32 bit mode.  */
306 static char stackop_size = '\0';
307
308 /* Non-zero to quieten some warnings.  */
309 static int quiet_warnings = 0;
310
311 /* CPU name.  */
312 static const char *cpu_arch_name = NULL;
313
314 /* CPU feature flags.  */
315 static unsigned int cpu_arch_flags = CpuUnknownFlags | CpuNo64;
316
317 /* If set, conditional jumps are not automatically promoted to handle
318    larger than a byte offset.  */
319 static unsigned int no_cond_jump_promotion = 0;
320
321 /* Pre-defined "_GLOBAL_OFFSET_TABLE_".  */
322 symbolS *GOT_symbol;
323
324 /* Interface to relax_segment.
325    There are 3 major relax states for 386 jump insns because the
326    different types of jumps add different sizes to frags when we're
327    figuring out what sort of jump to choose to reach a given label.  */
328
329 /* Types.  */
330 #define UNCOND_JUMP 0
331 #define COND_JUMP 1
332 #define COND_JUMP86 2
333
334 /* Sizes.  */
335 #define CODE16  1
336 #define SMALL   0
337 #define SMALL16 (SMALL | CODE16)
338 #define BIG     2
339 #define BIG16   (BIG | CODE16)
340
341 #ifndef INLINE
342 #ifdef __GNUC__
343 #define INLINE __inline__
344 #else
345 #define INLINE
346 #endif
347 #endif
348
349 #define ENCODE_RELAX_STATE(type, size) \
350   ((relax_substateT) (((type) << 2) | (size)))
351 #define TYPE_FROM_RELAX_STATE(s) \
352   ((s) >> 2)
353 #define DISP_SIZE_FROM_RELAX_STATE(s) \
354     ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
355
356 /* This table is used by relax_frag to promote short jumps to long
357    ones where necessary.  SMALL (short) jumps may be promoted to BIG
358    (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long).  We
359    don't allow a short jump in a 32 bit code segment to be promoted to
360    a 16 bit offset jump because it's slower (requires data size
361    prefix), and doesn't work, unless the destination is in the bottom
362    64k of the code segment (The top 16 bits of eip are zeroed).  */
363
364 const relax_typeS md_relax_table[] =
365 {
366   /* The fields are:
367      1) most positive reach of this state,
368      2) most negative reach of this state,
369      3) how many bytes this mode will have in the variable part of the frag
370      4) which index into the table to try if we can't fit into this one.  */
371
372   /* UNCOND_JUMP states.  */
373   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
374   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
375   /* dword jmp adds 4 bytes to frag:
376      0 extra opcode bytes, 4 displacement bytes.  */
377   {0, 0, 4, 0},
378   /* word jmp adds 2 byte2 to frag:
379      0 extra opcode bytes, 2 displacement bytes.  */
380   {0, 0, 2, 0},
381
382   /* COND_JUMP states.  */
383   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
384   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
385   /* dword conditionals adds 5 bytes to frag:
386      1 extra opcode byte, 4 displacement bytes.  */
387   {0, 0, 5, 0},
388   /* word conditionals add 3 bytes to frag:
389      1 extra opcode byte, 2 displacement bytes.  */
390   {0, 0, 3, 0},
391
392   /* COND_JUMP86 states.  */
393   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
394   {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
395   /* dword conditionals adds 5 bytes to frag:
396      1 extra opcode byte, 4 displacement bytes.  */
397   {0, 0, 5, 0},
398   /* word conditionals add 4 bytes to frag:
399      1 displacement byte and a 3 byte long branch insn.  */
400   {0, 0, 4, 0}
401 };
402
403 static const arch_entry cpu_arch[] = {
404   {"i8086",     Cpu086 },
405   {"i186",      Cpu086|Cpu186 },
406   {"i286",      Cpu086|Cpu186|Cpu286 },
407   {"i386",      Cpu086|Cpu186|Cpu286|Cpu386 },
408   {"i486",      Cpu086|Cpu186|Cpu286|Cpu386|Cpu486 },
409   {"i586",      Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuMMX },
410   {"i686",      Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuSSE },
411   {"pentium",   Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuMMX },
412   {"pentiumpro",Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuSSE },
413   {"pentium4",  Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX|CpuSSE|CpuSSE2 },
414   {"k6",        Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX|Cpu3dnow },
415   {"athlon",    Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuAthlon|CpuMMX|Cpu3dnow },
416   {"sledgehammer",Cpu086|Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuAthlon|CpuSledgehammer|CpuMMX|Cpu3dnow|CpuSSE|CpuSSE2 },
417   {NULL, 0 }
418 };
419
420 const pseudo_typeS md_pseudo_table[] =
421 {
422 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
423   {"align", s_align_bytes, 0},
424 #else
425   {"align", s_align_ptwo, 0},
426 #endif
427   {"arch", set_cpu_arch, 0},
428 #ifndef I386COFF
429   {"bss", s_bss, 0},
430 #endif
431   {"ffloat", float_cons, 'f'},
432   {"dfloat", float_cons, 'd'},
433   {"tfloat", float_cons, 'x'},
434   {"value", cons, 2},
435   {"noopt", s_ignore, 0},
436   {"optim", s_ignore, 0},
437   {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
438   {"code16", set_code_flag, CODE_16BIT},
439   {"code32", set_code_flag, CODE_32BIT},
440   {"code64", set_code_flag, CODE_64BIT},
441   {"intel_syntax", set_intel_syntax, 1},
442   {"att_syntax", set_intel_syntax, 0},
443   {"file", dwarf2_directive_file, 0},
444   {"loc", dwarf2_directive_loc, 0},
445   {0, 0, 0}
446 };
447
448 /* For interface with expression ().  */
449 extern char *input_line_pointer;
450
451 /* Hash table for instruction mnemonic lookup.  */
452 static struct hash_control *op_hash;
453
454 /* Hash table for register lookup.  */
455 static struct hash_control *reg_hash;
456 \f
457 void
458 i386_align_code (fragP, count)
459      fragS *fragP;
460      int count;
461 {
462   /* Various efficient no-op patterns for aligning code labels.
463      Note: Don't try to assemble the instructions in the comments.
464      0L and 0w are not legal.  */
465   static const char f32_1[] =
466     {0x90};                                     /* nop                  */
467   static const char f32_2[] =
468     {0x89,0xf6};                                /* movl %esi,%esi       */
469   static const char f32_3[] =
470     {0x8d,0x76,0x00};                           /* leal 0(%esi),%esi    */
471   static const char f32_4[] =
472     {0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
473   static const char f32_5[] =
474     {0x90,                                      /* nop                  */
475      0x8d,0x74,0x26,0x00};                      /* leal 0(%esi,1),%esi  */
476   static const char f32_6[] =
477     {0x8d,0xb6,0x00,0x00,0x00,0x00};            /* leal 0L(%esi),%esi   */
478   static const char f32_7[] =
479     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
480   static const char f32_8[] =
481     {0x90,                                      /* nop                  */
482      0x8d,0xb4,0x26,0x00,0x00,0x00,0x00};       /* leal 0L(%esi,1),%esi */
483   static const char f32_9[] =
484     {0x89,0xf6,                                 /* movl %esi,%esi       */
485      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
486   static const char f32_10[] =
487     {0x8d,0x76,0x00,                            /* leal 0(%esi),%esi    */
488      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
489   static const char f32_11[] =
490     {0x8d,0x74,0x26,0x00,                       /* leal 0(%esi,1),%esi  */
491      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
492   static const char f32_12[] =
493     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
494      0x8d,0xbf,0x00,0x00,0x00,0x00};            /* leal 0L(%edi),%edi   */
495   static const char f32_13[] =
496     {0x8d,0xb6,0x00,0x00,0x00,0x00,             /* leal 0L(%esi),%esi   */
497      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
498   static const char f32_14[] =
499     {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00,        /* leal 0L(%esi,1),%esi */
500      0x8d,0xbc,0x27,0x00,0x00,0x00,0x00};       /* leal 0L(%edi,1),%edi */
501   static const char f32_15[] =
502     {0xeb,0x0d,0x90,0x90,0x90,0x90,0x90,        /* jmp .+15; lotsa nops */
503      0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
504   static const char f16_3[] =
505     {0x8d,0x74,0x00};                           /* lea 0(%esi),%esi     */
506   static const char f16_4[] =
507     {0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
508   static const char f16_5[] =
509     {0x90,                                      /* nop                  */
510      0x8d,0xb4,0x00,0x00};                      /* lea 0w(%si),%si      */
511   static const char f16_6[] =
512     {0x89,0xf6,                                 /* mov %si,%si          */
513      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
514   static const char f16_7[] =
515     {0x8d,0x74,0x00,                            /* lea 0(%si),%si       */
516      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
517   static const char f16_8[] =
518     {0x8d,0xb4,0x00,0x00,                       /* lea 0w(%si),%si      */
519      0x8d,0xbd,0x00,0x00};                      /* lea 0w(%di),%di      */
520   static const char *const f32_patt[] = {
521     f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
522     f32_9, f32_10, f32_11, f32_12, f32_13, f32_14, f32_15
523   };
524   static const char *const f16_patt[] = {
525     f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8,
526     f32_15, f32_15, f32_15, f32_15, f32_15, f32_15, f32_15
527   };
528
529   /* ??? We can't use these fillers for x86_64, since they often kills the
530      upper halves.  Solve later.  */
531   if (flag_code == CODE_64BIT)
532     count = 1;
533
534   if (count > 0 && count <= 15)
535     {
536       if (flag_code == CODE_16BIT)
537         {
538           memcpy (fragP->fr_literal + fragP->fr_fix,
539                   f16_patt[count - 1], count);
540           if (count > 8)
541             /* Adjust jump offset.  */
542             fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
543         }
544       else
545         memcpy (fragP->fr_literal + fragP->fr_fix,
546                 f32_patt[count - 1], count);
547       fragP->fr_var = count;
548     }
549 }
550
551 static INLINE unsigned int
552 mode_from_disp_size (t)
553      unsigned int t;
554 {
555   return (t & Disp8) ? 1 : (t & (Disp16 | Disp32 | Disp32S)) ? 2 : 0;
556 }
557
558 static INLINE int
559 fits_in_signed_byte (num)
560      offsetT num;
561 {
562   return (num >= -128) && (num <= 127);
563 }
564
565 static INLINE int
566 fits_in_unsigned_byte (num)
567      offsetT num;
568 {
569   return (num & 0xff) == num;
570 }
571
572 static INLINE int
573 fits_in_unsigned_word (num)
574      offsetT num;
575 {
576   return (num & 0xffff) == num;
577 }
578
579 static INLINE int
580 fits_in_signed_word (num)
581      offsetT num;
582 {
583   return (-32768 <= num) && (num <= 32767);
584 }
585 static INLINE int
586 fits_in_signed_long (num)
587      offsetT num ATTRIBUTE_UNUSED;
588 {
589 #ifndef BFD64
590   return 1;
591 #else
592   return (!(((offsetT) -1 << 31) & num)
593           || (((offsetT) -1 << 31) & num) == ((offsetT) -1 << 31));
594 #endif
595 }                               /* fits_in_signed_long() */
596 static INLINE int
597 fits_in_unsigned_long (num)
598      offsetT num ATTRIBUTE_UNUSED;
599 {
600 #ifndef BFD64
601   return 1;
602 #else
603   return (num & (((offsetT) 2 << 31) - 1)) == num;
604 #endif
605 }                               /* fits_in_unsigned_long() */
606
607 static int
608 smallest_imm_type (num)
609      offsetT num;
610 {
611   if (cpu_arch_flags != (Cpu086 | Cpu186 | Cpu286 | Cpu386 | Cpu486 | CpuNo64))
612     {
613       /* This code is disabled on the 486 because all the Imm1 forms
614          in the opcode table are slower on the i486.  They're the
615          versions with the implicitly specified single-position
616          displacement, which has another syntax if you really want to
617          use that form.  */
618       if (num == 1)
619         return Imm1 | Imm8 | Imm8S | Imm16 | Imm32 | Imm32S | Imm64;
620     }
621   return (fits_in_signed_byte (num)
622           ? (Imm8S | Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
623           : fits_in_unsigned_byte (num)
624           ? (Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
625           : (fits_in_signed_word (num) || fits_in_unsigned_word (num))
626           ? (Imm16 | Imm32 | Imm32S | Imm64)
627           : fits_in_signed_long (num)
628           ? (Imm32 | Imm32S | Imm64)
629           : fits_in_unsigned_long (num)
630           ? (Imm32 | Imm64)
631           : Imm64);
632 }
633
634 static offsetT
635 offset_in_range (val, size)
636      offsetT val;
637      int size;
638 {
639   addressT mask;
640
641   switch (size)
642     {
643     case 1: mask = ((addressT) 1 <<  8) - 1; break;
644     case 2: mask = ((addressT) 1 << 16) - 1; break;
645     case 4: mask = ((addressT) 2 << 31) - 1; break;
646 #ifdef BFD64
647     case 8: mask = ((addressT) 2 << 63) - 1; break;
648 #endif
649     default: abort ();
650     }
651
652   /* If BFD64, sign extend val.  */
653   if (!use_rela_relocations)
654     if ((val & ~(((addressT) 2 << 31) - 1)) == 0)
655       val = (val ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
656
657   if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
658     {
659       char buf1[40], buf2[40];
660
661       sprint_value (buf1, val);
662       sprint_value (buf2, val & mask);
663       as_warn (_("%s shortened to %s"), buf1, buf2);
664     }
665   return val & mask;
666 }
667
668 /* Returns 0 if attempting to add a prefix where one from the same
669    class already exists, 1 if non rep/repne added, 2 if rep/repne
670    added.  */
671 static int
672 add_prefix (prefix)
673      unsigned int prefix;
674 {
675   int ret = 1;
676   int q;
677
678   if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
679       && flag_code == CODE_64BIT)
680     q = REX_PREFIX;
681   else
682     switch (prefix)
683       {
684       default:
685         abort ();
686
687       case CS_PREFIX_OPCODE:
688       case DS_PREFIX_OPCODE:
689       case ES_PREFIX_OPCODE:
690       case FS_PREFIX_OPCODE:
691       case GS_PREFIX_OPCODE:
692       case SS_PREFIX_OPCODE:
693         q = SEG_PREFIX;
694         break;
695
696       case REPNE_PREFIX_OPCODE:
697       case REPE_PREFIX_OPCODE:
698         ret = 2;
699         /* fall thru */
700       case LOCK_PREFIX_OPCODE:
701         q = LOCKREP_PREFIX;
702         break;
703
704       case FWAIT_OPCODE:
705         q = WAIT_PREFIX;
706         break;
707
708       case ADDR_PREFIX_OPCODE:
709         q = ADDR_PREFIX;
710         break;
711
712       case DATA_PREFIX_OPCODE:
713         q = DATA_PREFIX;
714         break;
715       }
716
717   if (i.prefix[q] != 0)
718     {
719       as_bad (_("same type of prefix used twice"));
720       return 0;
721     }
722
723   i.prefixes += 1;
724   i.prefix[q] = prefix;
725   return ret;
726 }
727
728 static void
729 set_code_flag (value)
730      int value;
731 {
732   flag_code = value;
733   cpu_arch_flags &= ~(Cpu64 | CpuNo64);
734   cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
735   if (value == CODE_64BIT && !(cpu_arch_flags & CpuSledgehammer))
736     {
737       as_bad (_("64bit mode not supported on this CPU."));
738     }
739   if (value == CODE_32BIT && !(cpu_arch_flags & Cpu386))
740     {
741       as_bad (_("32bit mode not supported on this CPU."));
742     }
743   stackop_size = '\0';
744 }
745
746 static void
747 set_16bit_gcc_code_flag (new_code_flag)
748      int new_code_flag;
749 {
750   flag_code = new_code_flag;
751   cpu_arch_flags &= ~(Cpu64 | CpuNo64);
752   cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
753   stackop_size = 'l';
754 }
755
756 static void
757 set_intel_syntax (syntax_flag)
758      int syntax_flag;
759 {
760   /* Find out if register prefixing is specified.  */
761   int ask_naked_reg = 0;
762
763   SKIP_WHITESPACE ();
764   if (!is_end_of_line[(unsigned char) *input_line_pointer])
765     {
766       char *string = input_line_pointer;
767       int e = get_symbol_end ();
768
769       if (strcmp (string, "prefix") == 0)
770         ask_naked_reg = 1;
771       else if (strcmp (string, "noprefix") == 0)
772         ask_naked_reg = -1;
773       else
774         as_bad (_("bad argument to syntax directive."));
775       *input_line_pointer = e;
776     }
777   demand_empty_rest_of_line ();
778
779   intel_syntax = syntax_flag;
780
781   if (ask_naked_reg == 0)
782     {
783 #ifdef BFD_ASSEMBLER
784       allow_naked_reg = (intel_syntax
785                          && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
786 #else
787       /* Conservative default.  */
788       allow_naked_reg = 0;
789 #endif
790     }
791   else
792     allow_naked_reg = (ask_naked_reg < 0);
793 }
794
795 static void
796 set_cpu_arch (dummy)
797      int dummy ATTRIBUTE_UNUSED;
798 {
799   SKIP_WHITESPACE ();
800
801   if (!is_end_of_line[(unsigned char) *input_line_pointer])
802     {
803       char *string = input_line_pointer;
804       int e = get_symbol_end ();
805       int i;
806
807       for (i = 0; cpu_arch[i].name; i++)
808         {
809           if (strcmp (string, cpu_arch[i].name) == 0)
810             {
811               cpu_arch_name = cpu_arch[i].name;
812               cpu_arch_flags = (cpu_arch[i].flags
813                                 | (flag_code == CODE_64BIT ? Cpu64 : CpuNo64));
814               break;
815             }
816         }
817       if (!cpu_arch[i].name)
818         as_bad (_("no such architecture: `%s'"), string);
819
820       *input_line_pointer = e;
821     }
822   else
823     as_bad (_("missing cpu architecture"));
824
825   no_cond_jump_promotion = 0;
826   if (*input_line_pointer == ','
827       && !is_end_of_line[(unsigned char) input_line_pointer[1]])
828     {
829       char *string = ++input_line_pointer;
830       int e = get_symbol_end ();
831
832       if (strcmp (string, "nojumps") == 0)
833         no_cond_jump_promotion = 1;
834       else if (strcmp (string, "jumps") == 0)
835         ;
836       else
837         as_bad (_("no such architecture modifier: `%s'"), string);
838
839       *input_line_pointer = e;
840     }
841
842   demand_empty_rest_of_line ();
843 }
844
845 #ifdef BFD_ASSEMBLER
846 unsigned long
847 i386_mach ()
848 {
849   if (!strcmp (default_arch, "x86_64"))
850     return bfd_mach_x86_64;
851   else if (!strcmp (default_arch, "i386"))
852     return bfd_mach_i386_i386;
853   else
854     as_fatal (_("Unknown architecture"));
855 }
856 #endif
857 \f
858 void
859 md_begin ()
860 {
861   const char *hash_err;
862
863   /* Initialize op_hash hash table.  */
864   op_hash = hash_new ();
865
866   {
867     const template *optab;
868     templates *core_optab;
869
870     /* Setup for loop.  */
871     optab = i386_optab;
872     core_optab = (templates *) xmalloc (sizeof (templates));
873     core_optab->start = optab;
874
875     while (1)
876       {
877         ++optab;
878         if (optab->name == NULL
879             || strcmp (optab->name, (optab - 1)->name) != 0)
880           {
881             /* different name --> ship out current template list;
882                add to hash table; & begin anew.  */
883             core_optab->end = optab;
884             hash_err = hash_insert (op_hash,
885                                     (optab - 1)->name,
886                                     (PTR) core_optab);
887             if (hash_err)
888               {
889                 as_fatal (_("Internal Error:  Can't hash %s: %s"),
890                           (optab - 1)->name,
891                           hash_err);
892               }
893             if (optab->name == NULL)
894               break;
895             core_optab = (templates *) xmalloc (sizeof (templates));
896             core_optab->start = optab;
897           }
898       }
899   }
900
901   /* Initialize reg_hash hash table.  */
902   reg_hash = hash_new ();
903   {
904     const reg_entry *regtab;
905
906     for (regtab = i386_regtab;
907          regtab < i386_regtab + sizeof (i386_regtab) / sizeof (i386_regtab[0]);
908          regtab++)
909       {
910         hash_err = hash_insert (reg_hash, regtab->reg_name, (PTR) regtab);
911         if (hash_err)
912           as_fatal (_("Internal Error:  Can't hash %s: %s"),
913                     regtab->reg_name,
914                     hash_err);
915       }
916   }
917
918   /* Fill in lexical tables:  mnemonic_chars, operand_chars.  */
919   {
920     int c;
921     char *p;
922
923     for (c = 0; c < 256; c++)
924       {
925         if (ISDIGIT (c))
926           {
927             digit_chars[c] = c;
928             mnemonic_chars[c] = c;
929             register_chars[c] = c;
930             operand_chars[c] = c;
931           }
932         else if (ISLOWER (c))
933           {
934             mnemonic_chars[c] = c;
935             register_chars[c] = c;
936             operand_chars[c] = c;
937           }
938         else if (ISUPPER (c))
939           {
940             mnemonic_chars[c] = TOLOWER (c);
941             register_chars[c] = mnemonic_chars[c];
942             operand_chars[c] = c;
943           }
944
945         if (ISALPHA (c) || ISDIGIT (c))
946           identifier_chars[c] = c;
947         else if (c >= 128)
948           {
949             identifier_chars[c] = c;
950             operand_chars[c] = c;
951           }
952       }
953
954 #ifdef LEX_AT
955     identifier_chars['@'] = '@';
956 #endif
957     digit_chars['-'] = '-';
958     identifier_chars['_'] = '_';
959     identifier_chars['.'] = '.';
960
961     for (p = operand_special_chars; *p != '\0'; p++)
962       operand_chars[(unsigned char) *p] = *p;
963   }
964
965 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
966   if (OUTPUT_FLAVOR == bfd_target_elf_flavour)
967     {
968       record_alignment (text_section, 2);
969       record_alignment (data_section, 2);
970       record_alignment (bss_section, 2);
971     }
972 #endif
973 }
974
975 void
976 i386_print_statistics (file)
977      FILE *file;
978 {
979   hash_print_statistics (file, "i386 opcode", op_hash);
980   hash_print_statistics (file, "i386 register", reg_hash);
981 }
982 \f
983 #ifdef DEBUG386
984
985 /* Debugging routines for md_assemble.  */
986 static void pi PARAMS ((char *, i386_insn *));
987 static void pte PARAMS ((template *));
988 static void pt PARAMS ((unsigned int));
989 static void pe PARAMS ((expressionS *));
990 static void ps PARAMS ((symbolS *));
991
992 static void
993 pi (line, x)
994      char *line;
995      i386_insn *x;
996 {
997   unsigned int i;
998
999   fprintf (stdout, "%s: template ", line);
1000   pte (&x->tm);
1001   fprintf (stdout, "  address: base %s  index %s  scale %x\n",
1002            x->base_reg ? x->base_reg->reg_name : "none",
1003            x->index_reg ? x->index_reg->reg_name : "none",
1004            x->log2_scale_factor);
1005   fprintf (stdout, "  modrm:  mode %x  reg %x  reg/mem %x\n",
1006            x->rm.mode, x->rm.reg, x->rm.regmem);
1007   fprintf (stdout, "  sib:  base %x  index %x  scale %x\n",
1008            x->sib.base, x->sib.index, x->sib.scale);
1009   fprintf (stdout, "  rex: 64bit %x  extX %x  extY %x  extZ %x\n",
1010            (x->rex & REX_MODE64) != 0,
1011            (x->rex & REX_EXTX) != 0,
1012            (x->rex & REX_EXTY) != 0,
1013            (x->rex & REX_EXTZ) != 0);
1014   for (i = 0; i < x->operands; i++)
1015     {
1016       fprintf (stdout, "    #%d:  ", i + 1);
1017       pt (x->types[i]);
1018       fprintf (stdout, "\n");
1019       if (x->types[i]
1020           & (Reg | SReg2 | SReg3 | Control | Debug | Test | RegMMX | RegXMM))
1021         fprintf (stdout, "%s\n", x->op[i].regs->reg_name);
1022       if (x->types[i] & Imm)
1023         pe (x->op[i].imms);
1024       if (x->types[i] & Disp)
1025         pe (x->op[i].disps);
1026     }
1027 }
1028
1029 static void
1030 pte (t)
1031      template *t;
1032 {
1033   unsigned int i;
1034   fprintf (stdout, " %d operands ", t->operands);
1035   fprintf (stdout, "opcode %x ", t->base_opcode);
1036   if (t->extension_opcode != None)
1037     fprintf (stdout, "ext %x ", t->extension_opcode);
1038   if (t->opcode_modifier & D)
1039     fprintf (stdout, "D");
1040   if (t->opcode_modifier & W)
1041     fprintf (stdout, "W");
1042   fprintf (stdout, "\n");
1043   for (i = 0; i < t->operands; i++)
1044     {
1045       fprintf (stdout, "    #%d type ", i + 1);
1046       pt (t->operand_types[i]);
1047       fprintf (stdout, "\n");
1048     }
1049 }
1050
1051 static void
1052 pe (e)
1053      expressionS *e;
1054 {
1055   fprintf (stdout, "    operation     %d\n", e->X_op);
1056   fprintf (stdout, "    add_number    %ld (%lx)\n",
1057            (long) e->X_add_number, (long) e->X_add_number);
1058   if (e->X_add_symbol)
1059     {
1060       fprintf (stdout, "    add_symbol    ");
1061       ps (e->X_add_symbol);
1062       fprintf (stdout, "\n");
1063     }
1064   if (e->X_op_symbol)
1065     {
1066       fprintf (stdout, "    op_symbol    ");
1067       ps (e->X_op_symbol);
1068       fprintf (stdout, "\n");
1069     }
1070 }
1071
1072 static void
1073 ps (s)
1074      symbolS *s;
1075 {
1076   fprintf (stdout, "%s type %s%s",
1077            S_GET_NAME (s),
1078            S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
1079            segment_name (S_GET_SEGMENT (s)));
1080 }
1081
1082 struct type_name
1083   {
1084     unsigned int mask;
1085     char *tname;
1086   }
1087
1088 static const type_names[] =
1089 {
1090   { Reg8, "r8" },
1091   { Reg16, "r16" },
1092   { Reg32, "r32" },
1093   { Reg64, "r64" },
1094   { Imm8, "i8" },
1095   { Imm8S, "i8s" },
1096   { Imm16, "i16" },
1097   { Imm32, "i32" },
1098   { Imm32S, "i32s" },
1099   { Imm64, "i64" },
1100   { Imm1, "i1" },
1101   { BaseIndex, "BaseIndex" },
1102   { Disp8, "d8" },
1103   { Disp16, "d16" },
1104   { Disp32, "d32" },
1105   { Disp32S, "d32s" },
1106   { Disp64, "d64" },
1107   { InOutPortReg, "InOutPortReg" },
1108   { ShiftCount, "ShiftCount" },
1109   { Control, "control reg" },
1110   { Test, "test reg" },
1111   { Debug, "debug reg" },
1112   { FloatReg, "FReg" },
1113   { FloatAcc, "FAcc" },
1114   { SReg2, "SReg2" },
1115   { SReg3, "SReg3" },
1116   { Acc, "Acc" },
1117   { JumpAbsolute, "Jump Absolute" },
1118   { RegMMX, "rMMX" },
1119   { RegXMM, "rXMM" },
1120   { EsSeg, "es" },
1121   { 0, "" }
1122 };
1123
1124 static void
1125 pt (t)
1126      unsigned int t;
1127 {
1128   const struct type_name *ty;
1129
1130   for (ty = type_names; ty->mask; ty++)
1131     if (t & ty->mask)
1132       fprintf (stdout, "%s, ", ty->tname);
1133   fflush (stdout);
1134 }
1135
1136 #endif /* DEBUG386 */
1137 \f
1138 int
1139 tc_i386_force_relocation (fixp)
1140      struct fix *fixp;
1141 {
1142 #ifdef BFD_ASSEMBLER
1143   if (fixp->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1144       || fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1145     return 1;
1146   return 0;
1147 #else
1148   /* For COFF.  */
1149   return fixp->fx_r_type == 7;
1150 #endif
1151 }
1152
1153 #ifdef BFD_ASSEMBLER
1154 static bfd_reloc_code_real_type reloc
1155   PARAMS ((int, int, int, bfd_reloc_code_real_type));
1156
1157 static bfd_reloc_code_real_type
1158 reloc (size, pcrel, sign, other)
1159      int size;
1160      int pcrel;
1161      int sign;
1162      bfd_reloc_code_real_type other;
1163 {
1164   if (other != NO_RELOC)
1165     return other;
1166
1167   if (pcrel)
1168     {
1169       if (!sign)
1170         as_bad (_("There are no unsigned pc-relative relocations"));
1171       switch (size)
1172         {
1173         case 1: return BFD_RELOC_8_PCREL;
1174         case 2: return BFD_RELOC_16_PCREL;
1175         case 4: return BFD_RELOC_32_PCREL;
1176         }
1177       as_bad (_("can not do %d byte pc-relative relocation"), size);
1178     }
1179   else
1180     {
1181       if (sign)
1182         switch (size)
1183           {
1184           case 4: return BFD_RELOC_X86_64_32S;
1185           }
1186       else
1187         switch (size)
1188           {
1189           case 1: return BFD_RELOC_8;
1190           case 2: return BFD_RELOC_16;
1191           case 4: return BFD_RELOC_32;
1192           case 8: return BFD_RELOC_64;
1193           }
1194       as_bad (_("can not do %s %d byte relocation"),
1195               sign ? "signed" : "unsigned", size);
1196     }
1197
1198   abort ();
1199   return BFD_RELOC_NONE;
1200 }
1201
1202 /* Here we decide which fixups can be adjusted to make them relative to
1203    the beginning of the section instead of the symbol.  Basically we need
1204    to make sure that the dynamic relocations are done correctly, so in
1205    some cases we force the original symbol to be used.  */
1206
1207 int
1208 tc_i386_fix_adjustable (fixP)
1209      fixS *fixP;
1210 {
1211 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1212   /* Prevent all adjustments to global symbols, or else dynamic
1213      linking will not work correctly.  */
1214   if (S_IS_EXTERNAL (fixP->fx_addsy)
1215       || S_IS_WEAK (fixP->fx_addsy)
1216       /* Don't adjust pc-relative references to merge sections in 64-bit
1217          mode.  */
1218       || (use_rela_relocations
1219           && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
1220           && fixP->fx_pcrel))
1221     return 0;
1222 #endif
1223   /* adjust_reloc_syms doesn't know about the GOT.  */
1224   if (fixP->fx_r_type == BFD_RELOC_386_GOTOFF
1225       || fixP->fx_r_type == BFD_RELOC_386_PLT32
1226       || fixP->fx_r_type == BFD_RELOC_386_GOT32
1227       || fixP->fx_r_type == BFD_RELOC_X86_64_PLT32
1228       || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
1229       || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
1230       || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1231       || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1232     return 0;
1233   return 1;
1234 }
1235 #else
1236 #define reloc(SIZE,PCREL,SIGN,OTHER)    0
1237 #define BFD_RELOC_16                    0
1238 #define BFD_RELOC_32                    0
1239 #define BFD_RELOC_16_PCREL              0
1240 #define BFD_RELOC_32_PCREL              0
1241 #define BFD_RELOC_386_PLT32             0
1242 #define BFD_RELOC_386_GOT32             0
1243 #define BFD_RELOC_386_GOTOFF            0
1244 #define BFD_RELOC_X86_64_PLT32          0
1245 #define BFD_RELOC_X86_64_GOT32          0
1246 #define BFD_RELOC_X86_64_GOTPCREL       0
1247 #endif
1248
1249 static int intel_float_operand PARAMS ((const char *mnemonic));
1250
1251 static int
1252 intel_float_operand (mnemonic)
1253      const char *mnemonic;
1254 {
1255   if (mnemonic[0] == 'f' && mnemonic[1] == 'i')
1256     return 2;
1257
1258   if (mnemonic[0] == 'f')
1259     return 1;
1260
1261   return 0;
1262 }
1263
1264 /* This is the guts of the machine-dependent assembler.  LINE points to a
1265    machine dependent instruction.  This function is supposed to emit
1266    the frags/bytes it assembles to.  */
1267
1268 void
1269 md_assemble (line)
1270      char *line;
1271 {
1272   int j;
1273   char mnemonic[MAX_MNEM_SIZE];
1274
1275   /* Initialize globals.  */
1276   memset (&i, '\0', sizeof (i));
1277   for (j = 0; j < MAX_OPERANDS; j++)
1278     i.reloc[j] = NO_RELOC;
1279   memset (disp_expressions, '\0', sizeof (disp_expressions));
1280   memset (im_expressions, '\0', sizeof (im_expressions));
1281   save_stack_p = save_stack;
1282
1283   /* First parse an instruction mnemonic & call i386_operand for the operands.
1284      We assume that the scrubber has arranged it so that line[0] is the valid
1285      start of a (possibly prefixed) mnemonic.  */
1286
1287   line = parse_insn (line, mnemonic);
1288   if (line == NULL)
1289     return;
1290
1291   line = parse_operands (line, mnemonic);
1292   if (line == NULL)
1293     return;
1294
1295   /* Now we've parsed the mnemonic into a set of templates, and have the
1296      operands at hand.  */
1297
1298   /* All intel opcodes have reversed operands except for "bound" and
1299      "enter".  We also don't reverse intersegment "jmp" and "call"
1300      instructions with 2 immediate operands so that the immediate segment
1301      precedes the offset, as it does when in AT&T mode.  "enter" and the
1302      intersegment "jmp" and "call" instructions are the only ones that
1303      have two immediate operands.  */
1304   if (intel_syntax && i.operands > 1
1305       && (strcmp (mnemonic, "bound") != 0)
1306       && !((i.types[0] & Imm) && (i.types[1] & Imm)))
1307     swap_operands ();
1308
1309   if (i.imm_operands)
1310     optimize_imm ();
1311
1312   if (i.disp_operands)
1313     optimize_disp ();
1314
1315   /* Next, we find a template that matches the given insn,
1316      making sure the overlap of the given operands types is consistent
1317      with the template operand types.  */
1318
1319   if (!match_template ())
1320     return;
1321
1322   /* Undo SYSV386_COMPAT brokenness when in Intel mode.  See i386.h  */
1323   if (SYSV386_COMPAT
1324       && intel_syntax
1325       && (i.tm.base_opcode & 0xfffffde0) == 0xdce0)
1326     i.tm.base_opcode ^= FloatR;
1327
1328   if (i.tm.opcode_modifier & FWait)
1329     if (!add_prefix (FWAIT_OPCODE))
1330       return;
1331
1332   /* Check string instruction segment overrides.  */
1333   if ((i.tm.opcode_modifier & IsString) != 0 && i.mem_operands != 0)
1334     {
1335       if (!check_string ())
1336         return;
1337     }
1338
1339   if (!process_suffix ())
1340     return;
1341
1342   /* Make still unresolved immediate matches conform to size of immediate
1343      given in i.suffix.  */
1344   if (!finalize_imm ())
1345     return;
1346
1347   if (i.types[0] & Imm1)
1348     i.imm_operands = 0; /* kludge for shift insns.  */
1349   if (i.types[0] & ImplicitRegister)
1350     i.reg_operands--;
1351   if (i.types[1] & ImplicitRegister)
1352     i.reg_operands--;
1353   if (i.types[2] & ImplicitRegister)
1354     i.reg_operands--;
1355
1356   if (i.tm.opcode_modifier & ImmExt)
1357     {
1358       /* These AMD 3DNow! and Intel Katmai New Instructions have an
1359          opcode suffix which is coded in the same place as an 8-bit
1360          immediate field would be.  Here we fake an 8-bit immediate
1361          operand from the opcode suffix stored in tm.extension_opcode.  */
1362
1363       expressionS *exp;
1364
1365       assert (i.imm_operands == 0 && i.operands <= 2 && 2 < MAX_OPERANDS);
1366
1367       exp = &im_expressions[i.imm_operands++];
1368       i.op[i.operands].imms = exp;
1369       i.types[i.operands++] = Imm8;
1370       exp->X_op = O_constant;
1371       exp->X_add_number = i.tm.extension_opcode;
1372       i.tm.extension_opcode = None;
1373     }
1374
1375   /* For insns with operands there are more diddles to do to the opcode.  */
1376   if (i.operands)
1377     {
1378       if (!process_operands ())
1379         return;
1380     }
1381   else if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
1382     {
1383       /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc.  */
1384       as_warn (_("translating to `%sp'"), i.tm.name);
1385     }
1386
1387   /* Handle conversion of 'int $3' --> special int3 insn.  */
1388   if (i.tm.base_opcode == INT_OPCODE && i.op[0].imms->X_add_number == 3)
1389     {
1390       i.tm.base_opcode = INT3_OPCODE;
1391       i.imm_operands = 0;
1392     }
1393
1394   if ((i.tm.opcode_modifier & (Jump | JumpByte | JumpDword))
1395       && i.op[0].disps->X_op == O_constant)
1396     {
1397       /* Convert "jmp constant" (and "call constant") to a jump (call) to
1398          the absolute address given by the constant.  Since ix86 jumps and
1399          calls are pc relative, we need to generate a reloc.  */
1400       i.op[0].disps->X_add_symbol = &abs_symbol;
1401       i.op[0].disps->X_op = O_symbol;
1402     }
1403
1404   if ((i.tm.opcode_modifier & Rex64) != 0)
1405     i.rex |= REX_MODE64;
1406
1407   /* For 8 bit registers we need an empty rex prefix.  Also if the
1408      instruction already has a prefix, we need to convert old
1409      registers to new ones.  */
1410
1411   if (((i.types[0] & Reg8) != 0
1412        && (i.op[0].regs->reg_flags & RegRex64) != 0)
1413       || ((i.types[1] & Reg8) != 0
1414           && (i.op[1].regs->reg_flags & RegRex64) != 0)
1415       || (((i.types[0] & Reg8) != 0 || (i.types[1] & Reg8) != 0)
1416           && i.rex != 0))
1417     {
1418       int x;
1419
1420       i.rex |= REX_OPCODE;
1421       for (x = 0; x < 2; x++)
1422         {
1423           /* Look for 8 bit operand that uses old registers.  */
1424           if ((i.types[x] & Reg8) != 0
1425               && (i.op[x].regs->reg_flags & RegRex64) == 0)
1426             {
1427               /* In case it is "hi" register, give up.  */
1428               if (i.op[x].regs->reg_num > 3)
1429                 as_bad (_("can't encode register '%%%s' in an instruction requiring REX prefix.\n"),
1430                         i.op[x].regs->reg_name);
1431
1432               /* Otherwise it is equivalent to the extended register.
1433                  Since the encoding doesn't change this is merely
1434                  cosmetic cleanup for debug output.  */
1435
1436               i.op[x].regs = i.op[x].regs + 8;
1437             }
1438         }
1439     }
1440
1441   if (i.rex != 0)
1442     add_prefix (REX_OPCODE | i.rex);
1443
1444   /* We are ready to output the insn.  */
1445   output_insn ();
1446 }
1447
1448 static char *
1449 parse_insn (line, mnemonic)
1450      char *line;
1451      char *mnemonic;
1452 {
1453   char *l = line;
1454   char *token_start = l;
1455   char *mnem_p;
1456
1457   /* Non-zero if we found a prefix only acceptable with string insns.  */
1458   const char *expecting_string_instruction = NULL;
1459
1460   while (1)
1461     {
1462       mnem_p = mnemonic;
1463       while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
1464         {
1465           mnem_p++;
1466           if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
1467             {
1468               as_bad (_("no such instruction: `%s'"), token_start);
1469               return NULL;
1470             }
1471           l++;
1472         }
1473       if (!is_space_char (*l)
1474           && *l != END_OF_INSN
1475           && *l != PREFIX_SEPARATOR
1476           && *l != ',')
1477         {
1478           as_bad (_("invalid character %s in mnemonic"),
1479                   output_invalid (*l));
1480           return NULL;
1481         }
1482       if (token_start == l)
1483         {
1484           if (*l == PREFIX_SEPARATOR)
1485             as_bad (_("expecting prefix; got nothing"));
1486           else
1487             as_bad (_("expecting mnemonic; got nothing"));
1488           return NULL;
1489         }
1490
1491       /* Look up instruction (or prefix) via hash table.  */
1492       current_templates = hash_find (op_hash, mnemonic);
1493
1494       if (*l != END_OF_INSN
1495           && (!is_space_char (*l) || l[1] != END_OF_INSN)
1496           && current_templates
1497           && (current_templates->start->opcode_modifier & IsPrefix))
1498         {
1499           /* If we are in 16-bit mode, do not allow addr16 or data16.
1500              Similarly, in 32-bit mode, do not allow addr32 or data32.  */
1501           if ((current_templates->start->opcode_modifier & (Size16 | Size32))
1502               && flag_code != CODE_64BIT
1503               && (((current_templates->start->opcode_modifier & Size32) != 0)
1504                   ^ (flag_code == CODE_16BIT)))
1505             {
1506               as_bad (_("redundant %s prefix"),
1507                       current_templates->start->name);
1508               return NULL;
1509             }
1510           /* Add prefix, checking for repeated prefixes.  */
1511           switch (add_prefix (current_templates->start->base_opcode))
1512             {
1513             case 0:
1514               return NULL;
1515             case 2:
1516               expecting_string_instruction = current_templates->start->name;
1517               break;
1518             }
1519           /* Skip past PREFIX_SEPARATOR and reset token_start.  */
1520           token_start = ++l;
1521         }
1522       else
1523         break;
1524     }
1525
1526   if (!current_templates)
1527     {
1528       /* See if we can get a match by trimming off a suffix.  */
1529       switch (mnem_p[-1])
1530         {
1531         case WORD_MNEM_SUFFIX:
1532         case BYTE_MNEM_SUFFIX:
1533         case QWORD_MNEM_SUFFIX:
1534           i.suffix = mnem_p[-1];
1535           mnem_p[-1] = '\0';
1536           current_templates = hash_find (op_hash, mnemonic);
1537           break;
1538         case SHORT_MNEM_SUFFIX:
1539         case LONG_MNEM_SUFFIX:
1540           if (!intel_syntax)
1541             {
1542               i.suffix = mnem_p[-1];
1543               mnem_p[-1] = '\0';
1544               current_templates = hash_find (op_hash, mnemonic);
1545             }
1546           break;
1547
1548           /* Intel Syntax.  */
1549         case 'd':
1550           if (intel_syntax)
1551             {
1552               if (intel_float_operand (mnemonic))
1553                 i.suffix = SHORT_MNEM_SUFFIX;
1554               else
1555                 i.suffix = LONG_MNEM_SUFFIX;
1556               mnem_p[-1] = '\0';
1557               current_templates = hash_find (op_hash, mnemonic);
1558             }
1559           break;
1560         }
1561       if (!current_templates)
1562         {
1563           as_bad (_("no such instruction: `%s'"), token_start);
1564           return NULL;
1565         }
1566     }
1567
1568   if (current_templates->start->opcode_modifier & (Jump | JumpByte))
1569     {
1570       /* Check for a branch hint.  We allow ",pt" and ",pn" for
1571          predict taken and predict not taken respectively.
1572          I'm not sure that branch hints actually do anything on loop
1573          and jcxz insns (JumpByte) for current Pentium4 chips.  They
1574          may work in the future and it doesn't hurt to accept them
1575          now.  */
1576       if (l[0] == ',' && l[1] == 'p')
1577         {
1578           if (l[2] == 't')
1579             {
1580               if (!add_prefix (DS_PREFIX_OPCODE))
1581                 return NULL;
1582               l += 3;
1583             }
1584           else if (l[2] == 'n')
1585             {
1586               if (!add_prefix (CS_PREFIX_OPCODE))
1587                 return NULL;
1588               l += 3;
1589             }
1590         }
1591     }
1592   /* Any other comma loses.  */
1593   if (*l == ',')
1594     {
1595       as_bad (_("invalid character %s in mnemonic"),
1596               output_invalid (*l));
1597       return NULL;
1598     }
1599
1600   /* Check if instruction is supported on specified architecture.  */
1601   if ((current_templates->start->cpu_flags & ~(Cpu64 | CpuNo64))
1602       & ~(cpu_arch_flags & ~(Cpu64 | CpuNo64)))
1603     {
1604       as_warn (_("`%s' is not supported on `%s'"),
1605                current_templates->start->name, cpu_arch_name);
1606     }
1607   else if ((Cpu386 & ~cpu_arch_flags) && (flag_code != CODE_16BIT))
1608     {
1609       as_warn (_("use .code16 to ensure correct addressing mode"));
1610     }
1611
1612   /* Check for rep/repne without a string instruction.  */
1613   if (expecting_string_instruction
1614       && !(current_templates->start->opcode_modifier & IsString))
1615     {
1616       as_bad (_("expecting string instruction after `%s'"),
1617               expecting_string_instruction);
1618       return NULL;
1619     }
1620
1621   return l;
1622 }
1623
1624 static char *
1625 parse_operands (l, mnemonic)
1626      char *l;
1627      const char *mnemonic;
1628 {
1629   char *token_start;
1630
1631   /* 1 if operand is pending after ','.  */
1632   unsigned int expecting_operand = 0;
1633
1634   /* Non-zero if operand parens not balanced.  */
1635   unsigned int paren_not_balanced;
1636
1637   while (*l != END_OF_INSN)
1638     {
1639       /* Skip optional white space before operand.  */
1640       if (is_space_char (*l))
1641         ++l;
1642       if (!is_operand_char (*l) && *l != END_OF_INSN)
1643         {
1644           as_bad (_("invalid character %s before operand %d"),
1645                   output_invalid (*l),
1646                   i.operands + 1);
1647           return NULL;
1648         }
1649       token_start = l;  /* after white space */
1650       paren_not_balanced = 0;
1651       while (paren_not_balanced || *l != ',')
1652         {
1653           if (*l == END_OF_INSN)
1654             {
1655               if (paren_not_balanced)
1656                 {
1657                   if (!intel_syntax)
1658                     as_bad (_("unbalanced parenthesis in operand %d."),
1659                             i.operands + 1);
1660                   else
1661                     as_bad (_("unbalanced brackets in operand %d."),
1662                             i.operands + 1);
1663                   return NULL;
1664                 }
1665               else
1666                 break;  /* we are done */
1667             }
1668           else if (!is_operand_char (*l) && !is_space_char (*l))
1669             {
1670               as_bad (_("invalid character %s in operand %d"),
1671                       output_invalid (*l),
1672                       i.operands + 1);
1673               return NULL;
1674             }
1675           if (!intel_syntax)
1676             {
1677               if (*l == '(')
1678                 ++paren_not_balanced;
1679               if (*l == ')')
1680                 --paren_not_balanced;
1681             }
1682           else
1683             {
1684               if (*l == '[')
1685                 ++paren_not_balanced;
1686               if (*l == ']')
1687                 --paren_not_balanced;
1688             }
1689           l++;
1690         }
1691       if (l != token_start)
1692         {                       /* Yes, we've read in another operand.  */
1693           unsigned int operand_ok;
1694           this_operand = i.operands++;
1695           if (i.operands > MAX_OPERANDS)
1696             {
1697               as_bad (_("spurious operands; (%d operands/instruction max)"),
1698                       MAX_OPERANDS);
1699               return NULL;
1700             }
1701           /* Now parse operand adding info to 'i' as we go along.  */
1702           END_STRING_AND_SAVE (l);
1703
1704           if (intel_syntax)
1705             operand_ok =
1706               i386_intel_operand (token_start,
1707                                   intel_float_operand (mnemonic));
1708           else
1709             operand_ok = i386_operand (token_start);
1710
1711           RESTORE_END_STRING (l);
1712           if (!operand_ok)
1713             return NULL;
1714         }
1715       else
1716         {
1717           if (expecting_operand)
1718             {
1719             expecting_operand_after_comma:
1720               as_bad (_("expecting operand after ','; got nothing"));
1721               return NULL;
1722             }
1723           if (*l == ',')
1724             {
1725               as_bad (_("expecting operand before ','; got nothing"));
1726               return NULL;
1727             }
1728         }
1729
1730       /* Now *l must be either ',' or END_OF_INSN.  */
1731       if (*l == ',')
1732         {
1733           if (*++l == END_OF_INSN)
1734             {
1735               /* Just skip it, if it's \n complain.  */
1736               goto expecting_operand_after_comma;
1737             }
1738           expecting_operand = 1;
1739         }
1740     }
1741   return l;
1742 }
1743
1744 static void
1745 swap_operands ()
1746 {
1747   union i386_op temp_op;
1748   unsigned int temp_type;
1749   RELOC_ENUM temp_reloc;
1750   int xchg1 = 0;
1751   int xchg2 = 0;
1752
1753   if (i.operands == 2)
1754     {
1755       xchg1 = 0;
1756       xchg2 = 1;
1757     }
1758   else if (i.operands == 3)
1759     {
1760       xchg1 = 0;
1761       xchg2 = 2;
1762     }
1763   temp_type = i.types[xchg2];
1764   i.types[xchg2] = i.types[xchg1];
1765   i.types[xchg1] = temp_type;
1766   temp_op = i.op[xchg2];
1767   i.op[xchg2] = i.op[xchg1];
1768   i.op[xchg1] = temp_op;
1769   temp_reloc = i.reloc[xchg2];
1770   i.reloc[xchg2] = i.reloc[xchg1];
1771   i.reloc[xchg1] = temp_reloc;
1772
1773   if (i.mem_operands == 2)
1774     {
1775       const seg_entry *temp_seg;
1776       temp_seg = i.seg[0];
1777       i.seg[0] = i.seg[1];
1778       i.seg[1] = temp_seg;
1779     }
1780 }
1781
1782 /* Try to ensure constant immediates are represented in the smallest
1783    opcode possible.  */
1784 static void
1785 optimize_imm ()
1786 {
1787   char guess_suffix = 0;
1788   int op;
1789
1790   if (i.suffix)
1791     guess_suffix = i.suffix;
1792   else if (i.reg_operands)
1793     {
1794       /* Figure out a suffix from the last register operand specified.
1795          We can't do this properly yet, ie. excluding InOutPortReg,
1796          but the following works for instructions with immediates.
1797          In any case, we can't set i.suffix yet.  */
1798       for (op = i.operands; --op >= 0;)
1799         if (i.types[op] & Reg)
1800           {
1801             if (i.types[op] & Reg8)
1802               guess_suffix = BYTE_MNEM_SUFFIX;
1803             else if (i.types[op] & Reg16)
1804               guess_suffix = WORD_MNEM_SUFFIX;
1805             else if (i.types[op] & Reg32)
1806               guess_suffix = LONG_MNEM_SUFFIX;
1807             else if (i.types[op] & Reg64)
1808               guess_suffix = QWORD_MNEM_SUFFIX;
1809             break;
1810           }
1811     }
1812   else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
1813     guess_suffix = WORD_MNEM_SUFFIX;
1814
1815   for (op = i.operands; --op >= 0;)
1816     if (i.types[op] & Imm)
1817       {
1818         switch (i.op[op].imms->X_op)
1819           {
1820           case O_constant:
1821             /* If a suffix is given, this operand may be shortened.  */
1822             switch (guess_suffix)
1823               {
1824               case LONG_MNEM_SUFFIX:
1825                 i.types[op] |= Imm32 | Imm64;
1826                 break;
1827               case WORD_MNEM_SUFFIX:
1828                 i.types[op] |= Imm16 | Imm32S | Imm32 | Imm64;
1829                 break;
1830               case BYTE_MNEM_SUFFIX:
1831                 i.types[op] |= Imm16 | Imm8 | Imm8S | Imm32S | Imm32 | Imm64;
1832                 break;
1833               }
1834
1835             /* If this operand is at most 16 bits, convert it
1836                to a signed 16 bit number before trying to see
1837                whether it will fit in an even smaller size.
1838                This allows a 16-bit operand such as $0xffe0 to
1839                be recognised as within Imm8S range.  */
1840             if ((i.types[op] & Imm16)
1841                 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
1842               {
1843                 i.op[op].imms->X_add_number =
1844                   (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
1845               }
1846             if ((i.types[op] & Imm32)
1847                 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
1848                     == 0))
1849               {
1850                 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
1851                                                 ^ ((offsetT) 1 << 31))
1852                                                - ((offsetT) 1 << 31));
1853               }
1854             i.types[op] |= smallest_imm_type (i.op[op].imms->X_add_number);
1855
1856             /* We must avoid matching of Imm32 templates when 64bit
1857                only immediate is available.  */
1858             if (guess_suffix == QWORD_MNEM_SUFFIX)
1859               i.types[op] &= ~Imm32;
1860             break;
1861
1862           case O_absent:
1863           case O_register:
1864             abort ();
1865
1866             /* Symbols and expressions.  */
1867           default:
1868             /* Convert symbolic operand to proper sizes for matching.  */
1869             switch (guess_suffix)
1870               {
1871               case QWORD_MNEM_SUFFIX:
1872                 i.types[op] = Imm64 | Imm32S;
1873                 break;
1874               case LONG_MNEM_SUFFIX:
1875                 i.types[op] = Imm32 | Imm64;
1876                 break;
1877               case WORD_MNEM_SUFFIX:
1878                 i.types[op] = Imm16 | Imm32 | Imm64;
1879                 break;
1880                 break;
1881               case BYTE_MNEM_SUFFIX:
1882                 i.types[op] = Imm8 | Imm8S | Imm16 | Imm32S | Imm32;
1883                 break;
1884                 break;
1885               }
1886             break;
1887           }
1888       }
1889 }
1890
1891 /* Try to use the smallest displacement type too.  */
1892 static void
1893 optimize_disp ()
1894 {
1895   int op;
1896
1897   for (op = i.operands; --op >= 0;)
1898     if ((i.types[op] & Disp) && i.op[op].disps->X_op == O_constant)
1899       {
1900         offsetT disp = i.op[op].disps->X_add_number;
1901
1902         if (i.types[op] & Disp16)
1903           {
1904             /* We know this operand is at most 16 bits, so
1905                convert to a signed 16 bit number before trying
1906                to see whether it will fit in an even smaller
1907                size.  */
1908
1909             disp = (((disp & 0xffff) ^ 0x8000) - 0x8000);
1910           }
1911         else if (i.types[op] & Disp32)
1912           {
1913             /* We know this operand is at most 32 bits, so convert to a
1914                signed 32 bit number before trying to see whether it will
1915                fit in an even smaller size.  */
1916             disp &= (((offsetT) 2 << 31) - 1);
1917             disp = (disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
1918           }
1919         if (flag_code == CODE_64BIT)
1920           {
1921             if (fits_in_signed_long (disp))
1922               i.types[op] |= Disp32S;
1923             if (fits_in_unsigned_long (disp))
1924               i.types[op] |= Disp32;
1925           }
1926         if ((i.types[op] & (Disp32 | Disp32S | Disp16))
1927             && fits_in_signed_byte (disp))
1928           i.types[op] |= Disp8;
1929       }
1930 }
1931
1932 static int
1933 match_template ()
1934 {
1935   /* Points to template once we've found it.  */
1936   const template *t;
1937   unsigned int overlap0, overlap1, overlap2;
1938   unsigned int found_reverse_match;
1939   int suffix_check;
1940
1941 #define MATCH(overlap, given, template)                         \
1942   ((overlap & ~JumpAbsolute)                                    \
1943    && (((given) & (BaseIndex | JumpAbsolute))                   \
1944        == ((overlap) & (BaseIndex | JumpAbsolute))))
1945
1946   /* If given types r0 and r1 are registers they must be of the same type
1947      unless the expected operand type register overlap is null.
1948      Note that Acc in a template matches every size of reg.  */
1949 #define CONSISTENT_REGISTER_MATCH(m0, g0, t0, m1, g1, t1)       \
1950   (((g0) & Reg) == 0 || ((g1) & Reg) == 0                       \
1951    || ((g0) & Reg) == ((g1) & Reg)                              \
1952    || ((((m0) & Acc) ? Reg : (t0)) & (((m1) & Acc) ? Reg : (t1)) & Reg) == 0 )
1953
1954   overlap0 = 0;
1955   overlap1 = 0;
1956   overlap2 = 0;
1957   found_reverse_match = 0;
1958   suffix_check = (i.suffix == BYTE_MNEM_SUFFIX
1959                   ? No_bSuf
1960                   : (i.suffix == WORD_MNEM_SUFFIX
1961                      ? No_wSuf
1962                      : (i.suffix == SHORT_MNEM_SUFFIX
1963                         ? No_sSuf
1964                         : (i.suffix == LONG_MNEM_SUFFIX
1965                            ? No_lSuf
1966                            : (i.suffix == QWORD_MNEM_SUFFIX
1967                               ? No_qSuf
1968                               : (i.suffix == LONG_DOUBLE_MNEM_SUFFIX
1969                                  ? No_xSuf : 0))))));
1970
1971   for (t = current_templates->start;
1972        t < current_templates->end;
1973        t++)
1974     {
1975       /* Must have right number of operands.  */
1976       if (i.operands != t->operands)
1977         continue;
1978
1979       /* Check the suffix, except for some instructions in intel mode.  */
1980       if ((t->opcode_modifier & suffix_check)
1981           && !(intel_syntax
1982                && (t->opcode_modifier & IgnoreSize))
1983           && !(intel_syntax
1984                && t->base_opcode == 0xd9
1985                && (t->extension_opcode == 5          /* 0xd9,5 "fldcw"  */
1986                    || t->extension_opcode == 7)))  /* 0xd9,7 "f{n}stcw"  */
1987         continue;
1988
1989       /* Do not verify operands when there are none.  */
1990       else if (!t->operands)
1991         {
1992           if (t->cpu_flags & ~cpu_arch_flags)
1993             continue;
1994           /* We've found a match; break out of loop.  */
1995           break;
1996         }
1997
1998       overlap0 = i.types[0] & t->operand_types[0];
1999       switch (t->operands)
2000         {
2001         case 1:
2002           if (!MATCH (overlap0, i.types[0], t->operand_types[0]))
2003             continue;
2004           break;
2005         case 2:
2006         case 3:
2007           overlap1 = i.types[1] & t->operand_types[1];
2008           if (!MATCH (overlap0, i.types[0], t->operand_types[0])
2009               || !MATCH (overlap1, i.types[1], t->operand_types[1])
2010               || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
2011                                              t->operand_types[0],
2012                                              overlap1, i.types[1],
2013                                              t->operand_types[1]))
2014             {
2015               /* Check if other direction is valid ...  */
2016               if ((t->opcode_modifier & (D | FloatD)) == 0)
2017                 continue;
2018
2019               /* Try reversing direction of operands.  */
2020               overlap0 = i.types[0] & t->operand_types[1];
2021               overlap1 = i.types[1] & t->operand_types[0];
2022               if (!MATCH (overlap0, i.types[0], t->operand_types[1])
2023                   || !MATCH (overlap1, i.types[1], t->operand_types[0])
2024                   || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
2025                                                  t->operand_types[1],
2026                                                  overlap1, i.types[1],
2027                                                  t->operand_types[0]))
2028                 {
2029                   /* Does not match either direction.  */
2030                   continue;
2031                 }
2032               /* found_reverse_match holds which of D or FloatDR
2033                  we've found.  */
2034               found_reverse_match = t->opcode_modifier & (D | FloatDR);
2035             }
2036           /* Found a forward 2 operand match here.  */
2037           else if (t->operands == 3)
2038             {
2039               /* Here we make use of the fact that there are no
2040                  reverse match 3 operand instructions, and all 3
2041                  operand instructions only need to be checked for
2042                  register consistency between operands 2 and 3.  */
2043               overlap2 = i.types[2] & t->operand_types[2];
2044               if (!MATCH (overlap2, i.types[2], t->operand_types[2])
2045                   || !CONSISTENT_REGISTER_MATCH (overlap1, i.types[1],
2046                                                  t->operand_types[1],
2047                                                  overlap2, i.types[2],
2048                                                  t->operand_types[2]))
2049
2050                 continue;
2051             }
2052           /* Found either forward/reverse 2 or 3 operand match here:
2053              slip through to break.  */
2054         }
2055       if (t->cpu_flags & ~cpu_arch_flags)
2056         {
2057           found_reverse_match = 0;
2058           continue;
2059         }
2060       /* We've found a match; break out of loop.  */
2061       break;
2062     }
2063
2064   if (t == current_templates->end)
2065     {
2066       /* We found no match.  */
2067       as_bad (_("suffix or operands invalid for `%s'"),
2068               current_templates->start->name);
2069       return 0;
2070     }
2071
2072   if (!quiet_warnings)
2073     {
2074       if (!intel_syntax
2075           && ((i.types[0] & JumpAbsolute)
2076               != (t->operand_types[0] & JumpAbsolute)))
2077         {
2078           as_warn (_("indirect %s without `*'"), t->name);
2079         }
2080
2081       if ((t->opcode_modifier & (IsPrefix | IgnoreSize))
2082           == (IsPrefix | IgnoreSize))
2083         {
2084           /* Warn them that a data or address size prefix doesn't
2085              affect assembly of the next line of code.  */
2086           as_warn (_("stand-alone `%s' prefix"), t->name);
2087         }
2088     }
2089
2090   /* Copy the template we found.  */
2091   i.tm = *t;
2092   if (found_reverse_match)
2093     {
2094       /* If we found a reverse match we must alter the opcode
2095          direction bit.  found_reverse_match holds bits to change
2096          (different for int & float insns).  */
2097
2098       i.tm.base_opcode ^= found_reverse_match;
2099
2100       i.tm.operand_types[0] = t->operand_types[1];
2101       i.tm.operand_types[1] = t->operand_types[0];
2102     }
2103
2104   return 1;
2105 }
2106
2107 static int
2108 check_string ()
2109 {
2110   int mem_op = (i.types[0] & AnyMem) ? 0 : 1;
2111   if ((i.tm.operand_types[mem_op] & EsSeg) != 0)
2112     {
2113       if (i.seg[0] != NULL && i.seg[0] != &es)
2114         {
2115           as_bad (_("`%s' operand %d must use `%%es' segment"),
2116                   i.tm.name,
2117                   mem_op + 1);
2118           return 0;
2119         }
2120       /* There's only ever one segment override allowed per instruction.
2121          This instruction possibly has a legal segment override on the
2122          second operand, so copy the segment to where non-string
2123          instructions store it, allowing common code.  */
2124       i.seg[0] = i.seg[1];
2125     }
2126   else if ((i.tm.operand_types[mem_op + 1] & EsSeg) != 0)
2127     {
2128       if (i.seg[1] != NULL && i.seg[1] != &es)
2129         {
2130           as_bad (_("`%s' operand %d must use `%%es' segment"),
2131                   i.tm.name,
2132                   mem_op + 2);
2133           return 0;
2134         }
2135     }
2136   return 1;
2137 }
2138
2139 static int
2140 process_suffix ()
2141 {
2142   /* If matched instruction specifies an explicit instruction mnemonic
2143      suffix, use it.  */
2144   if (i.tm.opcode_modifier & (Size16 | Size32 | Size64))
2145     {
2146       if (i.tm.opcode_modifier & Size16)
2147         i.suffix = WORD_MNEM_SUFFIX;
2148       else if (i.tm.opcode_modifier & Size64)
2149         i.suffix = QWORD_MNEM_SUFFIX;
2150       else
2151         i.suffix = LONG_MNEM_SUFFIX;
2152     }
2153   else if (i.reg_operands)
2154     {
2155       /* If there's no instruction mnemonic suffix we try to invent one
2156          based on register operands.  */
2157       if (!i.suffix)
2158         {
2159           /* We take i.suffix from the last register operand specified,
2160              Destination register type is more significant than source
2161              register type.  */
2162           int op;
2163           for (op = i.operands; --op >= 0;)
2164             if ((i.types[op] & Reg)
2165                 && !(i.tm.operand_types[op] & InOutPortReg))
2166               {
2167                 i.suffix = ((i.types[op] & Reg8) ? BYTE_MNEM_SUFFIX :
2168                             (i.types[op] & Reg16) ? WORD_MNEM_SUFFIX :
2169                             (i.types[op] & Reg64) ? QWORD_MNEM_SUFFIX :
2170                             LONG_MNEM_SUFFIX);
2171                 break;
2172               }
2173         }
2174       else if (i.suffix == BYTE_MNEM_SUFFIX)
2175         {
2176           if (!check_byte_reg ())
2177             return 0;
2178         }
2179       else if (i.suffix == LONG_MNEM_SUFFIX)
2180         {
2181           if (!check_long_reg ())
2182             return 0;
2183         }
2184       else if (i.suffix == QWORD_MNEM_SUFFIX)
2185         {
2186           if (!check_qword_reg ())
2187             return 0;
2188         }
2189       else if (i.suffix == WORD_MNEM_SUFFIX)
2190         {
2191           if (!check_word_reg ())
2192             return 0;
2193         }
2194       else if (intel_syntax && (i.tm.opcode_modifier & IgnoreSize))
2195         /* Do nothing if the instruction is going to ignore the prefix.  */
2196         ;
2197       else
2198         abort ();
2199     }
2200   else if ((i.tm.opcode_modifier & DefaultSize) && !i.suffix)
2201     {
2202       i.suffix = stackop_size;
2203     }
2204
2205   /* Change the opcode based on the operand size given by i.suffix;
2206      We need not change things for byte insns.  */
2207
2208   if (!i.suffix && (i.tm.opcode_modifier & W))
2209     {
2210       as_bad (_("no instruction mnemonic suffix given and no register operands; can't size instruction"));
2211       return 0;
2212     }
2213
2214   /* For movzx and movsx, need to check the register type.  */
2215   if (intel_syntax
2216       && (i.tm.base_opcode == 0xfb6 || i.tm.base_opcode == 0xfbe)
2217       && i.suffix == BYTE_MNEM_SUFFIX)
2218     {
2219       unsigned int prefix = DATA_PREFIX_OPCODE;
2220
2221       if ((i.op[1].regs->reg_type & Reg16) != 0)
2222         if (!add_prefix (prefix))
2223           return 0;
2224     }
2225
2226   if (i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
2227     {
2228       /* It's not a byte, select word/dword operation.  */
2229       if (i.tm.opcode_modifier & W)
2230         {
2231           if (i.tm.opcode_modifier & ShortForm)
2232             i.tm.base_opcode |= 8;
2233           else
2234             i.tm.base_opcode |= 1;
2235         }
2236
2237       /* Now select between word & dword operations via the operand
2238          size prefix, except for instructions that will ignore this
2239          prefix anyway.  */
2240       if (i.suffix != QWORD_MNEM_SUFFIX
2241           && (i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
2242           && !(i.tm.opcode_modifier & IgnoreSize))
2243         {
2244           unsigned int prefix = DATA_PREFIX_OPCODE;
2245           if (i.tm.opcode_modifier & JumpByte) /* jcxz, loop */
2246             prefix = ADDR_PREFIX_OPCODE;
2247
2248           if (!add_prefix (prefix))
2249             return 0;
2250         }
2251
2252       if (i.suffix != QWORD_MNEM_SUFFIX && (flag_code == CODE_64BIT)
2253           && !(i.tm.opcode_modifier & IgnoreSize)
2254           && (i.tm.opcode_modifier & JumpByte))
2255         {
2256           if (!add_prefix (ADDR_PREFIX_OPCODE))
2257             return 0;
2258         }
2259
2260       /* Set mode64 for an operand.  */
2261       if (i.suffix == QWORD_MNEM_SUFFIX
2262           && (i.tm.opcode_modifier & NoRex64) == 0)
2263         {
2264           i.rex |= REX_MODE64;
2265           if (flag_code < CODE_64BIT)
2266             {
2267               as_bad (_("64bit operations available only in 64bit modes."));
2268               return 0;
2269             }
2270         }
2271
2272       /* Size floating point instruction.  */
2273       if (i.suffix == LONG_MNEM_SUFFIX)
2274         {
2275           if (i.tm.opcode_modifier & FloatMF)
2276             i.tm.base_opcode ^= 4;
2277         }
2278     }
2279
2280   return 1;
2281 }
2282
2283 static int
2284 check_byte_reg ()
2285 {
2286   int op;
2287   for (op = i.operands; --op >= 0;)
2288     {
2289       /* If this is an eight bit register, it's OK.  If it's the 16 or
2290          32 bit version of an eight bit register, we will just use the
2291          low portion, and that's OK too.  */
2292       if (i.types[op] & Reg8)
2293         continue;
2294
2295       /* movzx and movsx should not generate this warning.  */
2296       if (intel_syntax
2297           && (i.tm.base_opcode == 0xfb7
2298               || i.tm.base_opcode == 0xfb6
2299               || i.tm.base_opcode == 0x63
2300               || i.tm.base_opcode == 0xfbe
2301               || i.tm.base_opcode == 0xfbf))
2302         continue;
2303
2304       if ((i.types[op] & WordReg) && i.op[op].regs->reg_num < 4
2305 #if 0
2306           /* Check that the template allows eight bit regs.  This
2307              kills insns such as `orb $1,%edx', which maybe should be
2308              allowed.  */
2309           && (i.tm.operand_types[op] & (Reg8 | InOutPortReg))
2310 #endif
2311           )
2312         {
2313           /* Prohibit these changes in the 64bit mode, since the
2314              lowering is more complicated.  */
2315           if (flag_code == CODE_64BIT
2316               && (i.tm.operand_types[op] & InOutPortReg) == 0)
2317             {
2318               as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2319                       i.op[op].regs->reg_name,
2320                       i.suffix);
2321               return 0;
2322             }
2323 #if REGISTER_WARNINGS
2324           if (!quiet_warnings
2325               && (i.tm.operand_types[op] & InOutPortReg) == 0)
2326             as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
2327                      (i.op[op].regs + (i.types[op] & Reg16
2328                                        ? REGNAM_AL - REGNAM_AX
2329                                        : REGNAM_AL - REGNAM_EAX))->reg_name,
2330                      i.op[op].regs->reg_name,
2331                      i.suffix);
2332 #endif
2333           continue;
2334         }
2335       /* Any other register is bad.  */
2336       if (i.types[op] & (Reg | RegMMX | RegXMM
2337                          | SReg2 | SReg3
2338                          | Control | Debug | Test
2339                          | FloatReg | FloatAcc))
2340         {
2341           as_bad (_("`%%%s' not allowed with `%s%c'"),
2342                   i.op[op].regs->reg_name,
2343                   i.tm.name,
2344                   i.suffix);
2345           return 0;
2346         }
2347     }
2348   return 1;
2349 }
2350
2351 static int
2352 check_long_reg ()
2353 {
2354   int op;
2355
2356   for (op = i.operands; --op >= 0;)
2357     /* Reject eight bit registers, except where the template requires
2358        them. (eg. movzb)  */
2359     if ((i.types[op] & Reg8) != 0
2360         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
2361       {
2362         as_bad (_("`%%%s' not allowed with `%s%c'"),
2363                 i.op[op].regs->reg_name,
2364                 i.tm.name,
2365                 i.suffix);
2366         return 0;
2367       }
2368   /* Warn if the e prefix on a general reg is missing.  */
2369     else if ((!quiet_warnings || flag_code == CODE_64BIT)
2370              && (i.types[op] & Reg16) != 0
2371              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
2372       {
2373         /* Prohibit these changes in the 64bit mode, since the
2374            lowering is more complicated.  */
2375         if (flag_code == CODE_64BIT)
2376           {
2377             as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2378                     i.op[op].regs->reg_name,
2379                     i.suffix);
2380             return 0;
2381           }
2382 #if REGISTER_WARNINGS
2383         else
2384           as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
2385                    (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
2386                    i.op[op].regs->reg_name,
2387                    i.suffix);
2388 #endif
2389       }
2390   /* Warn if the r prefix on a general reg is missing.  */
2391     else if ((i.types[op] & Reg64) != 0
2392              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
2393       {
2394         as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2395                 i.op[op].regs->reg_name,
2396                 i.suffix);
2397         return 0;
2398       }
2399   return 1;
2400 }
2401
2402 static int
2403 check_qword_reg ()
2404 {
2405   int op;
2406
2407   for (op = i.operands; --op >= 0; )
2408     /* Reject eight bit registers, except where the template requires
2409        them. (eg. movzb)  */
2410     if ((i.types[op] & Reg8) != 0
2411         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
2412       {
2413         as_bad (_("`%%%s' not allowed with `%s%c'"),
2414                 i.op[op].regs->reg_name,
2415                 i.tm.name,
2416                 i.suffix);
2417         return 0;
2418       }
2419   /* Warn if the e prefix on a general reg is missing.  */
2420     else if (((i.types[op] & Reg16) != 0
2421               || (i.types[op] & Reg32) != 0)
2422              && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
2423       {
2424         /* Prohibit these changes in the 64bit mode, since the
2425            lowering is more complicated.  */
2426         as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2427                 i.op[op].regs->reg_name,
2428                 i.suffix);
2429         return 0;
2430       }
2431   return 1;
2432 }
2433
2434 static int
2435 check_word_reg ()
2436 {
2437   int op;
2438   for (op = i.operands; --op >= 0;)
2439     /* Reject eight bit registers, except where the template requires
2440        them. (eg. movzb)  */
2441     if ((i.types[op] & Reg8) != 0
2442         && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
2443       {
2444         as_bad (_("`%%%s' not allowed with `%s%c'"),
2445                 i.op[op].regs->reg_name,
2446                 i.tm.name,
2447                 i.suffix);
2448         return 0;
2449       }
2450   /* Warn if the e prefix on a general reg is present.  */
2451     else if ((!quiet_warnings || flag_code == CODE_64BIT)
2452              && (i.types[op] & Reg32) != 0
2453              && (i.tm.operand_types[op] & (Reg16 | Acc)) != 0)
2454       {
2455         /* Prohibit these changes in the 64bit mode, since the
2456            lowering is more complicated.  */
2457         if (flag_code == CODE_64BIT)
2458           {
2459             as_bad (_("Incorrect register `%%%s' used with `%c' suffix"),
2460                     i.op[op].regs->reg_name,
2461                     i.suffix);
2462             return 0;
2463           }
2464         else
2465 #if REGISTER_WARNINGS
2466           as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
2467                    (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
2468                    i.op[op].regs->reg_name,
2469                    i.suffix);
2470 #endif
2471       }
2472   return 1;
2473 }
2474
2475 static int
2476 finalize_imm ()
2477 {
2478   unsigned int overlap0, overlap1, overlap2;
2479
2480   overlap0 = i.types[0] & i.tm.operand_types[0];
2481   if ((overlap0 & (Imm8 | Imm8S | Imm16 | Imm32 | Imm32S))
2482       && overlap0 != Imm8 && overlap0 != Imm8S
2483       && overlap0 != Imm16 && overlap0 != Imm32S
2484       && overlap0 != Imm32 && overlap0 != Imm64)
2485     {
2486       if (i.suffix)
2487         {
2488           overlap0 &= (i.suffix == BYTE_MNEM_SUFFIX
2489                        ? Imm8 | Imm8S
2490                        : (i.suffix == WORD_MNEM_SUFFIX
2491                           ? Imm16
2492                           : (i.suffix == QWORD_MNEM_SUFFIX
2493                              ? Imm64 | Imm32S
2494                              : Imm32)));
2495         }
2496       else if (overlap0 == (Imm16 | Imm32S | Imm32)
2497                || overlap0 == (Imm16 | Imm32)
2498                || overlap0 == (Imm16 | Imm32S))
2499         {
2500           overlap0 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
2501                       ? Imm16 : Imm32S);
2502         }
2503       if (overlap0 != Imm8 && overlap0 != Imm8S
2504           && overlap0 != Imm16 && overlap0 != Imm32S
2505           && overlap0 != Imm32 && overlap0 != Imm64)
2506         {
2507           as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
2508           return 0;
2509         }
2510     }
2511   i.types[0] = overlap0;
2512
2513   overlap1 = i.types[1] & i.tm.operand_types[1];
2514   if ((overlap1 & (Imm8 | Imm8S | Imm16 | Imm32S | Imm32))
2515       && overlap1 != Imm8 && overlap1 != Imm8S
2516       && overlap1 != Imm16 && overlap1 != Imm32S
2517       && overlap1 != Imm32 && overlap1 != Imm64)
2518     {
2519       if (i.suffix)
2520         {
2521           overlap1 &= (i.suffix == BYTE_MNEM_SUFFIX
2522                        ? Imm8 | Imm8S
2523                        : (i.suffix == WORD_MNEM_SUFFIX
2524                           ? Imm16
2525                           : (i.suffix == QWORD_MNEM_SUFFIX
2526                              ? Imm64 | Imm32S
2527                              : Imm32)));
2528         }
2529       else if (overlap1 == (Imm16 | Imm32 | Imm32S)
2530                || overlap1 == (Imm16 | Imm32)
2531                || overlap1 == (Imm16 | Imm32S))
2532         {
2533           overlap1 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
2534                       ? Imm16 : Imm32S);
2535         }
2536       if (overlap1 != Imm8 && overlap1 != Imm8S
2537           && overlap1 != Imm16 && overlap1 != Imm32S
2538           && overlap1 != Imm32 && overlap1 != Imm64)
2539         {
2540           as_bad (_("no instruction mnemonic suffix given; can't determine immediate size %x %c"),overlap1, i.suffix);
2541           return 0;
2542         }
2543     }
2544   i.types[1] = overlap1;
2545
2546   overlap2 = i.types[2] & i.tm.operand_types[2];
2547   assert ((overlap2 & Imm) == 0);
2548   i.types[2] = overlap2;
2549
2550   return 1;
2551 }
2552
2553 static int
2554 process_operands ()
2555 {
2556   /* Default segment register this instruction will use for memory
2557      accesses.  0 means unknown.  This is only for optimizing out
2558      unnecessary segment overrides.  */
2559   const seg_entry *default_seg = 0;
2560
2561   /* The imul $imm, %reg instruction is converted into
2562      imul $imm, %reg, %reg, and the clr %reg instruction
2563      is converted into xor %reg, %reg.  */
2564   if (i.tm.opcode_modifier & regKludge)
2565     {
2566       unsigned int first_reg_op = (i.types[0] & Reg) ? 0 : 1;
2567       /* Pretend we saw the extra register operand.  */
2568       assert (i.op[first_reg_op + 1].regs == 0);
2569       i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
2570       i.types[first_reg_op + 1] = i.types[first_reg_op];
2571       i.reg_operands = 2;
2572     }
2573
2574   if (i.tm.opcode_modifier & ShortForm)
2575     {
2576       /* The register or float register operand is in operand 0 or 1.  */
2577       unsigned int op = (i.types[0] & (Reg | FloatReg)) ? 0 : 1;
2578       /* Register goes in low 3 bits of opcode.  */
2579       i.tm.base_opcode |= i.op[op].regs->reg_num;
2580       if ((i.op[op].regs->reg_flags & RegRex) != 0)
2581         i.rex |= REX_EXTZ;
2582       if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
2583         {
2584           /* Warn about some common errors, but press on regardless.
2585              The first case can be generated by gcc (<= 2.8.1).  */
2586           if (i.operands == 2)
2587             {
2588               /* Reversed arguments on faddp, fsubp, etc.  */
2589               as_warn (_("translating to `%s %%%s,%%%s'"), i.tm.name,
2590                        i.op[1].regs->reg_name,
2591                        i.op[0].regs->reg_name);
2592             }
2593           else
2594             {
2595               /* Extraneous `l' suffix on fp insn.  */
2596               as_warn (_("translating to `%s %%%s'"), i.tm.name,
2597                        i.op[0].regs->reg_name);
2598             }
2599         }
2600     }
2601   else if (i.tm.opcode_modifier & Modrm)
2602     {
2603       /* The opcode is completed (modulo i.tm.extension_opcode which
2604          must be put into the modrm byte).
2605          Now, we make the modrm & index base bytes based on all the
2606          info we've collected.  */
2607
2608       default_seg = build_modrm_byte ();
2609     }
2610   else if (i.tm.opcode_modifier & (Seg2ShortForm | Seg3ShortForm))
2611     {
2612       if (i.tm.base_opcode == POP_SEG_SHORT
2613           && i.op[0].regs->reg_num == 1)
2614         {
2615           as_bad (_("you can't `pop %%cs'"));
2616           return 0;
2617         }
2618       i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
2619       if ((i.op[0].regs->reg_flags & RegRex) != 0)
2620         i.rex |= REX_EXTZ;
2621     }
2622   else if ((i.tm.base_opcode & ~(D | W)) == MOV_AX_DISP32)
2623     {
2624       default_seg = &ds;
2625     }
2626   else if ((i.tm.opcode_modifier & IsString) != 0)
2627     {
2628       /* For the string instructions that allow a segment override
2629          on one of their operands, the default segment is ds.  */
2630       default_seg = &ds;
2631     }
2632
2633   /* If a segment was explicitly specified,
2634      and the specified segment is not the default,
2635      use an opcode prefix to select it.
2636      If we never figured out what the default segment is,
2637      then default_seg will be zero at this point,
2638      and the specified segment prefix will always be used.  */
2639   if ((i.seg[0]) && (i.seg[0] != default_seg))
2640     {
2641       if (!add_prefix (i.seg[0]->seg_prefix))
2642         return 0;
2643     }
2644   return 1;
2645 }
2646
2647 static const seg_entry *
2648 build_modrm_byte ()
2649 {
2650   const seg_entry *default_seg = 0;
2651
2652   /* i.reg_operands MUST be the number of real register operands;
2653      implicit registers do not count.  */
2654   if (i.reg_operands == 2)
2655     {
2656       unsigned int source, dest;
2657       source = ((i.types[0]
2658                  & (Reg | RegMMX | RegXMM
2659                     | SReg2 | SReg3
2660                     | Control | Debug | Test))
2661                 ? 0 : 1);
2662       dest = source + 1;
2663
2664       i.rm.mode = 3;
2665       /* One of the register operands will be encoded in the i.tm.reg
2666          field, the other in the combined i.tm.mode and i.tm.regmem
2667          fields.  If no form of this instruction supports a memory
2668          destination operand, then we assume the source operand may
2669          sometimes be a memory operand and so we need to store the
2670          destination in the i.rm.reg field.  */
2671       if ((i.tm.operand_types[dest] & AnyMem) == 0)
2672         {
2673           i.rm.reg = i.op[dest].regs->reg_num;
2674           i.rm.regmem = i.op[source].regs->reg_num;
2675           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
2676             i.rex |= REX_EXTX;
2677           if ((i.op[source].regs->reg_flags & RegRex) != 0)
2678             i.rex |= REX_EXTZ;
2679         }
2680       else
2681         {
2682           i.rm.reg = i.op[source].regs->reg_num;
2683           i.rm.regmem = i.op[dest].regs->reg_num;
2684           if ((i.op[dest].regs->reg_flags & RegRex) != 0)
2685             i.rex |= REX_EXTZ;
2686           if ((i.op[source].regs->reg_flags & RegRex) != 0)
2687             i.rex |= REX_EXTX;
2688         }
2689     }
2690   else
2691     {                   /* If it's not 2 reg operands...  */
2692       if (i.mem_operands)
2693         {
2694           unsigned int fake_zero_displacement = 0;
2695           unsigned int op = ((i.types[0] & AnyMem)
2696                              ? 0
2697                              : (i.types[1] & AnyMem) ? 1 : 2);
2698
2699           default_seg = &ds;
2700
2701           if (i.base_reg == 0)
2702             {
2703               i.rm.mode = 0;
2704               if (!i.disp_operands)
2705                 fake_zero_displacement = 1;
2706               if (i.index_reg == 0)
2707                 {
2708                   /* Operand is just <disp>  */
2709                   if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0)
2710                       && (flag_code != CODE_64BIT))
2711                     {
2712                       i.rm.regmem = NO_BASE_REGISTER_16;
2713                       i.types[op] &= ~Disp;
2714                       i.types[op] |= Disp16;
2715                     }
2716                   else if (flag_code != CODE_64BIT
2717                            || (i.prefix[ADDR_PREFIX] != 0))
2718                     {
2719                       i.rm.regmem = NO_BASE_REGISTER;
2720                       i.types[op] &= ~Disp;
2721                       i.types[op] |= Disp32;
2722                     }
2723                   else
2724                     {
2725                       /* 64bit mode overwrites the 32bit absolute
2726                          addressing by RIP relative addressing and
2727                          absolute addressing is encoded by one of the
2728                          redundant SIB forms.  */
2729                       i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2730                       i.sib.base = NO_BASE_REGISTER;
2731                       i.sib.index = NO_INDEX_REGISTER;
2732                       i.types[op] &= ~Disp;
2733                       i.types[op] |= Disp32S;
2734                     }
2735                 }
2736               else /* !i.base_reg && i.index_reg  */
2737                 {
2738                   i.sib.index = i.index_reg->reg_num;
2739                   i.sib.base = NO_BASE_REGISTER;
2740                   i.sib.scale = i.log2_scale_factor;
2741                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2742                   i.types[op] &= ~Disp;
2743                   if (flag_code != CODE_64BIT)
2744                     i.types[op] |= Disp32;      /* Must be 32 bit */
2745                   else
2746                     i.types[op] |= Disp32S;
2747                   if ((i.index_reg->reg_flags & RegRex) != 0)
2748                     i.rex |= REX_EXTY;
2749                 }
2750             }
2751           /* RIP addressing for 64bit mode.  */
2752           else if (i.base_reg->reg_type == BaseIndex)
2753             {
2754               i.rm.regmem = NO_BASE_REGISTER;
2755               i.types[op] &= ~Disp;
2756               i.types[op] |= Disp32S;
2757               i.flags[op] = Operand_PCrel;
2758             }
2759           else if (i.base_reg->reg_type & Reg16)
2760             {
2761               switch (i.base_reg->reg_num)
2762                 {
2763                 case 3: /* (%bx)  */
2764                   if (i.index_reg == 0)
2765                     i.rm.regmem = 7;
2766                   else /* (%bx,%si) -> 0, or (%bx,%di) -> 1  */
2767                     i.rm.regmem = i.index_reg->reg_num - 6;
2768                   break;
2769                 case 5: /* (%bp)  */
2770                   default_seg = &ss;
2771                   if (i.index_reg == 0)
2772                     {
2773                       i.rm.regmem = 6;
2774                       if ((i.types[op] & Disp) == 0)
2775                         {
2776                           /* fake (%bp) into 0(%bp)  */
2777                           i.types[op] |= Disp8;
2778                           fake_zero_displacement = 1;
2779                         }
2780                     }
2781                   else /* (%bp,%si) -> 2, or (%bp,%di) -> 3  */
2782                     i.rm.regmem = i.index_reg->reg_num - 6 + 2;
2783                   break;
2784                 default: /* (%si) -> 4 or (%di) -> 5  */
2785                   i.rm.regmem = i.base_reg->reg_num - 6 + 4;
2786                 }
2787               i.rm.mode = mode_from_disp_size (i.types[op]);
2788             }
2789           else /* i.base_reg and 32/64 bit mode  */
2790             {
2791               if (flag_code == CODE_64BIT
2792                   && (i.types[op] & Disp))
2793                 {
2794                   if (i.types[op] & Disp8)
2795                     i.types[op] = Disp8 | Disp32S;
2796                   else
2797                     i.types[op] = Disp32S;
2798                 }
2799               i.rm.regmem = i.base_reg->reg_num;
2800               if ((i.base_reg->reg_flags & RegRex) != 0)
2801                 i.rex |= REX_EXTZ;
2802               i.sib.base = i.base_reg->reg_num;
2803               /* x86-64 ignores REX prefix bit here to avoid decoder
2804                  complications.  */
2805               if ((i.base_reg->reg_num & 7) == EBP_REG_NUM)
2806                 {
2807                   default_seg = &ss;
2808                   if (i.disp_operands == 0)
2809                     {
2810                       fake_zero_displacement = 1;
2811                       i.types[op] |= Disp8;
2812                     }
2813                 }
2814               else if (i.base_reg->reg_num == ESP_REG_NUM)
2815                 {
2816                   default_seg = &ss;
2817                 }
2818               i.sib.scale = i.log2_scale_factor;
2819               if (i.index_reg == 0)
2820                 {
2821                   /* <disp>(%esp) becomes two byte modrm with no index
2822                      register.  We've already stored the code for esp
2823                      in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
2824                      Any base register besides %esp will not use the
2825                      extra modrm byte.  */
2826                   i.sib.index = NO_INDEX_REGISTER;
2827 #if !SCALE1_WHEN_NO_INDEX
2828                   /* Another case where we force the second modrm byte.  */
2829                   if (i.log2_scale_factor)
2830                     i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2831 #endif
2832                 }
2833               else
2834                 {
2835                   i.sib.index = i.index_reg->reg_num;
2836                   i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
2837                   if ((i.index_reg->reg_flags & RegRex) != 0)
2838                     i.rex |= REX_EXTY;
2839                 }
2840               i.rm.mode = mode_from_disp_size (i.types[op]);
2841             }
2842
2843           if (fake_zero_displacement)
2844             {
2845               /* Fakes a zero displacement assuming that i.types[op]
2846                  holds the correct displacement size.  */
2847               expressionS *exp;
2848
2849               assert (i.op[op].disps == 0);
2850               exp = &disp_expressions[i.disp_operands++];
2851               i.op[op].disps = exp;
2852               exp->X_op = O_constant;
2853               exp->X_add_number = 0;
2854               exp->X_add_symbol = (symbolS *) 0;
2855               exp->X_op_symbol = (symbolS *) 0;
2856             }
2857         }
2858
2859       /* Fill in i.rm.reg or i.rm.regmem field with register operand
2860          (if any) based on i.tm.extension_opcode.  Again, we must be
2861          careful to make sure that segment/control/debug/test/MMX
2862          registers are coded into the i.rm.reg field.  */
2863       if (i.reg_operands)
2864         {
2865           unsigned int op =
2866             ((i.types[0]
2867               & (Reg | RegMMX | RegXMM
2868                  | SReg2 | SReg3
2869                  | Control | Debug | Test))
2870              ? 0
2871              : ((i.types[1]
2872                  & (Reg | RegMMX | RegXMM
2873                     | SReg2 | SReg3
2874                     | Control | Debug | Test))
2875                 ? 1
2876                 : 2));
2877           /* If there is an extension opcode to put here, the register
2878              number must be put into the regmem field.  */
2879           if (i.tm.extension_opcode != None)
2880             {
2881               i.rm.regmem = i.op[op].regs->reg_num;
2882               if ((i.op[op].regs->reg_flags & RegRex) != 0)
2883                 i.rex |= REX_EXTZ;
2884             }
2885           else
2886             {
2887               i.rm.reg = i.op[op].regs->reg_num;
2888               if ((i.op[op].regs->reg_flags & RegRex) != 0)
2889                 i.rex |= REX_EXTX;
2890             }
2891
2892           /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
2893              must set it to 3 to indicate this is a register operand
2894              in the regmem field.  */
2895           if (!i.mem_operands)
2896             i.rm.mode = 3;
2897         }
2898
2899       /* Fill in i.rm.reg field with extension opcode (if any).  */
2900       if (i.tm.extension_opcode != None)
2901         i.rm.reg = i.tm.extension_opcode;
2902     }
2903   return default_seg;
2904 }
2905
2906 static void
2907 output_branch ()
2908 {
2909   char *p;
2910   int code16;
2911   int prefix;
2912   relax_substateT subtype;
2913   symbolS *sym;
2914   offsetT off;
2915
2916   code16 = 0;
2917   if (flag_code == CODE_16BIT)
2918     code16 = CODE16;
2919
2920   prefix = 0;
2921   if (i.prefix[DATA_PREFIX] != 0)
2922     {
2923       prefix = 1;
2924       i.prefixes -= 1;
2925       code16 ^= CODE16;
2926     }
2927   /* Pentium4 branch hints.  */
2928   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
2929       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
2930     {
2931       prefix++;
2932       i.prefixes--;
2933     }
2934   if (i.prefix[REX_PREFIX] != 0)
2935     {
2936       prefix++;
2937       i.prefixes--;
2938     }
2939
2940   if (i.prefixes != 0 && !intel_syntax)
2941     as_warn (_("skipping prefixes on this instruction"));
2942
2943   /* It's always a symbol;  End frag & setup for relax.
2944      Make sure there is enough room in this frag for the largest
2945      instruction we may generate in md_convert_frag.  This is 2
2946      bytes for the opcode and room for the prefix and largest
2947      displacement.  */
2948   frag_grow (prefix + 2 + 4);
2949   /* Prefix and 1 opcode byte go in fr_fix.  */
2950   p = frag_more (prefix + 1);
2951   if (i.prefix[DATA_PREFIX] != 0)
2952     *p++ = DATA_PREFIX_OPCODE;
2953   if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
2954       || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
2955     *p++ = i.prefix[SEG_PREFIX];
2956   if (i.prefix[REX_PREFIX] != 0)
2957     *p++ = i.prefix[REX_PREFIX];
2958   *p = i.tm.base_opcode;
2959
2960   if ((unsigned char) *p == JUMP_PC_RELATIVE)
2961     subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL);
2962   else if ((cpu_arch_flags & Cpu386) != 0)
2963     subtype = ENCODE_RELAX_STATE (COND_JUMP, SMALL);
2964   else
2965     subtype = ENCODE_RELAX_STATE (COND_JUMP86, SMALL);
2966   subtype |= code16;
2967
2968   sym = i.op[0].disps->X_add_symbol;
2969   off = i.op[0].disps->X_add_number;
2970
2971   if (i.op[0].disps->X_op != O_constant
2972       && i.op[0].disps->X_op != O_symbol)
2973     {
2974       /* Handle complex expressions.  */
2975       sym = make_expr_symbol (i.op[0].disps);
2976       off = 0;
2977     }
2978
2979   /* 1 possible extra opcode + 4 byte displacement go in var part.
2980      Pass reloc in fr_var.  */
2981   frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
2982 }
2983
2984 static void
2985 output_jump ()
2986 {
2987   char *p;
2988   int size;
2989
2990   if (i.tm.opcode_modifier & JumpByte)
2991     {
2992       /* This is a loop or jecxz type instruction.  */
2993       size = 1;
2994       if (i.prefix[ADDR_PREFIX] != 0)
2995         {
2996           FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
2997           i.prefixes -= 1;
2998         }
2999       /* Pentium4 branch hints.  */
3000       if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
3001           || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
3002         {
3003           FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
3004           i.prefixes--;
3005         }
3006     }
3007   else
3008     {
3009       int code16;
3010
3011       code16 = 0;
3012       if (flag_code == CODE_16BIT)
3013         code16 = CODE16;
3014
3015       if (i.prefix[DATA_PREFIX] != 0)
3016         {
3017           FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
3018           i.prefixes -= 1;
3019           code16 ^= CODE16;
3020         }
3021
3022       size = 4;
3023       if (code16)
3024         size = 2;
3025     }
3026
3027   if (i.prefix[REX_PREFIX] != 0)
3028     {
3029       FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
3030       i.prefixes -= 1;
3031     }
3032
3033   if (i.prefixes != 0 && !intel_syntax)
3034     as_warn (_("skipping prefixes on this instruction"));
3035
3036   p = frag_more (1 + size);
3037   *p++ = i.tm.base_opcode;
3038
3039   fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3040                i.op[0].disps, 1, reloc (size, 1, 1, i.reloc[0]));
3041 }
3042
3043 static void
3044 output_interseg_jump ()
3045 {
3046   char *p;
3047   int size;
3048   int prefix;
3049   int code16;
3050
3051   code16 = 0;
3052   if (flag_code == CODE_16BIT)
3053     code16 = CODE16;
3054
3055   prefix = 0;
3056   if (i.prefix[DATA_PREFIX] != 0)
3057     {
3058       prefix = 1;
3059       i.prefixes -= 1;
3060       code16 ^= CODE16;
3061     }
3062   if (i.prefix[REX_PREFIX] != 0)
3063     {
3064       prefix++;
3065       i.prefixes -= 1;
3066     }
3067
3068   size = 4;
3069   if (code16)
3070     size = 2;
3071
3072   if (i.prefixes != 0 && !intel_syntax)
3073     as_warn (_("skipping prefixes on this instruction"));
3074
3075   /* 1 opcode; 2 segment; offset  */
3076   p = frag_more (prefix + 1 + 2 + size);
3077
3078   if (i.prefix[DATA_PREFIX] != 0)
3079     *p++ = DATA_PREFIX_OPCODE;
3080
3081   if (i.prefix[REX_PREFIX] != 0)
3082     *p++ = i.prefix[REX_PREFIX];
3083
3084   *p++ = i.tm.base_opcode;
3085   if (i.op[1].imms->X_op == O_constant)
3086     {
3087       offsetT n = i.op[1].imms->X_add_number;
3088
3089       if (size == 2
3090           && !fits_in_unsigned_word (n)
3091           && !fits_in_signed_word (n))
3092         {
3093           as_bad (_("16-bit jump out of range"));
3094           return;
3095         }
3096       md_number_to_chars (p, n, size);
3097     }
3098   else
3099     fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3100                  i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
3101   if (i.op[0].imms->X_op != O_constant)
3102     as_bad (_("can't handle non absolute segment in `%s'"),
3103             i.tm.name);
3104   md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
3105 }
3106
3107 static void
3108 output_insn ()
3109 {
3110   /* Tie dwarf2 debug info to the address at the start of the insn.
3111      We can't do this after the insn has been output as the current
3112      frag may have been closed off.  eg. by frag_var.  */
3113   dwarf2_emit_insn (0);
3114
3115   /* Output jumps.  */
3116   if (i.tm.opcode_modifier & Jump)
3117     output_branch ();
3118   else if (i.tm.opcode_modifier & (JumpByte | JumpDword))
3119     output_jump ();
3120   else if (i.tm.opcode_modifier & JumpInterSegment)
3121     output_interseg_jump ();
3122   else
3123     {
3124       /* Output normal instructions here.  */
3125       char *p;
3126       unsigned char *q;
3127
3128       /* All opcodes on i386 have either 1 or 2 bytes.  We may use third
3129          byte for the SSE instructions to specify a prefix they require.  */
3130       if (i.tm.base_opcode & 0xff0000)
3131         add_prefix ((i.tm.base_opcode >> 16) & 0xff);
3132
3133       /* The prefix bytes.  */
3134       for (q = i.prefix;
3135            q < i.prefix + sizeof (i.prefix) / sizeof (i.prefix[0]);
3136            q++)
3137         {
3138           if (*q)
3139             {
3140               p = frag_more (1);
3141               md_number_to_chars (p, (valueT) *q, 1);
3142             }
3143         }
3144
3145       /* Now the opcode; be careful about word order here!  */
3146       if (fits_in_unsigned_byte (i.tm.base_opcode))
3147         {
3148           FRAG_APPEND_1_CHAR (i.tm.base_opcode);
3149         }
3150       else
3151         {
3152           p = frag_more (2);
3153           /* Put out high byte first: can't use md_number_to_chars!  */
3154           *p++ = (i.tm.base_opcode >> 8) & 0xff;
3155           *p = i.tm.base_opcode & 0xff;
3156         }
3157
3158       /* Now the modrm byte and sib byte (if present).  */
3159       if (i.tm.opcode_modifier & Modrm)
3160         {
3161           p = frag_more (1);
3162           md_number_to_chars (p,
3163                               (valueT) (i.rm.regmem << 0
3164                                         | i.rm.reg << 3
3165                                         | i.rm.mode << 6),
3166                               1);
3167           /* If i.rm.regmem == ESP (4)
3168              && i.rm.mode != (Register mode)
3169              && not 16 bit
3170              ==> need second modrm byte.  */
3171           if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
3172               && i.rm.mode != 3
3173               && !(i.base_reg && (i.base_reg->reg_type & Reg16) != 0))
3174             {
3175               p = frag_more (1);
3176               md_number_to_chars (p,
3177                                   (valueT) (i.sib.base << 0
3178                                             | i.sib.index << 3
3179                                             | i.sib.scale << 6),
3180                                   1);
3181             }
3182         }
3183
3184       if (i.disp_operands)
3185         output_disp ();
3186
3187       if (i.imm_operands)
3188         output_imm ();
3189     }
3190
3191 #ifdef DEBUG386
3192   if (flag_debug)
3193     {
3194       pi (line, &i);
3195     }
3196 #endif /* DEBUG386  */
3197 }
3198
3199 static void
3200 output_disp ()
3201 {
3202   char *p;
3203   unsigned int n;
3204
3205   for (n = 0; n < i.operands; n++)
3206     {
3207       if (i.types[n] & Disp)
3208         {
3209           if (i.op[n].disps->X_op == O_constant)
3210             {
3211               int size;
3212               offsetT val;
3213
3214               size = 4;
3215               if (i.types[n] & (Disp8 | Disp16 | Disp64))
3216                 {
3217                   size = 2;
3218                   if (i.types[n] & Disp8)
3219                     size = 1;
3220                   if (i.types[n] & Disp64)
3221                     size = 8;
3222                 }
3223               val = offset_in_range (i.op[n].disps->X_add_number,
3224                                      size);
3225               p = frag_more (size);
3226               md_number_to_chars (p, val, size);
3227             }
3228           else
3229             {
3230               int size = 4;
3231               int sign = 0;
3232               int pcrel = (i.flags[n] & Operand_PCrel) != 0;
3233
3234               /* The PC relative address is computed relative
3235                  to the instruction boundary, so in case immediate
3236                  fields follows, we need to adjust the value.  */
3237               if (pcrel && i.imm_operands)
3238                 {
3239                   int imm_size = 4;
3240                   unsigned int n1;
3241
3242                   for (n1 = 0; n1 < i.operands; n1++)
3243                     if (i.types[n1] & Imm)
3244                       {
3245                         if (i.types[n1] & (Imm8 | Imm8S | Imm16 | Imm64))
3246                           {
3247                             imm_size = 2;
3248                             if (i.types[n1] & (Imm8 | Imm8S))
3249                               imm_size = 1;
3250                             if (i.types[n1] & Imm64)
3251                               imm_size = 8;
3252                           }
3253                         break;
3254                       }
3255                   /* We should find the immediate.  */
3256                   if (n1 == i.operands)
3257                     abort ();
3258                   i.op[n].disps->X_add_number -= imm_size;
3259                 }
3260
3261               if (i.types[n] & Disp32S)
3262                 sign = 1;
3263
3264               if (i.types[n] & (Disp16 | Disp64))
3265                 {
3266                   size = 2;
3267                   if (i.types[n] & Disp64)
3268                     size = 8;
3269                 }
3270
3271               p = frag_more (size);
3272               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3273                            i.op[n].disps, pcrel,
3274                            reloc (size, pcrel, sign, i.reloc[n]));
3275             }
3276         }
3277     }
3278 }
3279
3280 static void
3281 output_imm ()
3282 {
3283   char *p;
3284   unsigned int n;
3285
3286   for (n = 0; n < i.operands; n++)
3287     {
3288       if (i.types[n] & Imm)
3289         {
3290           if (i.op[n].imms->X_op == O_constant)
3291             {
3292               int size;
3293               offsetT val;
3294
3295               size = 4;
3296               if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
3297                 {
3298                   size = 2;
3299                   if (i.types[n] & (Imm8 | Imm8S))
3300                     size = 1;
3301                   else if (i.types[n] & Imm64)
3302                     size = 8;
3303                 }
3304               val = offset_in_range (i.op[n].imms->X_add_number,
3305                                      size);
3306               p = frag_more (size);
3307               md_number_to_chars (p, val, size);
3308             }
3309           else
3310             {
3311               /* Not absolute_section.
3312                  Need a 32-bit fixup (don't support 8bit
3313                  non-absolute imms).  Try to support other
3314                  sizes ...  */
3315               RELOC_ENUM reloc_type;
3316               int size = 4;
3317               int sign = 0;
3318
3319               if ((i.types[n] & (Imm32S))
3320                   && i.suffix == QWORD_MNEM_SUFFIX)
3321                 sign = 1;
3322               if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
3323                 {
3324                   size = 2;
3325                   if (i.types[n] & (Imm8 | Imm8S))
3326                     size = 1;
3327                   if (i.types[n] & Imm64)
3328                     size = 8;
3329                 }
3330
3331               p = frag_more (size);
3332               reloc_type = reloc (size, 0, sign, i.reloc[n]);
3333 #ifdef BFD_ASSEMBLER
3334               if (reloc_type == BFD_RELOC_32
3335                   && GOT_symbol
3336                   && GOT_symbol == i.op[n].imms->X_add_symbol
3337                   && (i.op[n].imms->X_op == O_symbol
3338                       || (i.op[n].imms->X_op == O_add
3339                           && ((symbol_get_value_expression
3340                                (i.op[n].imms->X_op_symbol)->X_op)
3341                               == O_subtract))))
3342                 {
3343                   /* We don't support dynamic linking on x86-64 yet.  */
3344                   if (flag_code == CODE_64BIT)
3345                     abort ();
3346                   reloc_type = BFD_RELOC_386_GOTPC;
3347                   i.op[n].imms->X_add_number += 3;
3348                 }
3349 #endif
3350               fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3351                            i.op[n].imms, 0, reloc_type);
3352             }
3353         }
3354     }
3355 }
3356 \f
3357 #ifndef LEX_AT
3358 static char *lex_got PARAMS ((RELOC_ENUM *, int *));
3359
3360 /* Parse operands of the form
3361    <symbol>@GOTOFF+<nnn>
3362    and similar .plt or .got references.
3363
3364    If we find one, set up the correct relocation in RELOC and copy the
3365    input string, minus the `@GOTOFF' into a malloc'd buffer for
3366    parsing by the calling routine.  Return this buffer, and if ADJUST
3367    is non-null set it to the length of the string we removed from the
3368    input line.  Otherwise return NULL.  */
3369 static char *
3370 lex_got (reloc, adjust)
3371      RELOC_ENUM *reloc;
3372      int *adjust;
3373 {
3374   static const char * const mode_name[NUM_FLAG_CODE] = { "32", "16", "64" };
3375   static const struct {
3376     const char *str;
3377     const RELOC_ENUM rel[NUM_FLAG_CODE];
3378   } gotrel[] = {
3379     { "PLT",      { BFD_RELOC_386_PLT32,  0, BFD_RELOC_X86_64_PLT32    } },
3380     { "GOTOFF",   { BFD_RELOC_386_GOTOFF, 0, 0                         } },
3381     { "GOTPCREL", { 0,                    0, BFD_RELOC_X86_64_GOTPCREL } },
3382     { "GOT",      { BFD_RELOC_386_GOT32,  0, BFD_RELOC_X86_64_GOT32    } }
3383   };
3384   char *cp;
3385   unsigned int j;
3386
3387   for (cp = input_line_pointer; *cp != '@'; cp++)
3388     if (is_end_of_line[(unsigned char) *cp])
3389       return NULL;
3390
3391   for (j = 0; j < sizeof (gotrel) / sizeof (gotrel[0]); j++)
3392     {
3393       int len;
3394
3395       len = strlen (gotrel[j].str);
3396       if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
3397         {
3398           if (gotrel[j].rel[(unsigned int) flag_code] != 0)
3399             {
3400               int first, second;
3401               char *tmpbuf, *past_reloc;
3402
3403               *reloc = gotrel[j].rel[(unsigned int) flag_code];
3404               if (adjust)
3405                 *adjust = len;
3406
3407               if (GOT_symbol == NULL)
3408                 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
3409
3410               /* Replace the relocation token with ' ', so that
3411                  errors like foo@GOTOFF1 will be detected.  */
3412
3413               /* The length of the first part of our input line.  */
3414               first = cp - input_line_pointer;
3415
3416               /* The second part goes from after the reloc token until
3417                  (and including) an end_of_line char.  Don't use strlen
3418                  here as the end_of_line char may not be a NUL.  */
3419               past_reloc = cp + 1 + len;
3420               for (cp = past_reloc; !is_end_of_line[(unsigned char) *cp++]; )
3421                 ;
3422               second = cp - past_reloc;
3423
3424               /* Allocate and copy string.  The trailing NUL shouldn't
3425                  be necessary, but be safe.  */
3426               tmpbuf = xmalloc (first + second + 2);
3427               memcpy (tmpbuf, input_line_pointer, first);
3428               tmpbuf[first] = ' ';
3429               memcpy (tmpbuf + first + 1, past_reloc, second);
3430               tmpbuf[first + second + 1] = '\0';
3431               return tmpbuf;
3432             }
3433
3434           as_bad (_("@%s reloc is not supported in %s bit mode"),
3435                   gotrel[j].str, mode_name[(unsigned int) flag_code]);
3436           return NULL;
3437         }
3438     }
3439
3440   /* Might be a symbol version string.  Don't as_bad here.  */
3441   return NULL;
3442 }
3443
3444 /* x86_cons_fix_new is called via the expression parsing code when a
3445    reloc is needed.  We use this hook to get the correct .got reloc.  */
3446 static RELOC_ENUM got_reloc = NO_RELOC;
3447
3448 void
3449 x86_cons_fix_new (frag, off, len, exp)
3450      fragS *frag;
3451      unsigned int off;
3452      unsigned int len;
3453      expressionS *exp;
3454 {
3455   RELOC_ENUM r = reloc (len, 0, 0, got_reloc);
3456   got_reloc = NO_RELOC;
3457   fix_new_exp (frag, off, len, exp, 0, r);
3458 }
3459
3460 void
3461 x86_cons (exp, size)
3462      expressionS *exp;
3463      int size;
3464 {
3465   if (size == 4)
3466     {
3467       /* Handle @GOTOFF and the like in an expression.  */
3468       char *save;
3469       char *gotfree_input_line;
3470       int adjust;
3471
3472       save = input_line_pointer;
3473       gotfree_input_line = lex_got (&got_reloc, &adjust);
3474       if (gotfree_input_line)
3475         input_line_pointer = gotfree_input_line;
3476
3477       expression (exp);
3478
3479       if (gotfree_input_line)
3480         {
3481           /* expression () has merrily parsed up to the end of line,
3482              or a comma - in the wrong buffer.  Transfer how far
3483              input_line_pointer has moved to the right buffer.  */
3484           input_line_pointer = (save
3485                                 + (input_line_pointer - gotfree_input_line)
3486                                 + adjust);
3487           free (gotfree_input_line);
3488         }
3489     }
3490   else
3491     expression (exp);
3492 }
3493 #endif
3494
3495 static int i386_immediate PARAMS ((char *));
3496
3497 static int
3498 i386_immediate (imm_start)
3499      char *imm_start;
3500 {
3501   char *save_input_line_pointer;
3502 #ifndef LEX_AT
3503   char *gotfree_input_line;
3504 #endif
3505   segT exp_seg = 0;
3506   expressionS *exp;
3507
3508   if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
3509     {
3510       as_bad (_("only 1 or 2 immediate operands are allowed"));
3511       return 0;
3512     }
3513
3514   exp = &im_expressions[i.imm_operands++];
3515   i.op[this_operand].imms = exp;
3516
3517   if (is_space_char (*imm_start))
3518     ++imm_start;
3519
3520   save_input_line_pointer = input_line_pointer;
3521   input_line_pointer = imm_start;
3522
3523 #ifndef LEX_AT
3524   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL);
3525   if (gotfree_input_line)
3526     input_line_pointer = gotfree_input_line;
3527 #endif
3528
3529   exp_seg = expression (exp);
3530
3531   SKIP_WHITESPACE ();
3532   if (*input_line_pointer)
3533     as_bad (_("junk `%s' after expression"), input_line_pointer);
3534
3535   input_line_pointer = save_input_line_pointer;
3536 #ifndef LEX_AT
3537   if (gotfree_input_line)
3538     free (gotfree_input_line);
3539 #endif
3540
3541   if (exp->X_op == O_absent || exp->X_op == O_big)
3542     {
3543       /* Missing or bad expr becomes absolute 0.  */
3544       as_bad (_("missing or invalid immediate expression `%s' taken as 0"),
3545               imm_start);
3546       exp->X_op = O_constant;
3547       exp->X_add_number = 0;
3548       exp->X_add_symbol = (symbolS *) 0;
3549       exp->X_op_symbol = (symbolS *) 0;
3550     }
3551   else if (exp->X_op == O_constant)
3552     {
3553       /* Size it properly later.  */
3554       i.types[this_operand] |= Imm64;
3555       /* If BFD64, sign extend val.  */
3556       if (!use_rela_relocations)
3557         if ((exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
3558           exp->X_add_number = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
3559     }
3560 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
3561   else if (1
3562 #ifdef BFD_ASSEMBLER
3563            && OUTPUT_FLAVOR == bfd_target_aout_flavour
3564 #endif
3565            && exp_seg != text_section
3566            && exp_seg != data_section
3567            && exp_seg != bss_section
3568            && exp_seg != undefined_section
3569 #ifdef BFD_ASSEMBLER
3570            && !bfd_is_com_section (exp_seg)
3571 #endif
3572            )
3573     {
3574 #ifdef BFD_ASSEMBLER
3575       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
3576 #else
3577       as_bad (_("unimplemented segment type %d in operand"), exp_seg);
3578 #endif
3579       return 0;
3580     }
3581 #endif
3582   else
3583     {
3584       /* This is an address.  The size of the address will be
3585          determined later, depending on destination register,
3586          suffix, or the default for the section.  */
3587       i.types[this_operand] |= Imm8 | Imm16 | Imm32 | Imm32S | Imm64;
3588     }
3589
3590   return 1;
3591 }
3592
3593 static char *i386_scale PARAMS ((char *));
3594
3595 static char *
3596 i386_scale (scale)
3597      char *scale;
3598 {
3599   offsetT val;
3600   char *save = input_line_pointer;
3601
3602   input_line_pointer = scale;
3603   val = get_absolute_expression ();
3604
3605   switch (val)
3606     {
3607     case 0:
3608     case 1:
3609       i.log2_scale_factor = 0;
3610       break;
3611     case 2:
3612       i.log2_scale_factor = 1;
3613       break;
3614     case 4:
3615       i.log2_scale_factor = 2;
3616       break;
3617     case 8:
3618       i.log2_scale_factor = 3;
3619       break;
3620     default:
3621       as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
3622               scale);
3623       input_line_pointer = save;
3624       return NULL;
3625     }
3626   if (i.log2_scale_factor != 0 && i.index_reg == 0)
3627     {
3628       as_warn (_("scale factor of %d without an index register"),
3629                1 << i.log2_scale_factor);
3630 #if SCALE1_WHEN_NO_INDEX
3631       i.log2_scale_factor = 0;
3632 #endif
3633     }
3634   scale = input_line_pointer;
3635   input_line_pointer = save;
3636   return scale;
3637 }
3638
3639 static int i386_displacement PARAMS ((char *, char *));
3640
3641 static int
3642 i386_displacement (disp_start, disp_end)
3643      char *disp_start;
3644      char *disp_end;
3645 {
3646   expressionS *exp;
3647   segT exp_seg = 0;
3648   char *save_input_line_pointer;
3649 #ifndef LEX_AT
3650   char *gotfree_input_line;
3651 #endif
3652   int bigdisp = Disp32;
3653
3654   if (flag_code == CODE_64BIT)
3655     {
3656       if (i.prefix[ADDR_PREFIX] == 0)
3657         bigdisp = Disp64;
3658     }
3659   else if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0))
3660     bigdisp = Disp16;
3661   i.types[this_operand] |= bigdisp;
3662
3663   exp = &disp_expressions[i.disp_operands];
3664   i.op[this_operand].disps = exp;
3665   i.disp_operands++;
3666   save_input_line_pointer = input_line_pointer;
3667   input_line_pointer = disp_start;
3668   END_STRING_AND_SAVE (disp_end);
3669
3670 #ifndef GCC_ASM_O_HACK
3671 #define GCC_ASM_O_HACK 0
3672 #endif
3673 #if GCC_ASM_O_HACK
3674   END_STRING_AND_SAVE (disp_end + 1);
3675   if ((i.types[this_operand] & BaseIndex) != 0
3676       && displacement_string_end[-1] == '+')
3677     {
3678       /* This hack is to avoid a warning when using the "o"
3679          constraint within gcc asm statements.
3680          For instance:
3681
3682          #define _set_tssldt_desc(n,addr,limit,type) \
3683          __asm__ __volatile__ ( \
3684          "movw %w2,%0\n\t" \
3685          "movw %w1,2+%0\n\t" \
3686          "rorl $16,%1\n\t" \
3687          "movb %b1,4+%0\n\t" \
3688          "movb %4,5+%0\n\t" \
3689          "movb $0,6+%0\n\t" \
3690          "movb %h1,7+%0\n\t" \
3691          "rorl $16,%1" \
3692          : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
3693
3694          This works great except that the output assembler ends
3695          up looking a bit weird if it turns out that there is
3696          no offset.  You end up producing code that looks like:
3697
3698          #APP
3699          movw $235,(%eax)
3700          movw %dx,2+(%eax)
3701          rorl $16,%edx
3702          movb %dl,4+(%eax)
3703          movb $137,5+(%eax)
3704          movb $0,6+(%eax)
3705          movb %dh,7+(%eax)
3706          rorl $16,%edx
3707          #NO_APP
3708
3709          So here we provide the missing zero.  */
3710
3711       *displacement_string_end = '0';
3712     }
3713 #endif
3714 #ifndef LEX_AT
3715   gotfree_input_line = lex_got (&i.reloc[this_operand], NULL);
3716   if (gotfree_input_line)
3717     input_line_pointer = gotfree_input_line;
3718 #endif
3719
3720   exp_seg = expression (exp);
3721
3722   SKIP_WHITESPACE ();
3723   if (*input_line_pointer)
3724     as_bad (_("junk `%s' after expression"), input_line_pointer);
3725 #if GCC_ASM_O_HACK
3726   RESTORE_END_STRING (disp_end + 1);
3727 #endif
3728   RESTORE_END_STRING (disp_end);
3729   input_line_pointer = save_input_line_pointer;
3730 #ifndef LEX_AT
3731   if (gotfree_input_line)
3732     free (gotfree_input_line);
3733 #endif
3734
3735 #ifdef BFD_ASSEMBLER
3736   /* We do this to make sure that the section symbol is in
3737      the symbol table.  We will ultimately change the relocation
3738      to be relative to the beginning of the section.  */
3739   if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
3740       || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
3741     {
3742       if (exp->X_op != O_symbol)
3743         {
3744           as_bad (_("bad expression used with @%s"),
3745                   (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
3746                    ? "GOTPCREL"
3747                    : "GOTOFF"));
3748           return 0;
3749         }
3750
3751       if (S_IS_LOCAL (exp->X_add_symbol)
3752           && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section)
3753         section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
3754       exp->X_op = O_subtract;
3755       exp->X_op_symbol = GOT_symbol;
3756       if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
3757         i.reloc[this_operand] = BFD_RELOC_32_PCREL;
3758       else
3759         i.reloc[this_operand] = BFD_RELOC_32;
3760     }
3761 #endif
3762
3763   if (exp->X_op == O_absent || exp->X_op == O_big)
3764     {
3765       /* Missing or bad expr becomes absolute 0.  */
3766       as_bad (_("missing or invalid displacement expression `%s' taken as 0"),
3767               disp_start);
3768       exp->X_op = O_constant;
3769       exp->X_add_number = 0;
3770       exp->X_add_symbol = (symbolS *) 0;
3771       exp->X_op_symbol = (symbolS *) 0;
3772     }
3773
3774 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
3775   if (exp->X_op != O_constant
3776 #ifdef BFD_ASSEMBLER
3777       && OUTPUT_FLAVOR == bfd_target_aout_flavour
3778 #endif
3779       && exp_seg != text_section
3780       && exp_seg != data_section
3781       && exp_seg != bss_section
3782       && exp_seg != undefined_section)
3783     {
3784 #ifdef BFD_ASSEMBLER
3785       as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
3786 #else
3787       as_bad (_("unimplemented segment type %d in operand"), exp_seg);
3788 #endif
3789       return 0;
3790     }
3791 #endif
3792   else if (flag_code == CODE_64BIT)
3793     i.types[this_operand] |= Disp32S | Disp32;
3794   return 1;
3795 }
3796
3797 static int i386_index_check PARAMS ((const char *));
3798
3799 /* Make sure the memory operand we've been dealt is valid.
3800    Return 1 on success, 0 on a failure.  */
3801
3802 static int
3803 i386_index_check (operand_string)
3804      const char *operand_string;
3805 {
3806   int ok;
3807 #if INFER_ADDR_PREFIX
3808   int fudged = 0;
3809
3810  tryprefix:
3811 #endif
3812   ok = 1;
3813   if (flag_code == CODE_64BIT)
3814     {
3815       if (i.prefix[ADDR_PREFIX] == 0)
3816         {
3817           /* 64bit checks.  */
3818           if ((i.base_reg
3819                && ((i.base_reg->reg_type & Reg64) == 0)
3820                    && (i.base_reg->reg_type != BaseIndex
3821                        || i.index_reg))
3822               || (i.index_reg
3823                   && ((i.index_reg->reg_type & (Reg64 | BaseIndex))
3824                       != (Reg64 | BaseIndex))))
3825             ok = 0;
3826         }
3827       else
3828         {
3829           /* 32bit checks.  */
3830           if ((i.base_reg
3831                && (i.base_reg->reg_type & (Reg32 | RegRex)) != Reg32)
3832               || (i.index_reg
3833                   && ((i.index_reg->reg_type & (Reg32 | BaseIndex | RegRex))
3834                       != (Reg32 | BaseIndex))))
3835             ok = 0;
3836         }
3837     }
3838   else
3839     {
3840       if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0))
3841         {
3842           /* 16bit checks.  */
3843           if ((i.base_reg
3844                && ((i.base_reg->reg_type & (Reg16 | BaseIndex | RegRex))
3845                    != (Reg16 | BaseIndex)))
3846               || (i.index_reg
3847                   && (((i.index_reg->reg_type & (Reg16 | BaseIndex))
3848                        != (Reg16 | BaseIndex))
3849                       || !(i.base_reg
3850                            && i.base_reg->reg_num < 6
3851                            && i.index_reg->reg_num >= 6
3852                            && i.log2_scale_factor == 0))))
3853             ok = 0;
3854         }
3855       else
3856         {
3857           /* 32bit checks.  */
3858           if ((i.base_reg
3859                && (i.base_reg->reg_type & (Reg32 | RegRex)) != Reg32)
3860               || (i.index_reg
3861                   && ((i.index_reg->reg_type & (Reg32 | BaseIndex | RegRex))
3862                       != (Reg32 | BaseIndex))))
3863             ok = 0;
3864         }
3865     }
3866   if (!ok)
3867     {
3868 #if INFER_ADDR_PREFIX
3869       if (flag_code != CODE_64BIT
3870           && i.prefix[ADDR_PREFIX] == 0 && stackop_size != '\0')
3871         {
3872           i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
3873           i.prefixes += 1;
3874           /* Change the size of any displacement too.  At most one of
3875              Disp16 or Disp32 is set.
3876              FIXME.  There doesn't seem to be any real need for separate
3877              Disp16 and Disp32 flags.  The same goes for Imm16 and Imm32.
3878              Removing them would probably clean up the code quite a lot.  */
3879           if (i.types[this_operand] & (Disp16 | Disp32))
3880              i.types[this_operand] ^= (Disp16 | Disp32);
3881           fudged = 1;
3882           goto tryprefix;
3883         }
3884       if (fudged)
3885         as_bad (_("`%s' is not a valid base/index expression"),
3886                 operand_string);
3887       else
3888 #endif
3889         as_bad (_("`%s' is not a valid %s bit base/index expression"),
3890                 operand_string,
3891                 flag_code_names[flag_code]);
3892       return 0;
3893     }
3894   return 1;
3895 }
3896
3897 /* Parse OPERAND_STRING into the i386_insn structure I.  Returns non-zero
3898    on error.  */
3899
3900 static int
3901 i386_operand (operand_string)
3902      char *operand_string;
3903 {
3904   const reg_entry *r;
3905   char *end_op;
3906   char *op_string = operand_string;
3907
3908   if (is_space_char (*op_string))
3909     ++op_string;
3910
3911   /* We check for an absolute prefix (differentiating,
3912      for example, 'jmp pc_relative_label' from 'jmp *absolute_label'.  */
3913   if (*op_string == ABSOLUTE_PREFIX)
3914     {
3915       ++op_string;
3916       if (is_space_char (*op_string))
3917         ++op_string;
3918       i.types[this_operand] |= JumpAbsolute;
3919     }
3920
3921   /* Check if operand is a register.  */
3922   if ((*op_string == REGISTER_PREFIX || allow_naked_reg)
3923       && (r = parse_register (op_string, &end_op)) != NULL)
3924     {
3925       /* Check for a segment override by searching for ':' after a
3926          segment register.  */
3927       op_string = end_op;
3928       if (is_space_char (*op_string))
3929         ++op_string;
3930       if (*op_string == ':' && (r->reg_type & (SReg2 | SReg3)))
3931         {
3932           switch (r->reg_num)
3933             {
3934             case 0:
3935               i.seg[i.mem_operands] = &es;
3936               break;
3937             case 1:
3938               i.seg[i.mem_operands] = &cs;
3939               break;
3940             case 2:
3941               i.seg[i.mem_operands] = &ss;
3942               break;
3943             case 3:
3944               i.seg[i.mem_operands] = &ds;
3945               break;
3946             case 4:
3947               i.seg[i.mem_operands] = &fs;
3948               break;
3949             case 5:
3950               i.seg[i.mem_operands] = &gs;
3951               break;
3952             }
3953
3954           /* Skip the ':' and whitespace.  */
3955           ++op_string;
3956           if (is_space_char (*op_string))
3957             ++op_string;
3958
3959           if (!is_digit_char (*op_string)
3960               && !is_identifier_char (*op_string)
3961               && *op_string != '('
3962               && *op_string != ABSOLUTE_PREFIX)
3963             {
3964               as_bad (_("bad memory operand `%s'"), op_string);
3965               return 0;
3966             }