1 /* tc-i386.c -- Assemble Intel syntax code for ix86/x86-64
2 Copyright (C) 2009-2023 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
23 operatorT op_modifier
; /* Operand modifier. */
24 int is_mem
; /* 1 if operand is memory reference. */
25 int is_indirect
; /* 1 if operand is indirect reference. */
26 int has_offset
; /* 1 if operand has offset. */
27 unsigned int in_offset
; /* >=1 if processing operand of offset. */
28 unsigned int in_bracket
; /* >=1 if processing operand in brackets. */
29 unsigned int in_scale
; /* >=1 if processing multiplication operand
31 i386_operand_type reloc_types
; /* Value obtained from lex_got(). */
32 const reg_entry
*base
; /* Base register (if any). */
33 const reg_entry
*index
; /* Index register (if any). */
34 offsetT scale_factor
; /* Accumulated scale factor. */
39 /* offset X_add_symbol */
40 #define O_offset O_md32
41 /* offset X_add_symbol */
42 #define O_short O_md31
43 /* near ptr X_add_symbol */
44 #define O_near_ptr O_md30
45 /* far ptr X_add_symbol */
46 #define O_far_ptr O_md29
47 /* byte ptr X_add_symbol */
48 #define O_byte_ptr O_md28
49 /* word ptr X_add_symbol */
50 #define O_word_ptr O_md27
51 /* dword ptr X_add_symbol */
52 #define O_dword_ptr O_md26
53 /* qword ptr X_add_symbol */
54 #define O_qword_ptr O_md25
55 /* mmword ptr X_add_symbol */
56 #define O_mmword_ptr O_qword_ptr
57 /* fword ptr X_add_symbol */
58 #define O_fword_ptr O_md24
59 /* tbyte ptr X_add_symbol */
60 #define O_tbyte_ptr O_md23
61 /* oword ptr X_add_symbol */
62 #define O_oword_ptr O_md22
63 /* xmmword ptr X_add_symbol */
64 #define O_xmmword_ptr O_oword_ptr
65 /* ymmword ptr X_add_symbol */
66 #define O_ymmword_ptr O_md21
67 /* zmmword ptr X_add_symbol */
68 #define O_zmmword_ptr O_md20
74 unsigned int operands
;
76 const i386_operators
[] =
78 { "and", O_bit_and
, 2 },
84 { "mod", O_modulus
, 2 },
86 { "not", O_bit_not
, 1 },
87 { "offset", O_offset
, 1 },
88 { "or", O_bit_inclusive_or
, 2 },
89 { "shl", O_left_shift
, 2 },
90 { "short", O_short
, 1 },
91 { "shr", O_right_shift
, 2 },
92 { "xor", O_bit_exclusive_or
, 2 },
93 { NULL
, O_illegal
, 0 }
100 unsigned short sz
[3];
104 #define I386_TYPE(t, n) { #t, O_##t##_ptr, { n, n, n } }
110 I386_TYPE(mmword
, 8),
111 I386_TYPE(tbyte
, 10),
112 I386_TYPE(oword
, 16),
113 I386_TYPE(xmmword
, 16),
114 I386_TYPE(ymmword
, 32),
115 I386_TYPE(zmmword
, 64),
117 { "near", O_near_ptr
, { 0xff04, 0xff02, 0xff08 } },
118 { "far", O_far_ptr
, { 0xff06, 0xff05, 0xff06 } },
119 { NULL
, O_illegal
, { 0, 0, 0 } }
122 operatorT
i386_operator (const char *name
, unsigned int operands
, char *pc
)
126 #ifdef SVR4_COMMENT_CHARS
127 if (!name
&& operands
== 2 && *input_line_pointer
== '\\')
128 switch (input_line_pointer
[1])
130 case '/': input_line_pointer
+= 2; return O_divide
;
131 case '%': input_line_pointer
+= 2; return O_modulus
;
132 case '*': input_line_pointer
+= 2; return O_multiply
;
143 switch (*input_line_pointer
)
146 ++input_line_pointer
;
149 ++input_line_pointer
;
152 if (this_operand
>= 0 && i
.reloc
[this_operand
] == NO_RELOC
)
155 char *gotfree_input_line
= lex_got (&i
.reloc
[this_operand
],
157 &intel_state
.reloc_types
);
159 if (!gotfree_input_line
)
161 free (gotfree_input_line
);
162 *input_line_pointer
++ = '+';
163 memset (input_line_pointer
, '0', adjust
- 1);
164 input_line_pointer
[adjust
- 1] = ' ';
172 for (j
= 0; i386_operators
[j
].name
; ++j
)
173 if (strcasecmp (i386_operators
[j
].name
, name
) == 0)
175 if (i386_operators
[j
].operands
176 && i386_operators
[j
].operands
!= operands
)
178 return i386_operators
[j
].op
;
181 for (j
= 0; i386_types
[j
].name
; ++j
)
182 if (strcasecmp (i386_types
[j
].name
, name
) == 0)
185 if (i386_types
[j
].name
&& *pc
== ' ')
190 ++input_line_pointer
;
191 c
= get_symbol_name (&pname
);
193 if (strcasecmp (pname
, "ptr") == 0)
195 /* FIXME: What if c == '"' ? */
198 if (intel_syntax
> 0 || operands
!= 1)
200 return i386_types
[j
].op
;
203 if (strcasecmp (pname
, "bcst") == 0)
205 /* FIXME: Again, what if c == '"' ? */
208 if (intel_syntax
> 0 || operands
!= 1
209 || i386_types
[j
].sz
[0] > 8
210 || (i386_types
[j
].sz
[0] & (i386_types
[j
].sz
[0] - 1)))
212 if (!i
.broadcast
.bytes
&& !i
.broadcast
.type
)
214 i
.broadcast
.bytes
= i386_types
[j
].sz
[0];
215 i
.broadcast
.operand
= this_operand
;
217 return i386_types
[j
].op
;
220 (void) restore_line_pointer (c
);
221 input_line_pointer
= pname
- 1;
227 static int i386_intel_parse_name (const char *name
, expressionS
*e
)
231 if (! strcmp (name
, "$"))
233 current_location (e
);
237 for (j
= 0; i386_types
[j
].name
; ++j
)
238 if (strcasecmp(i386_types
[j
].name
, name
) == 0)
240 e
->X_op
= O_constant
;
241 e
->X_add_number
= i386_types
[j
].sz
[flag_code
];
242 e
->X_add_symbol
= NULL
;
243 e
->X_op_symbol
= NULL
;
250 static INLINE
int i386_intel_check (const reg_entry
*rreg
,
251 const reg_entry
*base
,
252 const reg_entry
*iindex
)
254 if ((this_operand
>= 0
255 && rreg
!= i
.op
[this_operand
].regs
)
256 || base
!= intel_state
.base
257 || iindex
!= intel_state
.index
)
259 as_bad (_("invalid use of register"));
265 static INLINE
void i386_intel_fold (expressionS
*e
, symbolS
*sym
)
267 expressionS
*exp
= symbol_get_value_expression (sym
);
268 if (S_GET_SEGMENT (sym
) == absolute_section
)
270 offsetT val
= e
->X_add_number
;
273 e
->X_add_number
+= val
;
277 if (exp
->X_op
== O_symbol
278 && strcmp (S_GET_NAME (exp
->X_add_symbol
),
279 GLOBAL_OFFSET_TABLE_NAME
) == 0)
280 sym
= exp
->X_add_symbol
;
281 e
->X_add_symbol
= sym
;
282 e
->X_op_symbol
= NULL
;
288 i386_intel_simplify_register (expressionS
*e
)
292 if (this_operand
< 0 || intel_state
.in_offset
)
294 as_bad (_("invalid use of register"));
298 if (e
->X_op
== O_register
)
299 reg_num
= e
->X_add_number
;
301 reg_num
= e
->X_md
- 1;
303 if (reg_num
< 0 || reg_num
>= (int) i386_regtab_size
)
305 as_bad (_("invalid register number"));
309 if (!check_register (&i386_regtab
[reg_num
]))
311 as_bad (_("register '%s%s' cannot be used here"),
312 register_prefix
, i386_regtab
[reg_num
].reg_name
);
316 if (!intel_state
.in_bracket
)
318 if (i
.op
[this_operand
].regs
)
320 as_bad (_("invalid use of register"));
323 if (i386_regtab
[reg_num
].reg_type
.bitfield
.class == SReg
324 && i386_regtab
[reg_num
].reg_num
== RegFlat
)
326 as_bad (_("invalid use of pseudo-register"));
329 i
.op
[this_operand
].regs
= i386_regtab
+ reg_num
;
331 else if (!intel_state
.index
332 && (i386_regtab
[reg_num
].reg_type
.bitfield
.xmmword
333 || i386_regtab
[reg_num
].reg_type
.bitfield
.ymmword
334 || i386_regtab
[reg_num
].reg_type
.bitfield
.zmmword
335 || i386_regtab
[reg_num
].reg_num
== RegIZ
))
336 intel_state
.index
= i386_regtab
+ reg_num
;
337 else if (!intel_state
.base
&& !intel_state
.in_scale
)
338 intel_state
.base
= i386_regtab
+ reg_num
;
339 else if (!intel_state
.index
)
341 const insn_template
*t
= current_templates
->start
;
343 if (intel_state
.in_scale
344 || i386_regtab
[reg_num
].reg_type
.bitfield
.baseindex
345 || t
->mnem_off
== MN_bndmk
346 || t
->mnem_off
== MN_bndldx
347 || t
->mnem_off
== MN_bndstx
)
348 intel_state
.index
= i386_regtab
+ reg_num
;
351 /* Convert base to index and make ESP/RSP the base. */
352 intel_state
.index
= intel_state
.base
;
353 intel_state
.base
= i386_regtab
+ reg_num
;
358 /* esp is invalid as index */
359 intel_state
.index
= reg_eax
+ ESP_REG_NUM
;
364 static int i386_intel_simplify (expressionS
*);
366 static INLINE
int i386_intel_simplify_symbol(symbolS
*sym
)
368 int ret
= i386_intel_simplify (symbol_get_value_expression (sym
));
372 S_SET_SEGMENT(sym
, absolute_section
);
378 static int i386_intel_simplify (expressionS
*e
)
380 const reg_entry
*the_reg
= (this_operand
>= 0
381 ? i
.op
[this_operand
].regs
: NULL
);
382 const reg_entry
*base
= intel_state
.base
;
383 const reg_entry
*state_index
= intel_state
.index
;
394 if (!i386_intel_simplify_symbol (e
->X_add_symbol
)
395 || !i386_intel_check(the_reg
, intel_state
.base
,
399 if (!intel_state
.in_offset
)
400 ++intel_state
.in_bracket
;
401 ret
= i386_intel_simplify_symbol (e
->X_op_symbol
);
402 if (!intel_state
.in_offset
)
403 --intel_state
.in_bracket
;
409 i386_intel_fold (e
, e
->X_op_symbol
);
413 intel_state
.has_offset
= 1;
414 ++intel_state
.in_offset
;
415 ret
= i386_intel_simplify_symbol (e
->X_add_symbol
);
416 --intel_state
.in_offset
;
417 if (!ret
|| !i386_intel_check(the_reg
, base
, state_index
))
419 i386_intel_fold (e
, e
->X_add_symbol
);
426 case O_qword_ptr
: /* O_mmword_ptr */
428 case O_oword_ptr
: /* O_xmmword_ptr */
433 if (intel_state
.op_modifier
== O_absent
)
434 intel_state
.op_modifier
= e
->X_op
;
437 if (symbol_get_value_expression (e
->X_add_symbol
)->X_op
440 as_bad (_("invalid use of register"));
443 if (!i386_intel_simplify_symbol (e
->X_add_symbol
))
445 i386_intel_fold (e
, e
->X_add_symbol
);
449 if (symbol_get_value_expression (e
->X_op_symbol
)->X_op
452 as_bad (_("invalid use of register"));
455 if (!i386_intel_simplify_symbol (e
->X_op_symbol
)
456 || !i386_intel_check(the_reg
, intel_state
.base
,
459 if (!intel_state
.in_offset
)
461 if (!intel_state
.seg
)
462 intel_state
.seg
= e
->X_add_symbol
;
467 exp
.X_op
= O_full_ptr
;
468 exp
.X_add_symbol
= e
->X_add_symbol
;
469 exp
.X_op_symbol
= intel_state
.seg
;
470 intel_state
.seg
= make_expr_symbol (&exp
);
473 i386_intel_fold (e
, e
->X_op_symbol
);
477 if (this_operand
>= 0 && intel_state
.in_bracket
)
479 expressionS
*scale
= NULL
;
480 int has_index
= (intel_state
.index
!= NULL
);
482 if (!intel_state
.in_scale
++)
483 intel_state
.scale_factor
= 1;
485 ret
= i386_intel_simplify_symbol (e
->X_add_symbol
);
486 if (ret
&& !has_index
&& intel_state
.index
)
487 scale
= symbol_get_value_expression (e
->X_op_symbol
);
490 ret
= i386_intel_simplify_symbol (e
->X_op_symbol
);
491 if (ret
&& !scale
&& !has_index
&& intel_state
.index
)
492 scale
= symbol_get_value_expression (e
->X_add_symbol
);
496 resolve_expression (scale
);
497 if (scale
->X_op
!= O_constant
498 || intel_state
.index
->reg_type
.bitfield
.word
)
499 scale
->X_add_number
= 0;
500 intel_state
.scale_factor
*= scale
->X_add_number
;
503 --intel_state
.in_scale
;
507 if (!intel_state
.in_scale
)
508 switch (intel_state
.scale_factor
)
511 i
.log2_scale_factor
= 0;
514 i
.log2_scale_factor
= 1;
517 i
.log2_scale_factor
= 2;
520 i
.log2_scale_factor
= 3;
523 /* esp is invalid as index */
524 intel_state
.index
= reg_eax
+ ESP_REG_NUM
;
533 ret
= i386_intel_simplify_register (e
);
536 gas_assert (e
->X_add_number
< (unsigned short) -1);
537 e
->X_md
= (unsigned short) e
->X_add_number
+ 1;
538 e
->X_op
= O_constant
;
545 return i386_intel_simplify_register (e
);
551 && !i386_intel_simplify_symbol (e
->X_add_symbol
))
553 if (!the_reg
&& this_operand
>= 0
554 && e
->X_op
== O_symbol
&& !e
->X_add_number
)
555 the_reg
= i
.op
[this_operand
].regs
;
556 if (e
->X_op
== O_add
|| e
->X_op
== O_subtract
)
558 base
= intel_state
.base
;
559 state_index
= intel_state
.index
;
561 if (!i386_intel_check (the_reg
, base
, state_index
)
563 && !i386_intel_simplify_symbol (e
->X_op_symbol
))
564 || !i386_intel_check (the_reg
,
566 ? base
: intel_state
.base
),
568 ? state_index
: intel_state
.index
)))
573 if (this_operand
>= 0
574 && e
->X_op
== O_symbol
575 && !intel_state
.in_offset
)
577 segT seg
= S_GET_SEGMENT (e
->X_add_symbol
);
579 if (seg
!= absolute_section
580 && seg
!= reg_section
581 && seg
!= expr_section
)
582 intel_state
.is_mem
|= 2 - !intel_state
.in_bracket
;
588 int i386_need_index_operator (void)
590 return intel_syntax
< 0;
594 i386_intel_operand (char *operand_string
, int got_a_float
)
596 char *saved_input_line_pointer
, *buf
;
598 expressionS exp
, *expP
;
600 bool rc_sae_modifier
= i
.rounding
.type
!= rc_none
&& i
.rounding
.modifier
;
603 /* Handle vector immediates. */
604 if (RC_SAE_immediate (operand_string
))
608 as_bad (_("`%s': RC/SAE operand must precede immediate operands"),
609 insn_name (current_templates
->start
));
616 /* Initialize state structure. */
617 intel_state
.op_modifier
= O_absent
;
618 intel_state
.is_mem
= 0;
619 intel_state
.is_indirect
= 0;
620 intel_state
.has_offset
= 0;
621 intel_state
.base
= NULL
;
622 intel_state
.index
= NULL
;
623 intel_state
.seg
= NULL
;
624 operand_type_set (&intel_state
.reloc_types
, ~0);
625 gas_assert (!intel_state
.in_offset
);
626 gas_assert (!intel_state
.in_bracket
);
627 gas_assert (!intel_state
.in_scale
);
629 saved_input_line_pointer
= input_line_pointer
;
630 input_line_pointer
= buf
= xstrdup (operand_string
);
633 memset (&exp
, 0, sizeof(exp
));
634 exp_seg
= expression (&exp
);
635 ret
= i386_intel_simplify (&exp
);
640 /* Handle vector operations. */
641 if (*input_line_pointer
== '{')
643 char *end
= check_VecOperations (input_line_pointer
);
645 input_line_pointer
= end
;
650 if (!is_end_of_line
[(unsigned char) *input_line_pointer
])
653 as_bad (_("junk `%s' after expression"), input_line_pointer
);
656 else if (exp
.X_op
== O_illegal
|| exp
.X_op
== O_absent
)
659 as_bad (_("invalid expression"));
662 else if (!intel_state
.has_offset
663 && input_line_pointer
> buf
664 && *(input_line_pointer
- 1) == ']')
666 intel_state
.is_mem
|= 1;
667 intel_state
.is_indirect
= 1;
670 input_line_pointer
= saved_input_line_pointer
;
673 gas_assert (!intel_state
.in_offset
);
674 gas_assert (!intel_state
.in_bracket
);
675 gas_assert (!intel_state
.in_scale
);
680 if (intel_state
.op_modifier
!= O_absent
681 && current_templates
->start
->mnem_off
!= MN_lea
)
683 i
.types
[this_operand
].bitfield
.unspecified
= 0;
685 switch (intel_state
.op_modifier
)
688 i
.types
[this_operand
].bitfield
.byte
= 1;
689 suffix
= BYTE_MNEM_SUFFIX
;
693 i
.types
[this_operand
].bitfield
.word
= 1;
694 if (got_a_float
== 2) /* "fi..." */
695 suffix
= SHORT_MNEM_SUFFIX
;
696 else if (current_templates
->start
->mnem_off
!= MN_lar
697 && current_templates
->start
->mnem_off
!= MN_lsl
698 && current_templates
->start
->mnem_off
!= MN_arpl
)
699 suffix
= WORD_MNEM_SUFFIX
;
703 i
.types
[this_operand
].bitfield
.dword
= 1;
704 if ((insn_name (current_templates
->start
)[0] == 'l'
705 && insn_name (current_templates
->start
)[2] == 's'
706 && insn_name (current_templates
->start
)[3] == 0)
707 || current_templates
->start
->mnem_off
== MN_bound
)
708 suffix
= WORD_MNEM_SUFFIX
;
709 else if (flag_code
!= CODE_32BIT
710 && (current_templates
->start
->opcode_modifier
.jump
== JUMP
711 || current_templates
->start
->opcode_modifier
.jump
715 suffix
= WORD_MNEM_SUFFIX
;
717 else if (got_a_float
== 1) /* "f..." */
718 suffix
= SHORT_MNEM_SUFFIX
;
720 suffix
= LONG_MNEM_SUFFIX
;
724 i
.types
[this_operand
].bitfield
.fword
= 1;
725 if (current_templates
->start
->mnem_off
== MN_les
726 || current_templates
->start
->mnem_off
== MN_lds
727 || current_templates
->start
->mnem_off
== MN_lss
728 || current_templates
->start
->mnem_off
== MN_lfs
729 || current_templates
->start
->mnem_off
== MN_lgs
)
730 suffix
= LONG_MNEM_SUFFIX
;
731 else if (!got_a_float
)
733 if (flag_code
== CODE_16BIT
)
734 add_prefix (DATA_PREFIX_OPCODE
);
739 case O_qword_ptr
: /* O_mmword_ptr */
740 i
.types
[this_operand
].bitfield
.qword
= 1;
741 if (current_templates
->start
->mnem_off
== MN_bound
742 || got_a_float
== 1) /* "f..." */
743 suffix
= LONG_MNEM_SUFFIX
;
745 suffix
= QWORD_MNEM_SUFFIX
;
749 i
.types
[this_operand
].bitfield
.tbyte
= 1;
752 if (flag_code
== CODE_64BIT
753 && (current_templates
->start
->operand_types
[0].bitfield
.fword
754 || current_templates
->start
->operand_types
[0].bitfield
.tbyte
755 || current_templates
->start
->opcode_modifier
.jump
== JUMP_DWORD
756 || current_templates
->start
->opcode_modifier
.jump
== JUMP
))
757 suffix
= QWORD_MNEM_SUFFIX
; /* l[fgs]s, [ls][gi]dt, call, jmp */
759 i
.types
[this_operand
].bitfield
.byte
= 1; /* cause an error */
762 case O_oword_ptr
: /* O_xmmword_ptr */
763 i
.types
[this_operand
].bitfield
.xmmword
= 1;
767 i
.types
[this_operand
].bitfield
.ymmword
= 1;
771 i
.types
[this_operand
].bitfield
.zmmword
= 1;
778 if (current_templates
->start
->opcode_modifier
.jump
!= JUMP
779 && current_templates
->start
->opcode_modifier
.jump
!= JUMP_DWORD
)
782 i
.types
[this_operand
].bitfield
.byte
= 1;
783 i
.types
[this_operand
].bitfield
.tbyte
= 1;
789 BAD_CASE (intel_state
.op_modifier
);
793 /* Now check whether we actually want to infer an AT&T-like suffix.
794 We really only need to do this when operand size determination (incl.
795 REX.W) is going to be derived from it. For this we check whether the
796 given suffix is valid for any of the candidate templates. */
797 if (suffix
&& suffix
!= i
.suffix
798 && current_templates
->start
->mnem_off
!= MN_bound
)
800 const insn_template
*t
;
802 for (t
= current_templates
->start
; t
< current_templates
->end
; ++t
)
804 /* Operands haven't been swapped yet. */
805 unsigned int op
= t
->operands
- 1 - this_operand
;
807 /* Easy checks to skip templates which won't match anyway. */
808 if (this_operand
>= t
->operands
|| t
->opcode_modifier
.attsyntax
)
813 case BYTE_MNEM_SUFFIX
:
814 if (t
->opcode_modifier
.no_bsuf
)
817 case WORD_MNEM_SUFFIX
:
818 if (t
->opcode_modifier
.no_wsuf
)
821 case LONG_MNEM_SUFFIX
:
822 if (t
->opcode_modifier
.no_lsuf
)
825 case QWORD_MNEM_SUFFIX
:
826 if (t
->opcode_modifier
.no_qsuf
|| !q_suffix_allowed (t
))
829 case SHORT_MNEM_SUFFIX
:
830 if (t
->opcode_modifier
.no_ssuf
)
837 /* We can skip templates with swappable operands here, as one
838 operand will be a register, which operand size can be
840 if (t
->opcode_modifier
.d
)
843 /* In a few cases suffixes are permitted, but we can nevertheless
844 derive that these aren't going to be needed. This is only of
845 interest for insns using ModR/M. */
846 if (!t
->opcode_modifier
.modrm
)
849 if (!t
->operand_types
[op
].bitfield
.baseindex
)
852 switch (t
->operand_types
[op
].bitfield
.class)
863 if (t
== current_templates
->end
)
869 else if (suffix
&& i
.suffix
!= suffix
)
871 as_bad (_("conflicting operand size modifiers"));
876 /* Operands for jump/call need special consideration. */
877 if (current_templates
->start
->opcode_modifier
.jump
== JUMP
878 || current_templates
->start
->opcode_modifier
.jump
== JUMP_DWORD
879 || current_templates
->start
->opcode_modifier
.jump
== JUMP_INTERSEGMENT
)
881 bool jumpabsolute
= false;
883 if (i
.op
[this_operand
].regs
886 || intel_state
.is_mem
> 1)
889 switch (intel_state
.op_modifier
)
895 intel_state
.is_mem
= 1;
899 if (!intel_state
.seg
)
901 intel_state
.is_mem
= 1;
902 if (intel_state
.op_modifier
== O_absent
)
904 if (intel_state
.is_indirect
== 1)
908 as_bad (_("cannot infer the segment part of the operand"));
911 else if (S_GET_SEGMENT (intel_state
.seg
) == reg_section
)
914 if (intel_state
.op_modifier
== O_far_ptr
)
919 i386_operand_type types
;
921 if (i
.imm_operands
>= MAX_IMMEDIATE_OPERANDS
)
923 as_bad (_("at most %d immediate operands are allowed"),
924 MAX_IMMEDIATE_OPERANDS
);
927 expP
= &im_expressions
[i
.imm_operands
++];
928 memset (expP
, 0, sizeof(*expP
));
929 expP
->X_op
= O_symbol
;
930 expP
->X_add_symbol
= intel_state
.seg
;
931 i
.op
[this_operand
].imms
= expP
;
933 resolve_expression (expP
);
934 operand_type_set (&types
, ~0);
935 if (!i386_finalize_immediate (S_GET_SEGMENT (intel_state
.seg
),
936 expP
, types
, operand_string
))
938 if (i
.operands
< MAX_OPERANDS
)
940 this_operand
= i
.operands
++;
941 i
.types
[this_operand
].bitfield
.unspecified
= 1;
943 intel_state
.seg
= NULL
;
944 intel_state
.is_mem
= 0;
953 i
.jumpabsolute
= true;
954 intel_state
.is_mem
|= 1;
957 else if (intel_state
.seg
)
958 intel_state
.is_mem
|= 1;
960 if (i
.op
[this_operand
].regs
)
962 i386_operand_type temp
;
964 /* Register operand. */
965 if (intel_state
.base
|| intel_state
.index
|| intel_state
.seg
)
967 as_bad (_("invalid operand"));
971 temp
= i
.op
[this_operand
].regs
->reg_type
;
972 temp
.bitfield
.baseindex
= 0;
973 i
.types
[this_operand
] = operand_type_or (i
.types
[this_operand
],
975 i
.types
[this_operand
].bitfield
.unspecified
= 0;
978 if ((i
.rounding
.type
!= rc_none
&& !i
.rounding
.modifier
979 && temp
.bitfield
.class != Reg
)
984 for (j
= 0; j
< ARRAY_SIZE (RC_NamesTable
); ++j
)
985 if (i
.rounding
.type
== RC_NamesTable
[j
].type
)
987 as_bad (_("`%s': misplaced `{%s}'"),
988 insn_name (current_templates
->start
), RC_NamesTable
[j
].name
);
992 else if (intel_state
.base
995 || intel_state
.is_mem
)
997 /* Memory operand. */
1002 call 0x9090,0x90909090
1003 lcall 0x9090,0x90909090
1004 jmp 0x9090,0x90909090
1005 ljmp 0x9090,0x90909090
1008 if ((current_templates
->start
->opcode_modifier
.jump
== JUMP_INTERSEGMENT
1009 || current_templates
->start
->opcode_modifier
.jump
== JUMP_DWORD
1010 || current_templates
->start
->opcode_modifier
.jump
== JUMP
)
1011 && this_operand
== 1
1012 && intel_state
.seg
== NULL
1013 && i
.mem_operands
== 1
1014 && i
.disp_operands
== 1
1015 && intel_state
.op_modifier
== O_absent
)
1017 /* Try to process the first operand as immediate, */
1019 if (i386_finalize_immediate (exp_seg
, i
.op
[0].imms
,
1020 intel_state
.reloc_types
,
1024 expP
= &im_expressions
[0];
1025 i
.op
[this_operand
].imms
= expP
;
1028 /* Try to process the second operand as immediate, */
1029 if (i386_finalize_immediate (exp_seg
, expP
,
1030 intel_state
.reloc_types
,
1034 i
.disp_operands
= 0;
1036 i
.flags
[0] &= ~Operand_Mem
;
1037 i
.types
[0].bitfield
.disp16
= 0;
1038 i
.types
[0].bitfield
.disp32
= 0;
1045 /* Swap base and index in 16-bit memory operands like
1046 [si+bx]. Since i386_index_check is also used in AT&T
1047 mode we have to do this here. */
1048 if (intel_state
.base
1049 && intel_state
.index
1050 && intel_state
.base
->reg_type
.bitfield
.word
1051 && intel_state
.index
->reg_type
.bitfield
.word
1052 && intel_state
.base
->reg_num
>= 6
1053 && intel_state
.index
->reg_num
< 6)
1055 i
.base_reg
= intel_state
.index
;
1056 i
.index_reg
= intel_state
.base
;
1060 i
.base_reg
= intel_state
.base
;
1061 i
.index_reg
= intel_state
.index
;
1064 if (i
.base_reg
|| i
.index_reg
)
1065 i
.types
[this_operand
].bitfield
.baseindex
= 1;
1067 expP
= &disp_expressions
[i
.disp_operands
];
1068 memcpy (expP
, &exp
, sizeof(exp
));
1069 resolve_expression (expP
);
1071 if (expP
->X_op
!= O_constant
1072 || expP
->X_add_number
1073 || !i
.types
[this_operand
].bitfield
.baseindex
)
1075 i
.op
[this_operand
].disps
= expP
;
1078 i386_addressing_mode ();
1080 if (flag_code
== CODE_64BIT
)
1082 i
.types
[this_operand
].bitfield
.disp32
= 1;
1083 if (!i
.prefix
[ADDR_PREFIX
])
1084 i
.types
[this_operand
].bitfield
.disp64
= 1;
1086 else if (!i
.prefix
[ADDR_PREFIX
] ^ (flag_code
== CODE_16BIT
))
1087 i
.types
[this_operand
].bitfield
.disp32
= 1;
1089 i
.types
[this_operand
].bitfield
.disp16
= 1;
1091 #if defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT)
1093 * exp_seg is used only for verification in
1094 * i386_finalize_displacement, and we can end up seeing reg_section
1095 * here - but we know we removed all registers from the expression
1096 * (or error-ed on any remaining ones) in i386_intel_simplify. I
1097 * consider the check in i386_finalize_displacement bogus anyway, in
1098 * particular because it doesn't allow for expr_section, so I'd
1099 * rather see that check (and the similar one in
1100 * i386_finalize_immediate) use SEG_NORMAL(), but not being an a.out
1101 * expert I can't really say whether that would have other bad side
1104 if (OUTPUT_FLAVOR
== bfd_target_aout_flavour
1105 && exp_seg
== reg_section
)
1106 exp_seg
= expP
->X_op
!= O_constant
? undefined_section
1110 if (!i386_finalize_displacement (exp_seg
, expP
,
1111 intel_state
.reloc_types
,
1116 if (intel_state
.seg
)
1118 for (ret
= check_none
; ; ret
= operand_check
)
1120 expP
= symbol_get_value_expression (intel_state
.seg
);
1121 if (expP
->X_op
!= O_full_ptr
1122 || symbol_get_value_expression (expP
->X_op_symbol
)->X_op
1125 intel_state
.seg
= expP
->X_add_symbol
;
1127 if (expP
->X_op
!= O_register
)
1129 as_bad (_("segment register name expected"));
1132 if (i386_regtab
[expP
->X_add_number
].reg_type
.bitfield
.class != SReg
)
1134 as_bad (_("invalid use of register"));
1140 as_bad (_("redundant segment overrides"));
1143 as_warn (_("redundant segment overrides"));
1146 if (i386_regtab
[expP
->X_add_number
].reg_num
== RegFlat
)
1147 i
.seg
[i
.mem_operands
] = NULL
;
1149 i
.seg
[i
.mem_operands
] = &i386_regtab
[expP
->X_add_number
];
1152 if (!i386_index_check (operand_string
))
1155 i
.flags
[this_operand
] |= Operand_Mem
;
1161 if (i
.imm_operands
>= MAX_IMMEDIATE_OPERANDS
)
1163 as_bad (_("at most %d immediate operands are allowed"),
1164 MAX_IMMEDIATE_OPERANDS
);
1168 expP
= &im_expressions
[i
.imm_operands
++];
1169 i
.op
[this_operand
].imms
= expP
;
1172 return i386_finalize_immediate (exp_seg
, expP
, intel_state
.reloc_types
,