1 /* tc-i386.c -- Assemble Intel syntax code for ix86/x86-64
2 Copyright (C) 2009-2020 Free Software Foundation, Inc.
3
4 This file is part of GAS, the GNU Assembler.
5
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)
9 any later version.
10
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.
15
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
19 02110-1301, USA. */
20
21 static struct
22 {
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
30 * in brackets. */
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. */
35 symbolS *seg;
36 }
37 intel_state;
38
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
69
70 static struct
71 {
72 const char *name;
73 operatorT op;
74 unsigned int operands;
75 }
76 const i386_operators[] =
77 {
78 { "and", O_bit_and, 2 },
79 { "eq", O_eq, 2 },
80 { "ge", O_ge, 2 },
81 { "gt", O_gt, 2 },
82 { "le", O_le, 2 },
83 { "lt", O_lt, 2 },
84 { "mod", O_modulus, 2 },
85 { "ne", O_ne, 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 }
94 };
95
96 static struct
97 {
98 const char *name;
99 operatorT op;
100 unsigned short sz[3];
101 }
102 const i386_types[] =
103 {
104 #define I386_TYPE(t, n) { #t, O_##t##_ptr, { n, n, n } }
105 I386_TYPE(byte, 1),
106 I386_TYPE(word, 2),
107 I386_TYPE(dword, 4),
108 I386_TYPE(fword, 6),
109 I386_TYPE(qword, 8),
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),
116 #undef I386_TYPE
117 { "near", O_near_ptr, { 0xff04, 0xff02, 0xff08 } },
118 { "far", O_far_ptr, { 0xff06, 0xff05, 0xff06 } },
119 { NULL, O_illegal, { 0, 0, 0 } }
120 };
121
i386_operator(const char * name,unsigned int operands,char * pc)122 operatorT i386_operator (const char *name, unsigned int operands, char *pc)
123 {
124 unsigned int j;
125
126 if (!intel_syntax)
127 return O_absent;
128
129 if (!name)
130 {
131 if (operands != 2)
132 return O_illegal;
133 switch (*input_line_pointer)
134 {
135 case ':':
136 ++input_line_pointer;
137 return O_full_ptr;
138 case '[':
139 ++input_line_pointer;
140 return O_index;
141 case '@':
142 if (this_operand >= 0 && i.reloc[this_operand] == NO_RELOC)
143 {
144 int adjust = 0;
145 char *gotfree_input_line = lex_got (&i.reloc[this_operand],
146 &adjust,
147 &intel_state.reloc_types);
148
149 if (!gotfree_input_line)
150 break;
151 free (gotfree_input_line);
152 *input_line_pointer++ = '+';
153 memset (input_line_pointer, '0', adjust - 1);
154 input_line_pointer[adjust - 1] = ' ';
155 return O_add;
156 }
157 break;
158 }
159 return O_illegal;
160 }
161
162 for (j = 0; i386_operators[j].name; ++j)
163 if (strcasecmp (i386_operators[j].name, name) == 0)
164 {
165 if (i386_operators[j].operands
166 && i386_operators[j].operands != operands)
167 return O_illegal;
168 return i386_operators[j].op;
169 }
170
171 for (j = 0; i386_types[j].name; ++j)
172 if (strcasecmp (i386_types[j].name, name) == 0)
173 break;
174
175 if (i386_types[j].name && *pc == ' ')
176 {
177 char *pname;
178 char c;
179
180 ++input_line_pointer;
181 c = get_symbol_name (&pname);
182
183 if (strcasecmp (pname, "ptr") == 0)
184 {
185 /* FIXME: What if c == '"' ? */
186 pname[-1] = *pc;
187 *pc = c;
188 if (intel_syntax > 0 || operands != 1)
189 return O_illegal;
190 return i386_types[j].op;
191 }
192
193 (void) restore_line_pointer (c);
194 input_line_pointer = pname - 1;
195 }
196
197 return O_absent;
198 }
199
i386_intel_parse_name(const char * name,expressionS * e)200 static int i386_intel_parse_name (const char *name, expressionS *e)
201 {
202 unsigned int j;
203
204 if (! strcmp (name, "$"))
205 {
206 current_location (e);
207 return 1;
208 }
209
210 for (j = 0; i386_types[j].name; ++j)
211 if (strcasecmp(i386_types[j].name, name) == 0)
212 {
213 e->X_op = O_constant;
214 e->X_add_number = i386_types[j].sz[flag_code];
215 e->X_add_symbol = NULL;
216 e->X_op_symbol = NULL;
217 return 1;
218 }
219
220 return 0;
221 }
222
i386_intel_check(const reg_entry * rreg,const reg_entry * base,const reg_entry * iindex)223 static INLINE int i386_intel_check (const reg_entry *rreg,
224 const reg_entry *base,
225 const reg_entry *iindex)
226 {
227 if ((this_operand >= 0
228 && rreg != i.op[this_operand].regs)
229 || base != intel_state.base
230 || iindex != intel_state.index)
231 {
232 as_bad (_("invalid use of register"));
233 return 0;
234 }
235 return 1;
236 }
237
i386_intel_fold(expressionS * e,symbolS * sym)238 static INLINE void i386_intel_fold (expressionS *e, symbolS *sym)
239 {
240 expressionS *exp = symbol_get_value_expression (sym);
241 if (S_GET_SEGMENT (sym) == absolute_section)
242 {
243 offsetT val = e->X_add_number;
244
245 *e = *exp;
246 e->X_add_number += val;
247 }
248 else
249 {
250 if (exp->X_op == O_symbol
251 && strcmp (S_GET_NAME (exp->X_add_symbol),
252 GLOBAL_OFFSET_TABLE_NAME) == 0)
253 sym = exp->X_add_symbol;
254 e->X_add_symbol = sym;
255 e->X_op_symbol = NULL;
256 e->X_op = O_symbol;
257 }
258 }
259
260 static int
i386_intel_simplify_register(expressionS * e)261 i386_intel_simplify_register (expressionS *e)
262 {
263 int reg_num;
264
265 if (this_operand < 0 || intel_state.in_offset)
266 {
267 as_bad (_("invalid use of register"));
268 return 0;
269 }
270
271 if (e->X_op == O_register)
272 reg_num = e->X_add_number;
273 else
274 reg_num = e->X_md - 1;
275
276 if (reg_num < 0 || reg_num >= (int) i386_regtab_size)
277 {
278 as_bad (_("invalid register number"));
279 return 0;
280 }
281
282 if (!intel_state.in_bracket)
283 {
284 if (i.op[this_operand].regs)
285 {
286 as_bad (_("invalid use of register"));
287 return 0;
288 }
289 if (i386_regtab[reg_num].reg_type.bitfield.class == SReg
290 && i386_regtab[reg_num].reg_num == RegFlat)
291 {
292 as_bad (_("invalid use of pseudo-register"));
293 return 0;
294 }
295 i.op[this_operand].regs = i386_regtab + reg_num;
296 }
297 else if (!intel_state.index
298 && (i386_regtab[reg_num].reg_type.bitfield.xmmword
299 || i386_regtab[reg_num].reg_type.bitfield.ymmword
300 || i386_regtab[reg_num].reg_type.bitfield.zmmword
301 || i386_regtab[reg_num].reg_num == RegIZ))
302 intel_state.index = i386_regtab + reg_num;
303 else if (!intel_state.base && !intel_state.in_scale)
304 intel_state.base = i386_regtab + reg_num;
305 else if (!intel_state.index)
306 {
307 if (intel_state.in_scale
308 || current_templates->start->base_opcode == 0xf30f1b /* bndmk */
309 || (current_templates->start->base_opcode & ~1) == 0x0f1a /* bnd{ld,st}x */
310 || i386_regtab[reg_num].reg_type.bitfield.baseindex)
311 intel_state.index = i386_regtab + reg_num;
312 else
313 {
314 /* Convert base to index and make ESP/RSP the base. */
315 intel_state.index = intel_state.base;
316 intel_state.base = i386_regtab + reg_num;
317 }
318 }
319 else
320 {
321 /* esp is invalid as index */
322 intel_state.index = i386_regtab + REGNAM_EAX + ESP_REG_NUM;
323 }
324 return 2;
325 }
326
327 static int i386_intel_simplify (expressionS *);
328
i386_intel_simplify_symbol(symbolS * sym)329 static INLINE int i386_intel_simplify_symbol(symbolS *sym)
330 {
331 int ret = i386_intel_simplify (symbol_get_value_expression (sym));
332
333 if (ret == 2)
334 {
335 S_SET_SEGMENT(sym, absolute_section);
336 ret = 1;
337 }
338 return ret;
339 }
340
i386_intel_simplify(expressionS * e)341 static int i386_intel_simplify (expressionS *e)
342 {
343 const reg_entry *the_reg = (this_operand >= 0
344 ? i.op[this_operand].regs : NULL);
345 const reg_entry *base = intel_state.base;
346 const reg_entry *state_index = intel_state.index;
347 int ret;
348
349 if (!intel_syntax)
350 return 1;
351
352 switch (e->X_op)
353 {
354 case O_index:
355 if (e->X_add_symbol)
356 {
357 if (!i386_intel_simplify_symbol (e->X_add_symbol)
358 || !i386_intel_check(the_reg, intel_state.base,
359 intel_state.index))
360 return 0;
361 }
362 if (!intel_state.in_offset)
363 ++intel_state.in_bracket;
364 ret = i386_intel_simplify_symbol (e->X_op_symbol);
365 if (!intel_state.in_offset)
366 --intel_state.in_bracket;
367 if (!ret)
368 return 0;
369 if (e->X_add_symbol)
370 e->X_op = O_add;
371 else
372 i386_intel_fold (e, e->X_op_symbol);
373 break;
374
375 case O_offset:
376 intel_state.has_offset = 1;
377 ++intel_state.in_offset;
378 ret = i386_intel_simplify_symbol (e->X_add_symbol);
379 --intel_state.in_offset;
380 if (!ret || !i386_intel_check(the_reg, base, state_index))
381 return 0;
382 i386_intel_fold (e, e->X_add_symbol);
383 return ret;
384
385 case O_byte_ptr:
386 case O_word_ptr:
387 case O_dword_ptr:
388 case O_fword_ptr:
389 case O_qword_ptr: /* O_mmword_ptr */
390 case O_tbyte_ptr:
391 case O_oword_ptr: /* O_xmmword_ptr */
392 case O_ymmword_ptr:
393 case O_zmmword_ptr:
394 case O_near_ptr:
395 case O_far_ptr:
396 if (intel_state.op_modifier == O_absent)
397 intel_state.op_modifier = e->X_op;
398 /* FALLTHROUGH */
399 case O_short:
400 if (symbol_get_value_expression (e->X_add_symbol)->X_op
401 == O_register)
402 {
403 as_bad (_("invalid use of register"));
404 return 0;
405 }
406 if (!i386_intel_simplify_symbol (e->X_add_symbol))
407 return 0;
408 i386_intel_fold (e, e->X_add_symbol);
409 break;
410
411 case O_full_ptr:
412 if (symbol_get_value_expression (e->X_op_symbol)->X_op
413 == O_register)
414 {
415 as_bad (_("invalid use of register"));
416 return 0;
417 }
418 if (!i386_intel_simplify_symbol (e->X_op_symbol)
419 || !i386_intel_check(the_reg, intel_state.base,
420 intel_state.index))
421 return 0;
422 if (!intel_state.in_offset)
423 {
424 if (!intel_state.seg)
425 intel_state.seg = e->X_add_symbol;
426 else
427 {
428 expressionS exp;
429
430 exp.X_op = O_full_ptr;
431 exp.X_add_symbol = e->X_add_symbol;
432 exp.X_op_symbol = intel_state.seg;
433 intel_state.seg = make_expr_symbol (&exp);
434 }
435 }
436 i386_intel_fold (e, e->X_op_symbol);
437 break;
438
439 case O_multiply:
440 if (this_operand >= 0 && intel_state.in_bracket)
441 {
442 expressionS *scale = NULL;
443 int has_index = (intel_state.index != NULL);
444
445 if (!intel_state.in_scale++)
446 intel_state.scale_factor = 1;
447
448 ret = i386_intel_simplify_symbol (e->X_add_symbol);
449 if (ret && !has_index && intel_state.index)
450 scale = symbol_get_value_expression (e->X_op_symbol);
451
452 if (ret)
453 ret = i386_intel_simplify_symbol (e->X_op_symbol);
454 if (ret && !scale && !has_index && intel_state.index)
455 scale = symbol_get_value_expression (e->X_add_symbol);
456
457 if (ret && scale)
458 {
459 resolve_expression (scale);
460 if (scale->X_op != O_constant
461 || intel_state.index->reg_type.bitfield.word)
462 scale->X_add_number = 0;
463 intel_state.scale_factor *= scale->X_add_number;
464 }
465
466 --intel_state.in_scale;
467 if (!ret)
468 return 0;
469
470 if (!intel_state.in_scale)
471 switch (intel_state.scale_factor)
472 {
473 case 1:
474 i.log2_scale_factor = 0;
475 break;
476 case 2:
477 i.log2_scale_factor = 1;
478 break;
479 case 4:
480 i.log2_scale_factor = 2;
481 break;
482 case 8:
483 i.log2_scale_factor = 3;
484 break;
485 default:
486 /* esp is invalid as index */
487 intel_state.index = i386_regtab + REGNAM_EAX + ESP_REG_NUM;
488 break;
489 }
490
491 break;
492 }
493 goto fallthrough;
494
495 case O_register:
496 ret = i386_intel_simplify_register (e);
497 if (ret == 2)
498 {
499 gas_assert (e->X_add_number < (unsigned short) -1);
500 e->X_md = (unsigned short) e->X_add_number + 1;
501 e->X_op = O_constant;
502 e->X_add_number = 0;
503 }
504 return ret;
505
506 case O_constant:
507 if (e->X_md)
508 return i386_intel_simplify_register (e);
509
510 /* FALLTHROUGH */
511 default:
512 fallthrough:
513 if (e->X_add_symbol
514 && !i386_intel_simplify_symbol (e->X_add_symbol))
515 return 0;
516 if (e->X_op == O_add || e->X_op == O_subtract)
517 {
518 base = intel_state.base;
519 state_index = intel_state.index;
520 }
521 if (!i386_intel_check (the_reg, base, state_index)
522 || (e->X_op_symbol
523 && !i386_intel_simplify_symbol (e->X_op_symbol))
524 || !i386_intel_check (the_reg,
525 (e->X_op != O_add
526 ? base : intel_state.base),
527 (e->X_op != O_add
528 ? state_index : intel_state.index)))
529 return 0;
530 break;
531 }
532
533 if (this_operand >= 0
534 && e->X_op == O_symbol
535 && !intel_state.in_offset)
536 {
537 segT seg = S_GET_SEGMENT (e->X_add_symbol);
538
539 if (seg != absolute_section
540 && seg != reg_section
541 && seg != expr_section)
542 intel_state.is_mem |= 2 - !intel_state.in_bracket;
543 }
544
545 return 1;
546 }
547
i386_need_index_operator(void)548 int i386_need_index_operator (void)
549 {
550 return intel_syntax < 0;
551 }
552
553 static int
i386_intel_operand(char * operand_string,int got_a_float)554 i386_intel_operand (char *operand_string, int got_a_float)
555 {
556 char *saved_input_line_pointer, *buf;
557 segT exp_seg;
558 expressionS exp, *expP;
559 char suffix = 0;
560 int ret;
561
562 /* Handle vector immediates. */
563 if (RC_SAE_immediate (operand_string))
564 return 1;
565
566 /* Initialize state structure. */
567 intel_state.op_modifier = O_absent;
568 intel_state.is_mem = 0;
569 intel_state.is_indirect = 0;
570 intel_state.has_offset = 0;
571 intel_state.base = NULL;
572 intel_state.index = NULL;
573 intel_state.seg = NULL;
574 operand_type_set (&intel_state.reloc_types, ~0);
575 gas_assert (!intel_state.in_offset);
576 gas_assert (!intel_state.in_bracket);
577 gas_assert (!intel_state.in_scale);
578
579 saved_input_line_pointer = input_line_pointer;
580 input_line_pointer = buf = xstrdup (operand_string);
581
582 intel_syntax = -1;
583 memset (&exp, 0, sizeof(exp));
584 exp_seg = expression (&exp);
585 ret = i386_intel_simplify (&exp);
586 intel_syntax = 1;
587
588 SKIP_WHITESPACE ();
589
590 /* Handle vector operations. */
591 if (*input_line_pointer == '{')
592 {
593 char *end = check_VecOperations (input_line_pointer, NULL);
594 if (end)
595 input_line_pointer = end;
596 else
597 ret = 0;
598 }
599
600 if (!is_end_of_line[(unsigned char) *input_line_pointer])
601 {
602 if (ret)
603 as_bad (_("junk `%s' after expression"), input_line_pointer);
604 ret = 0;
605 }
606 else if (exp.X_op == O_illegal || exp.X_op == O_absent)
607 {
608 if (ret)
609 as_bad (_("invalid expression"));
610 ret = 0;
611 }
612 else if (!intel_state.has_offset
613 && input_line_pointer > buf
614 && *(input_line_pointer - 1) == ']')
615 {
616 intel_state.is_mem |= 1;
617 intel_state.is_indirect = 1;
618 }
619
620 input_line_pointer = saved_input_line_pointer;
621 free (buf);
622
623 gas_assert (!intel_state.in_offset);
624 gas_assert (!intel_state.in_bracket);
625 gas_assert (!intel_state.in_scale);
626
627 if (!ret)
628 return 0;
629
630 if (intel_state.op_modifier != O_absent
631 && current_templates->start->base_opcode != 0x8d /* lea */)
632 {
633 i.types[this_operand].bitfield.unspecified = 0;
634
635 switch (intel_state.op_modifier)
636 {
637 case O_byte_ptr:
638 i.types[this_operand].bitfield.byte = 1;
639 suffix = BYTE_MNEM_SUFFIX;
640 break;
641
642 case O_word_ptr:
643 i.types[this_operand].bitfield.word = 1;
644 if (got_a_float == 2) /* "fi..." */
645 suffix = SHORT_MNEM_SUFFIX;
646 else
647 suffix = WORD_MNEM_SUFFIX;
648 break;
649
650 case O_dword_ptr:
651 i.types[this_operand].bitfield.dword = 1;
652 if ((current_templates->start->name[0] == 'l'
653 && current_templates->start->name[2] == 's'
654 && current_templates->start->name[3] == 0)
655 || current_templates->start->base_opcode == 0x62 /* bound */)
656 suffix = WORD_MNEM_SUFFIX;
657 else if (flag_code != CODE_32BIT
658 && (current_templates->start->opcode_modifier.jump == JUMP
659 || current_templates->start->opcode_modifier.jump
660 == JUMP_DWORD))
661 suffix = flag_code == CODE_16BIT ? LONG_DOUBLE_MNEM_SUFFIX
662 : WORD_MNEM_SUFFIX;
663 else if (got_a_float == 1) /* "f..." */
664 suffix = SHORT_MNEM_SUFFIX;
665 else
666 suffix = LONG_MNEM_SUFFIX;
667 break;
668
669 case O_fword_ptr:
670 i.types[this_operand].bitfield.fword = 1;
671 if (current_templates->start->name[0] == 'l'
672 && current_templates->start->name[2] == 's'
673 && current_templates->start->name[3] == 0)
674 suffix = LONG_MNEM_SUFFIX;
675 else if (!got_a_float)
676 {
677 if (flag_code == CODE_16BIT)
678 add_prefix (DATA_PREFIX_OPCODE);
679 suffix = LONG_DOUBLE_MNEM_SUFFIX;
680 }
681 break;
682
683 case O_qword_ptr: /* O_mmword_ptr */
684 i.types[this_operand].bitfield.qword = 1;
685 if (current_templates->start->base_opcode == 0x62 /* bound */
686 || got_a_float == 1) /* "f..." */
687 suffix = LONG_MNEM_SUFFIX;
688 else
689 suffix = QWORD_MNEM_SUFFIX;
690 break;
691
692 case O_tbyte_ptr:
693 i.types[this_operand].bitfield.tbyte = 1;
694 if (got_a_float == 1)
695 suffix = LONG_DOUBLE_MNEM_SUFFIX;
696 else if ((current_templates->start->operand_types[0].bitfield.fword
697 || current_templates->start->operand_types[0].bitfield.tbyte)
698 && flag_code == CODE_64BIT)
699 suffix = QWORD_MNEM_SUFFIX; /* l[fgs]s, [ls][gi]dt */
700 else
701 i.types[this_operand].bitfield.byte = 1; /* cause an error */
702 break;
703
704 case O_oword_ptr: /* O_xmmword_ptr */
705 i.types[this_operand].bitfield.xmmword = 1;
706 break;
707
708 case O_ymmword_ptr:
709 i.types[this_operand].bitfield.ymmword = 1;
710 break;
711
712 case O_zmmword_ptr:
713 i.types[this_operand].bitfield.zmmword = 1;
714 break;
715
716 case O_far_ptr:
717 suffix = LONG_DOUBLE_MNEM_SUFFIX;
718 /* FALLTHROUGH */
719 case O_near_ptr:
720 if (current_templates->start->opcode_modifier.jump != JUMP
721 && current_templates->start->opcode_modifier.jump != JUMP_DWORD)
722 {
723 /* cause an error */
724 i.types[this_operand].bitfield.byte = 1;
725 i.types[this_operand].bitfield.tbyte = 1;
726 suffix = i.suffix;
727 }
728 break;
729
730 default:
731 BAD_CASE (intel_state.op_modifier);
732 break;
733 }
734
735 if (!i.suffix)
736 i.suffix = suffix;
737 else if (i.suffix != suffix)
738 {
739 as_bad (_("conflicting operand size modifiers"));
740 return 0;
741 }
742 }
743
744 /* Operands for jump/call need special consideration. */
745 if (current_templates->start->opcode_modifier.jump == JUMP
746 || current_templates->start->opcode_modifier.jump == JUMP_DWORD
747 || current_templates->start->opcode_modifier.jump == JUMP_INTERSEGMENT)
748 {
749 bfd_boolean jumpabsolute = FALSE;
750
751 if (i.op[this_operand].regs
752 || intel_state.base
753 || intel_state.index
754 || intel_state.is_mem > 1)
755 jumpabsolute = TRUE;
756 else
757 switch (intel_state.op_modifier)
758 {
759 case O_near_ptr:
760 if (intel_state.seg)
761 jumpabsolute = TRUE;
762 else
763 intel_state.is_mem = 1;
764 break;
765 case O_far_ptr:
766 case O_absent:
767 if (!intel_state.seg)
768 {
769 intel_state.is_mem = 1;
770 if (intel_state.op_modifier == O_absent)
771 {
772 if (intel_state.is_indirect == 1)
773 jumpabsolute = TRUE;
774 break;
775 }
776 as_bad (_("cannot infer the segment part of the operand"));
777 return 0;
778 }
779 else if (S_GET_SEGMENT (intel_state.seg) == reg_section)
780 jumpabsolute = TRUE;
781 else
782 {
783 i386_operand_type types;
784
785 if (i.imm_operands >= MAX_IMMEDIATE_OPERANDS)
786 {
787 as_bad (_("at most %d immediate operands are allowed"),
788 MAX_IMMEDIATE_OPERANDS);
789 return 0;
790 }
791 expP = &im_expressions[i.imm_operands++];
792 memset (expP, 0, sizeof(*expP));
793 expP->X_op = O_symbol;
794 expP->X_add_symbol = intel_state.seg;
795 i.op[this_operand].imms = expP;
796
797 resolve_expression (expP);
798 operand_type_set (&types, ~0);
799 if (!i386_finalize_immediate (S_GET_SEGMENT (intel_state.seg),
800 expP, types, operand_string))
801 return 0;
802 if (i.operands < MAX_OPERANDS)
803 {
804 this_operand = i.operands++;
805 i.types[this_operand].bitfield.unspecified = 1;
806 }
807 if (suffix == LONG_DOUBLE_MNEM_SUFFIX)
808 i.suffix = 0;
809 intel_state.seg = NULL;
810 intel_state.is_mem = 0;
811 }
812 break;
813 default:
814 jumpabsolute = TRUE;
815 break;
816 }
817 if (jumpabsolute)
818 {
819 i.jumpabsolute = TRUE;
820 intel_state.is_mem |= 1;
821 }
822 }
823 else if (intel_state.seg)
824 intel_state.is_mem |= 1;
825
826 if (i.op[this_operand].regs)
827 {
828 i386_operand_type temp;
829
830 /* Register operand. */
831 if (intel_state.base || intel_state.index || intel_state.seg)
832 {
833 as_bad (_("invalid operand"));
834 return 0;
835 }
836
837 temp = i.op[this_operand].regs->reg_type;
838 temp.bitfield.baseindex = 0;
839 i.types[this_operand] = operand_type_or (i.types[this_operand],
840 temp);
841 i.types[this_operand].bitfield.unspecified = 0;
842 ++i.reg_operands;
843 }
844 else if (intel_state.base
845 || intel_state.index
846 || intel_state.seg
847 || intel_state.is_mem)
848 {
849 /* Memory operand. */
850 if (i.mem_operands == 1 && !maybe_adjust_templates ())
851 return 0;
852 if ((int) i.mem_operands
853 >= 2 - !current_templates->start->opcode_modifier.isstring)
854 {
855 /* Handle
856
857 call 0x9090,0x90909090
858 lcall 0x9090,0x90909090
859 jmp 0x9090,0x90909090
860 ljmp 0x9090,0x90909090
861 */
862
863 if ((current_templates->start->opcode_modifier.jump == JUMP_INTERSEGMENT
864 || current_templates->start->opcode_modifier.jump == JUMP_DWORD
865 || current_templates->start->opcode_modifier.jump == JUMP)
866 && this_operand == 1
867 && intel_state.seg == NULL
868 && i.mem_operands == 1
869 && i.disp_operands == 1
870 && intel_state.op_modifier == O_absent)
871 {
872 /* Try to process the first operand as immediate, */
873 this_operand = 0;
874 if (i386_finalize_immediate (exp_seg, i.op[0].imms,
875 intel_state.reloc_types,
876 NULL))
877 {
878 this_operand = 1;
879 expP = &im_expressions[0];
880 i.op[this_operand].imms = expP;
881 *expP = exp;
882
883 /* Try to process the second operand as immediate, */
884 if (i386_finalize_immediate (exp_seg, expP,
885 intel_state.reloc_types,
886 NULL))
887 {
888 i.mem_operands = 0;
889 i.disp_operands = 0;
890 i.imm_operands = 2;
891 i.flags[0] &= ~Operand_Mem;
892 i.types[0].bitfield.disp16 = 0;
893 i.types[0].bitfield.disp32 = 0;
894 i.types[0].bitfield.disp32s = 0;
895 return 1;
896 }
897 }
898 }
899
900 as_bad (_("too many memory references for `%s'"),
901 current_templates->start->name);
902 return 0;
903 }
904
905 /* Swap base and index in 16-bit memory operands like
906 [si+bx]. Since i386_index_check is also used in AT&T
907 mode we have to do this here. */
908 if (intel_state.base
909 && intel_state.index
910 && intel_state.base->reg_type.bitfield.word
911 && intel_state.index->reg_type.bitfield.word
912 && intel_state.base->reg_num >= 6
913 && intel_state.index->reg_num < 6)
914 {
915 i.base_reg = intel_state.index;
916 i.index_reg = intel_state.base;
917 }
918 else
919 {
920 i.base_reg = intel_state.base;
921 i.index_reg = intel_state.index;
922 }
923
924 if (i.base_reg || i.index_reg)
925 i.types[this_operand].bitfield.baseindex = 1;
926
927 expP = &disp_expressions[i.disp_operands];
928 memcpy (expP, &exp, sizeof(exp));
929 resolve_expression (expP);
930
931 if (expP->X_op != O_constant
932 || expP->X_add_number
933 || !i.types[this_operand].bitfield.baseindex)
934 {
935 i.op[this_operand].disps = expP;
936 i.disp_operands++;
937
938 i386_addressing_mode ();
939
940 if (flag_code == CODE_64BIT)
941 {
942 if (!i.prefix[ADDR_PREFIX])
943 {
944 i.types[this_operand].bitfield.disp64 = 1;
945 i.types[this_operand].bitfield.disp32s = 1;
946 }
947 else
948 i.types[this_operand].bitfield.disp32 = 1;
949 }
950 else if (!i.prefix[ADDR_PREFIX] ^ (flag_code == CODE_16BIT))
951 i.types[this_operand].bitfield.disp32 = 1;
952 else
953 i.types[this_operand].bitfield.disp16 = 1;
954
955 #if defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT)
956 /*
957 * exp_seg is used only for verification in
958 * i386_finalize_displacement, and we can end up seeing reg_section
959 * here - but we know we removed all registers from the expression
960 * (or error-ed on any remaining ones) in i386_intel_simplify. I
961 * consider the check in i386_finalize_displacement bogus anyway, in
962 * particular because it doesn't allow for expr_section, so I'd
963 * rather see that check (and the similar one in
964 * i386_finalize_immediate) use SEG_NORMAL(), but not being an a.out
965 * expert I can't really say whether that would have other bad side
966 * effects.
967 */
968 if (OUTPUT_FLAVOR == bfd_target_aout_flavour
969 && exp_seg == reg_section)
970 exp_seg = expP->X_op != O_constant ? undefined_section
971 : absolute_section;
972 #endif
973
974 if (!i386_finalize_displacement (exp_seg, expP,
975 intel_state.reloc_types,
976 operand_string))
977 return 0;
978 }
979
980 if (intel_state.seg)
981 {
982 for (ret = check_none; ; ret = operand_check)
983 {
984 expP = symbol_get_value_expression (intel_state.seg);
985 if (expP->X_op != O_full_ptr
986 || symbol_get_value_expression (expP->X_op_symbol)->X_op
987 != O_register)
988 break;
989 intel_state.seg = expP->X_add_symbol;
990 }
991 if (expP->X_op != O_register)
992 {
993 as_bad (_("segment register name expected"));
994 return 0;
995 }
996 if (i386_regtab[expP->X_add_number].reg_type.bitfield.class != SReg)
997 {
998 as_bad (_("invalid use of register"));
999 return 0;
1000 }
1001 switch (ret)
1002 {
1003 case check_error:
1004 as_bad (_("redundant segment overrides"));
1005 return 0;
1006 case check_warning:
1007 as_warn (_("redundant segment overrides"));
1008 break;
1009 }
1010 switch (i386_regtab[expP->X_add_number].reg_num)
1011 {
1012 case 0: i.seg[i.mem_operands] = &es; break;
1013 case 1: i.seg[i.mem_operands] = &cs; break;
1014 case 2: i.seg[i.mem_operands] = &ss; break;
1015 case 3: i.seg[i.mem_operands] = &ds; break;
1016 case 4: i.seg[i.mem_operands] = &fs; break;
1017 case 5: i.seg[i.mem_operands] = &gs; break;
1018 case RegFlat: i.seg[i.mem_operands] = NULL; break;
1019 }
1020 }
1021
1022 if (!i386_index_check (operand_string))
1023 return 0;
1024
1025 i.flags[this_operand] |= Operand_Mem;
1026 if (i.mem_operands == 0)
1027 i.memop1_string = xstrdup (operand_string);
1028 ++i.mem_operands;
1029 }
1030 else
1031 {
1032 /* Immediate. */
1033 if (i.imm_operands >= MAX_IMMEDIATE_OPERANDS)
1034 {
1035 as_bad (_("at most %d immediate operands are allowed"),
1036 MAX_IMMEDIATE_OPERANDS);
1037 return 0;
1038 }
1039
1040 expP = &im_expressions[i.imm_operands++];
1041 i.op[this_operand].imms = expP;
1042 *expP = exp;
1043
1044 return i386_finalize_immediate (exp_seg, expP, intel_state.reloc_types,
1045 operand_string);
1046 }
1047
1048 return 1;
1049 }
1050