1 /* tc-i386.c -- Assemble code for the Intel 80386
2 Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
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.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 /* Intel 80386 machine specific gas.
24 Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
25 x86_64 support by Jan Hubicka (jh@suse.cz)
26 VIA PadLock support by Michal Ludvig (mludvig@suse.cz)
27 Bugs & suggestions are completely welcome. This is free software.
28 Please help us make it better. */
31 #include "safe-ctype.h"
33 #include "dwarf2dbg.h"
34 #include "dw2gencfi.h"
35 #include "elf/x86-64.h"
36 #include "opcodes/i386-init.h"
38 #ifndef REGISTER_WARNINGS
39 #define REGISTER_WARNINGS 1
42 #ifndef INFER_ADDR_PREFIX
43 #define INFER_ADDR_PREFIX 1
47 #define DEFAULT_ARCH "i386"
52 #define INLINE __inline__
58 /* Prefixes will be emitted in the order defined below.
59 WAIT_PREFIX must be the first prefix since FWAIT is really is an
60 instruction, and so must come before any prefixes.
61 The preferred prefix order is SEG_PREFIX, ADDR_PREFIX, DATA_PREFIX,
62 REP_PREFIX, LOCK_PREFIX. */
69 #define REX_PREFIX 6 /* must come last. */
70 #define MAX_PREFIXES 7 /* max prefixes per opcode */
72 /* we define the syntax here (modulo base,index,scale syntax) */
73 #define REGISTER_PREFIX '%'
74 #define IMMEDIATE_PREFIX '$'
75 #define ABSOLUTE_PREFIX '*'
77 /* these are the instruction mnemonic suffixes in AT&T syntax or
78 memory operand size in Intel syntax. */
79 #define WORD_MNEM_SUFFIX 'w'
80 #define BYTE_MNEM_SUFFIX 'b'
81 #define SHORT_MNEM_SUFFIX 's'
82 #define LONG_MNEM_SUFFIX 'l'
83 #define QWORD_MNEM_SUFFIX 'q'
84 #define XMMWORD_MNEM_SUFFIX 'x'
85 #define YMMWORD_MNEM_SUFFIX 'y'
86 /* Intel Syntax. Use a non-ascii letter since since it never appears
88 #define LONG_DOUBLE_MNEM_SUFFIX '\1'
90 #define END_OF_INSN '\0'
93 'templates' is for grouping together 'template' structures for opcodes
94 of the same name. This is only used for storing the insns in the grand
95 ole hash table of insns.
96 The templates themselves start at START and range up to (but not including)
101 const insn_template
*start
;
102 const insn_template
*end
;
106 /* 386 operand encoding bytes: see 386 book for details of this. */
109 unsigned int regmem
; /* codes register or memory operand */
110 unsigned int reg
; /* codes register operand (or extended opcode) */
111 unsigned int mode
; /* how to interpret regmem & reg */
115 /* x86-64 extension prefix. */
116 typedef int rex_byte
;
118 /* 386 opcode byte to code indirect addressing. */
127 /* x86 arch names, types and features */
130 const char *name
; /* arch name */
131 unsigned int len
; /* arch string length */
132 enum processor_type type
; /* arch type */
133 i386_cpu_flags flags
; /* cpu feature flags */
134 unsigned int skip
; /* show_arch should skip this. */
138 static void set_code_flag (int);
139 static void set_16bit_gcc_code_flag (int);
140 static void set_intel_syntax (int);
141 static void set_intel_mnemonic (int);
142 static void set_allow_index_reg (int);
143 static void set_sse_check (int);
144 static void set_cpu_arch (int);
146 static void pe_directive_secrel (int);
148 static void signed_cons (int);
149 static char *output_invalid (int c
);
150 static int i386_finalize_immediate (segT
, expressionS
*, i386_operand_type
,
152 static int i386_finalize_displacement (segT
, expressionS
*, i386_operand_type
,
154 static int i386_att_operand (char *);
155 static int i386_intel_operand (char *, int);
156 static int i386_intel_simplify (expressionS
*);
157 static int i386_intel_parse_name (const char *, expressionS
*);
158 static const reg_entry
*parse_register (char *, char **);
159 static char *parse_insn (char *, char *);
160 static char *parse_operands (char *, const char *);
161 static void swap_operands (void);
162 static void swap_2_operands (int, int);
163 static void optimize_imm (void);
164 static void optimize_disp (void);
165 static const insn_template
*match_template (void);
166 static int check_string (void);
167 static int process_suffix (void);
168 static int check_byte_reg (void);
169 static int check_long_reg (void);
170 static int check_qword_reg (void);
171 static int check_word_reg (void);
172 static int finalize_imm (void);
173 static int process_operands (void);
174 static const seg_entry
*build_modrm_byte (void);
175 static void output_insn (void);
176 static void output_imm (fragS
*, offsetT
);
177 static void output_disp (fragS
*, offsetT
);
179 static void s_bss (int);
181 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
182 static void handle_large_common (int small ATTRIBUTE_UNUSED
);
185 static const char *default_arch
= DEFAULT_ARCH
;
190 /* VEX prefix is either 2 byte or 3 byte. */
191 unsigned char bytes
[3];
193 /* Destination or source register specifier. */
194 const reg_entry
*register_specifier
;
197 /* 'md_assemble ()' gathers together information and puts it into a
204 const reg_entry
*regs
;
209 /* TM holds the template for the insn were currently assembling. */
212 /* SUFFIX holds the instruction size suffix for byte, word, dword
213 or qword, if given. */
216 /* OPERANDS gives the number of given operands. */
217 unsigned int operands
;
219 /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
220 of given register, displacement, memory operands and immediate
222 unsigned int reg_operands
, disp_operands
, mem_operands
, imm_operands
;
224 /* TYPES [i] is the type (see above #defines) which tells us how to
225 use OP[i] for the corresponding operand. */
226 i386_operand_type types
[MAX_OPERANDS
];
228 /* Displacement expression, immediate expression, or register for each
230 union i386_op op
[MAX_OPERANDS
];
232 /* Flags for operands. */
233 unsigned int flags
[MAX_OPERANDS
];
234 #define Operand_PCrel 1
236 /* Relocation type for operand */
237 enum bfd_reloc_code_real reloc
[MAX_OPERANDS
];
239 /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
240 the base index byte below. */
241 const reg_entry
*base_reg
;
242 const reg_entry
*index_reg
;
243 unsigned int log2_scale_factor
;
245 /* SEG gives the seg_entries of this insn. They are zero unless
246 explicit segment overrides are given. */
247 const seg_entry
*seg
[2];
249 /* PREFIX holds all the given prefix opcodes (usually null).
250 PREFIXES is the number of prefix opcodes. */
251 unsigned int prefixes
;
252 unsigned char prefix
[MAX_PREFIXES
];
254 /* RM and SIB are the modrm byte and the sib byte where the
255 addressing modes of this insn are encoded. */
261 /* Swap operand in encoding. */
262 unsigned int swap_operand
;
265 typedef struct _i386_insn i386_insn
;
267 /* List of chars besides those in app.c:symbol_chars that can start an
268 operand. Used to prevent the scrubber eating vital white-space. */
269 const char extra_symbol_chars
[] = "*%-(["
278 #if (defined (TE_I386AIX) \
279 || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
280 && !defined (TE_GNU) \
281 && !defined (TE_LINUX) \
282 && !defined (TE_NETWARE) \
283 && !defined (TE_FreeBSD) \
284 && !defined (TE_NetBSD)))
285 /* This array holds the chars that always start a comment. If the
286 pre-processor is disabled, these aren't very useful. The option
287 --divide will remove '/' from this list. */
288 const char *i386_comment_chars
= "#/";
289 #define SVR4_COMMENT_CHARS 1
290 #define PREFIX_SEPARATOR '\\'
293 const char *i386_comment_chars
= "#";
294 #define PREFIX_SEPARATOR '/'
297 /* This array holds the chars that only start a comment at the beginning of
298 a line. If the line seems to have the form '# 123 filename'
299 .line and .file directives will appear in the pre-processed output.
300 Note that input_file.c hand checks for '#' at the beginning of the
301 first line of the input file. This is because the compiler outputs
302 #NO_APP at the beginning of its output.
303 Also note that comments started like this one will always work if
304 '/' isn't otherwise defined. */
305 const char line_comment_chars
[] = "#/";
307 const char line_separator_chars
[] = ";";
309 /* Chars that can be used to separate mant from exp in floating point
311 const char EXP_CHARS
[] = "eE";
313 /* Chars that mean this number is a floating point constant
316 const char FLT_CHARS
[] = "fFdDxX";
318 /* Tables for lexical analysis. */
319 static char mnemonic_chars
[256];
320 static char register_chars
[256];
321 static char operand_chars
[256];
322 static char identifier_chars
[256];
323 static char digit_chars
[256];
325 /* Lexical macros. */
326 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
327 #define is_operand_char(x) (operand_chars[(unsigned char) x])
328 #define is_register_char(x) (register_chars[(unsigned char) x])
329 #define is_space_char(x) ((x) == ' ')
330 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
331 #define is_digit_char(x) (digit_chars[(unsigned char) x])
333 /* All non-digit non-letter characters that may occur in an operand. */
334 static char operand_special_chars
[] = "%$-+(,)*._~/<>|&^!:[@]";
336 /* md_assemble() always leaves the strings it's passed unaltered. To
337 effect this we maintain a stack of saved characters that we've smashed
338 with '\0's (indicating end of strings for various sub-fields of the
339 assembler instruction). */
340 static char save_stack
[32];
341 static char *save_stack_p
;
342 #define END_STRING_AND_SAVE(s) \
343 do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
344 #define RESTORE_END_STRING(s) \
345 do { *(s) = *--save_stack_p; } while (0)
347 /* The instruction we're assembling. */
350 /* Possible templates for current insn. */
351 static const templates
*current_templates
;
353 /* Per instruction expressionS buffers: max displacements & immediates. */
354 static expressionS disp_expressions
[MAX_MEMORY_OPERANDS
];
355 static expressionS im_expressions
[MAX_IMMEDIATE_OPERANDS
];
357 /* Current operand we are working on. */
358 static int this_operand
= -1;
360 /* We support four different modes. FLAG_CODE variable is used to distinguish
368 static enum flag_code flag_code
;
369 static unsigned int object_64bit
;
370 static int use_rela_relocations
= 0;
372 /* The names used to print error messages. */
373 static const char *flag_code_names
[] =
380 /* 1 for intel syntax,
382 static int intel_syntax
= 0;
384 /* 1 for intel mnemonic,
385 0 if att mnemonic. */
386 static int intel_mnemonic
= !SYSV386_COMPAT
;
388 /* 1 if support old (<= 2.8.1) versions of gcc. */
389 static int old_gcc
= OLDGCC_COMPAT
;
391 /* 1 if pseudo registers are permitted. */
392 static int allow_pseudo_reg
= 0;
394 /* 1 if register prefix % not required. */
395 static int allow_naked_reg
= 0;
397 /* 1 if pseudo index register, eiz/riz, is allowed . */
398 static int allow_index_reg
= 0;
408 /* Register prefix used for error message. */
409 static const char *register_prefix
= "%";
411 /* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
412 leave, push, and pop instructions so that gcc has the same stack
413 frame as in 32 bit mode. */
414 static char stackop_size
= '\0';
416 /* Non-zero to optimize code alignment. */
417 int optimize_align_code
= 1;
419 /* Non-zero to quieten some warnings. */
420 static int quiet_warnings
= 0;
423 static const char *cpu_arch_name
= NULL
;
424 static char *cpu_sub_arch_name
= NULL
;
426 /* CPU feature flags. */
427 static i386_cpu_flags cpu_arch_flags
= CPU_UNKNOWN_FLAGS
;
429 /* If we have selected a cpu we are generating instructions for. */
430 static int cpu_arch_tune_set
= 0;
432 /* Cpu we are generating instructions for. */
433 enum processor_type cpu_arch_tune
= PROCESSOR_UNKNOWN
;
435 /* CPU feature flags of cpu we are generating instructions for. */
436 static i386_cpu_flags cpu_arch_tune_flags
;
438 /* CPU instruction set architecture used. */
439 enum processor_type cpu_arch_isa
= PROCESSOR_UNKNOWN
;
441 /* CPU feature flags of instruction set architecture used. */
442 i386_cpu_flags cpu_arch_isa_flags
;
444 /* If set, conditional jumps are not automatically promoted to handle
445 larger than a byte offset. */
446 static unsigned int no_cond_jump_promotion
= 0;
448 /* Encode SSE instructions with VEX prefix. */
449 static unsigned int sse2avx
;
451 /* Pre-defined "_GLOBAL_OFFSET_TABLE_". */
452 static symbolS
*GOT_symbol
;
454 /* The dwarf2 return column, adjusted for 32 or 64 bit. */
455 unsigned int x86_dwarf2_return_column
;
457 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
458 int x86_cie_data_alignment
;
460 /* Interface to relax_segment.
461 There are 3 major relax states for 386 jump insns because the
462 different types of jumps add different sizes to frags when we're
463 figuring out what sort of jump to choose to reach a given label. */
466 #define UNCOND_JUMP 0
468 #define COND_JUMP86 2
473 #define SMALL16 (SMALL | CODE16)
475 #define BIG16 (BIG | CODE16)
479 #define INLINE __inline__
485 #define ENCODE_RELAX_STATE(type, size) \
486 ((relax_substateT) (((type) << 2) | (size)))
487 #define TYPE_FROM_RELAX_STATE(s) \
489 #define DISP_SIZE_FROM_RELAX_STATE(s) \
490 ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
492 /* This table is used by relax_frag to promote short jumps to long
493 ones where necessary. SMALL (short) jumps may be promoted to BIG
494 (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long). We
495 don't allow a short jump in a 32 bit code segment to be promoted to
496 a 16 bit offset jump because it's slower (requires data size
497 prefix), and doesn't work, unless the destination is in the bottom
498 64k of the code segment (The top 16 bits of eip are zeroed). */
500 const relax_typeS md_relax_table
[] =
503 1) most positive reach of this state,
504 2) most negative reach of this state,
505 3) how many bytes this mode will have in the variable part of the frag
506 4) which index into the table to try if we can't fit into this one. */
508 /* UNCOND_JUMP states. */
509 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG
)},
510 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG16
)},
511 /* dword jmp adds 4 bytes to frag:
512 0 extra opcode bytes, 4 displacement bytes. */
514 /* word jmp adds 2 byte2 to frag:
515 0 extra opcode bytes, 2 displacement bytes. */
518 /* COND_JUMP states. */
519 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP
, BIG
)},
520 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP
, BIG16
)},
521 /* dword conditionals adds 5 bytes to frag:
522 1 extra opcode byte, 4 displacement bytes. */
524 /* word conditionals add 3 bytes to frag:
525 1 extra opcode byte, 2 displacement bytes. */
528 /* COND_JUMP86 states. */
529 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86
, BIG
)},
530 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86
, BIG16
)},
531 /* dword conditionals adds 5 bytes to frag:
532 1 extra opcode byte, 4 displacement bytes. */
534 /* word conditionals add 4 bytes to frag:
535 1 displacement byte and a 3 byte long branch insn. */
539 static const arch_entry cpu_arch
[] =
541 { STRING_COMMA_LEN ("generic32"), PROCESSOR_GENERIC32
,
542 CPU_GENERIC32_FLAGS
, 0 },
543 { STRING_COMMA_LEN ("generic64"), PROCESSOR_GENERIC64
,
544 CPU_GENERIC64_FLAGS
, 0 },
545 { STRING_COMMA_LEN ("i8086"), PROCESSOR_UNKNOWN
,
547 { STRING_COMMA_LEN ("i186"), PROCESSOR_UNKNOWN
,
549 { STRING_COMMA_LEN ("i286"), PROCESSOR_UNKNOWN
,
551 { STRING_COMMA_LEN ("i386"), PROCESSOR_I386
,
553 { STRING_COMMA_LEN ("i486"), PROCESSOR_I486
,
555 { STRING_COMMA_LEN ("i586"), PROCESSOR_PENTIUM
,
557 { STRING_COMMA_LEN ("i686"), PROCESSOR_PENTIUMPRO
,
559 { STRING_COMMA_LEN ("pentium"), PROCESSOR_PENTIUM
,
561 { STRING_COMMA_LEN ("pentiumpro"), PROCESSOR_PENTIUMPRO
,
563 { STRING_COMMA_LEN ("pentiumii"), PROCESSOR_PENTIUMPRO
,
565 { STRING_COMMA_LEN ("pentiumiii"),PROCESSOR_PENTIUMPRO
,
567 { STRING_COMMA_LEN ("pentium4"), PROCESSOR_PENTIUM4
,
569 { STRING_COMMA_LEN ("prescott"), PROCESSOR_NOCONA
,
571 { STRING_COMMA_LEN ("nocona"), PROCESSOR_NOCONA
,
572 CPU_NOCONA_FLAGS
, 0 },
573 { STRING_COMMA_LEN ("yonah"), PROCESSOR_CORE
,
575 { STRING_COMMA_LEN ("core"), PROCESSOR_CORE
,
577 { STRING_COMMA_LEN ("merom"), PROCESSOR_CORE2
,
578 CPU_CORE2_FLAGS
, 1 },
579 { STRING_COMMA_LEN ("core2"), PROCESSOR_CORE2
,
580 CPU_CORE2_FLAGS
, 0 },
581 { STRING_COMMA_LEN ("corei7"), PROCESSOR_COREI7
,
582 CPU_COREI7_FLAGS
, 0 },
583 { STRING_COMMA_LEN ("l1om"), PROCESSOR_L1OM
,
585 { STRING_COMMA_LEN ("k6"), PROCESSOR_K6
,
587 { STRING_COMMA_LEN ("k6_2"), PROCESSOR_K6
,
589 { STRING_COMMA_LEN ("athlon"), PROCESSOR_ATHLON
,
590 CPU_ATHLON_FLAGS
, 0 },
591 { STRING_COMMA_LEN ("sledgehammer"), PROCESSOR_K8
,
593 { STRING_COMMA_LEN ("opteron"), PROCESSOR_K8
,
595 { STRING_COMMA_LEN ("k8"), PROCESSOR_K8
,
597 { STRING_COMMA_LEN ("amdfam10"), PROCESSOR_AMDFAM10
,
598 CPU_AMDFAM10_FLAGS
, 0 },
599 { STRING_COMMA_LEN (".8087"), PROCESSOR_UNKNOWN
,
601 { STRING_COMMA_LEN (".287"), PROCESSOR_UNKNOWN
,
603 { STRING_COMMA_LEN (".387"), PROCESSOR_UNKNOWN
,
605 { STRING_COMMA_LEN (".no87"), PROCESSOR_UNKNOWN
,
606 CPU_ANY87_FLAGS
, 0 },
607 { STRING_COMMA_LEN (".mmx"), PROCESSOR_UNKNOWN
,
609 { STRING_COMMA_LEN (".nommx"), PROCESSOR_UNKNOWN
,
610 CPU_3DNOWA_FLAGS
, 0 },
611 { STRING_COMMA_LEN (".sse"), PROCESSOR_UNKNOWN
,
613 { STRING_COMMA_LEN (".sse2"), PROCESSOR_UNKNOWN
,
615 { STRING_COMMA_LEN (".sse3"), PROCESSOR_UNKNOWN
,
617 { STRING_COMMA_LEN (".ssse3"), PROCESSOR_UNKNOWN
,
618 CPU_SSSE3_FLAGS
, 0 },
619 { STRING_COMMA_LEN (".sse4.1"), PROCESSOR_UNKNOWN
,
620 CPU_SSE4_1_FLAGS
, 0 },
621 { STRING_COMMA_LEN (".sse4.2"), PROCESSOR_UNKNOWN
,
622 CPU_SSE4_2_FLAGS
, 0 },
623 { STRING_COMMA_LEN (".sse4"), PROCESSOR_UNKNOWN
,
624 CPU_SSE4_2_FLAGS
, 0 },
625 { STRING_COMMA_LEN (".nosse"), PROCESSOR_UNKNOWN
,
626 CPU_ANY_SSE_FLAGS
, 0 },
627 { STRING_COMMA_LEN (".avx"), PROCESSOR_UNKNOWN
,
629 { STRING_COMMA_LEN (".noavx"), PROCESSOR_UNKNOWN
,
630 CPU_ANY_AVX_FLAGS
, 0 },
631 { STRING_COMMA_LEN (".vmx"), PROCESSOR_UNKNOWN
,
633 { STRING_COMMA_LEN (".smx"), PROCESSOR_UNKNOWN
,
635 { STRING_COMMA_LEN (".xsave"), PROCESSOR_UNKNOWN
,
636 CPU_XSAVE_FLAGS
, 0 },
637 { STRING_COMMA_LEN (".aes"), PROCESSOR_UNKNOWN
,
639 { STRING_COMMA_LEN (".pclmul"), PROCESSOR_UNKNOWN
,
640 CPU_PCLMUL_FLAGS
, 0 },
641 { STRING_COMMA_LEN (".clmul"), PROCESSOR_UNKNOWN
,
642 CPU_PCLMUL_FLAGS
, 1 },
643 { STRING_COMMA_LEN (".fma"), PROCESSOR_UNKNOWN
,
645 { STRING_COMMA_LEN (".fma4"), PROCESSOR_UNKNOWN
,
647 { STRING_COMMA_LEN (".xop"), PROCESSOR_UNKNOWN
,
649 { STRING_COMMA_LEN (".lwp"), PROCESSOR_UNKNOWN
,
651 { STRING_COMMA_LEN (".movbe"), PROCESSOR_UNKNOWN
,
652 CPU_MOVBE_FLAGS
, 0 },
653 { STRING_COMMA_LEN (".ept"), PROCESSOR_UNKNOWN
,
655 { STRING_COMMA_LEN (".clflush"), PROCESSOR_UNKNOWN
,
656 CPU_CLFLUSH_FLAGS
, 0 },
657 { STRING_COMMA_LEN (".syscall"), PROCESSOR_UNKNOWN
,
658 CPU_SYSCALL_FLAGS
, 0 },
659 { STRING_COMMA_LEN (".rdtscp"), PROCESSOR_UNKNOWN
,
660 CPU_RDTSCP_FLAGS
, 0 },
661 { STRING_COMMA_LEN (".3dnow"), PROCESSOR_UNKNOWN
,
662 CPU_3DNOW_FLAGS
, 0 },
663 { STRING_COMMA_LEN (".3dnowa"), PROCESSOR_UNKNOWN
,
664 CPU_3DNOWA_FLAGS
, 0 },
665 { STRING_COMMA_LEN (".padlock"), PROCESSOR_UNKNOWN
,
666 CPU_PADLOCK_FLAGS
, 0 },
667 { STRING_COMMA_LEN (".pacifica"), PROCESSOR_UNKNOWN
,
669 { STRING_COMMA_LEN (".svme"), PROCESSOR_UNKNOWN
,
671 { STRING_COMMA_LEN (".sse4a"), PROCESSOR_UNKNOWN
,
672 CPU_SSE4A_FLAGS
, 0 },
673 { STRING_COMMA_LEN (".abm"), PROCESSOR_UNKNOWN
,
678 /* Like s_lcomm_internal in gas/read.c but the alignment string
679 is allowed to be optional. */
682 pe_lcomm_internal (int needs_align
, symbolS
*symbolP
, addressT size
)
689 && *input_line_pointer
== ',')
691 align
= parse_align (needs_align
- 1);
693 if (align
== (addressT
) -1)
708 bss_alloc (symbolP
, size
, align
);
713 pe_lcomm (int needs_align
)
715 s_comm_internal (needs_align
* 2, pe_lcomm_internal
);
719 const pseudo_typeS md_pseudo_table
[] =
721 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
722 {"align", s_align_bytes
, 0},
724 {"align", s_align_ptwo
, 0},
726 {"arch", set_cpu_arch
, 0},
730 {"lcomm", pe_lcomm
, 1},
732 {"ffloat", float_cons
, 'f'},
733 {"dfloat", float_cons
, 'd'},
734 {"tfloat", float_cons
, 'x'},
736 {"slong", signed_cons
, 4},
737 {"noopt", s_ignore
, 0},
738 {"optim", s_ignore
, 0},
739 {"code16gcc", set_16bit_gcc_code_flag
, CODE_16BIT
},
740 {"code16", set_code_flag
, CODE_16BIT
},
741 {"code32", set_code_flag
, CODE_32BIT
},
742 {"code64", set_code_flag
, CODE_64BIT
},
743 {"intel_syntax", set_intel_syntax
, 1},
744 {"att_syntax", set_intel_syntax
, 0},
745 {"intel_mnemonic", set_intel_mnemonic
, 1},
746 {"att_mnemonic", set_intel_mnemonic
, 0},
747 {"allow_index_reg", set_allow_index_reg
, 1},
748 {"disallow_index_reg", set_allow_index_reg
, 0},
749 {"sse_check", set_sse_check
, 0},
750 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
751 {"largecomm", handle_large_common
, 0},
753 {"file", (void (*) (int)) dwarf2_directive_file
, 0},
754 {"loc", dwarf2_directive_loc
, 0},
755 {"loc_mark_labels", dwarf2_directive_loc_mark_labels
, 0},
758 {"secrel32", pe_directive_secrel
, 0},
763 /* For interface with expression (). */
764 extern char *input_line_pointer
;
766 /* Hash table for instruction mnemonic lookup. */
767 static struct hash_control
*op_hash
;
769 /* Hash table for register lookup. */
770 static struct hash_control
*reg_hash
;
773 i386_align_code (fragS
*fragP
, int count
)
775 /* Various efficient no-op patterns for aligning code labels.
776 Note: Don't try to assemble the instructions in the comments.
777 0L and 0w are not legal. */
778 static const char f32_1
[] =
780 static const char f32_2
[] =
781 {0x66,0x90}; /* xchg %ax,%ax */
782 static const char f32_3
[] =
783 {0x8d,0x76,0x00}; /* leal 0(%esi),%esi */
784 static const char f32_4
[] =
785 {0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */
786 static const char f32_5
[] =
788 0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */
789 static const char f32_6
[] =
790 {0x8d,0xb6,0x00,0x00,0x00,0x00}; /* leal 0L(%esi),%esi */
791 static const char f32_7
[] =
792 {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
793 static const char f32_8
[] =
795 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
796 static const char f32_9
[] =
797 {0x89,0xf6, /* movl %esi,%esi */
798 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
799 static const char f32_10
[] =
800 {0x8d,0x76,0x00, /* leal 0(%esi),%esi */
801 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
802 static const char f32_11
[] =
803 {0x8d,0x74,0x26,0x00, /* leal 0(%esi,1),%esi */
804 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
805 static const char f32_12
[] =
806 {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */
807 0x8d,0xbf,0x00,0x00,0x00,0x00}; /* leal 0L(%edi),%edi */
808 static const char f32_13
[] =
809 {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */
810 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
811 static const char f32_14
[] =
812 {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00, /* leal 0L(%esi,1),%esi */
813 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
814 static const char f16_3
[] =
815 {0x8d,0x74,0x00}; /* lea 0(%esi),%esi */
816 static const char f16_4
[] =
817 {0x8d,0xb4,0x00,0x00}; /* lea 0w(%si),%si */
818 static const char f16_5
[] =
820 0x8d,0xb4,0x00,0x00}; /* lea 0w(%si),%si */
821 static const char f16_6
[] =
822 {0x89,0xf6, /* mov %si,%si */
823 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
824 static const char f16_7
[] =
825 {0x8d,0x74,0x00, /* lea 0(%si),%si */
826 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
827 static const char f16_8
[] =
828 {0x8d,0xb4,0x00,0x00, /* lea 0w(%si),%si */
829 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
830 static const char jump_31
[] =
831 {0xeb,0x1d,0x90,0x90,0x90,0x90,0x90, /* jmp .+31; lotsa nops */
832 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
833 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
834 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
835 static const char *const f32_patt
[] = {
836 f32_1
, f32_2
, f32_3
, f32_4
, f32_5
, f32_6
, f32_7
, f32_8
,
837 f32_9
, f32_10
, f32_11
, f32_12
, f32_13
, f32_14
839 static const char *const f16_patt
[] = {
840 f32_1
, f32_2
, f16_3
, f16_4
, f16_5
, f16_6
, f16_7
, f16_8
843 static const char alt_3
[] =
845 /* nopl 0(%[re]ax) */
846 static const char alt_4
[] =
847 {0x0f,0x1f,0x40,0x00};
848 /* nopl 0(%[re]ax,%[re]ax,1) */
849 static const char alt_5
[] =
850 {0x0f,0x1f,0x44,0x00,0x00};
851 /* nopw 0(%[re]ax,%[re]ax,1) */
852 static const char alt_6
[] =
853 {0x66,0x0f,0x1f,0x44,0x00,0x00};
854 /* nopl 0L(%[re]ax) */
855 static const char alt_7
[] =
856 {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
857 /* nopl 0L(%[re]ax,%[re]ax,1) */
858 static const char alt_8
[] =
859 {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
860 /* nopw 0L(%[re]ax,%[re]ax,1) */
861 static const char alt_9
[] =
862 {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
863 /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
864 static const char alt_10
[] =
865 {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
867 nopw %cs:0L(%[re]ax,%[re]ax,1) */
868 static const char alt_long_11
[] =
870 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
873 nopw %cs:0L(%[re]ax,%[re]ax,1) */
874 static const char alt_long_12
[] =
877 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
881 nopw %cs:0L(%[re]ax,%[re]ax,1) */
882 static const char alt_long_13
[] =
886 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
891 nopw %cs:0L(%[re]ax,%[re]ax,1) */
892 static const char alt_long_14
[] =
897 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
903 nopw %cs:0L(%[re]ax,%[re]ax,1) */
904 static const char alt_long_15
[] =
910 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
911 /* nopl 0(%[re]ax,%[re]ax,1)
912 nopw 0(%[re]ax,%[re]ax,1) */
913 static const char alt_short_11
[] =
914 {0x0f,0x1f,0x44,0x00,0x00,
915 0x66,0x0f,0x1f,0x44,0x00,0x00};
916 /* nopw 0(%[re]ax,%[re]ax,1)
917 nopw 0(%[re]ax,%[re]ax,1) */
918 static const char alt_short_12
[] =
919 {0x66,0x0f,0x1f,0x44,0x00,0x00,
920 0x66,0x0f,0x1f,0x44,0x00,0x00};
921 /* nopw 0(%[re]ax,%[re]ax,1)
923 static const char alt_short_13
[] =
924 {0x66,0x0f,0x1f,0x44,0x00,0x00,
925 0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
928 static const char alt_short_14
[] =
929 {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
930 0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
932 nopl 0L(%[re]ax,%[re]ax,1) */
933 static const char alt_short_15
[] =
934 {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
935 0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
936 static const char *const alt_short_patt
[] = {
937 f32_1
, f32_2
, alt_3
, alt_4
, alt_5
, alt_6
, alt_7
, alt_8
,
938 alt_9
, alt_10
, alt_short_11
, alt_short_12
, alt_short_13
,
939 alt_short_14
, alt_short_15
941 static const char *const alt_long_patt
[] = {
942 f32_1
, f32_2
, alt_3
, alt_4
, alt_5
, alt_6
, alt_7
, alt_8
,
943 alt_9
, alt_10
, alt_long_11
, alt_long_12
, alt_long_13
,
944 alt_long_14
, alt_long_15
947 /* Only align for at least a positive non-zero boundary. */
948 if (count
<= 0 || count
> MAX_MEM_FOR_RS_ALIGN_CODE
)
951 /* We need to decide which NOP sequence to use for 32bit and
952 64bit. When -mtune= is used:
954 1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
955 PROCESSOR_GENERIC32, f32_patt will be used.
956 2. For PROCESSOR_PENTIUMPRO, PROCESSOR_PENTIUM4, PROCESSOR_NOCONA,
957 PROCESSOR_CORE, PROCESSOR_CORE2, PROCESSOR_COREI7, and
958 PROCESSOR_GENERIC64, alt_long_patt will be used.
959 3. For PROCESSOR_ATHLON, PROCESSOR_K6, PROCESSOR_K8 and
960 PROCESSOR_AMDFAM10, alt_short_patt will be used.
962 When -mtune= isn't used, alt_long_patt will be used if
963 cpu_arch_isa_flags has Cpu686. Otherwise, f32_patt will
966 When -march= or .arch is used, we can't use anything beyond
967 cpu_arch_isa_flags. */
969 if (flag_code
== CODE_16BIT
)
973 memcpy (fragP
->fr_literal
+ fragP
->fr_fix
,
975 /* Adjust jump offset. */
976 fragP
->fr_literal
[fragP
->fr_fix
+ 1] = count
- 2;
979 memcpy (fragP
->fr_literal
+ fragP
->fr_fix
,
980 f16_patt
[count
- 1], count
);
984 const char *const *patt
= NULL
;
986 if (fragP
->tc_frag_data
.isa
== PROCESSOR_UNKNOWN
)
988 /* PROCESSOR_UNKNOWN means that all ISAs may be used. */
989 switch (cpu_arch_tune
)
991 case PROCESSOR_UNKNOWN
:
992 /* We use cpu_arch_isa_flags to check if we SHOULD
993 optimize for Cpu686. */
994 if (fragP
->tc_frag_data
.isa_flags
.bitfield
.cpui686
)
995 patt
= alt_long_patt
;
999 case PROCESSOR_PENTIUMPRO
:
1000 case PROCESSOR_PENTIUM4
:
1001 case PROCESSOR_NOCONA
:
1002 case PROCESSOR_CORE
:
1003 case PROCESSOR_CORE2
:
1004 case PROCESSOR_COREI7
:
1005 case PROCESSOR_L1OM
:
1006 case PROCESSOR_GENERIC64
:
1007 patt
= alt_long_patt
;
1010 case PROCESSOR_ATHLON
:
1012 case PROCESSOR_AMDFAM10
:
1013 patt
= alt_short_patt
;
1015 case PROCESSOR_I386
:
1016 case PROCESSOR_I486
:
1017 case PROCESSOR_PENTIUM
:
1018 case PROCESSOR_GENERIC32
:
1025 switch (fragP
->tc_frag_data
.tune
)
1027 case PROCESSOR_UNKNOWN
:
1028 /* When cpu_arch_isa is set, cpu_arch_tune shouldn't be
1029 PROCESSOR_UNKNOWN. */
1033 case PROCESSOR_I386
:
1034 case PROCESSOR_I486
:
1035 case PROCESSOR_PENTIUM
:
1037 case PROCESSOR_ATHLON
:
1039 case PROCESSOR_AMDFAM10
:
1040 case PROCESSOR_GENERIC32
:
1041 /* We use cpu_arch_isa_flags to check if we CAN optimize
1043 if (fragP
->tc_frag_data
.isa_flags
.bitfield
.cpui686
)
1044 patt
= alt_short_patt
;
1048 case PROCESSOR_PENTIUMPRO
:
1049 case PROCESSOR_PENTIUM4
:
1050 case PROCESSOR_NOCONA
:
1051 case PROCESSOR_CORE
:
1052 case PROCESSOR_CORE2
:
1053 case PROCESSOR_COREI7
:
1054 case PROCESSOR_L1OM
:
1055 if (fragP
->tc_frag_data
.isa_flags
.bitfield
.cpui686
)
1056 patt
= alt_long_patt
;
1060 case PROCESSOR_GENERIC64
:
1061 patt
= alt_long_patt
;
1066 if (patt
== f32_patt
)
1068 /* If the padding is less than 15 bytes, we use the normal
1069 ones. Otherwise, we use a jump instruction and adjust
1073 /* For 64bit, the limit is 3 bytes. */
1074 if (flag_code
== CODE_64BIT
1075 && fragP
->tc_frag_data
.isa_flags
.bitfield
.cpulm
)
1080 memcpy (fragP
->fr_literal
+ fragP
->fr_fix
,
1081 patt
[count
- 1], count
);
1084 memcpy (fragP
->fr_literal
+ fragP
->fr_fix
,
1086 /* Adjust jump offset. */
1087 fragP
->fr_literal
[fragP
->fr_fix
+ 1] = count
- 2;
1092 /* Maximum length of an instruction is 15 byte. If the
1093 padding is greater than 15 bytes and we don't use jump,
1094 we have to break it into smaller pieces. */
1095 int padding
= count
;
1096 while (padding
> 15)
1099 memcpy (fragP
->fr_literal
+ fragP
->fr_fix
+ padding
,
1104 memcpy (fragP
->fr_literal
+ fragP
->fr_fix
,
1105 patt
[padding
- 1], padding
);
1108 fragP
->fr_var
= count
;
1112 operand_type_all_zero (const union i386_operand_type
*x
)
1114 switch (ARRAY_SIZE(x
->array
))
1123 return !x
->array
[0];
1130 operand_type_set (union i386_operand_type
*x
, unsigned int v
)
1132 switch (ARRAY_SIZE(x
->array
))
1147 operand_type_equal (const union i386_operand_type
*x
,
1148 const union i386_operand_type
*y
)
1150 switch (ARRAY_SIZE(x
->array
))
1153 if (x
->array
[2] != y
->array
[2])
1156 if (x
->array
[1] != y
->array
[1])
1159 return x
->array
[0] == y
->array
[0];
1167 cpu_flags_all_zero (const union i386_cpu_flags
*x
)
1169 switch (ARRAY_SIZE(x
->array
))
1178 return !x
->array
[0];
1185 cpu_flags_set (union i386_cpu_flags
*x
, unsigned int v
)
1187 switch (ARRAY_SIZE(x
->array
))
1202 cpu_flags_equal (const union i386_cpu_flags
*x
,
1203 const union i386_cpu_flags
*y
)
1205 switch (ARRAY_SIZE(x
->array
))
1208 if (x
->array
[2] != y
->array
[2])
1211 if (x
->array
[1] != y
->array
[1])
1214 return x
->array
[0] == y
->array
[0];
1222 cpu_flags_check_cpu64 (i386_cpu_flags f
)
1224 return !((flag_code
== CODE_64BIT
&& f
.bitfield
.cpuno64
)
1225 || (flag_code
!= CODE_64BIT
&& f
.bitfield
.cpu64
));
1228 static INLINE i386_cpu_flags
1229 cpu_flags_and (i386_cpu_flags x
, i386_cpu_flags y
)
1231 switch (ARRAY_SIZE (x
.array
))
1234 x
.array
[2] &= y
.array
[2];
1236 x
.array
[1] &= y
.array
[1];
1238 x
.array
[0] &= y
.array
[0];
1246 static INLINE i386_cpu_flags
1247 cpu_flags_or (i386_cpu_flags x
, i386_cpu_flags y
)
1249 switch (ARRAY_SIZE (x
.array
))
1252 x
.array
[2] |= y
.array
[2];
1254 x
.array
[1] |= y
.array
[1];
1256 x
.array
[0] |= y
.array
[0];
1264 static INLINE i386_cpu_flags
1265 cpu_flags_and_not (i386_cpu_flags x
, i386_cpu_flags y
)
1267 switch (ARRAY_SIZE (x
.array
))
1270 x
.array
[2] &= ~y
.array
[2];
1272 x
.array
[1] &= ~y
.array
[1];
1274 x
.array
[0] &= ~y
.array
[0];
1282 #define CPU_FLAGS_ARCH_MATCH 0x1
1283 #define CPU_FLAGS_64BIT_MATCH 0x2
1284 #define CPU_FLAGS_AES_MATCH 0x4
1285 #define CPU_FLAGS_PCLMUL_MATCH 0x8
1286 #define CPU_FLAGS_AVX_MATCH 0x10
1288 #define CPU_FLAGS_32BIT_MATCH \
1289 (CPU_FLAGS_ARCH_MATCH | CPU_FLAGS_AES_MATCH \
1290 | CPU_FLAGS_PCLMUL_MATCH | CPU_FLAGS_AVX_MATCH)
1291 #define CPU_FLAGS_PERFECT_MATCH \
1292 (CPU_FLAGS_32BIT_MATCH | CPU_FLAGS_64BIT_MATCH)
1294 /* Return CPU flags match bits. */
1297 cpu_flags_match (const insn_template
*t
)
1299 i386_cpu_flags x
= t
->cpu_flags
;
1300 int match
= cpu_flags_check_cpu64 (x
) ? CPU_FLAGS_64BIT_MATCH
: 0;
1302 x
.bitfield
.cpu64
= 0;
1303 x
.bitfield
.cpuno64
= 0;
1305 if (cpu_flags_all_zero (&x
))
1307 /* This instruction is available on all archs. */
1308 match
|= CPU_FLAGS_32BIT_MATCH
;
1312 /* This instruction is available only on some archs. */
1313 i386_cpu_flags cpu
= cpu_arch_flags
;
1315 cpu
.bitfield
.cpu64
= 0;
1316 cpu
.bitfield
.cpuno64
= 0;
1317 cpu
= cpu_flags_and (x
, cpu
);
1318 if (!cpu_flags_all_zero (&cpu
))
1320 if (x
.bitfield
.cpuavx
)
1322 /* We only need to check AES/PCLMUL/SSE2AVX with AVX. */
1323 if (cpu
.bitfield
.cpuavx
)
1325 /* Check SSE2AVX. */
1326 if (!t
->opcode_modifier
.sse2avx
|| sse2avx
)
1328 match
|= (CPU_FLAGS_ARCH_MATCH
1329 | CPU_FLAGS_AVX_MATCH
);
1331 if (!x
.bitfield
.cpuaes
|| cpu
.bitfield
.cpuaes
)
1332 match
|= CPU_FLAGS_AES_MATCH
;
1334 if (!x
.bitfield
.cpupclmul
1335 || cpu
.bitfield
.cpupclmul
)
1336 match
|= CPU_FLAGS_PCLMUL_MATCH
;
1340 match
|= CPU_FLAGS_ARCH_MATCH
;
1343 match
|= CPU_FLAGS_32BIT_MATCH
;
1349 static INLINE i386_operand_type
1350 operand_type_and (i386_operand_type x
, i386_operand_type y
)
1352 switch (ARRAY_SIZE (x
.array
))
1355 x
.array
[2] &= y
.array
[2];
1357 x
.array
[1] &= y
.array
[1];
1359 x
.array
[0] &= y
.array
[0];
1367 static INLINE i386_operand_type
1368 operand_type_or (i386_operand_type x
, i386_operand_type y
)
1370 switch (ARRAY_SIZE (x
.array
))
1373 x
.array
[2] |= y
.array
[2];
1375 x
.array
[1] |= y
.array
[1];
1377 x
.array
[0] |= y
.array
[0];
1385 static INLINE i386_operand_type
1386 operand_type_xor (i386_operand_type x
, i386_operand_type y
)
1388 switch (ARRAY_SIZE (x
.array
))
1391 x
.array
[2] ^= y
.array
[2];
1393 x
.array
[1] ^= y
.array
[1];
1395 x
.array
[0] ^= y
.array
[0];
1403 static const i386_operand_type acc32
= OPERAND_TYPE_ACC32
;
1404 static const i386_operand_type acc64
= OPERAND_TYPE_ACC64
;
1405 static const i386_operand_type control
= OPERAND_TYPE_CONTROL
;
1406 static const i386_operand_type inoutportreg
1407 = OPERAND_TYPE_INOUTPORTREG
;
1408 static const i386_operand_type reg16_inoutportreg
1409 = OPERAND_TYPE_REG16_INOUTPORTREG
;
1410 static const i386_operand_type disp16
= OPERAND_TYPE_DISP16
;
1411 static const i386_operand_type disp32
= OPERAND_TYPE_DISP32
;
1412 static const i386_operand_type disp32s
= OPERAND_TYPE_DISP32S
;
1413 static const i386_operand_type disp16_32
= OPERAND_TYPE_DISP16_32
;
1414 static const i386_operand_type anydisp
1415 = OPERAND_TYPE_ANYDISP
;
1416 static const i386_operand_type regxmm
= OPERAND_TYPE_REGXMM
;
1417 static const i386_operand_type regymm
= OPERAND_TYPE_REGYMM
;
1418 static const i386_operand_type imm8
= OPERAND_TYPE_IMM8
;
1419 static const i386_operand_type imm8s
= OPERAND_TYPE_IMM8S
;
1420 static const i386_operand_type imm16
= OPERAND_TYPE_IMM16
;
1421 static const i386_operand_type imm32
= OPERAND_TYPE_IMM32
;
1422 static const i386_operand_type imm32s
= OPERAND_TYPE_IMM32S
;
1423 static const i386_operand_type imm64
= OPERAND_TYPE_IMM64
;
1424 static const i386_operand_type imm16_32
= OPERAND_TYPE_IMM16_32
;
1425 static const i386_operand_type imm16_32s
= OPERAND_TYPE_IMM16_32S
;
1426 static const i386_operand_type imm16_32_32s
= OPERAND_TYPE_IMM16_32_32S
;
1437 operand_type_check (i386_operand_type t
, enum operand_type c
)
1442 return (t
.bitfield
.reg8
1445 || t
.bitfield
.reg64
);
1448 return (t
.bitfield
.imm8
1452 || t
.bitfield
.imm32s
1453 || t
.bitfield
.imm64
);
1456 return (t
.bitfield
.disp8
1457 || t
.bitfield
.disp16
1458 || t
.bitfield
.disp32
1459 || t
.bitfield
.disp32s
1460 || t
.bitfield
.disp64
);
1463 return (t
.bitfield
.disp8
1464 || t
.bitfield
.disp16
1465 || t
.bitfield
.disp32
1466 || t
.bitfield
.disp32s
1467 || t
.bitfield
.disp64
1468 || t
.bitfield
.baseindex
);
1477 /* Return 1 if there is no conflict in 8bit/16bit/32bit/64bit on
1478 operand J for instruction template T. */
1481 match_reg_size (const insn_template
*t
, unsigned int j
)
1483 return !((i
.types
[j
].bitfield
.byte
1484 && !t
->operand_types
[j
].bitfield
.byte
)
1485 || (i
.types
[j
].bitfield
.word
1486 && !t
->operand_types
[j
].bitfield
.word
)
1487 || (i
.types
[j
].bitfield
.dword
1488 && !t
->operand_types
[j
].bitfield
.dword
)
1489 || (i
.types
[j
].bitfield
.qword
1490 && !t
->operand_types
[j
].bitfield
.qword
));
1493 /* Return 1 if there is no conflict in any size on operand J for
1494 instruction template T. */
1497 match_mem_size (const insn_template
*t
, unsigned int j
)
1499 return (match_reg_size (t
, j
)
1500 && !((i
.types
[j
].bitfield
.unspecified
1501 && !t
->operand_types
[j
].bitfield
.unspecified
)
1502 || (i
.types
[j
].bitfield
.fword
1503 && !t
->operand_types
[j
].bitfield
.fword
)
1504 || (i
.types
[j
].bitfield
.tbyte
1505 && !t
->operand_types
[j
].bitfield
.tbyte
)
1506 || (i
.types
[j
].bitfield
.xmmword
1507 && !t
->operand_types
[j
].bitfield
.xmmword
)
1508 || (i
.types
[j
].bitfield
.ymmword
1509 && !t
->operand_types
[j
].bitfield
.ymmword
)));
1512 /* Return 1 if there is no size conflict on any operands for
1513 instruction template T. */
1516 operand_size_match (const insn_template
*t
)
1521 /* Don't check jump instructions. */
1522 if (t
->opcode_modifier
.jump
1523 || t
->opcode_modifier
.jumpbyte
1524 || t
->opcode_modifier
.jumpdword
1525 || t
->opcode_modifier
.jumpintersegment
)
1528 /* Check memory and accumulator operand size. */
1529 for (j
= 0; j
< i
.operands
; j
++)
1531 if (t
->operand_types
[j
].bitfield
.anysize
)
1534 if (t
->operand_types
[j
].bitfield
.acc
&& !match_reg_size (t
, j
))
1540 if (i
.types
[j
].bitfield
.mem
&& !match_mem_size (t
, j
))
1548 || (!t
->opcode_modifier
.d
&& !t
->opcode_modifier
.floatd
))
1551 /* Check reverse. */
1552 gas_assert (i
.operands
== 2);
1555 for (j
= 0; j
< 2; j
++)
1557 if (t
->operand_types
[j
].bitfield
.acc
1558 && !match_reg_size (t
, j
? 0 : 1))
1564 if (i
.types
[j
].bitfield
.mem
1565 && !match_mem_size (t
, j
? 0 : 1))
1576 operand_type_match (i386_operand_type overlap
,
1577 i386_operand_type given
)
1579 i386_operand_type temp
= overlap
;
1581 temp
.bitfield
.jumpabsolute
= 0;
1582 temp
.bitfield
.unspecified
= 0;
1583 temp
.bitfield
.byte
= 0;
1584 temp
.bitfield
.word
= 0;
1585 temp
.bitfield
.dword
= 0;
1586 temp
.bitfield
.fword
= 0;
1587 temp
.bitfield
.qword
= 0;
1588 temp
.bitfield
.tbyte
= 0;
1589 temp
.bitfield
.xmmword
= 0;
1590 temp
.bitfield
.ymmword
= 0;
1591 if (operand_type_all_zero (&temp
))
1594 return (given
.bitfield
.baseindex
== overlap
.bitfield
.baseindex
1595 && given
.bitfield
.jumpabsolute
== overlap
.bitfield
.jumpabsolute
);
1598 /* If given types g0 and g1 are registers they must be of the same type
1599 unless the expected operand type register overlap is null.
1600 Note that Acc in a template matches every size of reg. */
1603 operand_type_register_match (i386_operand_type m0
,
1604 i386_operand_type g0
,
1605 i386_operand_type t0
,
1606 i386_operand_type m1
,
1607 i386_operand_type g1
,
1608 i386_operand_type t1
)
1610 if (!operand_type_check (g0
, reg
))
1613 if (!operand_type_check (g1
, reg
))
1616 if (g0
.bitfield
.reg8
== g1
.bitfield
.reg8
1617 && g0
.bitfield
.reg16
== g1
.bitfield
.reg16
1618 && g0
.bitfield
.reg32
== g1
.bitfield
.reg32
1619 && g0
.bitfield
.reg64
== g1
.bitfield
.reg64
)
1622 if (m0
.bitfield
.acc
)
1624 t0
.bitfield
.reg8
= 1;
1625 t0
.bitfield
.reg16
= 1;
1626 t0
.bitfield
.reg32
= 1;
1627 t0
.bitfield
.reg64
= 1;
1630 if (m1
.bitfield
.acc
)
1632 t1
.bitfield
.reg8
= 1;
1633 t1
.bitfield
.reg16
= 1;
1634 t1
.bitfield
.reg32
= 1;
1635 t1
.bitfield
.reg64
= 1;
1638 return (!(t0
.bitfield
.reg8
& t1
.bitfield
.reg8
)
1639 && !(t0
.bitfield
.reg16
& t1
.bitfield
.reg16
)
1640 && !(t0
.bitfield
.reg32
& t1
.bitfield
.reg32
)
1641 && !(t0
.bitfield
.reg64
& t1
.bitfield
.reg64
));
1644 static INLINE
unsigned int
1645 mode_from_disp_size (i386_operand_type t
)
1647 if (t
.bitfield
.disp8
)
1649 else if (t
.bitfield
.disp16
1650 || t
.bitfield
.disp32
1651 || t
.bitfield
.disp32s
)
1658 fits_in_signed_byte (offsetT num
)
1660 return (num
>= -128) && (num
<= 127);
1664 fits_in_unsigned_byte (offsetT num
)
1666 return (num
& 0xff) == num
;
1670 fits_in_unsigned_word (offsetT num
)
1672 return (num
& 0xffff) == num
;
1676 fits_in_signed_word (offsetT num
)
1678 return (-32768 <= num
) && (num
<= 32767);
1682 fits_in_signed_long (offsetT num ATTRIBUTE_UNUSED
)
1687 return (!(((offsetT
) -1 << 31) & num
)
1688 || (((offsetT
) -1 << 31) & num
) == ((offsetT
) -1 << 31));
1690 } /* fits_in_signed_long() */
1693 fits_in_unsigned_long (offsetT num ATTRIBUTE_UNUSED
)
1698 return (num
& (((offsetT
) 2 << 31) - 1)) == num
;
1700 } /* fits_in_unsigned_long() */
1702 static i386_operand_type
1703 smallest_imm_type (offsetT num
)
1705 i386_operand_type t
;
1707 operand_type_set (&t
, 0);
1708 t
.bitfield
.imm64
= 1;
1710 if (cpu_arch_tune
!= PROCESSOR_I486
&& num
== 1)
1712 /* This code is disabled on the 486 because all the Imm1 forms
1713 in the opcode table are slower on the i486. They're the
1714 versions with the implicitly specified single-position
1715 displacement, which has another syntax if you really want to
1717 t
.bitfield
.imm1
= 1;
1718 t
.bitfield
.imm8
= 1;
1719 t
.bitfield
.imm8s
= 1;
1720 t
.bitfield
.imm16
= 1;
1721 t
.bitfield
.imm32
= 1;
1722 t
.bitfield
.imm32s
= 1;
1724 else if (fits_in_signed_byte (num
))
1726 t
.bitfield
.imm8
= 1;
1727 t
.bitfield
.imm8s
= 1;
1728 t
.bitfield
.imm16
= 1;
1729 t
.bitfield
.imm32
= 1;
1730 t
.bitfield
.imm32s
= 1;
1732 else if (fits_in_unsigned_byte (num
))
1734 t
.bitfield
.imm8
= 1;
1735 t
.bitfield
.imm16
= 1;
1736 t
.bitfield
.imm32
= 1;
1737 t
.bitfield
.imm32s
= 1;
1739 else if (fits_in_signed_word (num
) || fits_in_unsigned_word (num
))
1741 t
.bitfield
.imm16
= 1;
1742 t
.bitfield
.imm32
= 1;
1743 t
.bitfield
.imm32s
= 1;
1745 else if (fits_in_signed_long (num
))
1747 t
.bitfield
.imm32
= 1;
1748 t
.bitfield
.imm32s
= 1;
1750 else if (fits_in_unsigned_long (num
))
1751 t
.bitfield
.imm32
= 1;
1757 offset_in_range (offsetT val
, int size
)
1763 case 1: mask
= ((addressT
) 1 << 8) - 1; break;
1764 case 2: mask
= ((addressT
) 1 << 16) - 1; break;
1765 case 4: mask
= ((addressT
) 2 << 31) - 1; break;
1767 case 8: mask
= ((addressT
) 2 << 63) - 1; break;
1773 /* If BFD64, sign extend val for 32bit address mode. */
1774 if (flag_code
!= CODE_64BIT
1775 || i
.prefix
[ADDR_PREFIX
])
1776 if ((val
& ~(((addressT
) 2 << 31) - 1)) == 0)
1777 val
= (val
^ ((addressT
) 1 << 31)) - ((addressT
) 1 << 31);
1780 if ((val
& ~mask
) != 0 && (val
& ~mask
) != ~mask
)
1782 char buf1
[40], buf2
[40];
1784 sprint_value (buf1
, val
);
1785 sprint_value (buf2
, val
& mask
);
1786 as_warn (_("%s shortened to %s"), buf1
, buf2
);
1800 a. PREFIX_EXIST if attempting to add a prefix where one from the
1801 same class already exists.
1802 b. PREFIX_LOCK if lock prefix is added.
1803 c. PREFIX_REP if rep/repne prefix is added.
1804 d. PREFIX_OTHER if other prefix is added.
1807 static enum PREFIX_GROUP
1808 add_prefix (unsigned int prefix
)
1810 enum PREFIX_GROUP ret
= PREFIX_OTHER
;
1813 if (prefix
>= REX_OPCODE
&& prefix
< REX_OPCODE
+ 16
1814 && flag_code
== CODE_64BIT
)
1816 if ((i
.prefix
[REX_PREFIX
] & prefix
& REX_W
)
1817 || ((i
.prefix
[REX_PREFIX
] & (REX_R
| REX_X
| REX_B
))
1818 && (prefix
& (REX_R
| REX_X
| REX_B
))))
1829 case CS_PREFIX_OPCODE
:
1830 case DS_PREFIX_OPCODE
:
1831 case ES_PREFIX_OPCODE
:
1832 case FS_PREFIX_OPCODE
:
1833 case GS_PREFIX_OPCODE
:
1834 case SS_PREFIX_OPCODE
:
1838 case REPNE_PREFIX_OPCODE
:
1839 case REPE_PREFIX_OPCODE
:
1844 case LOCK_PREFIX_OPCODE
:
1853 case ADDR_PREFIX_OPCODE
:
1857 case DATA_PREFIX_OPCODE
:
1861 if (i
.prefix
[q
] != 0)
1869 i
.prefix
[q
] |= prefix
;
1872 as_bad (_("same type of prefix used twice"));
1878 set_code_flag (int value
)
1880 flag_code
= (enum flag_code
) value
;
1881 if (flag_code
== CODE_64BIT
)
1883 cpu_arch_flags
.bitfield
.cpu64
= 1;
1884 cpu_arch_flags
.bitfield
.cpuno64
= 0;
1888 cpu_arch_flags
.bitfield
.cpu64
= 0;
1889 cpu_arch_flags
.bitfield
.cpuno64
= 1;
1891 if (value
== CODE_64BIT
&& !cpu_arch_flags
.bitfield
.cpulm
)
1893 as_bad (_("64bit mode not supported on this CPU."));
1895 if (value
== CODE_32BIT
&& !cpu_arch_flags
.bitfield
.cpui386
)
1897 as_bad (_("32bit mode not supported on this CPU."));
1899 stackop_size
= '\0';
1903 set_16bit_gcc_code_flag (int new_code_flag
)
1905 flag_code
= (enum flag_code
) new_code_flag
;
1906 if (flag_code
!= CODE_16BIT
)
1908 cpu_arch_flags
.bitfield
.cpu64
= 0;
1909 cpu_arch_flags
.bitfield
.cpuno64
= 1;
1910 stackop_size
= LONG_MNEM_SUFFIX
;
1914 set_intel_syntax (int syntax_flag
)
1916 /* Find out if register prefixing is specified. */
1917 int ask_naked_reg
= 0;
1920 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1922 char *string
= input_line_pointer
;
1923 int e
= get_symbol_end ();
1925 if (strcmp (string
, "prefix") == 0)
1927 else if (strcmp (string
, "noprefix") == 0)
1930 as_bad (_("bad argument to syntax directive."));
1931 *input_line_pointer
= e
;
1933 demand_empty_rest_of_line ();
1935 intel_syntax
= syntax_flag
;
1937 if (ask_naked_reg
== 0)
1938 allow_naked_reg
= (intel_syntax
1939 && (bfd_get_symbol_leading_char (stdoutput
) != '\0'));
1941 allow_naked_reg
= (ask_naked_reg
< 0);
1943 expr_set_rank (O_full_ptr
, syntax_flag
? 10 : 0);
1945 identifier_chars
['%'] = intel_syntax
&& allow_naked_reg
? '%' : 0;
1946 identifier_chars
['$'] = intel_syntax
? '$' : 0;
1947 register_prefix
= allow_naked_reg
? "" : "%";
1951 set_intel_mnemonic (int mnemonic_flag
)
1953 intel_mnemonic
= mnemonic_flag
;
1957 set_allow_index_reg (int flag
)
1959 allow_index_reg
= flag
;
1963 set_sse_check (int dummy ATTRIBUTE_UNUSED
)
1967 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1969 char *string
= input_line_pointer
;
1970 int e
= get_symbol_end ();
1972 if (strcmp (string
, "none") == 0)
1973 sse_check
= sse_check_none
;
1974 else if (strcmp (string
, "warning") == 0)
1975 sse_check
= sse_check_warning
;
1976 else if (strcmp (string
, "error") == 0)
1977 sse_check
= sse_check_error
;
1979 as_bad (_("bad argument to sse_check directive."));
1980 *input_line_pointer
= e
;
1983 as_bad (_("missing argument for sse_check directive"));
1985 demand_empty_rest_of_line ();
1989 check_cpu_arch_compatible (const char *name ATTRIBUTE_UNUSED
,
1990 i386_cpu_flags new_flag ATTRIBUTE_UNUSED
)
1992 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
1993 static const char *arch
;
1995 /* Intel LIOM is only supported on ELF. */
2001 /* Use cpu_arch_name if it is set in md_parse_option. Otherwise
2002 use default_arch. */
2003 arch
= cpu_arch_name
;
2005 arch
= default_arch
;
2008 /* If we are targeting Intel L1OM, we must enable it. */
2009 if (get_elf_backend_data (stdoutput
)->elf_machine_code
!= EM_L1OM
2010 || new_flag
.bitfield
.cpul1om
)
2013 as_bad (_("`%s' is not supported on `%s'"), name
, arch
);
2018 set_cpu_arch (int dummy ATTRIBUTE_UNUSED
)
2022 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
2024 char *string
= input_line_pointer
;
2025 int e
= get_symbol_end ();
2027 i386_cpu_flags flags
;
2029 for (j
= 0; j
< ARRAY_SIZE (cpu_arch
); j
++)
2031 if (strcmp (string
, cpu_arch
[j
].name
) == 0)
2033 check_cpu_arch_compatible (string
, cpu_arch
[j
].flags
);
2037 cpu_arch_name
= cpu_arch
[j
].name
;
2038 cpu_sub_arch_name
= NULL
;
2039 cpu_arch_flags
= cpu_arch
[j
].flags
;
2040 if (flag_code
== CODE_64BIT
)
2042 cpu_arch_flags
.bitfield
.cpu64
= 1;
2043 cpu_arch_flags
.bitfield
.cpuno64
= 0;
2047 cpu_arch_flags
.bitfield
.cpu64
= 0;
2048 cpu_arch_flags
.bitfield
.cpuno64
= 1;
2050 cpu_arch_isa
= cpu_arch
[j
].type
;
2051 cpu_arch_isa_flags
= cpu_arch
[j
].flags
;
2052 if (!cpu_arch_tune_set
)
2054 cpu_arch_tune
= cpu_arch_isa
;
2055 cpu_arch_tune_flags
= cpu_arch_isa_flags
;
2060 if (strncmp (string
+ 1, "no", 2))
2061 flags
= cpu_flags_or (cpu_arch_flags
,
2064 flags
= cpu_flags_and_not (cpu_arch_flags
,
2066 if (!cpu_flags_equal (&flags
, &cpu_arch_flags
))
2068 if (cpu_sub_arch_name
)
2070 char *name
= cpu_sub_arch_name
;
2071 cpu_sub_arch_name
= concat (name
,
2073 (const char *) NULL
);
2077 cpu_sub_arch_name
= xstrdup (cpu_arch
[j
].name
);
2078 cpu_arch_flags
= flags
;
2080 *input_line_pointer
= e
;
2081 demand_empty_rest_of_line ();
2085 if (j
>= ARRAY_SIZE (cpu_arch
))
2086 as_bad (_("no such architecture: `%s'"), string
);
2088 *input_line_pointer
= e
;
2091 as_bad (_("missing cpu architecture"));
2093 no_cond_jump_promotion
= 0;
2094 if (*input_line_pointer
== ','
2095 && !is_end_of_line
[(unsigned char) input_line_pointer
[1]])
2097 char *string
= ++input_line_pointer
;
2098 int e
= get_symbol_end ();
2100 if (strcmp (string
, "nojumps") == 0)
2101 no_cond_jump_promotion
= 1;
2102 else if (strcmp (string
, "jumps") == 0)
2105 as_bad (_("no such architecture modifier: `%s'"), string
);
2107 *input_line_pointer
= e
;
2110 demand_empty_rest_of_line ();
2113 enum bfd_architecture
2116 if (cpu_arch_isa
== PROCESSOR_L1OM
)
2118 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
2119 || flag_code
!= CODE_64BIT
)
2120 as_fatal (_("Intel L1OM is 64bit ELF only"));
2121 return bfd_arch_l1om
;
2124 return bfd_arch_i386
;
2130 if (!strcmp (default_arch
, "x86_64"))
2132 if (cpu_arch_isa
== PROCESSOR_L1OM
)
2134 if (OUTPUT_FLAVOR
!= bfd_target_elf_flavour
)
2135 as_fatal (_("Intel L1OM is 64bit ELF only"));
2136 return bfd_mach_l1om
;
2139 return bfd_mach_x86_64
;
2141 else if (!strcmp (default_arch
, "i386"))
2142 return bfd_mach_i386_i386
;
2144 as_fatal (_("Unknown architecture"));
2150 const char *hash_err
;
2152 /* Initialize op_hash hash table. */
2153 op_hash
= hash_new ();
2156 const insn_template
*optab
;
2157 templates
*core_optab
;
2159 /* Setup for loop. */
2161 core_optab
= (templates
*) xmalloc (sizeof (templates
));
2162 core_optab
->start
= optab
;
2167 if (optab
->name
== NULL
2168 || strcmp (optab
->name
, (optab
- 1)->name
) != 0)
2170 /* different name --> ship out current template list;
2171 add to hash table; & begin anew. */
2172 core_optab
->end
= optab
;
2173 hash_err
= hash_insert (op_hash
,
2175 (void *) core_optab
);
2178 as_fatal (_("Internal Error: Can't hash %s: %s"),
2182 if (optab
->name
== NULL
)
2184 core_optab
= (templates
*) xmalloc (sizeof (templates
));
2185 core_optab
->start
= optab
;
2190 /* Initialize reg_hash hash table. */
2191 reg_hash
= hash_new ();
2193 const reg_entry
*regtab
;
2194 unsigned int regtab_size
= i386_regtab_size
;
2196 for (regtab
= i386_regtab
; regtab_size
--; regtab
++)
2198 hash_err
= hash_insert (reg_hash
, regtab
->reg_name
, (void *) regtab
);
2200 as_fatal (_("Internal Error: Can't hash %s: %s"),
2206 /* Fill in lexical tables: mnemonic_chars, operand_chars. */
2211 for (c
= 0; c
< 256; c
++)
2216 mnemonic_chars
[c
] = c
;
2217 register_chars
[c
] = c
;
2218 operand_chars
[c
] = c
;
2220 else if (ISLOWER (c
))
2222 mnemonic_chars
[c
] = c
;
2223 register_chars
[c
] = c
;
2224 operand_chars
[c
] = c
;
2226 else if (ISUPPER (c
))
2228 mnemonic_chars
[c
] = TOLOWER (c
);
2229 register_chars
[c
] = mnemonic_chars
[c
];
2230 operand_chars
[c
] = c
;
2233 if (ISALPHA (c
) || ISDIGIT (c
))
2234 identifier_chars
[c
] = c
;
2237 identifier_chars
[c
] = c
;
2238 operand_chars
[c
] = c
;
2243 identifier_chars
['@'] = '@';
2246 identifier_chars
['?'] = '?';
2247 operand_chars
['?'] = '?';
2249 digit_chars
['-'] = '-';
2250 mnemonic_chars
['_'] = '_';
2251 mnemonic_chars
['-'] = '-';
2252 mnemonic_chars
['.'] = '.';
2253 identifier_chars
['_'] = '_';
2254 identifier_chars
['.'] = '.';
2256 for (p
= operand_special_chars
; *p
!= '\0'; p
++)
2257 operand_chars
[(unsigned char) *p
] = *p
;
2260 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2263 record_alignment (text_section
, 2);
2264 record_alignment (data_section
, 2);
2265 record_alignment (bss_section
, 2);
2269 if (flag_code
== CODE_64BIT
)
2271 x86_dwarf2_return_column
= 16;
2272 x86_cie_data_alignment
= -8;
2276 x86_dwarf2_return_column
= 8;
2277 x86_cie_data_alignment
= -4;
2282 i386_print_statistics (FILE *file
)
2284 hash_print_statistics (file
, "i386 opcode", op_hash
);
2285 hash_print_statistics (file
, "i386 register", reg_hash
);
2290 /* Debugging routines for md_assemble. */
2291 static void pte (insn_template
*);
2292 static void pt (i386_operand_type
);
2293 static void pe (expressionS
*);
2294 static void ps (symbolS
*);
2297 pi (char *line
, i386_insn
*x
)
2301 fprintf (stdout
, "%s: template ", line
);
2303 fprintf (stdout
, " address: base %s index %s scale %x\n",
2304 x
->base_reg
? x
->base_reg
->reg_name
: "none",
2305 x
->index_reg
? x
->index_reg
->reg_name
: "none",
2306 x
->log2_scale_factor
);
2307 fprintf (stdout
, " modrm: mode %x reg %x reg/mem %x\n",
2308 x
->rm
.mode
, x
->rm
.reg
, x
->rm
.regmem
);
2309 fprintf (stdout
, " sib: base %x index %x scale %x\n",
2310 x
->sib
.base
, x
->sib
.index
, x
->sib
.scale
);
2311 fprintf (stdout
, " rex: 64bit %x extX %x extY %x extZ %x\n",
2312 (x
->rex
& REX_W
) != 0,
2313 (x
->rex
& REX_R
) != 0,
2314 (x
->rex
& REX_X
) != 0,
2315 (x
->rex
& REX_B
) != 0);
2316 for (i
= 0; i
< x
->operands
; i
++)
2318 fprintf (stdout
, " #%d: ", i
+ 1);
2320 fprintf (stdout
, "\n");
2321 if (x
->types
[i
].bitfield
.reg8
2322 || x
->types
[i
].bitfield
.reg16
2323 || x
->types
[i
].bitfield
.reg32
2324 || x
->types
[i
].bitfield
.reg64
2325 || x
->types
[i
].bitfield
.regmmx
2326 || x
->types
[i
].bitfield
.regxmm
2327 || x
->types
[i
].bitfield
.regymm
2328 || x
->types
[i
].bitfield
.sreg2
2329 || x
->types
[i
].bitfield
.sreg3
2330 || x
->types
[i
].bitfield
.control
2331 || x
->types
[i
].bitfield
.debug
2332 || x
->types
[i
].bitfield
.test
)
2333 fprintf (stdout
, "%s\n", x
->op
[i
].regs
->reg_name
);
2334 if (operand_type_check (x
->types
[i
], imm
))
2336 if (operand_type_check (x
->types
[i
], disp
))
2337 pe (x
->op
[i
].disps
);
2342 pte (insn_template
*t
)
2345 fprintf (stdout
, " %d operands ", t
->operands
);
2346 fprintf (stdout
, "opcode %x ", t
->base_opcode
);
2347 if (t
->extension_opcode
!= None
)
2348 fprintf (stdout
, "ext %x ", t
->extension_opcode
);
2349 if (t
->opcode_modifier
.d
)
2350 fprintf (stdout
, "D");
2351 if (t
->opcode_modifier
.w
)
2352 fprintf (stdout
, "W");
2353 fprintf (stdout
, "\n");
2354 for (i
= 0; i
< t
->operands
; i
++)
2356 fprintf (stdout
, " #%d type ", i
+ 1);
2357 pt (t
->operand_types
[i
]);
2358 fprintf (stdout
, "\n");
2365 fprintf (stdout
, " operation %d\n", e
->X_op
);
2366 fprintf (stdout
, " add_number %ld (%lx)\n",
2367 (long) e
->X_add_number
, (long) e
->X_add_number
);
2368 if (e
->X_add_symbol
)
2370 fprintf (stdout
, " add_symbol ");
2371 ps (e
->X_add_symbol
);
2372 fprintf (stdout
, "\n");
2376 fprintf (stdout
, " op_symbol ");
2377 ps (e
->X_op_symbol
);
2378 fprintf (stdout
, "\n");
2385 fprintf (stdout
, "%s type %s%s",
2387 S_IS_EXTERNAL (s
) ? "EXTERNAL " : "",
2388 segment_name (S_GET_SEGMENT (s
)));
2391 static struct type_name
2393 i386_operand_type mask
;
2396 const type_names
[] =
2398 { OPERAND_TYPE_REG8
, "r8" },
2399 { OPERAND_TYPE_REG16
, "r16" },
2400 { OPERAND_TYPE_REG32
, "r32" },
2401 { OPERAND_TYPE_REG64
, "r64" },
2402 { OPERAND_TYPE_IMM8
, "i8" },
2403 { OPERAND_TYPE_IMM8
, "i8s" },
2404 { OPERAND_TYPE_IMM16
, "i16" },
2405 { OPERAND_TYPE_IMM32
, "i32" },
2406 { OPERAND_TYPE_IMM32S
, "i32s" },
2407 { OPERAND_TYPE_IMM64
, "i64" },
2408 { OPERAND_TYPE_IMM1
, "i1" },
2409 { OPERAND_TYPE_BASEINDEX
, "BaseIndex" },
2410 { OPERAND_TYPE_DISP8
, "d8" },
2411 { OPERAND_TYPE_DISP16
, "d16" },
2412 { OPERAND_TYPE_DISP32
, "d32" },
2413 { OPERAND_TYPE_DISP32S
, "d32s" },
2414 { OPERAND_TYPE_DISP64
, "d64" },
2415 { OPERAND_TYPE_INOUTPORTREG
, "InOutPortReg" },
2416 { OPERAND_TYPE_SHIFTCOUNT
, "ShiftCount" },
2417 { OPERAND_TYPE_CONTROL
, "control reg" },
2418 { OPERAND_TYPE_TEST
, "test reg" },
2419 { OPERAND_TYPE_DEBUG
, "debug reg" },
2420 { OPERAND_TYPE_FLOATREG
, "FReg" },
2421 { OPERAND_TYPE_FLOATACC
, "FAcc" },
2422 { OPERAND_TYPE_SREG2
, "SReg2" },
2423 { OPERAND_TYPE_SREG3
, "SReg3" },
2424 { OPERAND_TYPE_ACC
, "Acc" },
2425 { OPERAND_TYPE_JUMPABSOLUTE
, "Jump Absolute" },
2426 { OPERAND_TYPE_REGMMX
, "rMMX" },
2427 { OPERAND_TYPE_REGXMM
, "rXMM" },
2428 { OPERAND_TYPE_REGYMM
, "rYMM" },
2429 { OPERAND_TYPE_ESSEG
, "es" },
2433 pt (i386_operand_type t
)
2436 i386_operand_type a
;
2438 for (j
= 0; j
< ARRAY_SIZE (type_names
); j
++)
2440 a
= operand_type_and (t
, type_names
[j
].mask
);
2441 if (!operand_type_all_zero (&a
))
2442 fprintf (stdout
, "%s, ", type_names
[j
].name
);
2447 #endif /* DEBUG386 */
2449 static bfd_reloc_code_real_type
2450 reloc (unsigned int size
,
2453 bfd_reloc_code_real_type other
)
2455 if (other
!= NO_RELOC
)
2457 reloc_howto_type
*rel
;
2462 case BFD_RELOC_X86_64_GOT32
:
2463 return BFD_RELOC_X86_64_GOT64
;
2465 case BFD_RELOC_X86_64_PLTOFF64
:
2466 return BFD_RELOC_X86_64_PLTOFF64
;
2468 case BFD_RELOC_X86_64_GOTPC32
:
2469 other
= BFD_RELOC_X86_64_GOTPC64
;
2471 case BFD_RELOC_X86_64_GOTPCREL
:
2472 other
= BFD_RELOC_X86_64_GOTPCREL64
;
2474 case BFD_RELOC_X86_64_TPOFF32
:
2475 other
= BFD_RELOC_X86_64_TPOFF64
;
2477 case BFD_RELOC_X86_64_DTPOFF32
:
2478 other
= BFD_RELOC_X86_64_DTPOFF64
;
2484 /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless. */
2485 if (size
== 4 && flag_code
!= CODE_64BIT
)
2488 rel
= bfd_reloc_type_lookup (stdoutput
, other
);
2490 as_bad (_("unknown relocation (%u)"), other
);
2491 else if (size
!= bfd_get_reloc_size (rel
))
2492 as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
2493 bfd_get_reloc_size (rel
),
2495 else if (pcrel
&& !rel
->pc_relative
)
2496 as_bad (_("non-pc-relative relocation for pc-relative field"));
2497 else if ((rel
->complain_on_overflow
== complain_overflow_signed
2499 || (rel
->complain_on_overflow
== complain_overflow_unsigned
2501 as_bad (_("relocated field and relocation type differ in signedness"));
2510 as_bad (_("there are no unsigned pc-relative relocations"));
2513 case 1: return BFD_RELOC_8_PCREL
;
2514 case 2: return BFD_RELOC_16_PCREL
;
2515 case 4: return BFD_RELOC_32_PCREL
;
2516 case 8: return BFD_RELOC_64_PCREL
;
2518 as_bad (_("cannot do %u byte pc-relative relocation"), size
);
2525 case 4: return BFD_RELOC_X86_64_32S
;
2530 case 1: return BFD_RELOC_8
;
2531 case 2: return BFD_RELOC_16
;
2532 case 4: return BFD_RELOC_32
;
2533 case 8: return BFD_RELOC_64
;
2535 as_bad (_("cannot do %s %u byte relocation"),
2536 sign
> 0 ? "signed" : "unsigned", size
);
2542 /* Here we decide which fixups can be adjusted to make them relative to
2543 the beginning of the section instead of the symbol. Basically we need
2544 to make sure that the dynamic relocations are done correctly, so in
2545 some cases we force the original symbol to be used. */
2548 tc_i386_fix_adjustable (fixS
*fixP ATTRIBUTE_UNUSED
)
2550 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
2554 /* Don't adjust pc-relative references to merge sections in 64-bit
2556 if (use_rela_relocations
2557 && (S_GET_SEGMENT (fixP
->fx_addsy
)->flags
& SEC_MERGE
) != 0
2561 /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
2562 and changed later by validate_fix. */
2563 if (GOT_symbol
&& fixP
->fx_subsy
== GOT_symbol
2564 && fixP
->fx_r_type
== BFD_RELOC_32_PCREL
)
2567 /* adjust_reloc_syms doesn't know about the GOT. */
2568 if (fixP
->fx_r_type
== BFD_RELOC_386_GOTOFF
2569 || fixP
->fx_r_type
== BFD_RELOC_386_PLT32
2570 || fixP
->fx_r_type
== BFD_RELOC_386_GOT32
2571 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_GD
2572 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_LDM
2573 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_LDO_32
2574 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_IE_32
2575 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_IE
2576 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_GOTIE
2577 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_LE_32
2578 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_LE
2579 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_GOTDESC
2580 || fixP
->fx_r_type
== BFD_RELOC_386_TLS_DESC_CALL
2581 || fixP
->fx_r_type
== BFD_RELOC_X86_64_PLT32
2582 || fixP
->fx_r_type
== BFD_RELOC_X86_64_GOT32
2583 || fixP
->fx_r_type
== BFD_RELOC_X86_64_GOTPCREL
2584 || fixP
->fx_r_type
== BFD_RELOC_X86_64_TLSGD
2585 || fixP
->fx_r_type
== BFD_RELOC_X86_64_TLSLD
2586 || fixP
->fx_r_type
== BFD_RELOC_X86_64_DTPOFF32
2587 || fixP
->fx_r_type
== BFD_RELOC_X86_64_DTPOFF64
2588 || fixP
->fx_r_type
== BFD_RELOC_X86_64_GOTTPOFF
2589 || fixP
->fx_r_type
== BFD_RELOC_X86_64_TPOFF32
2590 || fixP
->fx_r_type
== BFD_RELOC_X86_64_TPOFF64
2591 || fixP
->fx_r_type
== BFD_RELOC_X86_64_GOTOFF64
2592 || fixP
->fx_r_type
== BFD_RELOC_X86_64_GOTPC32_TLSDESC
2593 || fixP
->fx_r_type
== BFD_RELOC_X86_64_TLSDESC_CALL
2594 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
2595 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
2602 intel_float_operand (const char *mnemonic
)
2604 /* Note that the value returned is meaningful only for opcodes with (memory)
2605 operands, hence the code here is free to improperly handle opcodes that
2606 have no operands (for better performance and smaller code). */
2608 if (mnemonic
[0] != 'f')
2609 return 0; /* non-math */
2611 switch (mnemonic
[1])
2613 /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
2614 the fs segment override prefix not currently handled because no
2615 call path can make opcodes without operands get here */
2617 return 2 /* integer op */;
2619 if (mnemonic
[2] == 'd' && (mnemonic
[3] == 'c' || mnemonic
[3] == 'e'))
2620 return 3; /* fldcw/fldenv */
2623 if (mnemonic
[2] != 'o' /* fnop */)
2624 return 3; /* non-waiting control op */
2627 if (mnemonic
[2] == 's')
2628 return 3; /* frstor/frstpm */
2631 if (mnemonic
[2] == 'a')
2632 return 3; /* fsave */
2633 if (mnemonic
[2] == 't')
2635 switch (mnemonic
[3])
2637 case 'c': /* fstcw */
2638 case 'd': /* fstdw */
2639 case 'e': /* fstenv */
2640 case 's': /* fsts[gw] */
2646 if (mnemonic
[2] == 'r' || mnemonic
[2] == 's')
2647 return 0; /* fxsave/fxrstor are not really math ops */
2654 /* Build the VEX prefix. */
2657 build_vex_prefix (const insn_template
*t
)
2659 unsigned int register_specifier
;
2660 unsigned int implied_prefix
;
2661 unsigned int vector_length
;
2663 /* Check register specifier. */
2664 if (i
.vex
.register_specifier
)
2666 register_specifier
= i
.vex
.register_specifier
->reg_num
;
2667 if ((i
.vex
.register_specifier
->reg_flags
& RegRex
))
2668 register_specifier
+= 8;
2669 register_specifier
= ~register_specifier
& 0xf;
2672 register_specifier
= 0xf;
2674 /* Use 2-byte VEX prefix by swappping destination and source
2677 && i
.operands
== i
.reg_operands
2678 && i
.tm
.opcode_modifier
.vexopcode
== VEX0F
2679 && i
.tm
.opcode_modifier
.s
2682 unsigned int xchg
= i
.operands
- 1;
2683 union i386_op temp_op
;
2684 i386_operand_type temp_type
;
2686 temp_type
= i
.types
[xchg
];
2687 i
.types
[xchg
] = i
.types
[0];
2688 i
.types
[0] = temp_type
;
2689 temp_op
= i
.op
[xchg
];
2690 i
.op
[xchg
] = i
.op
[0];
2693 gas_assert (i
.rm
.mode
== 3);
2697 i
.rm
.regmem
= i
.rm
.reg
;
2700 /* Use the next insn. */
2704 vector_length
= i
.tm
.opcode_modifier
.vex
== VEX256
? 1 : 0;
2706 switch ((i
.tm
.base_opcode
>> 8) & 0xff)
2711 case DATA_PREFIX_OPCODE
:
2714 case REPE_PREFIX_OPCODE
:
2717 case REPNE_PREFIX_OPCODE
:
2724 /* Use 2-byte VEX prefix if possible. */
2725 if (i
.tm
.opcode_modifier
.vexopcode
== VEX0F
2726 && (i
.rex
& (REX_W
| REX_X
| REX_B
)) == 0)
2728 /* 2-byte VEX prefix. */
2732 i
.vex
.bytes
[0] = 0xc5;
2734 /* Check the REX.R bit. */
2735 r
= (i
.rex
& REX_R
) ? 0 : 1;
2736 i
.vex
.bytes
[1] = (r
<< 7
2737 | register_specifier
<< 3
2738 | vector_length
<< 2
2743 /* 3-byte VEX prefix. */
2747 i
.vex
.bytes
[0] = 0xc4;
2749 switch (i
.tm
.opcode_modifier
.vexopcode
)
2762 i
.vex
.bytes
[0] = 0x8f;
2766 i
.vex
.bytes
[0] = 0x8f;
2770 i
.vex
.bytes
[0] = 0x8f;
2776 /* The high 3 bits of the second VEX byte are 1's compliment
2777 of RXB bits from REX. */
2778 i
.vex
.bytes
[1] = (~i
.rex
& 0x7) << 5 | m
;
2780 /* Check the REX.W bit. */
2781 w
= (i
.rex
& REX_W
) ? 1 : 0;
2782 if (i
.tm
.opcode_modifier
.vexw
)
2787 if (i
.tm
.opcode_modifier
.vexw
== VEXW1
)
2791 i
.vex
.bytes
[2] = (w
<< 7
2792 | register_specifier
<< 3
2793 | vector_length
<< 2
2799 process_immext (void)
2803 if (i
.tm
.cpu_flags
.bitfield
.cpusse3
&& i
.operands
> 0)
2805 /* SSE3 Instructions have the fixed operands with an opcode
2806 suffix which is coded in the same place as an 8-bit immediate
2807 field would be. Here we check those operands and remove them
2811 for (x
= 0; x
< i
.operands
; x
++)
2812 if (i
.op
[x
].regs
->reg_num
!= x
)
2813 as_bad (_("can't use register '%s%s' as operand %d in '%s'."),
2814 register_prefix
, i
.op
[x
].regs
->reg_name
, x
+ 1,
2820 /* These AMD 3DNow! and SSE2 instructions have an opcode suffix
2821 which is coded in the same place as an 8-bit immediate field
2822 would be. Here we fake an 8-bit immediate operand from the
2823 opcode suffix stored in tm.extension_opcode.
2825 AVX instructions also use this encoding, for some of
2826 3 argument instructions. */
2828 gas_assert (i
.imm_operands
== 0
2830 || (i
.tm
.opcode_modifier
.vex
2831 && i
.operands
<= 4)));
2833 exp
= &im_expressions
[i
.imm_operands
++];
2834 i
.op
[i
.operands
].imms
= exp
;
2835 i
.types
[i
.operands
] = imm8
;
2837 exp
->X_op
= O_constant
;
2838 exp
->X_add_number
= i
.tm
.extension_opcode
;
2839 i
.tm
.extension_opcode
= None
;
2842 /* This is the guts of the machine-dependent assembler. LINE points to a
2843 machine dependent instruction. This function is supposed to emit
2844 the frags/bytes it assembles to. */
2847 md_assemble (char *line
)
2850 char mnemonic
[MAX_MNEM_SIZE
];
2851 const insn_template
*t
;
2853 /* Initialize globals. */
2854 memset (&i
, '\0', sizeof (i
));
2855 for (j
= 0; j
< MAX_OPERANDS
; j
++)
2856 i
.reloc
[j
] = NO_RELOC
;
2857 memset (disp_expressions
, '\0', sizeof (disp_expressions
));
2858 memset (im_expressions
, '\0', sizeof (im_expressions
));
2859 save_stack_p
= save_stack
;
2861 /* First parse an instruction mnemonic & call i386_operand for the operands.
2862 We assume that the scrubber has arranged it so that line[0] is the valid
2863 start of a (possibly prefixed) mnemonic. */
2865 line
= parse_insn (line
, mnemonic
);
2869 line
= parse_operands (line
, mnemonic
);
2874 /* Now we've parsed the mnemonic into a set of templates, and have the
2875 operands at hand. */
2877 /* All intel opcodes have reversed operands except for "bound" and
2878 "enter". We also don't reverse intersegment "jmp" and "call"
2879 instructions with 2 immediate operands so that the immediate segment
2880 precedes the offset, as it does when in AT&T mode. */
2883 && (strcmp (mnemonic
, "bound") != 0)
2884 && (strcmp (mnemonic
, "invlpga") != 0)
2885 && !(operand_type_check (i
.types
[0], imm
)
2886 && operand_type_check (i
.types
[1], imm
)))
2889 /* The order of the immediates should be reversed
2890 for 2 immediates extrq and insertq instructions */
2891 if (i
.imm_operands
== 2
2892 && (strcmp (mnemonic
, "extrq") == 0
2893 || strcmp (mnemonic
, "insertq") == 0))
2894 swap_2_operands (0, 1);
2899 /* Don't optimize displacement for movabs since it only takes 64bit
2902 && (flag_code
!= CODE_64BIT
2903 || strcmp (mnemonic
, "movabs") != 0))
2906 /* Next, we find a template that matches the given insn,
2907 making sure the overlap of the given operands types is consistent
2908 with the template operand types. */
2910 if (!(t
= match_template ()))
2913 if (sse_check
!= sse_check_none
2914 && !i
.tm
.opcode_modifier
.noavx
2915 && (i
.tm
.cpu_flags
.bitfield
.cpusse
2916 || i
.tm
.cpu_flags
.bitfield
.cpusse2
2917 || i
.tm
.cpu_flags
.bitfield
.cpusse3
2918 || i
.tm
.cpu_flags
.bitfield
.cpussse3
2919 || i
.tm
.cpu_flags
.bitfield
.cpusse4_1
2920 || i
.tm
.cpu_flags
.bitfield
.cpusse4_2
))
2922 (sse_check
== sse_check_warning
2924 : as_bad
) (_("SSE instruction `%s' is used"), i
.tm
.name
);
2927 /* Zap movzx and movsx suffix. The suffix has been set from
2928 "word ptr" or "byte ptr" on the source operand in Intel syntax
2929 or extracted from mnemonic in AT&T syntax. But we'll use
2930 the destination register to choose the suffix for encoding. */
2931 if ((i
.tm
.base_opcode
& ~9) == 0x0fb6)
2933 /* In Intel syntax, there must be a suffix. In AT&T syntax, if
2934 there is no suffix, the default will be byte extension. */
2935 if (i
.reg_operands
!= 2
2938 as_bad (_("ambiguous operand size for `%s'"), i
.tm
.name
);
2943 if (i
.tm
.opcode_modifier
.fwait
)
2944 if (!add_prefix (FWAIT_OPCODE
))
2947 /* Check for lock without a lockable instruction. Destination operand
2948 must be memory unless it is xchg (0x86). */
2949 if (i
.prefix
[LOCK_PREFIX
]
2950 && (!i
.tm
.opcode_modifier
.islockable
2951 || i
.mem_operands
== 0
2952 || (i
.tm
.base_opcode
!= 0x86
2953 && !operand_type_check (i
.types
[i
.operands
- 1], anymem
))))
2955 as_bad (_("expecting lockable instruction after `lock'"));
2959 /* Check string instruction segment overrides. */
2960 if (i
.tm
.opcode_modifier
.isstring
&& i
.mem_operands
!= 0)
2962 if (!check_string ())
2964 i
.disp_operands
= 0;
2967 if (!process_suffix ())
2970 /* Update operand types. */
2971 for (j
= 0; j
< i
.operands
; j
++)
2972 i
.types
[j
] = operand_type_and (i
.types
[j
], i
.tm
.operand_types
[j
]);
2974 /* Make still unresolved immediate matches conform to size of immediate
2975 given in i.suffix. */
2976 if (!finalize_imm ())
2979 if (i
.types
[0].bitfield
.imm1
)
2980 i
.imm_operands
= 0; /* kludge for shift insns. */
2982 /* We only need to check those implicit registers for instructions
2983 with 3 operands or less. */
2984 if (i
.operands
<= 3)
2985 for (j
= 0; j
< i
.operands
; j
++)
2986 if (i
.types
[j
].bitfield
.inoutportreg
2987 || i
.types
[j
].bitfield
.shiftcount
2988 || i
.types
[j
].bitfield
.acc
2989 || i
.types
[j
].bitfield
.floatacc
)
2992 /* ImmExt should be processed after SSE2AVX. */
2993 if (!i
.tm
.opcode_modifier
.sse2avx
2994 && i
.tm
.opcode_modifier
.immext
)
2997 /* For insns with operands there are more diddles to do to the opcode. */
3000 if (!process_operands ())
3003 else if (!quiet_warnings
&& i
.tm
.opcode_modifier
.ugh
)
3005 /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc. */
3006 as_warn (_("translating to `%sp'"), i
.tm
.name
);
3009 if (i
.tm
.opcode_modifier
.vex
)
3010 build_vex_prefix (t
);
3012 /* Handle conversion of 'int $3' --> special int3 insn. XOP or FMA4
3013 instructions may define INT_OPCODE as well, so avoid this corner
3014 case for those instructions that use MODRM. */
3015 if (i
.tm
.base_opcode
== INT_OPCODE
3016 && i
.op
[0].imms
->X_add_number
== 3
3017 && !i
.tm
.opcode_modifier
.modrm
)
3019 i
.tm
.base_opcode
= INT3_OPCODE
;
3023 if ((i
.tm
.opcode_modifier
.jump
3024 || i
.tm
.opcode_modifier
.jumpbyte
3025 || i
.tm
.opcode_modifier
.jumpdword
)
3026 && i
.op
[0].disps
->X_op
== O_constant
)
3028 /* Convert "jmp constant" (and "call constant") to a jump (call) to
3029 the absolute address given by the constant. Since ix86 jumps and
3030 calls are pc relative, we need to generate a reloc. */
3031 i
.op
[0].disps
->X_add_symbol
= &abs_symbol
;
3032 i
.op
[0].disps
->X_op
= O_symbol
;
3035 if (i
.tm
.opcode_modifier
.rex64
)
3038 /* For 8 bit registers we need an empty rex prefix. Also if the
3039 instruction already has a prefix, we need to convert old
3040 registers to new ones. */
3042 if ((i
.types
[0].bitfield
.reg8
3043 && (i
.op
[0].regs
->reg_flags
& RegRex64
) != 0)
3044 || (i
.types
[1].bitfield
.reg8
3045 && (i
.op
[1].regs
->reg_flags
& RegRex64
) != 0)
3046 || ((i
.types
[0].bitfield
.reg8
3047 || i
.types
[1].bitfield
.reg8
)
3052 i
.rex
|= REX_OPCODE
;
3053 for (x
= 0; x
< 2; x
++)
3055 /* Look for 8 bit operand that uses old registers. */
3056 if (i
.types
[x
].bitfield
.reg8
3057 && (i
.op
[x
].regs
->reg_flags
& RegRex64
) == 0)
3059 /* In case it is "hi" register, give up. */
3060 if (i
.op
[x
].regs
->reg_num
> 3)
3061 as_bad (_("can't encode register '%s%s' in an "
3062 "instruction requiring REX prefix."),
3063 register_prefix
, i
.op
[x
].regs
->reg_name
);
3065 /* Otherwise it is equivalent to the extended register.
3066 Since the encoding doesn't change this is merely
3067 cosmetic cleanup for debug output. */
3069 i
.op
[x
].regs
= i
.op
[x
].regs
+ 8;
3075 add_prefix (REX_OPCODE
| i
.rex
);
3077 /* We are ready to output the insn. */
3082 parse_insn (char *line
, char *mnemonic
)
3085 char *token_start
= l
;
3088 const insn_template
*t
;
3091 /* Non-zero if we found a prefix only acceptable with string insns. */
3092 const char *expecting_string_instruction
= NULL
;
3097 while ((*mnem_p
= mnemonic_chars
[(unsigned char) *l
]) != 0)
3102 if (mnem_p
>= mnemonic
+ MAX_MNEM_SIZE
)
3104 as_bad (_("no such instruction: `%s'"), token_start
);
3109 if (!is_space_char (*l
)
3110 && *l
!= END_OF_INSN
3112 || (*l
!= PREFIX_SEPARATOR
3115 as_bad (_("invalid character %s in mnemonic"),
3116 output_invalid (*l
));
3119 if (token_start
== l
)
3121 if (!intel_syntax
&& *l
== PREFIX_SEPARATOR
)
3122 as_bad (_("expecting prefix; got nothing"));
3124 as_bad (_("expecting mnemonic; got nothing"));
3128 /* Look up instruction (or prefix) via hash table. */
3129 current_templates
= (const templates
*) hash_find (op_hash
, mnemonic
);
3131 if (*l
!= END_OF_INSN
3132 && (!is_space_char (*l
) || l
[1] != END_OF_INSN
)
3133 && current_templates
3134 && current_templates
->start
->opcode_modifier
.isprefix
)
3136 if (!cpu_flags_check_cpu64 (current_templates
->start
->cpu_flags
))
3138 as_bad ((flag_code
!= CODE_64BIT
3139 ? _("`%s' is only supported in 64-bit mode")
3140 : _("`%s' is not supported in 64-bit mode")),
3141 current_templates
->start
->name
);
3144 /* If we are in 16-bit mode, do not allow addr16 or data16.
3145 Similarly, in 32-bit mode, do not allow addr32 or data32. */
3146 if ((current_templates
->start
->opcode_modifier
.size16
3147 || current_templates
->start
->opcode_modifier
.size32
)
3148 && flag_code
!= CODE_64BIT
3149 && (current_templates
->start
->opcode_modifier
.size32
3150 ^ (flag_code
== CODE_16BIT
)))
3152 as_bad (_("redundant %s prefix"),
3153 current_templates
->start
->name
);
3156 /* Add prefix, checking for repeated prefixes. */
3157 switch (add_prefix (current_templates
->start
->base_opcode
))
3162 expecting_string_instruction
= current_templates
->start
->name
;
3167 /* Skip past PREFIX_SEPARATOR and reset token_start. */
3174 if (!current_templates
)
3176 /* Check if we should swap operand in encoding. */
3177 if (mnem_p
- 2 == dot_p
&& dot_p
[1] == 's')
3183 current_templates
= (const templates
*) hash_find (op_hash
, mnemonic
);
3186 if (!current_templates
)
3189 /* See if we can get a match by trimming off a suffix. */
3192 case WORD_MNEM_SUFFIX
:
3193 if (intel_syntax
&& (intel_float_operand (mnemonic
) & 2))
3194 i
.suffix
= SHORT_MNEM_SUFFIX
;
3196 case BYTE_MNEM_SUFFIX
:
3197 case QWORD_MNEM_SUFFIX
:
3198 i
.suffix
= mnem_p
[-1];
3200 current_templates
= (const templates
*) hash_find (op_hash
,
3203 case SHORT_MNEM_SUFFIX
:
3204 case LONG_MNEM_SUFFIX
:
3207 i
.suffix
= mnem_p
[-1];
3209 current_templates
= (const templates
*) hash_find (op_hash
,
3218 if (intel_float_operand (mnemonic
) == 1)
3219 i
.suffix
= SHORT_MNEM_SUFFIX
;
3221 i
.suffix
= LONG_MNEM_SUFFIX
;
3223 current_templates
= (const templates
*) hash_find (op_hash
,
3228 if (!current_templates
)
3230 as_bad (_("no such instruction: `%s'"), token_start
);
3235 if (current_templates
->start
->opcode_modifier
.jump
3236 || current_templates
->start
->opcode_modifier
.jumpbyte
)
3238 /* Check for a branch hint. We allow ",pt" and ",pn" for
3239 predict taken and predict not taken respectively.
3240 I'm not sure that branch hints actually do anything on loop
3241 and jcxz insns (JumpByte) for current Pentium4 chips. They
3242 may work in the future and it doesn't hurt to accept them
3244 if (l
[0] == ',' && l
[1] == 'p')
3248 if (!add_prefix (DS_PREFIX_OPCODE
))
3252 else if (l
[2] == 'n')
3254 if (!add_prefix (CS_PREFIX_OPCODE
))
3260 /* Any other comma loses. */
3263 as_bad (_("invalid character %s in mnemonic"),
3264 output_invalid (*l
));
3268 /* Check if instruction is supported on specified architecture. */
3270 for (t
= current_templates
->start
; t
< current_templates
->end
; ++t
)
3272 supported
|= cpu_flags_match (t
);
3273 if (supported
== CPU_FLAGS_PERFECT_MATCH
)
3277 if (!(supported
& CPU_FLAGS_64BIT_MATCH
))
3279 as_bad (flag_code
== CODE_64BIT
3280 ? _("`%s' is not supported in 64-bit mode")
3281 : _("`%s' is only supported in 64-bit mode"),
3282 current_templates
->start
->name
);
3285 if (supported
!= CPU_FLAGS_PERFECT_MATCH
)
3287 as_bad (_("`%s' is not supported on `%s%s'"),
3288 current_templates
->start
->name
,
3289 cpu_arch_name
? cpu_arch_name
: default_arch
,
3290 cpu_sub_arch_name
? cpu_sub_arch_name
: "");
3295 if (!cpu_arch_flags
.bitfield
.cpui386
3296 && (flag_code
!= CODE_16BIT
))
3298 as_warn (_("use .code16 to ensure correct addressing mode"));
3301 /* Check for rep/repne without a string instruction. */
3302 if (expecting_string_instruction
)
3304 static templates override
;
3306 for (t
= current_templates
->start
; t
< current_templates
->end
; ++t
)
3307 if (t
->opcode_modifier
.isstring
)
3309 if (t
>= current_templates
->end
)
3311 as_bad (_("expecting string instruction after `%s'"),
3312 expecting_string_instruction
);
3315 for (override
.start
= t
; t
< current_templates
->end
; ++t
)
3316 if (!t
->opcode_modifier
.isstring
)
3319 current_templates
= &override
;
3326 parse_operands (char *l
, const char *mnemonic
)
3330 /* 1 if operand is pending after ','. */
3331 unsigned int expecting_operand
= 0;
3333 /* Non-zero if operand parens not balanced. */
3334 unsigned int paren_not_balanced
;
3336 while (*l
!= END_OF_INSN
)
3338 /* Skip optional white space before operand. */
3339 if (is_space_char (*l
))
3341 if (!is_operand_char (*l
) && *l
!= END_OF_INSN
)
3343 as_bad (_("invalid character %s before operand %d"),
3344 output_invalid (*l
),
3348 token_start
= l
; /* after white space */
3349 paren_not_balanced
= 0;
3350 while (paren_not_balanced
|| *l
!= ',')
3352 if (*l
== END_OF_INSN
)
3354 if (paren_not_balanced
)
3357 as_bad (_("unbalanced parenthesis in operand %d."),
3360 as_bad (_("unbalanced brackets in operand %d."),
3365 break; /* we are done */
3367 else if (!is_operand_char (*l
) && !is_space_char (*l
))
3369 as_bad (_("invalid character %s in operand %d"),
3370 output_invalid (*l
),
3377 ++paren_not_balanced
;
3379 --paren_not_balanced
;
3384 ++paren_not_balanced
;
3386 --paren_not_balanced
;
3390 if (l
!= token_start
)
3391 { /* Yes, we've read in another operand. */
3392 unsigned int operand_ok
;
3393 this_operand
= i
.operands
++;
3394 i
.types
[this_operand
].bitfield
.unspecified
= 1;
3395 if (i
.operands
> MAX_OPERANDS
)
3397 as_bad (_("spurious operands; (%d operands/instruction max)"),
3401 /* Now parse operand adding info to 'i' as we go along. */
3402 END_STRING_AND_SAVE (l
);
3406 i386_intel_operand (token_start
,
3407 intel_float_operand (mnemonic
));
3409 operand_ok
= i386_att_operand (token_start
);
3411 RESTORE_END_STRING (l
);
3417 if (expecting_operand
)
3419 expecting_operand_after_comma
:
3420 as_bad (_("expecting operand after ','; got nothing"));
3425 as_bad (_("expecting operand before ','; got nothing"));
3430 /* Now *l must be either ',' or END_OF_INSN. */
3433 if (*++l
== END_OF_INSN
)
3435 /* Just skip it, if it's \n complain. */
3436 goto expecting_operand_after_comma
;
3438 expecting_operand
= 1;
3445 swap_2_operands (int xchg1
, int xchg2
)
3447 union i386_op temp_op
;
3448 i386_operand_type temp_type
;
3449 enum bfd_reloc_code_real temp_reloc
;
3451 temp_type
= i
.types
[xchg2
];
3452 i
.types
[xchg2
] = i
.types
[xchg1
];
3453 i
.types
[xchg1
] = temp_type
;
3454 temp_op
= i
.op
[xchg2
];
3455 i
.op
[xchg2
] = i
.op
[xchg1
];
3456 i
.op
[xchg1
] = temp_op
;
3457 temp_reloc
= i
.reloc
[xchg2
];
3458 i
.reloc
[xchg2
] = i
.reloc
[xchg1
];
3459 i
.reloc
[xchg1
] = temp_reloc
;
3463 swap_operands (void)
3469 swap_2_operands (1, i
.operands
- 2);
3472 swap_2_operands (0, i
.operands
- 1);
3478 if (i
.mem_operands
== 2)
3480 const seg_entry
*temp_seg
;
3481 temp_seg
= i
.seg
[0];
3482 i
.seg
[0] = i
.seg
[1];
3483 i
.seg
[1] = temp_seg
;
3487 /* Try to ensure constant immediates are represented in the smallest
3492 char guess_suffix
= 0;
3496 guess_suffix
= i
.suffix
;
3497 else if (i
.reg_operands
)
3499 /* Figure out a suffix from the last register operand specified.
3500 We can't do this properly yet, ie. excluding InOutPortReg,
3501 but the following works for instructions with immediates.
3502 In any case, we can't set i.suffix yet. */
3503 for (op
= i
.operands
; --op
>= 0;)
3504 if (i
.types
[op
].bitfield
.reg8
)
3506 guess_suffix
= BYTE_MNEM_SUFFIX
;
3509 else if (i
.types
[op
].bitfield
.reg16
)
3511 guess_suffix
= WORD_MNEM_SUFFIX
;
3514 else if (i
.types
[op
].bitfield
.reg32
)
3516 guess_suffix
= LONG_MNEM_SUFFIX
;
3519 else if (i
.types
[op
].bitfield
.reg64
)
3521 guess_suffix
= QWORD_MNEM_SUFFIX
;
3525 else if ((flag_code
== CODE_16BIT
) ^ (i
.prefix
[DATA_PREFIX
] != 0))
3526 guess_suffix
= WORD_MNEM_SUFFIX
;
3528 for (op
= i
.operands
; --op
>= 0;)
3529 if (operand_type_check (i
.types
[op
], imm
))
3531 switch (i
.op
[op
].imms
->X_op
)
3534 /* If a suffix is given, this operand may be shortened. */
3535 switch (guess_suffix
)
3537 case LONG_MNEM_SUFFIX
:
3538 i
.types
[op
].bitfield
.imm32
= 1;
3539 i
.types
[op
].bitfield
.imm64
= 1;
3541 case WORD_MNEM_SUFFIX
:
3542 i
.types
[op
].bitfield
.imm16
= 1;
3543 i
.types
[op
].bitfield
.imm32
= 1;
3544 i
.types
[op
].bitfield
.imm32s
= 1;
3545 i
.types
[op
].bitfield
.imm64
= 1;
3547 case BYTE_MNEM_SUFFIX
:
3548 i
.types
[op
].bitfield
.imm8
= 1;
3549 i
.types
[op
].bitfield
.imm8s
= 1;
3550 i
.types
[op
].bitfield
.imm16
= 1;
3551 i
.types
[op
].bitfield
.imm32
= 1;
3552 i
.types
[op
].bitfield
.imm32s
= 1;
3553 i
.types
[op
].bitfield
.imm64
= 1;
3557 /* If this operand is at most 16 bits, convert it
3558 to a signed 16 bit number before trying to see
3559 whether it will fit in an even smaller size.
3560 This allows a 16-bit operand such as $0xffe0 to
3561 be recognised as within Imm8S range. */
3562 if ((i
.types
[op
].bitfield
.imm16
)
3563 && (i
.op
[op
].imms
->X_add_number
& ~(offsetT
) 0xffff) == 0)
3565 i
.op
[op
].imms
->X_add_number
=
3566 (((i
.op
[op
].imms
->X_add_number
& 0xffff) ^ 0x8000) - 0x8000);
3568 if ((i
.types
[op
].bitfield
.imm32
)
3569 && ((i
.op
[op
].imms
->X_add_number
& ~(((offsetT
) 2 << 31) - 1))
3572 i
.op
[op
].imms
->X_add_number
= ((i
.op
[op
].imms
->X_add_number
3573 ^ ((offsetT
) 1 << 31))
3574 - ((offsetT
) 1 << 31));
3577 = operand_type_or (i
.types
[op
],
3578 smallest_imm_type (i
.op
[op
].imms
->X_add_number
));
3580 /* We must avoid matching of Imm32 templates when 64bit
3581 only immediate is available. */
3582 if (guess_suffix
== QWORD_MNEM_SUFFIX
)
3583 i
.types
[op
].bitfield
.imm32
= 0;
3590 /* Symbols and expressions. */
3592 /* Convert symbolic operand to proper sizes for matching, but don't
3593 prevent matching a set of insns that only supports sizes other
3594 than those matching the insn suffix. */
3596 i386_operand_type mask
, allowed
;
3597 const insn_template
*t
;
3599 operand_type_set (&mask
, 0);
3600 operand_type_set (&allowed
, 0);
3602 for (t
= current_templates
->start
;
3603 t
< current_templates
->end
;
3605 allowed
= operand_type_or (allowed
,
3606 t
->operand_types
[op
]);
3607 switch (guess_suffix
)
3609 case QWORD_MNEM_SUFFIX
:
3610 mask
.bitfield
.imm64
= 1;
3611 mask
.bitfield
.imm32s
= 1;
3613 case LONG_MNEM_SUFFIX
:
3614 mask
.bitfield
.imm32
= 1;
3616 case WORD_MNEM_SUFFIX
:
3617 mask
.bitfield
.imm16
= 1;
3619 case BYTE_MNEM_SUFFIX
:
3620 mask
.bitfield
.imm8
= 1;
3625 allowed
= operand_type_and (mask
, allowed
);
3626 if (!operand_type_all_zero (&allowed
))
3627 i
.types
[op
] = operand_type_and (i
.types
[op
], mask
);
3634 /* Try to use the smallest displacement type too. */
3636 optimize_disp (void)
3640 for (op
= i
.operands
; --op
>= 0;)
3641 if (operand_type_check (i
.types
[op
], disp
))
3643 if (i
.op
[op
].disps
->X_op
== O_constant
)
3645 offsetT op_disp
= i
.op
[op
].disps
->X_add_number
;
3647 if (i
.types
[op
].bitfield
.disp16
3648 && (op_disp
& ~(offsetT
) 0xffff) == 0)
3650 /* If this operand is at most 16 bits, convert
3651 to a signed 16 bit number and don't use 64bit
3653 op_disp
= (((op_disp
& 0xffff) ^ 0x8000) - 0x8000);
3654 i
.types
[op
].bitfield
.disp64
= 0;
3656 if (i
.types
[op
].bitfield
.disp32
3657 && (op_disp
& ~(((offsetT
) 2 << 31) - 1)) == 0)
3659 /* If this operand is at most 32 bits, convert
3660 to a signed 32 bit number and don't use 64bit
3662 op_disp
&= (((offsetT
) 2 << 31) - 1);
3663 op_disp
= (op_disp
^ ((offsetT
) 1 << 31)) - ((addressT
) 1 << 31);
3664 i
.types
[op
].bitfield
.disp64
= 0;
3666 if (!op_disp
&& i
.types
[op
].bitfield
.baseindex
)
3668 i
.types
[op
].bitfield
.disp8
= 0;
3669 i
.types
[op
].bitfield
.disp16
= 0;
3670 i
.types
[op
].bitfield
.disp32
= 0;
3671 i
.types
[op
].bitfield
.disp32s
= 0;
3672 i
.types
[op
].bitfield
.disp64
= 0;
3676 else if (flag_code
== CODE_64BIT
)
3678 if (fits_in_signed_long (op_disp
))
3680 i
.types
[op
].bitfield
.disp64
= 0;
3681 i
.types
[op
].bitfield
.disp32s
= 1;
3683 if (i
.prefix
[ADDR_PREFIX
]
3684 && fits_in_unsigned_long (op_disp
))
3685 i
.types
[op
].bitfield
.disp32
= 1;
3687 if ((i
.types
[op
].bitfield
.disp32
3688 || i
.types
[op
].bitfield
.disp32s
3689 || i
.types
[op
].bitfield
.disp16
)
3690 && fits_in_signed_byte (op_disp
))
3691 i
.types
[op
].bitfield
.disp8
= 1;
3693 else if (i
.reloc
[op
] == BFD_RELOC_386_TLS_DESC_CALL
3694 || i
.reloc
[op
] == BFD_RELOC_X86_64_TLSDESC_CALL
)
3696 fix_new_exp (frag_now
, frag_more (0) - frag_now
->fr_literal
, 0,
3697 i
.op
[op
].disps
, 0, i
.reloc
[op
]);
3698 i
.types
[op
].bitfield
.disp8
= 0;
3699 i
.types
[op
].bitfield
.disp16
= 0;
3700 i
.types
[op
].bitfield
.disp32
= 0;
3701 i
.types
[op
].bitfield
.disp32s
= 0;
3702 i
.types
[op
].bitfield
.disp64
= 0;
3705 /* We only support 64bit displacement on constants. */
3706 i
.types
[op
].bitfield
.disp64
= 0;
3710 static const insn_template
*
3711 match_template (void)
3713 /* Points to template once we've found it. */
3714 const insn_template
*t
;
3715 i386_operand_type overlap0
, overlap1
, overlap2
, overlap3
;
3716 i386_operand_type overlap4
;
3717 unsigned int found_reverse_match
;
3718 i386_opcode_modifier suffix_check
;
3719 i386_operand_type operand_types
[MAX_OPERANDS
];
3720 int addr_prefix_disp
;
3722 unsigned int found_cpu_match
;
3723 unsigned int check_register
;
3725 #if MAX_OPERANDS != 5
3726 # error "MAX_OPERANDS must be 5."
3729 found_reverse_match
= 0;
3730 addr_prefix_disp
= -1;
3732 memset (&suffix_check
, 0, sizeof (suffix_check
));
3733 if (i
.suffix
== BYTE_MNEM_SUFFIX
)
3734 suffix_check
.no_bsuf
= 1;
3735 else if (i
.suffix
== WORD_MNEM_SUFFIX
)
3736 suffix_check
.no_wsuf
= 1;
3737 else if (i
.suffix
== SHORT_MNEM_SUFFIX
)
3738 suffix_check
.no_ssuf
= 1;
3739 else if (i
.suffix
== LONG_MNEM_SUFFIX
)
3740 suffix_check
.no_lsuf
= 1;
3741 else if (i
.suffix
== QWORD_MNEM_SUFFIX
)
3742 suffix_check
.no_qsuf
= 1;
3743 else if (i
.suffix
== LONG_DOUBLE_MNEM_SUFFIX
)
3744 suffix_check
.no_ldsuf
= 1;
3746 for (t
= current_templates
->start
; t
< current_templates
->end
; t
++)
3748 addr_prefix_disp
= -1;
3750 /* Must have right number of operands. */
3751 if (i
.operands
!= t
->operands
)
3754 /* Check processor support. */
3755 found_cpu_match
= (cpu_flags_match (t
)
3756 == CPU_FLAGS_PERFECT_MATCH
);
3757 if (!found_cpu_match
)
3760 /* Check old gcc support. */
3761 if (!old_gcc
&& t
->opcode_modifier
.oldgcc
)
3764 /* Check AT&T mnemonic. */
3765 if (intel_mnemonic
&& t
->opcode_modifier
.attmnemonic
)
3768 /* Check AT&T syntax Intel syntax. */
3769 if ((intel_syntax
&& t
->opcode_modifier
.attsyntax
)
3770 || (!intel_syntax
&& t
->opcode_modifier
.intelsyntax
))
3773 /* Check the suffix, except for some instructions in intel mode. */
3774 if ((!intel_syntax
|| !t
->opcode_modifier
.ignoresize
)
3775 && ((t
->opcode_modifier
.no_bsuf
&& suffix_check
.no_bsuf
)
3776 || (t
->opcode_modifier
.no_wsuf
&& suffix_check
.no_wsuf
)
3777 || (t
->opcode_modifier
.no_lsuf
&& suffix_check
.no_lsuf
)
3778 || (t
->opcode_modifier
.no_ssuf
&& suffix_check
.no_ssuf
)
3779 || (t
->opcode_modifier
.no_qsuf
&& suffix_check
.no_qsuf
)
3780 || (t
->opcode_modifier
.no_ldsuf
&& suffix_check
.no_ldsuf
)))
3783 if (!operand_size_match (t
))
3786 for (j
= 0; j
< MAX_OPERANDS
; j
++)
3787 operand_types
[j
] = t
->operand_types
[j
];
3789 /* In general, don't allow 64-bit operands in 32-bit mode. */
3790 if (i
.suffix
== QWORD_MNEM_SUFFIX
3791 && flag_code
!= CODE_64BIT
3793 ? (!t
->opcode_modifier
.ignoresize
3794 && !intel_float_operand (t
->name
))
3795 : intel_float_operand (t
->name
) != 2)
3796 && ((!operand_types
[0].bitfield
.regmmx
3797 && !operand_types
[0].bitfield
.regxmm
3798 && !operand_types
[0].bitfield
.regymm
)
3799 || (!operand_types
[t
->operands
> 1].bitfield
.regmmx
3800 && !!operand_types
[t
->operands
> 1].bitfield
.regxmm
3801 && !!operand_types
[t
->operands
> 1].bitfield
.regymm
))
3802 && (t
->base_opcode
!= 0x0fc7
3803 || t
->extension_opcode
!= 1 /* cmpxchg8b */))
3806 /* In general, don't allow 32-bit operands on pre-386. */
3807 else if (i
.suffix
== LONG_MNEM_SUFFIX
3808 && !cpu_arch_flags
.bitfield
.cpui386
3810 ? (!t
->opcode_modifier
.ignoresize
3811 && !intel_float_operand (t
->name
))
3812 : intel_float_operand (t
->name
) != 2)
3813 && ((!operand_types
[0].bitfield
.regmmx
3814 && !operand_types
[0].bitfield
.regxmm
)
3815 || (!operand_types
[t
->operands
> 1].bitfield
.regmmx
3816 && !!operand_types
[t
->operands
> 1].bitfield
.regxmm
)))
3819 /* Do not verify operands when there are none. */
3823 /* We've found a match; break out of loop. */
3827 /* Address size prefix will turn Disp64/Disp32/Disp16 operand
3828 into Disp32/Disp16/Disp32 operand. */
3829 if (i
.prefix
[ADDR_PREFIX
] != 0)
3831 /* There should be only one Disp operand. */
3835 for (j
= 0; j
< MAX_OPERANDS
; j
++)
3837 if (operand_types
[j
].bitfield
.disp16
)
3839 addr_prefix_disp
= j
;
3840 operand_types
[j
].bitfield
.disp32
= 1;
3841 operand_types
[j
].bitfield
.disp16
= 0;
3847 for (j
= 0; j
< MAX_OPERANDS
; j
++)
3849 if (operand_types
[j
].bitfield
.disp32
)
3851 addr_prefix_disp
= j
;
3852 operand_types
[j
].bitfield
.disp32
= 0;
3853 operand_types
[j
].bitfield
.disp16
= 1;
3859 for (j
= 0; j
< MAX_OPERANDS
; j
++)
3861 if (operand_types
[j
].bitfield
.disp64
)
3863 addr_prefix_disp
= j
;
3864 operand_types
[j
].bitfield
.disp64
= 0;
3865 operand_types
[j
].bitfield
.disp32
= 1;
3873 /* We check register size only if size of operands can be
3874 encoded the canonical way. */
3875 check_register
= t
->opcode_modifier
.w
;
3876 overlap0
= operand_type_and (i
.types
[0], operand_types
[0]);
3877 switch (t
->operands
)
3880 if (!operand_type_match (overlap0
, i
.types
[0]))
3884 /* xchg %eax, %eax is a special case. It is an aliase for nop
3885 only in 32bit mode and we can use opcode 0x90. In 64bit
3886 mode, we can't use 0x90 for xchg %eax, %eax since it should
3887 zero-extend %eax to %rax. */
3888 if (flag_code
== CODE_64BIT
3889 && t
->base_opcode
== 0x90
3890 && operand_type_equal (&i
.types
[0], &acc32
)
3891 && operand_type_equal (&i
.types
[1], &acc32
))
3895 /* If we swap operand in encoding, we either match
3896 the next one or reverse direction of operands. */
3897 if (t
->opcode_modifier
.s
)
3899 else if (t
->opcode_modifier
.d
)
3904 /* If we swap operand in encoding, we match the next one. */
3905 if (i
.swap_operand
&& t
->opcode_modifier
.s
)
3909 overlap1
= operand_type_and (i
.types
[1], operand_types
[1]);
3910 if (!operand_type_match (overlap0
, i
.types
[0])
3911 || !operand_type_match (overlap1
, i
.types
[1])
3913 && !operand_type_register_match (overlap0
, i
.types
[0],
3915 overlap1
, i
.types
[1],
3918 /* Check if other direction is valid ... */
3919 if (!t
->opcode_modifier
.d
&& !t
->opcode_modifier
.floatd
)
3923 /* Try reversing direction of operands. */
3924 overlap0
= operand_type_and (i
.types
[0], operand_types
[1]);
3925 overlap1
= operand_type_and (i
.types
[1], operand_types
[0]);
3926 if (!operand_type_match (overlap0
, i
.types
[0])
3927 || !operand_type_match (overlap1
, i
.types
[1])
3929 && !operand_type_register_match (overlap0
,
3936 /* Does not match either direction. */
3939 /* found_reverse_match holds which of D or FloatDR
3941 if (t
->opcode_modifier
.d
)
3942 found_reverse_match
= Opcode_D
;
3943 else if (t
->opcode_modifier
.floatd
)
3944 found_reverse_match
= Opcode_FloatD
;
3946 found_reverse_match
= 0;
3947 if (t
->opcode_modifier
.floatr
)
3948 found_reverse_match
|= Opcode_FloatR
;
3952 /* Found a forward 2 operand match here. */
3953 switch (t
->operands
)
3956 overlap4
= operand_type_and (i
.types
[4],
3959 overlap3
= operand_type_and (i
.types
[3],
3962 overlap2
= operand_type_and (i
.types
[2],
3967 switch (t
->operands
)
3970 if (!operand_type_match (overlap4
, i
.types
[4])
3971 || !operand_type_register_match (overlap3
,
3979 if (!operand_type_match (overlap3
, i
.types
[3])
3981 && !operand_type_register_match (overlap2
,
3989 /* Here we make use of the fact that there are no
3990 reverse match 3 operand instructions, and all 3
3991 operand instructions only need to be checked for
3992 register consistency between operands 2 and 3. */
3993 if (!operand_type_match (overlap2
, i
.types
[2])
3995 && !operand_type_register_match (overlap1
,
4005 /* Found either forward/reverse 2, 3 or 4 operand match here:
4006 slip through to break. */
4008 if (!found_cpu_match
)
4010 found_reverse_match
= 0;
4014 /* We've found a match; break out of loop. */
4018 if (t
== current_templates
->end
)
4020 /* We found no match. */
4022 as_bad (_("ambiguous operand size or operands invalid for `%s'"),
4023 current_templates
->start
->name
);
4025 as_bad (_("suffix or operands invalid for `%s'"),
4026 current_templates
->start
->name
);
4030 if (!quiet_warnings
)
4033 && (i
.types
[0].bitfield
.jumpabsolute
4034 != operand_types
[0].bitfield
.jumpabsolute
))
4036 as_warn (_("indirect %s without `*'"), t
->name
);
4039 if (t
->opcode_modifier
.isprefix
4040 && t
->opcode_modifier
.ignoresize
)
4042 /* Warn them that a data or address size prefix doesn't
4043 affect assembly of the next line of code. */
4044 as_warn (_("stand-alone `%s' prefix"), t
->name
);
4048 /* Copy the template we found. */
4051 if (addr_prefix_disp
!= -1)
4052 i
.tm
.operand_types
[addr_prefix_disp
]
4053 = operand_types
[addr_prefix_disp
];
4055 if (found_reverse_match
)
4057 /* If we found a reverse match we must alter the opcode
4058 direction bit. found_reverse_match holds bits to change
4059 (different for int & float insns). */
4061 i
.tm
.base_opcode
^= found_reverse_match
;
4063 i
.tm
.operand_types
[0] = operand_types
[1];
4064 i
.tm
.operand_types
[1] = operand_types
[0];
4073 int mem_op
= operand_type_check (i
.types
[0], anymem
) ? 0 : 1;
4074 if (i
.tm
.operand_types
[mem_op
].bitfield
.esseg
)
4076 if (i
.seg
[0] != NULL
&& i
.seg
[0] != &es
)
4078 as_bad (_("`%s' operand %d must use `%ses' segment"),
4084 /* There's only ever one segment override allowed per instruction.
4085 This instruction possibly has a legal segment override on the
4086 second operand, so copy the segment to where non-string
4087 instructions store it, allowing common code. */
4088 i
.seg
[0] = i
.seg
[1];
4090 else if (i
.tm
.operand_types
[mem_op
+ 1].bitfield
.esseg
)
4092 if (i
.seg
[1] != NULL
&& i
.seg
[1] != &es
)
4094 as_bad (_("`%s' operand %d must use `%ses' segment"),
4105 process_suffix (void)
4107 /* If matched instruction specifies an explicit instruction mnemonic
4109 if (i
.tm
.opcode_modifier
.size16
)
4110 i
.suffix
= WORD_MNEM_SUFFIX
;
4111 else if (i
.tm
.opcode_modifier
.size32
)
4112 i
.suffix
= LONG_MNEM_SUFFIX
;
4113 else if (i
.tm
.opcode_modifier
.size64
)
4114 i
.suffix
= QWORD_MNEM_SUFFIX
;
4115 else if (i
.reg_operands
)
4117 /* If there's no instruction mnemonic suffix we try to invent one
4118 based on register operands. */
4121 /* We take i.suffix from the last register operand specified,
4122 Destination register type is more significant than source
4123 register type. crc32 in SSE4.2 prefers source register
4125 if (i
.tm
.base_opcode
== 0xf20f38f1)
4127 if (i
.types
[0].bitfield
.reg16
)
4128 i
.suffix
= WORD_MNEM_SUFFIX
;
4129 else if (i
.types
[0].bitfield
.reg32
)
4130 i
.suffix
= LONG_MNEM_SUFFIX
;
4131 else if (i
.types
[0].bitfield
.reg64
)
4132 i
.suffix
= QWORD_MNEM_SUFFIX
;
4134 else if (i
.tm
.base_opcode
== 0xf20f38f0)
4136 if (i
.types
[0].bitfield
.reg8
)
4137 i
.suffix
= BYTE_MNEM_SUFFIX
;
4144 if (i
.tm
.base_opcode
== 0xf20f38f1
4145 || i
.tm
.base_opcode
== 0xf20f38f0)
4147 /* We have to know the operand size for crc32. */
4148 as_bad (_("ambiguous memory operand size for `%s`"),
4153 for (op
= i
.operands
; --op
>= 0;)
4154 if (!i
.tm
.operand_types
[op
].bitfield
.inoutportreg
)
4156 if (i
.types
[op
].bitfield
.reg8
)
4158 i
.suffix
= BYTE_MNEM_SUFFIX
;
4161 else if (i
.types
[op
].bitfield
.reg16
)
4163 i
.suffix
= WORD_MNEM_SUFFIX
;
4166 else if (i
.types
[op
].bitfield
.reg32
)
4168 i
.suffix
= LONG_MNEM_SUFFIX
;
4171 else if (i
.types
[op
].bitfield
.reg64
)
4173 i
.suffix
= QWORD_MNEM_SUFFIX
;
4179 else if (i
.suffix
== BYTE_MNEM_SUFFIX
)
4181 if (!check_byte_reg ())
4184 else if (i
.suffix
== LONG_MNEM_SUFFIX
)
4186 if (!check_long_reg ())
4189 else if (i
.suffix
== QWORD_MNEM_SUFFIX
)
4192 && i
.tm
.opcode_modifier
.ignoresize
4193 && i
.tm
.opcode_modifier
.no_qsuf
)
4195 else if (!check_qword_reg ())
4198 else if (i
.suffix
== WORD_MNEM_SUFFIX
)
4200 if (!check_word_reg ())
4203 else if (i
.suffix
== XMMWORD_MNEM_SUFFIX
4204 || i
.suffix
== YMMWORD_MNEM_SUFFIX
)
4206 /* Skip if the instruction has x/y suffix. match_template
4207 should check if it is a valid suffix. */
4209 else if (intel_syntax
&& i
.tm
.opcode_modifier
.ignoresize
)
4210 /* Do nothing if the instruction is going to ignore the prefix. */
4215 else if (i
.tm
.opcode_modifier
.defaultsize
4217 /* exclude fldenv/frstor/fsave/fstenv */
4218 && i
.tm
.opcode_modifier
.no_ssuf
)
4220 i
.suffix
= stackop_size
;
4222 else if (intel_syntax
4224 && (i
.tm
.operand_types
[0].bitfield
.jumpabsolute
4225 || i
.tm
.opcode_modifier
.jumpbyte
4226 || i
.tm
.opcode_modifier
.jumpintersegment
4227 || (i
.tm
.base_opcode
== 0x0f01 /* [ls][gi]dt */
4228 && i
.tm
.extension_opcode
<= 3)))
4233 if (!i
.tm
.opcode_modifier
.no_qsuf
)
4235 i
.suffix
= QWORD_MNEM_SUFFIX
;
4239 if (!i
.tm
.opcode_modifier
.no_lsuf
)
4240 i
.suffix
= LONG_MNEM_SUFFIX
;
4243 if (!i
.tm
.opcode_modifier
.no_wsuf
)
4244 i
.suffix
= WORD_MNEM_SUFFIX
;
4253 if (i
.tm
.opcode_modifier
.w
)
4255 as_bad (_("no instruction mnemonic suffix given and "
4256 "no register operands; can't size instruction"));
4262 unsigned int suffixes
;
4264 suffixes
= !i
.tm
.opcode_modifier
.no_bsuf
;
4265 if (!i
.tm
.opcode_modifier
.no_wsuf
)
4267 if (!i
.tm
.opcode_modifier
.no_lsuf
)
4269 if (!i
.tm
.opcode_modifier
.no_ldsuf
)
4271 if (!i
.tm
.opcode_modifier
.no_ssuf
)
4273 if (!i
.tm
.opcode_modifier
.no_qsuf
)
4276 /* There are more than suffix matches. */
4277 if (i
.tm
.opcode_modifier
.w
4278 || ((suffixes
& (suffixes
- 1))
4279 && !i
.tm
.opcode_modifier
.defaultsize
4280 && !i
.tm
.opcode_modifier
.ignoresize
))
4282 as_bad (_("ambiguous operand size for `%s'"), i
.tm
.name
);
4288 /* Change the opcode based on the operand size given by i.suffix;
4289 We don't need to change things for byte insns. */
4292 && i
.suffix
!= BYTE_MNEM_SUFFIX
4293 && i
.suffix
!= XMMWORD_MNEM_SUFFIX
4294 && i
.suffix
!= YMMWORD_MNEM_SUFFIX
)
4296 /* It's not a byte, select word/dword operation. */
4297 if (i
.tm
.opcode_modifier
.w
)
4299 if (i
.tm
.opcode_modifier
.shortform
)
4300 i
.tm
.base_opcode
|= 8;
4302 i
.tm
.base_opcode
|= 1;
4305 /* Now select between word & dword operations via the operand
4306 size prefix, except for instructions that will ignore this
4308 if (i
.tm
.opcode_modifier
.addrprefixop0
)
4310 /* The address size override prefix changes the size of the
4312 if ((flag_code
== CODE_32BIT
4313 && i
.op
->regs
[0].reg_type
.bitfield
.reg16
)
4314 || (flag_code
!= CODE_32BIT
4315 && i
.op
->regs
[0].reg_type
.bitfield
.reg32
))
4316 if (!add_prefix (ADDR_PREFIX_OPCODE
))
4319 else if (i
.suffix
!= QWORD_MNEM_SUFFIX
4320 && i
.suffix
!= LONG_DOUBLE_MNEM_SUFFIX
4321 && !i
.tm
.opcode_modifier
.ignoresize
4322 && !i
.tm
.opcode_modifier
.floatmf
4323 && ((i
.suffix
== LONG_MNEM_SUFFIX
) == (flag_code
== CODE_16BIT
)
4324 || (flag_code
== CODE_64BIT
4325 && i
.tm
.opcode_modifier
.jumpbyte
)))
4327 unsigned int prefix
= DATA_PREFIX_OPCODE
;
4329 if (i
.tm
.opcode_modifier
.jumpbyte
) /* jcxz, loop */
4330 prefix
= ADDR_PREFIX_OPCODE
;
4332 if (!add_prefix (prefix
))
4336 /* Set mode64 for an operand. */
4337 if (i
.suffix
== QWORD_MNEM_SUFFIX
4338 && flag_code
== CODE_64BIT
4339 && !i
.tm
.opcode_modifier
.norex64
)
4341 /* Special case for xchg %rax,%rax. It is NOP and doesn't
4342 need rex64. cmpxchg8b is also a special case. */
4343 if (! (i
.operands
== 2
4344 && i
.tm
.base_opcode
== 0x90
4345 && i
.tm
.extension_opcode
== None
4346 && operand_type_equal (&i
.types
[0], &acc64
)
4347 && operand_type_equal (&i
.types
[1], &acc64
))
4348 && ! (i
.operands
== 1
4349 && i
.tm
.base_opcode
== 0xfc7
4350 && i
.tm
.extension_opcode
== 1
4351 && !operand_type_check (i
.types
[0], reg
)
4352 && operand_type_check (i
.types
[0], anymem
)))
4356 /* Size floating point instruction. */
4357 if (i
.suffix
== LONG_MNEM_SUFFIX
)
4358 if (i
.tm
.opcode_modifier
.floatmf
)
4359 i
.tm
.base_opcode
^= 4;
4366 check_byte_reg (void)
4370 for (op
= i
.operands
; --op
>= 0;)
4372 /* If this is an eight bit register, it's OK. If it's the 16 or
4373 32 bit version of an eight bit register, we will just use the
4374 low portion, and that's OK too. */
4375 if (i
.types
[op
].bitfield
.reg8
)
4378 /* Don't generate this warning if not needed. */
4379 if (intel_syntax
&& i
.tm
.opcode_modifier
.byteokintel
)
4382 /* crc32 doesn't generate this warning. */
4383 if (i
.tm
.base_opcode
== 0xf20f38f0)
4386 if ((i
.types
[op
].bitfield
.reg16
4387 || i
.types
[op
].bitfield
.reg32
4388 || i
.types
[op
].bitfield
.reg64
)
4389 && i
.op
[op
].regs
->reg_num
< 4)
4391 /* Prohibit these changes in the 64bit mode, since the
4392 lowering is more complicated. */
4393 if (flag_code
== CODE_64BIT
4394 && !i
.tm
.operand_types
[op
].bitfield
.inoutportreg
)
4396 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
4397 register_prefix
, i
.op
[op
].regs
->reg_name
,
4401 #if REGISTER_WARNINGS
4403 && !i
.tm
.operand_types
[op
].bitfield
.inoutportreg
)
4404 as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
4406 (i
.op
[op
].regs
+ (i
.types
[op
].bitfield
.reg16
4407 ? REGNAM_AL
- REGNAM_AX
4408 : REGNAM_AL
- REGNAM_EAX
))->reg_name
,
4410 i
.op
[op
].regs
->reg_name
,
4415 /* Any other register is bad. */
4416 if (i
.types
[op
].bitfield
.reg16
4417 || i
.types
[op
].bitfield
.reg32
4418 || i
.types
[op
].bitfield
.reg64
4419 || i
.types
[op
].bitfield
.regmmx
4420 || i
.types
[op
].bitfield
.regxmm
4421 || i
.types
[op
].bitfield
.regymm
4422 || i
.types
[op
].bitfield
.sreg2
4423 || i
.types
[op
].bitfield
.sreg3
4424 || i
.types
[op
].bitfield
.control
4425 || i
.types
[op
].bitfield
.debug
4426 || i
.types
[op
].bitfield
.test
4427 || i
.types
[op
].bitfield
.floatreg
4428 || i
.types
[op
].bitfield
.floatacc
)
4430 as_bad (_("`%s%s' not allowed with `%s%c'"),
4432 i
.op
[op
].regs
->reg_name
,
4442 check_long_reg (void)
4446 for (op
= i
.operands
; --op
>= 0;)
4447 /* Reject eight bit registers, except where the template requires
4448 them. (eg. movzb) */
4449 if (i
.types
[op
].bitfield
.reg8
4450 && (i
.tm
.operand_types
[op
].bitfield
.reg16
4451 || i
.tm
.operand_types
[op
].bitfield
.reg32
4452 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4454 as_bad (_("`%s%s' not allowed with `%s%c'"),
4456 i
.op
[op
].regs
->reg_name
,
4461 /* Warn if the e prefix on a general reg is missing. */
4462 else if ((!quiet_warnings
|| flag_code
== CODE_64BIT
)
4463 && i
.types
[op
].bitfield
.reg16
4464 && (i
.tm
.operand_types
[op
].bitfield
.reg32
4465 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4467 /* Prohibit these changes in the 64bit mode, since the
4468 lowering is more complicated. */
4469 if (flag_code
== CODE_64BIT
)
4471 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
4472 register_prefix
, i
.op
[op
].regs
->reg_name
,
4476 #if REGISTER_WARNINGS
4478 as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
4480 (i
.op
[op
].regs
+ REGNAM_EAX
- REGNAM_AX
)->reg_name
,
4482 i
.op
[op
].regs
->reg_name
,
4486 /* Warn if the r prefix on a general reg is missing. */
4487 else if (i
.types
[op
].bitfield
.reg64
4488 && (i
.tm
.operand_types
[op
].bitfield
.reg32
4489 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4492 && i
.tm
.opcode_modifier
.toqword
4493 && !i
.types
[0].bitfield
.regxmm
)
4495 /* Convert to QWORD. We want REX byte. */
4496 i
.suffix
= QWORD_MNEM_SUFFIX
;
4500 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
4501 register_prefix
, i
.op
[op
].regs
->reg_name
,
4510 check_qword_reg (void)
4514 for (op
= i
.operands
; --op
>= 0; )
4515 /* Reject eight bit registers, except where the template requires
4516 them. (eg. movzb) */
4517 if (i
.types
[op
].bitfield
.reg8
4518 && (i
.tm
.operand_types
[op
].bitfield
.reg16
4519 || i
.tm
.operand_types
[op
].bitfield
.reg32
4520 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4522 as_bad (_("`%s%s' not allowed with `%s%c'"),
4524 i
.op
[op
].regs
->reg_name
,
4529 /* Warn if the e prefix on a general reg is missing. */
4530 else if ((i
.types
[op
].bitfield
.reg16
4531 || i
.types
[op
].bitfield
.reg32
)
4532 && (i
.tm
.operand_types
[op
].bitfield
.reg32
4533 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4535 /* Prohibit these changes in the 64bit mode, since the
4536 lowering is more complicated. */
4538 && i
.tm
.opcode_modifier
.todword
4539 && !i
.types
[0].bitfield
.regxmm
)
4541 /* Convert to DWORD. We don't want REX byte. */
4542 i
.suffix
= LONG_MNEM_SUFFIX
;
4546 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
4547 register_prefix
, i
.op
[op
].regs
->reg_name
,
4556 check_word_reg (void)
4559 for (op
= i
.operands
; --op
>= 0;)
4560 /* Reject eight bit registers, except where the template requires
4561 them. (eg. movzb) */
4562 if (i
.types
[op
].bitfield
.reg8
4563 && (i
.tm
.operand_types
[op
].bitfield
.reg16
4564 || i
.tm
.operand_types
[op
].bitfield
.reg32
4565 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4567 as_bad (_("`%s%s' not allowed with `%s%c'"),
4569 i
.op
[op
].regs
->reg_name
,
4574 /* Warn if the e prefix on a general reg is present. */
4575 else if ((!quiet_warnings
|| flag_code
== CODE_64BIT
)
4576 && i
.types
[op
].bitfield
.reg32
4577 && (i
.tm
.operand_types
[op
].bitfield
.reg16
4578 || i
.tm
.operand_types
[op
].bitfield
.acc
))
4580 /* Prohibit these changes in the 64bit mode, since the
4581 lowering is more complicated. */
4582 if (flag_code
== CODE_64BIT
)
4584 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
4585 register_prefix
, i
.op
[op
].regs
->reg_name
,
4590 #if REGISTER_WARNINGS
4591 as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
4593 (i
.op
[op
].regs
+ REGNAM_AX
- REGNAM_EAX
)->reg_name
,
4595 i
.op
[op
].regs
->reg_name
,
4603 update_imm (unsigned int j
)
4605 i386_operand_type overlap
= i
.types
[j
];
4606 if ((overlap
.bitfield
.imm8
4607 || overlap
.bitfield
.imm8s
4608 || overlap
.bitfield
.imm16
4609 || overlap
.bitfield
.imm32
4610 || overlap
.bitfield
.imm32s
4611 || overlap
.bitfield
.imm64
)
4612 && !operand_type_equal (&overlap
, &imm8
)
4613 && !operand_type_equal (&overlap
, &imm8s
)
4614 && !operand_type_equal (&overlap
, &imm16
)
4615 && !operand_type_equal (&overlap
, &imm32
)
4616 && !operand_type_equal (&overlap
, &imm32s
)
4617 && !operand_type_equal (&overlap
, &imm64
))
4621 i386_operand_type temp
;
4623 operand_type_set (&temp
, 0);
4624 if (i
.suffix
== BYTE_MNEM_SUFFIX
)
4626 temp
.bitfield
.imm8
= overlap
.bitfield
.imm8
;
4627 temp
.bitfield
.imm8s
= overlap
.bitfield
.imm8s
;
4629 else if (i
.suffix
== WORD_MNEM_SUFFIX
)
4630 temp
.bitfield
.imm16
= overlap
.bitfield
.imm16
;
4631 else if (i
.suffix
== QWORD_MNEM_SUFFIX
)
4633 temp
.bitfield
.imm64
= overlap
.bitfield
.imm64
;
4634 temp
.bitfield
.imm32s
= overlap
.bitfield
.imm32s
;
4637 temp
.bitfield
.imm32
= overlap
.bitfield
.imm32
;
4640 else if (operand_type_equal (&overlap
, &imm16_32_32s
)
4641 || operand_type_equal (&overlap
, &imm16_32
)
4642 || operand_type_equal (&overlap
, &imm16_32s
))
4644 if ((flag_code
== CODE_16BIT
) ^ (i
.prefix
[DATA_PREFIX
] != 0))
4649 if (!operand_type_equal (&overlap
, &imm8
)
4650 && !operand_type_equal (&overlap
, &imm8s
)
4651 && !operand_type_equal (&overlap
, &imm16
)
4652 && !operand_type_equal (&overlap
, &imm32
)
4653 && !operand_type_equal (&overlap
, &imm32s
)
4654 && !operand_type_equal (&overlap
, &imm64
))
4656 as_bad (_("no instruction mnemonic suffix given; "
4657 "can't determine immediate size"));
4661 i
.types
[j
] = overlap
;
4671 /* Update the first 2 immediate operands. */
4672 n
= i
.operands
> 2 ? 2 : i
.operands
;
4675 for (j
= 0; j
< n
; j
++)
4676 if (update_imm (j
) == 0)
4679 /* The 3rd operand can't be immediate operand. */
4680 gas_assert (operand_type_check (i
.types
[2], imm
) == 0);
4687 bad_implicit_operand (int xmm
)
4689 const char *ireg
= xmm
? "xmm0" : "ymm0";
4692 as_bad (_("the last operand of `%s' must be `%s%s'"),
4693 i
.tm
.name
, register_prefix
, ireg
);
4695 as_bad (_("the first operand of `%s' must be `%s%s'"),
4696 i
.tm
.name
, register_prefix
, ireg
);
4701 process_operands (void)
4703 /* Default segment register this instruction will use for memory
4704 accesses. 0 means unknown. This is only for optimizing out
4705 unnecessary segment overrides. */
4706 const seg_entry
*default_seg
= 0;
4708 if (i
.tm
.opcode_modifier
.sse2avx
4709 && (i
.tm
.opcode_modifier
.vexnds
4710 || i
.tm
.opcode_modifier
.vexndd
))
4712 unsigned int dupl
= i
.operands
;
4713 unsigned int dest
= dupl
- 1;
4716 /* The destination must be an xmm register. */
4717 gas_assert (i
.reg_operands
4718 && MAX_OPERANDS
> dupl
4719 && operand_type_equal (&i
.types
[dest
], ®xmm
));
4721 if (i
.tm
.opcode_modifier
.firstxmm0
)
4723 /* The first operand is implicit and must be xmm0. */
4724 gas_assert (operand_type_equal (&i
.types
[0], ®xmm
));
4725 if (i
.op
[0].regs
->reg_num
!= 0)
4726 return bad_implicit_operand (1);
4728 if (i
.tm
.opcode_modifier
.vexsources
== VEX3SOURCES
)
4730 /* Keep xmm0 for instructions with VEX prefix and 3
4736 /* We remove the first xmm0 and keep the number of
4737 operands unchanged, which in fact duplicates the
4739 for (j
= 1; j
< i
.operands
; j
++)
4741 i
.op
[j
- 1] = i
.op
[j
];
4742 i
.types
[j
- 1] = i
.types
[j
];
4743 i
.tm
.operand_types
[j
- 1] = i
.tm
.operand_types
[j
];
4747 else if (i
.tm
.opcode_modifier
.implicit1stxmm0
)
4749 gas_assert ((MAX_OPERANDS
- 1) > dupl
4750 && (i
.tm
.opcode_modifier
.vexsources
4753 /* Add the implicit xmm0 for instructions with VEX prefix
4755 for (j
= i
.operands
; j
> 0; j
--)
4757 i
.op
[j
] = i
.op
[j
- 1];
4758 i
.types
[j
] = i
.types
[j
- 1];
4759 i
.tm
.operand_types
[j
] = i
.tm
.operand_types
[j
- 1];
4762 = (const reg_entry
*) hash_find (reg_hash
, "xmm0");
4763 i
.types
[0] = regxmm
;
4764 i
.tm
.operand_types
[0] = regxmm
;
4767 i
.reg_operands
+= 2;
4772 i
.op
[dupl
] = i
.op
[dest
];
4773 i
.types
[dupl
] = i
.types
[dest
];
4774 i
.tm
.operand_types
[dupl
] = i
.tm
.operand_types
[dest
];
4783 i
.op
[dupl
] = i
.op
[dest
];
4784 i
.types
[dupl
] = i
.types
[dest
];
4785 i
.tm
.operand_types
[dupl
] = i
.tm
.operand_types
[dest
];
4788 if (i
.tm
.opcode_modifier
.immext
)
4791 else if (i
.tm
.opcode_modifier
.firstxmm0
)
4795 /* The first operand is implicit and must be xmm0/ymm0. */
4796 gas_assert (i
.reg_operands
4797 && (operand_type_equal (&i
.types
[0], ®xmm
)
4798 || operand_type_equal (&i
.types
[0], ®ymm
)));
4799 if (i
.op
[0].regs
->reg_num
!= 0)
4800 return bad_implicit_operand (i
.types
[0].bitfield
.regxmm
);
4802 for (j
= 1; j
< i
.operands
; j
++)
4804 i
.op
[j
- 1] = i
.op
[j
];
4805 i
.types
[j
- 1] = i
.types
[j
];
4807 /* We need to adjust fields in i.tm since they are used by
4808 build_modrm_byte. */
4809 i
.tm
.operand_types
[j
- 1] = i
.tm
.operand_types
[j
];
4816 else if (i
.tm
.opcode_modifier
.regkludge
)
4818 /* The imul $imm, %reg instruction is converted into
4819 imul $imm, %reg, %reg, and the clr %reg instruction
4820 is converted into xor %reg, %reg. */
4822 unsigned int first_reg_op
;
4824 if (operand_type_check (i
.types
[0], reg
))
4828 /* Pretend we saw the extra register operand. */
4829 gas_assert (i
.reg_operands
== 1
4830 && i
.op
[first_reg_op
+ 1].regs
== 0);
4831 i
.op
[first_reg_op
+ 1].regs
= i
.op
[first_reg_op
].regs
;
4832 i
.types
[first_reg_op
+ 1] = i
.types
[first_reg_op
];
4837 if (i
.tm
.opcode_modifier
.shortform
)
4839 if (i
.types
[0].bitfield
.sreg2
4840 || i
.types
[0].bitfield
.sreg3
)
4842 if (i
.tm
.base_opcode
== POP_SEG_SHORT
4843 && i
.op
[0].regs
->reg_num
== 1)
4845 as_bad (_("you can't `pop %scs'"), register_prefix
);
4848 i
.tm
.base_opcode
|= (i
.op
[0].regs
->reg_num
<< 3);
4849 if ((i
.op
[0].regs
->reg_flags
& RegRex
) != 0)
4854 /* The register or float register operand is in operand
4858 if (i
.types
[0].bitfield
.floatreg
4859 || operand_type_check (i
.types
[0], reg
))
4863 /* Register goes in low 3 bits of opcode. */
4864 i
.tm
.base_opcode
|= i
.op
[op
].regs
->reg_num
;
4865 if ((i
.op
[op
].regs
->reg_flags
& RegRex
) != 0)
4867 if (!quiet_warnings
&& i
.tm
.opcode_modifier
.ugh
)
4869 /* Warn about some common errors, but press on regardless.
4870 The first case can be generated by gcc (<= 2.8.1). */
4871 if (i
.operands
== 2)
4873 /* Reversed arguments on faddp, fsubp, etc. */
4874 as_warn (_("translating to `%s %s%s,%s%s'"), i
.tm
.name
,
4875 register_prefix
, i
.op
[!intel_syntax
].regs
->reg_name
,
4876 register_prefix
, i
.op
[intel_syntax
].regs
->reg_name
);
4880 /* Extraneous `l' suffix on fp insn. */
4881 as_warn (_("translating to `%s %s%s'"), i
.tm
.name
,
4882 register_prefix
, i
.op
[0].regs
->reg_name
);
4887 else if (i
.tm
.opcode_modifier
.modrm
)
4889 /* The opcode is completed (modulo i.tm.extension_opcode which
4890 must be put into the modrm byte). Now, we make the modrm and
4891 index base bytes based on all the info we've collected. */
4893 default_seg
= build_modrm_byte ();
4895 else if ((i
.tm
.base_opcode
& ~0x3) == MOV_AX_DISP32
)
4899 else if (i
.tm
.opcode_modifier
.isstring
)
4901 /* For the string instructions that allow a segment override
4902 on one of their operands, the default segment is ds. */
4906 if (i
.tm
.base_opcode
== 0x8d /* lea */
4909 as_warn (_("segment override on `%s' is ineffectual"), i
.tm
.name
);
4911 /* If a segment was explicitly specified, and the specified segment
4912 is not the default, use an opcode prefix to select it. If we
4913 never figured out what the default segment is, then default_seg
4914 will be zero at this point, and the specified segment prefix will
4916 if ((i
.seg
[0]) && (i
.seg
[0] != default_seg
))
4918 if (!add_prefix (i
.seg
[0]->seg_prefix
))
4924 static const seg_entry
*
4925 build_modrm_byte (void)
4927 const seg_entry
*default_seg
= 0;
4928 unsigned int source
, dest
;
4931 /* The first operand of instructions with VEX prefix and 3 sources
4932 must be VEX_Imm4. */
4933 vex_3_sources
= i
.tm
.opcode_modifier
.vexsources
== VEX3SOURCES
;
4936 unsigned int nds
, reg_slot
;
4939 if (i
.tm
.opcode_modifier
.veximmext
4940 && i
.tm
.opcode_modifier
.immext
)
4942 dest
= i
.operands
- 2;
4943 gas_assert (dest
== 3);
4946 dest
= i
.operands
- 1;
4949 /* This instruction must have 4 register operands
4950 or 3 register operands plus 1 memory operand.
4951 It must have VexNDS and VexImmExt. */
4952 gas_assert ((i
.reg_operands
== 4
4953 || (i
.reg_operands
== 3 && i
.mem_operands
== 1))
4954 && i
.tm
.opcode_modifier
.vexnds
4955 && i
.tm
.opcode_modifier
.veximmext
4956 && (operand_type_equal (&i
.tm
.operand_types
[dest
], ®xmm
)
4957 || operand_type_equal (&i
.tm
.operand_types
[dest
], ®ymm
)));
4959 /* Generate an 8bit immediate operand to encode the register
4961 exp
= &im_expressions
[i
.imm_operands
++];
4962 i
.op
[i
.operands
].imms
= exp
;
4963 i
.types
[i
.operands
] = imm8
;
4965 /* If VexW1 is set, the first operand is the source and
4966 the second operand is encoded in the immediate operand. */
4967 if (i
.tm
.opcode_modifier
.vexw
== VEXW1
)
4977 gas_assert ((operand_type_equal (&i
.tm
.operand_types
[reg_slot
], ®xmm
)
4978 || operand_type_equal (&i
.tm
.operand_types
[reg_slot
],
4980 && (operand_type_equal (&i
.tm
.operand_types
[nds
], ®xmm
)
4981 || operand_type_equal (&i
.tm
.operand_types
[nds
],
4983 exp
->X_op
= O_constant
;
4985 = ((i
.op
[reg_slot
].regs
->reg_num
4986 + ((i
.op
[reg_slot
].regs
->reg_flags
& RegRex
) ? 8 : 0)) << 4);
4987 i
.vex
.register_specifier
= i
.op
[nds
].regs
;
4992 /* i.reg_operands MUST be the number of real register operands;
4993 implicit registers do not count. If there are 3 register
4994 operands, it must be a instruction with VexNDS. For a
4995 instruction with VexNDD, the destination register is encoded
4996 in VEX prefix. If there are 4 register operands, it must be
4997 a instruction with VEX prefix and 3 sources. */
4998 if (i
.mem_operands
== 0
4999 && ((i
.reg_operands
== 2
5000 && !i
.tm
.opcode_modifier
.vexndd
5001 && !i
.tm
.opcode_modifier
.vexlwp
)
5002 || (i
.reg_operands
== 3
5003 && i
.tm
.opcode_modifier
.vexnds
)
5004 || (i
.reg_operands
== 4 && vex_3_sources
)))
5012 /* When there are 3 operands, one of them may be immediate,
5013 which may be the first or the last operand. Otherwise,
5014 the first operand must be shift count register (cl) or it
5015 is an instruction with VexNDS. */
5016 gas_assert (i
.imm_operands
== 1
5017 || (i
.imm_operands
== 0
5018 && (i
.tm
.opcode_modifier
.vexnds
5019 || i
.types
[0].bitfield
.shiftcount
)));
5020 if (operand_type_check (i
.types
[0], imm
)
5021 || i
.types
[0].bitfield
.shiftcount
)
5027 /* When there are 4 operands, the first two must be 8bit
5028 immediate operands. The source operand will be the 3rd
5031 For instructions with VexNDS, if the first operand
5032 an imm8, the source operand is the 2nd one. If the last
5033 operand is imm8, the source operand is the first one. */
5034 gas_assert ((i
.imm_operands
== 2
5035 && i
.types
[0].bitfield
.imm8
5036 && i
.types
[1].bitfield
.imm8
)
5037 || (i
.tm
.opcode_modifier
.vexnds
5038 && i
.imm_operands
== 1
5039 && (i
.types
[0].bitfield
.imm8
5040 || i
.types
[i
.operands
- 1].bitfield
.imm8
)));
5041 if (i
.tm
.opcode_modifier
.vexnds
)
5043 if (i
.types
[0].bitfield
.imm8
)
5061 if (i
.tm
.opcode_modifier
.vexnds
)
5063 /* For instructions with VexNDS, the register-only
5064 source operand must be XMM or YMM register. It is
5065 encoded in VEX prefix. We need to clear RegMem bit
5066 before calling operand_type_equal. */
5067 i386_operand_type op
= i
.tm
.operand_types
[dest
];
5068 op
.bitfield
.regmem
= 0;
5069 if ((dest
+ 1) >= i
.operands
5070 || (!operand_type_equal (&op
, ®xmm
)
5071 && !operand_type_equal (&op
, ®ymm
)))
5073 i
.vex
.register_specifier
= i
.op
[dest
].regs
;
5079 /* One of the register operands will be encoded in the i.tm.reg
5080 field, the other in the combined i.tm.mode and i.tm.regmem
5081 fields. If no form of this instruction supports a memory
5082 destination operand, then we assume the source operand may
5083 sometimes be a memory operand and so we need to store the
5084 destination in the i.rm.reg field. */
5085 if (!i
.tm
.operand_types
[dest
].bitfield
.regmem
5086 && operand_type_check (i
.tm
.operand_types
[dest
], anymem
) == 0)
5088 i
.rm
.reg
= i
.op
[dest
].regs
->reg_num
;
5089 i
.rm
.regmem
= i
.op
[source
].regs
->reg_num
;
5090 if ((i
.op
[dest
].regs
->reg_flags
& RegRex
) != 0)
5092 if ((i
.op
[source
].regs
->reg_flags
& RegRex
) != 0)
5097 i
.rm
.reg
= i
.op
[source
].regs
->reg_num
;
5098 i
.rm
.regmem
= i
.op
[dest
].regs
->reg_num
;
5099 if ((i
.op
[dest
].regs
->reg_flags
& RegRex
) != 0)
5101 if ((i
.op
[source
].regs
->reg_flags
& RegRex
) != 0)
5104 if (flag_code
!= CODE_64BIT
&& (i
.rex
& (REX_R
| REX_B
)))
5106 if (!i
.types
[0].bitfield
.control
5107 && !i
.types
[1].bitfield
.control
)
5109 i
.rex
&= ~(REX_R
| REX_B
);
5110 add_prefix (LOCK_PREFIX_OPCODE
);
5114 { /* If it's not 2 reg operands... */
5119 unsigned int fake_zero_displacement
= 0;
5122 for (op
= 0; op
< i
.operands
; op
++)
5123 if (operand_type_check (i
.types
[op
], anymem
))
5125 gas_assert (op
< i
.operands
);
5129 if (i
.base_reg
== 0)
5132 if (!i
.disp_operands
)
5133 fake_zero_displacement
= 1;
5134 if (i
.index_reg
== 0)
5136 /* Operand is just <disp> */
5137 if (flag_code
== CODE_64BIT
)
5139 /* 64bit mode overwrites the 32bit absolute
5140 addressing by RIP relative addressing and
5141 absolute addressing is encoded by one of the
5142 redundant SIB forms. */
5143 i
.rm
.regmem
= ESCAPE_TO_TWO_BYTE_ADDRESSING
;
5144 i
.sib
.base
= NO_BASE_REGISTER
;
5145 i
.sib
.index
= NO_INDEX_REGISTER
;
5146 i
.types
[op
] = ((i
.prefix
[ADDR_PREFIX
] == 0)
5147 ? disp32s
: disp32
);
5149 else if ((flag_code
== CODE_16BIT
)
5150 ^ (i
.prefix
[ADDR_PREFIX
] != 0))
5152 i
.rm
.regmem
= NO_BASE_REGISTER_16
;
5153 i
.types
[op
] = disp16
;
5157 i
.rm
.regmem
= NO_BASE_REGISTER
;
5158 i
.types
[op
] = disp32
;
5161 else /* !i.base_reg && i.index_reg */
5163 if (i
.index_reg
->reg_num
== RegEiz
5164 || i
.index_reg
->reg_num
== RegRiz
)
5165 i
.sib
.index
= NO_INDEX_REGISTER
;
5167 i
.sib
.index
= i
.index_reg
->reg_num
;
5168 i
.sib
.base
= NO_BASE_REGISTER
;
5169 i
.sib
.scale
= i
.log2_scale_factor
;
5170 i
.rm
.regmem
= ESCAPE_TO_TWO_BYTE_ADDRESSING
;
5171 i
.types
[op
].bitfield
.disp8
= 0;
5172 i
.types
[op
].bitfield
.disp16
= 0;
5173 i
.types
[op
].bitfield
.disp64
= 0;
5174 if (flag_code
!= CODE_64BIT
)
5176 /* Must be 32 bit */
5177 i
.types
[op
].bitfield
.disp32
= 1;
5178 i
.types
[op
].bitfield
.disp32s
= 0;
5182 i
.types
[op
].bitfield
.disp32
= 0;
5183 i
.types
[op
].bitfield
.disp32s
= 1;
5185 if ((i
.index_reg
->reg_flags
& RegRex
) != 0)
5189 /* RIP addressing for 64bit mode. */
5190 else if (i
.base_reg
->reg_num
== RegRip
||
5191 i
.base_reg
->reg_num
== RegEip
)
5193 i
.rm
.regmem
= NO_BASE_REGISTER
;
5194 i
.types
[op
].bitfield
.disp8
= 0;
5195 i
.types
[op
].bitfield
.disp16
= 0;
5196 i
.types
[op
].bitfield
.disp32
= 0;
5197 i
.types
[op
].bitfield
.disp32s
= 1;
5198 i
.types
[op
].bitfield
.disp64
= 0;
5199 i
.flags
[op
] |= Operand_PCrel
;
5200 if (! i
.disp_operands
)
5201 fake_zero_displacement
= 1;
5203 else if (i
.base_reg
->reg_type
.bitfield
.reg16
)
5205 switch (i
.base_reg
->reg_num
)
5208 if (i
.index_reg
== 0)
5210 else /* (%bx,%si) -> 0, or (%bx,%di) -> 1 */
5211 i
.rm
.regmem
= i
.index_reg
->reg_num
- 6;
5215 if (i
.index_reg
== 0)
5218 if (operand_type_check (i
.types
[op
], disp
) == 0)
5220 /* fake (%bp) into 0(%bp) */
5221 i
.types
[op
].bitfield
.disp8
= 1;
5222 fake_zero_displacement
= 1;
5225 else /* (%bp,%si) -> 2, or (%bp,%di) -> 3 */
5226 i
.rm
.regmem
= i
.index_reg
->reg_num
- 6 + 2;
5228 default: /* (%si) -> 4 or (%di) -> 5 */
5229 i
.rm
.regmem
= i
.base_reg
->reg_num
- 6 + 4;
5231 i
.rm
.mode
= mode_from_disp_size (i
.types
[op
]);
5233 else /* i.base_reg and 32/64 bit mode */
5235 if (flag_code
== CODE_64BIT
5236 && operand_type_check (i
.types
[op
], disp
))
5238 i386_operand_type temp
;
5239 operand_type_set (&temp
, 0);
5240 temp
.bitfield
.disp8
= i
.types
[op
].bitfield
.disp8
;
5242 if (i
.prefix
[ADDR_PREFIX
] == 0)
5243 i
.types
[op
].bitfield
.disp32s
= 1;
5245 i
.types
[op
].bitfield
.disp32
= 1;
5248 i
.rm
.regmem
= i
.base_reg
->reg_num
;
5249 if ((i
.base_reg
->reg_flags
& RegRex
) != 0)
5251 i
.sib
.base
= i
.base_reg
->reg_num
;
5252 /* x86-64 ignores REX prefix bit here to avoid decoder
5254 if ((i
.base_reg
->reg_num
& 7) == EBP_REG_NUM
)
5257 if (i
.disp_operands
== 0)
5259 fake_zero_displacement
= 1;
5260 i
.types
[op
].bitfield
.disp8
= 1;
5263 else if (i
.base_reg
->reg_num
== ESP_REG_NUM
)
5267 i
.sib
.scale
= i
.log2_scale_factor
;
5268 if (i
.index_reg
== 0)
5270 /* <disp>(%esp) becomes two byte modrm with no index
5271 register. We've already stored the code for esp
5272 in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
5273 Any base register besides %esp will not use the
5274 extra modrm byte. */
5275 i
.sib
.index
= NO_INDEX_REGISTER
;
5279 if (i
.index_reg
->reg_num
== RegEiz
5280 || i
.index_reg
->reg_num
== RegRiz
)
5281 i
.sib
.index
= NO_INDEX_REGISTER
;
5283 i
.sib
.index
= i
.index_reg
->reg_num
;
5284 i
.rm
.regmem
= ESCAPE_TO_TWO_BYTE_ADDRESSING
;
5285 if ((i
.index_reg
->reg_flags
& RegRex
) != 0)
5290 && (i
.reloc
[op
] == BFD_RELOC_386_TLS_DESC_CALL
5291 || i
.reloc
[op
] == BFD_RELOC_X86_64_TLSDESC_CALL
))
5294 i
.rm
.mode
= mode_from_disp_size (i
.types
[op
]);
5297 if (fake_zero_displacement
)
5299 /* Fakes a zero displacement assuming that i.types[op]
5300 holds the correct displacement size. */
5303 gas_assert (i
.op
[op
].disps
== 0);
5304 exp
= &disp_expressions
[i
.disp_operands
++];
5305 i
.op
[op
].disps
= exp
;
5306 exp
->X_op
= O_constant
;
5307 exp
->X_add_number
= 0;
5308 exp
->X_add_symbol
= (symbolS
*) 0;
5309 exp
->X_op_symbol
= (symbolS
*) 0;
5317 if (i
.tm
.opcode_modifier
.vexsources
== XOP2SOURCES
)
5319 if (operand_type_check (i
.types
[0], imm
))
5320 i
.vex
.register_specifier
= NULL
;
5323 /* VEX.vvvv encodes one of the sources when the first
5324 operand is not an immediate. */
5325 if (i
.tm
.opcode_modifier
.vexw
== VEXW0
)
5326 i
.vex
.register_specifier
= i
.op
[0].regs
;
5328 i
.vex
.register_specifier
= i
.op
[1].regs
;
5331 /* Destination is a XMM register encoded in the ModRM.reg
5333 i
.rm
.reg
= i
.op
[2].regs
->reg_num
;
5334 if ((i
.op
[2].regs
->reg_flags
& RegRex
) != 0)
5337 /* ModRM.rm and VEX.B encodes the other source. */
5338 if (!i
.mem_operands
)
5342 if (i
.tm
.opcode_modifier
.vexw
== VEXW0
)
5343 i
.rm
.regmem
= i
.op
[1].regs
->reg_num
;
5345 i
.rm
.regmem
= i
.op
[0].regs
->reg_num
;
5347 if ((i
.op
[1].regs
->reg_flags
& RegRex
) != 0)
5351 else if (i
.tm
.opcode_modifier
.vexlwp
)
5353 i
.vex
.register_specifier
= i
.op
[2].regs
;
5354 if (!i
.mem_operands
)
5357 i
.rm
.regmem
= i
.op
[1].regs
->reg_num
;
5358 if ((i
.op
[1].regs
->reg_flags
& RegRex
) != 0)
5362 /* Fill in i.rm.reg or i.rm.regmem field with register operand
5363 (if any) based on i.tm.extension_opcode. Again, we must be
5364 careful to make sure that segment/control/debug/test/MMX
5365 registers are coded into the i.rm.reg field. */
5366 else if (i
.reg_operands
)
5369 unsigned int vex_reg
= ~0;
5371 for (op
= 0; op
< i
.operands
; op
++)
5372 if (i
.types
[op
].bitfield
.reg8
5373 || i
.types
[op
].bitfield
.reg16
5374 || i
.types
[op
].bitfield
.reg32
5375 || i
.types
[op
].bitfield
.reg64
5376 || i
.types
[op
].bitfield
.regmmx
5377 || i
.types
[op
].bitfield
.regxmm
5378 || i
.types
[op
].bitfield
.regymm
5379 || i
.types
[op
].bitfield
.sreg2
5380 || i
.types
[op
].bitfield
.sreg3
5381 || i
.types
[op
].bitfield
.control
5382 || i
.types
[op
].bitfield
.debug
5383 || i
.types
[op
].bitfield
.test
)
5388 else if (i
.tm
.opcode_modifier
.vexnds
)
5390 /* For instructions with VexNDS, the register-only
5391 source operand is encoded in VEX prefix. */
5392 gas_assert (mem
!= (unsigned int) ~0);
5397 gas_assert (op
< i
.operands
);
5402 gas_assert (vex_reg
< i
.operands
);
5405 else if (i
.tm
.opcode_modifier
.vexndd
)
5407 /* For instructions with VexNDD, there should be
5408 no memory operand and the register destination
5409 is encoded in VEX prefix. */
5410 gas_assert (i
.mem_operands
== 0
5411 && (op
+ 2) == i
.operands
);
5415 gas_assert (op
< i
.operands
);
5417 if (vex_reg
!= (unsigned int) ~0)
5419 gas_assert (i
.reg_operands
== 2);
5421 if (!operand_type_equal (&i
.tm
.operand_types
[vex_reg
],
5423 && !operand_type_equal (&i
.tm
.operand_types
[vex_reg
],
5427 i
.vex
.register_specifier
= i
.op
[vex_reg
].regs
;
5430 /* Don't set OP operand twice. */
5433 /* If there is an extension opcode to put here, the
5434 register number must be put into the regmem field. */
5435 if (i
.tm
.extension_opcode
!= None
)
5437 i
.rm
.regmem
= i
.op
[op
].regs
->reg_num
;
5438 if ((i
.op
[op
].regs
->reg_flags
& RegRex
) != 0)
5443 i
.rm
.reg
= i
.op
[op
].regs
->reg_num
;
5444 if ((i
.op
[op
].regs
->reg_flags
& RegRex
) != 0)
5449 /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
5450 must set it to 3 to indicate this is a register operand
5451 in the regmem field. */
5452 if (!i
.mem_operands
)
5456 /* Fill in i.rm.reg field with extension opcode (if any). */
5457 if (i
.tm
.extension_opcode
!= None
)
5458 i
.rm
.reg
= i
.tm
.extension_opcode
;
5464 output_branch (void)
5469 relax_substateT subtype
;
5474 if (flag_code
== CODE_16BIT
)
5478 if (i
.prefix
[DATA_PREFIX
] != 0)
5484 /* Pentium4 branch hints. */
5485 if (i
.prefix
[SEG_PREFIX
] == CS_PREFIX_OPCODE
/* not taken */
5486 || i
.prefix
[SEG_PREFIX
] == DS_PREFIX_OPCODE
/* taken */)
5491 if (i
.prefix
[REX_PREFIX
] != 0)
5497 if (i
.prefixes
!= 0 && !intel_syntax
)
5498 as_warn (_("skipping prefixes on this instruction"));
5500 /* It's always a symbol; End frag & setup for relax.
5501 Make sure there is enough room in this frag for the largest
5502 instruction we may generate in md_convert_frag. This is 2
5503 bytes for the opcode and room for the prefix and largest
5505 frag_grow (prefix
+ 2 + 4);
5506 /* Prefix and 1 opcode byte go in fr_fix. */
5507 p
= frag_more (prefix
+ 1);
5508 if (i
.prefix
[DATA_PREFIX
] != 0)
5509 *p
++ = DATA_PREFIX_OPCODE
;
5510 if (i
.prefix
[SEG_PREFIX
] == CS_PREFIX_OPCODE
5511 || i
.prefix
[SEG_PREFIX
] == DS_PREFIX_OPCODE
)
5512 *p
++ = i
.prefix
[SEG_PREFIX
];
5513 if (i
.prefix
[REX_PREFIX
] != 0)
5514 *p
++ = i
.prefix
[REX_PREFIX
];
5515 *p
= i
.tm
.base_opcode
;
5517 if ((unsigned char) *p
== JUMP_PC_RELATIVE
)
5518 subtype
= ENCODE_RELAX_STATE (UNCOND_JUMP
, SMALL
);
5519 else if (cpu_arch_flags
.bitfield
.cpui386
)
5520 subtype
= ENCODE_RELAX_STATE (COND_JUMP
, SMALL
);
5522 subtype
= ENCODE_RELAX_STATE (COND_JUMP86
, SMALL
);
5525 sym
= i
.op
[0].disps
->X_add_symbol
;
5526 off
= i
.op
[0].disps
->X_add_number
;
5528 if (i
.op
[0].disps
->X_op
!= O_constant
5529 && i
.op
[0].disps
->X_op
!= O_symbol
)
5531 /* Handle complex expressions. */
5532 sym
= make_expr_symbol (i
.op
[0].disps
);
5536 /* 1 possible extra opcode + 4 byte displacement go in var part.
5537 Pass reloc in fr_var. */
5538 frag_var (rs_machine_dependent
, 5, i
.reloc
[0], subtype
, sym
, off
, p
);
5548 if (i
.tm
.opcode_modifier
.jumpbyte
)
5550 /* This is a loop or jecxz type instruction. */
5552 if (i
.prefix
[ADDR_PREFIX
] != 0)
5554 FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE
);
5557 /* Pentium4 branch hints. */
5558 if (i
.prefix
[SEG_PREFIX
] == CS_PREFIX_OPCODE
/* not taken */
5559 || i
.prefix
[SEG_PREFIX
] == DS_PREFIX_OPCODE
/* taken */)
5561 FRAG_APPEND_1_CHAR (i
.prefix
[SEG_PREFIX
]);
5570 if (flag_code
== CODE_16BIT
)
5573 if (i
.prefix
[DATA_PREFIX
] != 0)
5575 FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE
);
5585 if (i
.prefix
[REX_PREFIX
] != 0)
5587 FRAG_APPEND_1_CHAR (i
.prefix
[REX_PREFIX
]);
5591 if (i
.prefixes
!= 0 && !intel_syntax
)
5592 as_warn (_("skipping prefixes on this instruction"));
5594 p
= frag_more (1 + size
);
5595 *p
++ = i
.tm
.base_opcode
;
5597 fixP
= fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
5598 i
.op
[0].disps
, 1, reloc (size
, 1, 1, i
.reloc
[0]));
5600 /* All jumps handled here are signed, but don't use a signed limit
5601 check for 32 and 16 bit jumps as we want to allow wrap around at
5602 4G and 64k respectively. */
5604 fixP
->fx_signed
= 1;
5608 output_interseg_jump (void)
5616 if (flag_code
== CODE_16BIT
)
5620 if (i
.prefix
[DATA_PREFIX
] != 0)
5626 if (i
.prefix
[REX_PREFIX
] != 0)
5636 if (i
.prefixes
!= 0 && !intel_syntax
)
5637 as_warn (_("skipping prefixes on this instruction"));
5639 /* 1 opcode; 2 segment; offset */
5640 p
= frag_more (prefix
+ 1 + 2 + size
);
5642 if (i
.prefix
[DATA_PREFIX
] != 0)
5643 *p
++ = DATA_PREFIX_OPCODE
;
5645 if (i
.prefix
[REX_PREFIX
] != 0)
5646 *p
++ = i
.prefix
[REX_PREFIX
];
5648 *p
++ = i
.tm
.base_opcode
;
5649 if (i
.op
[1].imms
->X_op
== O_constant
)
5651 offsetT n
= i
.op
[1].imms
->X_add_number
;
5654 && !fits_in_unsigned_word (n
)
5655 && !fits_in_signed_word (n
))
5657 as_bad (_("16-bit jump out of range"));
5660 md_number_to_chars (p
, n
, size
);
5663 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
5664 i
.op
[1].imms
, 0, reloc (size
, 0, 0, i
.reloc
[1]));
5665 if (i
.op
[0].imms
->X_op
!= O_constant
)
5666 as_bad (_("can't handle non absolute segment in `%s'"),
5668 md_number_to_chars (p
+ size
, (valueT
) i
.op
[0].imms
->X_add_number
, 2);
5674 fragS
*insn_start_frag
;
5675 offsetT insn_start_off
;
5677 /* Tie dwarf2 debug info to the address at the start of the insn.
5678 We can't do this after the insn has been output as the current
5679 frag may have been closed off. eg. by frag_var. */
5680 dwarf2_emit_insn (0);
5682 insn_start_frag
= frag_now
;
5683 insn_start_off
= frag_now_fix ();
5686 if (i
.tm
.opcode_modifier
.jump
)
5688 else if (i
.tm
.opcode_modifier
.jumpbyte
5689 || i
.tm
.opcode_modifier
.jumpdword
)
5691 else if (i
.tm
.opcode_modifier
.jumpintersegment
)
5692 output_interseg_jump ();
5695 /* Output normal instructions here. */
5699 unsigned int prefix
;
5701 /* Since the VEX prefix contains the implicit prefix, we don't
5702 need the explicit prefix. */
5703 if (!i
.tm
.opcode_modifier
.vex
)
5705 switch (i
.tm
.opcode_length
)
5708 if (i
.tm
.base_opcode
& 0xff000000)
5710 prefix
= (i
.tm
.base_opcode
>> 24) & 0xff;
5715 if ((i
.tm
.base_opcode
& 0xff0000) != 0)
5717 prefix
= (i
.tm
.base_opcode
>> 16) & 0xff;
5718 if (i
.tm
.cpu_flags
.bitfield
.cpupadlock
)
5721 if (prefix
!= REPE_PREFIX_OPCODE
5722 || (i
.prefix
[REP_PREFIX
]
5723 != REPE_PREFIX_OPCODE
))
5724 add_prefix (prefix
);
5727 add_prefix (prefix
);
5736 /* The prefix bytes. */
5737 for (j
= ARRAY_SIZE (i
.prefix
), q
= i
.prefix
; j
> 0; j
--, q
++)
5739 FRAG_APPEND_1_CHAR (*q
);
5742 if (i
.tm
.opcode_modifier
.vex
)
5744 for (j
= 0, q
= i
.prefix
; j
< ARRAY_SIZE (i
.prefix
); j
++, q
++)
5749 /* REX byte is encoded in VEX prefix. */
5753 FRAG_APPEND_1_CHAR (*q
);
5756 /* There should be no other prefixes for instructions
5761 /* Now the VEX prefix. */
5762 p
= frag_more (i
.vex
.length
);
5763 for (j
= 0; j
< i
.vex
.length
; j
++)
5764 p
[j
] = i
.vex
.bytes
[j
];
5767 /* Now the opcode; be careful about word order here! */
5768 if (i
.tm
.opcode_length
== 1)
5770 FRAG_APPEND_1_CHAR (i
.tm
.base_opcode
);
5774 switch (i
.tm
.opcode_length
)
5778 *p
++ = (i
.tm
.base_opcode
>> 16) & 0xff;
5788 /* Put out high byte first: can't use md_number_to_chars! */
5789 *p
++ = (i
.tm
.base_opcode
>> 8) & 0xff;
5790 *p
= i
.tm
.base_opcode
& 0xff;
5793 /* Now the modrm byte and sib byte (if present). */
5794 if (i
.tm
.opcode_modifier
.modrm
)
5796 FRAG_APPEND_1_CHAR ((i
.rm
.regmem
<< 0
5799 /* If i.rm.regmem == ESP (4)
5800 && i.rm.mode != (Register mode)
5802 ==> need second modrm byte. */
5803 if (i
.rm
.regmem
== ESCAPE_TO_TWO_BYTE_ADDRESSING
5805 && !(i
.base_reg
&& i
.base_reg
->reg_type
.bitfield
.reg16
))
5806 FRAG_APPEND_1_CHAR ((i
.sib
.base
<< 0
5808 | i
.sib
.scale
<< 6));
5811 if (i
.disp_operands
)
5812 output_disp (insn_start_frag
, insn_start_off
);
5815 output_imm (insn_start_frag
, insn_start_off
);
5821 pi ("" /*line*/, &i
);
5823 #endif /* DEBUG386 */
5826 /* Return the size of the displacement operand N. */
5829 disp_size (unsigned int n
)
5832 if (i
.types
[n
].bitfield
.disp64
)
5834 else if (i
.types
[n
].bitfield
.disp8
)
5836 else if (i
.types
[n
].bitfield
.disp16
)
5841 /* Return the size of the immediate operand N. */
5844 imm_size (unsigned int n
)
5847 if (i
.types
[n
].bitfield
.imm64
)
5849 else if (i
.types
[n
].bitfield
.imm8
|| i
.types
[n
].bitfield
.imm8s
)
5851 else if (i
.types
[n
].bitfield
.imm16
)
5857 output_disp (fragS
*insn_start_frag
, offsetT insn_start_off
)
5862 for (n
= 0; n
< i
.operands
; n
++)
5864 if (operand_type_check (i
.types
[n
], disp
))
5866 if (i
.op
[n
].disps
->X_op
== O_constant
)
5868 int size
= disp_size (n
);
5871 val
= offset_in_range (i
.op
[n
].disps
->X_add_number
,
5873 p
= frag_more (size
);
5874 md_number_to_chars (p
, val
, size
);
5878 enum bfd_reloc_code_real reloc_type
;
5879 int size
= disp_size (n
);
5880 int sign
= i
.types
[n
].bitfield
.disp32s
;
5881 int pcrel
= (i
.flags
[n
] & Operand_PCrel
) != 0;
5883 /* We can't have 8 bit displacement here. */
5884 gas_assert (!i
.types
[n
].bitfield
.disp8
);
5886 /* The PC relative address is computed relative
5887 to the instruction boundary, so in case immediate
5888 fields follows, we need to adjust the value. */
5889 if (pcrel
&& i
.imm_operands
)
5894 for (n1
= 0; n1
< i
.operands
; n1
++)
5895 if (operand_type_check (i
.types
[n1
], imm
))
5897 /* Only one immediate is allowed for PC
5898 relative address. */
5899 gas_assert (sz
== 0);
5901 i
.op
[n
].disps
->X_add_number
-= sz
;
5903 /* We should find the immediate. */
5904 gas_assert (sz
!= 0);
5907 p
= frag_more (size
);
5908 reloc_type
= reloc (size
, pcrel
, sign
, i
.reloc
[n
]);
5910 && GOT_symbol
== i
.op
[n
].disps
->X_add_symbol
5911 && (((reloc_type
== BFD_RELOC_32
5912 || reloc_type
== BFD_RELOC_X86_64_32S
5913 || (reloc_type
== BFD_RELOC_64
5915 && (i
.op
[n
].disps
->X_op
== O_symbol
5916 || (i
.op
[n
].disps
->X_op
== O_add
5917 && ((symbol_get_value_expression
5918 (i
.op
[n
].disps
->X_op_symbol
)->X_op
)
5920 || reloc_type
== BFD_RELOC_32_PCREL
))
5924 if (insn_start_frag
== frag_now
)
5925 add
= (p
- frag_now
->fr_literal
) - insn_start_off
;
5930 add
= insn_start_frag
->fr_fix
- insn_start_off
;
5931 for (fr
= insn_start_frag
->fr_next
;
5932 fr
&& fr
!= frag_now
; fr
= fr
->fr_next
)
5934 add
+= p
- frag_now
->fr_literal
;
5939 reloc_type
= BFD_RELOC_386_GOTPC
;
5940 i
.op
[n
].imms
->X_add_number
+= add
;
5942 else if (reloc_type
== BFD_RELOC_64
)
5943 reloc_type
= BFD_RELOC_X86_64_GOTPC64
;
5945 /* Don't do the adjustment for x86-64, as there
5946 the pcrel addressing is relative to the _next_
5947 insn, and that is taken care of in other code. */
5948 reloc_type
= BFD_RELOC_X86_64_GOTPC32
;
5950 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
5951 i
.op
[n
].disps
, pcrel
, reloc_type
);
5958 output_imm (fragS
*insn_start_frag
, offsetT insn_start_off
)
5963 for (n
= 0; n
< i
.operands
; n
++)
5965 if (operand_type_check (i
.types
[n
], imm
))
5967 if (i
.op
[n
].imms
->X_op
== O_constant
)
5969 int size
= imm_size (n
);
5972 val
= offset_in_range (i
.op
[n
].imms
->X_add_number
,
5974 p
= frag_more (size
);
5975 md_number_to_chars (p
, val
, size
);
5979 /* Not absolute_section.
5980 Need a 32-bit fixup (don't support 8bit
5981 non-absolute imms). Try to support other
5983 enum bfd_reloc_code_real reloc_type
;
5984 int size
= imm_size (n
);
5987 if (i
.types
[n
].bitfield
.imm32s
5988 && (i
.suffix
== QWORD_MNEM_SUFFIX
5989 || (!i
.suffix
&& i
.tm
.opcode_modifier
.no_lsuf
)))
5994 p
= frag_more (size
);
5995 reloc_type
= reloc (size
, 0, sign
, i
.reloc
[n
]);
5997 /* This is tough to explain. We end up with this one if we
5998 * have operands that look like
5999 * "_GLOBAL_OFFSET_TABLE_+[.-.L284]". The goal here is to
6000 * obtain the absolute address of the GOT, and it is strongly
6001 * preferable from a performance point of view to avoid using
6002 * a runtime relocation for this. The actual sequence of
6003 * instructions often look something like:
6008 * addl $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
6010 * The call and pop essentially return the absolute address
6011 * of the label .L66 and store it in %ebx. The linker itself
6012 * will ultimately change the first operand of the addl so
6013 * that %ebx points to the GOT, but to keep things simple, the
6014 * .o file must have this operand set so that it generates not
6015 * the absolute address of .L66, but the absolute address of
6016 * itself. This allows the linker itself simply treat a GOTPC
6017 * relocation as asking for a pcrel offset to the GOT to be
6018 * added in, and the addend of the relocation is stored in the
6019 * operand field for the instruction itself.
6021 * Our job here is to fix the operand so that it would add
6022 * the correct offset so that %ebx would point to itself. The
6023 * thing that is tricky is that .-.L66 will point to the
6024 * beginning of the instruction, so we need to further modify
6025 * the operand so that it will point to itself. There are
6026 * other cases where you have something like:
6028 * .long $_GLOBAL_OFFSET_TABLE_+[.-.L66]
6030 * and here no correction would be required. Internally in
6031 * the assembler we treat operands of this form as not being
6032 * pcrel since the '.' is explicitly mentioned, and I wonder
6033 * whether it would simplify matters to do it this way. Who
6034 * knows. In earlier versions of the PIC patches, the
6035 * pcrel_adjust field was used to store the correction, but
6036 * since the expression is not pcrel, I felt it would be
6037 * confusing to do it this way. */
6039 if ((reloc_type
== BFD_RELOC_32
6040 || reloc_type
== BFD_RELOC_X86_64_32S
6041 || reloc_type
== BFD_RELOC_64
)
6043 && GOT_symbol
== i
.op
[n
].imms
->X_add_symbol
6044 && (i
.op
[n
].imms
->X_op
== O_symbol
6045 || (i
.op
[n
].imms
->X_op
== O_add
6046 && ((symbol_get_value_expression
6047 (i
.op
[n
].imms
->X_op_symbol
)->X_op
)
6052 if (insn_start_frag
== frag_now
)
6053 add
= (p
- frag_now
->fr_literal
) - insn_start_off
;
6058 add
= insn_start_frag
->fr_fix
- insn_start_off
;
6059 for (fr
= insn_start_frag
->fr_next
;
6060 fr
&& fr
!= frag_now
; fr
= fr
->fr_next
)
6062 add
+= p
- frag_now
->fr_literal
;
6066 reloc_type
= BFD_RELOC_386_GOTPC
;
6068 reloc_type
= BFD_RELOC_X86_64_GOTPC32
;
6070 reloc_type
= BFD_RELOC_X86_64_GOTPC64
;
6071 i
.op
[n
].imms
->X_add_number
+= add
;
6073 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
6074 i
.op
[n
].imms
, 0, reloc_type
);
6080 /* x86_cons_fix_new is called via the expression parsing code when a
6081 reloc is needed. We use this hook to get the correct .got reloc. */
6082 static enum bfd_reloc_code_real got_reloc
= NO_RELOC
;
6083 static int cons_sign
= -1;
6086 x86_cons_fix_new (fragS
*frag
, unsigned int off
, unsigned int len
,
6089 enum bfd_reloc_code_real r
= reloc (len
, 0, cons_sign
, got_reloc
);
6091 got_reloc
= NO_RELOC
;
6094 if (exp
->X_op
== O_secrel
)
6096 exp
->X_op
= O_symbol
;
6097 r
= BFD_RELOC_32_SECREL
;
6101 fix_new_exp (frag
, off
, len
, exp
, 0, r
);
6104 #if (!defined (OBJ_ELF) && !defined (OBJ_MAYBE_ELF)) || defined (LEX_AT)
6105 # define lex_got(reloc, adjust, types) NULL
6107 /* Parse operands of the form
6108 <symbol>@GOTOFF+<nnn>
6109 and similar .plt or .got references.
6111 If we find one, set up the correct relocation in RELOC and copy the
6112 input string, minus the `@GOTOFF' into a malloc'd buffer for
6113 parsing by the calling routine. Return this buffer, and if ADJUST
6114 is non-null set it to the length of the string we removed from the
6115 input line. Otherwise return NULL. */
6117 lex_got (enum bfd_reloc_code_real
*rel
,
6119 i386_operand_type
*types
)
6121 /* Some of the relocations depend on the size of what field is to
6122 be relocated. But in our callers i386_immediate and i386_displacement
6123 we don't yet know the operand size (this will be set by insn
6124 matching). Hence we record the word32 relocation here,
6125 and adjust the reloc according to the real size in reloc(). */
6126 static const struct {
6128 const enum bfd_reloc_code_real rel
[2];
6129 const i386_operand_type types64
;
6131 { "PLTOFF", { _dummy_first_bfd_reloc_code_real
,
6132 BFD_RELOC_X86_64_PLTOFF64
},
6133 OPERAND_TYPE_IMM64
},
6134 { "PLT", { BFD_RELOC_386_PLT32
,
6135 BFD_RELOC_X86_64_PLT32
},
6136 OPERAND_TYPE_IMM32_32S_DISP32
},
6137 { "GOTPLT", { _dummy_first_bfd_reloc_code_real
,
6138 BFD_RELOC_X86_64_GOTPLT64
},
6139 OPERAND_TYPE_IMM64_DISP64
},
6140 { "GOTOFF", { BFD_RELOC_386_GOTOFF
,
6141 BFD_RELOC_X86_64_GOTOFF64
},
6142 OPERAND_TYPE_IMM64_DISP64
},
6143 { "GOTPCREL", { _dummy_first_bfd_reloc_code_real
,
6144 BFD_RELOC_X86_64_GOTPCREL
},
6145 OPERAND_TYPE_IMM32_32S_DISP32
},
6146 { "TLSGD", { BFD_RELOC_386_TLS_GD
,
6147 BFD_RELOC_X86_64_TLSGD
},
6148 OPERAND_TYPE_IMM32_32S_DISP32
},
6149 { "TLSLDM", { BFD_RELOC_386_TLS_LDM
,
6150 _dummy_first_bfd_reloc_code_real
},
6151 OPERAND_TYPE_NONE
},
6152 { "TLSLD", { _dummy_first_bfd_reloc_code_real
,
6153 BFD_RELOC_X86_64_TLSLD
},
6154 OPERAND_TYPE_IMM32_32S_DISP32
},
6155 { "GOTTPOFF", { BFD_RELOC_386_TLS_IE_32
,
6156 BFD_RELOC_X86_64_GOTTPOFF
},
6157 OPERAND_TYPE_IMM32_32S_DISP32
},
6158 { "TPOFF", { BFD_RELOC_386_TLS_LE_32
,
6159 BFD_RELOC_X86_64_TPOFF32
},
6160 OPERAND_TYPE_IMM32_32S_64_DISP32_64
},
6161 { "NTPOFF", { BFD_RELOC_386_TLS_LE
,
6162 _dummy_first_bfd_reloc_code_real
},
6163 OPERAND_TYPE_NONE
},
6164 { "DTPOFF", { BFD_RELOC_386_TLS_LDO_32
,
6165 BFD_RELOC_X86_64_DTPOFF32
},
6167 OPERAND_TYPE_IMM32_32S_64_DISP32_64
},
6168 { "GOTNTPOFF",{ BFD_RELOC_386_TLS_GOTIE
,
6169 _dummy_first_bfd_reloc_code_real
},
6170 OPERAND_TYPE_NONE
},
6171 { "INDNTPOFF",{ BFD_RELOC_386_TLS_IE
,
6172 _dummy_first_bfd_reloc_code_real
},
6173 OPERAND_TYPE_NONE
},
6174 { "GOT", { BFD_RELOC_386_GOT32
,
6175 BFD_RELOC_X86_64_GOT32
},
6176 OPERAND_TYPE_IMM32_32S_64_DISP32
},
6177 { "TLSDESC", { BFD_RELOC_386_TLS_GOTDESC
,
6178 BFD_RELOC_X86_64_GOTPC32_TLSDESC
},
6179 OPERAND_TYPE_IMM32_32S_DISP32
},
6180 { "TLSCALL", { BFD_RELOC_386_TLS_DESC_CALL
,
6181 BFD_RELOC_X86_64_TLSDESC_CALL
},
6182 OPERAND_TYPE_IMM32_32S_DISP32
},
6190 for (cp
= input_line_pointer
; *cp
!= '@'; cp
++)
6191 if (is_end_of_line
[(unsigned char) *cp
] || *cp
== ',')
6194 for (j
= 0; j
< ARRAY_SIZE (gotrel
); j
++)
6198 len
= strlen (gotrel
[j
].str
);
6199 if (strncasecmp (cp
+ 1, gotrel
[j
].str
, len
) == 0)
6201 if (gotrel
[j
].rel
[object_64bit
] != 0)
6204 char *tmpbuf
, *past_reloc
;
6206 *rel
= gotrel
[j
].rel
[object_64bit
];
6212 if (flag_code
!= CODE_64BIT
)
6214 types
->bitfield
.imm32
= 1;
6215 types
->bitfield
.disp32
= 1;
6218 *types
= gotrel
[j
].types64
;
6221 if (GOT_symbol
== NULL
)
6222 GOT_symbol
= symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME
);
6224 /* The length of the first part of our input line. */
6225 first
= cp
- input_line_pointer
;
6227 /* The second part goes from after the reloc token until
6228 (and including) an end_of_line char or comma. */
6229 past_reloc
= cp
+ 1 + len
;
6231 while (!is_end_of_line
[(unsigned char) *cp
] && *cp
!= ',')
6233 second
= cp
+ 1 - past_reloc
;
6235 /* Allocate and copy string. The trailing NUL shouldn't
6236 be necessary, but be safe. */
6237 tmpbuf
= (char *) xmalloc (first
+ second
+ 2);
6238 memcpy (tmpbuf
, input_line_pointer
, first
);
6239 if (second
!= 0 && *past_reloc
!= ' ')
6240 /* Replace the relocation token with ' ', so that
6241 errors like foo@GOTOFF1 will be detected. */
6242 tmpbuf
[first
++] = ' ';
6243 memcpy (tmpbuf
+ first
, past_reloc
, second
);
6244 tmpbuf
[first
+ second
] = '\0';
6248 as_bad (_("@%s reloc is not supported with %d-bit output format"),
6249 gotrel
[j
].str
, 1 << (5 + object_64bit
));
6254 /* Might be a symbol version string. Don't as_bad here. */
6259 x86_cons (expressionS
*exp
, int size
)
6261 intel_syntax
= -intel_syntax
;
6263 if (size
== 4 || (object_64bit
&& size
== 8))
6265 /* Handle @GOTOFF and the like in an expression. */
6267 char *gotfree_input_line
;
6270 save
= input_line_pointer
;
6271 gotfree_input_line
= lex_got (&got_reloc
, &adjust
, NULL
);
6272 if (gotfree_input_line
)
6273 input_line_pointer
= gotfree_input_line
;
6277 if (gotfree_input_line
)
6279 /* expression () has merrily parsed up to the end of line,
6280 or a comma - in the wrong buffer. Transfer how far
6281 input_line_pointer has moved to the right buffer. */
6282 input_line_pointer
= (save
6283 + (input_line_pointer
- gotfree_input_line
)
6285 free (gotfree_input_line
);
6286 if (exp
->X_op
== O_constant
6287 || exp
->X_op
== O_absent
6288 || exp
->X_op
== O_illegal
6289 || exp
->X_op
== O_register
6290 || exp
->X_op
== O_big
)
6292 char c
= *input_line_pointer
;
6293 *input_line_pointer
= 0;
6294 as_bad (_("missing or invalid expression `%s'"), save
);
6295 *input_line_pointer
= c
;
6302 intel_syntax
= -intel_syntax
;
6305 i386_intel_simplify (exp
);
6310 signed_cons (int size
)
6312 if (flag_code
== CODE_64BIT
)
6320 pe_directive_secrel (dummy
)
6321 int dummy ATTRIBUTE_UNUSED
;
6328 if (exp
.X_op
== O_symbol
)
6329 exp
.X_op
= O_secrel
;
6331 emit_expr (&exp
, 4);
6333 while (*input_line_pointer
++ == ',');
6335 input_line_pointer
--;
6336 demand_empty_rest_of_line ();
6341 i386_immediate (char *imm_start
)
6343 char *save_input_line_pointer
;
6344 char *gotfree_input_line
;
6347 i386_operand_type types
;
6349 operand_type_set (&types
, ~0);
6351 if (i
.imm_operands
== MAX_IMMEDIATE_OPERANDS
)
6353 as_bad (_("at most %d immediate operands are allowed"),
6354 MAX_IMMEDIATE_OPERANDS
);
6358 exp
= &im_expressions
[i
.imm_operands
++];
6359 i
.op
[this_operand
].imms
= exp
;
6361 if (is_space_char (*imm_start
))
6364 save_input_line_pointer
= input_line_pointer
;
6365 input_line_pointer
= imm_start
;
6367 gotfree_input_line
= lex_got (&i
.reloc
[this_operand
], NULL
, &types
);
6368 if (gotfree_input_line
)
6369 input_line_pointer
= gotfree_input_line
;
6371 exp_seg
= expression (exp
);
6374 if (*input_line_pointer
)
6375 as_bad (_("junk `%s' after expression"), input_line_pointer
);
6377 input_line_pointer
= save_input_line_pointer
;
6378 if (gotfree_input_line
)
6380 free (gotfree_input_line
);
6382 if (exp
->X_op
== O_constant
|| exp
->X_op
== O_register
)
6383 exp
->X_op
= O_illegal
;
6386 return i386_finalize_immediate (exp_seg
, exp
, types
, imm_start
);
6390 i386_finalize_immediate (segT exp_seg ATTRIBUTE_UNUSED
, expressionS
*exp
,
6391 i386_operand_type types
, const char *imm_start
)
6393 if (exp
->X_op
== O_absent
|| exp
->X_op
== O_illegal
|| exp
->X_op
== O_big
)
6396 as_bad (_("missing or invalid immediate expression `%s'"),
6400 else if (exp
->X_op
== O_constant
)
6402 /* Size it properly later. */
6403 i
.types
[this_operand
].bitfield
.imm64
= 1;
6404 /* If BFD64, sign extend val. */
6405 if (!use_rela_relocations
6406 && (exp
->X_add_number
& ~(((addressT
) 2 << 31) - 1)) == 0)
6408 = (exp
->X_add_number
^ ((addressT
) 1 << 31)) - ((addressT
) 1 << 31);
6410 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
6411 else if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
6412 && exp_seg
!= absolute_section
6413 && exp_seg
!= text_section
6414 && exp_seg
!= data_section
6415 && exp_seg
!= bss_section
6416 && exp_seg
!= undefined_section
6417 && !bfd_is_com_section (exp_seg
))
6419 as_bad (_("unimplemented segment %s in operand"), exp_seg
->name
);
6423 else if (!intel_syntax
&& exp
->X_op
== O_register
)
6426 as_bad (_("illegal immediate register operand %s"), imm_start
);
6431 /* This is an address. The size of the address will be
6432 determined later, depending on destination register,
6433 suffix, or the default for the section. */
6434 i
.types
[this_operand
].bitfield
.imm8
= 1;
6435 i
.types
[this_operand
].bitfield
.imm16
= 1;
6436 i
.types
[this_operand
].bitfield
.imm32
= 1;
6437 i
.types
[this_operand
].bitfield
.imm32s
= 1;
6438 i
.types
[this_operand
].bitfield
.imm64
= 1;
6439 i
.types
[this_operand
] = operand_type_and (i
.types
[this_operand
],
6447 i386_scale (char *scale
)
6450 char *save
= input_line_pointer
;
6452 input_line_pointer
= scale
;
6453 val
= get_absolute_expression ();
6458 i
.log2_scale_factor
= 0;
6461 i
.log2_scale_factor
= 1;
6464 i
.log2_scale_factor
= 2;
6467 i
.log2_scale_factor
= 3;
6471 char sep
= *input_line_pointer
;
6473 *input_line_pointer
= '\0';
6474 as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
6476 *input_line_pointer
= sep
;
6477 input_line_pointer
= save
;
6481 if (i
.log2_scale_factor
!= 0 && i
.index_reg
== 0)
6483 as_warn (_("scale factor of %d without an index register"),
6484 1 << i
.log2_scale_factor
);
6485 i
.log2_scale_factor
= 0;
6487 scale
= input_line_pointer
;
6488 input_line_pointer
= save
;
6493 i386_displacement (char *disp_start
, char *disp_end
)
6497 char *save_input_line_pointer
;
6498 char *gotfree_input_line
;
6500 i386_operand_type bigdisp
, types
= anydisp
;
6503 if (i
.disp_operands
== MAX_MEMORY_OPERANDS
)
6505 as_bad (_("at most %d displacement operands are allowed"),
6506 MAX_MEMORY_OPERANDS
);
6510 operand_type_set (&bigdisp
, 0);
6511 if ((i
.types
[this_operand
].bitfield
.jumpabsolute
)
6512 || (!current_templates
->start
->opcode_modifier
.jump
6513 && !current_templates
->start
->opcode_modifier
.jumpdword
))
6515 bigdisp
.bitfield
.disp32
= 1;
6516 override
= (i
.prefix
[ADDR_PREFIX
] != 0);
6517 if (flag_code
== CODE_64BIT
)
6521 bigdisp
.bitfield
.disp32s
= 1;
6522 bigdisp
.bitfield
.disp64
= 1;
6525 else if ((flag_code
== CODE_16BIT
) ^ override
)
6527 bigdisp
.bitfield
.disp32
= 0;
6528 bigdisp
.bitfield
.disp16
= 1;
6533 /* For PC-relative branches, the width of the displacement
6534 is dependent upon data size, not address size. */
6535 override
= (i
.prefix
[DATA_PREFIX
] != 0);
6536 if (flag_code
== CODE_64BIT
)
6538 if (override
|| i
.suffix
== WORD_MNEM_SUFFIX
)
6539 bigdisp
.bitfield
.disp16
= 1;
6542 bigdisp
.bitfield
.disp32
= 1;
6543 bigdisp
.bitfield
.disp32s
= 1;
6549 override
= (i
.suffix
== (flag_code
!= CODE_16BIT
6551 : LONG_MNEM_SUFFIX
));
6552 bigdisp
.bitfield
.disp32
= 1;
6553 if ((flag_code
== CODE_16BIT
) ^ override
)
6555 bigdisp
.bitfield
.disp32
= 0;
6556 bigdisp
.bitfield
.disp16
= 1;
6560 i
.types
[this_operand
] = operand_type_or (i
.types
[this_operand
],
6563 exp
= &disp_expressions
[i
.disp_operands
];
6564 i
.op
[this_operand
].disps
= exp
;
6566 save_input_line_pointer
= input_line_pointer
;
6567 input_line_pointer
= disp_start
;
6568 END_STRING_AND_SAVE (disp_end
);
6570 #ifndef GCC_ASM_O_HACK
6571 #define GCC_ASM_O_HACK 0
6574 END_STRING_AND_SAVE (disp_end
+ 1);
6575 if (i
.types
[this_operand
].bitfield
.baseIndex
6576 && displacement_string_end
[-1] == '+')
6578 /* This hack is to avoid a warning when using the "o"
6579 constraint within gcc asm statements.
6582 #define _set_tssldt_desc(n,addr,limit,type) \
6583 __asm__ __volatile__ ( \
6585 "movw %w1,2+%0\n\t" \
6587 "movb %b1,4+%0\n\t" \
6588 "movb %4,5+%0\n\t" \
6589 "movb $0,6+%0\n\t" \
6590 "movb %h1,7+%0\n\t" \
6592 : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
6594 This works great except that the output assembler ends
6595 up looking a bit weird if it turns out that there is
6596 no offset. You end up producing code that looks like:
6609 So here we provide the missing zero. */
6611 *displacement_string_end
= '0';
6614 gotfree_input_line
= lex_got (&i
.reloc
[this_operand
], NULL
, &types
);
6615 if (gotfree_input_line
)
6616 input_line_pointer
= gotfree_input_line
;
6618 exp_seg
= expression (exp
);
6621 if (*input_line_pointer
)
6622 as_bad (_("junk `%s' after expression"), input_line_pointer
);
6624 RESTORE_END_STRING (disp_end
+ 1);
6626 input_line_pointer
= save_input_line_pointer
;
6627 if (gotfree_input_line
)
6629 free (gotfree_input_line
);
6631 if (exp
->X_op
== O_constant
|| exp
->X_op
== O_register
)
6632 exp
->X_op
= O_illegal
;
6635 ret
= i386_finalize_displacement (exp_seg
, exp
, types
, disp_start
);
6637 RESTORE_END_STRING (disp_end
);
6643 i386_finalize_displacement (segT exp_seg ATTRIBUTE_UNUSED
, expressionS
*exp
,
6644 i386_operand_type types
, const char *disp_start
)
6646 i386_operand_type bigdisp
;
6649 /* We do this to make sure that the section symbol is in
6650 the symbol table. We will ultimately change the relocation
6651 to be relative to the beginning of the section. */
6652 if (i
.reloc
[this_operand
] == BFD_RELOC_386_GOTOFF
6653 || i
.reloc
[this_operand
] == BFD_RELOC_X86_64_GOTPCREL
6654 || i
.reloc
[this_operand
] == BFD_RELOC_X86_64_GOTOFF64
)
6656 if (exp
->X_op
!= O_symbol
)
6659 if (S_IS_LOCAL (exp
->X_add_symbol
)
6660 && S_GET_SEGMENT (exp
->X_add_symbol
) != undefined_section
)
6661 section_symbol (S_GET_SEGMENT (exp
->X_add_symbol
));
6662 exp
->X_op
= O_subtract
;
6663 exp
->X_op_symbol
= GOT_symbol
;
6664 if (i
.reloc
[this_operand
] == BFD_RELOC_X86_64_GOTPCREL
)
6665 i
.reloc
[this_operand
] = BFD_RELOC_32_PCREL
;
6666 else if (i
.reloc
[this_operand
] == BFD_RELOC_X86_64_GOTOFF64
)
6667 i
.reloc
[this_operand
] = BFD_RELOC_64
;
6669 i
.reloc
[this_operand
] = BFD_RELOC_32
;
6672 else if (exp
->X_op
== O_absent
6673 || exp
->X_op
== O_illegal
6674 || exp
->X_op
== O_big
)
6677 as_bad (_("missing or invalid displacement expression `%s'"),
6682 else if (flag_code
== CODE_64BIT
6683 && !i
.prefix
[ADDR_PREFIX
]
6684 && exp
->X_op
== O_constant
)
6686 /* Since displacement is signed extended to 64bit, don't allow
6687 disp32 and turn off disp32s if they are out of range. */
6688 i
.types
[this_operand
].bitfield
.disp32
= 0;
6689 if (!fits_in_signed_long (exp
->X_add_number
))
6691 i
.types
[this_operand
].bitfield
.disp32s
= 0;
6692 if (i
.types
[this_operand
].bitfield
.baseindex
)
6694 as_bad (_("0x%lx out range of signed 32bit displacement"),
6695 (long) exp
->X_add_number
);
6701 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
6702 else if (exp
->X_op
!= O_constant
6703 && OUTPUT_FLAVOR
== bfd_target_aout_flavour
6704 && exp_seg
!= absolute_section
6705 && exp_seg
!= text_section
6706 && exp_seg
!= data_section
6707 && exp_seg
!= bss_section
6708 && exp_seg
!= undefined_section
6709 && !bfd_is_com_section (exp_seg
))
6711 as_bad (_("unimplemented segment %s in operand"), exp_seg
->name
);
6716 /* Check if this is a displacement only operand. */
6717 bigdisp
= i
.types
[this_operand
];
6718 bigdisp
.bitfield
.disp8
= 0;
6719 bigdisp
.bitfield
.disp16
= 0;
6720 bigdisp
.bitfield
.disp32
= 0;
6721 bigdisp
.bitfield
.disp32s
= 0;
6722 bigdisp
.bitfield
.disp64
= 0;
6723 if (operand_type_all_zero (&bigdisp
))
6724 i
.types
[this_operand
] = operand_type_and (i
.types
[this_operand
],
6730 /* Make sure the memory operand we've been dealt is valid.
6731 Return 1 on success, 0 on a failure. */
6734 i386_index_check (const char *operand_string
)
6737 const char *kind
= "base/index";
6738 #if INFER_ADDR_PREFIX
6744 if (current_templates
->start
->opcode_modifier
.isstring
6745 && !current_templates
->start
->opcode_modifier
.immext
6746 && (current_templates
->end
[-1].opcode_modifier
.isstring
6749 /* Memory operands of string insns are special in that they only allow
6750 a single register (rDI, rSI, or rBX) as their memory address. */
6751 unsigned int expected
;
6753 kind
= "string address";
6755 if (current_templates
->start
->opcode_modifier
.w
)
6757 i386_operand_type type
= current_templates
->end
[-1].operand_types
[0];
6759 if (!type
.bitfield
.baseindex
6760 || ((!i
.mem_operands
!= !intel_syntax
)
6761 && current_templates
->end
[-1].operand_types
[1]
6762 .bitfield
.baseindex
))
6763 type
= current_templates
->end
[-1].operand_types
[1];
6764 expected
= type
.bitfield
.esseg
? 7 /* rDI */ : 6 /* rSI */;
6767 expected
= 3 /* rBX */;
6769 if (!i
.base_reg
|| i
.index_reg
6770 || operand_type_check (i
.types
[this_operand
], disp
))
6772 else if (!(flag_code
== CODE_64BIT
6773 ? i
.prefix
[ADDR_PREFIX
]
6774 ? i
.base_reg
->reg_type
.bitfield
.reg32
6775 : i
.base_reg
->reg_type
.bitfield
.reg64
6776 : (flag_code
== CODE_16BIT
) ^ !i
.prefix
[ADDR_PREFIX
]
6777 ? i
.base_reg
->reg_type
.bitfield
.reg32
6778 : i
.base_reg
->reg_type
.bitfield
.reg16
))
6780 else if (i
.base_reg
->reg_num
!= expected
)
6787 for (j
= 0; j
< i386_regtab_size
; ++j
)
6788 if ((flag_code
== CODE_64BIT
6789 ? i
.prefix
[ADDR_PREFIX
]
6790 ? i386_regtab
[j
].reg_type
.bitfield
.reg32
6791 : i386_regtab
[j
].reg_type
.bitfield
.reg64
6792 : (flag_code
== CODE_16BIT
) ^ !i
.prefix
[ADDR_PREFIX
]
6793 ? i386_regtab
[j
].reg_type
.bitfield
.reg32
6794 : i386_regtab
[j
].reg_type
.bitfield
.reg16
)
6795 && i386_regtab
[j
].reg_num
== expected
)
6797 gas_assert (j
< i386_regtab_size
);
6798 as_warn (_("`%s' is not valid here (expected `%c%s%s%c')"),
6800 intel_syntax
? '[' : '(',
6802 i386_regtab
[j
].reg_name
,
6803 intel_syntax
? ']' : ')');
6807 else if (flag_code
== CODE_64BIT
)
6810 && ((i
.prefix
[ADDR_PREFIX
] == 0
6811 && !i
.base_reg
->reg_type
.bitfield
.reg64
)
6812 || (i
.prefix
[ADDR_PREFIX
]
6813 && !i
.base_reg
->reg_type
.bitfield
.reg32
))
6815 || i
.base_reg
->reg_num
!=
6816 (i
.prefix
[ADDR_PREFIX
] == 0 ? RegRip
: RegEip
)))
6818 && (!i
.index_reg
->reg_type
.bitfield
.baseindex
6819 || (i
.prefix
[ADDR_PREFIX
] == 0
6820 && i
.index_reg
->reg_num
!= RegRiz
6821 && !i
.index_reg
->reg_type
.bitfield
.reg64
6823 || (i
.prefix
[ADDR_PREFIX
]
6824 && i
.index_reg
->reg_num
!= RegEiz
6825 && !i
.index_reg
->reg_type
.bitfield
.reg32
))))
6830 if ((flag_code
== CODE_16BIT
) ^ (i
.prefix
[ADDR_PREFIX
] != 0))
6834 && (!i
.base_reg
->reg_type
.bitfield
.reg16
6835 || !i
.base_reg
->reg_type
.bitfield
.baseindex
))
6837 && (!i
.index_reg
->reg_type
.bitfield
.reg16
6838 || !i
.index_reg
->reg_type
.bitfield
.baseindex
6840 && i
.base_reg
->reg_num
< 6
6841 && i
.index_reg
->reg_num
>= 6
6842 && i
.log2_scale_factor
== 0))))
6849 && !i
.base_reg
->reg_type
.bitfield
.reg32
)
6851 && ((!i
.index_reg
->reg_type
.bitfield
.reg32
6852 && i
.index_reg
->reg_num
!= RegEiz
)
6853 || !i
.index_reg
->reg_type
.bitfield
.baseindex
)))
6859 #if INFER_ADDR_PREFIX
6860 if (!i
.mem_operands
&& !i
.prefix
[ADDR_PREFIX
])
6862 i
.prefix
[ADDR_PREFIX
] = ADDR_PREFIX_OPCODE
;
6864 /* Change the size of any displacement too. At most one of
6865 Disp16 or Disp32 is set.
6866 FIXME. There doesn't seem to be any real need for separate
6867 Disp16 and Disp32 flags. The same goes for Imm16 and Imm32.
6868 Removing them would probably clean up the code quite a lot. */
6869 if (flag_code
!= CODE_64BIT
6870 && (i
.types
[this_operand
].bitfield
.disp16
6871 || i
.types
[this_operand
].bitfield
.disp32
))
6872 i
.types
[this_operand
]
6873 = operand_type_xor (i
.types
[this_operand
], disp16_32
);
6878 as_bad (_("`%s' is not a valid %s expression"),
6883 as_bad (_("`%s' is not a valid %s-bit %s expression"),
6885 flag_code_names
[i
.prefix
[ADDR_PREFIX
]
6886 ? flag_code
== CODE_32BIT
6895 /* Parse OPERAND_STRING into the i386_insn structure I. Returns zero
6899 i386_att_operand (char *operand_string
)
6903 char *op_string
= operand_string
;
6905 if (is_space_char (*op_string
))
6908 /* We check for an absolute prefix (differentiating,
6909 for example, 'jmp pc_relative_label' from 'jmp *absolute_label'. */
6910 if (*op_string
== ABSOLUTE_PREFIX
)
6913 if (is_space_char (*op_string
))
6915 i
.types
[this_operand
].bitfield
.jumpabsolute
= 1;
6918 /* Check if operand is a register. */
6919 if ((r
= parse_register (op_string
, &end_op
)) != NULL
)
6921 i386_operand_type temp
;
6923 /* Check for a segment override by searching for ':' after a
6924 segment register. */
6926 if (is_space_char (*op_string
))
6928 if (*op_string
== ':'
6929 && (r
->reg_type
.bitfield
.sreg2
6930 || r
->reg_type
.bitfield
.sreg3
))
6935 i
.seg
[i
.mem_operands
] = &es
;
6938 i
.seg
[i
.mem_operands
] = &cs
;
6941 i
.seg
[i
.mem_operands
] = &ss
;
6944 i
.seg
[i
.mem_operands
] = &ds
;
6947 i
.seg
[i
.mem_operands
] = &fs
;
6950 i
.seg
[i
.mem_operands
] = &gs
;
6954 /* Skip the ':' and whitespace. */
6956 if (is_space_char (*op_string
))
6959 if (!is_digit_char (*op_string
)
6960 && !is_identifier_char (*op_string
)
6961 && *op_string
!= '('
6962 && *op_string
!= ABSOLUTE_PREFIX
)
6964 as_bad (_("bad memory operand `%s'"), op_string
);
6967 /* Handle case of %es:*foo. */
6968 if (*op_string
== ABSOLUTE_PREFIX
)
6971 if (is_space_char (*op_string
))
6973 i
.types
[this_operand
].bitfield
.jumpabsolute
= 1;
6975 goto do_memory_reference
;
6979 as_bad (_("junk `%s' after register"), op_string
);
6983 temp
.bitfield
.baseindex
= 0;
6984 i
.types
[this_operand
] = operand_type_or (i
.types
[this_operand
],
6986 i
.types
[this_operand
].bitfield
.unspecified
= 0;
6987 i
.op
[this_operand
].regs
= r
;
6990 else if (*op_string
== REGISTER_PREFIX
)
6992 as_bad (_("bad register name `%s'"), op_string
);
6995 else if (*op_string
== IMMEDIATE_PREFIX
)
6998 if (i
.types
[this_operand
].bitfield
.jumpabsolute
)
7000 as_bad (_("immediate operand illegal with absolute jump"));
7003 if (!i386_immediate (op_string
))
7006 else if (is_digit_char (*op_string
)
7007 || is_identifier_char (*op_string
)
7008 || *op_string
== '(')
7010 /* This is a memory reference of some sort. */
7013 /* Start and end of displacement string expression (if found). */
7014 char *displacement_string_start
;
7015 char *displacement_string_end
;
7017 do_memory_reference
:
7018 if ((i
.mem_operands
== 1
7019 && !current_templates
->start
->opcode_modifier
.isstring
)
7020 || i
.mem_operands
== 2)
7022 as_bad (_("too many memory references for `%s'"),
7023 current_templates
->start
->name
);
7027 /* Check for base index form. We detect the base index form by
7028 looking for an ')' at the end of the operand, searching
7029 for the '(' matching it, and finding a REGISTER_PREFIX or ','
7031 base_string
= op_string
+ strlen (op_string
);
7034 if (is_space_char (*base_string
))
7037 /* If we only have a displacement, set-up for it to be parsed later. */
7038 displacement_string_start
= op_string
;
7039 displacement_string_end
= base_string
+ 1;
7041 if (*base_string
== ')')
7044 unsigned int parens_balanced
= 1;
7045 /* We've already checked that the number of left & right ()'s are
7046 equal, so this loop will not be infinite. */
7050 if (*base_string
== ')')
7052 if (*base_string
== '(')
7055 while (parens_balanced
);
7057 temp_string
= base_string
;
7059 /* Skip past '(' and whitespace. */
7061 if (is_space_char (*base_string
))
7064 if (*base_string
== ','
7065 || ((i
.base_reg
= parse_register (base_string
, &end_op
))
7068 displacement_string_end
= temp_string
;
7070 i
.types
[this_operand
].bitfield
.baseindex
= 1;
7074 base_string
= end_op
;
7075 if (is_space_char (*base_string
))
7079 /* There may be an index reg or scale factor here. */
7080 if (*base_string
== ',')
7083 if (is_space_char (*base_string
))
7086 if ((i
.index_reg
= parse_register (base_string
, &end_op
))
7089 base_string
= end_op
;
7090 if (is_space_char (*base_string
))
7092 if (*base_string
== ',')
7095 if (is_space_char (*base_string
))
7098 else if (*base_string
!= ')')
7100 as_bad (_("expecting `,' or `)' "
7101 "after index register in `%s'"),
7106 else if (*base_string
== REGISTER_PREFIX
)
7108 as_bad (_("bad register name `%s'"), base_string
);
7112 /* Check for scale factor. */
7113 if (*base_string
!= ')')
7115 char *end_scale
= i386_scale (base_string
);
7120 base_string
= end_scale
;
7121 if (is_space_char (*base_string
))
7123 if (*base_string
!= ')')
7125 as_bad (_("expecting `)' "
7126 "after scale factor in `%s'"),
7131 else if (!i
.index_reg
)
7133 as_bad (_("expecting index register or scale factor "
7134 "after `,'; got '%c'"),
7139 else if (*base_string
!= ')')
7141 as_bad (_("expecting `,' or `)' "
7142 "after base register in `%s'"),
7147 else if (*base_string
== REGISTER_PREFIX
)
7149 as_bad (_("bad register name `%s'"), base_string
);
7154 /* If there's an expression beginning the operand, parse it,
7155 assuming displacement_string_start and
7156 displacement_string_end are meaningful. */
7157 if (displacement_string_start
!= displacement_string_end
)
7159 if (!i386_displacement (displacement_string_start
,
7160 displacement_string_end
))
7164 /* Special case for (%dx) while doing input/output op. */
7166 && operand_type_equal (&i
.base_reg
->reg_type
,
7167 ®16_inoutportreg
)
7169 && i
.log2_scale_factor
== 0
7170 && i
.seg
[i
.mem_operands
] == 0
7171 && !operand_type_check (i
.types
[this_operand
], disp
))
7173 i
.types
[this_operand
] = inoutportreg
;
7177 if (i386_index_check (operand_string
) == 0)
7179 i
.types
[this_operand
].bitfield
.mem
= 1;
7184 /* It's not a memory operand; argh! */
7185 as_bad (_("invalid char %s beginning operand %d `%s'"),
7186 output_invalid (*op_string
),
7191 return 1; /* Normal return. */
7194 /* md_estimate_size_before_relax()
7196 Called just before relax() for rs_machine_dependent frags. The x86
7197 assembler uses these frags to handle variable size jump
7200 Any symbol that is now undefined will not become defined.
7201 Return the correct fr_subtype in the frag.
7202 Return the initial "guess for variable size of frag" to caller.
7203 The guess is actually the growth beyond the fixed part. Whatever
7204 we do to grow the fixed or variable part contributes to our
7208 md_estimate_size_before_relax (fragP
, segment
)
7212 /* We've already got fragP->fr_subtype right; all we have to do is
7213 check for un-relaxable symbols. On an ELF system, we can't relax
7214 an externally visible symbol, because it may be overridden by a
7216 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
7217 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7219 && (S_IS_EXTERNAL (fragP
->fr_symbol
)
7220 || S_IS_WEAK (fragP
->fr_symbol
)
7221 || ((symbol_get_bfdsym (fragP
->fr_symbol
)->flags
7222 & BSF_GNU_INDIRECT_FUNCTION
))))
7224 #if defined (OBJ_COFF) && defined (TE_PE)
7225 || (OUTPUT_FLAVOR
== bfd_target_coff_flavour
7226 && S_IS_WEAK (fragP
->fr_symbol
))
7230 /* Symbol is undefined in this segment, or we need to keep a
7231 reloc so that weak symbols can be overridden. */
7232 int size
= (fragP
->fr_subtype
& CODE16
) ? 2 : 4;
7233 enum bfd_reloc_code_real reloc_type
;
7234 unsigned char *opcode
;
7237 if (fragP
->fr_var
!= NO_RELOC
)
7238 reloc_type
= (enum bfd_reloc_code_real
) fragP
->fr_var
;
7240 reloc_type
= BFD_RELOC_16_PCREL
;
7242 reloc_type
= BFD_RELOC_32_PCREL
;
7244 old_fr_fix
= fragP
->fr_fix
;
7245 opcode
= (unsigned char *) fragP
->fr_opcode
;
7247 switch (TYPE_FROM_RELAX_STATE (fragP
->fr_subtype
))
7250 /* Make jmp (0xeb) a (d)word displacement jump. */
7252 fragP
->fr_fix
+= size
;
7253 fix_new (fragP
, old_fr_fix
, size
,
7255 fragP
->fr_offset
, 1,
7261 && (!no_cond_jump_promotion
|| fragP
->fr_var
!= NO_RELOC
))
7263 /* Negate the condition, and branch past an
7264 unconditional jump. */
7267 /* Insert an unconditional jump. */
7269 /* We added two extra opcode bytes, and have a two byte
7271 fragP
->fr_fix
+= 2 + 2;
7272 fix_new (fragP
, old_fr_fix
+ 2, 2,
7274 fragP
->fr_offset
, 1,
7281 if (no_cond_jump_promotion
&& fragP
->fr_var
== NO_RELOC
)
7286 fixP
= fix_new (fragP
, old_fr_fix
, 1,
7288 fragP
->fr_offset
, 1,
7290 fixP
->fx_signed
= 1;
7294 /* This changes the byte-displacement jump 0x7N
7295 to the (d)word-displacement jump 0x0f,0x8N. */
7296 opcode
[1] = opcode
[0] + 0x10;
7297 opcode
[0] = TWO_BYTE_OPCODE_ESCAPE
;
7298 /* We've added an opcode byte. */
7299 fragP
->fr_fix
+= 1 + size
;
7300 fix_new (fragP
, old_fr_fix
+ 1, size
,
7302 fragP
->fr_offset
, 1,
7307 BAD_CASE (fragP
->fr_subtype
);
7311 return fragP
->fr_fix
- old_fr_fix
;
7314 /* Guess size depending on current relax state. Initially the relax
7315 state will correspond to a short jump and we return 1, because
7316 the variable part of the frag (the branch offset) is one byte
7317 long. However, we can relax a section more than once and in that
7318 case we must either set fr_subtype back to the unrelaxed state,
7319 or return the value for the appropriate branch. */
7320 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
7323 /* Called after relax() is finished.
7325 In: Address of frag.
7326 fr_type == rs_machine_dependent.
7327 fr_subtype is what the address relaxed to.
7329 Out: Any fixSs and constants are set up.
7330 Caller will turn frag into a ".space 0". */
7333 md_convert_frag (abfd
, sec
, fragP
)
7334 bfd
*abfd ATTRIBUTE_UNUSED
;
7335 segT sec ATTRIBUTE_UNUSED
;
7338 unsigned char *opcode
;
7339 unsigned char *where_to_put_displacement
= NULL
;
7340 offsetT target_address
;
7341 offsetT opcode_address
;
7342 unsigned int extension
= 0;
7343 offsetT displacement_from_opcode_start
;
7345 opcode
= (unsigned char *) fragP
->fr_opcode
;
7347 /* Address we want to reach in file space. */
7348 target_address
= S_GET_VALUE (fragP
->fr_symbol
) + fragP
->fr_offset
;
7350 /* Address opcode resides at in file space. */
7351 opcode_address
= fragP
->fr_address
+ fragP
->fr_fix
;
7353 /* Displacement from opcode start to fill into instruction. */
7354 displacement_from_opcode_start
= target_address
- opcode_address
;
7356 if ((fragP
->fr_subtype
& BIG
) == 0)
7358 /* Don't have to change opcode. */
7359 extension
= 1; /* 1 opcode + 1 displacement */
7360 where_to_put_displacement
= &opcode
[1];
7364 if (no_cond_jump_promotion
7365 && TYPE_FROM_RELAX_STATE (fragP
->fr_subtype
) != UNCOND_JUMP
)
7366 as_warn_where (fragP
->fr_file
, fragP
->fr_line
,
7367 _("long jump required"));
7369 switch (fragP
->fr_subtype
)
7371 case ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG
):
7372 extension
= 4; /* 1 opcode + 4 displacement */
7374 where_to_put_displacement
= &opcode
[1];
7377 case ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG16
):
7378 extension
= 2; /* 1 opcode + 2 displacement */
7380 where_to_put_displacement
= &opcode
[1];
7383 case ENCODE_RELAX_STATE (COND_JUMP
, BIG
):
7384 case ENCODE_RELAX_STATE (COND_JUMP86
, BIG
):
7385 extension
= 5; /* 2 opcode + 4 displacement */
7386 opcode
[1] = opcode
[0] + 0x10;
7387 opcode
[0] = TWO_BYTE_OPCODE_ESCAPE
;
7388 where_to_put_displacement
= &opcode
[2];
7391 case ENCODE_RELAX_STATE (COND_JUMP
, BIG16
):
7392 extension
= 3; /* 2 opcode + 2 displacement */
7393 opcode
[1] = opcode
[0] + 0x10;
7394 opcode
[0] = TWO_BYTE_OPCODE_ESCAPE
;
7395 where_to_put_displacement
= &opcode
[2];
7398 case ENCODE_RELAX_STATE (COND_JUMP86
, BIG16
):
7403 where_to_put_displacement
= &opcode
[3];
7407 BAD_CASE (fragP
->fr_subtype
);
7412 /* If size if less then four we are sure that the operand fits,
7413 but if it's 4, then it could be that the displacement is larger
7415 if (DISP_SIZE_FROM_RELAX_STATE (fragP
->fr_subtype
) == 4
7417 && ((addressT
) (displacement_from_opcode_start
- extension
7418 + ((addressT
) 1 << 31))
7419 > (((addressT
) 2 << 31) - 1)))
7421 as_bad_where (fragP
->fr_file
, fragP
->fr_line
,
7422 _("jump target out of range"));
7423 /* Make us emit 0. */
7424 displacement_from_opcode_start
= extension
;
7426 /* Now put displacement after opcode. */
7427 md_number_to_chars ((char *) where_to_put_displacement
,
7428 (valueT
) (displacement_from_opcode_start
- extension
),
7429 DISP_SIZE_FROM_RELAX_STATE (fragP
->fr_subtype
));
7430 fragP
->fr_fix
+= extension
;
7433 /* Apply a fixup (fixS) to segment data, once it has been determined
7434 by our caller that we have all the info we need to fix it up.
7436 On the 386, immediates, displacements, and data pointers are all in
7437 the same (little-endian) format, so we don't need to care about which
7441 md_apply_fix (fixP
, valP
, seg
)
7442 /* The fix we're to put in. */
7444 /* Pointer to the value of the bits. */
7446 /* Segment fix is from. */
7447 segT seg ATTRIBUTE_UNUSED
;
7449 char *p
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
7450 valueT value
= *valP
;
7452 #if !defined (TE_Mach)
7455 switch (fixP
->fx_r_type
)
7461 fixP
->fx_r_type
= BFD_RELOC_64_PCREL
;
7464 case BFD_RELOC_X86_64_32S
:
7465 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
7468 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
7471 fixP
->fx_r_type
= BFD_RELOC_8_PCREL
;
7476 if (fixP
->fx_addsy
!= NULL
7477 && (fixP
->fx_r_type
== BFD_RELOC_32_PCREL
7478 || fixP
->fx_r_type
== BFD_RELOC_64_PCREL
7479 || fixP
->fx_r_type
== BFD_RELOC_16_PCREL
7480 || fixP
->fx_r_type
== BFD_RELOC_8_PCREL
)
7481 && !use_rela_relocations
)
7483 /* This is a hack. There should be a better way to handle this.
7484 This covers for the fact that bfd_install_relocation will
7485 subtract the current location (for partial_inplace, PC relative
7486 relocations); see more below. */
7490 || OUTPUT_FLAVOR
== bfd_target_coff_flavour
7493 value
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
7495 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7498 segT sym_seg
= S_GET_SEGMENT (fixP
->fx_addsy
);
7501 || (symbol_section_p (fixP
->fx_addsy
)
7502 && sym_seg
!= absolute_section
))
7503 && !generic_force_reloc (fixP
))
7505 /* Yes, we add the values in twice. This is because
7506 bfd_install_relocation subtracts them out again. I think
7507 bfd_install_relocation is broken, but I don't dare change
7509 value
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
7513 #if defined (OBJ_COFF) && defined (TE_PE)
7514 /* For some reason, the PE format does not store a
7515 section address offset for a PC relative symbol. */
7516 if (S_GET_SEGMENT (fixP
->fx_addsy
) != seg
7517 || S_IS_WEAK (fixP
->fx_addsy
))
7518 value
+= md_pcrel_from (fixP
);
7521 #if defined (OBJ_COFF) && defined (TE_PE)
7522 if (fixP
->fx_addsy
!= NULL
&& S_IS_WEAK (fixP
->fx_addsy
))
7524 value
-= S_GET_VALUE (fixP
->fx_addsy
);
7528 /* Fix a few things - the dynamic linker expects certain values here,
7529 and we must not disappoint it. */
7530 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7531 if (IS_ELF
&& fixP
->fx_addsy
)
7532 switch (fixP
->fx_r_type
)
7534 case BFD_RELOC_386_PLT32
:
7535 case BFD_RELOC_X86_64_PLT32
:
7536 /* Make the jump instruction point to the address of the operand. At
7537 runtime we merely add the offset to the actual PLT entry. */
7541 case BFD_RELOC_386_TLS_GD
:
7542 case BFD_RELOC_386_TLS_LDM
:
7543 case BFD_RELOC_386_TLS_IE_32
:
7544 case BFD_RELOC_386_TLS_IE
:
7545 case BFD_RELOC_386_TLS_GOTIE
:
7546 case BFD_RELOC_386_TLS_GOTDESC
:
7547 case BFD_RELOC_X86_64_TLSGD
:
7548 case BFD_RELOC_X86_64_TLSLD
:
7549 case BFD_RELOC_X86_64_GOTTPOFF
:
7550 case BFD_RELOC_X86_64_GOTPC32_TLSDESC
:
7551 value
= 0; /* Fully resolved at runtime. No addend. */
7553 case BFD_RELOC_386_TLS_LE
:
7554 case BFD_RELOC_386_TLS_LDO_32
:
7555 case BFD_RELOC_386_TLS_LE_32
:
7556 case BFD_RELOC_X86_64_DTPOFF32
:
7557 case BFD_RELOC_X86_64_DTPOFF64
:
7558 case BFD_RELOC_X86_64_TPOFF32
:
7559 case BFD_RELOC_X86_64_TPOFF64
:
7560 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
7563 case BFD_RELOC_386_TLS_DESC_CALL
:
7564 case BFD_RELOC_X86_64_TLSDESC_CALL
:
7565 value
= 0; /* Fully resolved at runtime. No addend. */
7566 S_SET_THREAD_LOCAL (fixP
->fx_addsy
);
7570 case BFD_RELOC_386_GOT32
:
7571 case BFD_RELOC_X86_64_GOT32
:
7572 value
= 0; /* Fully resolved at runtime. No addend. */
7575 case BFD_RELOC_VTABLE_INHERIT
:
7576 case BFD_RELOC_VTABLE_ENTRY
:
7583 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) */
7585 #endif /* !defined (TE_Mach) */
7587 /* Are we finished with this relocation now? */
7588 if (fixP
->fx_addsy
== NULL
)
7590 #if defined (OBJ_COFF) && defined (TE_PE)
7591 else if (fixP
->fx_addsy
!= NULL
&& S_IS_WEAK (fixP
->fx_addsy
))
7594 /* Remember value for tc_gen_reloc. */
7595 fixP
->fx_addnumber
= value
;
7596 /* Clear out the frag for now. */
7600 else if (use_rela_relocations
)
7602 fixP
->fx_no_overflow
= 1;
7603 /* Remember value for tc_gen_reloc. */
7604 fixP
->fx_addnumber
= value
;
7608 md_number_to_chars (p
, value
, fixP
->fx_size
);
7612 md_atof (int type
, char *litP
, int *sizeP
)
7614 /* This outputs the LITTLENUMs in REVERSE order;
7615 in accord with the bigendian 386. */
7616 return ieee_md_atof (type
, litP
, sizeP
, FALSE
);
7619 static char output_invalid_buf
[sizeof (unsigned char) * 2 + 6];
7622 output_invalid (int c
)
7625 snprintf (output_invalid_buf
, sizeof (output_invalid_buf
),
7628 snprintf (output_invalid_buf
, sizeof (output_invalid_buf
),
7629 "(0x%x)", (unsigned char) c
);
7630 return output_invalid_buf
;
7633 /* REG_STRING starts *before* REGISTER_PREFIX. */
7635 static const reg_entry
*
7636 parse_real_register (char *reg_string
, char **end_op
)
7638 char *s
= reg_string
;
7640 char reg_name_given
[MAX_REG_NAME_SIZE
+ 1];
7643 /* Skip possible REGISTER_PREFIX and possible whitespace. */
7644 if (*s
== REGISTER_PREFIX
)
7647 if (is_space_char (*s
))
7651 while ((*p
++ = register_chars
[(unsigned char) *s
]) != '\0')
7653 if (p
>= reg_name_given
+ MAX_REG_NAME_SIZE
)
7654 return (const reg_entry
*) NULL
;
7658 /* For naked regs, make sure that we are not dealing with an identifier.
7659 This prevents confusing an identifier like `eax_var' with register
7661 if (allow_naked_reg
&& identifier_chars
[(unsigned char) *s
])
7662 return (const reg_entry
*) NULL
;
7666 r
= (const reg_entry
*) hash_find (reg_hash
, reg_name_given
);
7668 /* Handle floating point regs, allowing spaces in the (i) part. */
7669 if (r
== i386_regtab
/* %st is first entry of table */)
7671 if (is_space_char (*s
))
7676 if (is_space_char (*s
))
7678 if (*s
>= '0' && *s
<= '7')
7682 if (is_space_char (*s
))
7687 r
= (const reg_entry
*) hash_find (reg_hash
, "st(0)");
7692 /* We have "%st(" then garbage. */
7693 return (const reg_entry
*) NULL
;
7697 if (r
== NULL
|| allow_pseudo_reg
)
7700 if (operand_type_all_zero (&r
->reg_type
))
7701 return (const reg_entry
*) NULL
;
7703 if ((r
->reg_type
.bitfield
.reg32
7704 || r
->reg_type
.bitfield
.sreg3
7705 || r
->reg_type
.bitfield
.control
7706 || r
->reg_type
.bitfield
.debug
7707 || r
->reg_type
.bitfield
.test
)
7708 && !cpu_arch_flags
.bitfield
.cpui386
)
7709 return (const reg_entry
*) NULL
;
7711 if (r
->reg_type
.bitfield
.floatreg
7712 && !cpu_arch_flags
.bitfield
.cpu8087
7713 && !cpu_arch_flags
.bitfield
.cpu287
7714 && !cpu_arch_flags
.bitfield
.cpu387
)
7715 return (const reg_entry
*) NULL
;
7717 if (r
->reg_type
.bitfield
.regmmx
&& !cpu_arch_flags
.bitfield
.cpummx
)
7718 return (const reg_entry
*) NULL
;
7720 if (r
->reg_type
.bitfield
.regxmm
&& !cpu_arch_flags
.bitfield
.cpusse
)
7721 return (const reg_entry
*) NULL
;
7723 if (r
->reg_type
.bitfield
.regymm
&& !cpu_arch_flags
.bitfield
.cpuavx
)
7724 return (const reg_entry
*) NULL
;
7726 /* Don't allow fake index register unless allow_index_reg isn't 0. */
7727 if (!allow_index_reg
7728 && (r
->reg_num
== RegEiz
|| r
->reg_num
== RegRiz
))
7729 return (const reg_entry
*) NULL
;
7731 if (((r
->reg_flags
& (RegRex64
| RegRex
))
7732 || r
->reg_type
.bitfield
.reg64
)
7733 && (!cpu_arch_flags
.bitfield
.cpulm
7734 || !operand_type_equal (&r
->reg_type
, &control
))
7735 && flag_code
!= CODE_64BIT
)
7736 return (const reg_entry
*) NULL
;
7738 if (r
->reg_type
.bitfield
.sreg3
&& r
->reg_num
== RegFlat
&& !intel_syntax
)
7739 return (const reg_entry
*) NULL
;
7744 /* REG_STRING starts *before* REGISTER_PREFIX. */
7746 static const reg_entry
*
7747 parse_register (char *reg_string
, char **end_op
)
7751 if (*reg_string
== REGISTER_PREFIX
|| allow_naked_reg
)
7752 r
= parse_real_register (reg_string
, end_op
);
7757 char *save
= input_line_pointer
;
7761 input_line_pointer
= reg_string
;
7762 c
= get_symbol_end ();
7763 symbolP
= symbol_find (reg_string
);
7764 if (symbolP
&& S_GET_SEGMENT (symbolP
) == reg_section
)
7766 const expressionS
*e
= symbol_get_value_expression (symbolP
);
7768 know (e
->X_op
== O_register
);
7769 know (e
->X_add_number
>= 0
7770 && (valueT
) e
->X_add_number
< i386_regtab_size
);
7771 r
= i386_regtab
+ e
->X_add_number
;
7772 *end_op
= input_line_pointer
;
7774 *input_line_pointer
= c
;
7775 input_line_pointer
= save
;
7781 i386_parse_name (char *name
, expressionS
*e
, char *nextcharP
)
7784 char *end
= input_line_pointer
;
7787 r
= parse_register (name
, &input_line_pointer
);
7788 if (r
&& end
<= input_line_pointer
)
7790 *nextcharP
= *input_line_pointer
;
7791 *input_line_pointer
= 0;
7792 e
->X_op
= O_register
;
7793 e
->X_add_number
= r
- i386_regtab
;
7796 input_line_pointer
= end
;
7798 return intel_syntax
? i386_intel_parse_name (name
, e
) : 0;
7802 md_operand (expressionS
*e
)
7807 switch (*input_line_pointer
)
7809 case REGISTER_PREFIX
:
7810 r
= parse_real_register (input_line_pointer
, &end
);
7813 e
->X_op
= O_register
;
7814 e
->X_add_number
= r
- i386_regtab
;
7815 input_line_pointer
= end
;
7820 gas_assert (intel_syntax
);
7821 end
= input_line_pointer
++;
7823 if (*input_line_pointer
== ']')
7825 ++input_line_pointer
;
7826 e
->X_op_symbol
= make_expr_symbol (e
);
7827 e
->X_add_symbol
= NULL
;
7828 e
->X_add_number
= 0;
7834 input_line_pointer
= end
;
7841 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7842 const char *md_shortopts
= "kVQ:sqn";
7844 const char *md_shortopts
= "qn";
7847 #define OPTION_32 (OPTION_MD_BASE + 0)
7848 #define OPTION_64 (OPTION_MD_BASE + 1)
7849 #define OPTION_DIVIDE (OPTION_MD_BASE + 2)
7850 #define OPTION_MARCH (OPTION_MD_BASE + 3)
7851 #define OPTION_MTUNE (OPTION_MD_BASE + 4)
7852 #define OPTION_MMNEMONIC (OPTION_MD_BASE + 5)
7853 #define OPTION_MSYNTAX (OPTION_MD_BASE + 6)
7854 #define OPTION_MINDEX_REG (OPTION_MD_BASE + 7)
7855 #define OPTION_MNAKED_REG (OPTION_MD_BASE + 8)
7856 #define OPTION_MOLD_GCC (OPTION_MD_BASE + 9)
7857 #define OPTION_MSSE2AVX (OPTION_MD_BASE + 10)
7858 #define OPTION_MSSE_CHECK (OPTION_MD_BASE + 11)
7860 struct option md_longopts
[] =
7862 {"32", no_argument
, NULL
, OPTION_32
},
7863 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
7864 || defined (TE_PE) || defined (TE_PEP))
7865 {"64", no_argument
, NULL
, OPTION_64
},
7867 {"divide", no_argument
, NULL
, OPTION_DIVIDE
},
7868 {"march", required_argument
, NULL
, OPTION_MARCH
},
7869 {"mtune", required_argument
, NULL
, OPTION_MTUNE
},
7870 {"mmnemonic", required_argument
, NULL
, OPTION_MMNEMONIC
},
7871 {"msyntax", required_argument
, NULL
, OPTION_MSYNTAX
},
7872 {"mindex-reg", no_argument
, NULL
, OPTION_MINDEX_REG
},
7873 {"mnaked-reg", no_argument
, NULL
, OPTION_MNAKED_REG
},
7874 {"mold-gcc", no_argument
, NULL
, OPTION_MOLD_GCC
},
7875 {"msse2avx", no_argument
, NULL
, OPTION_MSSE2AVX
},
7876 {"msse-check", required_argument
, NULL
, OPTION_MSSE_CHECK
},
7877 {NULL
, no_argument
, NULL
, 0}
7879 size_t md_longopts_size
= sizeof (md_longopts
);
7882 md_parse_option (int c
, char *arg
)
7890 optimize_align_code
= 0;
7897 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7898 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
7899 should be emitted or not. FIXME: Not implemented. */
7903 /* -V: SVR4 argument to print version ID. */
7905 print_version_id ();
7908 /* -k: Ignore for FreeBSD compatibility. */
7913 /* -s: On i386 Solaris, this tells the native assembler to use
7914 .stab instead of .stab.excl. We always use .stab anyhow. */
7917 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
7918 || defined (TE_PE) || defined (TE_PEP))
7921 const char **list
, **l
;
7923 list
= bfd_target_list ();
7924 for (l
= list
; *l
!= NULL
; l
++)
7925 if (CONST_STRNEQ (*l
, "elf64-x86-64")
7926 || strcmp (*l
, "coff-x86-64") == 0
7927 || strcmp (*l
, "pe-x86-64") == 0
7928 || strcmp (*l
, "pei-x86-64") == 0)
7930 default_arch
= "x86_64";
7934 as_fatal (_("No compiled in support for x86_64"));
7941 default_arch
= "i386";
7945 #ifdef SVR4_COMMENT_CHARS
7950 n
= (char *) xmalloc (strlen (i386_comment_chars
) + 1);
7952 for (s
= i386_comment_chars
; *s
!= '\0'; s
++)
7956 i386_comment_chars
= n
;
7962 arch
= xstrdup (arg
);
7966 as_fatal (_("Invalid -march= option: `%s'"), arg
);
7967 next
= strchr (arch
, '+');
7970 for (j
= 0; j
< ARRAY_SIZE (cpu_arch
); j
++)
7972 if (strcmp (arch
, cpu_arch
[j
].name
) == 0)
7975 cpu_arch_name
= cpu_arch
[j
].name
;
7976 cpu_sub_arch_name
= NULL
;
7977 cpu_arch_flags
= cpu_arch
[j
].flags
;
7978 cpu_arch_isa
= cpu_arch
[j
].type
;
7979 cpu_arch_isa_flags
= cpu_arch
[j
].flags
;
7980 if (!cpu_arch_tune_set
)
7982 cpu_arch_tune
= cpu_arch_isa
;
7983 cpu_arch_tune_flags
= cpu_arch_isa_flags
;
7987 else if (*cpu_arch
[j
].name
== '.'
7988 && strcmp (arch
, cpu_arch
[j
].name
+ 1) == 0)
7990 /* ISA entension. */
7991 i386_cpu_flags flags
;
7993 if (strncmp (arch
, "no", 2))
7994 flags
= cpu_flags_or (cpu_arch_flags
,
7997 flags
= cpu_flags_and_not (cpu_arch_flags
,
7999 if (!cpu_flags_equal (&flags
, &cpu_arch_flags
))
8001 if (cpu_sub_arch_name
)
8003 char *name
= cpu_sub_arch_name
;
8004 cpu_sub_arch_name
= concat (name
,
8006 (const char *) NULL
);
8010 cpu_sub_arch_name
= xstrdup (cpu_arch
[j
].name
);
8011 cpu_arch_flags
= flags
;
8017 if (j
>= ARRAY_SIZE (cpu_arch
))
8018 as_fatal (_("Invalid -march= option: `%s'"), arg
);
8022 while (next
!= NULL
);
8027 as_fatal (_("Invalid -mtune= option: `%s'"), arg
);
8028 for (j
= 0; j
< ARRAY_SIZE (cpu_arch
); j
++)
8030 if (strcmp (arg
, cpu_arch
[j
].name
) == 0)
8032 cpu_arch_tune_set
= 1;
8033 cpu_arch_tune
= cpu_arch
[j
].type
;
8034 cpu_arch_tune_flags
= cpu_arch
[j
].flags
;
8038 if (j
>= ARRAY_SIZE (cpu_arch
))
8039 as_fatal (_("Invalid -mtune= option: `%s'"), arg
);
8042 case OPTION_MMNEMONIC
:
8043 if (strcasecmp (arg
, "att") == 0)
8045 else if (strcasecmp (arg
, "intel") == 0)
8048 as_fatal (_("Invalid -mmnemonic= option: `%s'"), arg
);
8051 case OPTION_MSYNTAX
:
8052 if (strcasecmp (arg
, "att") == 0)
8054 else if (strcasecmp (arg
, "intel") == 0)
8057 as_fatal (_("Invalid -msyntax= option: `%s'"), arg
);
8060 case OPTION_MINDEX_REG
:
8061 allow_index_reg
= 1;
8064 case OPTION_MNAKED_REG
:
8065 allow_naked_reg
= 1;
8068 case OPTION_MOLD_GCC
:
8072 case OPTION_MSSE2AVX
:
8076 case OPTION_MSSE_CHECK
:
8077 if (strcasecmp (arg
, "error") == 0)
8078 sse_check
= sse_check_error
;
8079 else if (strcasecmp (arg
, "warning") == 0)
8080 sse_check
= sse_check_warning
;
8081 else if (strcasecmp (arg
, "none") == 0)
8082 sse_check
= sse_check_none
;
8084 as_fatal (_("Invalid -msse-check= option: `%s'"), arg
);
8093 #define MESSAGE_TEMPLATE \
8097 show_arch (FILE *stream
, int ext
)
8099 static char message
[] = MESSAGE_TEMPLATE
;
8100 char *start
= message
+ 27;
8102 int size
= sizeof (MESSAGE_TEMPLATE
);
8109 left
= size
- (start
- message
);
8110 for (j
= 0; j
< ARRAY_SIZE (cpu_arch
); j
++)
8112 /* Should it be skipped? */
8113 if (cpu_arch
[j
].skip
)
8116 name
= cpu_arch
[j
].name
;
8117 len
= cpu_arch
[j
].len
;
8120 /* It is an extension. Skip if we aren't asked to show it. */
8131 /* It is an processor. Skip if we show only extension. */
8135 /* Reserve 2 spaces for ", " or ",\0" */
8138 /* Check if there is any room. */
8146 p
= mempcpy (p
, name
, len
);
8150 /* Output the current message now and start a new one. */
8153 fprintf (stream
, "%s\n", message
);
8155 left
= size
- (start
- message
) - len
- 2;
8157 gas_assert (left
>= 0);
8159 p
= mempcpy (p
, name
, len
);
8164 fprintf (stream
, "%s\n", message
);
8168 md_show_usage (FILE *stream
)
8170 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8171 fprintf (stream
, _("\
8173 -V print assembler version number\n\
8176 fprintf (stream
, _("\
8177 -n Do not optimize code alignment\n\
8178 -q quieten some warnings\n"));
8179 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8180 fprintf (stream
, _("\
8183 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
8184 || defined (TE_PE) || defined (TE_PEP))
8185 fprintf (stream
, _("\
8186 --32/--64 generate 32bit/64bit code\n"));
8188 #ifdef SVR4_COMMENT_CHARS
8189 fprintf (stream
, _("\
8190 --divide do not treat `/' as a comment character\n"));
8192 fprintf (stream
, _("\
8193 --divide ignored\n"));
8195 fprintf (stream
, _("\
8196 -march=CPU[,+EXTENSION...]\n\
8197 generate code for CPU and EXTENSION, CPU is one of:\n"));
8198 show_arch (stream
, 0);
8199 fprintf (stream
, _("\
8200 EXTENSION is combination of:\n"));
8201 show_arch (stream
, 1);
8202 fprintf (stream
, _("\
8203 -mtune=CPU optimize for CPU, CPU is one of:\n"));
8204 show_arch (stream
, 0);
8205 fprintf (stream
, _("\
8206 -msse2avx encode SSE instructions with VEX prefix\n"));
8207 fprintf (stream
, _("\
8208 -msse-check=[none|error|warning]\n\
8209 check SSE instructions\n"));
8210 fprintf (stream
, _("\
8211 -mmnemonic=[att|intel] use AT&T/Intel mnemonic\n"));
8212 fprintf (stream
, _("\
8213 -msyntax=[att|intel] use AT&T/Intel syntax\n"));
8214 fprintf (stream
, _("\
8215 -mindex-reg support pseudo index registers\n"));
8216 fprintf (stream
, _("\
8217 -mnaked-reg don't require `%%' prefix for registers\n"));
8218 fprintf (stream
, _("\
8219 -mold-gcc support old (<= 2.8.1) versions of gcc\n"));
8222 #if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
8223 || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) \
8224 || defined (TE_PE) || defined (TE_PEP) || defined (OBJ_MACH_O))
8226 /* Pick the target format to use. */
8229 i386_target_format (void)
8231 if (!strcmp (default_arch
, "x86_64"))
8233 set_code_flag (CODE_64BIT
);
8234 if (cpu_flags_all_zero (&cpu_arch_isa_flags
))
8236 cpu_arch_isa_flags
.bitfield
.cpui186
= 1;
8237 cpu_arch_isa_flags
.bitfield
.cpui286
= 1;
8238 cpu_arch_isa_flags
.bitfield
.cpui386
= 1;
8239 cpu_arch_isa_flags
.bitfield
.cpui486
= 1;
8240 cpu_arch_isa_flags
.bitfield
.cpui586
= 1;
8241 cpu_arch_isa_flags
.bitfield
.cpui686
= 1;
8242 cpu_arch_isa_flags
.bitfield
.cpuclflush
= 1;
8243 cpu_arch_isa_flags
.bitfield
.cpummx
= 1;
8244 cpu_arch_isa_flags
.bitfield
.cpusse
= 1;
8245 cpu_arch_isa_flags
.bitfield
.cpusse2
= 1;
8246 cpu_arch_isa_flags
.bitfield
.cpulm
= 1;
8248 if (cpu_flags_all_zero (&cpu_arch_tune_flags
))
8250 cpu_arch_tune_flags
.bitfield
.cpui186
= 1;
8251 cpu_arch_tune_flags
.bitfield
.cpui286
= 1;
8252 cpu_arch_tune_flags
.bitfield
.cpui386
= 1;
8253 cpu_arch_tune_flags
.bitfield
.cpui486
= 1;
8254 cpu_arch_tune_flags
.bitfield
.cpui586
= 1;
8255 cpu_arch_tune_flags
.bitfield
.cpui686
= 1;
8256 cpu_arch_tune_flags
.bitfield
.cpuclflush
= 1;
8257 cpu_arch_tune_flags
.bitfield
.cpummx
= 1;
8258 cpu_arch_tune_flags
.bitfield
.cpusse
= 1;
8259 cpu_arch_tune_flags
.bitfield
.cpusse2
= 1;
8262 else if (!strcmp (default_arch
, "i386"))
8264 set_code_flag (CODE_32BIT
);
8265 if (cpu_flags_all_zero (&cpu_arch_isa_flags
))
8267 cpu_arch_isa_flags
.bitfield
.cpui186
= 1;
8268 cpu_arch_isa_flags
.bitfield
.cpui286
= 1;
8269 cpu_arch_isa_flags
.bitfield
.cpui386
= 1;
8271 if (cpu_flags_all_zero (&cpu_arch_tune_flags
))
8273 cpu_arch_tune_flags
.bitfield
.cpui186
= 1;
8274 cpu_arch_tune_flags
.bitfield
.cpui286
= 1;
8275 cpu_arch_tune_flags
.bitfield
.cpui386
= 1;
8279 as_fatal (_("Unknown architecture"));
8280 switch (OUTPUT_FLAVOR
)
8282 #if defined (OBJ_MAYBE_AOUT) || defined (OBJ_AOUT)
8283 case bfd_target_aout_flavour
:
8284 return AOUT_TARGET_FORMAT
;
8286 #if defined (OBJ_MAYBE_COFF) || defined (OBJ_COFF)
8287 # if defined (TE_PE) || defined (TE_PEP)
8288 case bfd_target_coff_flavour
:
8289 return flag_code
== CODE_64BIT
? "pe-x86-64" : "pe-i386";
8290 # elif defined (TE_GO32)
8291 case bfd_target_coff_flavour
:
8294 case bfd_target_coff_flavour
:
8298 #if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
8299 case bfd_target_elf_flavour
:
8301 if (flag_code
== CODE_64BIT
)
8304 use_rela_relocations
= 1;
8306 if (cpu_arch_isa
== PROCESSOR_L1OM
)
8308 if (flag_code
!= CODE_64BIT
)
8309 as_fatal (_("Intel L1OM is 64bit only"));
8310 return ELF_TARGET_L1OM_FORMAT
;
8313 return (flag_code
== CODE_64BIT
8314 ? ELF_TARGET_FORMAT64
: ELF_TARGET_FORMAT
);
8317 #if defined (OBJ_MACH_O)
8318 case bfd_target_mach_o_flavour
:
8319 return flag_code
== CODE_64BIT
? "mach-o-x86-64" : "mach-o-i386";
8327 #endif /* OBJ_MAYBE_ more than one */
8329 #if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))
8331 i386_elf_emit_arch_note (void)
8333 if (IS_ELF
&& cpu_arch_name
!= NULL
)
8336 asection
*seg
= now_seg
;
8337 subsegT subseg
= now_subseg
;
8338 Elf_Internal_Note i_note
;
8339 Elf_External_Note e_note
;
8340 asection
*note_secp
;
8343 /* Create the .note section. */
8344 note_secp
= subseg_new (".note", 0);
8345 bfd_set_section_flags (stdoutput
,
8347 SEC_HAS_CONTENTS
| SEC_READONLY
);
8349 /* Process the arch string. */
8350 len
= strlen (cpu_arch_name
);
8352 i_note
.namesz
= len
+ 1;
8354 i_note
.type
= NT_ARCH
;
8355 p
= frag_more (sizeof (e_note
.namesz
));
8356 md_number_to_chars (p
, (valueT
) i_note
.namesz
, sizeof (e_note
.namesz
));
8357 p
= frag_more (sizeof (e_note
.descsz
));
8358 md_number_to_chars (p
, (valueT
) i_note
.descsz
, sizeof (e_note
.descsz
));
8359 p
= frag_more (sizeof (e_note
.type
));
8360 md_number_to_chars (p
, (valueT
) i_note
.type
, sizeof (e_note
.type
));
8361 p
= frag_more (len
+ 1);
8362 strcpy (p
, cpu_arch_name
);
8364 frag_align (2, 0, 0);
8366 subseg_set (seg
, subseg
);
8372 md_undefined_symbol (name
)
8375 if (name
[0] == GLOBAL_OFFSET_TABLE_NAME
[0]
8376 && name
[1] == GLOBAL_OFFSET_TABLE_NAME
[1]
8377 && name
[2] == GLOBAL_OFFSET_TABLE_NAME
[2]
8378 && strcmp (name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
8382 if (symbol_find (name
))
8383 as_bad (_("GOT already in symbol table"));
8384 GOT_symbol
= symbol_new (name
, undefined_section
,
8385 (valueT
) 0, &zero_address_frag
);
8392 /* Round up a section size to the appropriate boundary. */
8395 md_section_align (segment
, size
)
8396 segT segment ATTRIBUTE_UNUSED
;
8399 #if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
8400 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
)
8402 /* For a.out, force the section size to be aligned. If we don't do
8403 this, BFD will align it for us, but it will not write out the
8404 final bytes of the section. This may be a bug in BFD, but it is
8405 easier to fix it here since that is how the other a.out targets
8409 align
= bfd_get_section_alignment (stdoutput
, segment
);
8410 size
= ((size
+ (1 << align
) - 1) & ((valueT
) -1 << align
));
8417 /* On the i386, PC-relative offsets are relative to the start of the
8418 next instruction. That is, the address of the offset, plus its
8419 size, since the offset is always the last part of the insn. */
8422 md_pcrel_from (fixS
*fixP
)
8424 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
8430 s_bss (int ignore ATTRIBUTE_UNUSED
)
8434 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8436 obj_elf_section_change_hook ();
8438 temp
= get_absolute_expression ();
8439 subseg_set (bss_section
, (subsegT
) temp
);
8440 demand_empty_rest_of_line ();
8446 i386_validate_fix (fixS
*fixp
)
8448 if (fixp
->fx_subsy
&& fixp
->fx_subsy
== GOT_symbol
)
8450 if (fixp
->fx_r_type
== BFD_RELOC_32_PCREL
)
8454 fixp
->fx_r_type
= BFD_RELOC_X86_64_GOTPCREL
;
8459 fixp
->fx_r_type
= BFD_RELOC_386_GOTOFF
;
8461 fixp
->fx_r_type
= BFD_RELOC_X86_64_GOTOFF64
;
8468 tc_gen_reloc (section
, fixp
)
8469 asection
*section ATTRIBUTE_UNUSED
;
8473 bfd_reloc_code_real_type code
;
8475 switch (fixp
->fx_r_type
)
8477 case BFD_RELOC_X86_64_PLT32
:
8478 case BFD_RELOC_X86_64_GOT32
:
8479 case BFD_RELOC_X86_64_GOTPCREL
:
8480 case BFD_RELOC_386_PLT32
:
8481 case BFD_RELOC_386_GOT32
:
8482 case BFD_RELOC_386_GOTOFF
:
8483 case BFD_RELOC_386_GOTPC
:
8484 case BFD_RELOC_386_TLS_GD
:
8485 case BFD_RELOC_386_TLS_LDM
:
8486 case BFD_RELOC_386_TLS_LDO_32
:
8487 case BFD_RELOC_386_TLS_IE_32
:
8488 case BFD_RELOC_386_TLS_IE
:
8489 case BFD_RELOC_386_TLS_GOTIE
:
8490 case BFD_RELOC_386_TLS_LE_32
:
8491 case BFD_RELOC_386_TLS_LE
:
8492 case BFD_RELOC_386_TLS_GOTDESC
:
8493 case BFD_RELOC_386_TLS_DESC_CALL
:
8494 case BFD_RELOC_X86_64_TLSGD
:
8495 case BFD_RELOC_X86_64_TLSLD
:
8496 case BFD_RELOC_X86_64_DTPOFF32
:
8497 case BFD_RELOC_X86_64_DTPOFF64
:
8498 case BFD_RELOC_X86_64_GOTTPOFF
:
8499 case BFD_RELOC_X86_64_TPOFF32
:
8500 case BFD_RELOC_X86_64_TPOFF64
:
8501 case BFD_RELOC_X86_64_GOTOFF64
:
8502 case BFD_RELOC_X86_64_GOTPC32
:
8503 case BFD_RELOC_X86_64_GOT64
:
8504 case BFD_RELOC_X86_64_GOTPCREL64
:
8505 case BFD_RELOC_X86_64_GOTPC64
:
8506 case BFD_RELOC_X86_64_GOTPLT64
:
8507 case BFD_RELOC_X86_64_PLTOFF64
:
8508 case BFD_RELOC_X86_64_GOTPC32_TLSDESC
:
8509 case BFD_RELOC_X86_64_TLSDESC_CALL
:
8511 case BFD_RELOC_VTABLE_ENTRY
:
8512 case BFD_RELOC_VTABLE_INHERIT
:
8514 case BFD_RELOC_32_SECREL
:
8516 code
= fixp
->fx_r_type
;
8518 case BFD_RELOC_X86_64_32S
:
8519 if (!fixp
->fx_pcrel
)
8521 /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32. */
8522 code
= fixp
->fx_r_type
;
8528 switch (fixp
->fx_size
)
8531 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
8532 _("can not do %d byte pc-relative relocation"),
8534 code
= BFD_RELOC_32_PCREL
;
8536 case 1: code
= BFD_RELOC_8_PCREL
; break;
8537 case 2: code
= BFD_RELOC_16_PCREL
; break;
8538 case 4: code
= BFD_RELOC_32_PCREL
; break;
8540 case 8: code
= BFD_RELOC_64_PCREL
; break;
8546 switch (fixp
->fx_size
)
8549 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
8550 _("can not do %d byte relocation"),
8552 code
= BFD_RELOC_32
;
8554 case 1: code
= BFD_RELOC_8
; break;
8555 case 2: code
= BFD_RELOC_16
; break;
8556 case 4: code
= BFD_RELOC_32
; break;
8558 case 8: code
= BFD_RELOC_64
; break;
8565 if ((code
== BFD_RELOC_32
8566 || code
== BFD_RELOC_32_PCREL
8567 || code
== BFD_RELOC_X86_64_32S
)
8569 && fixp
->fx_addsy
== GOT_symbol
)
8572 code
= BFD_RELOC_386_GOTPC
;
8574 code
= BFD_RELOC_X86_64_GOTPC32
;
8576 if ((code
== BFD_RELOC_64
|| code
== BFD_RELOC_64_PCREL
)
8578 && fixp
->fx_addsy
== GOT_symbol
)
8580 code
= BFD_RELOC_X86_64_GOTPC64
;
8583 rel
= (arelent
*) xmalloc (sizeof (arelent
));
8584 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
8585 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
8587 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
8589 if (!use_rela_relocations
)
8591 /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
8592 vtable entry to be used in the relocation's section offset. */
8593 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
8594 rel
->address
= fixp
->fx_offset
;
8595 #if defined (OBJ_COFF) && defined (TE_PE)
8596 else if (fixp
->fx_addsy
&& S_IS_WEAK (fixp
->fx_addsy
))
8597 rel
->addend
= fixp
->fx_addnumber
- (S_GET_VALUE (fixp
->fx_addsy
) * 2);
8602 /* Use the rela in 64bit mode. */
8605 if (!fixp
->fx_pcrel
)
8606 rel
->addend
= fixp
->fx_offset
;
8610 case BFD_RELOC_X86_64_PLT32
:
8611 case BFD_RELOC_X86_64_GOT32
:
8612 case BFD_RELOC_X86_64_GOTPCREL
:
8613 case BFD_RELOC_X86_64_TLSGD
:
8614 case BFD_RELOC_X86_64_TLSLD
:
8615 case BFD_RELOC_X86_64_GOTTPOFF
:
8616 case BFD_RELOC_X86_64_GOTPC32_TLSDESC
:
8617 case BFD_RELOC_X86_64_TLSDESC_CALL
:
8618 rel
->addend
= fixp
->fx_offset
- fixp
->fx_size
;
8621 rel
->addend
= (section
->vma
8623 + fixp
->fx_addnumber
8624 + md_pcrel_from (fixp
));
8629 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
8630 if (rel
->howto
== NULL
)
8632 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
8633 _("cannot represent relocation type %s"),
8634 bfd_get_reloc_code_name (code
));
8635 /* Set howto to a garbage value so that we can keep going. */
8636 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
8637 gas_assert (rel
->howto
!= NULL
);
8643 #include "tc-i386-intel.c"
8646 tc_x86_parse_to_dw2regnum (expressionS
*exp
)
8648 int saved_naked_reg
;
8649 char saved_register_dot
;
8651 saved_naked_reg
= allow_naked_reg
;
8652 allow_naked_reg
= 1;
8653 saved_register_dot
= register_chars
['.'];
8654 register_chars
['.'] = '.';
8655 allow_pseudo_reg
= 1;
8656 expression_and_evaluate (exp
);
8657 allow_pseudo_reg
= 0;
8658 register_chars
['.'] = saved_register_dot
;
8659 allow_naked_reg
= saved_naked_reg
;
8661 if (exp
->X_op
== O_register
&& exp
->X_add_number
>= 0)
8663 if ((addressT
) exp
->X_add_number
< i386_regtab_size
)
8665 exp
->X_op
= O_constant
;
8666 exp
->X_add_number
= i386_regtab
[exp
->X_add_number
]
8667 .dw2_regnum
[flag_code
>> 1];
8670 exp
->X_op
= O_illegal
;
8675 tc_x86_frame_initial_instructions (void)
8677 static unsigned int sp_regno
[2];
8679 if (!sp_regno
[flag_code
>> 1])
8681 char *saved_input
= input_line_pointer
;
8682 char sp
[][4] = {"esp", "rsp"};
8685 input_line_pointer
= sp
[flag_code
>> 1];
8686 tc_x86_parse_to_dw2regnum (&exp
);
8687 gas_assert (exp
.X_op
== O_constant
);
8688 sp_regno
[flag_code
>> 1] = exp
.X_add_number
;
8689 input_line_pointer
= saved_input
;
8692 cfi_add_CFA_def_cfa (sp_regno
[flag_code
>> 1], -x86_cie_data_alignment
);
8693 cfi_add_CFA_offset (x86_dwarf2_return_column
, x86_cie_data_alignment
);
8697 i386_elf_section_type (const char *str
, size_t len
)
8699 if (flag_code
== CODE_64BIT
8700 && len
== sizeof ("unwind") - 1
8701 && strncmp (str
, "unwind", 6) == 0)
8702 return SHT_X86_64_UNWIND
;
8709 i386_solaris_fix_up_eh_frame (segT sec
)
8711 if (flag_code
== CODE_64BIT
)
8712 elf_section_type (sec
) = SHT_X86_64_UNWIND
;
8718 tc_pe_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
8722 exp
.X_op
= O_secrel
;
8723 exp
.X_add_symbol
= symbol
;
8724 exp
.X_add_number
= 0;
8725 emit_expr (&exp
, size
);
8729 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
8730 /* For ELF on x86-64, add support for SHF_X86_64_LARGE. */
8733 x86_64_section_letter (int letter
, char **ptr_msg
)
8735 if (flag_code
== CODE_64BIT
)
8738 return SHF_X86_64_LARGE
;
8740 *ptr_msg
= _("Bad .section directive: want a,l,w,x,M,S,G,T in string");
8743 *ptr_msg
= _("Bad .section directive: want a,w,x,M,S,G,T in string");
8748 x86_64_section_word (char *str
, size_t len
)
8750 if (len
== 5 && flag_code
== CODE_64BIT
&& CONST_STRNEQ (str
, "large"))
8751 return SHF_X86_64_LARGE
;
8757 handle_large_common (int small ATTRIBUTE_UNUSED
)
8759 if (flag_code
!= CODE_64BIT
)
8761 s_comm_internal (0, elf_common_parse
);
8762 as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
8766 static segT lbss_section
;
8767 asection
*saved_com_section_ptr
= elf_com_section_ptr
;
8768 asection
*saved_bss_section
= bss_section
;
8770 if (lbss_section
== NULL
)
8772 flagword applicable
;
8774 subsegT subseg
= now_subseg
;
8776 /* The .lbss section is for local .largecomm symbols. */
8777 lbss_section
= subseg_new (".lbss", 0);
8778 applicable
= bfd_applicable_section_flags (stdoutput
);
8779 bfd_set_section_flags (stdoutput
, lbss_section
,
8780 applicable
& SEC_ALLOC
);
8781 seg_info (lbss_section
)->bss
= 1;
8783 subseg_set (seg
, subseg
);
8786 elf_com_section_ptr
= &_bfd_elf_large_com_section
;
8787 bss_section
= lbss_section
;
8789 s_comm_internal (0, elf_common_parse
);
8791 elf_com_section_ptr
= saved_com_section_ptr
;
8792 bss_section
= saved_bss_section
;
8795 #endif /* OBJ_ELF || OBJ_MAYBE_ELF */