1 /* i386.c -- Assemble code for the Intel 80386
2 Copyright (C) 1989, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 Intel 80386 machine specific gas.
24 Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
25 Bugs & suggestions are completely welcome. This is free software.
26 Please help us make it better.
33 #include "opcode/i386.h"
36 #define TC_RELOC(X,Y) (Y)
39 #ifndef REGISTER_WARNINGS
40 #define REGISTER_WARNINGS 1
43 #ifndef INFER_ADDR_PREFIX
44 #define INFER_ADDR_PREFIX 1
47 #ifndef SCALE1_WHEN_NO_INDEX
48 /* Specifying a scale factor besides 1 when there is no index is
49 futile. eg. `mov (%ebx,2),%al' does exactly the same as
50 `mov (%ebx),%al'. To slavishly follow what the programmer
51 specified, set SCALE1_WHEN_NO_INDEX to 0. */
52 #define SCALE1_WHEN_NO_INDEX 1
58 static unsigned int mode_from_disp_size
PARAMS ((unsigned int));
59 static int fits_in_signed_byte
PARAMS ((long));
60 static int fits_in_unsigned_byte
PARAMS ((long));
61 static int fits_in_unsigned_word
PARAMS ((long));
62 static int fits_in_signed_word
PARAMS ((long));
63 static int smallest_imm_type
PARAMS ((long));
64 static int add_prefix
PARAMS ((unsigned int));
65 static void set_16bit_code_flag
PARAMS ((int));
66 static void set_16bit_gcc_code_flag
PARAMS((int));
67 static void set_intel_syntax
PARAMS ((int));
70 static bfd_reloc_code_real_type reloc
71 PARAMS ((int, int, bfd_reloc_code_real_type
));
74 /* 'md_assemble ()' gathers together information and puts it into a
79 /* TM holds the template for the insn were currently assembling. */
82 /* SUFFIX holds the instruction mnemonic suffix if given.
83 (e.g. 'l' for 'movl') */
86 /* Operands are coded with OPERANDS, TYPES, DISPS, IMMS, and REGS. */
88 /* OPERANDS gives the number of given operands. */
89 unsigned int operands
;
91 /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
92 of given register, displacement, memory operands and immediate
94 unsigned int reg_operands
, disp_operands
, mem_operands
, imm_operands
;
96 /* TYPES [i] is the type (see above #defines) which tells us how to
97 search through DISPS [i] & IMMS [i] & REGS [i] for the required
99 unsigned int types
[MAX_OPERANDS
];
101 /* Displacements (if given) for each operand. */
102 expressionS
*disps
[MAX_OPERANDS
];
104 /* Relocation type for operand */
106 enum bfd_reloc_code_real disp_reloc
[MAX_OPERANDS
];
108 int disp_reloc
[MAX_OPERANDS
];
111 /* Immediate operands (if given) for each operand. */
112 expressionS
*imms
[MAX_OPERANDS
];
114 /* Register operands (if given) for each operand. */
115 const reg_entry
*regs
[MAX_OPERANDS
];
117 /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
118 the base index byte below. */
119 const reg_entry
*base_reg
;
120 const reg_entry
*index_reg
;
121 unsigned int log2_scale_factor
;
123 /* SEG gives the seg_entries of this insn. They are zero unless
124 explicit segment overrides are given. */
125 const seg_entry
*seg
[2]; /* segments for memory operands (if given) */
127 /* PREFIX holds all the given prefix opcodes (usually null).
128 PREFIXES is the number of prefix opcodes. */
129 unsigned int prefixes
;
130 unsigned char prefix
[MAX_PREFIXES
];
132 /* RM and SIB are the modrm byte and the sib byte where the
133 addressing modes of this insn are encoded. */
139 typedef struct _i386_insn i386_insn
;
141 /* List of chars besides those in app.c:symbol_chars that can start an
142 operand. Used to prevent the scrubber eating vital white-space. */
144 const char extra_symbol_chars
[] = "*%-(@";
146 const char extra_symbol_chars
[] = "*%-(";
149 /* This array holds the chars that always start a comment. If the
150 pre-processor is disabled, these aren't very useful */
151 #if defined (TE_I386AIX) || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) && ! defined (TE_LINUX))
152 /* Putting '/' here makes it impossible to use the divide operator.
153 However, we need it for compatibility with SVR4 systems. */
154 const char comment_chars
[] = "#/";
155 #define PREFIX_SEPARATOR '\\'
157 const char comment_chars
[] = "#";
158 #define PREFIX_SEPARATOR '/'
161 /* This array holds the chars that only start a comment at the beginning of
162 a line. If the line seems to have the form '# 123 filename'
163 .line and .file directives will appear in the pre-processed output */
164 /* Note that input_file.c hand checks for '#' at the beginning of the
165 first line of the input file. This is because the compiler outputs
166 #NO_APP at the beginning of its output. */
167 /* Also note that comments started like this one will always work if
168 '/' isn't otherwise defined. */
169 #if defined (TE_I386AIX) || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) && ! defined (TE_LINUX))
170 const char line_comment_chars
[] = "";
172 const char line_comment_chars
[] = "/";
175 const char line_separator_chars
[] = "";
177 /* Chars that can be used to separate mant from exp in floating point nums */
178 const char EXP_CHARS
[] = "eE";
180 /* Chars that mean this number is a floating point constant */
183 const char FLT_CHARS
[] = "fFdDxX";
185 /* tables for lexical analysis */
186 static char mnemonic_chars
[256];
187 static char register_chars
[256];
188 static char operand_chars
[256];
189 static char identifier_chars
[256];
190 static char digit_chars
[256];
193 #define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
194 #define is_operand_char(x) (operand_chars[(unsigned char) x])
195 #define is_register_char(x) (register_chars[(unsigned char) x])
196 #define is_space_char(x) ((x) == ' ')
197 #define is_identifier_char(x) (identifier_chars[(unsigned char) x])
198 #define is_digit_char(x) (digit_chars[(unsigned char) x])
200 /* put here all non-digit non-letter charcters that may occur in an operand */
201 static char operand_special_chars
[] = "%$-+(,)*._~/<>|&^!:[@]";
203 /* md_assemble() always leaves the strings it's passed unaltered. To
204 effect this we maintain a stack of saved characters that we've smashed
205 with '\0's (indicating end of strings for various sub-fields of the
206 assembler instruction). */
207 static char save_stack
[32];
208 static char *save_stack_p
; /* stack pointer */
209 #define END_STRING_AND_SAVE(s) \
210 do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
211 #define RESTORE_END_STRING(s) \
212 do { *(s) = *--save_stack_p; } while (0)
214 /* The instruction we're assembling. */
217 /* Possible templates for current insn. */
218 static const templates
*current_templates
;
220 /* Per instruction expressionS buffers: 2 displacements & 2 immediate max. */
221 static expressionS disp_expressions
[2], im_expressions
[2];
223 static int this_operand
; /* current operand we are working on */
225 static int flag_do_long_jump
; /* FIXME what does this do? */
227 static int flag_16bit_code
; /* 1 if we're writing 16-bit code, 0 if 32-bit */
229 static int intel_syntax
= 0; /* 1 for intel syntax, 0 if att syntax */
231 static int allow_naked_reg
= 0; /* 1 if register prefix % not required */
233 static char stackop_size
= '\0'; /* Used in 16 bit gcc mode to add an l
234 suffix to call, ret, enter, leave, push,
235 and pop instructions. */
237 /* Interface to relax_segment.
238 There are 2 relax states for 386 jump insns: one for conditional &
239 one for unconditional jumps. This is because the these two types
240 of jumps add different sizes to frags when we're figuring out what
241 sort of jump to choose to reach a given label. */
244 #define COND_JUMP 1 /* conditional jump */
245 #define UNCOND_JUMP 2 /* unconditional jump */
249 #define SMALL16 (SMALL|CODE16)
251 #define BIG16 (BIG|CODE16)
255 #define INLINE __inline__
261 #define ENCODE_RELAX_STATE(type,size) \
262 ((relax_substateT)((type<<2) | (size)))
263 #define SIZE_FROM_RELAX_STATE(s) \
264 ( (((s) & 0x3) == BIG ? 4 : (((s) & 0x3) == BIG16 ? 2 : 1)) )
266 /* This table is used by relax_frag to promote short jumps to long
267 ones where necessary. SMALL (short) jumps may be promoted to BIG
268 (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long). We
269 don't allow a short jump in a 32 bit code segment to be promoted to
270 a 16 bit offset jump because it's slower (requires data size
271 prefix), and doesn't work, unless the destination is in the bottom
272 64k of the code segment (The top 16 bits of eip are zeroed). */
274 const relax_typeS md_relax_table
[] =
277 1) most positive reach of this state,
278 2) most negative reach of this state,
279 3) how many bytes this mode will add to the size of the current frag
280 4) which index into the table to try if we can't fit into this one.
287 {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (COND_JUMP
, BIG
)},
288 {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (COND_JUMP
, BIG16
)},
289 /* dword conditionals adds 4 bytes to frag:
290 1 extra opcode byte, 3 extra displacement bytes. */
292 /* word conditionals add 2 bytes to frag:
293 1 extra opcode byte, 1 extra displacement byte. */
296 {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG
)},
297 {127 + 1, -128 + 1, 0, ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG16
)},
298 /* dword jmp adds 3 bytes to frag:
299 0 extra opcode bytes, 3 extra displacement bytes. */
301 /* word jmp adds 1 byte to frag:
302 0 extra opcode bytes, 1 extra displacement byte. */
309 i386_align_code (fragP
, count
)
313 /* Various efficient no-op patterns for aligning code labels. */
314 /* Note: Don't try to assemble the instructions in the comments. */
315 /* 0L and 0w are not legal */
316 static const char f32_1
[] =
318 static const char f32_2
[] =
319 {0x89,0xf6}; /* movl %esi,%esi */
320 static const char f32_3
[] =
321 {0x8d,0x76,0x00}; /* leal 0(%esi),%esi */
322 static const char f32_4
[] =
323 {0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */
324 static const char f32_5
[] =
326 0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */
327 static const char f32_6
[] =
328 {0x8d,0xb6,0x00,0x00,0x00,0x00}; /* leal 0L(%esi),%esi */
329 static const char f32_7
[] =
330 {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
331 static const char f32_8
[] =
333 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
334 static const char f32_9
[] =
335 {0x89,0xf6, /* movl %esi,%esi */
336 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
337 static const char f32_10
[] =
338 {0x8d,0x76,0x00, /* leal 0(%esi),%esi */
339 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
340 static const char f32_11
[] =
341 {0x8d,0x74,0x26,0x00, /* leal 0(%esi,1),%esi */
342 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
343 static const char f32_12
[] =
344 {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */
345 0x8d,0xbf,0x00,0x00,0x00,0x00}; /* leal 0L(%edi),%edi */
346 static const char f32_13
[] =
347 {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */
348 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
349 static const char f32_14
[] =
350 {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00, /* leal 0L(%esi,1),%esi */
351 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
352 static const char f32_15
[] =
353 {0xeb,0x0d,0x90,0x90,0x90,0x90,0x90, /* jmp .+15; lotsa nops */
354 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
355 static const char f16_3
[] =
356 {0x8d,0x74,0x00}; /* lea 0(%esi),%esi */
357 static const char f16_4
[] =
358 {0x8d,0xb4,0x00,0x00}; /* lea 0w(%si),%si */
359 static const char f16_5
[] =
361 0x8d,0xb4,0x00,0x00}; /* lea 0w(%si),%si */
362 static const char f16_6
[] =
363 {0x89,0xf6, /* mov %si,%si */
364 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
365 static const char f16_7
[] =
366 {0x8d,0x74,0x00, /* lea 0(%si),%si */
367 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
368 static const char f16_8
[] =
369 {0x8d,0xb4,0x00,0x00, /* lea 0w(%si),%si */
370 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
371 static const char *const f32_patt
[] = {
372 f32_1
, f32_2
, f32_3
, f32_4
, f32_5
, f32_6
, f32_7
, f32_8
,
373 f32_9
, f32_10
, f32_11
, f32_12
, f32_13
, f32_14
, f32_15
375 static const char *const f16_patt
[] = {
376 f32_1
, f32_2
, f16_3
, f16_4
, f16_5
, f16_6
, f16_7
, f16_8
,
377 f32_15
, f32_15
, f32_15
, f32_15
, f32_15
, f32_15
, f32_15
380 if (count
> 0 && count
<= 15)
384 memcpy(fragP
->fr_literal
+ fragP
->fr_fix
,
385 f16_patt
[count
- 1], count
);
386 if (count
> 8) /* adjust jump offset */
387 fragP
->fr_literal
[fragP
->fr_fix
+ 1] = count
- 2;
390 memcpy(fragP
->fr_literal
+ fragP
->fr_fix
,
391 f32_patt
[count
- 1], count
);
392 fragP
->fr_var
= count
;
396 static char *output_invalid
PARAMS ((int c
));
397 static int i386_operand
PARAMS ((char *operand_string
));
398 static int i386_intel_operand
PARAMS ((char *operand_string
, int got_a_float
));
399 static const reg_entry
*parse_register
PARAMS ((char *reg_string
,
403 static void s_bss
PARAMS ((int));
406 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
408 static INLINE
unsigned int
409 mode_from_disp_size (t
)
412 return (t
& Disp8
) ? 1 : (t
& (Disp16
|Disp32
)) ? 2 : 0;
416 fits_in_signed_byte (num
)
419 return (num
>= -128) && (num
<= 127);
420 } /* fits_in_signed_byte() */
423 fits_in_unsigned_byte (num
)
426 return (num
& 0xff) == num
;
427 } /* fits_in_unsigned_byte() */
430 fits_in_unsigned_word (num
)
433 return (num
& 0xffff) == num
;
434 } /* fits_in_unsigned_word() */
437 fits_in_signed_word (num
)
440 return (-32768 <= num
) && (num
<= 32767);
441 } /* fits_in_signed_word() */
444 smallest_imm_type (num
)
448 /* This code is disabled because all the Imm1 forms in the opcode table
449 are slower on the i486, and they're the versions with the implicitly
450 specified single-position displacement, which has another syntax if
451 you really want to use that form. If you really prefer to have the
452 one-byte-shorter Imm1 form despite these problems, re-enable this
455 return Imm1
| Imm8
| Imm8S
| Imm16
| Imm32
;
457 return (fits_in_signed_byte (num
)
458 ? (Imm8S
| Imm8
| Imm16
| Imm32
)
459 : fits_in_unsigned_byte (num
)
460 ? (Imm8
| Imm16
| Imm32
)
461 : (fits_in_signed_word (num
) || fits_in_unsigned_word (num
))
464 } /* smallest_imm_type() */
466 /* Returns 0 if attempting to add a prefix where one from the same
467 class already exists, 1 if non rep/repne added, 2 if rep/repne
481 case CS_PREFIX_OPCODE
:
482 case DS_PREFIX_OPCODE
:
483 case ES_PREFIX_OPCODE
:
484 case FS_PREFIX_OPCODE
:
485 case GS_PREFIX_OPCODE
:
486 case SS_PREFIX_OPCODE
:
490 case REPNE_PREFIX_OPCODE
:
491 case REPE_PREFIX_OPCODE
:
494 case LOCK_PREFIX_OPCODE
:
502 case ADDR_PREFIX_OPCODE
:
506 case DATA_PREFIX_OPCODE
:
513 as_bad (_("same type of prefix used twice"));
518 i
.prefix
[q
] = prefix
;
523 set_16bit_code_flag (new_16bit_code_flag
)
524 int new_16bit_code_flag
;
526 flag_16bit_code
= new_16bit_code_flag
;
531 set_16bit_gcc_code_flag (new_16bit_code_flag
)
532 int new_16bit_code_flag
;
534 flag_16bit_code
= new_16bit_code_flag
;
535 stackop_size
= new_16bit_code_flag
? 'l' : '\0';
539 set_intel_syntax (syntax_flag
)
542 /* Find out if register prefixing is specified. */
543 int ask_naked_reg
= 0;
546 if (! is_end_of_line
[(unsigned char) *input_line_pointer
])
548 char *string
= input_line_pointer
;
549 int e
= get_symbol_end ();
551 if (strcmp(string
, "prefix") == 0)
553 else if (strcmp(string
, "noprefix") == 0)
556 as_bad (_("Bad argument to syntax directive."));
557 *input_line_pointer
= e
;
559 demand_empty_rest_of_line ();
561 intel_syntax
= syntax_flag
;
563 if (ask_naked_reg
== 0)
566 allow_naked_reg
= (intel_syntax
567 && (bfd_get_symbol_leading_char (stdoutput
) != '\0'));
569 allow_naked_reg
= 0; /* conservative default */
573 allow_naked_reg
= (ask_naked_reg
< 0);
576 const pseudo_typeS md_pseudo_table
[] =
581 #if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
582 {"align", s_align_bytes
, 0},
584 {"align", s_align_ptwo
, 0},
586 {"ffloat", float_cons
, 'f'},
587 {"dfloat", float_cons
, 'd'},
588 {"tfloat", float_cons
, 'x'},
590 {"noopt", s_ignore
, 0},
591 {"optim", s_ignore
, 0},
592 {"code16gcc", set_16bit_gcc_code_flag
, 1},
593 {"code16", set_16bit_code_flag
, 1},
594 {"code32", set_16bit_code_flag
, 0},
595 {"intel_syntax", set_intel_syntax
, 1},
596 {"att_syntax", set_intel_syntax
, 0},
600 /* for interface with expression () */
601 extern char *input_line_pointer
;
603 /* hash table for instruction mnemonic lookup */
604 static struct hash_control
*op_hash
;
605 /* hash table for register lookup */
606 static struct hash_control
*reg_hash
;
612 const char *hash_err
;
614 /* initialize op_hash hash table */
615 op_hash
= hash_new ();
618 register const template *optab
;
619 register templates
*core_optab
;
621 optab
= i386_optab
; /* setup for loop */
622 core_optab
= (templates
*) xmalloc (sizeof (templates
));
623 core_optab
->start
= optab
;
628 if (optab
->name
== NULL
629 || strcmp (optab
->name
, (optab
- 1)->name
) != 0)
631 /* different name --> ship out current template list;
632 add to hash table; & begin anew */
633 core_optab
->end
= optab
;
634 hash_err
= hash_insert (op_hash
,
640 as_fatal (_("Internal Error: Can't hash %s: %s"),
644 if (optab
->name
== NULL
)
646 core_optab
= (templates
*) xmalloc (sizeof (templates
));
647 core_optab
->start
= optab
;
652 /* initialize reg_hash hash table */
653 reg_hash
= hash_new ();
655 register const reg_entry
*regtab
;
657 for (regtab
= i386_regtab
;
658 regtab
< i386_regtab
+ sizeof (i386_regtab
) / sizeof (i386_regtab
[0]);
661 hash_err
= hash_insert (reg_hash
, regtab
->reg_name
, (PTR
) regtab
);
667 /* fill in lexical tables: mnemonic_chars, operand_chars. */
672 for (c
= 0; c
< 256; c
++)
677 mnemonic_chars
[c
] = c
;
678 register_chars
[c
] = c
;
679 operand_chars
[c
] = c
;
681 else if (islower (c
))
683 mnemonic_chars
[c
] = c
;
684 register_chars
[c
] = c
;
685 operand_chars
[c
] = c
;
687 else if (isupper (c
))
689 mnemonic_chars
[c
] = tolower (c
);
690 register_chars
[c
] = mnemonic_chars
[c
];
691 operand_chars
[c
] = c
;
694 if (isalpha (c
) || isdigit (c
))
695 identifier_chars
[c
] = c
;
698 identifier_chars
[c
] = c
;
699 operand_chars
[c
] = c
;
704 identifier_chars
['@'] = '@';
706 digit_chars
['-'] = '-';
707 identifier_chars
['_'] = '_';
708 identifier_chars
['.'] = '.';
710 for (p
= operand_special_chars
; *p
!= '\0'; p
++)
711 operand_chars
[(unsigned char) *p
] = *p
;
714 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
715 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
)
717 record_alignment (text_section
, 2);
718 record_alignment (data_section
, 2);
719 record_alignment (bss_section
, 2);
725 i386_print_statistics (file
)
728 hash_print_statistics (file
, "i386 opcode", op_hash
);
729 hash_print_statistics (file
, "i386 register", reg_hash
);
735 /* debugging routines for md_assemble */
736 static void pi
PARAMS ((char *, i386_insn
*));
737 static void pte
PARAMS ((template *));
738 static void pt
PARAMS ((unsigned int));
739 static void pe
PARAMS ((expressionS
*));
740 static void ps
PARAMS ((symbolS
*));
747 register template *p
;
750 fprintf (stdout
, "%s: template ", line
);
752 fprintf (stdout
, " modrm: mode %x reg %x reg/mem %x",
753 x
->rm
.mode
, x
->rm
.reg
, x
->rm
.regmem
);
754 fprintf (stdout
, " base %x index %x scale %x\n",
755 x
->bi
.base
, x
->bi
.index
, x
->bi
.scale
);
756 for (i
= 0; i
< x
->operands
; i
++)
758 fprintf (stdout
, " #%d: ", i
+ 1);
760 fprintf (stdout
, "\n");
762 & (Reg
| SReg2
| SReg3
| Control
| Debug
| Test
| RegMMX
| RegXMM
))
763 fprintf (stdout
, "%s\n", x
->regs
[i
]->reg_name
);
764 if (x
->types
[i
] & Imm
)
766 if (x
->types
[i
] & Disp
)
776 fprintf (stdout
, " %d operands ", t
->operands
);
777 fprintf (stdout
, "opcode %x ",
779 if (t
->extension_opcode
!= None
)
780 fprintf (stdout
, "ext %x ", t
->extension_opcode
);
781 if (t
->opcode_modifier
& D
)
782 fprintf (stdout
, "D");
783 if (t
->opcode_modifier
& W
)
784 fprintf (stdout
, "W");
785 fprintf (stdout
, "\n");
786 for (i
= 0; i
< t
->operands
; i
++)
788 fprintf (stdout
, " #%d type ", i
+ 1);
789 pt (t
->operand_types
[i
]);
790 fprintf (stdout
, "\n");
798 fprintf (stdout
, " operation %d\n", e
->X_op
);
799 fprintf (stdout
, " add_number %ld (%lx)\n",
800 (long) e
->X_add_number
, (long) e
->X_add_number
);
803 fprintf (stdout
, " add_symbol ");
804 ps (e
->X_add_symbol
);
805 fprintf (stdout
, "\n");
809 fprintf (stdout
, " op_symbol ");
811 fprintf (stdout
, "\n");
819 fprintf (stdout
, "%s type %s%s",
821 S_IS_EXTERNAL (s
) ? "EXTERNAL " : "",
822 segment_name (S_GET_SEGMENT (s
)));
841 { BaseIndex
, "BaseIndex" },
845 { InOutPortReg
, "InOutPortReg" },
846 { ShiftCount
, "ShiftCount" },
847 { Control
, "control reg" },
848 { Test
, "test reg" },
849 { Debug
, "debug reg" },
850 { FloatReg
, "FReg" },
851 { FloatAcc
, "FAcc" },
855 { JumpAbsolute
, "Jump Absolute" },
866 register struct type_name
*ty
;
870 fprintf (stdout
, _("Unknown"));
874 for (ty
= type_names
; ty
->mask
; ty
++)
876 fprintf (stdout
, "%s, ", ty
->tname
);
881 #endif /* DEBUG386 */
884 tc_i386_force_relocation (fixp
)
888 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
889 || fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
894 return fixp
->fx_r_type
==7;
899 static bfd_reloc_code_real_type reloc
900 PARAMS ((int, int, bfd_reloc_code_real_type
));
902 static bfd_reloc_code_real_type
903 reloc (size
, pcrel
, other
)
906 bfd_reloc_code_real_type other
;
908 if (other
!= NO_RELOC
) return other
;
914 case 1: return BFD_RELOC_8_PCREL
;
915 case 2: return BFD_RELOC_16_PCREL
;
916 case 4: return BFD_RELOC_32_PCREL
;
918 as_bad (_("Can not do %d byte pc-relative relocation"), size
);
924 case 1: return BFD_RELOC_8
;
925 case 2: return BFD_RELOC_16
;
926 case 4: return BFD_RELOC_32
;
928 as_bad (_("Can not do %d byte relocation"), size
);
931 return BFD_RELOC_NONE
;
935 * Here we decide which fixups can be adjusted to make them relative to
936 * the beginning of the section instead of the symbol. Basically we need
937 * to make sure that the dynamic relocations are done correctly, so in
938 * some cases we force the original symbol to be used.
941 tc_i386_fix_adjustable(fixP
)
945 /* Prevent all adjustments to global symbols. */
946 if (S_IS_EXTERN (fixP
->fx_addsy
))
948 if (S_IS_WEAK (fixP
->fx_addsy
))
951 /* adjust_reloc_syms doesn't know about the GOT */
952 if (fixP
->fx_r_type
== BFD_RELOC_386_GOTOFF
953 || fixP
->fx_r_type
== BFD_RELOC_386_PLT32
954 || fixP
->fx_r_type
== BFD_RELOC_386_GOT32
955 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
956 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
961 #define reloc(SIZE,PCREL,OTHER) 0
962 #define BFD_RELOC_16 0
963 #define BFD_RELOC_32 0
964 #define BFD_RELOC_16_PCREL 0
965 #define BFD_RELOC_32_PCREL 0
966 #define BFD_RELOC_386_PLT32 0
967 #define BFD_RELOC_386_GOT32 0
968 #define BFD_RELOC_386_GOTOFF 0
972 intel_float_operand
PARAMS ((char *mnemonic
));
975 intel_float_operand (mnemonic
)
978 if (mnemonic
[0] == 'f' && mnemonic
[1] =='i')
981 if (mnemonic
[0] == 'f')
987 /* This is the guts of the machine-dependent assembler. LINE points to a
988 machine dependent instruction. This function is supposed to emit
989 the frags/bytes it assembles to. */
995 /* Points to template once we've found it. */
998 /* Count the size of the instruction generated. */
1003 char mnemonic
[MAX_MNEM_SIZE
];
1005 /* Initialize globals. */
1006 memset (&i
, '\0', sizeof (i
));
1007 for (j
= 0; j
< MAX_OPERANDS
; j
++)
1008 i
.disp_reloc
[j
] = NO_RELOC
;
1009 memset (disp_expressions
, '\0', sizeof (disp_expressions
));
1010 memset (im_expressions
, '\0', sizeof (im_expressions
));
1011 save_stack_p
= save_stack
; /* reset stack pointer */
1013 /* First parse an instruction mnemonic & call i386_operand for the operands.
1014 We assume that the scrubber has arranged it so that line[0] is the valid
1015 start of a (possibly prefixed) mnemonic. */
1018 char *token_start
= l
;
1021 /* Non-zero if we found a prefix only acceptable with string insns. */
1022 const char *expecting_string_instruction
= NULL
;
1027 while ((*mnem_p
= mnemonic_chars
[(unsigned char) *l
]) != 0)
1030 if (mnem_p
>= mnemonic
+ sizeof (mnemonic
))
1032 as_bad (_("no such 386 instruction: `%s'"), token_start
);
1037 if (!is_space_char (*l
)
1038 && *l
!= END_OF_INSN
1039 && *l
!= PREFIX_SEPARATOR
)
1041 as_bad (_("invalid character %s in mnemonic"),
1042 output_invalid (*l
));
1045 if (token_start
== l
)
1047 if (*l
== PREFIX_SEPARATOR
)
1048 as_bad (_("expecting prefix; got nothing"));
1050 as_bad (_("expecting mnemonic; got nothing"));
1054 /* Look up instruction (or prefix) via hash table. */
1055 current_templates
= hash_find (op_hash
, mnemonic
);
1057 if (*l
!= END_OF_INSN
1058 && (! is_space_char (*l
) || l
[1] != END_OF_INSN
)
1059 && current_templates
1060 && (current_templates
->start
->opcode_modifier
& IsPrefix
))
1062 /* If we are in 16-bit mode, do not allow addr16 or data16.
1063 Similarly, in 32-bit mode, do not allow addr32 or data32. */
1064 if ((current_templates
->start
->opcode_modifier
& (Size16
| Size32
))
1065 && (((current_templates
->start
->opcode_modifier
& Size32
) != 0)
1068 as_bad (_("redundant %s prefix"),
1069 current_templates
->start
->name
);
1072 /* Add prefix, checking for repeated prefixes. */
1073 switch (add_prefix (current_templates
->start
->base_opcode
))
1078 expecting_string_instruction
=
1079 current_templates
->start
->name
;
1082 /* Skip past PREFIX_SEPARATOR and reset token_start. */
1089 if (!current_templates
)
1091 /* See if we can get a match by trimming off a suffix. */
1094 case DWORD_MNEM_SUFFIX
:
1095 case WORD_MNEM_SUFFIX
:
1096 case BYTE_MNEM_SUFFIX
:
1097 case SHORT_MNEM_SUFFIX
:
1098 #if LONG_MNEM_SUFFIX != DWORD_MNEM_SUFFIX
1099 case LONG_MNEM_SUFFIX
:
1101 i
.suffix
= mnem_p
[-1];
1103 current_templates
= hash_find (op_hash
, mnemonic
);
1107 case INTEL_DWORD_MNEM_SUFFIX
:
1110 i
.suffix
= mnem_p
[-1];
1112 current_templates
= hash_find (op_hash
, mnemonic
);
1116 if (!current_templates
)
1118 as_bad (_("no such 386 instruction: `%s'"), token_start
);
1123 /* check for rep/repne without a string instruction */
1124 if (expecting_string_instruction
1125 && !(current_templates
->start
->opcode_modifier
& IsString
))
1127 as_bad (_("expecting string instruction after `%s'"),
1128 expecting_string_instruction
);
1132 /* There may be operands to parse. */
1133 if (*l
!= END_OF_INSN
)
1135 /* parse operands */
1137 /* 1 if operand is pending after ','. */
1138 unsigned int expecting_operand
= 0;
1140 /* Non-zero if operand parens not balanced. */
1141 unsigned int paren_not_balanced
;
1145 /* skip optional white space before operand */
1146 if (is_space_char (*l
))
1148 if (!is_operand_char (*l
) && *l
!= END_OF_INSN
)
1150 as_bad (_("invalid character %s before operand %d"),
1151 output_invalid (*l
),
1155 token_start
= l
; /* after white space */
1156 paren_not_balanced
= 0;
1157 while (paren_not_balanced
|| *l
!= ',')
1159 if (*l
== END_OF_INSN
)
1161 if (paren_not_balanced
)
1164 as_bad (_("unbalanced parenthesis in operand %d."),
1167 as_bad (_("unbalanced brackets in operand %d."),
1172 break; /* we are done */
1174 else if (!is_operand_char (*l
) && !is_space_char (*l
))
1176 as_bad (_("invalid character %s in operand %d"),
1177 output_invalid (*l
),
1184 ++paren_not_balanced
;
1186 --paren_not_balanced
;
1191 ++paren_not_balanced
;
1193 --paren_not_balanced
;
1197 if (l
!= token_start
)
1198 { /* yes, we've read in another operand */
1199 unsigned int operand_ok
;
1200 this_operand
= i
.operands
++;
1201 if (i
.operands
> MAX_OPERANDS
)
1203 as_bad (_("spurious operands; (%d operands/instruction max)"),
1207 /* now parse operand adding info to 'i' as we go along */
1208 END_STRING_AND_SAVE (l
);
1211 operand_ok
= i386_intel_operand (token_start
, intel_float_operand (mnemonic
));
1213 operand_ok
= i386_operand (token_start
);
1215 RESTORE_END_STRING (l
); /* restore old contents */
1221 if (expecting_operand
)
1223 expecting_operand_after_comma
:
1224 as_bad (_("expecting operand after ','; got nothing"));
1229 as_bad (_("expecting operand before ','; got nothing"));
1234 /* now *l must be either ',' or END_OF_INSN */
1237 if (*++l
== END_OF_INSN
)
1238 { /* just skip it, if it's \n complain */
1239 goto expecting_operand_after_comma
;
1241 expecting_operand
= 1;
1244 while (*l
!= END_OF_INSN
); /* until we get end of insn */
1248 /* Now we've parsed the mnemonic into a set of templates, and have the
1251 Next, we find a template that matches the given insn,
1252 making sure the overlap of the given operands types is consistent
1253 with the template operand types. */
1255 #define MATCH(overlap, given, template) \
1257 && ((given) & BaseIndex) == ((overlap) & BaseIndex) \
1258 && ((given) & JumpAbsolute) == ((template) & JumpAbsolute))
1260 /* If given types r0 and r1 are registers they must be of the same type
1261 unless the expected operand type register overlap is null.
1262 Note that Acc in a template matches every size of reg. */
1263 #define CONSISTENT_REGISTER_MATCH(m0, g0, t0, m1, g1, t1) \
1264 ( ((g0) & Reg) == 0 || ((g1) & Reg) == 0 || \
1265 ((g0) & Reg) == ((g1) & Reg) || \
1266 ((((m0) & Acc) ? Reg : (t0)) & (((m1) & Acc) ? Reg : (t1)) & Reg) == 0 )
1269 register unsigned int overlap0
, overlap1
;
1270 unsigned int overlap2
;
1271 unsigned int found_reverse_match
;
1274 /* All intel opcodes have reversed operands except for BOUND and ENTER */
1276 && (strcmp (mnemonic
, "enter") != 0)
1277 && (strcmp (mnemonic
, "bound") != 0)
1278 && (strncmp (mnemonic
, "fsub", 4) !=0)
1279 && (strncmp (mnemonic
, "fdiv", 4) !=0))
1281 const reg_entry
*temp_reg
= NULL
;
1282 expressionS
*temp_disp
= NULL
;
1283 expressionS
*temp_imm
= NULL
;
1284 unsigned int temp_type
;
1288 if (i
.operands
== 2)
1293 else if (i
.operands
== 3)
1301 temp_type
= i
.types
[xchg2
];
1302 if (temp_type
& (Reg
| FloatReg
))
1303 temp_reg
= i
.regs
[xchg2
];
1304 else if (temp_type
& Imm
)
1305 temp_imm
= i
.imms
[xchg2
];
1306 else if (temp_type
& Disp
)
1307 temp_disp
= i
.disps
[xchg2
];
1309 i
.types
[xchg2
] = i
.types
[xchg1
];
1311 if (i
.types
[xchg1
] & (Reg
| FloatReg
))
1313 i
.regs
[xchg2
] = i
.regs
[xchg1
];
1314 i
.regs
[xchg1
] = NULL
;
1316 else if (i
.types
[xchg2
] & Imm
)
1318 i
.imms
[xchg2
] = i
.imms
[xchg1
];
1319 i
.imms
[xchg1
] = NULL
;
1321 else if (i
.types
[xchg2
] & Disp
)
1323 i
.disps
[xchg2
] = i
.disps
[xchg1
];
1324 i
.disps
[xchg1
] = NULL
;
1327 if (temp_type
& (Reg
| FloatReg
))
1329 i
.regs
[xchg1
] = temp_reg
;
1330 if (! (i
.types
[xchg1
] & (Reg
| FloatReg
)))
1331 i
.regs
[xchg2
] = NULL
;
1333 else if (temp_type
& Imm
)
1335 i
.imms
[xchg1
] = temp_imm
;
1336 if (! (i
.types
[xchg1
] & Imm
))
1337 i
.imms
[xchg2
] = NULL
;
1339 else if (temp_type
& Disp
)
1341 i
.disps
[xchg1
] = temp_disp
;
1342 if (! (i
.types
[xchg1
] & Disp
))
1343 i
.disps
[xchg2
] = NULL
;
1346 i
.types
[xchg1
] = temp_type
;
1348 if (!strcmp(mnemonic
,"jmp")
1349 || !strcmp (mnemonic
, "call"))
1350 if ((i
.types
[0] & Reg
) || i
.types
[0] & BaseIndex
)
1351 i
.types
[0] |= JumpAbsolute
;
1357 found_reverse_match
= 0;
1358 suffix_check
= (i
.suffix
== BYTE_MNEM_SUFFIX
1360 : (i
.suffix
== WORD_MNEM_SUFFIX
1362 : (i
.suffix
== SHORT_MNEM_SUFFIX
1364 : (i
.suffix
== LONG_MNEM_SUFFIX
1366 : (i
.suffix
== INTEL_DWORD_MNEM_SUFFIX
1368 : (i
.suffix
== LONG_DOUBLE_MNEM_SUFFIX
? No_xSuf
: 0))))));
1370 for (t
= current_templates
->start
;
1371 t
< current_templates
->end
;
1374 /* Must have right number of operands. */
1375 if (i
.operands
!= t
->operands
)
1378 /* For some opcodes, don't check the suffix */
1381 if (strcmp (t
->name
, "fnstcw")
1382 && strcmp (t
->name
, "fldcw")
1383 && (t
->opcode_modifier
& suffix_check
))
1386 /* Must not have disallowed suffix. */
1387 else if ((t
->opcode_modifier
& suffix_check
))
1390 else if (!t
->operands
)
1391 break; /* 0 operands always matches */
1393 overlap0
= i
.types
[0] & t
->operand_types
[0];
1394 switch (t
->operands
)
1397 if (!MATCH (overlap0
, i
.types
[0], t
->operand_types
[0]))
1402 overlap1
= i
.types
[1] & t
->operand_types
[1];
1403 if (!MATCH (overlap0
, i
.types
[0], t
->operand_types
[0])
1404 || !MATCH (overlap1
, i
.types
[1], t
->operand_types
[1])
1405 || !CONSISTENT_REGISTER_MATCH (overlap0
, i
.types
[0],
1406 t
->operand_types
[0],
1407 overlap1
, i
.types
[1],
1408 t
->operand_types
[1]))
1411 /* check if other direction is valid ... */
1412 if ((t
->opcode_modifier
& (D
|FloatD
)) == 0)
1415 /* try reversing direction of operands */
1416 overlap0
= i
.types
[0] & t
->operand_types
[1];
1417 overlap1
= i
.types
[1] & t
->operand_types
[0];
1418 if (!MATCH (overlap0
, i
.types
[0], t
->operand_types
[1])
1419 || !MATCH (overlap1
, i
.types
[1], t
->operand_types
[0])
1420 || !CONSISTENT_REGISTER_MATCH (overlap0
, i
.types
[0],
1421 t
->operand_types
[1],
1422 overlap1
, i
.types
[1],
1423 t
->operand_types
[0]))
1425 /* does not match either direction */
1428 /* found_reverse_match holds which of D or FloatDR
1430 found_reverse_match
= t
->opcode_modifier
& (D
|FloatDR
);
1433 /* found a forward 2 operand match here */
1434 if (t
->operands
== 3)
1436 /* Here we make use of the fact that there are no
1437 reverse match 3 operand instructions, and all 3
1438 operand instructions only need to be checked for
1439 register consistency between operands 2 and 3. */
1440 overlap2
= i
.types
[2] & t
->operand_types
[2];
1441 if (!MATCH (overlap2
, i
.types
[2], t
->operand_types
[2])
1442 || !CONSISTENT_REGISTER_MATCH (overlap1
, i
.types
[1],
1443 t
->operand_types
[1],
1444 overlap2
, i
.types
[2],
1445 t
->operand_types
[2]))
1449 /* found either forward/reverse 2 or 3 operand match here:
1450 slip through to break */
1452 break; /* we've found a match; break out of loop */
1453 } /* for (t = ... */
1454 if (t
== current_templates
->end
)
1455 { /* we found no match */
1456 as_bad (_("suffix or operands invalid for `%s'"),
1457 current_templates
->start
->name
);
1461 if ((t
->opcode_modifier
& (IsPrefix
|IgnoreSize
)) == (IsPrefix
|IgnoreSize
))
1463 /* Warn them that a data or address size prefix doesn't affect
1464 assembly of the next line of code. */
1465 as_warn (_("stand-alone `%s' prefix"), t
->name
);
1468 /* Copy the template we found. */
1470 if (found_reverse_match
)
1472 i
.tm
.operand_types
[0] = t
->operand_types
[1];
1473 i
.tm
.operand_types
[1] = t
->operand_types
[0];
1477 if (i
.tm
.opcode_modifier
& FWait
)
1478 if (! add_prefix (FWAIT_OPCODE
))
1481 /* Check string instruction segment overrides */
1482 if ((i
.tm
.opcode_modifier
& IsString
) != 0 && i
.mem_operands
!= 0)
1484 int mem_op
= (i
.types
[0] & AnyMem
) ? 0 : 1;
1485 if ((i
.tm
.operand_types
[mem_op
] & EsSeg
) != 0)
1487 if (i
.seg
[0] != NULL
&& i
.seg
[0] != &es
)
1489 as_bad (_("`%s' operand %d must use `%%es' segment"),
1494 /* There's only ever one segment override allowed per instruction.
1495 This instruction possibly has a legal segment override on the
1496 second operand, so copy the segment to where non-string
1497 instructions store it, allowing common code. */
1498 i
.seg
[0] = i
.seg
[1];
1500 else if ((i
.tm
.operand_types
[mem_op
+ 1] & EsSeg
) != 0)
1502 if (i
.seg
[1] != NULL
&& i
.seg
[1] != &es
)
1504 as_bad (_("`%s' operand %d must use `%%es' segment"),
1512 /* If matched instruction specifies an explicit instruction mnemonic
1514 if (i
.tm
.opcode_modifier
& (Size16
| Size32
))
1516 if (i
.tm
.opcode_modifier
& Size16
)
1517 i
.suffix
= WORD_MNEM_SUFFIX
;
1519 i
.suffix
= DWORD_MNEM_SUFFIX
;
1521 else if (i
.reg_operands
)
1523 /* If there's no instruction mnemonic suffix we try to invent one
1524 based on register operands. */
1527 /* We take i.suffix from the last register operand specified,
1528 Destination register type is more significant than source
1531 for (op
= i
.operands
; --op
>= 0; )
1532 if (i
.types
[op
] & Reg
)
1534 i
.suffix
= ((i
.types
[op
] & Reg8
) ? BYTE_MNEM_SUFFIX
:
1535 (i
.types
[op
] & Reg16
) ? WORD_MNEM_SUFFIX
:
1540 else if (i
.suffix
== BYTE_MNEM_SUFFIX
)
1543 for (op
= i
.operands
; --op
>= 0; )
1545 /* If this is an eight bit register, it's OK. If it's
1546 the 16 or 32 bit version of an eight bit register,
1547 we will just use the low portion, and that's OK too. */
1548 if (i
.types
[op
] & Reg8
)
1551 /* movzx and movsx should not generate this warning. */
1553 && (i
.tm
.base_opcode
== 0xfb7
1554 || i
.tm
.base_opcode
== 0xfb6
1555 || i
.tm
.base_opcode
== 0xfbe
1556 || i
.tm
.base_opcode
== 0xfbf))
1559 if ((i
.types
[op
] & WordReg
) && i
.regs
[op
]->reg_num
< 4
1561 /* Check that the template allows eight bit regs
1562 This kills insns such as `orb $1,%edx', which
1563 maybe should be allowed. */
1564 && (i
.tm
.operand_types
[op
] & (Reg8
|InOutPortReg
))
1568 #if REGISTER_WARNINGS
1569 if ((i
.tm
.operand_types
[op
] & InOutPortReg
) == 0)
1570 as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
1571 (i
.regs
[op
] - (i
.types
[op
] & Reg16
? 8 : 16))->reg_name
,
1572 i
.regs
[op
]->reg_name
,
1577 /* Any other register is bad */
1578 if (i
.types
[op
] & (Reg
| RegMMX
| RegXMM
1580 | Control
| Debug
| Test
1581 | FloatReg
| FloatAcc
))
1583 as_bad (_("`%%%s' not allowed with `%s%c'"),
1584 i
.regs
[op
]->reg_name
,
1591 else if (i
.suffix
== DWORD_MNEM_SUFFIX
)
1594 for (op
= i
.operands
; --op
>= 0; )
1595 /* Reject eight bit registers, except where the template
1596 requires them. (eg. movzb) */
1597 if ((i
.types
[op
] & Reg8
) != 0
1598 && (i
.tm
.operand_types
[op
] & (Reg16
|Reg32
|Acc
)) != 0)
1600 as_bad (_("`%%%s' not allowed with `%s%c'"),
1601 i
.regs
[op
]->reg_name
,
1606 #if REGISTER_WARNINGS
1607 /* Warn if the e prefix on a general reg is missing. */
1608 else if ((i
.types
[op
] & Reg16
) != 0
1609 && (i
.tm
.operand_types
[op
] & (Reg32
|Acc
)) != 0)
1611 as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
1612 (i
.regs
[op
] + 8)->reg_name
,
1613 i
.regs
[op
]->reg_name
,
1618 else if (i
.suffix
== WORD_MNEM_SUFFIX
)
1621 for (op
= i
.operands
; --op
>= 0; )
1622 /* Reject eight bit registers, except where the template
1623 requires them. (eg. movzb) */
1624 if ((i
.types
[op
] & Reg8
) != 0
1625 && (i
.tm
.operand_types
[op
] & (Reg16
|Reg32
|Acc
)) != 0)
1627 as_bad (_("`%%%s' not allowed with `%s%c'"),
1628 i
.regs
[op
]->reg_name
,
1633 #if REGISTER_WARNINGS
1634 /* Warn if the e prefix on a general reg is present. */
1635 else if ((i
.types
[op
] & Reg32
) != 0
1636 && (i
.tm
.operand_types
[op
] & (Reg16
|Acc
)) != 0)
1638 as_warn (_("using `%%%s' instead of `%%%s' due to `%c' suffix"),
1639 (i
.regs
[op
] - 8)->reg_name
,
1640 i
.regs
[op
]->reg_name
,
1648 else if ((i
.tm
.opcode_modifier
& DefaultSize
) && !i
.suffix
)
1650 i
.suffix
= stackop_size
;
1653 /* Make still unresolved immediate matches conform to size of immediate
1654 given in i.suffix. Note: overlap2 cannot be an immediate! */
1655 if ((overlap0
& (Imm8
| Imm8S
| Imm16
| Imm32
))
1656 && overlap0
!= Imm8
&& overlap0
!= Imm8S
1657 && overlap0
!= Imm16
&& overlap0
!= Imm32
)
1661 overlap0
&= (i
.suffix
== BYTE_MNEM_SUFFIX
? (Imm8
| Imm8S
) :
1662 (i
.suffix
== WORD_MNEM_SUFFIX
? Imm16
: Imm32
));
1664 else if (overlap0
== (Imm16
| Imm32
))
1667 (flag_16bit_code
^ (i
.prefix
[DATA_PREFIX
] != 0)) ? Imm16
: Imm32
;
1671 as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
1675 if ((overlap1
& (Imm8
| Imm8S
| Imm16
| Imm32
))
1676 && overlap1
!= Imm8
&& overlap1
!= Imm8S
1677 && overlap1
!= Imm16
&& overlap1
!= Imm32
)
1681 overlap1
&= (i
.suffix
== BYTE_MNEM_SUFFIX
? (Imm8
| Imm8S
) :
1682 (i
.suffix
== WORD_MNEM_SUFFIX
? Imm16
: Imm32
));
1684 else if (overlap1
== (Imm16
| Imm32
))
1687 (flag_16bit_code
^ (i
.prefix
[DATA_PREFIX
] != 0)) ? Imm16
: Imm32
;
1691 as_bad (_("no instruction mnemonic suffix given; can't determine immediate size"));
1695 assert ((overlap2
& Imm
) == 0);
1697 i
.types
[0] = overlap0
;
1698 if (overlap0
& ImplicitRegister
)
1700 if (overlap0
& Imm1
)
1701 i
.imm_operands
= 0; /* kludge for shift insns */
1703 i
.types
[1] = overlap1
;
1704 if (overlap1
& ImplicitRegister
)
1707 i
.types
[2] = overlap2
;
1708 if (overlap2
& ImplicitRegister
)
1711 /* Finalize opcode. First, we change the opcode based on the operand
1712 size given by i.suffix: We need not change things for byte insns. */
1714 if (!i
.suffix
&& (i
.tm
.opcode_modifier
& W
))
1716 as_bad (_("no instruction mnemonic suffix given and no register operands; can't size instruction"));
1720 /* For movzx and movsx, need to check the register type */
1722 && (i
.tm
.base_opcode
== 0xfb6 || i
.tm
.base_opcode
== 0xfbe))
1723 if (i
.suffix
&& i
.suffix
== BYTE_MNEM_SUFFIX
)
1725 unsigned int prefix
= DATA_PREFIX_OPCODE
;
1727 if ((i
.regs
[1]->reg_type
& Reg16
) != 0)
1728 if (!add_prefix (prefix
))
1732 if (i
.suffix
&& i
.suffix
!= BYTE_MNEM_SUFFIX
)
1734 /* It's not a byte, select word/dword operation. */
1735 if (i
.tm
.opcode_modifier
& W
)
1737 if (i
.tm
.opcode_modifier
& ShortForm
)
1738 i
.tm
.base_opcode
|= 8;
1740 i
.tm
.base_opcode
|= 1;
1742 /* Now select between word & dword operations via the operand
1743 size prefix, except for instructions that will ignore this
1745 if (((intel_syntax
&& (i
.suffix
== INTEL_DWORD_MNEM_SUFFIX
))
1746 || i
.suffix
== DWORD_MNEM_SUFFIX
1747 || i
.suffix
== LONG_MNEM_SUFFIX
) == flag_16bit_code
1748 && !(i
.tm
.opcode_modifier
& IgnoreSize
))
1750 unsigned int prefix
= DATA_PREFIX_OPCODE
;
1751 if (i
.tm
.opcode_modifier
& JumpByte
) /* jcxz, loop */
1752 prefix
= ADDR_PREFIX_OPCODE
;
1754 if (! add_prefix (prefix
))
1757 /* Size floating point instruction. */
1758 if (i
.suffix
== LONG_MNEM_SUFFIX
1759 || (intel_syntax
&& i
.suffix
== INTEL_DWORD_MNEM_SUFFIX
))
1761 if (i
.tm
.opcode_modifier
& FloatMF
)
1762 i
.tm
.base_opcode
^= 4;
1766 if (i
.tm
.opcode_modifier
& ImmExt
)
1768 /* These AMD 3DNow! and Intel Katmai New Instructions have an
1769 opcode suffix which is coded in the same place as an 8-bit
1770 immediate field would be. Here we fake an 8-bit immediate
1771 operand from the opcode suffix stored in tm.extension_opcode. */
1775 assert(i
.imm_operands
== 0 && i
.operands
<= 2);
1777 exp
= &im_expressions
[i
.imm_operands
++];
1778 i
.imms
[i
.operands
] = exp
;
1779 i
.types
[i
.operands
++] = Imm8
;
1780 exp
->X_op
= O_constant
;
1781 exp
->X_add_number
= i
.tm
.extension_opcode
;
1782 i
.tm
.extension_opcode
= None
;
1785 /* For insns with operands there are more diddles to do to the opcode. */
1788 /* Default segment register this instruction will use
1789 for memory accesses. 0 means unknown.
1790 This is only for optimizing out unnecessary segment overrides. */
1791 const seg_entry
*default_seg
= 0;
1793 /* If we found a reverse match we must alter the opcode
1794 direction bit. found_reverse_match holds bits to change
1795 (different for int & float insns). */
1797 i
.tm
.base_opcode
^= found_reverse_match
;
1799 /* The imul $imm, %reg instruction is converted into
1800 imul $imm, %reg, %reg, and the clr %reg instruction
1801 is converted into xor %reg, %reg. */
1802 if (i
.tm
.opcode_modifier
& regKludge
)
1804 unsigned int first_reg_op
= (i
.types
[0] & Reg
) ? 0 : 1;
1805 /* Pretend we saw the extra register operand. */
1806 i
.regs
[first_reg_op
+1] = i
.regs
[first_reg_op
];
1810 if (i
.tm
.opcode_modifier
& ShortForm
)
1812 /* The register or float register operand is in operand 0 or 1. */
1813 unsigned int op
= (i
.types
[0] & (Reg
| FloatReg
)) ? 0 : 1;
1814 /* Register goes in low 3 bits of opcode. */
1815 i
.tm
.base_opcode
|= i
.regs
[op
]->reg_num
;
1816 if ((i
.tm
.opcode_modifier
& Ugh
) != 0)
1818 /* Warn about some common errors, but press on regardless.
1819 The first case can be generated by gcc (<= 2.8.1). */
1820 if (i
.operands
== 2)
1822 /* reversed arguments on faddp, fsubp, etc. */
1823 as_warn (_("translating to `%s %%%s,%%%s'"), i
.tm
.name
,
1824 i
.regs
[1]->reg_name
,
1825 i
.regs
[0]->reg_name
);
1829 /* extraneous `l' suffix on fp insn */
1830 as_warn (_("translating to `%s %%%s'"), i
.tm
.name
,
1831 i
.regs
[0]->reg_name
);
1835 else if (i
.tm
.opcode_modifier
& Modrm
)
1837 /* The opcode is completed (modulo i.tm.extension_opcode which
1838 must be put into the modrm byte).
1839 Now, we make the modrm & index base bytes based on all the
1840 info we've collected. */
1842 /* i.reg_operands MUST be the number of real register operands;
1843 implicit registers do not count. */
1844 if (i
.reg_operands
== 2)
1846 unsigned int source
, dest
;
1847 source
= ((i
.types
[0]
1848 & (Reg
| RegMMX
| RegXMM
1850 | Control
| Debug
| Test
))
1855 /* One of the register operands will be encoded in the
1856 i.tm.reg field, the other in the combined i.tm.mode
1857 and i.tm.regmem fields. If no form of this
1858 instruction supports a memory destination operand,
1859 then we assume the source operand may sometimes be
1860 a memory operand and so we need to store the
1861 destination in the i.rm.reg field. */
1862 if ((i
.tm
.operand_types
[dest
] & AnyMem
) == 0)
1864 i
.rm
.reg
= i
.regs
[dest
]->reg_num
;
1865 i
.rm
.regmem
= i
.regs
[source
]->reg_num
;
1869 i
.rm
.reg
= i
.regs
[source
]->reg_num
;
1870 i
.rm
.regmem
= i
.regs
[dest
]->reg_num
;
1874 { /* if it's not 2 reg operands... */
1877 unsigned int fake_zero_displacement
= 0;
1878 unsigned int op
= ((i
.types
[0] & AnyMem
)
1880 : (i
.types
[1] & AnyMem
) ? 1 : 2);
1887 if (! i
.disp_operands
)
1888 fake_zero_displacement
= 1;
1891 /* Operand is just <disp> */
1892 if (flag_16bit_code
^ (i
.prefix
[ADDR_PREFIX
] != 0))
1894 i
.rm
.regmem
= NO_BASE_REGISTER_16
;
1895 i
.types
[op
] &= ~Disp
;
1896 i
.types
[op
] |= Disp16
;
1900 i
.rm
.regmem
= NO_BASE_REGISTER
;
1901 i
.types
[op
] &= ~Disp
;
1902 i
.types
[op
] |= Disp32
;
1905 else /* ! i.base_reg && i.index_reg */
1907 i
.sib
.index
= i
.index_reg
->reg_num
;
1908 i
.sib
.base
= NO_BASE_REGISTER
;
1909 i
.sib
.scale
= i
.log2_scale_factor
;
1910 i
.rm
.regmem
= ESCAPE_TO_TWO_BYTE_ADDRESSING
;
1911 i
.types
[op
] &= ~Disp
;
1912 i
.types
[op
] |= Disp32
; /* Must be 32 bit */
1915 else if (i
.base_reg
->reg_type
& Reg16
)
1917 switch (i
.base_reg
->reg_num
)
1922 else /* (%bx,%si) -> 0, or (%bx,%di) -> 1 */
1923 i
.rm
.regmem
= i
.index_reg
->reg_num
- 6;
1930 if ((i
.types
[op
] & Disp
) == 0)
1932 /* fake (%bp) into 0(%bp) */
1933 i
.types
[op
] |= Disp8
;
1934 fake_zero_displacement
= 1;
1937 else /* (%bp,%si) -> 2, or (%bp,%di) -> 3 */
1938 i
.rm
.regmem
= i
.index_reg
->reg_num
- 6 + 2;
1940 default: /* (%si) -> 4 or (%di) -> 5 */
1941 i
.rm
.regmem
= i
.base_reg
->reg_num
- 6 + 4;
1943 i
.rm
.mode
= mode_from_disp_size (i
.types
[op
]);
1945 else /* i.base_reg and 32 bit mode */
1947 i
.rm
.regmem
= i
.base_reg
->reg_num
;
1948 i
.sib
.base
= i
.base_reg
->reg_num
;
1949 if (i
.base_reg
->reg_num
== EBP_REG_NUM
)
1952 if (i
.disp_operands
== 0)
1954 fake_zero_displacement
= 1;
1955 i
.types
[op
] |= Disp8
;
1958 else if (i
.base_reg
->reg_num
== ESP_REG_NUM
)
1962 i
.sib
.scale
= i
.log2_scale_factor
;
1965 /* <disp>(%esp) becomes two byte modrm
1966 with no index register. We've already
1967 stored the code for esp in i.rm.regmem
1968 ie. ESCAPE_TO_TWO_BYTE_ADDRESSING. Any
1969 base register besides %esp will not use
1970 the extra modrm byte. */
1971 i
.sib
.index
= NO_INDEX_REGISTER
;
1972 #if ! SCALE1_WHEN_NO_INDEX
1973 /* Another case where we force the second
1975 if (i
.log2_scale_factor
)
1976 i
.rm
.regmem
= ESCAPE_TO_TWO_BYTE_ADDRESSING
;
1981 i
.sib
.index
= i
.index_reg
->reg_num
;
1982 i
.rm
.regmem
= ESCAPE_TO_TWO_BYTE_ADDRESSING
;
1984 i
.rm
.mode
= mode_from_disp_size (i
.types
[op
]);
1987 if (fake_zero_displacement
)
1989 /* Fakes a zero displacement assuming that i.types[op]
1990 holds the correct displacement size. */
1993 exp
= &disp_expressions
[i
.disp_operands
++];
1995 exp
->X_op
= O_constant
;
1996 exp
->X_add_number
= 0;
1997 exp
->X_add_symbol
= (symbolS
*) 0;
1998 exp
->X_op_symbol
= (symbolS
*) 0;
2002 /* Fill in i.rm.reg or i.rm.regmem field with register
2003 operand (if any) based on i.tm.extension_opcode.
2004 Again, we must be careful to make sure that
2005 segment/control/debug/test/MMX registers are coded
2006 into the i.rm.reg field. */
2011 & (Reg
| RegMMX
| RegXMM
2013 | Control
| Debug
| Test
))
2016 & (Reg
| RegMMX
| RegXMM
2018 | Control
| Debug
| Test
))
2021 /* If there is an extension opcode to put here, the
2022 register number must be put into the regmem field. */
2023 if (i
.tm
.extension_opcode
!= None
)
2024 i
.rm
.regmem
= i
.regs
[op
]->reg_num
;
2026 i
.rm
.reg
= i
.regs
[op
]->reg_num
;
2028 /* Now, if no memory operand has set i.rm.mode = 0, 1, 2
2029 we must set it to 3 to indicate this is a register
2030 operand in the regmem field. */
2031 if (!i
.mem_operands
)
2035 /* Fill in i.rm.reg field with extension opcode (if any). */
2036 if (i
.tm
.extension_opcode
!= None
)
2037 i
.rm
.reg
= i
.tm
.extension_opcode
;
2040 else if (i
.tm
.opcode_modifier
& (Seg2ShortForm
| Seg3ShortForm
))
2042 if (i
.tm
.base_opcode
== POP_SEG_SHORT
&& i
.regs
[0]->reg_num
== 1)
2044 as_bad (_("you can't `pop %%cs'"));
2047 i
.tm
.base_opcode
|= (i
.regs
[0]->reg_num
<< 3);
2049 else if ((i
.tm
.base_opcode
& ~(D
|W
)) == MOV_AX_DISP32
)
2053 else if ((i
.tm
.opcode_modifier
& IsString
) != 0)
2055 /* For the string instructions that allow a segment override
2056 on one of their operands, the default segment is ds. */
2060 /* If a segment was explicitly specified,
2061 and the specified segment is not the default,
2062 use an opcode prefix to select it.
2063 If we never figured out what the default segment is,
2064 then default_seg will be zero at this point,
2065 and the specified segment prefix will always be used. */
2066 if ((i
.seg
[0]) && (i
.seg
[0] != default_seg
))
2068 if (! add_prefix (i
.seg
[0]->seg_prefix
))
2072 else if ((i
.tm
.opcode_modifier
& Ugh
) != 0)
2074 /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc. */
2075 as_warn (_("translating to `%sp'"), i
.tm
.name
);
2079 /* Handle conversion of 'int $3' --> special int3 insn. */
2080 if (i
.tm
.base_opcode
== INT_OPCODE
&& i
.imms
[0]->X_add_number
== 3)
2082 i
.tm
.base_opcode
= INT3_OPCODE
;
2086 /* We are ready to output the insn. */
2091 if (i
.tm
.opcode_modifier
& Jump
)
2093 long n
= (long) i
.disps
[0]->X_add_number
;
2094 int prefix
= (i
.prefix
[DATA_PREFIX
] != 0);
2102 if (flag_16bit_code
)
2105 if (!intel_syntax
&& (i
.prefixes
!= 0))
2106 as_warn (_("skipping prefixes on this instruction"));
2108 if (i
.disps
[0]->X_op
== O_constant
)
2110 if (fits_in_signed_byte (n
))
2114 p
[0] = i
.tm
.base_opcode
;
2119 /* Use 16-bit jumps only for 16-bit code,
2120 because text segments are limited to 64K anyway;
2121 Use 32-bit jumps for 32-bit code, because they're faster,
2122 and a 16-bit jump will clear the top 16 bits of %eip. */
2123 int jmp_size
= code16
? 2 : 4;
2124 if (code16
&& !fits_in_signed_word (n
))
2126 as_bad (_("16-bit jump out of range"));
2130 if (i
.tm
.base_opcode
== JUMP_PC_RELATIVE
)
2132 /* unconditional jump */
2133 insn_size
+= prefix
+ 1 + jmp_size
;
2134 p
= frag_more (prefix
+ 1 + jmp_size
);
2136 *p
++ = DATA_PREFIX_OPCODE
;
2138 md_number_to_chars (p
, (valueT
) n
, jmp_size
);
2142 /* conditional jump */
2143 insn_size
+= prefix
+ 2 + jmp_size
;
2144 p
= frag_more (prefix
+ 2 + jmp_size
);
2146 *p
++ = DATA_PREFIX_OPCODE
;
2147 *p
++ = TWO_BYTE_OPCODE_ESCAPE
;
2148 *p
++ = i
.tm
.base_opcode
+ 0x10;
2149 md_number_to_chars (p
, (valueT
) n
, jmp_size
);
2155 int size
= code16
? 2 : 4;
2157 /* It's a symbol; end frag & setup for relax.
2158 Make sure there are more than 6 chars left in the current frag;
2159 if not we'll have to start a new one. */
2160 frag_grow (prefix
+ 1 + 2 + size
);
2161 insn_size
+= 1 + prefix
;
2162 p
= frag_more (1 + prefix
);
2164 *p
++ = DATA_PREFIX_OPCODE
;
2165 *p
= i
.tm
.base_opcode
;
2166 frag_var (rs_machine_dependent
,
2167 prefix
+ 2 + size
, /* 2 opcode/prefix + displacement */
2169 ((unsigned char) *p
== JUMP_PC_RELATIVE
2170 ? ENCODE_RELAX_STATE (UNCOND_JUMP
, SMALL
) | code16
2171 : ENCODE_RELAX_STATE (COND_JUMP
, SMALL
) | code16
),
2172 i
.disps
[0]->X_add_symbol
,
2176 else if (i
.tm
.opcode_modifier
& (JumpByte
| JumpDword
))
2178 int size
= (i
.tm
.opcode_modifier
& JumpByte
) ? 1 : 4;
2179 long n
= (long) i
.disps
[0]->X_add_number
;
2181 if (size
== 1) /* then this is a loop or jecxz type instruction */
2183 if (i
.prefix
[ADDR_PREFIX
])
2186 FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE
);
2194 if (i
.prefix
[DATA_PREFIX
])
2197 FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE
);
2201 if (flag_16bit_code
)
2208 if (!intel_syntax
&& (i
.prefixes
!= 0))
2209 as_warn (_("skipping prefixes on this instruction"));
2211 if (fits_in_unsigned_byte (i
.tm
.base_opcode
))
2213 insn_size
+= 1 + size
;
2214 p
= frag_more (1 + size
);
2218 insn_size
+= 2 + size
; /* opcode can be at most two bytes */
2219 p
= frag_more (2 + size
);
2220 *p
++ = (i
.tm
.base_opcode
>> 8) & 0xff;
2222 *p
++ = i
.tm
.base_opcode
& 0xff;
2224 if (i
.disps
[0]->X_op
== O_constant
)
2226 if (size
== 1 && !fits_in_signed_byte (n
))
2228 as_bad (_("`%s' only takes byte displacement; %ld shortened to %d"),
2231 else if (size
== 2 && !fits_in_signed_word (n
))
2233 as_bad (_("16-bit jump out of range"));
2236 md_number_to_chars (p
, (valueT
) n
, size
);
2240 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
2241 i
.disps
[0], 1, reloc (size
, 1, i
.disp_reloc
[0]));
2245 else if (i
.tm
.opcode_modifier
& JumpInterSegment
)
2249 int prefix
= i
.prefix
[DATA_PREFIX
] != 0;
2257 if (flag_16bit_code
)
2261 reloc_type
= BFD_RELOC_32
;
2265 reloc_type
= BFD_RELOC_16
;
2268 if (!intel_syntax
&& (i
.prefixes
!= 0))
2269 as_warn (_("skipping prefixes on this instruction"));
2271 insn_size
+= prefix
+ 1 + 2 + size
; /* 1 opcode; 2 segment; offset */
2272 p
= frag_more (prefix
+ 1 + 2 + size
);
2274 *p
++ = DATA_PREFIX_OPCODE
;
2275 *p
++ = i
.tm
.base_opcode
;
2276 if (i
.imms
[1]->X_op
== O_constant
)
2278 long n
= (long) i
.imms
[1]->X_add_number
;
2280 if (size
== 2 && !fits_in_unsigned_word (n
))
2282 as_bad (_("16-bit jump out of range"));
2285 md_number_to_chars (p
, (valueT
) n
, size
);
2288 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
2289 i
.imms
[1], 0, reloc_type
);
2290 if (i
.imms
[0]->X_op
!= O_constant
)
2291 as_bad (_("can't handle non absolute segment in `%s'"),
2293 md_number_to_chars (p
+ size
, (valueT
) i
.imms
[0]->X_add_number
, 2);
2297 /* Output normal instructions here. */
2300 /* The prefix bytes. */
2302 q
< i
.prefix
+ sizeof (i
.prefix
) / sizeof (i
.prefix
[0]);
2309 md_number_to_chars (p
, (valueT
) *q
, 1);
2313 /* Now the opcode; be careful about word order here! */
2314 if (fits_in_unsigned_byte (i
.tm
.base_opcode
))
2317 FRAG_APPEND_1_CHAR (i
.tm
.base_opcode
);
2319 else if (fits_in_unsigned_word (i
.tm
.base_opcode
))
2323 /* put out high byte first: can't use md_number_to_chars! */
2324 *p
++ = (i
.tm
.base_opcode
>> 8) & 0xff;
2325 *p
= i
.tm
.base_opcode
& 0xff;
2328 { /* opcode is either 3 or 4 bytes */
2329 if (i
.tm
.base_opcode
& 0xff000000)
2333 *p
++ = (i
.tm
.base_opcode
>> 24) & 0xff;
2340 *p
++ = (i
.tm
.base_opcode
>> 16) & 0xff;
2341 *p
++ = (i
.tm
.base_opcode
>> 8) & 0xff;
2342 *p
= (i
.tm
.base_opcode
) & 0xff;
2345 /* Now the modrm byte and sib byte (if present). */
2346 if (i
.tm
.opcode_modifier
& Modrm
)
2350 md_number_to_chars (p
,
2351 (valueT
) (i
.rm
.regmem
<< 0
2355 /* If i.rm.regmem == ESP (4)
2356 && i.rm.mode != (Register mode)
2358 ==> need second modrm byte. */
2359 if (i
.rm
.regmem
== ESCAPE_TO_TWO_BYTE_ADDRESSING
2361 && !(i
.base_reg
&& (i
.base_reg
->reg_type
& Reg16
) != 0))
2365 md_number_to_chars (p
,
2366 (valueT
) (i
.sib
.base
<< 0
2368 | i
.sib
.scale
<< 6),
2373 if (i
.disp_operands
)
2375 register unsigned int n
;
2377 for (n
= 0; n
< i
.operands
; n
++)
2381 if (i
.disps
[n
]->X_op
== O_constant
)
2384 long val
= (long) i
.disps
[n
]->X_add_number
;
2386 if (i
.types
[n
] & (Disp8
| Disp16
))
2391 mask
= ~ (long) 0xffff;
2392 if (i
.types
[n
] & Disp8
)
2395 mask
= ~ (long) 0xff;
2398 if ((val
& mask
) != 0 && (val
& mask
) != mask
)
2399 as_warn (_("%ld shortened to %ld"),
2403 p
= frag_more (size
);
2404 md_number_to_chars (p
, (valueT
) val
, size
);
2406 else if (i
.types
[n
] & Disp32
)
2410 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 4,
2412 TC_RELOC (i
.disp_reloc
[n
], BFD_RELOC_32
));
2415 { /* must be Disp16 */
2418 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, 2,
2420 TC_RELOC (i
.disp_reloc
[n
], BFD_RELOC_16
));
2424 } /* end displacement output */
2426 /* output immediate */
2429 register unsigned int n
;
2431 for (n
= 0; n
< i
.operands
; n
++)
2435 if (i
.imms
[n
]->X_op
== O_constant
)
2438 long val
= (long) i
.imms
[n
]->X_add_number
;
2440 if (i
.types
[n
] & (Imm8
| Imm8S
| Imm16
))
2445 mask
= ~ (long) 0xffff;
2446 if (i
.types
[n
] & (Imm8
| Imm8S
))
2449 mask
= ~ (long) 0xff;
2451 if ((val
& mask
) != 0 && (val
& mask
) != mask
)
2452 as_warn (_("%ld shortened to %ld"),
2456 p
= frag_more (size
);
2457 md_number_to_chars (p
, (valueT
) val
, size
);
2460 { /* not absolute_section */
2461 /* Need a 32-bit fixup (don't support 8bit
2462 non-absolute ims). Try to support other
2468 if (i
.types
[n
] & (Imm8
| Imm8S
))
2470 else if (i
.types
[n
] & Imm16
)
2475 p
= frag_more (size
);
2476 r_type
= reloc (size
, 0, i
.disp_reloc
[0]);
2477 #ifdef BFD_ASSEMBLER
2478 if (r_type
== BFD_RELOC_32
2480 && GOT_symbol
== i
.imms
[n
]->X_add_symbol
2481 && (i
.imms
[n
]->X_op
== O_symbol
2482 || (i
.imms
[n
]->X_op
== O_add
2483 && ((symbol_get_value_expression
2484 (i
.imms
[n
]->X_op_symbol
)->X_op
)
2487 r_type
= BFD_RELOC_386_GOTPC
;
2488 i
.imms
[n
]->X_add_number
+= 3;
2491 fix_new_exp (frag_now
, p
- frag_now
->fr_literal
, size
,
2492 i
.imms
[n
], pcrel
, r_type
);
2496 } /* end immediate output */
2504 #endif /* DEBUG386 */
2508 static int i386_immediate
PARAMS ((char *));
2511 i386_immediate (imm_start
)
2514 char *save_input_line_pointer
;
2518 if (i
.imm_operands
== MAX_IMMEDIATE_OPERANDS
)
2520 as_bad (_("Only 1 or 2 immediate operands are allowed"));
2524 exp
= &im_expressions
[i
.imm_operands
++];
2525 i
.imms
[this_operand
] = exp
;
2527 if (is_space_char (*imm_start
))
2530 save_input_line_pointer
= input_line_pointer
;
2531 input_line_pointer
= imm_start
;
2536 * We can have operands of the form
2537 * <symbol>@GOTOFF+<nnn>
2538 * Take the easy way out here and copy everything
2539 * into a temporary buffer...
2543 cp
= strchr (input_line_pointer
, '@');
2550 /* GOT relocations are not supported in 16 bit mode */
2551 if (flag_16bit_code
)
2552 as_bad (_("GOT relocations not supported in 16 bit mode"));
2554 if (GOT_symbol
== NULL
)
2555 GOT_symbol
= symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME
);
2557 if (strncmp (cp
+ 1, "PLT", 3) == 0)
2559 i
.disp_reloc
[this_operand
] = BFD_RELOC_386_PLT32
;
2562 else if (strncmp (cp
+ 1, "GOTOFF", 6) == 0)
2564 i
.disp_reloc
[this_operand
] = BFD_RELOC_386_GOTOFF
;
2567 else if (strncmp (cp
+ 1, "GOT", 3) == 0)
2569 i
.disp_reloc
[this_operand
] = BFD_RELOC_386_GOT32
;
2573 as_bad (_("Bad reloc specifier in expression"));
2575 /* Replace the relocation token with ' ', so that errors like
2576 foo@GOTOFF1 will be detected. */
2577 first
= cp
- input_line_pointer
;
2578 tmpbuf
= (char *) alloca (strlen(input_line_pointer
));
2579 memcpy (tmpbuf
, input_line_pointer
, first
);
2580 tmpbuf
[first
] = ' ';
2581 strcpy (tmpbuf
+ first
+ 1, cp
+ 1 + len
);
2582 input_line_pointer
= tmpbuf
;
2587 exp_seg
= expression (exp
);
2590 if (*input_line_pointer
)
2591 as_bad (_("Ignoring junk `%s' after expression"), input_line_pointer
);
2593 input_line_pointer
= save_input_line_pointer
;
2595 if (exp
->X_op
== O_absent
)
2597 /* missing or bad expr becomes absolute 0 */
2598 as_bad (_("Missing or invalid immediate expression `%s' taken as 0"),
2600 exp
->X_op
= O_constant
;
2601 exp
->X_add_number
= 0;
2602 exp
->X_add_symbol
= (symbolS
*) 0;
2603 exp
->X_op_symbol
= (symbolS
*) 0;
2604 i
.types
[this_operand
] |= Imm
;
2606 else if (exp
->X_op
== O_constant
)
2609 if (flag_16bit_code
^ (i
.prefix
[DATA_PREFIX
] != 0))
2612 i
.types
[this_operand
] |=
2613 (bigimm
| smallest_imm_type ((long) exp
->X_add_number
));
2615 /* If a suffix is given, this operand may be shortended. */
2618 case WORD_MNEM_SUFFIX
:
2619 i
.types
[this_operand
] |= Imm16
;
2621 case BYTE_MNEM_SUFFIX
:
2622 i
.types
[this_operand
] |= Imm16
| Imm8
| Imm8S
;
2627 else if (exp_seg
!= text_section
2628 && exp_seg
!= data_section
2629 && exp_seg
!= bss_section
2630 && exp_seg
!= undefined_section
2631 #ifdef BFD_ASSEMBLER
2632 && !bfd_is_com_section (exp_seg
)
2636 as_bad (_("Unimplemented segment type %d in operand"), exp_seg
);
2642 /* This is an address. The size of the address will be
2643 determined later, depending on destination register,
2644 suffix, or the default for the section. We exclude
2645 Imm8S here so that `push $foo' and other instructions
2646 with an Imm8S form will use Imm16 or Imm32. */
2647 i
.types
[this_operand
] |= (Imm8
| Imm16
| Imm32
);
2653 static int i386_scale
PARAMS ((char *));
2659 if (!isdigit (*scale
))
2666 i
.log2_scale_factor
= 0;
2669 i
.log2_scale_factor
= 1;
2672 i
.log2_scale_factor
= 2;
2675 i
.log2_scale_factor
= 3;
2679 as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
2683 if (i
.log2_scale_factor
!= 0 && ! i
.index_reg
)
2685 as_warn (_("scale factor of %d without an index register"),
2686 1 << i
.log2_scale_factor
);
2687 #if SCALE1_WHEN_NO_INDEX
2688 i
.log2_scale_factor
= 0;
2694 static int i386_displacement
PARAMS ((char *, char *));
2697 i386_displacement (disp_start
, disp_end
)
2701 register expressionS
*exp
;
2703 char *save_input_line_pointer
;
2704 int bigdisp
= Disp32
;
2706 if (flag_16bit_code
^ (i
.prefix
[ADDR_PREFIX
] != 0))
2708 i
.types
[this_operand
] |= bigdisp
;
2710 exp
= &disp_expressions
[i
.disp_operands
];
2711 i
.disps
[this_operand
] = exp
;
2712 i
.disp_reloc
[this_operand
] = NO_RELOC
;
2714 save_input_line_pointer
= input_line_pointer
;
2715 input_line_pointer
= disp_start
;
2716 END_STRING_AND_SAVE (disp_end
);
2718 #ifndef GCC_ASM_O_HACK
2719 #define GCC_ASM_O_HACK 0
2722 END_STRING_AND_SAVE (disp_end
+ 1);
2723 if ((i
.types
[this_operand
] & BaseIndex
) != 0
2724 && displacement_string_end
[-1] == '+')
2726 /* This hack is to avoid a warning when using the "o"
2727 constraint within gcc asm statements.
2730 #define _set_tssldt_desc(n,addr,limit,type) \
2731 __asm__ __volatile__ ( \
2733 "movw %w1,2+%0\n\t" \
2735 "movb %b1,4+%0\n\t" \
2736 "movb %4,5+%0\n\t" \
2737 "movb $0,6+%0\n\t" \
2738 "movb %h1,7+%0\n\t" \
2740 : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
2742 This works great except that the output assembler ends
2743 up looking a bit weird if it turns out that there is
2744 no offset. You end up producing code that looks like:
2757 So here we provide the missing zero.
2760 *displacement_string_end
= '0';
2766 * We can have operands of the form
2767 * <symbol>@GOTOFF+<nnn>
2768 * Take the easy way out here and copy everything
2769 * into a temporary buffer...
2773 cp
= strchr (input_line_pointer
, '@');
2780 /* GOT relocations are not supported in 16 bit mode */
2781 if (flag_16bit_code
)
2782 as_bad (_("GOT relocations not supported in 16 bit mode"));
2784 if (GOT_symbol
== NULL
)
2785 GOT_symbol
= symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME
);
2787 if (strncmp (cp
+ 1, "PLT", 3) == 0)
2789 i
.disp_reloc
[this_operand
] = BFD_RELOC_386_PLT32
;
2792 else if (strncmp (cp
+ 1, "GOTOFF", 6) == 0)
2794 i
.disp_reloc
[this_operand
] = BFD_RELOC_386_GOTOFF
;
2797 else if (strncmp (cp
+ 1, "GOT", 3) == 0)
2799 i
.disp_reloc
[this_operand
] = BFD_RELOC_386_GOT32
;
2803 as_bad (_("Bad reloc specifier in expression"));
2805 /* Replace the relocation token with ' ', so that errors like
2806 foo@GOTOFF1 will be detected. */
2807 first
= cp
- input_line_pointer
;
2808 tmpbuf
= (char *) alloca (strlen(input_line_pointer
));
2809 memcpy (tmpbuf
, input_line_pointer
, first
);
2810 tmpbuf
[first
] = ' ';
2811 strcpy (tmpbuf
+ first
+ 1, cp
+ 1 + len
);
2812 input_line_pointer
= tmpbuf
;
2817 exp_seg
= expression (exp
);
2819 #ifdef BFD_ASSEMBLER
2820 /* We do this to make sure that the section symbol is in
2821 the symbol table. We will ultimately change the relocation
2822 to be relative to the beginning of the section */
2823 if (i
.disp_reloc
[this_operand
] == BFD_RELOC_386_GOTOFF
)
2825 if (S_IS_LOCAL(exp
->X_add_symbol
)
2826 && S_GET_SEGMENT (exp
->X_add_symbol
) != undefined_section
)
2827 section_symbol (S_GET_SEGMENT (exp
->X_add_symbol
));
2828 assert (exp
->X_op
== O_symbol
);
2829 exp
->X_op
= O_subtract
;
2830 exp
->X_op_symbol
= GOT_symbol
;
2831 i
.disp_reloc
[this_operand
] = BFD_RELOC_32
;
2836 if (*input_line_pointer
)
2837 as_bad (_("Ignoring junk `%s' after expression"),
2838 input_line_pointer
);
2840 RESTORE_END_STRING (disp_end
+ 1);
2842 RESTORE_END_STRING (disp_end
);
2843 input_line_pointer
= save_input_line_pointer
;
2845 if (exp
->X_op
== O_constant
)
2847 if (fits_in_signed_byte (exp
->X_add_number
))
2848 i
.types
[this_operand
] |= Disp8
;
2851 else if (exp_seg
!= text_section
2852 && exp_seg
!= data_section
2853 && exp_seg
!= bss_section
2854 && exp_seg
!= undefined_section
)
2856 as_bad (_ ("Unimplemented segment type %d in operand"), exp_seg
);
2863 static int i386_operand_modifier
PARAMS ((char **, int));
2866 i386_operand_modifier (op_string
, got_a_float
)
2870 if (!strncasecmp (*op_string
, "BYTE PTR", 8))
2872 i
.suffix
= BYTE_MNEM_SUFFIX
;
2877 else if (!strncasecmp (*op_string
, "WORD PTR", 8))
2879 i
.suffix
= WORD_MNEM_SUFFIX
;
2884 else if (!strncasecmp (*op_string
, "DWORD PTR", 9))
2887 i
.suffix
= SHORT_MNEM_SUFFIX
;
2889 i
.suffix
= DWORD_MNEM_SUFFIX
;
2894 else if (!strncasecmp (*op_string
, "QWORD PTR", 9))
2896 i
.suffix
= INTEL_DWORD_MNEM_SUFFIX
;
2901 else if (!strncasecmp (*op_string
, "XWORD PTR", 9))
2903 i
.suffix
= LONG_DOUBLE_MNEM_SUFFIX
;
2908 else if (!strncasecmp (*op_string
, "SHORT", 5))
2914 else if (!strncasecmp (*op_string
, "OFFSET FLAT:", 12))
2920 else if (!strncasecmp (*op_string
, "FLAT", 4))
2926 else return NONE_FOUND
;
2929 static char * build_displacement_string
PARAMS ((int, char *));
2932 build_displacement_string (initial_disp
, op_string
)
2936 char *temp_string
= (char *) malloc (strlen (op_string
) + 1);
2937 char *end_of_operand_string
;
2941 temp_string
[0] = '\0';
2942 tc
= end_of_operand_string
= strchr (op_string
, '[');
2943 if ( initial_disp
&& !end_of_operand_string
)
2945 strcpy (temp_string
, op_string
);
2946 return (temp_string
);
2949 /* Build the whole displacement string */
2952 strncpy (temp_string
, op_string
, end_of_operand_string
- op_string
);
2953 temp_string
[end_of_operand_string
- op_string
] = '\0';
2957 temp_disp
= op_string
;
2959 while (*temp_disp
!= '\0')
2962 int add_minus
= (*temp_disp
== '-');
2964 if (*temp_disp
== '+' || *temp_disp
== '-' || *temp_disp
== '[')
2967 if (is_space_char (*temp_disp
))
2970 /* Don't consider registers */
2971 if ( !((*temp_disp
== REGISTER_PREFIX
|| allow_naked_reg
)
2972 && parse_register (temp_disp
, &end_op
)) )
2974 char *string_start
= temp_disp
;
2976 while (*temp_disp
!= ']'
2977 && *temp_disp
!= '+'
2978 && *temp_disp
!= '-'
2979 && *temp_disp
!= '*')
2983 strcat (temp_string
, "-");
2985 strcat (temp_string
, "+");
2987 strncat (temp_string
, string_start
, temp_disp
- string_start
);
2988 if (*temp_disp
== '+' || *temp_disp
== '-')
2992 while (*temp_disp
!= '\0'
2993 && *temp_disp
!= '+'
2994 && *temp_disp
!= '-')
3001 static int i386_parse_seg
PARAMS ((char *));
3004 i386_parse_seg (op_string
)
3007 if (is_space_char (*op_string
))
3010 /* Should be one of es, cs, ss, ds fs or gs */
3011 switch (*op_string
++)
3014 i
.seg
[i
.mem_operands
] = &es
;
3017 i
.seg
[i
.mem_operands
] = &cs
;
3020 i
.seg
[i
.mem_operands
] = &ss
;
3023 i
.seg
[i
.mem_operands
] = &ds
;
3026 i
.seg
[i
.mem_operands
] = &fs
;
3029 i
.seg
[i
.mem_operands
] = &gs
;
3032 as_bad (_("bad segment name `%s'"), op_string
);
3036 if (*op_string
++ != 's')
3038 as_bad (_("bad segment name `%s'"), op_string
);
3042 if (is_space_char (*op_string
))
3045 if (*op_string
!= ':')
3047 as_bad (_("bad segment name `%s'"), op_string
);
3055 static int i386_index_check
PARAMS((const char *));
3057 /* Make sure the memory operand we've been dealt is valid.
3058 Returns 1 on success, 0 on a failure.
3061 i386_index_check (operand_string
)
3062 const char *operand_string
;
3064 #if INFER_ADDR_PREFIX
3069 if (flag_16bit_code
^ (i
.prefix
[ADDR_PREFIX
] != 0) ?
3070 /* 16 bit mode checks */
3072 && ((i
.base_reg
->reg_type
& (Reg16
|BaseIndex
))
3073 != (Reg16
|BaseIndex
)))
3075 && (((i
.index_reg
->reg_type
& (Reg16
|BaseIndex
))
3076 != (Reg16
|BaseIndex
))
3078 && i
.base_reg
->reg_num
< 6
3079 && i
.index_reg
->reg_num
>= 6
3080 && i
.log2_scale_factor
== 0)))) :
3081 /* 32 bit mode checks */
3083 && (i
.base_reg
->reg_type
& Reg32
) == 0)
3085 && ((i
.index_reg
->reg_type
& (Reg32
|BaseIndex
))
3086 != (Reg32
|BaseIndex
)))))
3088 #if INFER_ADDR_PREFIX
3089 if (i
.prefix
[ADDR_PREFIX
] == 0 && stackop_size
!= '\0')
3091 i
.prefix
[ADDR_PREFIX
] = ADDR_PREFIX_OPCODE
;
3093 /* Change the size of any displacement too. At most one of
3094 Disp16 or Disp32 is set.
3095 FIXME. There doesn't seem to be any real need for separate
3096 Disp16 and Disp32 flags. The same goes for Imm16 and Imm32.
3097 Removing them would probably clean up the code quite a lot.
3099 if (i
.types
[this_operand
] & (Disp16
|Disp32
))
3100 i
.types
[this_operand
] ^= (Disp16
|Disp32
);
3106 as_bad (_("`%s' is not a valid base/index expression"),
3109 as_bad (_("`%s' is not a valid %s bit base/index expression"),
3111 flag_16bit_code
^ (i
.prefix
[ADDR_PREFIX
] != 0) ? "16" : "32");
3117 static int i386_intel_memory_operand
PARAMS ((char *));
3120 i386_intel_memory_operand (operand_string
)
3121 char *operand_string
;
3123 char *op_string
= operand_string
;
3124 char *end_of_operand_string
;
3126 if ((i
.mem_operands
== 1
3127 && (current_templates
->start
->opcode_modifier
& IsString
) == 0)
3128 || i
.mem_operands
== 2)
3130 as_bad (_("too many memory references for `%s'"),
3131 current_templates
->start
->name
);
3135 /* Look for displacement preceding open bracket */
3136 if (*op_string
!= '[')
3141 end_seg
= strchr (op_string
, ':');
3144 if (!i386_parse_seg (op_string
))
3146 op_string
= end_seg
+ 1;
3149 temp_string
= build_displacement_string (true, op_string
);
3151 if (i
.disp_operands
== 0 &&
3152 !i386_displacement (temp_string
, temp_string
+ strlen (temp_string
)))
3155 end_of_operand_string
= strchr (op_string
, '[');
3156 if (!end_of_operand_string
)
3157 end_of_operand_string
= op_string
+ strlen (op_string
);
3159 if (is_space_char (*end_of_operand_string
))
3160 --end_of_operand_string
;
3162 op_string
= end_of_operand_string
;
3165 if (*op_string
== '[')
3169 /* Pick off each component and figure out where it belongs */
3171 end_of_operand_string
= op_string
;
3173 while (*op_string
!= ']')
3175 const reg_entry
*temp_reg
;
3179 while (*end_of_operand_string
!= '+'
3180 && *end_of_operand_string
!= '-'
3181 && *end_of_operand_string
!= '*'
3182 && *end_of_operand_string
!= ']')
3183 end_of_operand_string
++;
3185 temp_string
= op_string
;
3186 if (*temp_string
== '+')
3189 if (is_space_char (*temp_string
))
3193 if ((*temp_string
== REGISTER_PREFIX
|| allow_naked_reg
)
3194 && (temp_reg
= parse_register (temp_string
, &end_op
)) != NULL
)
3196 if (i
.base_reg
== NULL
)
3197 i
.base_reg
= temp_reg
;
3199 i
.index_reg
= temp_reg
;
3201 i
.types
[this_operand
] |= BaseIndex
;
3203 else if (*temp_string
== REGISTER_PREFIX
)
3205 as_bad (_("bad register name `%s'"), temp_string
);
3208 else if (is_digit_char (*op_string
)
3209 || *op_string
== '+' || *op_string
== '-')
3211 temp_string
= build_displacement_string (false, op_string
);
3213 if (*temp_string
== '+')
3216 if (i
.disp_operands
== 0 &&
3217 !i386_displacement (temp_string
, temp_string
+ strlen (temp_string
)))
3221 end_of_operand_string
= op_string
;
3222 while (*end_of_operand_string
!= ']'
3223 && *end_of_operand_string
!= '+'
3224 && *end_of_operand_string
!= '-'
3225 && *end_of_operand_string
!= '*')
3226 ++end_of_operand_string
;
3228 else if (*op_string
== '*')
3232 if (i
.base_reg
&& !i
.index_reg
)
3234 i
.index_reg
= i
.base_reg
;
3238 if (!i386_scale (op_string
))
3241 op_string
= end_of_operand_string
;
3242 ++end_of_operand_string
;
3246 if (i386_index_check (operand_string
) == 0)
3254 i386_intel_operand (operand_string
, got_a_float
)
3255 char *operand_string
;
3258 const reg_entry
* r
;
3260 char *op_string
= operand_string
;
3262 int operand_modifier
= i386_operand_modifier (&op_string
, got_a_float
);
3263 if (is_space_char (*op_string
))
3266 switch (operand_modifier
)
3273 if (!i386_intel_memory_operand (op_string
))
3279 if (!i386_immediate (op_string
))
3285 /* Should be register or immediate */
3286 if (is_digit_char (*op_string
)
3287 && strchr (op_string
, '[') == 0)
3289 if (!i386_immediate (op_string
))
3292 else if ((*op_string
== REGISTER_PREFIX
|| allow_naked_reg
)
3293 && (r
= parse_register (op_string
, &end_op
)) != NULL
)
3295 /* Check for a segment override by searching for ':' after a
3296 segment register. */
3298 if (is_space_char (*op_string
))
3300 if (*op_string
== ':' && (r
->reg_type
& (SReg2
| SReg3
)))
3305 i
.seg
[i
.mem_operands
] = &es
;
3308 i
.seg
[i
.mem_operands
] = &cs
;
3311 i
.seg
[i
.mem_operands
] = &ss
;
3314 i
.seg
[i
.mem_operands
] = &ds
;
3317 i
.seg
[i
.mem_operands
] = &fs
;
3320 i
.seg
[i
.mem_operands
] = &gs
;
3325 i
.types
[this_operand
] |= r
->reg_type
& ~BaseIndex
;
3326 i
.regs
[this_operand
] = r
;
3329 else if (*op_string
== REGISTER_PREFIX
)
3331 as_bad (_("bad register name `%s'"), op_string
);
3334 else if (!i386_intel_memory_operand (op_string
))
3343 /* Parse OPERAND_STRING into the i386_insn structure I. Returns non-zero
3347 i386_operand (operand_string
)
3348 char *operand_string
;
3352 char *op_string
= operand_string
;
3354 if (is_space_char (*op_string
))
3357 /* We check for an absolute prefix (differentiating,
3358 for example, 'jmp pc_relative_label' from 'jmp *absolute_label'. */
3359 if (*op_string
== ABSOLUTE_PREFIX
)
3362 if (is_space_char (*op_string
))
3364 i
.types
[this_operand
] |= JumpAbsolute
;
3367 /* Check if operand is a register. */
3368 if ((*op_string
== REGISTER_PREFIX
|| allow_naked_reg
)
3369 && (r
= parse_register (op_string
, &end_op
)) != NULL
)
3371 /* Check for a segment override by searching for ':' after a
3372 segment register. */
3374 if (is_space_char (*op_string
))
3376 if (*op_string
== ':' && (r
->reg_type
& (SReg2
| SReg3
)))
3381 i
.seg
[i
.mem_operands
] = &es
;
3384 i
.seg
[i
.mem_operands
] = &cs
;
3387 i
.seg
[i
.mem_operands
] = &ss
;
3390 i
.seg
[i
.mem_operands
] = &ds
;
3393 i
.seg
[i
.mem_operands
] = &fs
;
3396 i
.seg
[i
.mem_operands
] = &gs
;
3400 /* Skip the ':' and whitespace. */
3402 if (is_space_char (*op_string
))
3405 if (!is_digit_char (*op_string
)
3406 && !is_identifier_char (*op_string
)
3407 && *op_string
!= '('
3408 && *op_string
!= ABSOLUTE_PREFIX
)
3410 as_bad (_("bad memory operand `%s'"), op_string
);
3413 /* Handle case of %es:*foo. */
3414 if (*op_string
== ABSOLUTE_PREFIX
)
3417 if (is_space_char (*op_string
))
3419 i
.types
[this_operand
] |= JumpAbsolute
;
3421 goto do_memory_reference
;
3425 as_bad (_("Junk `%s' after register"), op_string
);
3428 i
.types
[this_operand
] |= r
->reg_type
& ~BaseIndex
;
3429 i
.regs
[this_operand
] = r
;
3432 else if (*op_string
== REGISTER_PREFIX
)
3434 as_bad (_("bad register name `%s'"), op_string
);
3437 else if (*op_string
== IMMEDIATE_PREFIX
)
3438 { /* ... or an immediate */
3440 if (i
.types
[this_operand
] & JumpAbsolute
)
3442 as_bad (_("Immediate operand illegal with absolute jump"));
3445 if (!i386_immediate (op_string
))
3448 else if (is_digit_char (*op_string
)
3449 || is_identifier_char (*op_string
)
3450 || *op_string
== '(' )
3452 /* This is a memory reference of some sort. */
3455 /* Start and end of displacement string expression (if found). */
3456 char *displacement_string_start
;
3457 char *displacement_string_end
;
3459 do_memory_reference
:
3460 if ((i
.mem_operands
== 1
3461 && (current_templates
->start
->opcode_modifier
& IsString
) == 0)
3462 || i
.mem_operands
== 2)
3464 as_bad (_("too many memory references for `%s'"),
3465 current_templates
->start
->name
);
3469 /* Check for base index form. We detect the base index form by
3470 looking for an ')' at the end of the operand, searching
3471 for the '(' matching it, and finding a REGISTER_PREFIX or ','
3473 base_string
= op_string
+ strlen (op_string
);
3476 if (is_space_char (*base_string
))
3479 /* If we only have a displacement, set-up for it to be parsed later. */
3480 displacement_string_start
= op_string
;
3481 displacement_string_end
= base_string
+ 1;
3483 if (*base_string
== ')')
3486 unsigned int parens_balanced
= 1;
3487 /* We've already checked that the number of left & right ()'s are
3488 equal, so this loop will not be infinite. */
3492 if (*base_string
== ')')
3494 if (*base_string
== '(')
3497 while (parens_balanced
);
3499 temp_string
= base_string
;
3501 /* Skip past '(' and whitespace. */
3503 if (is_space_char (*base_string
))
3506 if (*base_string
== ','
3507 || ((*base_string
== REGISTER_PREFIX
|| allow_naked_reg
)
3508 && (i
.base_reg
= parse_register (base_string
, &end_op
)) != NULL
))
3510 displacement_string_end
= temp_string
;
3512 i
.types
[this_operand
] |= BaseIndex
;
3516 base_string
= end_op
;
3517 if (is_space_char (*base_string
))
3521 /* There may be an index reg or scale factor here. */
3522 if (*base_string
== ',')
3525 if (is_space_char (*base_string
))
3528 if ((*base_string
== REGISTER_PREFIX
|| allow_naked_reg
)
3529 && (i
.index_reg
= parse_register (base_string
, &end_op
)) != NULL
)
3531 base_string
= end_op
;
3532 if (is_space_char (*base_string
))
3534 if (*base_string
== ',')
3537 if (is_space_char (*base_string
))
3540 else if (*base_string
!= ')' )
3542 as_bad (_("expecting `,' or `)' after index register in `%s'"),
3547 else if (*base_string
== REGISTER_PREFIX
)
3549 as_bad (_("bad register name `%s'"), base_string
);
3553 /* Check for scale factor. */
3554 if (isdigit ((unsigned char) *base_string
))
3556 if (!i386_scale (base_string
))
3560 if (is_space_char (*base_string
))
3562 if (*base_string
!= ')')
3564 as_bad (_("expecting `)' after scale factor in `%s'"),
3569 else if (!i
.index_reg
)
3571 as_bad (_("expecting index register or scale factor after `,'; got '%c'"),
3576 else if (*base_string
!= ')')
3578 as_bad (_("expecting `,' or `)' after base register in `%s'"),
3583 else if (*base_string
== REGISTER_PREFIX
)
3585 as_bad (_("bad register name `%s'"), base_string
);
3590 /* If there's an expression beginning the operand, parse it,
3591 assuming displacement_string_start and
3592 displacement_string_end are meaningful. */
3593 if (displacement_string_start
!= displacement_string_end
)
3595 if (!i386_displacement (displacement_string_start
,
3596 displacement_string_end
))
3600 /* Special case for (%dx) while doing input/output op. */
3602 && i
.base_reg
->reg_type
== (Reg16
| InOutPortReg
)
3604 && i
.log2_scale_factor
== 0
3605 && i
.seg
[i
.mem_operands
] == 0
3606 && (i
.types
[this_operand
] & Disp
) == 0)
3608 i
.types
[this_operand
] = InOutPortReg
;
3612 if (i386_index_check (operand_string
) == 0)
3617 { /* it's not a memory operand; argh! */
3618 as_bad (_("invalid char %s beginning operand %d `%s'"),
3619 output_invalid (*op_string
),
3624 return 1; /* normal return */
3628 * md_estimate_size_before_relax()
3630 * Called just before relax().
3631 * Any symbol that is now undefined will not become defined.
3632 * Return the correct fr_subtype in the frag.
3633 * Return the initial "guess for fr_var" to caller.
3634 * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
3635 * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
3636 * Although it may not be explicit in the frag, pretend fr_var starts with a
3640 md_estimate_size_before_relax (fragP
, segment
)
3641 register fragS
*fragP
;
3642 register segT segment
;
3644 register unsigned char *opcode
;
3645 register int old_fr_fix
;
3647 old_fr_fix
= fragP
->fr_fix
;
3648 opcode
= (unsigned char *) fragP
->fr_opcode
;
3649 /* We've already got fragP->fr_subtype right; all we have to do is
3650 check for un-relaxable symbols. */
3651 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
)
3653 /* symbol is undefined in this segment */
3654 int code16
= fragP
->fr_subtype
& CODE16
;
3655 int size
= code16
? 2 : 4;
3656 int pcrel_reloc
= code16
? BFD_RELOC_16_PCREL
: BFD_RELOC_32_PCREL
;
3660 case JUMP_PC_RELATIVE
: /* make jmp (0xeb) a dword displacement jump */
3661 opcode
[0] = 0xe9; /* dword disp jmp */
3662 fragP
->fr_fix
+= size
;
3663 fix_new (fragP
, old_fr_fix
, size
,
3665 fragP
->fr_offset
, 1,
3666 (GOT_symbol
&& /* Not quite right - we should switch on
3667 presence of @PLT, but I cannot see how
3668 to get to that from here. We should have
3669 done this in md_assemble to really
3670 get it right all of the time, but I
3671 think it does not matter that much, as
3672 this will be right most of the time. ERY*/
3673 S_GET_SEGMENT(fragP
->fr_symbol
) == undefined_section
)
3674 ? BFD_RELOC_386_PLT32
: pcrel_reloc
);
3678 /* This changes the byte-displacement jump 0x7N
3679 to the dword-displacement jump 0x0f8N. */
3680 opcode
[1] = opcode
[0] + 0x10;
3681 opcode
[0] = TWO_BYTE_OPCODE_ESCAPE
; /* two-byte escape */
3682 fragP
->fr_fix
+= 1 + size
; /* we've added an opcode byte */
3683 fix_new (fragP
, old_fr_fix
+ 1, size
,
3685 fragP
->fr_offset
, 1,
3686 (GOT_symbol
&& /* Not quite right - we should switch on
3687 presence of @PLT, but I cannot see how
3688 to get to that from here. ERY */
3689 S_GET_SEGMENT(fragP
->fr_symbol
) == undefined_section
)
3690 ? BFD_RELOC_386_PLT32
: pcrel_reloc
);
3695 return (fragP
->fr_var
+ fragP
->fr_fix
- old_fr_fix
);
3696 } /* md_estimate_size_before_relax() */
3699 * md_convert_frag();
3701 * Called after relax() is finished.
3702 * In: Address of frag.
3703 * fr_type == rs_machine_dependent.
3704 * fr_subtype is what the address relaxed to.
3706 * Out: Any fixSs and constants are set up.
3707 * Caller will turn frag into a ".space 0".
3709 #ifndef BFD_ASSEMBLER
3711 md_convert_frag (headers
, sec
, fragP
)
3712 object_headers
*headers ATTRIBUTE_UNUSED
;
3713 segT sec ATTRIBUTE_UNUSED
;
3714 register fragS
*fragP
;
3717 md_convert_frag (abfd
, sec
, fragP
)
3718 bfd
*abfd ATTRIBUTE_UNUSED
;
3719 segT sec ATTRIBUTE_UNUSED
;
3720 register fragS
*fragP
;
3723 register unsigned char *opcode
;
3724 unsigned char *where_to_put_displacement
= NULL
;
3725 unsigned int target_address
;
3726 unsigned int opcode_address
;
3727 unsigned int extension
= 0;
3728 int displacement_from_opcode_start
;
3730 opcode
= (unsigned char *) fragP
->fr_opcode
;
3732 /* Address we want to reach in file space. */
3733 target_address
= S_GET_VALUE (fragP
->fr_symbol
) + fragP
->fr_offset
;
3734 #ifdef BFD_ASSEMBLER /* not needed otherwise? */
3735 target_address
+= symbol_get_frag (fragP
->fr_symbol
)->fr_address
;
3738 /* Address opcode resides at in file space. */
3739 opcode_address
= fragP
->fr_address
+ fragP
->fr_fix
;
3741 /* Displacement from opcode start to fill into instruction. */
3742 displacement_from_opcode_start
= target_address
- opcode_address
;
3744 switch (fragP
->fr_subtype
)
3746 case ENCODE_RELAX_STATE (COND_JUMP
, SMALL
):
3747 case ENCODE_RELAX_STATE (COND_JUMP
, SMALL16
):
3748 case ENCODE_RELAX_STATE (UNCOND_JUMP
, SMALL
):
3749 case ENCODE_RELAX_STATE (UNCOND_JUMP
, SMALL16
):
3750 /* don't have to change opcode */
3751 extension
= 1; /* 1 opcode + 1 displacement */
3752 where_to_put_displacement
= &opcode
[1];
3755 case ENCODE_RELAX_STATE (COND_JUMP
, BIG
):
3756 extension
= 5; /* 2 opcode + 4 displacement */
3757 opcode
[1] = opcode
[0] + 0x10;
3758 opcode
[0] = TWO_BYTE_OPCODE_ESCAPE
;
3759 where_to_put_displacement
= &opcode
[2];
3762 case ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG
):
3763 extension
= 4; /* 1 opcode + 4 displacement */
3765 where_to_put_displacement
= &opcode
[1];
3768 case ENCODE_RELAX_STATE (COND_JUMP
, BIG16
):
3769 extension
= 3; /* 2 opcode + 2 displacement */
3770 opcode
[1] = opcode
[0] + 0x10;
3771 opcode
[0] = TWO_BYTE_OPCODE_ESCAPE
;
3772 where_to_put_displacement
= &opcode
[2];
3775 case ENCODE_RELAX_STATE (UNCOND_JUMP
, BIG16
):
3776 extension
= 2; /* 1 opcode + 2 displacement */
3778 where_to_put_displacement
= &opcode
[1];
3782 BAD_CASE (fragP
->fr_subtype
);
3785 /* now put displacement after opcode */
3786 md_number_to_chars ((char *) where_to_put_displacement
,
3787 (valueT
) (displacement_from_opcode_start
- extension
),
3788 SIZE_FROM_RELAX_STATE (fragP
->fr_subtype
));
3789 fragP
->fr_fix
+= extension
;
3793 int md_short_jump_size
= 2; /* size of byte displacement jmp */
3794 int md_long_jump_size
= 5; /* size of dword displacement jmp */
3795 const int md_reloc_size
= 8; /* Size of relocation record */
3798 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3800 addressT from_addr
, to_addr
;
3801 fragS
*frag ATTRIBUTE_UNUSED
;
3802 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
3806 offset
= to_addr
- (from_addr
+ 2);
3807 md_number_to_chars (ptr
, (valueT
) 0xeb, 1); /* opcode for byte-disp jump */
3808 md_number_to_chars (ptr
+ 1, (valueT
) offset
, 1);
3812 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3814 addressT from_addr
, to_addr
;
3820 if (flag_do_long_jump
)
3822 offset
= to_addr
- S_GET_VALUE (to_symbol
);
3823 md_number_to_chars (ptr
, (valueT
) 0xe9, 1);/* opcode for long jmp */
3824 md_number_to_chars (ptr
+ 1, (valueT
) offset
, 4);
3825 fix_new (frag
, (ptr
+ 1) - frag
->fr_literal
, 4,
3826 to_symbol
, (offsetT
) 0, 0, BFD_RELOC_32
);
3830 offset
= to_addr
- (from_addr
+ 5);
3831 md_number_to_chars (ptr
, (valueT
) 0xe9, 1);
3832 md_number_to_chars (ptr
+ 1, (valueT
) offset
, 4);
3836 /* Apply a fixup (fixS) to segment data, once it has been determined
3837 by our caller that we have all the info we need to fix it up.
3839 On the 386, immediates, displacements, and data pointers are all in
3840 the same (little-endian) format, so we don't need to care about which
3844 md_apply_fix3 (fixP
, valp
, seg
)
3845 fixS
*fixP
; /* The fix we're to put in. */
3846 valueT
*valp
; /* Pointer to the value of the bits. */
3847 segT seg ATTRIBUTE_UNUSED
; /* Segment fix is from. */
3849 register char *p
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
3850 valueT value
= *valp
;
3852 #if defined (BFD_ASSEMBLER) && !defined (TE_Mach)
3855 switch (fixP
->fx_r_type
)
3861 fixP
->fx_r_type
= BFD_RELOC_32_PCREL
;
3864 fixP
->fx_r_type
= BFD_RELOC_16_PCREL
;
3867 fixP
->fx_r_type
= BFD_RELOC_8_PCREL
;
3873 * This is a hack. There should be a better way to
3876 if ((fixP
->fx_r_type
== BFD_RELOC_32_PCREL
3877 || fixP
->fx_r_type
== BFD_RELOC_16_PCREL
3878 || fixP
->fx_r_type
== BFD_RELOC_8_PCREL
)
3882 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
3884 || OUTPUT_FLAVOR
== bfd_target_coff_flavour
3887 value
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
3889 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3890 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
3891 && (S_GET_SEGMENT (fixP
->fx_addsy
) == seg
3892 || symbol_section_p (fixP
->fx_addsy
))
3893 && ! S_IS_EXTERNAL (fixP
->fx_addsy
)
3894 && ! S_IS_WEAK (fixP
->fx_addsy
)
3895 && S_IS_DEFINED (fixP
->fx_addsy
)
3896 && ! S_IS_COMMON (fixP
->fx_addsy
))
3898 /* Yes, we add the values in twice. This is because
3899 bfd_perform_relocation subtracts them out again. I think
3900 bfd_perform_relocation is broken, but I don't dare change
3902 value
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
3905 #if defined (OBJ_COFF) && defined (TE_PE)
3906 /* For some reason, the PE format does not store a section
3907 address offset for a PC relative symbol. */
3908 if (S_GET_SEGMENT (fixP
->fx_addsy
) != seg
)
3909 value
+= md_pcrel_from (fixP
);
3913 /* Fix a few things - the dynamic linker expects certain values here,
3914 and we must not dissappoint it. */
3915 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
3916 if (OUTPUT_FLAVOR
== bfd_target_elf_flavour
3918 switch (fixP
->fx_r_type
) {
3919 case BFD_RELOC_386_PLT32
:
3920 /* Make the jump instruction point to the address of the operand. At
3921 runtime we merely add the offset to the actual PLT entry. */
3924 case BFD_RELOC_386_GOTPC
:
3926 * This is tough to explain. We end up with this one if we have
3927 * operands that look like "_GLOBAL_OFFSET_TABLE_+[.-.L284]". The goal
3928 * here is to obtain the absolute address of the GOT, and it is strongly
3929 * preferable from a performance point of view to avoid using a runtime
3930 * relocation for this. The actual sequence of instructions often look
3936 * addl $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
3938 * The call and pop essentially return the absolute address of
3939 * the label .L66 and store it in %ebx. The linker itself will
3940 * ultimately change the first operand of the addl so that %ebx points to
3941 * the GOT, but to keep things simple, the .o file must have this operand
3942 * set so that it generates not the absolute address of .L66, but the
3943 * absolute address of itself. This allows the linker itself simply
3944 * treat a GOTPC relocation as asking for a pcrel offset to the GOT to be
3945 * added in, and the addend of the relocation is stored in the operand
3946 * field for the instruction itself.
3948 * Our job here is to fix the operand so that it would add the correct
3949 * offset so that %ebx would point to itself. The thing that is tricky is
3950 * that .-.L66 will point to the beginning of the instruction, so we need
3951 * to further modify the operand so that it will point to itself.
3952 * There are other cases where you have something like:
3954 * .long $_GLOBAL_OFFSET_TABLE_+[.-.L66]
3956 * and here no correction would be required. Internally in the assembler
3957 * we treat operands of this form as not being pcrel since the '.' is
3958 * explicitly mentioned, and I wonder whether it would simplify matters
3959 * to do it this way. Who knows. In earlier versions of the PIC patches,
3960 * the pcrel_adjust field was used to store the correction, but since the
3961 * expression is not pcrel, I felt it would be confusing to do it this way.
3965 case BFD_RELOC_386_GOT32
:
3966 value
= 0; /* Fully resolved at runtime. No addend. */
3968 case BFD_RELOC_386_GOTOFF
:
3971 case BFD_RELOC_VTABLE_INHERIT
:
3972 case BFD_RELOC_VTABLE_ENTRY
:
3979 #endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) */
3981 #endif /* defined (BFD_ASSEMBLER) && !defined (TE_Mach) */
3982 md_number_to_chars (p
, value
, fixP
->fx_size
);
3988 /* This is never used. */
3989 long /* Knows about the byte order in a word. */
3990 md_chars_to_number (con
, nbytes
)
3991 unsigned char con
[]; /* Low order byte 1st. */
3992 int nbytes
; /* Number of bytes in the input. */
3995 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
3997 retval
<<= BITS_PER_CHAR
;
4005 #define MAX_LITTLENUMS 6
4007 /* Turn the string pointed to by litP into a floating point constant of type
4008 type, and emit the appropriate bytes. The number of LITTLENUMS emitted
4009 is stored in *sizeP . An error message is returned, or NULL on OK. */
4011 md_atof (type
, litP
, sizeP
)
4017 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
4018 LITTLENUM_TYPE
*wordP
;
4040 return _("Bad call to md_atof ()");
4042 t
= atof_ieee (input_line_pointer
, type
, words
);
4044 input_line_pointer
= t
;
4046 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
4047 /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
4048 the bigendian 386. */
4049 for (wordP
= words
+ prec
- 1; prec
--;)
4051 md_number_to_chars (litP
, (valueT
) (*wordP
--), sizeof (LITTLENUM_TYPE
));
4052 litP
+= sizeof (LITTLENUM_TYPE
);
4057 char output_invalid_buf
[8];
4059 static char * output_invalid
PARAMS ((int));
4066 sprintf (output_invalid_buf
, "'%c'", c
);
4068 sprintf (output_invalid_buf
, "(0x%x)", (unsigned) c
);
4069 return output_invalid_buf
;
4073 /* REG_STRING starts *before* REGISTER_PREFIX. */
4075 static const reg_entry
*
4076 parse_register (reg_string
, end_op
)
4080 char *s
= reg_string
;
4082 char reg_name_given
[MAX_REG_NAME_SIZE
+ 1];
4085 /* Skip possible REGISTER_PREFIX and possible whitespace. */
4086 if (*s
== REGISTER_PREFIX
)
4089 if (is_space_char (*s
))
4093 while ((*p
++ = register_chars
[(unsigned char) *s
]) != '\0')
4095 if (p
>= reg_name_given
+ MAX_REG_NAME_SIZE
)
4096 return (const reg_entry
*) NULL
;
4102 r
= (const reg_entry
*) hash_find (reg_hash
, reg_name_given
);
4104 /* Handle floating point regs, allowing spaces in the (i) part. */
4105 if (r
== i386_regtab
/* %st is first entry of table */)
4107 if (is_space_char (*s
))
4112 if (is_space_char (*s
))
4114 if (*s
>= '0' && *s
<= '7')
4116 r
= &i386_float_regtab
[*s
- '0'];
4118 if (is_space_char (*s
))
4126 /* We have "%st(" then garbage */
4127 return (const reg_entry
*) NULL
;
4135 CONST
char *md_shortopts
= "kmVQ:";
4137 CONST
char *md_shortopts
= "m";
4139 struct option md_longopts
[] = {
4140 {NULL
, no_argument
, NULL
, 0}
4142 size_t md_longopts_size
= sizeof (md_longopts
);
4145 md_parse_option (c
, arg
)
4147 char *arg ATTRIBUTE_UNUSED
;
4152 flag_do_long_jump
= 1;
4155 #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
4156 /* -k: Ignore for FreeBSD compatibility. */
4160 /* -V: SVR4 argument to print version ID. */
4162 print_version_id ();
4165 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
4166 should be emitted or not. FIXME: Not implemented. */
4178 md_show_usage (stream
)
4181 fprintf (stream
, _("\
4182 -m do long jump\n"));
4185 #ifdef BFD_ASSEMBLER
4186 #ifdef OBJ_MAYBE_ELF
4187 #ifdef OBJ_MAYBE_COFF
4189 /* Pick the target format to use. */
4192 i386_target_format ()
4194 switch (OUTPUT_FLAVOR
)
4196 case bfd_target_coff_flavour
:
4198 case bfd_target_elf_flavour
:
4199 return "elf32-i386";
4206 #endif /* OBJ_MAYBE_COFF */
4207 #endif /* OBJ_MAYBE_ELF */
4208 #endif /* BFD_ASSEMBLER */
4212 md_undefined_symbol (name
)
4215 if (*name
== '_' && *(name
+1) == 'G'
4216 && strcmp(name
, GLOBAL_OFFSET_TABLE_NAME
) == 0)
4220 if (symbol_find (name
))
4221 as_bad (_("GOT already in symbol table"));
4222 GOT_symbol
= symbol_new (name
, undefined_section
,
4223 (valueT
) 0, &zero_address_frag
);
4230 /* Round up a section size to the appropriate boundary. */
4232 md_section_align (segment
, size
)
4233 segT segment ATTRIBUTE_UNUSED
;
4237 #ifdef BFD_ASSEMBLER
4238 /* For a.out, force the section size to be aligned. If we don't do
4239 this, BFD will align it for us, but it will not write out the
4240 final bytes of the section. This may be a bug in BFD, but it is
4241 easier to fix it here since that is how the other a.out targets
4245 align
= bfd_get_section_alignment (stdoutput
, segment
);
4246 size
= ((size
+ (1 << align
) - 1) & ((valueT
) -1 << align
));
4253 /* On the i386, PC-relative offsets are relative to the start of the
4254 next instruction. That is, the address of the offset, plus its
4255 size, since the offset is always the last part of the insn. */
4258 md_pcrel_from (fixP
)
4261 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
4268 int ignore ATTRIBUTE_UNUSED
;
4272 temp
= get_absolute_expression ();
4273 subseg_set (bss_section
, (subsegT
) temp
);
4274 demand_empty_rest_of_line ();
4280 #ifdef BFD_ASSEMBLER
4283 i386_validate_fix (fixp
)
4286 if (fixp
->fx_subsy
&& fixp
->fx_subsy
== GOT_symbol
)
4288 fixp
->fx_r_type
= BFD_RELOC_386_GOTOFF
;
4294 tc_gen_reloc (section
, fixp
)
4295 asection
*section ATTRIBUTE_UNUSED
;
4299 bfd_reloc_code_real_type code
;
4301 switch (fixp
->fx_r_type
)
4303 case BFD_RELOC_386_PLT32
:
4304 case BFD_RELOC_386_GOT32
:
4305 case BFD_RELOC_386_GOTOFF
:
4306 case BFD_RELOC_386_GOTPC
:
4308 case BFD_RELOC_VTABLE_ENTRY
:
4309 case BFD_RELOC_VTABLE_INHERIT
:
4310 code
= fixp
->fx_r_type
;
4315 switch (fixp
->fx_size
)
4318 as_bad (_("Can not do %d byte pc-relative relocation"),
4320 code
= BFD_RELOC_32_PCREL
;
4322 case 1: code
= BFD_RELOC_8_PCREL
; break;
4323 case 2: code
= BFD_RELOC_16_PCREL
; break;
4324 case 4: code
= BFD_RELOC_32_PCREL
; break;
4329 switch (fixp
->fx_size
)
4332 as_bad (_("Can not do %d byte relocation"), fixp
->fx_size
);
4333 code
= BFD_RELOC_32
;
4335 case 1: code
= BFD_RELOC_8
; break;
4336 case 2: code
= BFD_RELOC_16
; break;
4337 case 4: code
= BFD_RELOC_32
; break;
4343 if (code
== BFD_RELOC_32
4345 && fixp
->fx_addsy
== GOT_symbol
)
4346 code
= BFD_RELOC_386_GOTPC
;
4348 rel
= (arelent
*) xmalloc (sizeof (arelent
));
4349 rel
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
4350 *rel
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
4352 rel
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
4353 /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
4354 vtable entry to be used in the relocation's section offset. */
4355 if (fixp
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
4356 rel
->address
= fixp
->fx_offset
;
4359 rel
->addend
= fixp
->fx_addnumber
;
4363 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
4364 if (rel
->howto
== NULL
)
4366 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
4367 _("Cannot represent relocation type %s"),
4368 bfd_get_reloc_code_name (code
));
4369 /* Set howto to a garbage value so that we can keep going. */
4370 rel
->howto
= bfd_reloc_type_lookup (stdoutput
, BFD_RELOC_32
);
4371 assert (rel
->howto
!= NULL
);
4377 #else /* ! BFD_ASSEMBLER */
4379 #if (defined(OBJ_AOUT) | defined(OBJ_BOUT))
4381 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
4384 relax_addressT segment_address_in_file
;
4387 * In: length of relocation (or of address) in chars: 1, 2 or 4.
4388 * Out: GNU LD relocation length code: 0, 1, or 2.
4391 static const unsigned char nbytes_r_length
[] = {42, 0, 1, 42, 2};
4394 know (fixP
->fx_addsy
!= NULL
);
4396 md_number_to_chars (where
,
4397 (valueT
) (fixP
->fx_frag
->fr_address
4398 + fixP
->fx_where
- segment_address_in_file
),
4401 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
4402 ? S_GET_TYPE (fixP
->fx_addsy
)
4403 : fixP
->fx_addsy
->sy_number
);
4405 where
[6] = (r_symbolnum
>> 16) & 0x0ff;
4406 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
4407 where
[4] = r_symbolnum
& 0x0ff;
4408 where
[7] = ((((!S_IS_DEFINED (fixP
->fx_addsy
)) << 3) & 0x08)
4409 | ((nbytes_r_length
[fixP
->fx_size
] << 1) & 0x06)
4410 | (((fixP
->fx_pcrel
<< 0) & 0x01) & 0x0f));
4413 #endif /* OBJ_AOUT or OBJ_BOUT */
4415 #if defined (I386COFF)
4418 tc_coff_fix2rtype (fixP
)
4421 if (fixP
->fx_r_type
== R_IMAGEBASE
)
4424 return (fixP
->fx_pcrel
?
4425 (fixP
->fx_size
== 1 ? R_PCRBYTE
:
4426 fixP
->fx_size
== 2 ? R_PCRWORD
:
4428 (fixP
->fx_size
== 1 ? R_RELBYTE
:
4429 fixP
->fx_size
== 2 ? R_RELWORD
:
4434 tc_coff_sizemachdep (frag
)
4438 return (frag
->fr_next
->fr_address
- frag
->fr_address
);
4443 #endif /* I386COFF */
4445 #endif /* ! BFD_ASSEMBLER */
4447 /* end of tc-i386.c */