projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* emultempl/alphaelf.em: Format option help.
[deliverable/binutils-gdb.git] / gas / config / tc-i386.c
CommitLineData
b534c6d3 1/* tc-i386.c -- Assemble code for the Intel 80386
f7e42eb4 2 Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4dc85607 3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
47926f60 4 Free Software Foundation, Inc.
252b5132
RH		 5
6 This file is part of GAS, the GNU Assembler.
7
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
ec2655a6 10 the Free Software Foundation; either version 3, or (at your option)
252b5132
RH		 11 any later version.
12
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
4b4da160
NC		 20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
252b5132 22
47926f60
KH		 23/* Intel 80386 machine specific gas.
24 Written by Eliot Dresselhaus (eliot@mgm.mit.edu).
3e73aa7c 25 x86_64 support by Jan Hubicka (jh@suse.cz)
0f10071e 26 VIA PadLock support by Michal Ludvig (mludvig@suse.cz)
47926f60
KH		 27 Bugs & suggestions are completely welcome. This is free software.
28 Please help us make it better. */
252b5132 29
252b5132 30#include "as.h"
3882b010 31#include "safe-ctype.h"
252b5132 32#include "subsegs.h"
316e2c05 33#include "dwarf2dbg.h"
54cfded0 34#include "dw2gencfi.h"
d2b2c203 35#include "elf/x86-64.h"
252b5132 36
252b5132
RH		 37#ifndef REGISTER_WARNINGS
38#define REGISTER_WARNINGS 1
39#endif
40
c3332e24 41#ifndef INFER_ADDR_PREFIX
eecb386c 42#define INFER_ADDR_PREFIX 1
c3332e24
AM		 43#endif
44
252b5132
RH		 45#ifndef SCALE1_WHEN_NO_INDEX
46/* Specifying a scale factor besides 1 when there is no index is
47 futile. eg. `mov (%ebx,2),%al' does exactly the same as
48 `mov (%ebx),%al'. To slavishly follow what the programmer
49 specified, set SCALE1_WHEN_NO_INDEX to 0. */
50#define SCALE1_WHEN_NO_INDEX 1
51#endif
52
29b0f896
AM		 53#ifndef DEFAULT_ARCH
54#define DEFAULT_ARCH "i386"
246fcdee 55#endif
252b5132 56
edde18a5
AM		 57#ifndef INLINE
58#if __GNUC__ >= 2
59#define INLINE __inline__
60#else
61#define INLINE
62#endif
63#endif
64
e3bb37b5
L		 65static void set_code_flag (int);
66static void set_16bit_gcc_code_flag (int);
67static void set_intel_syntax (int);
68static void set_cpu_arch (int);
6482c264 69#ifdef TE_PE
e3bb37b5 70static void pe_directive_secrel (int);
6482c264 71#endif
e3bb37b5
L		 72static void signed_cons (int);
73static char *output_invalid (int c);
74static int i386_operand (char *);
75static int i386_intel_operand (char *, int);
76static const reg_entry *parse_register (char *, char **);
77static char *parse_insn (char *, char *);
78static char *parse_operands (char *, const char *);
79static void swap_operands (void);
4d456e3d 80static void swap_2_operands (int, int);
e3bb37b5
L		 81static void optimize_imm (void);
82static void optimize_disp (void);
83static int match_template (void);
84static int check_string (void);
85static int process_suffix (void);
86static int check_byte_reg (void);
87static int check_long_reg (void);
88static int check_qword_reg (void);
89static int check_word_reg (void);
90static int finalize_imm (void);
91static int process_operands (void);
92static const seg_entry *build_modrm_byte (void);
93static void output_insn (void);
94static void output_imm (fragS *, offsetT);
95static void output_disp (fragS *, offsetT);
29b0f896 96#ifndef I386COFF
e3bb37b5 97static void s_bss (int);
252b5132 98#endif
17d4e2a2
L		 99#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
100static void handle_large_common (int small ATTRIBUTE_UNUSED);
101#endif
252b5132 102
a847613f 103static const char *default_arch = DEFAULT_ARCH;
3e73aa7c 104
252b5132 105/* 'md_assemble ()' gathers together information and puts it into a
47926f60 106 i386_insn. */
252b5132 107
520dc8e8
AM		 108union i386_op
109 {
110 expressionS *disps;
111 expressionS *imms;
112 const reg_entry *regs;
113 };
114
252b5132
RH		 115struct _i386_insn
116 {
47926f60 117 /* TM holds the template for the insn were currently assembling. */
252b5132
RH		 118 template tm;
119
120 /* SUFFIX holds the instruction mnemonic suffix if given.
121 (e.g. 'l' for 'movl') */
122 char suffix;
123
47926f60 124 /* OPERANDS gives the number of given operands. */
252b5132
RH		 125 unsigned int operands;
126
127 /* REG_OPERANDS, DISP_OPERANDS, MEM_OPERANDS, IMM_OPERANDS give the number
128 of given register, displacement, memory operands and immediate
47926f60 129 operands. */
252b5132
RH		 130 unsigned int reg_operands, disp_operands, mem_operands, imm_operands;
131
132 /* TYPES [i] is the type (see above #defines) which tells us how to
520dc8e8 133 use OP[i] for the corresponding operand. */
252b5132
RH		 134 unsigned int types[MAX_OPERANDS];
135
520dc8e8
AM		 136 /* Displacement expression, immediate expression, or register for each
137 operand. */
138 union i386_op op[MAX_OPERANDS];
252b5132 139
3e73aa7c
JH		 140 /* Flags for operands. */
141 unsigned int flags[MAX_OPERANDS];
142#define Operand_PCrel 1
143
252b5132 144 /* Relocation type for operand */
f86103b7 145 enum bfd_reloc_code_real reloc[MAX_OPERANDS];
252b5132 146
252b5132
RH		 147 /* BASE_REG, INDEX_REG, and LOG2_SCALE_FACTOR are used to encode
148 the base index byte below. */
149 const reg_entry *base_reg;
150 const reg_entry *index_reg;
151 unsigned int log2_scale_factor;
152
153 /* SEG gives the seg_entries of this insn. They are zero unless
47926f60 154 explicit segment overrides are given. */
ce8a8b2f 155 const seg_entry *seg[2];
252b5132
RH		 156
157 /* PREFIX holds all the given prefix opcodes (usually null).
158 PREFIXES is the number of prefix opcodes. */
159 unsigned int prefixes;
160 unsigned char prefix[MAX_PREFIXES];
161
162 /* RM and SIB are the modrm byte and the sib byte where the
163 addressing modes of this insn are encoded. */
164
165 modrm_byte rm;
3e73aa7c 166 rex_byte rex;
252b5132
RH		 167 sib_byte sib;
168 };
169
170typedef struct _i386_insn i386_insn;
171
172/* List of chars besides those in app.c:symbol_chars that can start an
173 operand. Used to prevent the scrubber eating vital white-space. */
32137342 174const char extra_symbol_chars[] = "*%-(["
252b5132 175#ifdef LEX_AT
32137342
NC		 176 "@"
177#endif
178#ifdef LEX_QM
179 "?"
252b5132 180#endif
32137342 181 ;
252b5132 182
29b0f896
AM		 183#if (defined (TE_I386AIX) \
184 || ((defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)) \
3896cfd5 185 && !defined (TE_GNU) \
29b0f896 186 && !defined (TE_LINUX) \
32137342 187 && !defined (TE_NETWARE) \
29b0f896
AM		 188 && !defined (TE_FreeBSD) \
189 && !defined (TE_NetBSD)))
252b5132 190/* This array holds the chars that always start a comment. If the
b3b91714
AM		 191 pre-processor is disabled, these aren't very useful. The option
192 --divide will remove '/' from this list. */
193const char *i386_comment_chars = "#/";
194#define SVR4_COMMENT_CHARS 1
252b5132 195#define PREFIX_SEPARATOR '\\'
252b5132 196
b3b91714
AM		 197#else
198const char *i386_comment_chars = "#";
199#define PREFIX_SEPARATOR '/'
200#endif
201
252b5132
RH		 202/* This array holds the chars that only start a comment at the beginning of
203 a line. If the line seems to have the form '# 123 filename'
ce8a8b2f
AM		 204 .line and .file directives will appear in the pre-processed output.
205 Note that input_file.c hand checks for '#' at the beginning of the
252b5132 206 first line of the input file. This is because the compiler outputs
ce8a8b2f
AM		 207 #NO_APP at the beginning of its output.
208 Also note that comments started like this one will always work if
252b5132 209 '/' isn't otherwise defined. */
b3b91714 210const char line_comment_chars[] = "#/";
252b5132 211
63a0b638 212const char line_separator_chars[] = ";";
252b5132 213
ce8a8b2f
AM		 214/* Chars that can be used to separate mant from exp in floating point
215 nums. */
252b5132
RH		 216const char EXP_CHARS[] = "eE";
217
ce8a8b2f
AM		 218/* Chars that mean this number is a floating point constant
219 As in 0f12.456
220 or 0d1.2345e12. */
252b5132
RH		 221const char FLT_CHARS[] = "fFdDxX";
222
ce8a8b2f 223/* Tables for lexical analysis. */
252b5132
RH		 224static char mnemonic_chars[256];
225static char register_chars[256];
226static char operand_chars[256];
227static char identifier_chars[256];
228static char digit_chars[256];
229
ce8a8b2f 230/* Lexical macros. */
252b5132
RH		 231#define is_mnemonic_char(x) (mnemonic_chars[(unsigned char) x])
232#define is_operand_char(x) (operand_chars[(unsigned char) x])
233#define is_register_char(x) (register_chars[(unsigned char) x])
234#define is_space_char(x) ((x) == ' ')
235#define is_identifier_char(x) (identifier_chars[(unsigned char) x])
236#define is_digit_char(x) (digit_chars[(unsigned char) x])
237
0234cb7c 238/* All non-digit non-letter characters that may occur in an operand. */
252b5132
RH		 239static char operand_special_chars[] = "%$-+(,)*._~/<>|&^!:[@]";
240
241/* md_assemble() always leaves the strings it's passed unaltered. To
242 effect this we maintain a stack of saved characters that we've smashed
243 with '\0's (indicating end of strings for various sub-fields of the
47926f60 244 assembler instruction). */
252b5132 245static char save_stack[32];
ce8a8b2f 246static char *save_stack_p;
252b5132
RH		 247#define END_STRING_AND_SAVE(s) \
248 do { *save_stack_p++ = *(s); *(s) = '\0'; } while (0)
249#define RESTORE_END_STRING(s) \
250 do { *(s) = *--save_stack_p; } while (0)
251
47926f60 252/* The instruction we're assembling. */
252b5132
RH		 253static i386_insn i;
254
255/* Possible templates for current insn. */
256static const templates *current_templates;
257
31b2323c
L		 258/* Per instruction expressionS buffers: max displacements & immediates. */
259static expressionS disp_expressions[MAX_MEMORY_OPERANDS];
260static expressionS im_expressions[MAX_IMMEDIATE_OPERANDS];
252b5132 261
47926f60
KH		 262/* Current operand we are working on. */
263static int this_operand;
252b5132 264
3e73aa7c
JH		 265/* We support four different modes. FLAG_CODE variable is used to distinguish
266 these. */
267
268enum flag_code {
269 CODE_32BIT,
270 CODE_16BIT,
271 CODE_64BIT };
f3c180ae 272#define NUM_FLAG_CODE ((int) CODE_64BIT + 1)
3e73aa7c
JH		 273
274static enum flag_code flag_code;
4fa24527 275static unsigned int object_64bit;
3e73aa7c
JH		 276static int use_rela_relocations = 0;
277
278/* The names used to print error messages. */
b77a7acd 279static const char *flag_code_names[] =
3e73aa7c
JH		 280 {
281 "32",
282 "16",
283 "64"
284 };
252b5132 285
47926f60
KH		 286/* 1 for intel syntax,
287 0 if att syntax. */
288static int intel_syntax = 0;
252b5132 289
47926f60
KH		 290/* 1 if register prefix % not required. */
291static int allow_naked_reg = 0;
252b5132 292
2ca3ace5
L		 293/* Register prefix used for error message. */
294static const char *register_prefix = "%";
295
47926f60
KH		 296/* Used in 16 bit gcc mode to add an l suffix to call, ret, enter,
297 leave, push, and pop instructions so that gcc has the same stack
298 frame as in 32 bit mode. */
299static char stackop_size = '\0';
eecb386c 300
12b55ccc
L		 301/* Non-zero to optimize code alignment. */
302int optimize_align_code = 1;
303
47926f60
KH		 304/* Non-zero to quieten some warnings. */
305static int quiet_warnings = 0;
a38cf1db 306
47926f60
KH		 307/* CPU name. */
308static const char *cpu_arch_name = NULL;
5c6af06e 309static const char *cpu_sub_arch_name = NULL;
a38cf1db 310
47926f60 311/* CPU feature flags. */
29b0f896 312static unsigned int cpu_arch_flags = CpuUnknownFlags | CpuNo64;
a38cf1db 313
ccc9c027
L		 314/* If we have selected a cpu we are generating instructions for. */
315static int cpu_arch_tune_set = 0;
316
9103f4f4
L		 317/* Cpu we are generating instructions for. */
318static enum processor_type cpu_arch_tune = PROCESSOR_UNKNOWN;
319
320/* CPU feature flags of cpu we are generating instructions for. */
321static unsigned int cpu_arch_tune_flags = 0;
322
ccc9c027
L		 323/* CPU instruction set architecture used. */
324static enum processor_type cpu_arch_isa = PROCESSOR_UNKNOWN;
325
9103f4f4
L		 326/* CPU feature flags of instruction set architecture used. */
327static unsigned int cpu_arch_isa_flags = 0;
328
fddf5b5b
AM		 329/* If set, conditional jumps are not automatically promoted to handle
330 larger than a byte offset. */
331static unsigned int no_cond_jump_promotion = 0;
332
29b0f896 333/* Pre-defined "_GLOBAL_OFFSET_TABLE_". */
87c245cc 334static symbolS *GOT_symbol;
29b0f896 335
a4447b93
RH		 336/* The dwarf2 return column, adjusted for 32 or 64 bit. */
337unsigned int x86_dwarf2_return_column;
338
339/* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
340int x86_cie_data_alignment;
341
252b5132 342/* Interface to relax_segment.
fddf5b5b
AM		 343 There are 3 major relax states for 386 jump insns because the
344 different types of jumps add different sizes to frags when we're
345 figuring out what sort of jump to choose to reach a given label. */
252b5132 346
47926f60 347/* Types. */
93c2a809
AM		 348#define UNCOND_JUMP 0
349#define COND_JUMP 1
350#define COND_JUMP86 2
fddf5b5b 351
47926f60 352/* Sizes. */
252b5132
RH		 353#define CODE16 1
354#define SMALL 0
29b0f896 355#define SMALL16 (SMALL | CODE16)
252b5132 356#define BIG 2
29b0f896 357#define BIG16 (BIG | CODE16)
252b5132
RH		 358
359#ifndef INLINE
360#ifdef __GNUC__
361#define INLINE __inline__
362#else
363#define INLINE
364#endif
365#endif
366
fddf5b5b
AM		 367#define ENCODE_RELAX_STATE(type, size) \
368 ((relax_substateT) (((type) << 2) | (size)))
369#define TYPE_FROM_RELAX_STATE(s) \
370 ((s) >> 2)
371#define DISP_SIZE_FROM_RELAX_STATE(s) \
372 ((((s) & 3) == BIG ? 4 : (((s) & 3) == BIG16 ? 2 : 1)))
252b5132
RH		 373
374/* This table is used by relax_frag to promote short jumps to long
375 ones where necessary. SMALL (short) jumps may be promoted to BIG
376 (32 bit long) ones, and SMALL16 jumps to BIG16 (16 bit long). We
377 don't allow a short jump in a 32 bit code segment to be promoted to
378 a 16 bit offset jump because it's slower (requires data size
379 prefix), and doesn't work, unless the destination is in the bottom
380 64k of the code segment (The top 16 bits of eip are zeroed). */
381
382const relax_typeS md_relax_table[] =
383{
24eab124
AM		 384 /* The fields are:
385 1) most positive reach of this state,
386 2) most negative reach of this state,
93c2a809 387 3) how many bytes this mode will have in the variable part of the frag
ce8a8b2f 388 4) which index into the table to try if we can't fit into this one. */
252b5132 389
fddf5b5b 390 /* UNCOND_JUMP states. */
93c2a809
AM		 391 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG)},
392 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16)},
393 /* dword jmp adds 4 bytes to frag:
394 0 extra opcode bytes, 4 displacement bytes. */
252b5132 395 {0, 0, 4, 0},
93c2a809
AM		 396 /* word jmp adds 2 byte2 to frag:
397 0 extra opcode bytes, 2 displacement bytes. */
252b5132
RH		 398 {0, 0, 2, 0},
399
93c2a809
AM		 400 /* COND_JUMP states. */
401 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG)},
402 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP, BIG16)},
403 /* dword conditionals adds 5 bytes to frag:
404 1 extra opcode byte, 4 displacement bytes. */
405 {0, 0, 5, 0},
fddf5b5b 406 /* word conditionals add 3 bytes to frag:
93c2a809
AM		 407 1 extra opcode byte, 2 displacement bytes. */
408 {0, 0, 3, 0},
409
410 /* COND_JUMP86 states. */
411 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG)},
412 {127 + 1, -128 + 1, 1, ENCODE_RELAX_STATE (COND_JUMP86, BIG16)},
413 /* dword conditionals adds 5 bytes to frag:
414 1 extra opcode byte, 4 displacement bytes. */
415 {0, 0, 5, 0},
416 /* word conditionals add 4 bytes to frag:
417 1 displacement byte and a 3 byte long branch insn. */
418 {0, 0, 4, 0}
252b5132
RH		 419};
420
9103f4f4
L		 421static const arch_entry cpu_arch[] =
422{
423 {"generic32", PROCESSOR_GENERIC32,
d32cad65 424 Cpu186|Cpu286|Cpu386},
9103f4f4 425 {"generic64", PROCESSOR_GENERIC64,
d32cad65 426 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
9103f4f4
L		 427 |CpuMMX2|CpuSSE|CpuSSE2},
428 {"i8086", PROCESSOR_UNKNOWN,
d32cad65 429 0},
9103f4f4 430 {"i186", PROCESSOR_UNKNOWN,
d32cad65 431 Cpu186},
9103f4f4 432 {"i286", PROCESSOR_UNKNOWN,
d32cad65 433 Cpu186|Cpu286},
76bc74dc 434 {"i386", PROCESSOR_I386,
d32cad65 435 Cpu186|Cpu286|Cpu386},
9103f4f4 436 {"i486", PROCESSOR_I486,
d32cad65 437 Cpu186|Cpu286|Cpu386|Cpu486},
9103f4f4 438 {"i586", PROCESSOR_PENTIUM,
d32cad65 439 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586},
9103f4f4 440 {"i686", PROCESSOR_PENTIUMPRO,
d32cad65 441 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686},
9103f4f4 442 {"pentium", PROCESSOR_PENTIUM,
d32cad65 443 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586},
9103f4f4 444 {"pentiumpro",PROCESSOR_PENTIUMPRO,
d32cad65 445 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686},
9103f4f4 446 {"pentiumii", PROCESSOR_PENTIUMPRO,
d32cad65 447 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX},
9103f4f4 448 {"pentiumiii",PROCESSOR_PENTIUMPRO,
d32cad65 449 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuMMX|CpuMMX2|CpuSSE},
9103f4f4 450 {"pentium4", PROCESSOR_PENTIUM4,
d32cad65 451 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
9103f4f4
L		 452 |CpuMMX2|CpuSSE|CpuSSE2},
453 {"prescott", PROCESSOR_NOCONA,
d32cad65 454 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
9103f4f4
L		 455 |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
456 {"nocona", PROCESSOR_NOCONA,
d32cad65 457 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
9103f4f4 458 |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
ef05d495 459 {"yonah", PROCESSOR_CORE,
d32cad65 460 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
9103f4f4 461 |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
ef05d495 462 {"core", PROCESSOR_CORE,
d32cad65 463 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
ef05d495
L		 464 |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
465 {"merom", PROCESSOR_CORE2,
466 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
467 |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3},
468 {"core2", PROCESSOR_CORE2,
469 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuP4|CpuMMX
470 |CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3},
9103f4f4 471 {"k6", PROCESSOR_K6,
d32cad65 472 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX},
9103f4f4 473 {"k6_2", PROCESSOR_K6,
d32cad65 474 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|CpuK6|CpuMMX|Cpu3dnow},
9103f4f4 475 {"athlon", PROCESSOR_ATHLON,
d32cad65 476 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
9103f4f4
L		 477 |CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA},
478 {"sledgehammer", PROCESSOR_K8,
d32cad65 479 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
9103f4f4
L		 480 |CpuSledgehammer|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2},
481 {"opteron", PROCESSOR_K8,
d32cad65 482 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
9103f4f4
L		 483 |CpuSledgehammer|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2},
484 {"k8", PROCESSOR_K8,
d32cad65 485 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6
9103f4f4 486 |CpuSledgehammer|CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2},
050dfa73 487 {"amdfam10", PROCESSOR_AMDFAM10,
d32cad65
L		 488 Cpu186|Cpu286|Cpu386|Cpu486|Cpu586|Cpu686|CpuK6|CpuSledgehammer
489 |CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a
490 |CpuABM},
9103f4f4
L		 491 {".mmx", PROCESSOR_UNKNOWN,
492 CpuMMX},
493 {".sse", PROCESSOR_UNKNOWN,
494 CpuMMX|CpuMMX2|CpuSSE},
495 {".sse2", PROCESSOR_UNKNOWN,
496 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2},
497 {".sse3", PROCESSOR_UNKNOWN,
498 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3},
ef05d495
L		 499 {".ssse3", PROCESSOR_UNKNOWN,
500 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3},
42903f7f
L		 501 {".sse4.1", PROCESSOR_UNKNOWN,
502 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4_1},
381d071f
L		 503 {".sse4.2", PROCESSOR_UNKNOWN,
504 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4},
505 {".sse4", PROCESSOR_UNKNOWN,
506 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSSE3|CpuSSE4},
9103f4f4
L		 507 {".3dnow", PROCESSOR_UNKNOWN,
508 CpuMMX|Cpu3dnow},
509 {".3dnowa", PROCESSOR_UNKNOWN,
510 CpuMMX|CpuMMX2|Cpu3dnow|Cpu3dnowA},
511 {".padlock", PROCESSOR_UNKNOWN,
512 CpuPadLock},
513 {".pacifica", PROCESSOR_UNKNOWN,
514 CpuSVME},
515 {".svme", PROCESSOR_UNKNOWN,
050dfa73
MM		 516 CpuSVME},
517 {".sse4a", PROCESSOR_UNKNOWN,
518 CpuMMX|CpuMMX2|CpuSSE|CpuSSE2|CpuSSE3|CpuSSE4a},
519 {".abm", PROCESSOR_UNKNOWN,
520 CpuABM}
e413e4e9
AM		 521};
522
29b0f896
AM		 523const pseudo_typeS md_pseudo_table[] =
524{
525#if !defined(OBJ_AOUT) && !defined(USE_ALIGN_PTWO)
526 {"align", s_align_bytes, 0},
527#else
528 {"align", s_align_ptwo, 0},
529#endif
530 {"arch", set_cpu_arch, 0},
531#ifndef I386COFF
532 {"bss", s_bss, 0},
533#endif
534 {"ffloat", float_cons, 'f'},
535 {"dfloat", float_cons, 'd'},
536 {"tfloat", float_cons, 'x'},
537 {"value", cons, 2},
d182319b 538 {"slong", signed_cons, 4},
29b0f896
AM		 539 {"noopt", s_ignore, 0},
540 {"optim", s_ignore, 0},
541 {"code16gcc", set_16bit_gcc_code_flag, CODE_16BIT},
542 {"code16", set_code_flag, CODE_16BIT},
543 {"code32", set_code_flag, CODE_32BIT},
544 {"code64", set_code_flag, CODE_64BIT},
545 {"intel_syntax", set_intel_syntax, 1},
546 {"att_syntax", set_intel_syntax, 0},
3b22753a
L		 547#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
548 {"largecomm", handle_large_common, 0},
07a53e5c 549#else
e3bb37b5 550 {"file", (void (*) (int)) dwarf2_directive_file, 0},
07a53e5c
RH		 551 {"loc", dwarf2_directive_loc, 0},
552 {"loc_mark_labels", dwarf2_directive_loc_mark_labels, 0},
3b22753a 553#endif
6482c264
NC		 554#ifdef TE_PE
555 {"secrel32", pe_directive_secrel, 0},
556#endif
29b0f896
AM		 557 {0, 0, 0}
558};
559
560/* For interface with expression (). */
561extern char *input_line_pointer;
562
563/* Hash table for instruction mnemonic lookup. */
564static struct hash_control *op_hash;
565
566/* Hash table for register lookup. */
567static struct hash_control *reg_hash;
568\f
252b5132 569void
e3bb37b5 570i386_align_code (fragS *fragP, int count)
252b5132 571{
ce8a8b2f
AM		 572 /* Various efficient no-op patterns for aligning code labels.
573 Note: Don't try to assemble the instructions in the comments.
574 0L and 0w are not legal. */
252b5132
RH		 575 static const char f32_1[] =
576 {0x90}; /* nop */
577 static const char f32_2[] =
ccc9c027 578 {0x66,0x90}; /* xchg %ax,%ax */
252b5132
RH		 579 static const char f32_3[] =
580 {0x8d,0x76,0x00}; /* leal 0(%esi),%esi */
581 static const char f32_4[] =
582 {0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */
583 static const char f32_5[] =
584 {0x90, /* nop */
585 0x8d,0x74,0x26,0x00}; /* leal 0(%esi,1),%esi */
586 static const char f32_6[] =
587 {0x8d,0xb6,0x00,0x00,0x00,0x00}; /* leal 0L(%esi),%esi */
588 static const char f32_7[] =
589 {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
590 static const char f32_8[] =
591 {0x90, /* nop */
592 0x8d,0xb4,0x26,0x00,0x00,0x00,0x00}; /* leal 0L(%esi,1),%esi */
593 static const char f32_9[] =
594 {0x89,0xf6, /* movl %esi,%esi */
595 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
596 static const char f32_10[] =
597 {0x8d,0x76,0x00, /* leal 0(%esi),%esi */
598 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
599 static const char f32_11[] =
600 {0x8d,0x74,0x26,0x00, /* leal 0(%esi,1),%esi */
601 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
602 static const char f32_12[] =
603 {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */
604 0x8d,0xbf,0x00,0x00,0x00,0x00}; /* leal 0L(%edi),%edi */
605 static const char f32_13[] =
606 {0x8d,0xb6,0x00,0x00,0x00,0x00, /* leal 0L(%esi),%esi */
607 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
608 static const char f32_14[] =
609 {0x8d,0xb4,0x26,0x00,0x00,0x00,0x00, /* leal 0L(%esi,1),%esi */
610 0x8d,0xbc,0x27,0x00,0x00,0x00,0x00}; /* leal 0L(%edi,1),%edi */
c3332e24
AM		 611 static const char f16_3[] =
612 {0x8d,0x74,0x00}; /* lea 0(%esi),%esi */
252b5132
RH		 613 static const char f16_4[] =
614 {0x8d,0xb4,0x00,0x00}; /* lea 0w(%si),%si */
615 static const char f16_5[] =
616 {0x90, /* nop */
617 0x8d,0xb4,0x00,0x00}; /* lea 0w(%si),%si */
618 static const char f16_6[] =
619 {0x89,0xf6, /* mov %si,%si */
620 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
621 static const char f16_7[] =
622 {0x8d,0x74,0x00, /* lea 0(%si),%si */
623 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
624 static const char f16_8[] =
625 {0x8d,0xb4,0x00,0x00, /* lea 0w(%si),%si */
626 0x8d,0xbd,0x00,0x00}; /* lea 0w(%di),%di */
76bc74dc
L		 627 static const char jump_31[] =
628 {0xeb,0x1d,0x90,0x90,0x90,0x90,0x90, /* jmp .+31; lotsa nops */
629 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
630 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90,
631 0x90,0x90,0x90,0x90,0x90,0x90,0x90,0x90};
252b5132
RH		 632 static const char *const f32_patt[] = {
633 f32_1, f32_2, f32_3, f32_4, f32_5, f32_6, f32_7, f32_8,
76bc74dc 634 f32_9, f32_10, f32_11, f32_12, f32_13, f32_14
252b5132
RH		 635 };
636 static const char *const f16_patt[] = {
76bc74dc 637 f32_1, f32_2, f16_3, f16_4, f16_5, f16_6, f16_7, f16_8
252b5132 638 };
ccc9c027
L		 639 /* nopl (%[re]ax) */
640 static const char alt_3[] =
641 {0x0f,0x1f,0x00};
642 /* nopl 0(%[re]ax) */
643 static const char alt_4[] =
644 {0x0f,0x1f,0x40,0x00};
645 /* nopl 0(%[re]ax,%[re]ax,1) */
646 static const char alt_5[] =
647 {0x0f,0x1f,0x44,0x00,0x00};
648 /* nopw 0(%[re]ax,%[re]ax,1) */
649 static const char alt_6[] =
650 {0x66,0x0f,0x1f,0x44,0x00,0x00};
651 /* nopl 0L(%[re]ax) */
652 static const char alt_7[] =
653 {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
654 /* nopl 0L(%[re]ax,%[re]ax,1) */
655 static const char alt_8[] =
656 {0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
657 /* nopw 0L(%[re]ax,%[re]ax,1) */
658 static const char alt_9[] =
659 {0x66,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
660 /* nopw %cs:0L(%[re]ax,%[re]ax,1) */
661 static const char alt_10[] =
662 {0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
663 /* data16
664 nopw %cs:0L(%[re]ax,%[re]ax,1) */
665 static const char alt_long_11[] =
666 {0x66,
667 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
668 /* data16
669 data16
670 nopw %cs:0L(%[re]ax,%[re]ax,1) */
671 static const char alt_long_12[] =
672 {0x66,
673 0x66,
674 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
675 /* data16
676 data16
677 data16
678 nopw %cs:0L(%[re]ax,%[re]ax,1) */
679 static const char alt_long_13[] =
680 {0x66,
681 0x66,
682 0x66,
683 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
684 /* data16
685 data16
686 data16
687 data16
688 nopw %cs:0L(%[re]ax,%[re]ax,1) */
689 static const char alt_long_14[] =
690 {0x66,
691 0x66,
692 0x66,
693 0x66,
694 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
695 /* data16
696 data16
697 data16
698 data16
699 data16
700 nopw %cs:0L(%[re]ax,%[re]ax,1) */
701 static const char alt_long_15[] =
702 {0x66,
703 0x66,
704 0x66,
705 0x66,
706 0x66,
707 0x66,0x2e,0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
708 /* nopl 0(%[re]ax,%[re]ax,1)
709 nopw 0(%[re]ax,%[re]ax,1) */
710 static const char alt_short_11[] =
711 {0x0f,0x1f,0x44,0x00,0x00,
712 0x66,0x0f,0x1f,0x44,0x00,0x00};
713 /* nopw 0(%[re]ax,%[re]ax,1)
714 nopw 0(%[re]ax,%[re]ax,1) */
715 static const char alt_short_12[] =
716 {0x66,0x0f,0x1f,0x44,0x00,0x00,
717 0x66,0x0f,0x1f,0x44,0x00,0x00};
718 /* nopw 0(%[re]ax,%[re]ax,1)
719 nopl 0L(%[re]ax) */
720 static const char alt_short_13[] =
721 {0x66,0x0f,0x1f,0x44,0x00,0x00,
722 0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
723 /* nopl 0L(%[re]ax)
724 nopl 0L(%[re]ax) */
725 static const char alt_short_14[] =
726 {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
727 0x0f,0x1f,0x80,0x00,0x00,0x00,0x00};
728 /* nopl 0L(%[re]ax)
729 nopl 0L(%[re]ax,%[re]ax,1) */
730 static const char alt_short_15[] =
731 {0x0f,0x1f,0x80,0x00,0x00,0x00,0x00,
732 0x0f,0x1f,0x84,0x00,0x00,0x00,0x00,0x00};
733 static const char *const alt_short_patt[] = {
734 f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
735 alt_9, alt_10, alt_short_11, alt_short_12, alt_short_13,
736 alt_short_14, alt_short_15
737 };
738 static const char *const alt_long_patt[] = {
739 f32_1, f32_2, alt_3, alt_4, alt_5, alt_6, alt_7, alt_8,
740 alt_9, alt_10, alt_long_11, alt_long_12, alt_long_13,
741 alt_long_14, alt_long_15
742 };
252b5132 743
76bc74dc
L		 744 /* Only align for at least a positive non-zero boundary. */
745 if (count <= 0 || count > MAX_MEM_FOR_RS_ALIGN_CODE)
33fef721 746 return;
3e73aa7c 747
ccc9c027
L		 748 /* We need to decide which NOP sequence to use for 32bit and
749 64bit. When -mtune= is used:
4eed87de 750
76bc74dc
L		 751 1. For PROCESSOR_I386, PROCESSOR_I486, PROCESSOR_PENTIUM and
752 PROCESSOR_GENERIC32, f32_patt will be used.
753 2. For PROCESSOR_PENTIUMPRO, PROCESSOR_PENTIUM4, PROCESSOR_NOCONA,
754 PROCESSOR_CORE, PROCESSOR_CORE2, and PROCESSOR_GENERIC64,
755 alt_long_patt will be used.
756 3. For PROCESSOR_ATHLON, PROCESSOR_K6, PROCESSOR_K8 and
757 PROCESSOR_AMDFAM10, alt_short_patt will be used.
ccc9c027 758
76bc74dc
L		 759 When -mtune= isn't used, alt_long_patt will be used if
760 cpu_arch_isa_flags has Cpu686. Otherwise, f32_patt will
761 be used.
ccc9c027
L		 762
763 When -march= or .arch is used, we can't use anything beyond
764 cpu_arch_isa_flags. */
765
766 if (flag_code == CODE_16BIT)
767 {
ccc9c027 768 if (count > 8)
33fef721 769 {
76bc74dc
L		 770 memcpy (fragP->fr_literal + fragP->fr_fix,
771 jump_31, count);
772 /* Adjust jump offset. */
773 fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
252b5132 774 }
76bc74dc
L		 775 else
776 memcpy (fragP->fr_literal + fragP->fr_fix,
777 f16_patt[count - 1], count);
252b5132 778 }
33fef721 779 else
ccc9c027
L		 780 {
781 const char *const *patt = NULL;
782
783 if (cpu_arch_isa == PROCESSOR_UNKNOWN)
784 {
785 /* PROCESSOR_UNKNOWN means that all ISAs may be used. */
786 switch (cpu_arch_tune)
787 {
788 case PROCESSOR_UNKNOWN:
789 /* We use cpu_arch_isa_flags to check if we SHOULD
790 optimize for Cpu686. */
791 if ((cpu_arch_isa_flags & Cpu686) != 0)
76bc74dc 792 patt = alt_long_patt;
ccc9c027
L		 793 else
794 patt = f32_patt;
795 break;
ccc9c027
L		 796 case PROCESSOR_PENTIUMPRO:
797 case PROCESSOR_PENTIUM4:
798 case PROCESSOR_NOCONA:
ef05d495 799 case PROCESSOR_CORE:
76bc74dc
L		 800 case PROCESSOR_CORE2:
801 case PROCESSOR_GENERIC64:
802 patt = alt_long_patt;
803 break;
ccc9c027
L		 804 case PROCESSOR_K6:
805 case PROCESSOR_ATHLON:
806 case PROCESSOR_K8:
4eed87de 807 case PROCESSOR_AMDFAM10:
ccc9c027
L		 808 patt = alt_short_patt;
809 break;
76bc74dc 810 case PROCESSOR_I386:
ccc9c027
L		 811 case PROCESSOR_I486:
812 case PROCESSOR_PENTIUM:
813 case PROCESSOR_GENERIC32:
814 patt = f32_patt;
815 break;
4eed87de 816 }
ccc9c027
L		 817 }
818 else
819 {
820 switch (cpu_arch_tune)
821 {
822 case PROCESSOR_UNKNOWN:
823 /* When cpu_arch_isa is net, cpu_arch_tune shouldn't be
824 PROCESSOR_UNKNOWN. */
825 abort ();
826 break;
827
76bc74dc 828 case PROCESSOR_I386:
ccc9c027
L		 829 case PROCESSOR_I486:
830 case PROCESSOR_PENTIUM:
ccc9c027
L		 831 case PROCESSOR_K6:
832 case PROCESSOR_ATHLON:
833 case PROCESSOR_K8:
4eed87de 834 case PROCESSOR_AMDFAM10:
ccc9c027
L		 835 case PROCESSOR_GENERIC32:
836 /* We use cpu_arch_isa_flags to check if we CAN optimize
837 for Cpu686. */
838 if ((cpu_arch_isa_flags & Cpu686) != 0)
839 patt = alt_short_patt;
840 else
841 patt = f32_patt;
842 break;
76bc74dc
L		 843 case PROCESSOR_PENTIUMPRO:
844 case PROCESSOR_PENTIUM4:
845 case PROCESSOR_NOCONA:
846 case PROCESSOR_CORE:
ef05d495 847 case PROCESSOR_CORE2:
ccc9c027
L		 848 if ((cpu_arch_isa_flags & Cpu686) != 0)
849 patt = alt_long_patt;
850 else
851 patt = f32_patt;
852 break;
853 case PROCESSOR_GENERIC64:
76bc74dc 854 patt = alt_long_patt;
ccc9c027 855 break;
4eed87de 856 }
ccc9c027
L		 857 }
858
76bc74dc
L		 859 if (patt == f32_patt)
860 {
861 /* If the padding is less than 15 bytes, we use the normal
862 ones. Otherwise, we use a jump instruction and adjust
863 its offset. */
864 if (count < 15)
865 memcpy (fragP->fr_literal + fragP->fr_fix,
866 patt[count - 1], count);
867 else
868 {
869 memcpy (fragP->fr_literal + fragP->fr_fix,
870 jump_31, count);
871 /* Adjust jump offset. */
872 fragP->fr_literal[fragP->fr_fix + 1] = count - 2;
873 }
874 }
875 else
876 {
877 /* Maximum length of an instruction is 15 byte. If the
878 padding is greater than 15 bytes and we don't use jump,
879 we have to break it into smaller pieces. */
880 int padding = count;
881 while (padding > 15)
882 {
883 padding -= 15;
884 memcpy (fragP->fr_literal + fragP->fr_fix + padding,
885 patt [14], 15);
886 }
887
888 if (padding)
889 memcpy (fragP->fr_literal + fragP->fr_fix,
890 patt [padding - 1], padding);
891 }
ccc9c027 892 }
33fef721 893 fragP->fr_var = count;
252b5132
RH		 894}
895
252b5132 896static INLINE unsigned int
e3bb37b5 897mode_from_disp_size (unsigned int t)
252b5132 898{
3e73aa7c 899 return (t & Disp8) ? 1 : (t & (Disp16 | Disp32 | Disp32S)) ? 2 : 0;
252b5132
RH		 900}
901
902static INLINE int
e3bb37b5 903fits_in_signed_byte (offsetT num)
252b5132
RH		 904{
905 return (num >= -128) && (num <= 127);
47926f60 906}
252b5132
RH		 907
908static INLINE int
e3bb37b5 909fits_in_unsigned_byte (offsetT num)
252b5132
RH		 910{
911 return (num & 0xff) == num;
47926f60 912}
252b5132
RH		 913
914static INLINE int
e3bb37b5 915fits_in_unsigned_word (offsetT num)
252b5132
RH		 916{
917 return (num & 0xffff) == num;
47926f60 918}
252b5132
RH		 919
920static INLINE int
e3bb37b5 921fits_in_signed_word (offsetT num)
252b5132
RH		 922{
923 return (-32768 <= num) && (num <= 32767);
47926f60 924}
2a962e6d 925
3e73aa7c 926static INLINE int
e3bb37b5 927fits_in_signed_long (offsetT num ATTRIBUTE_UNUSED)
3e73aa7c
JH		 928{
929#ifndef BFD64
930 return 1;
931#else
932 return (!(((offsetT) -1 << 31) & num)
933 || (((offsetT) -1 << 31) & num) == ((offsetT) -1 << 31));
934#endif
935} /* fits_in_signed_long() */
2a962e6d 936
3e73aa7c 937static INLINE int
e3bb37b5 938fits_in_unsigned_long (offsetT num ATTRIBUTE_UNUSED)
3e73aa7c
JH		 939{
940#ifndef BFD64
941 return 1;
942#else
943 return (num & (((offsetT) 2 << 31) - 1)) == num;
944#endif
945} /* fits_in_unsigned_long() */
252b5132 946
1509aa9a 947static unsigned int
e3bb37b5 948smallest_imm_type (offsetT num)
252b5132 949{
d32cad65 950 if (cpu_arch_flags != (Cpu186 | Cpu286 | Cpu386 | Cpu486 | CpuNo64))
e413e4e9
AM		 951 {
952 /* This code is disabled on the 486 because all the Imm1 forms
953 in the opcode table are slower on the i486. They're the
954 versions with the implicitly specified single-position
955 displacement, which has another syntax if you really want to
956 use that form. */
957 if (num == 1)
3e73aa7c 958 return Imm1 | Imm8 | Imm8S | Imm16 | Imm32 | Imm32S | Imm64;
e413e4e9 959 }
252b5132 960 return (fits_in_signed_byte (num)
3e73aa7c 961 ? (Imm8S | Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
252b5132 962 : fits_in_unsigned_byte (num)
3e73aa7c 963 ? (Imm8 | Imm16 | Imm32 | Imm32S | Imm64)
252b5132 964 : (fits_in_signed_word (num) || fits_in_unsigned_word (num))
3e73aa7c
JH		 965 ? (Imm16 | Imm32 | Imm32S | Imm64)
966 : fits_in_signed_long (num)
967 ? (Imm32 | Imm32S | Imm64)
968 : fits_in_unsigned_long (num)
969 ? (Imm32 | Imm64)
970 : Imm64);
47926f60 971}
252b5132 972
847f7ad4 973static offsetT
e3bb37b5 974offset_in_range (offsetT val, int size)
847f7ad4 975{
508866be 976 addressT mask;
ba2adb93 977
847f7ad4
AM		 978 switch (size)
979 {
508866be
L		 980 case 1: mask = ((addressT) 1 << 8) - 1; break;
981 case 2: mask = ((addressT) 1 << 16) - 1; break;
3b0ec529 982 case 4: mask = ((addressT) 2 << 31) - 1; break;
3e73aa7c
JH		 983#ifdef BFD64
984 case 8: mask = ((addressT) 2 << 63) - 1; break;
985#endif
47926f60 986 default: abort ();
847f7ad4
AM		 987 }
988
ba2adb93 989 /* If BFD64, sign extend val. */
3e73aa7c
JH		 990 if (!use_rela_relocations)
991 if ((val & ~(((addressT) 2 << 31) - 1)) == 0)
992 val = (val ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
ba2adb93 993
47926f60 994 if ((val & ~mask) != 0 && (val & ~mask) != ~mask)
847f7ad4
AM		 995 {
996 char buf1[40], buf2[40];
997
998 sprint_value (buf1, val);
999 sprint_value (buf2, val & mask);
1000 as_warn (_("%s shortened to %s"), buf1, buf2);
1001 }
1002 return val & mask;
1003}
1004
252b5132
RH		 1005/* Returns 0 if attempting to add a prefix where one from the same
1006 class already exists, 1 if non rep/repne added, 2 if rep/repne
1007 added. */
1008static int
e3bb37b5 1009add_prefix (unsigned int prefix)
252b5132
RH		 1010{
1011 int ret = 1;
b1905489 1012 unsigned int q;
252b5132 1013
29b0f896
AM		 1014 if (prefix >= REX_OPCODE && prefix < REX_OPCODE + 16
1015 && flag_code == CODE_64BIT)
b1905489 1016 {
161a04f6
L		 1017 if ((i.prefix[REX_PREFIX] & prefix & REX_W)
1018 || ((i.prefix[REX_PREFIX] & (REX_R | REX_X | REX_B))
1019 && (prefix & (REX_R | REX_X | REX_B))))
b1905489
JB		 1020 ret = 0;
1021 q = REX_PREFIX;
1022 }
3e73aa7c 1023 else
b1905489
JB		 1024 {
1025 switch (prefix)
1026 {
1027 default:
1028 abort ();
1029
1030 case CS_PREFIX_OPCODE:
1031 case DS_PREFIX_OPCODE:
1032 case ES_PREFIX_OPCODE:
1033 case FS_PREFIX_OPCODE:
1034 case GS_PREFIX_OPCODE:
1035 case SS_PREFIX_OPCODE:
1036 q = SEG_PREFIX;
1037 break;
1038
1039 case REPNE_PREFIX_OPCODE:
1040 case REPE_PREFIX_OPCODE:
1041 ret = 2;
1042 /* fall thru */
1043 case LOCK_PREFIX_OPCODE:
1044 q = LOCKREP_PREFIX;
1045 break;
1046
1047 case FWAIT_OPCODE:
1048 q = WAIT_PREFIX;
1049 break;
1050
1051 case ADDR_PREFIX_OPCODE:
1052 q = ADDR_PREFIX;
1053 break;
1054
1055 case DATA_PREFIX_OPCODE:
1056 q = DATA_PREFIX;
1057 break;
1058 }
1059 if (i.prefix[q] != 0)
1060 ret = 0;
1061 }
252b5132 1062
b1905489 1063 if (ret)
252b5132 1064 {
b1905489
JB		 1065 if (!i.prefix[q])
1066 ++i.prefixes;
1067 i.prefix[q] |= prefix;
252b5132 1068 }
b1905489
JB		 1069 else
1070 as_bad (_("same type of prefix used twice"));
252b5132 1071
252b5132
RH		 1072 return ret;
1073}
1074
1075static void
e3bb37b5 1076set_code_flag (int value)
eecb386c 1077{
3e73aa7c
JH		 1078 flag_code = value;
1079 cpu_arch_flags &= ~(Cpu64 | CpuNo64);
1080 cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
1081 if (value == CODE_64BIT && !(cpu_arch_flags & CpuSledgehammer))
1082 {
1083 as_bad (_("64bit mode not supported on this CPU."));
1084 }
1085 if (value == CODE_32BIT && !(cpu_arch_flags & Cpu386))
1086 {
1087 as_bad (_("32bit mode not supported on this CPU."));
1088 }
eecb386c
AM		 1089 stackop_size = '\0';
1090}
1091
1092static void
e3bb37b5 1093set_16bit_gcc_code_flag (int new_code_flag)
252b5132 1094{
3e73aa7c
JH		 1095 flag_code = new_code_flag;
1096 cpu_arch_flags &= ~(Cpu64 | CpuNo64);
1097 cpu_arch_flags |= (flag_code == CODE_64BIT ? Cpu64 : CpuNo64);
9306ca4a 1098 stackop_size = LONG_MNEM_SUFFIX;
252b5132
RH		 1099}
1100
1101static void
e3bb37b5 1102set_intel_syntax (int syntax_flag)
252b5132
RH		 1103{
1104 /* Find out if register prefixing is specified. */
1105 int ask_naked_reg = 0;
1106
1107 SKIP_WHITESPACE ();
29b0f896 1108 if (!is_end_of_line[(unsigned char) *input_line_pointer])
252b5132
RH		 1109 {
1110 char *string = input_line_pointer;
1111 int e = get_symbol_end ();
1112
47926f60 1113 if (strcmp (string, "prefix") == 0)
252b5132 1114 ask_naked_reg = 1;
47926f60 1115 else if (strcmp (string, "noprefix") == 0)
252b5132
RH		 1116 ask_naked_reg = -1;
1117 else
d0b47220 1118 as_bad (_("bad argument to syntax directive."));
252b5132
RH		 1119 *input_line_pointer = e;
1120 }
1121 demand_empty_rest_of_line ();
c3332e24 1122
252b5132
RH		 1123 intel_syntax = syntax_flag;
1124
1125 if (ask_naked_reg == 0)
f86103b7
AM		 1126 allow_naked_reg = (intel_syntax
1127 && (bfd_get_symbol_leading_char (stdoutput) != '\0'));
252b5132
RH		 1128 else
1129 allow_naked_reg = (ask_naked_reg < 0);
9306ca4a 1130
e4a3b5a4 1131 identifier_chars['%'] = intel_syntax && allow_naked_reg ? '%' : 0;
9306ca4a 1132 identifier_chars['$'] = intel_syntax ? '$' : 0;
e4a3b5a4 1133 register_prefix = allow_naked_reg ? "" : "%";
252b5132
RH		 1134}
1135
e413e4e9 1136static void
e3bb37b5 1137set_cpu_arch (int dummy ATTRIBUTE_UNUSED)
e413e4e9 1138{
47926f60 1139 SKIP_WHITESPACE ();
e413e4e9 1140
29b0f896 1141 if (!is_end_of_line[(unsigned char) *input_line_pointer])
e413e4e9
AM		 1142 {
1143 char *string = input_line_pointer;
1144 int e = get_symbol_end ();
9103f4f4 1145 unsigned int i;
e413e4e9 1146
9103f4f4 1147 for (i = 0; i < ARRAY_SIZE (cpu_arch); i++)
e413e4e9
AM		 1148 {
1149 if (strcmp (string, cpu_arch[i].name) == 0)
1150 {
5c6af06e
JB		 1151 if (*string != '.')
1152 {
1153 cpu_arch_name = cpu_arch[i].name;
1154 cpu_sub_arch_name = NULL;
1155 cpu_arch_flags = (cpu_arch[i].flags
4eed87de
AM		 1156 | (flag_code == CODE_64BIT
1157 ? Cpu64 : CpuNo64));
ccc9c027 1158 cpu_arch_isa = cpu_arch[i].type;
9103f4f4 1159 cpu_arch_isa_flags = cpu_arch[i].flags;
ccc9c027
L		 1160 if (!cpu_arch_tune_set)
1161 {
1162 cpu_arch_tune = cpu_arch_isa;
1163 cpu_arch_tune_flags = cpu_arch_isa_flags;
1164 }
5c6af06e
JB		 1165 break;
1166 }
1167 if ((cpu_arch_flags | cpu_arch[i].flags) != cpu_arch_flags)
1168 {
1169 cpu_sub_arch_name = cpu_arch[i].name;
1170 cpu_arch_flags |= cpu_arch[i].flags;
1171 }
1172 *input_line_pointer = e;
1173 demand_empty_rest_of_line ();
1174 return;
e413e4e9
AM		 1175 }
1176 }
9103f4f4 1177 if (i >= ARRAY_SIZE (cpu_arch))
e413e4e9
AM		 1178 as_bad (_("no such architecture: `%s'"), string);
1179
1180 *input_line_pointer = e;
1181 }
1182 else
1183 as_bad (_("missing cpu architecture"));
1184
fddf5b5b
AM		 1185 no_cond_jump_promotion = 0;
1186 if (*input_line_pointer == ','
29b0f896 1187 && !is_end_of_line[(unsigned char) input_line_pointer[1]])
fddf5b5b
AM		 1188 {
1189 char *string = ++input_line_pointer;
1190 int e = get_symbol_end ();
1191
1192 if (strcmp (string, "nojumps") == 0)
1193 no_cond_jump_promotion = 1;
1194 else if (strcmp (string, "jumps") == 0)
1195 ;
1196 else
1197 as_bad (_("no such architecture modifier: `%s'"), string);
1198
1199 *input_line_pointer = e;
1200 }
1201
e413e4e9
AM		 1202 demand_empty_rest_of_line ();
1203}
1204
b9d79e03
JH		 1205unsigned long
1206i386_mach ()
1207{
1208 if (!strcmp (default_arch, "x86_64"))
1209 return bfd_mach_x86_64;
1210 else if (!strcmp (default_arch, "i386"))
1211 return bfd_mach_i386_i386;
1212 else
1213 as_fatal (_("Unknown architecture"));
1214}
b9d79e03 1215\f
252b5132
RH		 1216void
1217md_begin ()
1218{
1219 const char *hash_err;
1220
47926f60 1221 /* Initialize op_hash hash table. */
252b5132
RH		 1222 op_hash = hash_new ();
1223
1224 {
29b0f896
AM		 1225 const template *optab;
1226 templates *core_optab;
252b5132 1227
47926f60
KH		 1228 /* Setup for loop. */
1229 optab = i386_optab;
252b5132
RH		 1230 core_optab = (templates *) xmalloc (sizeof (templates));
1231 core_optab->start = optab;
1232
1233 while (1)
1234 {
1235 ++optab;
1236 if (optab->name == NULL
1237 || strcmp (optab->name, (optab - 1)->name) != 0)
1238 {
1239 /* different name --> ship out current template list;
47926f60 1240 add to hash table; & begin anew. */
252b5132
RH		 1241 core_optab->end = optab;
1242 hash_err = hash_insert (op_hash,
1243 (optab - 1)->name,
1244 (PTR) core_optab);
1245 if (hash_err)
1246 {
252b5132
RH		 1247 as_fatal (_("Internal Error: Can't hash %s: %s"),
1248 (optab - 1)->name,
1249 hash_err);
1250 }
1251 if (optab->name == NULL)
1252 break;
1253 core_optab = (templates *) xmalloc (sizeof (templates));
1254 core_optab->start = optab;
1255 }
1256 }
1257 }
1258
47926f60 1259 /* Initialize reg_hash hash table. */
252b5132
RH		 1260 reg_hash = hash_new ();
1261 {
29b0f896 1262 const reg_entry *regtab;
c3fe08fa 1263 unsigned int regtab_size = i386_regtab_size;
252b5132 1264
c3fe08fa 1265 for (regtab = i386_regtab; regtab_size--; regtab++)
252b5132
RH		 1266 {
1267 hash_err = hash_insert (reg_hash, regtab->reg_name, (PTR) regtab);
1268 if (hash_err)
3e73aa7c
JH		 1269 as_fatal (_("Internal Error: Can't hash %s: %s"),
1270 regtab->reg_name,
1271 hash_err);
252b5132
RH		 1272 }
1273 }
1274
47926f60 1275 /* Fill in lexical tables: mnemonic_chars, operand_chars. */
252b5132 1276 {
29b0f896
AM		 1277 int c;
1278 char *p;
252b5132
RH		 1279
1280 for (c = 0; c < 256; c++)
1281 {
3882b010 1282 if (ISDIGIT (c))
252b5132
RH		 1283 {
1284 digit_chars[c] = c;
1285 mnemonic_chars[c] = c;
1286 register_chars[c] = c;
1287 operand_chars[c] = c;
1288 }
3882b010 1289 else if (ISLOWER (c))
252b5132
RH		 1290 {
1291 mnemonic_chars[c] = c;
1292 register_chars[c] = c;
1293 operand_chars[c] = c;
1294 }
3882b010 1295 else if (ISUPPER (c))
252b5132 1296 {
3882b010 1297 mnemonic_chars[c] = TOLOWER (c);
252b5132
RH		 1298 register_chars[c] = mnemonic_chars[c];
1299 operand_chars[c] = c;
1300 }
1301
3882b010 1302 if (ISALPHA (c) || ISDIGIT (c))
252b5132
RH		 1303 identifier_chars[c] = c;
1304 else if (c >= 128)
1305 {
1306 identifier_chars[c] = c;
1307 operand_chars[c] = c;
1308 }
1309 }
1310
1311#ifdef LEX_AT
1312 identifier_chars['@'] = '@';
32137342
NC		 1313#endif
1314#ifdef LEX_QM
1315 identifier_chars['?'] = '?';
1316 operand_chars['?'] = '?';
252b5132 1317#endif
252b5132 1318 digit_chars['-'] = '-';
791fe849 1319 mnemonic_chars['-'] = '-';
0003779b 1320 mnemonic_chars['.'] = '.';
252b5132
RH		 1321 identifier_chars['_'] = '_';
1322 identifier_chars['.'] = '.';
1323
1324 for (p = operand_special_chars; *p != '\0'; p++)
1325 operand_chars[(unsigned char) *p] = *p;
1326 }
1327
1328#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
718ddfc0 1329 if (IS_ELF)
252b5132
RH		 1330 {
1331 record_alignment (text_section, 2);
1332 record_alignment (data_section, 2);
1333 record_alignment (bss_section, 2);
1334 }
1335#endif
a4447b93
RH		 1336
1337 if (flag_code == CODE_64BIT)
1338 {
1339 x86_dwarf2_return_column = 16;
1340 x86_cie_data_alignment = -8;
1341 }
1342 else
1343 {
1344 x86_dwarf2_return_column = 8;
1345 x86_cie_data_alignment = -4;
1346 }
252b5132
RH		 1347}
1348
1349void
e3bb37b5 1350i386_print_statistics (FILE *file)
252b5132
RH		 1351{
1352 hash_print_statistics (file, "i386 opcode", op_hash);
1353 hash_print_statistics (file, "i386 register", reg_hash);
1354}
1355\f
252b5132
RH		 1356#ifdef DEBUG386
1357
ce8a8b2f 1358/* Debugging routines for md_assemble. */
e3bb37b5
L		 1359static void pte (template *);
1360static void pt (unsigned int);
1361static void pe (expressionS *);
1362static void ps (symbolS *);
252b5132
RH		 1363
1364static void
e3bb37b5 1365pi (char *line, i386_insn *x)
252b5132 1366{
09f131f2 1367 unsigned int i;
252b5132
RH		 1368
1369 fprintf (stdout, "%s: template ", line);
1370 pte (&x->tm);
09f131f2
JH		 1371 fprintf (stdout, " address: base %s index %s scale %x\n",
1372 x->base_reg ? x->base_reg->reg_name : "none",
1373 x->index_reg ? x->index_reg->reg_name : "none",
1374 x->log2_scale_factor);
1375 fprintf (stdout, " modrm: mode %x reg %x reg/mem %x\n",
252b5132 1376 x->rm.mode, x->rm.reg, x->rm.regmem);
09f131f2
JH		 1377 fprintf (stdout, " sib: base %x index %x scale %x\n",
1378 x->sib.base, x->sib.index, x->sib.scale);
1379 fprintf (stdout, " rex: 64bit %x extX %x extY %x extZ %x\n",
161a04f6
L		 1380 (x->rex & REX_W) != 0,
1381 (x->rex & REX_R) != 0,
1382 (x->rex & REX_X) != 0,
1383 (x->rex & REX_B) != 0);
252b5132
RH		 1384 for (i = 0; i < x->operands; i++)
1385 {
1386 fprintf (stdout, " #%d: ", i + 1);
1387 pt (x->types[i]);
1388 fprintf (stdout, "\n");
1389 if (x->types[i]
3f4438ab 1390 & (Reg | SReg2 | SReg3 | Control | Debug | Test | RegMMX | RegXMM))
520dc8e8 1391 fprintf (stdout, "%s\n", x->op[i].regs->reg_name);
252b5132 1392 if (x->types[i] & Imm)
520dc8e8 1393 pe (x->op[i].imms);
252b5132 1394 if (x->types[i] & Disp)
520dc8e8 1395 pe (x->op[i].disps);
252b5132
RH		 1396 }
1397}
1398
1399static void
e3bb37b5 1400pte (template *t)
252b5132 1401{
09f131f2 1402 unsigned int i;
252b5132 1403 fprintf (stdout, " %d operands ", t->operands);
47926f60 1404 fprintf (stdout, "opcode %x ", t->base_opcode);
252b5132
RH		 1405 if (t->extension_opcode != None)
1406 fprintf (stdout, "ext %x ", t->extension_opcode);
1407 if (t->opcode_modifier & D)
1408 fprintf (stdout, "D");
1409 if (t->opcode_modifier & W)
1410 fprintf (stdout, "W");
1411 fprintf (stdout, "\n");
1412 for (i = 0; i < t->operands; i++)
1413 {
1414 fprintf (stdout, " #%d type ", i + 1);
1415 pt (t->operand_types[i]);
1416 fprintf (stdout, "\n");
1417 }
1418}
1419
1420static void
e3bb37b5 1421pe (expressionS *e)
252b5132 1422{
24eab124 1423 fprintf (stdout, " operation %d\n", e->X_op);
b77ad1d4
AM		 1424 fprintf (stdout, " add_number %ld (%lx)\n",
1425 (long) e->X_add_number, (long) e->X_add_number);
252b5132
RH		 1426 if (e->X_add_symbol)
1427 {
1428 fprintf (stdout, " add_symbol ");
1429 ps (e->X_add_symbol);
1430 fprintf (stdout, "\n");
1431 }
1432 if (e->X_op_symbol)
1433 {
1434 fprintf (stdout, " op_symbol ");
1435 ps (e->X_op_symbol);
1436 fprintf (stdout, "\n");
1437 }
1438}
1439
1440static void
e3bb37b5 1441ps (symbolS *s)
252b5132
RH		 1442{
1443 fprintf (stdout, "%s type %s%s",
1444 S_GET_NAME (s),
1445 S_IS_EXTERNAL (s) ? "EXTERNAL " : "",
1446 segment_name (S_GET_SEGMENT (s)));
1447}
1448
7b81dfbb 1449static struct type_name
252b5132
RH		 1450 {
1451 unsigned int mask;
1452 char *tname;
1453 }
7b81dfbb 1454const type_names[] =
252b5132
RH		 1455{
1456 { Reg8, "r8" },
1457 { Reg16, "r16" },
1458 { Reg32, "r32" },
09f131f2 1459 { Reg64, "r64" },
252b5132
RH		 1460 { Imm8, "i8" },
1461 { Imm8S, "i8s" },
1462 { Imm16, "i16" },
1463 { Imm32, "i32" },
09f131f2
JH		 1464 { Imm32S, "i32s" },
1465 { Imm64, "i64" },
252b5132
RH		 1466 { Imm1, "i1" },
1467 { BaseIndex, "BaseIndex" },
1468 { Disp8, "d8" },
1469 { Disp16, "d16" },
1470 { Disp32, "d32" },
09f131f2
JH		 1471 { Disp32S, "d32s" },
1472 { Disp64, "d64" },
252b5132
RH		 1473 { InOutPortReg, "InOutPortReg" },
1474 { ShiftCount, "ShiftCount" },
1475 { Control, "control reg" },
1476 { Test, "test reg" },
1477 { Debug, "debug reg" },
1478 { FloatReg, "FReg" },
1479 { FloatAcc, "FAcc" },
1480 { SReg2, "SReg2" },
1481 { SReg3, "SReg3" },
1482 { Acc, "Acc" },
1483 { JumpAbsolute, "Jump Absolute" },
1484 { RegMMX, "rMMX" },
3f4438ab 1485 { RegXMM, "rXMM" },
252b5132
RH		 1486 { EsSeg, "es" },
1487 { 0, "" }
1488};
1489
1490static void
1491pt (t)
1492 unsigned int t;
1493{
29b0f896 1494 const struct type_name *ty;
252b5132 1495
09f131f2
JH		 1496 for (ty = type_names; ty->mask; ty++)
1497 if (t & ty->mask)
1498 fprintf (stdout, "%s, ", ty->tname);
252b5132
RH		 1499 fflush (stdout);
1500}
1501
1502#endif /* DEBUG386 */
1503\f
252b5132 1504static bfd_reloc_code_real_type
3956db08 1505reloc (unsigned int size,
64e74474
AM		 1506 int pcrel,
1507 int sign,
1508 bfd_reloc_code_real_type other)
252b5132 1509{
47926f60 1510 if (other != NO_RELOC)
3956db08
JB		 1511 {
1512 reloc_howto_type *reloc;
1513
1514 if (size == 8)
1515 switch (other)
1516 {
64e74474
AM		 1517 case BFD_RELOC_X86_64_GOT32:
1518 return BFD_RELOC_X86_64_GOT64;
1519 break;
1520 case BFD_RELOC_X86_64_PLTOFF64:
1521 return BFD_RELOC_X86_64_PLTOFF64;
1522 break;
1523 case BFD_RELOC_X86_64_GOTPC32:
1524 other = BFD_RELOC_X86_64_GOTPC64;
1525 break;
1526 case BFD_RELOC_X86_64_GOTPCREL:
1527 other = BFD_RELOC_X86_64_GOTPCREL64;
1528 break;
1529 case BFD_RELOC_X86_64_TPOFF32:
1530 other = BFD_RELOC_X86_64_TPOFF64;
1531 break;
1532 case BFD_RELOC_X86_64_DTPOFF32:
1533 other = BFD_RELOC_X86_64_DTPOFF64;
1534 break;
1535 default:
1536 break;
3956db08 1537 }
e05278af
JB		 1538
1539 /* Sign-checking 4-byte relocations in 16-/32-bit code is pointless. */
1540 if (size == 4 && flag_code != CODE_64BIT)
1541 sign = -1;
1542
3956db08
JB		 1543 reloc = bfd_reloc_type_lookup (stdoutput, other);
1544 if (!reloc)
1545 as_bad (_("unknown relocation (%u)"), other);
1546 else if (size != bfd_get_reloc_size (reloc))
1547 as_bad (_("%u-byte relocation cannot be applied to %u-byte field"),
1548 bfd_get_reloc_size (reloc),
1549 size);
1550 else if (pcrel && !reloc->pc_relative)
1551 as_bad (_("non-pc-relative relocation for pc-relative field"));
1552 else if ((reloc->complain_on_overflow == complain_overflow_signed
1553 && !sign)
1554 || (reloc->complain_on_overflow == complain_overflow_unsigned
64e74474 1555 && sign > 0))
3956db08
JB		 1556 as_bad (_("relocated field and relocation type differ in signedness"));
1557 else
1558 return other;
1559 return NO_RELOC;
1560 }
252b5132
RH		 1561
1562 if (pcrel)
1563 {
3e73aa7c 1564 if (!sign)
3956db08 1565 as_bad (_("there are no unsigned pc-relative relocations"));
252b5132
RH		 1566 switch (size)
1567 {
1568 case 1: return BFD_RELOC_8_PCREL;
1569 case 2: return BFD_RELOC_16_PCREL;
1570 case 4: return BFD_RELOC_32_PCREL;
d6ab8113 1571 case 8: return BFD_RELOC_64_PCREL;
252b5132 1572 }
3956db08 1573 as_bad (_("cannot do %u byte pc-relative relocation"), size);
252b5132
RH		 1574 }
1575 else
1576 {
3956db08 1577 if (sign > 0)
e5cb08ac 1578 switch (size)
3e73aa7c
JH		 1579 {
1580 case 4: return BFD_RELOC_X86_64_32S;
1581 }
1582 else
1583 switch (size)
1584 {
1585 case 1: return BFD_RELOC_8;
1586 case 2: return BFD_RELOC_16;
1587 case 4: return BFD_RELOC_32;
1588 case 8: return BFD_RELOC_64;
1589 }
3956db08
JB		 1590 as_bad (_("cannot do %s %u byte relocation"),
1591 sign > 0 ? "signed" : "unsigned", size);
252b5132
RH		 1592 }
1593
bfb32b52 1594 abort ();
252b5132
RH		 1595 return BFD_RELOC_NONE;
1596}
1597
47926f60
KH		 1598/* Here we decide which fixups can be adjusted to make them relative to
1599 the beginning of the section instead of the symbol. Basically we need
1600 to make sure that the dynamic relocations are done correctly, so in
1601 some cases we force the original symbol to be used. */
1602
252b5132 1603int
e3bb37b5 1604tc_i386_fix_adjustable (fixS *fixP ATTRIBUTE_UNUSED)
252b5132 1605{
6d249963 1606#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
718ddfc0 1607 if (!IS_ELF)
31312f95
AM		 1608 return 1;
1609
a161fe53
AM		 1610 /* Don't adjust pc-relative references to merge sections in 64-bit
1611 mode. */
1612 if (use_rela_relocations
1613 && (S_GET_SEGMENT (fixP->fx_addsy)->flags & SEC_MERGE) != 0
1614 && fixP->fx_pcrel)
252b5132 1615 return 0;
31312f95 1616
8d01d9a9
AJ		 1617 /* The x86_64 GOTPCREL are represented as 32bit PCrel relocations
1618 and changed later by validate_fix. */
1619 if (GOT_symbol && fixP->fx_subsy == GOT_symbol
1620 && fixP->fx_r_type == BFD_RELOC_32_PCREL)
1621 return 0;
1622
ce8a8b2f 1623 /* adjust_reloc_syms doesn't know about the GOT. */
252b5132
RH		 1624 if (fixP->fx_r_type == BFD_RELOC_386_GOTOFF
1625 || fixP->fx_r_type == BFD_RELOC_386_PLT32
1626 || fixP->fx_r_type == BFD_RELOC_386_GOT32
13ae64f3
JJ		 1627 || fixP->fx_r_type == BFD_RELOC_386_TLS_GD
1628 || fixP->fx_r_type == BFD_RELOC_386_TLS_LDM
1629 || fixP->fx_r_type == BFD_RELOC_386_TLS_LDO_32
1630 || fixP->fx_r_type == BFD_RELOC_386_TLS_IE_32
37e55690
JJ		 1631 || fixP->fx_r_type == BFD_RELOC_386_TLS_IE
1632 || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTIE
13ae64f3
JJ		 1633 || fixP->fx_r_type == BFD_RELOC_386_TLS_LE_32
1634 || fixP->fx_r_type == BFD_RELOC_386_TLS_LE
67a4f2b7
AO		 1635 || fixP->fx_r_type == BFD_RELOC_386_TLS_GOTDESC
1636 || fixP->fx_r_type == BFD_RELOC_386_TLS_DESC_CALL
3e73aa7c
JH		 1637 || fixP->fx_r_type == BFD_RELOC_X86_64_PLT32
1638 || fixP->fx_r_type == BFD_RELOC_X86_64_GOT32
80b3ee89 1639 || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPCREL
bffbf940
JJ		 1640 || fixP->fx_r_type == BFD_RELOC_X86_64_TLSGD
1641 || fixP->fx_r_type == BFD_RELOC_X86_64_TLSLD
1642 || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF32
d6ab8113 1643 || fixP->fx_r_type == BFD_RELOC_X86_64_DTPOFF64
bffbf940
JJ		 1644 || fixP->fx_r_type == BFD_RELOC_X86_64_GOTTPOFF
1645 || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF32
d6ab8113
JB		 1646 || fixP->fx_r_type == BFD_RELOC_X86_64_TPOFF64
1647 || fixP->fx_r_type == BFD_RELOC_X86_64_GOTOFF64
67a4f2b7
AO		 1648 || fixP->fx_r_type == BFD_RELOC_X86_64_GOTPC32_TLSDESC
1649 || fixP->fx_r_type == BFD_RELOC_X86_64_TLSDESC_CALL
252b5132
RH		 1650 || fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
1651 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
1652 return 0;
31312f95 1653#endif
252b5132
RH		 1654 return 1;
1655}
252b5132 1656
b4cac588 1657static int
e3bb37b5 1658intel_float_operand (const char *mnemonic)
252b5132 1659{
9306ca4a
JB		 1660 /* Note that the value returned is meaningful only for opcodes with (memory)
1661 operands, hence the code here is free to improperly handle opcodes that
1662 have no operands (for better performance and smaller code). */
1663
1664 if (mnemonic[0] != 'f')
1665 return 0; /* non-math */
1666
1667 switch (mnemonic[1])
1668 {
1669 /* fclex, fdecstp, fdisi, femms, feni, fincstp, finit, fsetpm, and
1670 the fs segment override prefix not currently handled because no
1671 call path can make opcodes without operands get here */
1672 case 'i':
1673 return 2 /* integer op */;
1674 case 'l':
1675 if (mnemonic[2] == 'd' && (mnemonic[3] == 'c' || mnemonic[3] == 'e'))
1676 return 3; /* fldcw/fldenv */
1677 break;
1678 case 'n':
1679 if (mnemonic[2] != 'o' /* fnop */)
1680 return 3; /* non-waiting control op */
1681 break;
1682 case 'r':
1683 if (mnemonic[2] == 's')
1684 return 3; /* frstor/frstpm */
1685 break;
1686 case 's':
1687 if (mnemonic[2] == 'a')
1688 return 3; /* fsave */
1689 if (mnemonic[2] == 't')
1690 {
1691 switch (mnemonic[3])
1692 {
1693 case 'c': /* fstcw */
1694 case 'd': /* fstdw */
1695 case 'e': /* fstenv */
1696 case 's': /* fsts[gw] */
1697 return 3;
1698 }
1699 }
1700 break;
1701 case 'x':
1702 if (mnemonic[2] == 'r' || mnemonic[2] == 's')
1703 return 0; /* fxsave/fxrstor are not really math ops */
1704 break;
1705 }
252b5132 1706
9306ca4a 1707 return 1;
252b5132
RH		 1708}
1709
1710/* This is the guts of the machine-dependent assembler. LINE points to a
1711 machine dependent instruction. This function is supposed to emit
1712 the frags/bytes it assembles to. */
1713
1714void
1715md_assemble (line)
1716 char *line;
1717{
252b5132 1718 int j;
252b5132
RH		 1719 char mnemonic[MAX_MNEM_SIZE];
1720
47926f60 1721 /* Initialize globals. */
252b5132
RH		 1722 memset (&i, '\0', sizeof (i));
1723 for (j = 0; j < MAX_OPERANDS; j++)
1ae12ab7 1724 i.reloc[j] = NO_RELOC;
252b5132
RH		 1725 memset (disp_expressions, '\0', sizeof (disp_expressions));
1726 memset (im_expressions, '\0', sizeof (im_expressions));
ce8a8b2f 1727 save_stack_p = save_stack;
252b5132
RH		 1728
1729 /* First parse an instruction mnemonic & call i386_operand for the operands.
1730 We assume that the scrubber has arranged it so that line[0] is the valid
47926f60 1731 start of a (possibly prefixed) mnemonic. */
252b5132 1732
29b0f896
AM		 1733 line = parse_insn (line, mnemonic);
1734 if (line == NULL)
1735 return;
252b5132 1736
29b0f896
AM		 1737 line = parse_operands (line, mnemonic);
1738 if (line == NULL)
1739 return;
252b5132 1740
4eed87de 1741 /* The order of the immediates should be reversed
050dfa73 1742 for 2 immediates extrq and insertq instructions */
4d456e3d
L		 1743 if ((i.imm_operands == 2)
1744 && ((strcmp (mnemonic, "extrq") == 0)
1745 || (strcmp (mnemonic, "insertq") == 0)))
050dfa73 1746 {
4eed87de
AM		 1747 swap_2_operands (0, 1);
1748 /* "extrq" and insertq" are the only two instructions whose operands
050dfa73
MM		 1749 have to be reversed even though they have two immediate operands.
1750 */
1751 if (intel_syntax)
1752 swap_operands ();
1753 }
1754
29b0f896
AM		 1755 /* Now we've parsed the mnemonic into a set of templates, and have the
1756 operands at hand. */
1757
1758 /* All intel opcodes have reversed operands except for "bound" and
1759 "enter". We also don't reverse intersegment "jmp" and "call"
1760 instructions with 2 immediate operands so that the immediate segment
050dfa73 1761 precedes the offset, as it does when in AT&T mode. */
4d456e3d
L		 1762 if (intel_syntax
1763 && i.operands > 1
29b0f896 1764 && (strcmp (mnemonic, "bound") != 0)
30123838 1765 && (strcmp (mnemonic, "invlpga") != 0)
29b0f896
AM		 1766 && !((i.types[0] & Imm) && (i.types[1] & Imm)))
1767 swap_operands ();
1768
1769 if (i.imm_operands)
1770 optimize_imm ();
1771
b300c311
L		 1772 /* Don't optimize displacement for movabs since it only takes 64bit
1773 displacement. */
1774 if (i.disp_operands
1775 && (flag_code != CODE_64BIT
1776 || strcmp (mnemonic, "movabs") != 0))
29b0f896
AM		 1777 optimize_disp ();
1778
1779 /* Next, we find a template that matches the given insn,
1780 making sure the overlap of the given operands types is consistent
1781 with the template operand types. */
252b5132 1782
29b0f896
AM		 1783 if (!match_template ())
1784 return;
252b5132 1785
cd61ebfe
AM		 1786 if (intel_syntax)
1787 {
1788 /* Undo SYSV386_COMPAT brokenness when in Intel mode. See i386.h */
1789 if (SYSV386_COMPAT
1790 && (i.tm.base_opcode & 0xfffffde0) == 0xdce0)
8a2ed489 1791 i.tm.base_opcode ^= Opcode_FloatR;
cd61ebfe
AM		 1792
1793 /* Zap movzx and movsx suffix. The suffix may have been set from
1794 "word ptr" or "byte ptr" on the source operand, but we'll use
1795 the suffix later to choose the destination register. */
1796 if ((i.tm.base_opcode & ~9) == 0x0fb6)
9306ca4a
JB		 1797 {
1798 if (i.reg_operands < 2
1799 && !i.suffix
1800 && (~i.tm.opcode_modifier
1801 & (No_bSuf
1802 | No_wSuf
1803 | No_lSuf
1804 | No_sSuf
1805 | No_xSuf
1806 | No_qSuf)))
1807 as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
1808
1809 i.suffix = 0;
1810 }
cd61ebfe 1811 }
24eab124 1812
29b0f896
AM		 1813 if (i.tm.opcode_modifier & FWait)
1814 if (!add_prefix (FWAIT_OPCODE))
1815 return;
252b5132 1816
29b0f896
AM		 1817 /* Check string instruction segment overrides. */
1818 if ((i.tm.opcode_modifier & IsString) != 0 && i.mem_operands != 0)
1819 {
1820 if (!check_string ())
5dd0794d 1821 return;
29b0f896 1822 }
5dd0794d 1823
29b0f896
AM		 1824 if (!process_suffix ())
1825 return;
e413e4e9 1826
29b0f896
AM		 1827 /* Make still unresolved immediate matches conform to size of immediate
1828 given in i.suffix. */
1829 if (!finalize_imm ())
1830 return;
252b5132 1831
29b0f896
AM		 1832 if (i.types[0] & Imm1)
1833 i.imm_operands = 0; /* kludge for shift insns. */
1834 if (i.types[0] & ImplicitRegister)
1835 i.reg_operands--;
1836 if (i.types[1] & ImplicitRegister)
1837 i.reg_operands--;
1838 if (i.types[2] & ImplicitRegister)
1839 i.reg_operands--;
252b5132 1840
29b0f896
AM		 1841 if (i.tm.opcode_modifier & ImmExt)
1842 {
02fc3089
L		 1843 expressionS *exp;
1844
b7d9ef37 1845 if ((i.tm.cpu_flags & CpuSSE3) && i.operands > 0)
ca164297 1846 {
b7d9ef37 1847 /* Streaming SIMD extensions 3 Instructions have the fixed
ca164297
L		 1848 operands with an opcode suffix which is coded in the same
1849 place as an 8-bit immediate field would be. Here we check
1850 those operands and remove them afterwards. */
1851 unsigned int x;
1852
a4622f40 1853 for (x = 0; x < i.operands; x++)
ca164297 1854 if (i.op[x].regs->reg_num != x)
a540244d
L		 1855 as_bad (_("can't use register '%s%s' as operand %d in '%s'."),
1856 register_prefix,
1857 i.op[x].regs->reg_name,
1858 x + 1,
1859 i.tm.name);
ca164297
L		 1860 i.operands = 0;
1861 }
1862
29b0f896
AM		 1863 /* These AMD 3DNow! and Intel Katmai New Instructions have an
1864 opcode suffix which is coded in the same place as an 8-bit
1865 immediate field would be. Here we fake an 8-bit immediate
1866 operand from the opcode suffix stored in tm.extension_opcode. */
252b5132 1867
29b0f896 1868 assert (i.imm_operands == 0 && i.operands <= 2 && 2 < MAX_OPERANDS);
252b5132 1869
29b0f896
AM		 1870 exp = &im_expressions[i.imm_operands++];
1871 i.op[i.operands].imms = exp;
1872 i.types[i.operands++] = Imm8;
1873 exp->X_op = O_constant;
1874 exp->X_add_number = i.tm.extension_opcode;
1875 i.tm.extension_opcode = None;
1876 }
252b5132 1877
29b0f896
AM		 1878 /* For insns with operands there are more diddles to do to the opcode. */
1879 if (i.operands)
1880 {
1881 if (!process_operands ())
1882 return;
1883 }
1884 else if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
1885 {
1886 /* UnixWare fsub no args is alias for fsubp, fadd -> faddp, etc. */
1887 as_warn (_("translating to `%sp'"), i.tm.name);
1888 }
252b5132 1889
29b0f896
AM		 1890 /* Handle conversion of 'int $3' --> special int3 insn. */
1891 if (i.tm.base_opcode == INT_OPCODE && i.op[0].imms->X_add_number == 3)
1892 {
1893 i.tm.base_opcode = INT3_OPCODE;
1894 i.imm_operands = 0;
1895 }
252b5132 1896
29b0f896
AM		 1897 if ((i.tm.opcode_modifier & (Jump | JumpByte | JumpDword))
1898 && i.op[0].disps->X_op == O_constant)
1899 {
1900 /* Convert "jmp constant" (and "call constant") to a jump (call) to
1901 the absolute address given by the constant. Since ix86 jumps and
1902 calls are pc relative, we need to generate a reloc. */
1903 i.op[0].disps->X_add_symbol = &abs_symbol;
1904 i.op[0].disps->X_op = O_symbol;
1905 }
252b5132 1906
29b0f896 1907 if ((i.tm.opcode_modifier & Rex64) != 0)
161a04f6 1908 i.rex |= REX_W;
252b5132 1909
29b0f896
AM		 1910 /* For 8 bit registers we need an empty rex prefix. Also if the
1911 instruction already has a prefix, we need to convert old
1912 registers to new ones. */
773f551c 1913
29b0f896
AM		 1914 if (((i.types[0] & Reg8) != 0
1915 && (i.op[0].regs->reg_flags & RegRex64) != 0)
1916 || ((i.types[1] & Reg8) != 0
1917 && (i.op[1].regs->reg_flags & RegRex64) != 0)
1918 || (((i.types[0] & Reg8) != 0 || (i.types[1] & Reg8) != 0)
1919 && i.rex != 0))
1920 {
1921 int x;
726c5dcd 1922
29b0f896
AM		 1923 i.rex |= REX_OPCODE;
1924 for (x = 0; x < 2; x++)
1925 {
1926 /* Look for 8 bit operand that uses old registers. */
1927 if ((i.types[x] & Reg8) != 0
1928 && (i.op[x].regs->reg_flags & RegRex64) == 0)
773f551c 1929 {
29b0f896
AM		 1930 /* In case it is "hi" register, give up. */
1931 if (i.op[x].regs->reg_num > 3)
a540244d 1932 as_bad (_("can't encode register '%s%s' in an "
4eed87de 1933 "instruction requiring REX prefix."),
a540244d 1934 register_prefix, i.op[x].regs->reg_name);
773f551c 1935
29b0f896
AM		 1936 /* Otherwise it is equivalent to the extended register.
1937 Since the encoding doesn't change this is merely
1938 cosmetic cleanup for debug output. */
1939
1940 i.op[x].regs = i.op[x].regs + 8;
773f551c 1941 }
29b0f896
AM		 1942 }
1943 }
773f551c 1944
29b0f896
AM		 1945 if (i.rex != 0)
1946 add_prefix (REX_OPCODE | i.rex);
1947
1948 /* We are ready to output the insn. */
1949 output_insn ();
1950}
1951
1952static char *
e3bb37b5 1953parse_insn (char *line, char *mnemonic)
29b0f896
AM		 1954{
1955 char *l = line;
1956 char *token_start = l;
1957 char *mnem_p;
5c6af06e
JB		 1958 int supported;
1959 const template *t;
29b0f896
AM		 1960
1961 /* Non-zero if we found a prefix only acceptable with string insns. */
1962 const char *expecting_string_instruction = NULL;
45288df1 1963
29b0f896
AM		 1964 while (1)
1965 {
1966 mnem_p = mnemonic;
1967 while ((*mnem_p = mnemonic_chars[(unsigned char) *l]) != 0)
1968 {
1969 mnem_p++;
1970 if (mnem_p >= mnemonic + MAX_MNEM_SIZE)
45288df1 1971 {
29b0f896
AM		 1972 as_bad (_("no such instruction: `%s'"), token_start);
1973 return NULL;
1974 }
1975 l++;
1976 }
1977 if (!is_space_char (*l)
1978 && *l != END_OF_INSN
e44823cf
JB		 1979 && (intel_syntax
1980 || (*l != PREFIX_SEPARATOR
1981 && *l != ',')))
29b0f896
AM		 1982 {
1983 as_bad (_("invalid character %s in mnemonic"),
1984 output_invalid (*l));
1985 return NULL;
1986 }
1987 if (token_start == l)
1988 {
e44823cf 1989 if (!intel_syntax && *l == PREFIX_SEPARATOR)
29b0f896
AM		 1990 as_bad (_("expecting prefix; got nothing"));
1991 else
1992 as_bad (_("expecting mnemonic; got nothing"));
1993 return NULL;
1994 }
45288df1 1995
29b0f896
AM		 1996 /* Look up instruction (or prefix) via hash table. */
1997 current_templates = hash_find (op_hash, mnemonic);
47926f60 1998
29b0f896
AM		 1999 if (*l != END_OF_INSN
2000 && (!is_space_char (*l) || l[1] != END_OF_INSN)
2001 && current_templates
2002 && (current_templates->start->opcode_modifier & IsPrefix))
2003 {
2dd88dca
JB		 2004 if (current_templates->start->cpu_flags
2005 & (flag_code != CODE_64BIT ? Cpu64 : CpuNo64))
2006 {
2007 as_bad ((flag_code != CODE_64BIT
2008 ? _("`%s' is only supported in 64-bit mode")
2009 : _("`%s' is not supported in 64-bit mode")),
2010 current_templates->start->name);
2011 return NULL;
2012 }
29b0f896
AM		 2013 /* If we are in 16-bit mode, do not allow addr16 or data16.
2014 Similarly, in 32-bit mode, do not allow addr32 or data32. */
2015 if ((current_templates->start->opcode_modifier & (Size16 | Size32))
2016 && flag_code != CODE_64BIT
2017 && (((current_templates->start->opcode_modifier & Size32) != 0)
2018 ^ (flag_code == CODE_16BIT)))
2019 {
2020 as_bad (_("redundant %s prefix"),
2021 current_templates->start->name);
2022 return NULL;
45288df1 2023 }
29b0f896
AM		 2024 /* Add prefix, checking for repeated prefixes. */
2025 switch (add_prefix (current_templates->start->base_opcode))
2026 {
2027 case 0:
2028 return NULL;
2029 case 2:
2030 expecting_string_instruction = current_templates->start->name;
2031 break;
2032 }
2033 /* Skip past PREFIX_SEPARATOR and reset token_start. */
2034 token_start = ++l;
2035 }
2036 else
2037 break;
2038 }
45288df1 2039
29b0f896
AM		 2040 if (!current_templates)
2041 {
2042 /* See if we can get a match by trimming off a suffix. */
2043 switch (mnem_p[-1])
2044 {
2045 case WORD_MNEM_SUFFIX:
9306ca4a
JB		 2046 if (intel_syntax && (intel_float_operand (mnemonic) & 2))
2047 i.suffix = SHORT_MNEM_SUFFIX;
2048 else
29b0f896
AM		 2049 case BYTE_MNEM_SUFFIX:
2050 case QWORD_MNEM_SUFFIX:
2051 i.suffix = mnem_p[-1];
2052 mnem_p[-1] = '\0';
2053 current_templates = hash_find (op_hash, mnemonic);
2054 break;
2055 case SHORT_MNEM_SUFFIX:
2056 case LONG_MNEM_SUFFIX:
2057 if (!intel_syntax)
2058 {
2059 i.suffix = mnem_p[-1];
2060 mnem_p[-1] = '\0';
2061 current_templates = hash_find (op_hash, mnemonic);
2062 }
2063 break;
252b5132 2064
29b0f896
AM		 2065 /* Intel Syntax. */
2066 case 'd':
2067 if (intel_syntax)
2068 {
9306ca4a 2069 if (intel_float_operand (mnemonic) == 1)
29b0f896
AM		 2070 i.suffix = SHORT_MNEM_SUFFIX;
2071 else
2072 i.suffix = LONG_MNEM_SUFFIX;
2073 mnem_p[-1] = '\0';
2074 current_templates = hash_find (op_hash, mnemonic);
2075 }
2076 break;
2077 }
2078 if (!current_templates)
2079 {
2080 as_bad (_("no such instruction: `%s'"), token_start);
2081 return NULL;
2082 }
2083 }
252b5132 2084
29b0f896
AM		 2085 if (current_templates->start->opcode_modifier & (Jump | JumpByte))
2086 {
2087 /* Check for a branch hint. We allow ",pt" and ",pn" for
2088 predict taken and predict not taken respectively.
2089 I'm not sure that branch hints actually do anything on loop
2090 and jcxz insns (JumpByte) for current Pentium4 chips. They
2091 may work in the future and it doesn't hurt to accept them
2092 now. */
2093 if (l[0] == ',' && l[1] == 'p')
2094 {
2095 if (l[2] == 't')
2096 {
2097 if (!add_prefix (DS_PREFIX_OPCODE))
2098 return NULL;
2099 l += 3;
2100 }
2101 else if (l[2] == 'n')
2102 {
2103 if (!add_prefix (CS_PREFIX_OPCODE))
2104 return NULL;
2105 l += 3;
2106 }
2107 }
2108 }
2109 /* Any other comma loses. */
2110 if (*l == ',')
2111 {
2112 as_bad (_("invalid character %s in mnemonic"),
2113 output_invalid (*l));
2114 return NULL;
2115 }
252b5132 2116
29b0f896 2117 /* Check if instruction is supported on specified architecture. */
5c6af06e
JB		 2118 supported = 0;
2119 for (t = current_templates->start; t < current_templates->end; ++t)
2120 {
2121 if (!((t->cpu_flags & ~(Cpu64 | CpuNo64))
2122 & ~(cpu_arch_flags & ~(Cpu64 | CpuNo64))))
64e74474 2123 supported |= 1;
5c6af06e 2124 if (!(t->cpu_flags & (flag_code == CODE_64BIT ? CpuNo64 : Cpu64)))
64e74474 2125 supported |= 2;
5c6af06e
JB		 2126 }
2127 if (!(supported & 2))
2128 {
2129 as_bad (flag_code == CODE_64BIT
2130 ? _("`%s' is not supported in 64-bit mode")
2131 : _("`%s' is only supported in 64-bit mode"),
2132 current_templates->start->name);
2133 return NULL;
2134 }
2135 if (!(supported & 1))
29b0f896 2136 {
5c6af06e
JB		 2137 as_warn (_("`%s' is not supported on `%s%s'"),
2138 current_templates->start->name,
2139 cpu_arch_name,
2140 cpu_sub_arch_name ? cpu_sub_arch_name : "");
29b0f896
AM		 2141 }
2142 else if ((Cpu386 & ~cpu_arch_flags) && (flag_code != CODE_16BIT))
2143 {
2144 as_warn (_("use .code16 to ensure correct addressing mode"));
2145 }
252b5132 2146
29b0f896 2147 /* Check for rep/repne without a string instruction. */
f41bbced 2148 if (expecting_string_instruction)
29b0f896 2149 {
f41bbced
JB		 2150 static templates override;
2151
2152 for (t = current_templates->start; t < current_templates->end; ++t)
2153 if (t->opcode_modifier & IsString)
2154 break;
2155 if (t >= current_templates->end)
2156 {
2157 as_bad (_("expecting string instruction after `%s'"),
64e74474 2158 expecting_string_instruction);
f41bbced
JB		 2159 return NULL;
2160 }
2161 for (override.start = t; t < current_templates->end; ++t)
2162 if (!(t->opcode_modifier & IsString))
2163 break;
2164 override.end = t;
2165 current_templates = &override;
29b0f896 2166 }
252b5132 2167
29b0f896
AM		 2168 return l;
2169}
252b5132 2170
29b0f896 2171static char *
e3bb37b5 2172parse_operands (char *l, const char *mnemonic)
29b0f896
AM		 2173{
2174 char *token_start;
3138f287 2175
29b0f896
AM		 2176 /* 1 if operand is pending after ','. */
2177 unsigned int expecting_operand = 0;
252b5132 2178
29b0f896
AM		 2179 /* Non-zero if operand parens not balanced. */
2180 unsigned int paren_not_balanced;
2181
2182 while (*l != END_OF_INSN)
2183 {
2184 /* Skip optional white space before operand. */
2185 if (is_space_char (*l))
2186 ++l;
2187 if (!is_operand_char (*l) && *l != END_OF_INSN)
2188 {
2189 as_bad (_("invalid character %s before operand %d"),
2190 output_invalid (*l),
2191 i.operands + 1);
2192 return NULL;
2193 }
2194 token_start = l; /* after white space */
2195 paren_not_balanced = 0;
2196 while (paren_not_balanced || *l != ',')
2197 {
2198 if (*l == END_OF_INSN)
2199 {
2200 if (paren_not_balanced)
2201 {
2202 if (!intel_syntax)
2203 as_bad (_("unbalanced parenthesis in operand %d."),
2204 i.operands + 1);
2205 else
2206 as_bad (_("unbalanced brackets in operand %d."),
2207 i.operands + 1);
2208 return NULL;
2209 }
2210 else
2211 break; /* we are done */
2212 }
2213 else if (!is_operand_char (*l) && !is_space_char (*l))
2214 {
2215 as_bad (_("invalid character %s in operand %d"),
2216 output_invalid (*l),
2217 i.operands + 1);
2218 return NULL;
2219 }
2220 if (!intel_syntax)
2221 {
2222 if (*l == '(')
2223 ++paren_not_balanced;
2224 if (*l == ')')
2225 --paren_not_balanced;
2226 }
2227 else
2228 {
2229 if (*l == '[')
2230 ++paren_not_balanced;
2231 if (*l == ']')
2232 --paren_not_balanced;
2233 }
2234 l++;
2235 }
2236 if (l != token_start)
2237 { /* Yes, we've read in another operand. */
2238 unsigned int operand_ok;
2239 this_operand = i.operands++;
2240 if (i.operands > MAX_OPERANDS)
2241 {
2242 as_bad (_("spurious operands; (%d operands/instruction max)"),
2243 MAX_OPERANDS);
2244 return NULL;
2245 }
2246 /* Now parse operand adding info to 'i' as we go along. */
2247 END_STRING_AND_SAVE (l);
2248
2249 if (intel_syntax)
2250 operand_ok =
2251 i386_intel_operand (token_start,
2252 intel_float_operand (mnemonic));
2253 else
2254 operand_ok = i386_operand (token_start);
2255
2256 RESTORE_END_STRING (l);
2257 if (!operand_ok)
2258 return NULL;
2259 }
2260 else
2261 {
2262 if (expecting_operand)
2263 {
2264 expecting_operand_after_comma:
2265 as_bad (_("expecting operand after ','; got nothing"));
2266 return NULL;
2267 }
2268 if (*l == ',')
2269 {
2270 as_bad (_("expecting operand before ','; got nothing"));
2271 return NULL;
2272 }
2273 }
7f3f1ea2 2274
29b0f896
AM		 2275 /* Now *l must be either ',' or END_OF_INSN. */
2276 if (*l == ',')
2277 {
2278 if (*++l == END_OF_INSN)
2279 {
2280 /* Just skip it, if it's \n complain. */
2281 goto expecting_operand_after_comma;
2282 }
2283 expecting_operand = 1;
2284 }
2285 }
2286 return l;
2287}
7f3f1ea2 2288
050dfa73 2289static void
4d456e3d 2290swap_2_operands (int xchg1, int xchg2)
050dfa73
MM		 2291{
2292 union i386_op temp_op;
2293 unsigned int temp_type;
2294 enum bfd_reloc_code_real temp_reloc;
4eed87de 2295
050dfa73
MM		 2296 temp_type = i.types[xchg2];
2297 i.types[xchg2] = i.types[xchg1];
2298 i.types[xchg1] = temp_type;
2299 temp_op = i.op[xchg2];
2300 i.op[xchg2] = i.op[xchg1];
2301 i.op[xchg1] = temp_op;
2302 temp_reloc = i.reloc[xchg2];
2303 i.reloc[xchg2] = i.reloc[xchg1];
2304 i.reloc[xchg1] = temp_reloc;
2305}
2306
29b0f896 2307static void
e3bb37b5 2308swap_operands (void)
29b0f896 2309{
b7c61d9a 2310 switch (i.operands)
050dfa73 2311 {
b7c61d9a 2312 case 4:
4d456e3d 2313 swap_2_operands (1, i.operands - 2);
b7c61d9a
L		 2314 case 3:
2315 case 2:
4d456e3d 2316 swap_2_operands (0, i.operands - 1);
b7c61d9a
L		 2317 break;
2318 default:
2319 abort ();
29b0f896 2320 }
29b0f896
AM		 2321
2322 if (i.mem_operands == 2)
2323 {
2324 const seg_entry *temp_seg;
2325 temp_seg = i.seg[0];
2326 i.seg[0] = i.seg[1];
2327 i.seg[1] = temp_seg;
2328 }
2329}
252b5132 2330
29b0f896
AM		 2331/* Try to ensure constant immediates are represented in the smallest
2332 opcode possible. */
2333static void
e3bb37b5 2334optimize_imm (void)
29b0f896
AM		 2335{
2336 char guess_suffix = 0;
2337 int op;
252b5132 2338
29b0f896
AM		 2339 if (i.suffix)
2340 guess_suffix = i.suffix;
2341 else if (i.reg_operands)
2342 {
2343 /* Figure out a suffix from the last register operand specified.
2344 We can't do this properly yet, ie. excluding InOutPortReg,
2345 but the following works for instructions with immediates.
2346 In any case, we can't set i.suffix yet. */
2347 for (op = i.operands; --op >= 0;)
2348 if (i.types[op] & Reg)
252b5132 2349 {
29b0f896
AM		 2350 if (i.types[op] & Reg8)
2351 guess_suffix = BYTE_MNEM_SUFFIX;
2352 else if (i.types[op] & Reg16)
2353 guess_suffix = WORD_MNEM_SUFFIX;
2354 else if (i.types[op] & Reg32)
2355 guess_suffix = LONG_MNEM_SUFFIX;
2356 else if (i.types[op] & Reg64)
2357 guess_suffix = QWORD_MNEM_SUFFIX;
2358 break;
252b5132 2359 }
29b0f896
AM		 2360 }
2361 else if ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0))
2362 guess_suffix = WORD_MNEM_SUFFIX;
2363
2364 for (op = i.operands; --op >= 0;)
2365 if (i.types[op] & Imm)
2366 {
2367 switch (i.op[op].imms->X_op)
252b5132 2368 {
29b0f896
AM		 2369 case O_constant:
2370 /* If a suffix is given, this operand may be shortened. */
2371 switch (guess_suffix)
252b5132 2372 {
29b0f896
AM		 2373 case LONG_MNEM_SUFFIX:
2374 i.types[op] |= Imm32 | Imm64;
2375 break;
2376 case WORD_MNEM_SUFFIX:
2377 i.types[op] |= Imm16 | Imm32S | Imm32 | Imm64;
2378 break;
2379 case BYTE_MNEM_SUFFIX:
2380 i.types[op] |= Imm16 | Imm8 | Imm8S | Imm32S | Imm32 | Imm64;
2381 break;
252b5132 2382 }
252b5132 2383
29b0f896
AM		 2384 /* If this operand is at most 16 bits, convert it
2385 to a signed 16 bit number before trying to see
2386 whether it will fit in an even smaller size.
2387 This allows a 16-bit operand such as $0xffe0 to
2388 be recognised as within Imm8S range. */
2389 if ((i.types[op] & Imm16)
2390 && (i.op[op].imms->X_add_number & ~(offsetT) 0xffff) == 0)
252b5132 2391 {
29b0f896
AM		 2392 i.op[op].imms->X_add_number =
2393 (((i.op[op].imms->X_add_number & 0xffff) ^ 0x8000) - 0x8000);
2394 }
2395 if ((i.types[op] & Imm32)
2396 && ((i.op[op].imms->X_add_number & ~(((offsetT) 2 << 31) - 1))
2397 == 0))
2398 {
2399 i.op[op].imms->X_add_number = ((i.op[op].imms->X_add_number
2400 ^ ((offsetT) 1 << 31))
2401 - ((offsetT) 1 << 31));
2402 }
2403 i.types[op] |= smallest_imm_type (i.op[op].imms->X_add_number);
252b5132 2404
29b0f896
AM		 2405 /* We must avoid matching of Imm32 templates when 64bit
2406 only immediate is available. */
2407 if (guess_suffix == QWORD_MNEM_SUFFIX)
2408 i.types[op] &= ~Imm32;
2409 break;
252b5132 2410
29b0f896
AM		 2411 case O_absent:
2412 case O_register:
2413 abort ();
2414
2415 /* Symbols and expressions. */
2416 default:
9cd96992
JB		 2417 /* Convert symbolic operand to proper sizes for matching, but don't
2418 prevent matching a set of insns that only supports sizes other
2419 than those matching the insn suffix. */
2420 {
2421 unsigned int mask, allowed = 0;
2422 const template *t;
2423
4eed87de
AM		 2424 for (t = current_templates->start;
2425 t < current_templates->end;
2426 ++t)
2427 allowed |= t->operand_types[op];
9cd96992
JB		 2428 switch (guess_suffix)
2429 {
2430 case QWORD_MNEM_SUFFIX:
2431 mask = Imm64 | Imm32S;
2432 break;
2433 case LONG_MNEM_SUFFIX:
2434 mask = Imm32;
2435 break;
2436 case WORD_MNEM_SUFFIX:
2437 mask = Imm16;
2438 break;
2439 case BYTE_MNEM_SUFFIX:
2440 mask = Imm8;
2441 break;
2442 default:
2443 mask = 0;
2444 break;
2445 }
64e74474
AM		 2446 if (mask & allowed)
2447 i.types[op] &= mask;
9cd96992 2448 }
29b0f896 2449 break;
252b5132 2450 }
29b0f896
AM		 2451 }
2452}
47926f60 2453
29b0f896
AM		 2454/* Try to use the smallest displacement type too. */
2455static void
e3bb37b5 2456optimize_disp (void)
29b0f896
AM		 2457{
2458 int op;
3e73aa7c 2459
29b0f896 2460 for (op = i.operands; --op >= 0;)
b300c311 2461 if (i.types[op] & Disp)
252b5132 2462 {
b300c311 2463 if (i.op[op].disps->X_op == O_constant)
252b5132 2464 {
b300c311 2465 offsetT disp = i.op[op].disps->X_add_number;
29b0f896 2466
b300c311
L		 2467 if ((i.types[op] & Disp16)
2468 && (disp & ~(offsetT) 0xffff) == 0)
2469 {
2470 /* If this operand is at most 16 bits, convert
2471 to a signed 16 bit number and don't use 64bit
2472 displacement. */
2473 disp = (((disp & 0xffff) ^ 0x8000) - 0x8000);
2474 i.types[op] &= ~Disp64;
2475 }
2476 if ((i.types[op] & Disp32)
2477 && (disp & ~(((offsetT) 2 << 31) - 1)) == 0)
2478 {
2479 /* If this operand is at most 32 bits, convert
2480 to a signed 32 bit number and don't use 64bit
2481 displacement. */
2482 disp &= (((offsetT) 2 << 31) - 1);
2483 disp = (disp ^ ((offsetT) 1 << 31)) - ((addressT) 1 << 31);
2484 i.types[op] &= ~Disp64;
2485 }
2486 if (!disp && (i.types[op] & BaseIndex))
2487 {
2488 i.types[op] &= ~Disp;
2489 i.op[op].disps = 0;
2490 i.disp_operands--;
2491 }
2492 else if (flag_code == CODE_64BIT)
2493 {
2494 if (fits_in_signed_long (disp))
28a9d8f5
L		 2495 {
2496 i.types[op] &= ~Disp64;
2497 i.types[op] |= Disp32S;
2498 }
b300c311
L		 2499 if (fits_in_unsigned_long (disp))
2500 i.types[op] |= Disp32;
2501 }
2502 if ((i.types[op] & (Disp32 | Disp32S | Disp16))
2503 && fits_in_signed_byte (disp))
2504 i.types[op] |= Disp8;
252b5132 2505 }
67a4f2b7
AO		 2506 else if (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
2507 || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL)
2508 {
2509 fix_new_exp (frag_now, frag_more (0) - frag_now->fr_literal, 0,
2510 i.op[op].disps, 0, i.reloc[op]);
2511 i.types[op] &= ~Disp;
2512 }
2513 else
b300c311
L		 2514 /* We only support 64bit displacement on constants. */
2515 i.types[op] &= ~Disp64;
252b5132 2516 }
29b0f896
AM		 2517}
2518
2519static int
e3bb37b5 2520match_template (void)
29b0f896
AM		 2521{
2522 /* Points to template once we've found it. */
2523 const template *t;
f48ff2ae 2524 unsigned int overlap0, overlap1, overlap2, overlap3;
29b0f896
AM		 2525 unsigned int found_reverse_match;
2526 int suffix_check;
f48ff2ae 2527 unsigned int operand_types [MAX_OPERANDS];
539e75ad 2528 int addr_prefix_disp;
a5c311ca 2529 unsigned int j;
29b0f896 2530
f48ff2ae
L		 2531#if MAX_OPERANDS != 4
2532# error "MAX_OPERANDS must be 4."
2533#endif
2534
29b0f896
AM		 2535#define MATCH(overlap, given, template) \
2536 ((overlap & ~JumpAbsolute) \
2537 && (((given) & (BaseIndex | JumpAbsolute)) \
2538 == ((overlap) & (BaseIndex | JumpAbsolute))))
2539
2540 /* If given types r0 and r1 are registers they must be of the same type
2541 unless the expected operand type register overlap is null.
2542 Note that Acc in a template matches every size of reg. */
2543#define CONSISTENT_REGISTER_MATCH(m0, g0, t0, m1, g1, t1) \
2544 (((g0) & Reg) == 0 || ((g1) & Reg) == 0 \
2545 || ((g0) & Reg) == ((g1) & Reg) \
2546 || ((((m0) & Acc) ? Reg : (t0)) & (((m1) & Acc) ? Reg : (t1)) & Reg) == 0 )
2547
2548 overlap0 = 0;
2549 overlap1 = 0;
2550 overlap2 = 0;
f48ff2ae 2551 overlap3 = 0;
29b0f896 2552 found_reverse_match = 0;
a5c311ca
L		 2553 for (j = 0; j < MAX_OPERANDS; j++)
2554 operand_types [j] = 0;
539e75ad 2555 addr_prefix_disp = -1;
29b0f896
AM		 2556 suffix_check = (i.suffix == BYTE_MNEM_SUFFIX
2557 ? No_bSuf
2558 : (i.suffix == WORD_MNEM_SUFFIX
2559 ? No_wSuf
2560 : (i.suffix == SHORT_MNEM_SUFFIX
2561 ? No_sSuf
2562 : (i.suffix == LONG_MNEM_SUFFIX
2563 ? No_lSuf
2564 : (i.suffix == QWORD_MNEM_SUFFIX
2565 ? No_qSuf
2566 : (i.suffix == LONG_DOUBLE_MNEM_SUFFIX
2567 ? No_xSuf : 0))))));
2568
45aa61fe 2569 for (t = current_templates->start; t < current_templates->end; t++)
29b0f896 2570 {
539e75ad
L		 2571 addr_prefix_disp = -1;
2572
29b0f896
AM		 2573 /* Must have right number of operands. */
2574 if (i.operands != t->operands)
2575 continue;
2576
20592a94 2577 /* Check the suffix, except for some instructions in intel mode. */
29b0f896
AM		 2578 if ((t->opcode_modifier & suffix_check)
2579 && !(intel_syntax
9306ca4a 2580 && (t->opcode_modifier & IgnoreSize)))
29b0f896
AM		 2581 continue;
2582
a5c311ca
L		 2583 for (j = 0; j < MAX_OPERANDS; j++)
2584 operand_types [j] = t->operand_types [j];
539e75ad 2585
45aa61fe
AM		 2586 /* In general, don't allow 64-bit operands in 32-bit mode. */
2587 if (i.suffix == QWORD_MNEM_SUFFIX
2588 && flag_code != CODE_64BIT
2589 && (intel_syntax
2590 ? (!(t->opcode_modifier & IgnoreSize)
2591 && !intel_float_operand (t->name))
2592 : intel_float_operand (t->name) != 2)
539e75ad
L		 2593 && (!(operand_types[0] & (RegMMX | RegXMM))
2594 || !(operand_types[t->operands > 1] & (RegMMX | RegXMM)))
45aa61fe
AM		 2595 && (t->base_opcode != 0x0fc7
2596 || t->extension_opcode != 1 /* cmpxchg8b */))
2597 continue;
2598
29b0f896
AM		 2599 /* Do not verify operands when there are none. */
2600 else if (!t->operands)
2601 {
2602 if (t->cpu_flags & ~cpu_arch_flags)
2603 continue;
2604 /* We've found a match; break out of loop. */
2605 break;
2606 }
252b5132 2607
539e75ad
L		 2608 /* Address size prefix will turn Disp64/Disp32/Disp16 operand
2609 into Disp32/Disp16/Disp32 operand. */
2610 if (i.prefix[ADDR_PREFIX] != 0)
2611 {
a5c311ca 2612 unsigned int DispOn = 0, DispOff = 0;
539e75ad
L		 2613
2614 switch (flag_code)
2615 {
2616 case CODE_16BIT:
2617 DispOn = Disp32;
2618 DispOff = Disp16;
2619 break;
2620 case CODE_32BIT:
2621 DispOn = Disp16;
2622 DispOff = Disp32;
2623 break;
2624 case CODE_64BIT:
2625 DispOn = Disp32;
2626 DispOff = Disp64;
2627 break;
2628 }
2629
f48ff2ae 2630 for (j = 0; j < MAX_OPERANDS; j++)
539e75ad
L		 2631 {
2632 /* There should be only one Disp operand. */
2633 if ((operand_types[j] & DispOff))
2634 {
2635 addr_prefix_disp = j;
2636 operand_types[j] |= DispOn;
2637 operand_types[j] &= ~DispOff;
2638 break;
2639 }
2640 }
2641 }
2642
2643 overlap0 = i.types[0] & operand_types[0];
29b0f896
AM		 2644 switch (t->operands)
2645 {
2646 case 1:
539e75ad 2647 if (!MATCH (overlap0, i.types[0], operand_types[0]))
29b0f896
AM		 2648 continue;
2649 break;
2650 case 2:
8b38ad71
L		 2651 /* xchg %eax, %eax is a special case. It is an aliase for nop
2652 only in 32bit mode and we can use opcode 0x90. In 64bit
2653 mode, we can't use 0x90 for xchg %eax, %eax since it should
2654 zero-extend %eax to %rax. */
2655 if (flag_code == CODE_64BIT
2656 && t->base_opcode == 0x90
2657 && i.types [0] == (Acc | Reg32)
2658 && i.types [1] == (Acc | Reg32))
2659 continue;
29b0f896 2660 case 3:
f48ff2ae 2661 case 4:
539e75ad
L		 2662 overlap1 = i.types[1] & operand_types[1];
2663 if (!MATCH (overlap0, i.types[0], operand_types[0])
2664 || !MATCH (overlap1, i.types[1], operand_types[1])
cb712a9e 2665 /* monitor in SSE3 is a very special case. The first
708587a4 2666 register and the second register may have different
381d071f 2667 sizes. The same applies to crc32 in SSE4.2. */
cb712a9e
L		 2668 || !((t->base_opcode == 0x0f01
2669 && t->extension_opcode == 0xc8)
381d071f 2670 || t->base_opcode == 0xf20f38f1
cb712a9e 2671 || CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
539e75ad 2672 operand_types[0],
cb712a9e 2673 overlap1, i.types[1],
539e75ad 2674 operand_types[1])))
29b0f896
AM		 2675 {
2676 /* Check if other direction is valid ... */
2677 if ((t->opcode_modifier & (D | FloatD)) == 0)
2678 continue;
2679
2680 /* Try reversing direction of operands. */
539e75ad
L		 2681 overlap0 = i.types[0] & operand_types[1];
2682 overlap1 = i.types[1] & operand_types[0];
2683 if (!MATCH (overlap0, i.types[0], operand_types[1])
2684 || !MATCH (overlap1, i.types[1], operand_types[0])
29b0f896 2685 || !CONSISTENT_REGISTER_MATCH (overlap0, i.types[0],
539e75ad 2686 operand_types[1],
29b0f896 2687 overlap1, i.types[1],
539e75ad 2688 operand_types[0]))
29b0f896
AM		 2689 {
2690 /* Does not match either direction. */
2691 continue;
2692 }
2693 /* found_reverse_match holds which of D or FloatDR
2694 we've found. */
8a2ed489
L		 2695 if ((t->opcode_modifier & D))
2696 found_reverse_match = Opcode_D;
2697 else if ((t->opcode_modifier & FloatD))
2698 found_reverse_match = Opcode_FloatD;
2699 else
2700 found_reverse_match = 0;
2701 if ((t->opcode_modifier & FloatR))
2702 found_reverse_match |= Opcode_FloatR;
29b0f896 2703 }
f48ff2ae 2704 else
29b0f896 2705 {
f48ff2ae 2706 /* Found a forward 2 operand match here. */
d1cbb4db
L		 2707 switch (t->operands)
2708 {
2709 case 4:
2710 overlap3 = i.types[3] & operand_types[3];
2711 case 3:
2712 overlap2 = i.types[2] & operand_types[2];
2713 break;
2714 }
29b0f896 2715
f48ff2ae
L		 2716 switch (t->operands)
2717 {
2718 case 4:
2719 if (!MATCH (overlap3, i.types[3], operand_types[3])
2720 || !CONSISTENT_REGISTER_MATCH (overlap2,
2721 i.types[2],
2722 operand_types[2],
2723 overlap3,
2724 i.types[3],
2725 operand_types[3]))
2726 continue;
2727 case 3:
2728 /* Here we make use of the fact that there are no
2729 reverse match 3 operand instructions, and all 3
2730 operand instructions only need to be checked for
2731 register consistency between operands 2 and 3. */
2732 if (!MATCH (overlap2, i.types[2], operand_types[2])
2733 || !CONSISTENT_REGISTER_MATCH (overlap1,
2734 i.types[1],
2735 operand_types[1],
2736 overlap2,
2737 i.types[2],
2738 operand_types[2]))
2739 continue;
2740 break;
2741 }
29b0f896 2742 }
f48ff2ae 2743 /* Found either forward/reverse 2, 3 or 4 operand match here:
29b0f896
AM		 2744 slip through to break. */
2745 }
2746 if (t->cpu_flags & ~cpu_arch_flags)
2747 {
2748 found_reverse_match = 0;
2749 continue;
2750 }
2751 /* We've found a match; break out of loop. */
2752 break;
2753 }
2754
2755 if (t == current_templates->end)
2756 {
2757 /* We found no match. */
2758 as_bad (_("suffix or operands invalid for `%s'"),
2759 current_templates->start->name);
2760 return 0;
2761 }
252b5132 2762
29b0f896
AM		 2763 if (!quiet_warnings)
2764 {
2765 if (!intel_syntax
2766 && ((i.types[0] & JumpAbsolute)
539e75ad 2767 != (operand_types[0] & JumpAbsolute)))
29b0f896
AM		 2768 {
2769 as_warn (_("indirect %s without `*'"), t->name);
2770 }
2771
2772 if ((t->opcode_modifier & (IsPrefix | IgnoreSize))
2773 == (IsPrefix | IgnoreSize))
2774 {
2775 /* Warn them that a data or address size prefix doesn't
2776 affect assembly of the next line of code. */
2777 as_warn (_("stand-alone `%s' prefix"), t->name);
2778 }
2779 }
2780
2781 /* Copy the template we found. */
2782 i.tm = *t;
539e75ad
L		 2783
2784 if (addr_prefix_disp != -1)
2785 i.tm.operand_types[addr_prefix_disp]
2786 = operand_types[addr_prefix_disp];
2787
29b0f896
AM		 2788 if (found_reverse_match)
2789 {
2790 /* If we found a reverse match we must alter the opcode
2791 direction bit. found_reverse_match holds bits to change
2792 (different for int & float insns). */
2793
2794 i.tm.base_opcode ^= found_reverse_match;
2795
539e75ad
L		 2796 i.tm.operand_types[0] = operand_types[1];
2797 i.tm.operand_types[1] = operand_types[0];
29b0f896
AM		 2798 }
2799
2800 return 1;
2801}
2802
2803static int
e3bb37b5 2804check_string (void)
29b0f896
AM		 2805{
2806 int mem_op = (i.types[0] & AnyMem) ? 0 : 1;
2807 if ((i.tm.operand_types[mem_op] & EsSeg) != 0)
2808 {
2809 if (i.seg[0] != NULL && i.seg[0] != &es)
2810 {
2811 as_bad (_("`%s' operand %d must use `%%es' segment"),
2812 i.tm.name,
2813 mem_op + 1);
2814 return 0;
2815 }
2816 /* There's only ever one segment override allowed per instruction.
2817 This instruction possibly has a legal segment override on the
2818 second operand, so copy the segment to where non-string
2819 instructions store it, allowing common code. */
2820 i.seg[0] = i.seg[1];
2821 }
2822 else if ((i.tm.operand_types[mem_op + 1] & EsSeg) != 0)
2823 {
2824 if (i.seg[1] != NULL && i.seg[1] != &es)
2825 {
2826 as_bad (_("`%s' operand %d must use `%%es' segment"),
2827 i.tm.name,
2828 mem_op + 2);
2829 return 0;
2830 }
2831 }
2832 return 1;
2833}
2834
2835static int
543613e9 2836process_suffix (void)
29b0f896
AM		 2837{
2838 /* If matched instruction specifies an explicit instruction mnemonic
2839 suffix, use it. */
2840 if (i.tm.opcode_modifier & (Size16 | Size32 | Size64))
2841 {
2842 if (i.tm.opcode_modifier & Size16)
2843 i.suffix = WORD_MNEM_SUFFIX;
2844 else if (i.tm.opcode_modifier & Size64)
2845 i.suffix = QWORD_MNEM_SUFFIX;
2846 else
2847 i.suffix = LONG_MNEM_SUFFIX;
2848 }
2849 else if (i.reg_operands)
2850 {
2851 /* If there's no instruction mnemonic suffix we try to invent one
2852 based on register operands. */
2853 if (!i.suffix)
2854 {
2855 /* We take i.suffix from the last register operand specified,
2856 Destination register type is more significant than source
381d071f
L		 2857 register type. crc32 in SSE4.2 prefers source register
2858 type. */
2859 if (i.tm.base_opcode == 0xf20f38f1)
2860 {
2861 if ((i.types[0] & Reg))
2862 i.suffix = ((i.types[0] & Reg16) ? WORD_MNEM_SUFFIX :
29b0f896 2863 LONG_MNEM_SUFFIX);
381d071f 2864 }
9344ff29 2865 else if (i.tm.base_opcode == 0xf20f38f0)
20592a94
L		 2866 {
2867 if ((i.types[0] & Reg8))
2868 i.suffix = BYTE_MNEM_SUFFIX;
2869 }
381d071f
L		 2870
2871 if (!i.suffix)
2872 {
2873 int op;
2874
20592a94
L		 2875 if (i.tm.base_opcode == 0xf20f38f1
2876 || i.tm.base_opcode == 0xf20f38f0)
2877 {
2878 /* We have to know the operand size for crc32. */
2879 as_bad (_("ambiguous memory operand size for `%s`"),
2880 i.tm.name);
2881 return 0;
2882 }
2883
381d071f
L		 2884 for (op = i.operands; --op >= 0;)
2885 if ((i.types[op] & Reg)
2886 && !(i.tm.operand_types[op] & InOutPortReg))
2887 {
2888 i.suffix = ((i.types[op] & Reg8) ? BYTE_MNEM_SUFFIX :
2889 (i.types[op] & Reg16) ? WORD_MNEM_SUFFIX :
2890 (i.types[op] & Reg64) ? QWORD_MNEM_SUFFIX :
2891 LONG_MNEM_SUFFIX);
2892 break;
2893 }
2894 }
29b0f896
AM		 2895 }
2896 else if (i.suffix == BYTE_MNEM_SUFFIX)
2897 {
2898 if (!check_byte_reg ())
2899 return 0;
2900 }
2901 else if (i.suffix == LONG_MNEM_SUFFIX)
2902 {
2903 if (!check_long_reg ())
2904 return 0;
2905 }
2906 else if (i.suffix == QWORD_MNEM_SUFFIX)
2907 {
2908 if (!check_qword_reg ())
2909 return 0;
2910 }
2911 else if (i.suffix == WORD_MNEM_SUFFIX)
2912 {
2913 if (!check_word_reg ())
2914 return 0;
2915 }
2916 else if (intel_syntax && (i.tm.opcode_modifier & IgnoreSize))
2917 /* Do nothing if the instruction is going to ignore the prefix. */
2918 ;
2919 else
2920 abort ();
2921 }
9306ca4a
JB		 2922 else if ((i.tm.opcode_modifier & DefaultSize)
2923 && !i.suffix
2924 /* exclude fldenv/frstor/fsave/fstenv */
2925 && (i.tm.opcode_modifier & No_sSuf))
29b0f896
AM		 2926 {
2927 i.suffix = stackop_size;
2928 }
9306ca4a
JB		 2929 else if (intel_syntax
2930 && !i.suffix
2931 && ((i.tm.operand_types[0] & JumpAbsolute)
64e74474
AM		 2932 || (i.tm.opcode_modifier & (JumpByte|JumpInterSegment))
2933 || (i.tm.base_opcode == 0x0f01 /* [ls][gi]dt */
2934 && i.tm.extension_opcode <= 3)))
9306ca4a
JB		 2935 {
2936 switch (flag_code)
2937 {
2938 case CODE_64BIT:
2939 if (!(i.tm.opcode_modifier & No_qSuf))
2940 {
2941 i.suffix = QWORD_MNEM_SUFFIX;
2942 break;
2943 }
2944 case CODE_32BIT:
2945 if (!(i.tm.opcode_modifier & No_lSuf))
2946 i.suffix = LONG_MNEM_SUFFIX;
2947 break;
2948 case CODE_16BIT:
2949 if (!(i.tm.opcode_modifier & No_wSuf))
2950 i.suffix = WORD_MNEM_SUFFIX;
2951 break;
2952 }
2953 }
252b5132 2954
9306ca4a 2955 if (!i.suffix)
29b0f896 2956 {
9306ca4a
JB		 2957 if (!intel_syntax)
2958 {
2959 if (i.tm.opcode_modifier & W)
2960 {
4eed87de
AM		 2961 as_bad (_("no instruction mnemonic suffix given and "
2962 "no register operands; can't size instruction"));
9306ca4a
JB		 2963 return 0;
2964 }
2965 }
2966 else
2967 {
64e74474
AM		 2968 unsigned int suffixes = (~i.tm.opcode_modifier
2969 & (No_bSuf
2970 | No_wSuf
2971 | No_lSuf
2972 | No_sSuf
2973 | No_xSuf
2974 | No_qSuf));
9306ca4a
JB		 2975
2976 if ((i.tm.opcode_modifier & W)
2977 || ((suffixes & (suffixes - 1))
2978 && !(i.tm.opcode_modifier & (DefaultSize | IgnoreSize))))
2979 {
2980 as_bad (_("ambiguous operand size for `%s'"), i.tm.name);
2981 return 0;
2982 }
2983 }
29b0f896 2984 }
252b5132 2985
9306ca4a
JB		 2986 /* Change the opcode based on the operand size given by i.suffix;
2987 We don't need to change things for byte insns. */
2988
29b0f896
AM		 2989 if (i.suffix && i.suffix != BYTE_MNEM_SUFFIX)
2990 {
2991 /* It's not a byte, select word/dword operation. */
2992 if (i.tm.opcode_modifier & W)
2993 {
2994 if (i.tm.opcode_modifier & ShortForm)
2995 i.tm.base_opcode |= 8;
2996 else
2997 i.tm.base_opcode |= 1;
2998 }
0f3f3d8b 2999
29b0f896
AM		 3000 /* Now select between word & dword operations via the operand
3001 size prefix, except for instructions that will ignore this
3002 prefix anyway. */
cb712a9e
L		 3003 if (i.tm.base_opcode == 0x0f01 && i.tm.extension_opcode == 0xc8)
3004 {
3005 /* monitor in SSE3 is a very special case. The default size
3006 of AX is the size of mode. The address size override
3007 prefix will change the size of AX. */
3008 if (i.op->regs[0].reg_type &
3009 (flag_code == CODE_32BIT ? Reg16 : Reg32))
3010 if (!add_prefix (ADDR_PREFIX_OPCODE))
3011 return 0;
3012 }
3013 else if (i.suffix != QWORD_MNEM_SUFFIX
3014 && i.suffix != LONG_DOUBLE_MNEM_SUFFIX
3015 && !(i.tm.opcode_modifier & (IgnoreSize | FloatMF))
3016 && ((i.suffix == LONG_MNEM_SUFFIX) == (flag_code == CODE_16BIT)
3017 || (flag_code == CODE_64BIT
3018 && (i.tm.opcode_modifier & JumpByte))))
24eab124
AM		 3019 {
3020 unsigned int prefix = DATA_PREFIX_OPCODE;
543613e9 3021
29b0f896
AM		 3022 if (i.tm.opcode_modifier & JumpByte) /* jcxz, loop */
3023 prefix = ADDR_PREFIX_OPCODE;
252b5132 3024
29b0f896
AM		 3025 if (!add_prefix (prefix))
3026 return 0;
24eab124 3027 }
252b5132 3028
29b0f896
AM		 3029 /* Set mode64 for an operand. */
3030 if (i.suffix == QWORD_MNEM_SUFFIX
9146926a 3031 && flag_code == CODE_64BIT
29b0f896 3032 && (i.tm.opcode_modifier & NoRex64) == 0)
46e883c5
L		 3033 {
3034 /* Special case for xchg %rax,%rax. It is NOP and doesn't
3035 need rex64. */
3036 if (i.operands != 2
3037 || i.types [0] != (Acc | Reg64)
3038 || i.types [1] != (Acc | Reg64)
13a1e313 3039 || i.tm.base_opcode != 0x90)
f6bee062 3040 i.rex |= REX_W;
46e883c5 3041 }
3e73aa7c 3042
29b0f896
AM		 3043 /* Size floating point instruction. */
3044 if (i.suffix == LONG_MNEM_SUFFIX)
543613e9
NC		 3045 if (i.tm.opcode_modifier & FloatMF)
3046 i.tm.base_opcode ^= 4;
29b0f896 3047 }
7ecd2f8b 3048
29b0f896
AM		 3049 return 1;
3050}
3e73aa7c 3051
29b0f896 3052static int
543613e9 3053check_byte_reg (void)
29b0f896
AM		 3054{
3055 int op;
543613e9 3056
29b0f896
AM		 3057 for (op = i.operands; --op >= 0;)
3058 {
3059 /* If this is an eight bit register, it's OK. If it's the 16 or
3060 32 bit version of an eight bit register, we will just use the
3061 low portion, and that's OK too. */
3062 if (i.types[op] & Reg8)
3063 continue;
3064
c3ad16c0
L		 3065 /* movzx, movsx, pextrb and pinsrb should not generate this
3066 warning. */
29b0f896
AM		 3067 if (intel_syntax
3068 && (i.tm.base_opcode == 0xfb7
3069 || i.tm.base_opcode == 0xfb6
3070 || i.tm.base_opcode == 0x63
3071 || i.tm.base_opcode == 0xfbe
c3ad16c0
L		 3072 || i.tm.base_opcode == 0xfbf
3073 || i.tm.base_opcode == 0x660f3a14
3074 || i.tm.base_opcode == 0x660f3a20))
29b0f896
AM		 3075 continue;
3076
9344ff29
L		 3077 /* crc32 doesn't generate this warning. */
3078 if (i.tm.base_opcode == 0xf20f38f0)
3079 continue;
3080
65ec77d2 3081 if ((i.types[op] & WordReg) && i.op[op].regs->reg_num < 4)
29b0f896
AM		 3082 {
3083 /* Prohibit these changes in the 64bit mode, since the
3084 lowering is more complicated. */
3085 if (flag_code == CODE_64BIT
3086 && (i.tm.operand_types[op] & InOutPortReg) == 0)
3087 {
2ca3ace5
L		 3088 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
3089 register_prefix, i.op[op].regs->reg_name,
29b0f896
AM		 3090 i.suffix);
3091 return 0;
3092 }
3093#if REGISTER_WARNINGS
3094 if (!quiet_warnings
3095 && (i.tm.operand_types[op] & InOutPortReg) == 0)
a540244d
L		 3096 as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
3097 register_prefix,
29b0f896
AM		 3098 (i.op[op].regs + (i.types[op] & Reg16
3099 ? REGNAM_AL - REGNAM_AX
3100 : REGNAM_AL - REGNAM_EAX))->reg_name,
a540244d 3101 register_prefix,
29b0f896
AM		 3102 i.op[op].regs->reg_name,
3103 i.suffix);
3104#endif
3105 continue;
3106 }
3107 /* Any other register is bad. */
3108 if (i.types[op] & (Reg | RegMMX | RegXMM
3109 | SReg2 | SReg3
3110 | Control | Debug | Test
3111 | FloatReg | FloatAcc))
3112 {
a540244d
L		 3113 as_bad (_("`%s%s' not allowed with `%s%c'"),
3114 register_prefix,
29b0f896
AM		 3115 i.op[op].regs->reg_name,
3116 i.tm.name,
3117 i.suffix);
3118 return 0;
3119 }
3120 }
3121 return 1;
3122}
3123
3124static int
e3bb37b5 3125check_long_reg (void)
29b0f896
AM		 3126{
3127 int op;
3128
3129 for (op = i.operands; --op >= 0;)
3130 /* Reject eight bit registers, except where the template requires
3131 them. (eg. movzb) */
3132 if ((i.types[op] & Reg8) != 0
3133 && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
3134 {
a540244d
L		 3135 as_bad (_("`%s%s' not allowed with `%s%c'"),
3136 register_prefix,
29b0f896
AM		 3137 i.op[op].regs->reg_name,
3138 i.tm.name,
3139 i.suffix);
3140 return 0;
3141 }
3142 /* Warn if the e prefix on a general reg is missing. */
3143 else if ((!quiet_warnings || flag_code == CODE_64BIT)
3144 && (i.types[op] & Reg16) != 0
3145 && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
3146 {
3147 /* Prohibit these changes in the 64bit mode, since the
3148 lowering is more complicated. */
3149 if (flag_code == CODE_64BIT)
252b5132 3150 {
2ca3ace5
L		 3151 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
3152 register_prefix, i.op[op].regs->reg_name,
29b0f896
AM		 3153 i.suffix);
3154 return 0;
252b5132 3155 }
29b0f896
AM		 3156#if REGISTER_WARNINGS
3157 else
a540244d
L		 3158 as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
3159 register_prefix,
29b0f896 3160 (i.op[op].regs + REGNAM_EAX - REGNAM_AX)->reg_name,
a540244d 3161 register_prefix,
29b0f896
AM		 3162 i.op[op].regs->reg_name,
3163 i.suffix);
3164#endif
252b5132 3165 }
29b0f896
AM		 3166 /* Warn if the r prefix on a general reg is missing. */
3167 else if ((i.types[op] & Reg64) != 0
3168 && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
252b5132 3169 {
34828aad
L		 3170 if (intel_syntax
3171 && i.tm.base_opcode == 0xf30f2d
3172 && (i.types[0] & RegXMM) == 0)
3173 {
3174 /* cvtss2si converts DWORD memory to Reg64. We want
3175 REX byte. */
3176 i.suffix = QWORD_MNEM_SUFFIX;
3177 }
3178 else
3179 {
3180 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
3181 register_prefix, i.op[op].regs->reg_name,
3182 i.suffix);
3183 return 0;
3184 }
29b0f896
AM		 3185 }
3186 return 1;
3187}
252b5132 3188
29b0f896 3189static int
e3bb37b5 3190check_qword_reg (void)
29b0f896
AM		 3191{
3192 int op;
252b5132 3193
29b0f896
AM		 3194 for (op = i.operands; --op >= 0; )
3195 /* Reject eight bit registers, except where the template requires
3196 them. (eg. movzb) */
3197 if ((i.types[op] & Reg8) != 0
3198 && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
3199 {
a540244d
L		 3200 as_bad (_("`%s%s' not allowed with `%s%c'"),
3201 register_prefix,
29b0f896
AM		 3202 i.op[op].regs->reg_name,
3203 i.tm.name,
3204 i.suffix);
3205 return 0;
3206 }
3207 /* Warn if the e prefix on a general reg is missing. */
34828aad 3208 else if ((i.types[op] & (Reg16 | Reg32)) != 0
29b0f896
AM		 3209 && (i.tm.operand_types[op] & (Reg32 | Acc)) != 0)
3210 {
3211 /* Prohibit these changes in the 64bit mode, since the
3212 lowering is more complicated. */
34828aad
L		 3213 if (intel_syntax
3214 && i.tm.base_opcode == 0xf20f2d
3215 && (i.types[0] & RegXMM) == 0)
3216 {
3217 /* cvtsd2si converts QWORD memory to Reg32. We don't want
3218 REX byte. */
3219 i.suffix = LONG_MNEM_SUFFIX;
3220 }
3221 else
3222 {
3223 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
3224 register_prefix, i.op[op].regs->reg_name,
3225 i.suffix);
3226 return 0;
3227 }
252b5132 3228 }
29b0f896
AM		 3229 return 1;
3230}
252b5132 3231
29b0f896 3232static int
e3bb37b5 3233check_word_reg (void)
29b0f896
AM		 3234{
3235 int op;
3236 for (op = i.operands; --op >= 0;)
3237 /* Reject eight bit registers, except where the template requires
3238 them. (eg. movzb) */
3239 if ((i.types[op] & Reg8) != 0
3240 && (i.tm.operand_types[op] & (Reg16 | Reg32 | Acc)) != 0)
3241 {
a540244d
L		 3242 as_bad (_("`%s%s' not allowed with `%s%c'"),
3243 register_prefix,
29b0f896
AM		 3244 i.op[op].regs->reg_name,
3245 i.tm.name,
3246 i.suffix);
3247 return 0;
3248 }
3249 /* Warn if the e prefix on a general reg is present. */
3250 else if ((!quiet_warnings || flag_code == CODE_64BIT)
3251 && (i.types[op] & Reg32) != 0
3252 && (i.tm.operand_types[op] & (Reg16 | Acc)) != 0)
252b5132 3253 {
29b0f896
AM		 3254 /* Prohibit these changes in the 64bit mode, since the
3255 lowering is more complicated. */
3256 if (flag_code == CODE_64BIT)
252b5132 3257 {
2ca3ace5
L		 3258 as_bad (_("Incorrect register `%s%s' used with `%c' suffix"),
3259 register_prefix, i.op[op].regs->reg_name,
29b0f896
AM		 3260 i.suffix);
3261 return 0;
252b5132 3262 }
29b0f896
AM		 3263 else
3264#if REGISTER_WARNINGS
a540244d
L		 3265 as_warn (_("using `%s%s' instead of `%s%s' due to `%c' suffix"),
3266 register_prefix,
29b0f896 3267 (i.op[op].regs + REGNAM_AX - REGNAM_EAX)->reg_name,
a540244d 3268 register_prefix,
29b0f896
AM		 3269 i.op[op].regs->reg_name,
3270 i.suffix);
3271#endif
3272 }
3273 return 1;
3274}
252b5132 3275
29b0f896 3276static int
e3bb37b5 3277finalize_imm (void)
29b0f896
AM		 3278{
3279 unsigned int overlap0, overlap1, overlap2;
3280
3281 overlap0 = i.types[0] & i.tm.operand_types[0];
20f0a1fc 3282 if ((overlap0 & (Imm8 | Imm8S | Imm16 | Imm32 | Imm32S | Imm64))
29b0f896
AM		 3283 && overlap0 != Imm8 && overlap0 != Imm8S
3284 && overlap0 != Imm16 && overlap0 != Imm32S
3285 && overlap0 != Imm32 && overlap0 != Imm64)
3286 {
3287 if (i.suffix)
3288 {
3289 overlap0 &= (i.suffix == BYTE_MNEM_SUFFIX
3290 ? Imm8 | Imm8S
3291 : (i.suffix == WORD_MNEM_SUFFIX
3292 ? Imm16
3293 : (i.suffix == QWORD_MNEM_SUFFIX
3294 ? Imm64 | Imm32S
3295 : Imm32)));
3296 }
3297 else if (overlap0 == (Imm16 | Imm32S | Imm32)
3298 || overlap0 == (Imm16 | Imm32)
3299 || overlap0 == (Imm16 | Imm32S))
3300 {
3301 overlap0 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
3302 ? Imm16 : Imm32S);
3303 }
3304 if (overlap0 != Imm8 && overlap0 != Imm8S
3305 && overlap0 != Imm16 && overlap0 != Imm32S
3306 && overlap0 != Imm32 && overlap0 != Imm64)
3307 {
4eed87de
AM		 3308 as_bad (_("no instruction mnemonic suffix given; "
3309 "can't determine immediate size"));
29b0f896
AM		 3310 return 0;
3311 }
3312 }
3313 i.types[0] = overlap0;
3314
3315 overlap1 = i.types[1] & i.tm.operand_types[1];
37edbb65 3316 if ((overlap1 & (Imm8 | Imm8S | Imm16 | Imm32S | Imm32 | Imm64))
29b0f896
AM		 3317 && overlap1 != Imm8 && overlap1 != Imm8S
3318 && overlap1 != Imm16 && overlap1 != Imm32S
3319 && overlap1 != Imm32 && overlap1 != Imm64)
3320 {
3321 if (i.suffix)
3322 {
3323 overlap1 &= (i.suffix == BYTE_MNEM_SUFFIX
3324 ? Imm8 | Imm8S
3325 : (i.suffix == WORD_MNEM_SUFFIX
3326 ? Imm16
3327 : (i.suffix == QWORD_MNEM_SUFFIX
3328 ? Imm64 | Imm32S
3329 : Imm32)));
3330 }
3331 else if (overlap1 == (Imm16 | Imm32 | Imm32S)
3332 || overlap1 == (Imm16 | Imm32)
3333 || overlap1 == (Imm16 | Imm32S))
3334 {
3335 overlap1 = ((flag_code == CODE_16BIT) ^ (i.prefix[DATA_PREFIX] != 0)
3336 ? Imm16 : Imm32S);
3337 }
3338 if (overlap1 != Imm8 && overlap1 != Imm8S
3339 && overlap1 != Imm16 && overlap1 != Imm32S
3340 && overlap1 != Imm32 && overlap1 != Imm64)
3341 {
4eed87de
AM		 3342 as_bad (_("no instruction mnemonic suffix given; "
3343 "can't determine immediate size %x %c"),
3344 overlap1, i.suffix);
29b0f896
AM		 3345 return 0;
3346 }
3347 }
3348 i.types[1] = overlap1;
3349
3350 overlap2 = i.types[2] & i.tm.operand_types[2];
3351 assert ((overlap2 & Imm) == 0);
3352 i.types[2] = overlap2;
3353
3354 return 1;
3355}
3356
3357static int
e3bb37b5 3358process_operands (void)
29b0f896
AM		 3359{
3360 /* Default segment register this instruction will use for memory
3361 accesses. 0 means unknown. This is only for optimizing out
3362 unnecessary segment overrides. */
3363 const seg_entry *default_seg = 0;
3364
3365 /* The imul $imm, %reg instruction is converted into
3366 imul $imm, %reg, %reg, and the clr %reg instruction
3367 is converted into xor %reg, %reg. */
5f15756d 3368 if (i.tm.opcode_modifier & RegKludge)
29b0f896 3369 {
42903f7f
L		 3370 if ((i.tm.cpu_flags & CpuSSE4_1))
3371 {
3372 /* The first operand in instruction blendvpd, blendvps and
3373 pblendvb in SSE4.1 is implicit and must be xmm0. */
3374 assert (i.operands == 3
3375 && i.reg_operands >= 2
3376 && i.types[0] == RegXMM);
3377 if (i.op[0].regs->reg_num != 0)
3378 {
3379 if (intel_syntax)
3380 as_bad (_("the last operand of `%s' must be `%sxmm0'"),
3381 i.tm.name, register_prefix);
3382 else
3383 as_bad (_("the first operand of `%s' must be `%sxmm0'"),
3384 i.tm.name, register_prefix);
3385 return 0;
3386 }
3387 i.op[0] = i.op[1];
3388 i.op[1] = i.op[2];
3389 i.types[0] = i.types[1];
3390 i.types[1] = i.types[2];
3391 i.operands--;
3392 i.reg_operands--;
3393
3394 /* We need to adjust fields in i.tm since they are used by
3395 build_modrm_byte. */
3396 i.tm.operand_types [0] = i.tm.operand_types [1];
3397 i.tm.operand_types [1] = i.tm.operand_types [2];
3398 i.tm.operands--;
3399 }
3400 else
3401 {
3402 unsigned int first_reg_op = (i.types[0] & Reg) ? 0 : 1;
3403 /* Pretend we saw the extra register operand. */
3404 assert (i.reg_operands == 1
3405 && i.op[first_reg_op + 1].regs == 0);
3406 i.op[first_reg_op + 1].regs = i.op[first_reg_op].regs;
3407 i.types[first_reg_op + 1] = i.types[first_reg_op];
3408 i.operands++;
3409 i.reg_operands++;
3410 }
29b0f896
AM		 3411 }
3412
3413 if (i.tm.opcode_modifier & ShortForm)
3414 {
4eed87de 3415 if (i.types[0] & (SReg2 | SReg3))
29b0f896 3416 {
4eed87de
AM		 3417 if (i.tm.base_opcode == POP_SEG_SHORT
3418 && i.op[0].regs->reg_num == 1)
29b0f896 3419 {
4eed87de
AM		 3420 as_bad (_("you can't `pop %%cs'"));
3421 return 0;
29b0f896 3422 }
4eed87de
AM		 3423 i.tm.base_opcode |= (i.op[0].regs->reg_num << 3);
3424 if ((i.op[0].regs->reg_flags & RegRex) != 0)
161a04f6 3425 i.rex |= REX_B;
4eed87de
AM		 3426 }
3427 else
3428 {
3429 /* The register or float register operand is in operand 0 or 1. */
3430 unsigned int op = (i.types[0] & (Reg | FloatReg)) ? 0 : 1;
3431 /* Register goes in low 3 bits of opcode. */
3432 i.tm.base_opcode |= i.op[op].regs->reg_num;
3433 if ((i.op[op].regs->reg_flags & RegRex) != 0)
161a04f6 3434 i.rex |= REX_B;
4eed87de 3435 if (!quiet_warnings && (i.tm.opcode_modifier & Ugh) != 0)
29b0f896 3436 {
4eed87de
AM		 3437 /* Warn about some common errors, but press on regardless.
3438 The first case can be generated by gcc (<= 2.8.1). */
3439 if (i.operands == 2)
3440 {
3441 /* Reversed arguments on faddp, fsubp, etc. */
a540244d
L		 3442 as_warn (_("translating to `%s %s%s,%s%s'"), i.tm.name,
3443 register_prefix, i.op[1].regs->reg_name,
3444 register_prefix, i.op[0].regs->reg_name);
4eed87de
AM		 3445 }
3446 else
3447 {
3448 /* Extraneous `l' suffix on fp insn. */
a540244d
L		 3449 as_warn (_("translating to `%s %s%s'"), i.tm.name,
3450 register_prefix, i.op[0].regs->reg_name);
4eed87de 3451 }
29b0f896
AM		 3452 }
3453 }
3454 }
3455 else if (i.tm.opcode_modifier & Modrm)
3456 {
3457 /* The opcode is completed (modulo i.tm.extension_opcode which
52271982
AM		 3458 must be put into the modrm byte). Now, we make the modrm and
3459 index base bytes based on all the info we've collected. */
29b0f896
AM		 3460
3461 default_seg = build_modrm_byte ();
3462 }
8a2ed489 3463 else if ((i.tm.base_opcode & ~0x3) == MOV_AX_DISP32)
29b0f896
AM		 3464 {
3465 default_seg = &ds;
3466 }
3467 else if ((i.tm.opcode_modifier & IsString) != 0)
3468 {
3469 /* For the string instructions that allow a segment override
3470 on one of their operands, the default segment is ds. */
3471 default_seg = &ds;
3472 }
3473
30123838
JB		 3474 if ((i.tm.base_opcode == 0x8d /* lea */
3475 || (i.tm.cpu_flags & CpuSVME))
3476 && i.seg[0] && !quiet_warnings)
3477 as_warn (_("segment override on `%s' is ineffectual"), i.tm.name);
52271982
AM		 3478
3479 /* If a segment was explicitly specified, and the specified segment
3480 is not the default, use an opcode prefix to select it. If we
3481 never figured out what the default segment is, then default_seg
3482 will be zero at this point, and the specified segment prefix will
3483 always be used. */
29b0f896
AM		 3484 if ((i.seg[0]) && (i.seg[0] != default_seg))
3485 {
3486 if (!add_prefix (i.seg[0]->seg_prefix))
3487 return 0;
3488 }
3489 return 1;
3490}
3491
3492static const seg_entry *
e3bb37b5 3493build_modrm_byte (void)
29b0f896
AM		 3494{
3495 const seg_entry *default_seg = 0;
3496
3497 /* i.reg_operands MUST be the number of real register operands;
3498 implicit registers do not count. */
3499 if (i.reg_operands == 2)
3500 {
3501 unsigned int source, dest;
cab737b9
L		 3502
3503 switch (i.operands)
3504 {
3505 case 2:
3506 source = 0;
3507 break;
3508 case 3:
c81128dc
L		 3509 /* When there are 3 operands, one of them may be immediate,
3510 which may be the first or the last operand. Otherwise,
3511 the first operand must be shift count register (cl). */
3512 assert (i.imm_operands == 1
3513 || (i.imm_operands == 0
3514 && (i.types[0] & ShiftCount)));
3515 source = (i.types[0] & (Imm | ShiftCount)) ? 1 : 0;
cab737b9
L		 3516 break;
3517 case 4:
3518 /* When there are 4 operands, the first two must be immediate
3519 operands. The source operand will be the 3rd one. */
3520 assert (i.imm_operands == 2
3521 && (i.types[0] & Imm)
3522 && (i.types[1] & Imm));
3523 source = 2;
3524 break;
3525 default:
3526 abort ();
3527 }
3528
29b0f896
AM		 3529 dest = source + 1;
3530
3531 i.rm.mode = 3;
3532 /* One of the register operands will be encoded in the i.tm.reg
3533 field, the other in the combined i.tm.mode and i.tm.regmem
3534 fields. If no form of this instruction supports a memory
3535 destination operand, then we assume the source operand may
3536 sometimes be a memory operand and so we need to store the
3537 destination in the i.rm.reg field. */
e72cf3ec 3538 if ((i.tm.operand_types[dest] & (AnyMem | RegMem)) == 0)
29b0f896
AM		 3539 {
3540 i.rm.reg = i.op[dest].regs->reg_num;
3541 i.rm.regmem = i.op[source].regs->reg_num;
3542 if ((i.op[dest].regs->reg_flags & RegRex) != 0)
161a04f6 3543 i.rex |= REX_R;
29b0f896 3544 if ((i.op[source].regs->reg_flags & RegRex) != 0)
161a04f6 3545 i.rex |= REX_B;
29b0f896
AM		 3546 }
3547 else
3548 {
3549 i.rm.reg = i.op[source].regs->reg_num;
3550 i.rm.regmem = i.op[dest].regs->reg_num;
3551 if ((i.op[dest].regs->reg_flags & RegRex) != 0)
161a04f6 3552 i.rex |= REX_B;
29b0f896 3553 if ((i.op[source].regs->reg_flags & RegRex) != 0)
161a04f6 3554 i.rex |= REX_R;
29b0f896 3555 }
161a04f6 3556 if (flag_code != CODE_64BIT && (i.rex & (REX_R | REX_B)))
c4a530c5
JB		 3557 {
3558 if (!((i.types[0] | i.types[1]) & Control))
3559 abort ();
161a04f6 3560 i.rex &= ~(REX_R | REX_B);
c4a530c5
JB		 3561 add_prefix (LOCK_PREFIX_OPCODE);
3562 }
29b0f896
AM		 3563 }
3564 else
3565 { /* If it's not 2 reg operands... */
3566 if (i.mem_operands)
3567 {
3568 unsigned int fake_zero_displacement = 0;
99018f42 3569 unsigned int op;
4eed87de 3570
99018f42
L		 3571 for (op = 0; op < i.operands; op++)
3572 if ((i.types[op] & AnyMem))
3573 break;
3574 assert (op < i.operands);
29b0f896
AM		 3575
3576 default_seg = &ds;
3577
3578 if (i.base_reg == 0)
3579 {
3580 i.rm.mode = 0;
3581 if (!i.disp_operands)
3582 fake_zero_displacement = 1;
3583 if (i.index_reg == 0)
3584 {
3585 /* Operand is just <disp> */
20f0a1fc 3586 if (flag_code == CODE_64BIT)
29b0f896
AM		 3587 {
3588 /* 64bit mode overwrites the 32bit absolute
3589 addressing by RIP relative addressing and
3590 absolute addressing is encoded by one of the
3591 redundant SIB forms. */
3592 i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3593 i.sib.base = NO_BASE_REGISTER;
3594 i.sib.index = NO_INDEX_REGISTER;
fc225355
L		 3595 i.types[op] = ((i.prefix[ADDR_PREFIX] == 0)
3596 ? Disp32S : Disp32);
20f0a1fc 3597 }
fc225355
L		 3598 else if ((flag_code == CODE_16BIT)
3599 ^ (i.prefix[ADDR_PREFIX] != 0))
20f0a1fc
NC		 3600 {
3601 i.rm.regmem = NO_BASE_REGISTER_16;
3602 i.types[op] = Disp16;
3603 }
3604 else
3605 {
3606 i.rm.regmem = NO_BASE_REGISTER;
3607 i.types[op] = Disp32;
29b0f896
AM		 3608 }
3609 }
3610 else /* !i.base_reg && i.index_reg */
3611 {
3612 i.sib.index = i.index_reg->reg_num;
3613 i.sib.base = NO_BASE_REGISTER;
3614 i.sib.scale = i.log2_scale_factor;
3615 i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3616 i.types[op] &= ~Disp;
3617 if (flag_code != CODE_64BIT)
3618 i.types[op] |= Disp32; /* Must be 32 bit */
3619 else
3620 i.types[op] |= Disp32S;
3621 if ((i.index_reg->reg_flags & RegRex) != 0)
161a04f6 3622 i.rex |= REX_X;
29b0f896
AM		 3623 }
3624 }
3625 /* RIP addressing for 64bit mode. */
3626 else if (i.base_reg->reg_type == BaseIndex)
3627 {
3628 i.rm.regmem = NO_BASE_REGISTER;
20f0a1fc 3629 i.types[op] &= ~ Disp;
29b0f896 3630 i.types[op] |= Disp32S;
71903a11 3631 i.flags[op] |= Operand_PCrel;
20f0a1fc
NC		 3632 if (! i.disp_operands)
3633 fake_zero_displacement = 1;
29b0f896
AM		 3634 }
3635 else if (i.base_reg->reg_type & Reg16)
3636 {
3637 switch (i.base_reg->reg_num)
3638 {
3639 case 3: /* (%bx) */
3640 if (i.index_reg == 0)
3641 i.rm.regmem = 7;
3642 else /* (%bx,%si) -> 0, or (%bx,%di) -> 1 */
3643 i.rm.regmem = i.index_reg->reg_num - 6;
3644 break;
3645 case 5: /* (%bp) */
3646 default_seg = &ss;
3647 if (i.index_reg == 0)
3648 {
3649 i.rm.regmem = 6;
3650 if ((i.types[op] & Disp) == 0)
3651 {
3652 /* fake (%bp) into 0(%bp) */
3653 i.types[op] |= Disp8;
252b5132 3654 fake_zero_displacement = 1;
29b0f896
AM		 3655 }
3656 }
3657 else /* (%bp,%si) -> 2, or (%bp,%di) -> 3 */
3658 i.rm.regmem = i.index_reg->reg_num - 6 + 2;
3659 break;
3660 default: /* (%si) -> 4 or (%di) -> 5 */
3661 i.rm.regmem = i.base_reg->reg_num - 6 + 4;
3662 }
3663 i.rm.mode = mode_from_disp_size (i.types[op]);
3664 }
3665 else /* i.base_reg and 32/64 bit mode */
3666 {
3667 if (flag_code == CODE_64BIT
3668 && (i.types[op] & Disp))
fc225355
L		 3669 i.types[op] = ((i.types[op] & Disp8)
3670 | (i.prefix[ADDR_PREFIX] == 0
3671 ? Disp32S : Disp32));
20f0a1fc 3672
29b0f896
AM		 3673 i.rm.regmem = i.base_reg->reg_num;
3674 if ((i.base_reg->reg_flags & RegRex) != 0)
161a04f6 3675 i.rex |= REX_B;
29b0f896
AM		 3676 i.sib.base = i.base_reg->reg_num;
3677 /* x86-64 ignores REX prefix bit here to avoid decoder
3678 complications. */
3679 if ((i.base_reg->reg_num & 7) == EBP_REG_NUM)
3680 {
3681 default_seg = &ss;
3682 if (i.disp_operands == 0)
3683 {
3684 fake_zero_displacement = 1;
3685 i.types[op] |= Disp8;
3686 }
3687 }
3688 else if (i.base_reg->reg_num == ESP_REG_NUM)
3689 {
3690 default_seg = &ss;
3691 }
3692 i.sib.scale = i.log2_scale_factor;
3693 if (i.index_reg == 0)
3694 {
3695 /* <disp>(%esp) becomes two byte modrm with no index
3696 register. We've already stored the code for esp
3697 in i.rm.regmem ie. ESCAPE_TO_TWO_BYTE_ADDRESSING.
3698 Any base register besides %esp will not use the
3699 extra modrm byte. */
3700 i.sib.index = NO_INDEX_REGISTER;
3701#if !SCALE1_WHEN_NO_INDEX
3702 /* Another case where we force the second modrm byte. */
3703 if (i.log2_scale_factor)
3704 i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
252b5132 3705#endif
29b0f896
AM		 3706 }
3707 else
3708 {
3709 i.sib.index = i.index_reg->reg_num;
3710 i.rm.regmem = ESCAPE_TO_TWO_BYTE_ADDRESSING;
3711 if ((i.index_reg->reg_flags & RegRex) != 0)
161a04f6 3712 i.rex |= REX_X;
29b0f896 3713 }
67a4f2b7
AO		 3714
3715 if (i.disp_operands
3716 && (i.reloc[op] == BFD_RELOC_386_TLS_DESC_CALL
3717 || i.reloc[op] == BFD_RELOC_X86_64_TLSDESC_CALL))
3718 i.rm.mode = 0;
3719 else
3720 i.rm.mode = mode_from_disp_size (i.types[op]);
29b0f896 3721 }
252b5132 3722
29b0f896
AM		 3723 if (fake_zero_displacement)
3724 {
3725 /* Fakes a zero displacement assuming that i.types[op]
3726 holds the correct displacement size. */
3727 expressionS *exp;
3728
3729 assert (i.op[op].disps == 0);
3730 exp = &disp_expressions[i.disp_operands++];
3731 i.op[op].disps = exp;
3732 exp->X_op = O_constant;
3733 exp->X_add_number = 0;
3734 exp->X_add_symbol = (symbolS *) 0;
3735 exp->X_op_symbol = (symbolS *) 0;
3736 }
3737 }
252b5132 3738
29b0f896
AM		 3739 /* Fill in i.rm.reg or i.rm.regmem field with register operand
3740 (if any) based on i.tm.extension_opcode. Again, we must be
3741 careful to make sure that segment/control/debug/test/MMX
3742 registers are coded into the i.rm.reg field. */
3743 if (i.reg_operands)
3744 {
99018f42
L		 3745 unsigned int op;
3746
3747 for (op = 0; op < i.operands; op++)
3748 if ((i.types[op] & (Reg | RegMMX | RegXMM
3749 | SReg2 | SReg3
3750 | Control | Debug | Test)))
3751 break;
3752 assert (op < i.operands);
3753
29b0f896
AM		 3754 /* If there is an extension opcode to put here, the register
3755 number must be put into the regmem field. */
3756 if (i.tm.extension_opcode != None)
3757 {
3758 i.rm.regmem = i.op[op].regs->reg_num;
3759 if ((i.op[op].regs->reg_flags & RegRex) != 0)
161a04f6 3760 i.rex |= REX_B;
29b0f896
AM		 3761 }
3762 else
3763 {
3764 i.rm.reg = i.op[op].regs->reg_num;
3765 if ((i.op[op].regs->reg_flags & RegRex) != 0)
161a04f6 3766 i.rex |= REX_R;
29b0f896 3767 }
252b5132 3768
29b0f896
AM		 3769 /* Now, if no memory operand has set i.rm.mode = 0, 1, 2 we
3770 must set it to 3 to indicate this is a register operand
3771 in the regmem field. */
3772 if (!i.mem_operands)
3773 i.rm.mode = 3;
3774 }
252b5132 3775
29b0f896
AM		 3776 /* Fill in i.rm.reg field with extension opcode (if any). */
3777 if (i.tm.extension_opcode != None)
3778 i.rm.reg = i.tm.extension_opcode;
3779 }
3780 return default_seg;
3781}
252b5132 3782
29b0f896 3783static void
e3bb37b5 3784output_branch (void)
29b0f896
AM		 3785{
3786 char *p;
3787 int code16;
3788 int prefix;
3789 relax_substateT subtype;
3790 symbolS *sym;
3791 offsetT off;
3792
3793 code16 = 0;
3794 if (flag_code == CODE_16BIT)
3795 code16 = CODE16;
3796
3797 prefix = 0;
3798 if (i.prefix[DATA_PREFIX] != 0)
252b5132 3799 {
29b0f896
AM		 3800 prefix = 1;
3801 i.prefixes -= 1;
3802 code16 ^= CODE16;
252b5132 3803 }
29b0f896
AM		 3804 /* Pentium4 branch hints. */
3805 if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
3806 || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
2f66722d 3807 {
29b0f896
AM		 3808 prefix++;
3809 i.prefixes--;
3810 }
3811 if (i.prefix[REX_PREFIX] != 0)
3812 {
3813 prefix++;
3814 i.prefixes--;
2f66722d
AM		 3815 }
3816
29b0f896
AM		 3817 if (i.prefixes != 0 && !intel_syntax)
3818 as_warn (_("skipping prefixes on this instruction"));
3819
3820 /* It's always a symbol; End frag & setup for relax.
3821 Make sure there is enough room in this frag for the largest
3822 instruction we may generate in md_convert_frag. This is 2
3823 bytes for the opcode and room for the prefix and largest
3824 displacement. */
3825 frag_grow (prefix + 2 + 4);
3826 /* Prefix and 1 opcode byte go in fr_fix. */
3827 p = frag_more (prefix + 1);
3828 if (i.prefix[DATA_PREFIX] != 0)
3829 *p++ = DATA_PREFIX_OPCODE;
3830 if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE
3831 || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE)
3832 *p++ = i.prefix[SEG_PREFIX];
3833 if (i.prefix[REX_PREFIX] != 0)
3834 *p++ = i.prefix[REX_PREFIX];
3835 *p = i.tm.base_opcode;
3836
3837 if ((unsigned char) *p == JUMP_PC_RELATIVE)
3838 subtype = ENCODE_RELAX_STATE (UNCOND_JUMP, SMALL);
3839 else if ((cpu_arch_flags & Cpu386) != 0)
3840 subtype = ENCODE_RELAX_STATE (COND_JUMP, SMALL);
3841 else
3842 subtype = ENCODE_RELAX_STATE (COND_JUMP86, SMALL);
3843 subtype |= code16;
3e73aa7c 3844
29b0f896
AM		 3845 sym = i.op[0].disps->X_add_symbol;
3846 off = i.op[0].disps->X_add_number;
3e73aa7c 3847
29b0f896
AM		 3848 if (i.op[0].disps->X_op != O_constant
3849 && i.op[0].disps->X_op != O_symbol)
3e73aa7c 3850 {
29b0f896
AM		 3851 /* Handle complex expressions. */
3852 sym = make_expr_symbol (i.op[0].disps);
3853 off = 0;
3854 }
3e73aa7c 3855
29b0f896
AM		 3856 /* 1 possible extra opcode + 4 byte displacement go in var part.
3857 Pass reloc in fr_var. */
3858 frag_var (rs_machine_dependent, 5, i.reloc[0], subtype, sym, off, p);
3859}
3e73aa7c 3860
29b0f896 3861static void
e3bb37b5 3862output_jump (void)
29b0f896
AM		 3863{
3864 char *p;
3865 int size;
3e02c1cc 3866 fixS *fixP;
29b0f896
AM		 3867
3868 if (i.tm.opcode_modifier & JumpByte)
3869 {
3870 /* This is a loop or jecxz type instruction. */
3871 size = 1;
3872 if (i.prefix[ADDR_PREFIX] != 0)
3873 {
3874 FRAG_APPEND_1_CHAR (ADDR_PREFIX_OPCODE);
3875 i.prefixes -= 1;
3876 }
3877 /* Pentium4 branch hints. */
3878 if (i.prefix[SEG_PREFIX] == CS_PREFIX_OPCODE /* not taken */
3879 || i.prefix[SEG_PREFIX] == DS_PREFIX_OPCODE /* taken */)
3880 {
3881 FRAG_APPEND_1_CHAR (i.prefix[SEG_PREFIX]);
3882 i.prefixes--;
3e73aa7c
JH		 3883 }
3884 }
29b0f896
AM		 3885 else
3886 {
3887 int code16;
3e73aa7c 3888
29b0f896
AM		 3889 code16 = 0;
3890 if (flag_code == CODE_16BIT)
3891 code16 = CODE16;
3e73aa7c 3892
29b0f896
AM		 3893 if (i.prefix[DATA_PREFIX] != 0)
3894 {
3895 FRAG_APPEND_1_CHAR (DATA_PREFIX_OPCODE);
3896 i.prefixes -= 1;
3897 code16 ^= CODE16;
3898 }
252b5132 3899
29b0f896
AM		 3900 size = 4;
3901 if (code16)
3902 size = 2;
3903 }
9fcc94b6 3904
29b0f896
AM		 3905 if (i.prefix[REX_PREFIX] != 0)
3906 {
3907 FRAG_APPEND_1_CHAR (i.prefix[REX_PREFIX]);
3908 i.prefixes -= 1;
3909 }
252b5132 3910
29b0f896
AM		 3911 if (i.prefixes != 0 && !intel_syntax)
3912 as_warn (_("skipping prefixes on this instruction"));
e0890092 3913
29b0f896
AM		 3914 p = frag_more (1 + size);
3915 *p++ = i.tm.base_opcode;
e0890092 3916
3e02c1cc
AM		 3917 fixP = fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3918 i.op[0].disps, 1, reloc (size, 1, 1, i.reloc[0]));
3919
3920 /* All jumps handled here are signed, but don't use a signed limit
3921 check for 32 and 16 bit jumps as we want to allow wrap around at
3922 4G and 64k respectively. */
3923 if (size == 1)
3924 fixP->fx_signed = 1;
29b0f896 3925}
e0890092 3926
29b0f896 3927static void
e3bb37b5 3928output_interseg_jump (void)
29b0f896
AM		 3929{
3930 char *p;
3931 int size;
3932 int prefix;
3933 int code16;
252b5132 3934
29b0f896
AM		 3935 code16 = 0;
3936 if (flag_code == CODE_16BIT)
3937 code16 = CODE16;
a217f122 3938
29b0f896
AM		 3939 prefix = 0;
3940 if (i.prefix[DATA_PREFIX] != 0)
3941 {
3942 prefix = 1;
3943 i.prefixes -= 1;
3944 code16 ^= CODE16;
3945 }
3946 if (i.prefix[REX_PREFIX] != 0)
3947 {
3948 prefix++;
3949 i.prefixes -= 1;
3950 }
252b5132 3951
29b0f896
AM		 3952 size = 4;
3953 if (code16)
3954 size = 2;
252b5132 3955
29b0f896
AM		 3956 if (i.prefixes != 0 && !intel_syntax)
3957 as_warn (_("skipping prefixes on this instruction"));
252b5132 3958
29b0f896
AM		 3959 /* 1 opcode; 2 segment; offset */
3960 p = frag_more (prefix + 1 + 2 + size);
3e73aa7c 3961
29b0f896
AM		 3962 if (i.prefix[DATA_PREFIX] != 0)
3963 *p++ = DATA_PREFIX_OPCODE;
252b5132 3964
29b0f896
AM		 3965 if (i.prefix[REX_PREFIX] != 0)
3966 *p++ = i.prefix[REX_PREFIX];
252b5132 3967
29b0f896
AM		 3968 *p++ = i.tm.base_opcode;
3969 if (i.op[1].imms->X_op == O_constant)
3970 {
3971 offsetT n = i.op[1].imms->X_add_number;
252b5132 3972
29b0f896
AM		 3973 if (size == 2
3974 && !fits_in_unsigned_word (n)
3975 && !fits_in_signed_word (n))
3976 {
3977 as_bad (_("16-bit jump out of range"));
3978 return;
3979 }
3980 md_number_to_chars (p, n, size);
3981 }
3982 else
3983 fix_new_exp (frag_now, p - frag_now->fr_literal, size,
3984 i.op[1].imms, 0, reloc (size, 0, 0, i.reloc[1]));
3985 if (i.op[0].imms->X_op != O_constant)
3986 as_bad (_("can't handle non absolute segment in `%s'"),
3987 i.tm.name);
3988 md_number_to_chars (p + size, (valueT) i.op[0].imms->X_add_number, 2);
3989}
a217f122 3990
29b0f896 3991static void
e3bb37b5 3992output_insn (void)
29b0f896 3993{
2bbd9c25
JJ		 3994 fragS *insn_start_frag;
3995 offsetT insn_start_off;
3996
29b0f896
AM		 3997 /* Tie dwarf2 debug info to the address at the start of the insn.
3998 We can't do this after the insn has been output as the current
3999 frag may have been closed off. eg. by frag_var. */
4000 dwarf2_emit_insn (0);
4001
2bbd9c25
JJ		 4002 insn_start_frag = frag_now;
4003 insn_start_off = frag_now_fix ();
4004
29b0f896
AM		 4005 /* Output jumps. */
4006 if (i.tm.opcode_modifier & Jump)
4007 output_branch ();
4008 else if (i.tm.opcode_modifier & (JumpByte | JumpDword))
4009 output_jump ();
4010 else if (i.tm.opcode_modifier & JumpInterSegment)
4011 output_interseg_jump ();
4012 else
4013 {
4014 /* Output normal instructions here. */
4015 char *p;
4016 unsigned char *q;
331d2d0d 4017 unsigned int prefix;
252b5132 4018
42903f7f 4019 /* All opcodes on i386 have either 1 or 2 bytes. SSSE3 and
381d071f
L		 4020 SSE4 instructions have 3 bytes. We may use one more higher
4021 byte to specify a prefix the instruction requires. Exclude
4022 instructions which are in both SSE4 and ABM. */
4023 if ((i.tm.cpu_flags & (CpuSSSE3 | CpuSSE4)) != 0
4024 && (i.tm.cpu_flags & CpuABM) == 0)
bc4bd9ab 4025 {
331d2d0d
L		 4026 if (i.tm.base_opcode & 0xff000000)
4027 {
4028 prefix = (i.tm.base_opcode >> 24) & 0xff;
4029 goto check_prefix;
4030 }
4031 }
4032 else if ((i.tm.base_opcode & 0xff0000) != 0)
4033 {
4034 prefix = (i.tm.base_opcode >> 16) & 0xff;
bc4bd9ab
MK		 4035 if ((i.tm.cpu_flags & CpuPadLock) != 0)
4036 {
64e74474 4037 check_prefix:
bc4bd9ab
MK		 4038 if (prefix != REPE_PREFIX_OPCODE
4039 || i.prefix[LOCKREP_PREFIX] != REPE_PREFIX_OPCODE)
4040 add_prefix (prefix);
4041 }
4042 else
331d2d0d 4043 add_prefix (prefix);
0f10071e 4044 }
252b5132 4045
29b0f896
AM		 4046 /* The prefix bytes. */
4047 for (q = i.prefix;
4048 q < i.prefix + sizeof (i.prefix) / sizeof (i.prefix[0]);
4049 q++)
4050 {
4051 if (*q)
4052 {
4053 p = frag_more (1);
4054 md_number_to_chars (p, (valueT) *q, 1);
4055 }
4056 }
252b5132 4057
29b0f896
AM		 4058 /* Now the opcode; be careful about word order here! */
4059 if (fits_in_unsigned_byte (i.tm.base_opcode))
4060 {
4061 FRAG_APPEND_1_CHAR (i.tm.base_opcode);
4062 }
4063 else
4064 {
381d071f
L		 4065 if ((i.tm.cpu_flags & (CpuSSSE3 | CpuSSE4)) != 0
4066 && (i.tm.cpu_flags & CpuABM) == 0)
331d2d0d
L		 4067 {
4068 p = frag_more (3);
4069 *p++ = (i.tm.base_opcode >> 16) & 0xff;
4070 }
4071 else
4072 p = frag_more (2);
0f10071e 4073
29b0f896
AM		 4074 /* Put out high byte first: can't use md_number_to_chars! */
4075 *p++ = (i.tm.base_opcode >> 8) & 0xff;
4076 *p = i.tm.base_opcode & 0xff;
4077 }
3e73aa7c 4078
29b0f896
AM		 4079 /* Now the modrm byte and sib byte (if present). */
4080 if (i.tm.opcode_modifier & Modrm)
4081 {
4082 p = frag_more (1);
4083 md_number_to_chars (p,
4084 (valueT) (i.rm.regmem << 0
4085 | i.rm.reg << 3
4086 | i.rm.mode << 6),
4087 1);
4088 /* If i.rm.regmem == ESP (4)
4089 && i.rm.mode != (Register mode)
4090 && not 16 bit
4091 ==> need second modrm byte. */
4092 if (i.rm.regmem == ESCAPE_TO_TWO_BYTE_ADDRESSING
4093 && i.rm.mode != 3
4094 && !(i.base_reg && (i.base_reg->reg_type & Reg16) != 0))
4095 {
4096 p = frag_more (1);
4097 md_number_to_chars (p,
4098 (valueT) (i.sib.base << 0
4099 | i.sib.index << 3
4100 | i.sib.scale << 6),
4101 1);
4102 }
4103 }
3e73aa7c 4104
29b0f896 4105 if (i.disp_operands)
2bbd9c25 4106 output_disp (insn_start_frag, insn_start_off);
3e73aa7c 4107
29b0f896 4108 if (i.imm_operands)
2bbd9c25 4109 output_imm (insn_start_frag, insn_start_off);
29b0f896 4110 }
252b5132 4111
29b0f896
AM		 4112#ifdef DEBUG386
4113 if (flag_debug)
4114 {
7b81dfbb 4115 pi ("" /*line*/, &i);
29b0f896
AM		 4116 }
4117#endif /* DEBUG386 */
4118}
252b5132 4119
e205caa7
L		 4120/* Return the size of the displacement operand N. */
4121
4122static int
4123disp_size (unsigned int n)
4124{
4125 int size = 4;
4126 if (i.types[n] & (Disp8 | Disp16 | Disp64))
4127 {
4128 size = 2;
4129 if (i.types[n] & Disp8)
4130 size = 1;
4131 if (i.types[n] & Disp64)
4132 size = 8;
4133 }
4134 return size;
4135}
4136
4137/* Return the size of the immediate operand N. */
4138
4139static int
4140imm_size (unsigned int n)
4141{
4142 int size = 4;
4143 if (i.types[n] & (Imm8 | Imm8S | Imm16 | Imm64))
4144 {
4145 size = 2;
4146 if (i.types[n] & (Imm8 | Imm8S))
4147 size = 1;
4148 if (i.types[n] & Imm64)
4149 size = 8;
4150 }
4151 return size;
4152}
4153
29b0f896 4154static void
64e74474 4155output_disp (fragS *insn_start_frag, offsetT insn_start_off)
29b0f896
AM		 4156{
4157 char *p;
4158 unsigned int n;
252b5132 4159
29b0f896
AM		 4160 for (n = 0; n < i.operands; n++)
4161 {
4162 if (i.types[n] & Disp)
4163 {
4164 if (i.op[n].disps->X_op == O_constant)
4165 {
e205caa7 4166 int size = disp_size (n);
29b0f896 4167 offsetT val;
252b5132 4168
29b0f896
AM		 4169 val = offset_in_range (i.op[n].disps->X_add_number,
4170 size);
4171 p = frag_more (size);
4172 md_number_to_chars (p, val, size);
4173 }
4174 else
4175 {
f86103b7 4176 enum bfd_reloc_code_real reloc_type;
e205caa7
L		 4177 int size = disp_size (n);
4178 int sign = (i.types[n] & Disp32S) != 0;
29b0f896
AM		 4179 int pcrel = (i.flags[n] & Operand_PCrel) != 0;
4180
e205caa7
L		 4181 /* We can't have 8 bit displacement here. */
4182 assert ((i.types[n] & Disp8) == 0);
4183
29b0f896
AM		 4184 /* The PC relative address is computed relative
4185 to the instruction boundary, so in case immediate
4186 fields follows, we need to adjust the value. */
4187 if (pcrel && i.imm_operands)
4188 {
29b0f896 4189 unsigned int n1;
e205caa7 4190 int sz = 0;
252b5132 4191
29b0f896
AM		 4192 for (n1 = 0; n1 < i.operands; n1++)
4193 if (i.types[n1] & Imm)
252b5132 4194 {
e205caa7
L		 4195 /* Only one immediate is allowed for PC
4196 relative address. */
4197 assert (sz == 0);
4198 sz = imm_size (n1);
4199 i.op[n].disps->X_add_number -= sz;
252b5132 4200 }
29b0f896 4201 /* We should find the immediate. */
e205caa7 4202 assert (sz != 0);
29b0f896 4203 }
520dc8e8 4204
29b0f896 4205 p = frag_more (size);
2bbd9c25 4206 reloc_type = reloc (size, pcrel, sign, i.reloc[n]);
d6ab8113 4207 if (GOT_symbol
2bbd9c25 4208 && GOT_symbol == i.op[n].disps->X_add_symbol
d6ab8113 4209 && (((reloc_type == BFD_RELOC_32
7b81dfbb
AJ		 4210 || reloc_type == BFD_RELOC_X86_64_32S
4211 || (reloc_type == BFD_RELOC_64
4212 && object_64bit))
d6ab8113
JB		 4213 && (i.op[n].disps->X_op == O_symbol
4214 || (i.op[n].disps->X_op == O_add
4215 && ((symbol_get_value_expression
4216 (i.op[n].disps->X_op_symbol)->X_op)
4217 == O_subtract))))
4218 || reloc_type == BFD_RELOC_32_PCREL))
2bbd9c25
JJ		 4219 {
4220 offsetT add;
4221
4222 if (insn_start_frag == frag_now)
4223 add = (p - frag_now->fr_literal) - insn_start_off;
4224 else
4225 {
4226 fragS *fr;
4227
4228 add = insn_start_frag->fr_fix - insn_start_off;
4229 for (fr = insn_start_frag->fr_next;
4230 fr && fr != frag_now; fr = fr->fr_next)
4231 add += fr->fr_fix;
4232 add += p - frag_now->fr_literal;
4233 }
4234
4fa24527 4235 if (!object_64bit)
7b81dfbb
AJ		 4236 {
4237 reloc_type = BFD_RELOC_386_GOTPC;
4238 i.op[n].imms->X_add_number += add;
4239 }
4240 else if (reloc_type == BFD_RELOC_64)
4241 reloc_type = BFD_RELOC_X86_64_GOTPC64;
d6ab8113 4242 else
7b81dfbb
AJ		 4243 /* Don't do the adjustment for x86-64, as there
4244 the pcrel addressing is relative to the _next_
4245 insn, and that is taken care of in other code. */
d6ab8113 4246 reloc_type = BFD_RELOC_X86_64_GOTPC32;
2bbd9c25 4247 }
062cd5e7 4248 fix_new_exp (frag_now, p - frag_now->fr_literal, size,
2bbd9c25 4249 i.op[n].disps, pcrel, reloc_type);
29b0f896
AM		 4250 }
4251 }
4252 }
4253}
252b5132 4254
29b0f896 4255static void
64e74474 4256output_imm (fragS *insn_start_frag, offsetT insn_start_off)
29b0f896
AM		 4257{
4258 char *p;
4259 unsigned int n;
252b5132 4260
29b0f896
AM		 4261 for (n = 0; n < i.operands; n++)
4262 {
4263 if (i.types[n] & Imm)
4264 {
4265 if (i.op[n].imms->X_op == O_constant)
4266 {
e205caa7 4267 int size = imm_size (n);
29b0f896 4268 offsetT val;
b4cac588 4269
29b0f896
AM		 4270 val = offset_in_range (i.op[n].imms->X_add_number,
4271 size);
4272 p = frag_more (size);
4273 md_number_to_chars (p, val, size);
4274 }
4275 else
4276 {
4277 /* Not absolute_section.
4278 Need a 32-bit fixup (don't support 8bit
4279 non-absolute imms). Try to support other
4280 sizes ... */
f86103b7 4281 enum bfd_reloc_code_real reloc_type;
e205caa7
L		 4282 int size = imm_size (n);
4283 int sign;
29b0f896
AM		 4284
4285 if ((i.types[n] & (Imm32S))
a7d61044
JB		 4286 && (i.suffix == QWORD_MNEM_SUFFIX
4287 || (!i.suffix && (i.tm.opcode_modifier & No_lSuf))))
29b0f896 4288 sign = 1;
e205caa7
L		 4289 else
4290 sign = 0;
520dc8e8 4291
29b0f896
AM		 4292 p = frag_more (size);
4293 reloc_type = reloc (size, 0, sign, i.reloc[n]);
f86103b7 4294
2bbd9c25
JJ		 4295 /* This is tough to explain. We end up with this one if we
4296 * have operands that look like
4297 * "_GLOBAL_OFFSET_TABLE_+[.-.L284]". The goal here is to
4298 * obtain the absolute address of the GOT, and it is strongly
4299 * preferable from a performance point of view to avoid using
4300 * a runtime relocation for this. The actual sequence of
4301 * instructions often look something like:
4302 *
4303 * call .L66
4304 * .L66:
4305 * popl %ebx
4306 * addl $_GLOBAL_OFFSET_TABLE_+[.-.L66],%ebx
4307 *
4308 * The call and pop essentially return the absolute address
4309 * of the label .L66 and store it in %ebx. The linker itself
4310 * will ultimately change the first operand of the addl so
4311 * that %ebx points to the GOT, but to keep things simple, the
4312 * .o file must have this operand set so that it generates not
4313 * the absolute address of .L66, but the absolute address of
4314 * itself. This allows the linker itself simply treat a GOTPC
4315 * relocation as asking for a pcrel offset to the GOT to be
4316 * added in, and the addend of the relocation is stored in the
4317 * operand field for the instruction itself.
4318 *
4319 * Our job here is to fix the operand so that it would add
4320 * the correct offset so that %ebx would point to itself. The
4321 * thing that is tricky is that .-.L66 will point to the
4322 * beginning of the instruction, so we need to further modify
4323 * the operand so that it will point to itself. There are
4324 * other cases where you have something like:
4325 *
4326 * .long $_GLOBAL_OFFSET_TABLE_+[.-.L66]
4327 *
4328 * and here no correction would be required. Internally in
4329 * the assembler we treat operands of this form as not being
4330 * pcrel since the '.' is explicitly mentioned, and I wonder
4331 * whether it would simplify matters to do it this way. Who
4332 * knows. In earlier versions of the PIC patches, the
4333 * pcrel_adjust field was used to store the correction, but
4334 * since the expression is not pcrel, I felt it would be
4335 * confusing to do it this way. */
4336
d6ab8113 4337 if ((reloc_type == BFD_RELOC_32
7b81dfbb
AJ		 4338 || reloc_type == BFD_RELOC_X86_64_32S
4339 || reloc_type == BFD_RELOC_64)
29b0f896
AM		 4340 && GOT_symbol
4341 && GOT_symbol == i.op[n].imms->X_add_symbol
4342 && (i.op[n].imms->X_op == O_symbol
4343 || (i.op[n].imms->X_op == O_add
4344 && ((symbol_get_value_expression
4345 (i.op[n].imms->X_op_symbol)->X_op)
4346 == O_subtract))))
4347 {
2bbd9c25
JJ		 4348 offsetT add;
4349
4350 if (insn_start_frag == frag_now)
4351 add = (p - frag_now->fr_literal) - insn_start_off;
4352 else
4353 {
4354 fragS *fr;
4355
4356 add = insn_start_frag->fr_fix - insn_start_off;
4357 for (fr = insn_start_frag->fr_next;
4358 fr && fr != frag_now; fr = fr->fr_next)
4359 add += fr->fr_fix;
4360 add += p - frag_now->fr_literal;
4361 }
4362
4fa24527 4363 if (!object_64bit)
d6ab8113 4364 reloc_type = BFD_RELOC_386_GOTPC;
7b81dfbb 4365 else if (size == 4)
d6ab8113 4366 reloc_type = BFD_RELOC_X86_64_GOTPC32;
7b81dfbb
AJ		 4367 else if (size == 8)
4368 reloc_type = BFD_RELOC_X86_64_GOTPC64;
2bbd9c25 4369 i.op[n].imms->X_add_number += add;
29b0f896 4370 }
29b0f896
AM		 4371 fix_new_exp (frag_now, p - frag_now->fr_literal, size,
4372 i.op[n].imms, 0, reloc_type);
4373 }
4374 }
4375 }
252b5132
RH		 4376}
4377\f
d182319b
JB		 4378/* x86_cons_fix_new is called via the expression parsing code when a
4379 reloc is needed. We use this hook to get the correct .got reloc. */
4380static enum bfd_reloc_code_real got_reloc = NO_RELOC;
4381static int cons_sign = -1;
4382
4383void
e3bb37b5 4384x86_cons_fix_new (fragS *frag, unsigned int off, unsigned int len,
64e74474 4385 expressionS *exp)
d182319b
JB		 4386{
4387 enum bfd_reloc_code_real r = reloc (len, 0, cons_sign, got_reloc);
4388
4389 got_reloc = NO_RELOC;
4390
4391#ifdef TE_PE
4392 if (exp->X_op == O_secrel)
4393 {
4394 exp->X_op = O_symbol;
4395 r = BFD_RELOC_32_SECREL;
4396 }
4397#endif
4398
4399 fix_new_exp (frag, off, len, exp, 0, r);
4400}
4401
718ddfc0
JB		 4402#if (!defined (OBJ_ELF) && !defined (OBJ_MAYBE_ELF)) || defined (LEX_AT)
4403# define lex_got(reloc, adjust, types) NULL
4404#else
f3c180ae
AM		 4405/* Parse operands of the form
4406 <symbol>@GOTOFF+<nnn>
4407 and similar .plt or .got references.
4408
4409 If we find one, set up the correct relocation in RELOC and copy the
4410 input string, minus the `@GOTOFF' into a malloc'd buffer for
4411 parsing by the calling routine. Return this buffer, and if ADJUST
4412 is non-null set it to the length of the string we removed from the
4413 input line. Otherwise return NULL. */
4414static char *
3956db08 4415lex_got (enum bfd_reloc_code_real *reloc,
64e74474
AM		 4416 int *adjust,
4417 unsigned int *types)
f3c180ae 4418{
7b81dfbb
AJ		 4419 /* Some of the relocations depend on the size of what field is to
4420 be relocated. But in our callers i386_immediate and i386_displacement
4421 we don't yet know the operand size (this will be set by insn
4422 matching). Hence we record the word32 relocation here,
4423 and adjust the reloc according to the real size in reloc(). */
f3c180ae
AM		 4424 static const struct {
4425 const char *str;
4fa24527 4426 const enum bfd_reloc_code_real rel[2];
3956db08 4427 const unsigned int types64;
f3c180ae 4428 } gotrel[] = {
4eed87de
AM		 4429 { "PLTOFF", { 0,
4430 BFD_RELOC_X86_64_PLTOFF64 },
4431 Imm64 },
4432 { "PLT", { BFD_RELOC_386_PLT32,
4433 BFD_RELOC_X86_64_PLT32 },
4434 Imm32 | Imm32S | Disp32 },
4435 { "GOTPLT", { 0,
4436 BFD_RELOC_X86_64_GOTPLT64 },
4437 Imm64 | Disp64 },
4438 { "GOTOFF", { BFD_RELOC_386_GOTOFF,
4439 BFD_RELOC_X86_64_GOTOFF64 },
4440 Imm64 | Disp64 },
4441 { "GOTPCREL", { 0,
4442 BFD_RELOC_X86_64_GOTPCREL },
4443 Imm32 | Imm32S | Disp32 },
4444 { "TLSGD", { BFD_RELOC_386_TLS_GD,
4445 BFD_RELOC_X86_64_TLSGD },
4446 Imm32 | Imm32S | Disp32 },
4447 { "TLSLDM", { BFD_RELOC_386_TLS_LDM,
4448 0 },
4449 0 },
4450 { "TLSLD", { 0,
4451 BFD_RELOC_X86_64_TLSLD },
4452 Imm32 | Imm32S | Disp32 },
4453 { "GOTTPOFF", { BFD_RELOC_386_TLS_IE_32,
4454 BFD_RELOC_X86_64_GOTTPOFF },
4455 Imm32 | Imm32S | Disp32 },
4456 { "TPOFF", { BFD_RELOC_386_TLS_LE_32,
4457 BFD_RELOC_X86_64_TPOFF32 },
4458 Imm32 | Imm32S | Imm64 | Disp32 | Disp64 },
4459 { "NTPOFF", { BFD_RELOC_386_TLS_LE,
4460 0 },
4461 0 },
4462 { "DTPOFF", { BFD_RELOC_386_TLS_LDO_32,
4463 BFD_RELOC_X86_64_DTPOFF32 },
4464 Imm32 | Imm32S | Imm64 | Disp32 | Disp64 },
4465 { "GOTNTPOFF",{ BFD_RELOC_386_TLS_GOTIE,
4466 0 },
4467 0 },
4468 { "INDNTPOFF",{ BFD_RELOC_386_TLS_IE,
4469 0 },
4470 0 },
4471 { "GOT", { BFD_RELOC_386_GOT32,
4472 BFD_RELOC_X86_64_GOT32 },
4473 Imm32 | Imm32S | Disp32 | Imm64 },
4474 { "TLSDESC", { BFD_RELOC_386_TLS_GOTDESC,
4475 BFD_RELOC_X86_64_GOTPC32_TLSDESC },
4476 Imm32 | Imm32S | Disp32 },
4477 { "TLSCALL", { BFD_RELOC_386_TLS_DESC_CALL,
4478 BFD_RELOC_X86_64_TLSDESC_CALL },
4479 Imm32 | Imm32S | Disp32 }
f3c180ae
AM		 4480 };
4481 char *cp;
4482 unsigned int j;
4483
718ddfc0
JB		 4484 if (!IS_ELF)
4485 return NULL;
4486
f3c180ae
AM		 4487 for (cp = input_line_pointer; *cp != '@'; cp++)
4488 if (is_end_of_line[(unsigned char) *cp])
4489 return NULL;
4490
4491 for (j = 0; j < sizeof (gotrel) / sizeof (gotrel[0]); j++)
4492 {
4493 int len;
4494
4495 len = strlen (gotrel[j].str);
28f81592 4496 if (strncasecmp (cp + 1, gotrel[j].str, len) == 0)
f3c180ae 4497 {
4fa24527 4498 if (gotrel[j].rel[object_64bit] != 0)
f3c180ae 4499 {
28f81592
AM		 4500 int first, second;
4501 char *tmpbuf, *past_reloc;
f3c180ae 4502
4fa24527 4503 *reloc = gotrel[j].rel[object_64bit];
28f81592
AM		 4504 if (adjust)
4505 *adjust = len;
f3c180ae 4506
3956db08
JB		 4507 if (types)
4508 {
4509 if (flag_code != CODE_64BIT)
4eed87de 4510 *types = Imm32 | Disp32;
3956db08
JB		 4511 else
4512 *types = gotrel[j].types64;
4513 }
4514
f3c180ae
AM		 4515 if (GOT_symbol == NULL)
4516 GOT_symbol = symbol_find_or_make (GLOBAL_OFFSET_TABLE_NAME);
4517
28f81592 4518 /* The length of the first part of our input line. */
f3c180ae 4519 first = cp - input_line_pointer;
28f81592
AM		 4520
4521 /* The second part goes from after the reloc token until
4522 (and including) an end_of_line char. Don't use strlen
4523 here as the end_of_line char may not be a NUL. */
4524 past_reloc = cp + 1 + len;
4525 for (cp = past_reloc; !is_end_of_line[(unsigned char) *cp++]; )
4526 ;
4527 second = cp - past_reloc;
4528
4529 /* Allocate and copy string. The trailing NUL shouldn't
4530 be necessary, but be safe. */
4531 tmpbuf = xmalloc (first + second + 2);
f3c180ae 4532 memcpy (tmpbuf, input_line_pointer, first);
0787a12d
AM		 4533 if (second != 0 && *past_reloc != ' ')
4534 /* Replace the relocation token with ' ', so that
4535 errors like foo@GOTOFF1 will be detected. */
4536 tmpbuf[first++] = ' ';
4537 memcpy (tmpbuf + first, past_reloc, second);
4538 tmpbuf[first + second] = '\0';
f3c180ae
AM		 4539 return tmpbuf;
4540 }
4541
4fa24527
JB		 4542 as_bad (_("@%s reloc is not supported with %d-bit output format"),
4543 gotrel[j].str, 1 << (5 + object_64bit));
f3c180ae
AM		 4544 return NULL;
4545 }
4546 }
4547
4548 /* Might be a symbol version string. Don't as_bad here. */
4549 return NULL;
4550}
4551
f3c180ae 4552void
e3bb37b5 4553x86_cons (expressionS *exp, int size)
f3c180ae 4554{
4fa24527 4555 if (size == 4 || (object_64bit && size == 8))
f3c180ae
AM		 4556 {
4557 /* Handle @GOTOFF and the like in an expression. */
4558 char *save;
4559 char *gotfree_input_line;
4560 int adjust;
4561
4562 save = input_line_pointer;
3956db08 4563 gotfree_input_line = lex_got (&got_reloc, &adjust, NULL);
f3c180ae
AM		 4564 if (gotfree_input_line)
4565 input_line_pointer = gotfree_input_line;
4566
4567 expression (exp);
4568
4569 if (gotfree_input_line)
4570 {
4571 /* expression () has merrily parsed up to the end of line,
4572 or a comma - in the wrong buffer. Transfer how far
4573 input_line_pointer has moved to the right buffer. */
4574 input_line_pointer = (save
4575 + (input_line_pointer - gotfree_input_line)
4576 + adjust);
4577 free (gotfree_input_line);
4578 }
4579 }
4580 else
4581 expression (exp);
4582}
4583#endif
4584
d182319b 4585static void signed_cons (int size)
6482c264 4586{
d182319b
JB		 4587 if (flag_code == CODE_64BIT)
4588 cons_sign = 1;
4589 cons (size);
4590 cons_sign = -1;
6482c264
NC		 4591}
4592
d182319b 4593#ifdef TE_PE
6482c264
NC		 4594static void
4595pe_directive_secrel (dummy)
4596 int dummy ATTRIBUTE_UNUSED;
4597{
4598 expressionS exp;
4599
4600 do
4601 {
4602 expression (&exp);
4603 if (exp.X_op == O_symbol)
4604 exp.X_op = O_secrel;
4605
4606 emit_expr (&exp, 4);
4607 }
4608 while (*input_line_pointer++ == ',');
4609
4610 input_line_pointer--;
4611 demand_empty_rest_of_line ();
4612}
6482c264
NC		 4613#endif
4614
252b5132 4615static int
70e41ade 4616i386_immediate (char *imm_start)
252b5132
RH		 4617{
4618 char *save_input_line_pointer;
f3c180ae 4619 char *gotfree_input_line;
252b5132 4620 segT exp_seg = 0;
47926f60 4621 expressionS *exp;
3956db08 4622 unsigned int types = ~0U;
252b5132
RH		 4623
4624 if (i.imm_operands == MAX_IMMEDIATE_OPERANDS)
4625 {
31b2323c
L		 4626 as_bad (_("at most %d immediate operands are allowed"),
4627 MAX_IMMEDIATE_OPERANDS);
252b5132
RH		 4628 return 0;
4629 }
4630
4631 exp = &im_expressions[i.imm_operands++];
520dc8e8 4632 i.op[this_operand].imms = exp;
252b5132
RH		 4633
4634 if (is_space_char (*imm_start))
4635 ++imm_start;
4636
4637 save_input_line_pointer = input_line_pointer;
4638 input_line_pointer = imm_start;
4639
3956db08 4640 gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
f3c180ae
AM		 4641 if (gotfree_input_line)
4642 input_line_pointer = gotfree_input_line;
252b5132
RH		 4643
4644 exp_seg = expression (exp);
4645
83183c0c 4646 SKIP_WHITESPACE ();
252b5132 4647 if (*input_line_pointer)
f3c180ae 4648 as_bad (_("junk `%s' after expression"), input_line_pointer);
252b5132
RH		 4649
4650 input_line_pointer = save_input_line_pointer;
f3c180ae
AM		 4651 if (gotfree_input_line)
4652 free (gotfree_input_line);
252b5132 4653
2daf4fd8 4654 if (exp->X_op == O_absent || exp->X_op == O_big)
252b5132 4655 {
47926f60 4656 /* Missing or bad expr becomes absolute 0. */
d0b47220 4657 as_bad (_("missing or invalid immediate expression `%s' taken as 0"),
24eab124 4658 imm_start);
252b5132
RH		 4659 exp->X_op = O_constant;
4660 exp->X_add_number = 0;
4661 exp->X_add_symbol = (symbolS *) 0;
4662 exp->X_op_symbol = (symbolS *) 0;
252b5132 4663 }
3e73aa7c 4664 else if (exp->X_op == O_constant)
252b5132 4665 {
47926f60 4666 /* Size it properly later. */
3e73aa7c
JH		 4667 i.types[this_operand] |= Imm64;
4668 /* If BFD64, sign extend val. */
4eed87de
AM		 4669 if (!use_rela_relocations
4670 && (exp->X_add_number & ~(((addressT) 2 << 31) - 1)) == 0)
4671 exp->X_add_number
4672 = (exp->X_add_number ^ ((addressT) 1 << 31)) - ((addressT) 1 << 31);
252b5132 4673 }
4c63da97 4674#if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
f86103b7 4675 else if (OUTPUT_FLAVOR == bfd_target_aout_flavour
31312f95 4676 && exp_seg != absolute_section
47926f60 4677 && exp_seg != text_section
24eab124
AM		 4678 && exp_seg != data_section
4679 && exp_seg != bss_section
4680 && exp_seg != undefined_section
f86103b7 4681 && !bfd_is_com_section (exp_seg))
252b5132 4682 {
d0b47220 4683 as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
252b5132
RH		 4684 return 0;
4685 }
4686#endif
bb8f5920
L		 4687 else if (!intel_syntax && exp->X_op == O_register)
4688 {
4689 as_bad (_("illegal immediate register operand %s"), imm_start);
4690 return 0;
4691 }
252b5132
RH		 4692 else
4693 {
4694 /* This is an address. The size of the address will be
24eab124 4695 determined later, depending on destination register,
3e73aa7c
JH		 4696 suffix, or the default for the section. */
4697 i.types[this_operand] |= Imm8 | Imm16 | Imm32 | Imm32S | Imm64;
3956db08 4698 i.types[this_operand] &= types;
252b5132
RH		 4699 }
4700
4701 return 1;
4702}
4703
551c1ca1 4704static char *
e3bb37b5 4705i386_scale (char *scale)
252b5132 4706{
551c1ca1
AM		 4707 offsetT val;
4708 char *save = input_line_pointer;
252b5132 4709
551c1ca1
AM		 4710 input_line_pointer = scale;
4711 val = get_absolute_expression ();
4712
4713 switch (val)
252b5132 4714 {
551c1ca1 4715 case 1:
252b5132
RH		 4716 i.log2_scale_factor = 0;
4717 break;
551c1ca1 4718 case 2:
252b5132
RH		 4719 i.log2_scale_factor = 1;
4720 break;
551c1ca1 4721 case 4:
252b5132
RH		 4722 i.log2_scale_factor = 2;
4723 break;
551c1ca1 4724 case 8:
252b5132
RH		 4725 i.log2_scale_factor = 3;
4726 break;
4727 default:
a724f0f4
JB		 4728 {
4729 char sep = *input_line_pointer;
4730
4731 *input_line_pointer = '\0';
4732 as_bad (_("expecting scale factor of 1, 2, 4, or 8: got `%s'"),
4733 scale);
4734 *input_line_pointer = sep;
4735 input_line_pointer = save;
4736 return NULL;
4737 }
252b5132 4738 }
29b0f896 4739 if (i.log2_scale_factor != 0 && i.index_reg == 0)
252b5132
RH		 4740 {
4741 as_warn (_("scale factor of %d without an index register"),
24eab124 4742 1 << i.log2_scale_factor);
252b5132
RH		 4743#if SCALE1_WHEN_NO_INDEX
4744 i.log2_scale_factor = 0;
4745#endif
4746 }
551c1ca1
AM		 4747 scale = input_line_pointer;
4748 input_line_pointer = save;
4749 return scale;
252b5132
RH		 4750}
4751
252b5132 4752static int
e3bb37b5 4753i386_displacement (char *disp_start, char *disp_end)
252b5132 4754{
29b0f896 4755 expressionS *exp;
252b5132
RH		 4756 segT exp_seg = 0;
4757 char *save_input_line_pointer;
f3c180ae 4758 char *gotfree_input_line;
e05278af 4759 int bigdisp, override;
3956db08 4760 unsigned int types = Disp;
252b5132 4761
31b2323c
L		 4762 if (i.disp_operands == MAX_MEMORY_OPERANDS)
4763 {
4764 as_bad (_("at most %d displacement operands are allowed"),
4765 MAX_MEMORY_OPERANDS);
4766 return 0;
4767 }
4768
e05278af
JB		 4769 if ((i.types[this_operand] & JumpAbsolute)
4770 || !(current_templates->start->opcode_modifier & (Jump | JumpDword)))
4771 {
4772 bigdisp = Disp32;
4773 override = (i.prefix[ADDR_PREFIX] != 0);
4774 }
4775 else
4776 {
4777 /* For PC-relative branches, the width of the displacement
4778 is dependent upon data size, not address size. */
4779 bigdisp = 0;
4780 override = (i.prefix[DATA_PREFIX] != 0);
4781 }
3e73aa7c 4782 if (flag_code == CODE_64BIT)
7ecd2f8b 4783 {
e05278af 4784 if (!bigdisp)
64e74474
AM		 4785 bigdisp = ((override || i.suffix == WORD_MNEM_SUFFIX)
4786 ? Disp16
4787 : Disp32S | Disp32);
e05278af 4788 else if (!override)
3956db08 4789 bigdisp = Disp64 | Disp32S | Disp32;
7ecd2f8b 4790 }
e05278af
JB		 4791 else
4792 {
4793 if (!bigdisp)
4794 {
4795 if (!override)
4796 override = (i.suffix == (flag_code != CODE_16BIT
4797 ? WORD_MNEM_SUFFIX
4798 : LONG_MNEM_SUFFIX));
4799 bigdisp = Disp32;
4800 }
4801 if ((flag_code == CODE_16BIT) ^ override)
4802 bigdisp = Disp16;
4803 }
252b5132
RH		 4804 i.types[this_operand] |= bigdisp;
4805
4806 exp = &disp_expressions[i.disp_operands];
520dc8e8 4807 i.op[this_operand].disps = exp;
252b5132
RH		 4808 i.disp_operands++;
4809 save_input_line_pointer = input_line_pointer;
4810 input_line_pointer = disp_start;
4811 END_STRING_AND_SAVE (disp_end);
4812
4813#ifndef GCC_ASM_O_HACK
4814#define GCC_ASM_O_HACK 0
4815#endif
4816#if GCC_ASM_O_HACK
4817 END_STRING_AND_SAVE (disp_end + 1);
4818 if ((i.types[this_operand] & BaseIndex) != 0
24eab124 4819 && displacement_string_end[-1] == '+')
252b5132
RH		 4820 {
4821 /* This hack is to avoid a warning when using the "o"
24eab124
AM		 4822 constraint within gcc asm statements.
4823 For instance:
4824
4825 #define _set_tssldt_desc(n,addr,limit,type) \
4826 __asm__ __volatile__ ( \
4827 "movw %w2,%0\n\t" \
4828 "movw %w1,2+%0\n\t" \
4829 "rorl $16,%1\n\t" \
4830 "movb %b1,4+%0\n\t" \
4831 "movb %4,5+%0\n\t" \
4832 "movb $0,6+%0\n\t" \
4833 "movb %h1,7+%0\n\t" \
4834 "rorl $16,%1" \
4835 : "=o"(*(n)) : "q" (addr), "ri"(limit), "i"(type))
4836
4837 This works great except that the output assembler ends
4838 up looking a bit weird if it turns out that there is
4839 no offset. You end up producing code that looks like:
4840
4841 #APP
4842 movw $235,(%eax)
4843 movw %dx,2+(%eax)
4844 rorl $16,%edx
4845 movb %dl,4+(%eax)
4846 movb $137,5+(%eax)
4847 movb $0,6+(%eax)
4848 movb %dh,7+(%eax)
4849 rorl $16,%edx
4850 #NO_APP
4851
47926f60 4852 So here we provide the missing zero. */
24eab124
AM		 4853
4854 *displacement_string_end = '0';
252b5132
RH		 4855 }
4856#endif
3956db08 4857 gotfree_input_line = lex_got (&i.reloc[this_operand], NULL, &types);
f3c180ae
AM		 4858 if (gotfree_input_line)
4859 input_line_pointer = gotfree_input_line;
252b5132 4860
24eab124 4861 exp_seg = expression (exp);
252b5132 4862
636c26b0
AM		 4863 SKIP_WHITESPACE ();
4864 if (*input_line_pointer)
4865 as_bad (_("junk `%s' after expression"), input_line_pointer);
4866#if GCC_ASM_O_HACK
4867 RESTORE_END_STRING (disp_end + 1);
4868#endif
4869 RESTORE_END_STRING (disp_end);
4870 input_line_pointer = save_input_line_pointer;
636c26b0
AM		 4871 if (gotfree_input_line)
4872 free (gotfree_input_line);
636c26b0 4873
24eab124
AM		 4874 /* We do this to make sure that the section symbol is in
4875 the symbol table. We will ultimately change the relocation
47926f60 4876 to be relative to the beginning of the section. */
1ae12ab7 4877 if (i.reloc[this_operand] == BFD_RELOC_386_GOTOFF
d6ab8113
JB		 4878 || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
4879 || i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
24eab124 4880 {
636c26b0
AM		 4881 if (exp->X_op != O_symbol)
4882 {
4883 as_bad (_("bad expression used with @%s"),
4884 (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL
4885 ? "GOTPCREL"
4886 : "GOTOFF"));
4887 return 0;
4888 }
4889
e5cb08ac 4890 if (S_IS_LOCAL (exp->X_add_symbol)
24eab124
AM		 4891 && S_GET_SEGMENT (exp->X_add_symbol) != undefined_section)
4892 section_symbol (S_GET_SEGMENT (exp->X_add_symbol));
24eab124
AM		 4893 exp->X_op = O_subtract;
4894 exp->X_op_symbol = GOT_symbol;
1ae12ab7 4895 if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTPCREL)
29b0f896 4896 i.reloc[this_operand] = BFD_RELOC_32_PCREL;
d6ab8113
JB		 4897 else if (i.reloc[this_operand] == BFD_RELOC_X86_64_GOTOFF64)
4898 i.reloc[this_operand] = BFD_RELOC_64;
23df1078 4899 else
29b0f896 4900 i.reloc[this_operand] = BFD_RELOC_32;
24eab124 4901 }
252b5132 4902
2daf4fd8
AM		 4903 if (exp->X_op == O_absent || exp->X_op == O_big)
4904 {
47926f60 4905 /* Missing or bad expr becomes absolute 0. */
d0b47220 4906 as_bad (_("missing or invalid displacement expression `%s' taken as 0"),
2daf4fd8
AM		 4907 disp_start);
4908 exp->X_op = O_constant;
4909 exp->X_add_number = 0;
4910 exp->X_add_symbol = (symbolS *) 0;
4911 exp->X_op_symbol = (symbolS *) 0;
4912 }
4913
4c63da97 4914#if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
45288df1 4915 if (exp->X_op != O_constant
45288df1 4916 && OUTPUT_FLAVOR == bfd_target_aout_flavour
31312f95 4917 && exp_seg != absolute_section
45288df1
AM		 4918 && exp_seg != text_section
4919 && exp_seg != data_section
4920 && exp_seg != bss_section
31312f95 4921 && exp_seg != undefined_section
f86103b7 4922 && !bfd_is_com_section (exp_seg))
24eab124 4923 {
d0b47220 4924 as_bad (_("unimplemented segment %s in operand"), exp_seg->name);
24eab124
AM		 4925 return 0;
4926 }
252b5132 4927#endif
3956db08
JB		 4928
4929 if (!(i.types[this_operand] & ~Disp))
4930 i.types[this_operand] &= types;
4931
252b5132
RH		 4932 return 1;
4933}
4934
eecb386c 4935/* Make sure the memory operand we've been dealt is valid.
47926f60
KH		 4936 Return 1 on success, 0 on a failure. */
4937
252b5132 4938static int
e3bb37b5 4939i386_index_check (const char *operand_string)
252b5132 4940{
3e73aa7c 4941 int ok;
24eab124 4942#if INFER_ADDR_PREFIX
eecb386c
AM		 4943 int fudged = 0;
4944
24eab124
AM		 4945 tryprefix:
4946#endif
3e73aa7c 4947 ok = 1;
30123838
JB		 4948 if ((current_templates->start->cpu_flags & CpuSVME)
4949 && current_templates->end[-1].operand_types[0] == AnyMem)
4950 {
4951 /* Memory operands of SVME insns are special in that they only allow
4952 rAX as their memory address and ignore any segment override. */
4953 unsigned RegXX;
4954
4955 /* SKINIT is even more restrictive: it always requires EAX. */
4956 if (strcmp (current_templates->start->name, "skinit") == 0)
4957 RegXX = Reg32;
4958 else if (flag_code == CODE_64BIT)
4959 RegXX = i.prefix[ADDR_PREFIX] == 0 ? Reg64 : Reg32;
4960 else
64e74474
AM		 4961 RegXX = ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0)
4962 ? Reg16
4963 : Reg32);
30123838
JB		 4964 if (!i.base_reg
4965 || !(i.base_reg->reg_type & Acc)
4966 || !(i.base_reg->reg_type & RegXX)
4967 || i.index_reg
4968 || (i.types[0] & Disp))
4969 ok = 0;
4970 }
4971 else if (flag_code == CODE_64BIT)
64e74474
AM		 4972 {
4973 unsigned RegXX = (i.prefix[ADDR_PREFIX] == 0 ? Reg64 : Reg32);
4974
4975 if ((i.base_reg
4976 && ((i.base_reg->reg_type & RegXX) == 0)
4977 && (i.base_reg->reg_type != BaseIndex
4978 || i.index_reg))
4979 || (i.index_reg
4980 && ((i.index_reg->reg_type & (RegXX | BaseIndex))
4981 != (RegXX | BaseIndex))))
4982 ok = 0;
3e73aa7c
JH		 4983 }
4984 else
4985 {
4986 if ((flag_code == CODE_16BIT) ^ (i.prefix[ADDR_PREFIX] != 0))
4987 {
4988 /* 16bit checks. */
4989 if ((i.base_reg
29b0f896
AM		 4990 && ((i.base_reg->reg_type & (Reg16 | BaseIndex | RegRex))
4991 != (Reg16 | BaseIndex)))
3e73aa7c 4992 || (i.index_reg
29b0f896
AM		 4993 && (((i.index_reg->reg_type & (Reg16 | BaseIndex))
4994 != (Reg16 | BaseIndex))
4995 || !(i.base_reg
4996 && i.base_reg->reg_num < 6
4997 && i.index_reg->reg_num >= 6
4998 && i.log2_scale_factor == 0))))
3e73aa7c
JH		 4999 ok = 0;
5000 }
5001 else
e5cb08ac 5002 {
3e73aa7c
JH		 5003 /* 32bit checks. */
5004 if ((i.base_reg
5005 && (i.base_reg->reg_type & (Reg32 | RegRex)) != Reg32)
5006 || (i.index_reg
29b0f896
AM		 5007 && ((i.index_reg->reg_type & (Reg32 | BaseIndex | RegRex))
5008 != (Reg32 | BaseIndex))))
e5cb08ac 5009 ok = 0;
3e73aa7c
JH		 5010 }
5011 }
5012 if (!ok)
24eab124
AM		 5013 {
5014#if INFER_ADDR_PREFIX
20f0a1fc 5015 if (i.prefix[ADDR_PREFIX] == 0)
24eab124
AM		 5016 {
5017 i.prefix[ADDR_PREFIX] = ADDR_PREFIX_OPCODE;
5018 i.prefixes += 1;
b23bac36
AM		 5019 /* Change the size of any displacement too. At most one of
5020 Disp16 or Disp32 is set.
5021 FIXME. There doesn't seem to be any real need for separate
5022 Disp16 and Disp32 flags. The same goes for Imm16 and Imm32.
47926f60 5023 Removing them would probably clean up the code quite a lot. */
4eed87de
AM		 5024 if (flag_code != CODE_64BIT
5025 && (i.types[this_operand] & (Disp16 | Disp32)))
64e74474 5026 i.types[this_operand] ^= (Disp16 | Disp32);
eecb386c 5027 fudged = 1;
24eab124
AM		 5028 goto tryprefix;
5029 }
eecb386c
AM		 5030 if (fudged)
5031 as_bad (_("`%s' is not a valid base/index expression"),
5032 operand_string);
5033 else
c388dee8 5034#endif
eecb386c
AM		 5035 as_bad (_("`%s' is not a valid %s bit base/index expression"),
5036 operand_string,
3e73aa7c 5037 flag_code_names[flag_code]);
24eab124 5038 }
20f0a1fc 5039 return ok;
24eab124 5040}
252b5132 5041
252b5132 5042/* Parse OPERAND_STRING into the i386_insn structure I. Returns non-zero
47926f60 5043 on error. */
252b5132 5044
252b5132 5045static int
e3bb37b5 5046i386_operand (char *operand_string)
252b5132 5047{
af6bdddf
AM		 5048 const reg_entry *r;
5049 char *end_op;
24eab124 5050 char *op_string = operand_string;
252b5132 5051
24eab124 5052 if (is_space_char (*op_string))
252b5132
RH		 5053 ++op_string;
5054
24eab124 5055 /* We check for an absolute prefix (differentiating,
47926f60 5056 for example, 'jmp pc_relative_label' from 'jmp *absolute_label'. */
24eab124
AM		 5057 if (*op_string == ABSOLUTE_PREFIX)
5058 {
5059 ++op_string;
5060 if (is_space_char (*op_string))
5061 ++op_string;
5062 i.types[this_operand] |= JumpAbsolute;
5063 }
252b5132 5064
47926f60 5065 /* Check if operand is a register. */
4d1bb795 5066 if ((r = parse_register (op_string, &end_op)) != NULL)
24eab124 5067 {
24eab124
AM		 5068 /* Check for a segment override by searching for ':' after a
5069 segment register. */
5070 op_string = end_op;
5071 if (is_space_char (*op_string))
5072 ++op_string;
5073 if (*op_string == ':' && (r->reg_type & (SReg2 | SReg3)))
5074 {
5075 switch (r->reg_num)
5076 {
5077 case 0:
5078 i.seg[i.mem_operands] = &es;
5079 break;
5080 case 1:
5081 i.seg[i.mem_operands] = &cs;
5082 break;
5083 case 2:
5084 i.seg[i.mem_operands] = &ss;
5085 break;
5086 case 3:
5087 i.seg[i.mem_operands] = &ds;
5088 break;
5089 case 4:
5090 i.seg[i.mem_operands] = &fs;
5091 break;
5092 case 5:
5093 i.seg[i.mem_operands] = &gs;
5094 break;
5095 }
252b5132 5096
24eab124 5097 /* Skip the ':' and whitespace. */
252b5132
RH		 5098 ++op_string;
5099 if (is_space_char (*op_string))
24eab124 5100 ++op_string;
252b5132 5101
24eab124
AM		 5102 if (!is_digit_char (*op_string)
5103 && !is_identifier_char (*op_string)
5104 && *op_string != '('
5105 && *op_string != ABSOLUTE_PREFIX)
5106 {
5107 as_bad (_("bad memory operand `%s'"), op_string);
5108 return 0;
5109 }
47926f60 5110 /* Handle case of %es:*foo. */
24eab124
AM		 5111 if (*op_string == ABSOLUTE_PREFIX)
5112 {
5113 ++op_string;
5114 if (is_space_char (*op_string))
5115 ++op_string;
5116 i.types[this_operand] |= JumpAbsolute;
5117 }
5118 goto do_memory_reference;
5119 }
5120 if (*op_string)
5121 {
d0b47220 5122 as_bad (_("junk `%s' after register"), op_string);
24eab124
AM		 5123 return 0;
5124 }
5125 i.types[this_operand] |= r->reg_type & ~BaseIndex;
520dc8e8 5126 i.op[this_operand].regs = r;
24eab124
AM		 5127 i.reg_operands++;
5128 }
af6bdddf
AM		 5129 else if (*op_string == REGISTER_PREFIX)
5130 {
5131 as_bad (_("bad register name `%s'"), op_string);
5132 return 0;
5133 }
24eab124 5134 else if (*op_string == IMMEDIATE_PREFIX)
ce8a8b2f 5135 {
24eab124
AM		 5136 ++op_string;
5137 if (i.types[this_operand] & JumpAbsolute)
5138 {
d0b47220 5139 as_bad (_("immediate operand illegal with absolute jump"));
24eab124
AM		 5140 return 0;
5141 }
5142 if (!i386_immediate (op_string))
5143 return 0;
5144 }
5145 else if (is_digit_char (*op_string)
5146 || is_identifier_char (*op_string)
e5cb08ac 5147 || *op_string == '(')
24eab124 5148 {
47926f60 5149 /* This is a memory reference of some sort. */
af6bdddf 5150 char *base_string;
252b5132 5151
47926f60 5152 /* Start and end of displacement string expression (if found). */
eecb386c
AM		 5153 char *displacement_string_start;
5154 char *displacement_string_end;
252b5132 5155
24eab124 5156 do_memory_reference:
24eab124
AM		 5157 if ((i.mem_operands == 1
5158 && (current_templates->start->opcode_modifier & IsString) == 0)
5159 || i.mem_operands == 2)
5160 {
5161 as_bad (_("too many memory references for `%s'"),
5162 current_templates->start->name);
5163 return 0;
5164 }
252b5132 5165
24eab124
AM		 5166 /* Check for base index form. We detect the base index form by
5167 looking for an ')' at the end of the operand, searching
5168 for the '(' matching it, and finding a REGISTER_PREFIX or ','
5169 after the '('. */
af6bdddf 5170 base_string = op_string + strlen (op_string);
c3332e24 5171
af6bdddf
AM		 5172 --base_string;
5173 if (is_space_char (*base_string))
5174 --base_string;
252b5132 5175
47926f60 5176 /* If we only have a displacement, set-up for it to be parsed later. */
af6bdddf
AM		 5177 displacement_string_start = op_string;
5178 displacement_string_end = base_string + 1;
252b5132 5179
24eab124
AM		 5180 if (*base_string == ')')
5181 {
af6bdddf 5182 char *temp_string;
24eab124
AM		 5183 unsigned int parens_balanced = 1;
5184 /* We've already checked that the number of left & right ()'s are
47926f60 5185 equal, so this loop will not be infinite. */
24eab124
AM		 5186 do
5187 {
5188 base_string--;
5189 if (*base_string == ')')
5190 parens_balanced++;
5191 if (*base_string == '(')
5192 parens_balanced--;
5193 }
5194 while (parens_balanced);
c3332e24 5195
af6bdddf 5196 temp_string = base_string;
c3332e24 5197
24eab124 5198 /* Skip past '(' and whitespace. */
252b5132
RH		 5199 ++base_string;
5200 if (is_space_char (*base_string))
24eab124 5201 ++base_string;
252b5132 5202
af6bdddf 5203 if (*base_string == ','
4eed87de
AM		 5204 || ((i.base_reg = parse_register (base_string, &end_op))
5205 != NULL))
252b5132 5206 {
af6bdddf 5207 displacement_string_end = temp_string;
252b5132 5208
af6bdddf 5209 i.types[this_operand] |= BaseIndex;
252b5132 5210
af6bdddf 5211 if (i.base_reg)
24eab124 5212 {
24eab124
AM		 5213 base_string = end_op;
5214 if (is_space_char (*base_string))
5215 ++base_string;
af6bdddf
AM		 5216 }
5217
5218 /* There may be an index reg or scale factor here. */
5219 if (*base_string == ',')
5220 {
5221 ++base_string;
5222 if (is_space_char (*base_string))
5223 ++base_string;
5224
4eed87de
AM		 5225 if ((i.index_reg = parse_register (base_string, &end_op))
5226 != NULL)
24eab124 5227 {
af6bdddf 5228 base_string = end_op;
24eab124
AM		 5229 if (is_space_char (*base_string))
5230 ++base_string;
af6bdddf
AM		 5231 if (*base_string == ',')
5232 {
5233 ++base_string;
5234 if (is_space_char (*base_string))
5235 ++base_string;
5236 }
e5cb08ac 5237 else if (*base_string != ')')
af6bdddf 5238 {
4eed87de
AM		 5239 as_bad (_("expecting `,' or `)' "
5240 "after index register in `%s'"),
af6bdddf
AM		 5241 operand_string);
5242 return 0;
5243 }
24eab124 5244 }
af6bdddf 5245 else if (*base_string == REGISTER_PREFIX)
24eab124 5246 {
af6bdddf 5247 as_bad (_("bad register name `%s'"), base_string);
24eab124
AM		 5248 return 0;
5249 }
252b5132 5250
47926f60 5251 /* Check for scale factor. */
551c1ca1 5252 if (*base_string != ')')
af6bdddf 5253 {
551c1ca1
AM		 5254 char *end_scale = i386_scale (base_string);
5255
5256 if (!end_scale)
af6bdddf 5257 return 0;
24eab124 5258
551c1ca1 5259 base_string = end_scale;
af6bdddf
AM		 5260 if (is_space_char (*base_string))
5261 ++base_string;
5262 if (*base_string != ')')
5263 {
4eed87de
AM		 5264 as_bad (_("expecting `)' "
5265 "after scale factor in `%s'"),
af6bdddf
AM		 5266 operand_string);
5267 return 0;
5268 }
5269 }
5270 else if (!i.index_reg)
24eab124 5271 {
4eed87de
AM		 5272 as_bad (_("expecting index register or scale factor "
5273 "after `,'; got '%c'"),
af6bdddf 5274 *base_string);
24eab124
AM		 5275 return 0;
5276 }
5277 }
af6bdddf 5278 else if (*base_string != ')')
24eab124 5279 {
4eed87de
AM		 5280 as_bad (_("expecting `,' or `)' "
5281 "after base register in `%s'"),
af6bdddf 5282 operand_string);
24eab124
AM		 5283 return 0;
5284 }
c3332e24 5285 }
af6bdddf 5286 else if (*base_string == REGISTER_PREFIX)
c3332e24 5287 {
af6bdddf 5288 as_bad (_("bad register name `%s'"), base_string);
24eab124 5289 return 0;
c3332e24 5290 }
24eab124
AM		 5291 }
5292
5293 /* If there's an expression beginning the operand, parse it,
5294 assuming displacement_string_start and
5295 displacement_string_end are meaningful. */
5296 if (displacement_string_start != displacement_string_end)
5297 {
5298 if (!i386_displacement (displacement_string_start,
5299 displacement_string_end))
5300 return 0;
5301 }
5302
5303 /* Special case for (%dx) while doing input/output op. */
5304 if (i.base_reg
5305 && i.base_reg->reg_type == (Reg16 | InOutPortReg)
5306 && i.index_reg == 0
5307 && i.log2_scale_factor == 0
5308 && i.seg[i.mem_operands] == 0
5309 && (i.types[this_operand] & Disp) == 0)
5310 {
5311 i.types[this_operand] = InOutPortReg;
5312 return 1;
5313 }
5314
eecb386c
AM		 5315 if (i386_index_check (operand_string) == 0)
5316 return 0;
24eab124
AM		 5317 i.mem_operands++;
5318 }
5319 else
ce8a8b2f
AM		 5320 {
5321 /* It's not a memory operand; argh! */
24eab124
AM		 5322 as_bad (_("invalid char %s beginning operand %d `%s'"),
5323 output_invalid (*op_string),
5324 this_operand + 1,
5325 op_string);
5326 return 0;
5327 }
47926f60 5328 return 1; /* Normal return. */
252b5132
RH		 5329}
5330\f
ee7fcc42
AM		 5331/* md_estimate_size_before_relax()
5332
5333 Called just before relax() for rs_machine_dependent frags. The x86
5334 assembler uses these frags to handle variable size jump
5335 instructions.
5336
5337 Any symbol that is now undefined will not become defined.
5338 Return the correct fr_subtype in the frag.
5339 Return the initial "guess for variable size of frag" to caller.
5340 The guess is actually the growth beyond the fixed part. Whatever
5341 we do to grow the fixed or variable part contributes to our
5342 returned value. */
5343
252b5132
RH		 5344int
5345md_estimate_size_before_relax (fragP, segment)
29b0f896
AM		 5346 fragS *fragP;
5347 segT segment;
252b5132 5348{
252b5132 5349 /* We've already got fragP->fr_subtype right; all we have to do is
b98ef147
AM		 5350 check for un-relaxable symbols. On an ELF system, we can't relax
5351 an externally visible symbol, because it may be overridden by a
5352 shared library. */
5353 if (S_GET_SEGMENT (fragP->fr_symbol) != segment
6d249963 5354#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
718ddfc0 5355 || (IS_ELF
31312f95
AM		 5356 && (S_IS_EXTERNAL (fragP->fr_symbol)
5357 || S_IS_WEAK (fragP->fr_symbol)))
b98ef147
AM		 5358#endif
5359 )
252b5132 5360 {
b98ef147
AM		 5361 /* Symbol is undefined in this segment, or we need to keep a
5362 reloc so that weak symbols can be overridden. */
5363 int size = (fragP->fr_subtype & CODE16) ? 2 : 4;
f86103b7 5364 enum bfd_reloc_code_real reloc_type;
ee7fcc42
AM		 5365 unsigned char *opcode;
5366 int old_fr_fix;
f6af82bd 5367
ee7fcc42
AM		 5368 if (fragP->fr_var != NO_RELOC)
5369 reloc_type = fragP->fr_var;
b98ef147 5370 else if (size == 2)
f6af82bd
AM		 5371 reloc_type = BFD_RELOC_16_PCREL;
5372 else
5373 reloc_type = BFD_RELOC_32_PCREL;
252b5132 5374
ee7fcc42
AM		 5375 old_fr_fix = fragP->fr_fix;
5376 opcode = (unsigned char *) fragP->fr_opcode;
5377
fddf5b5b 5378 switch (TYPE_FROM_RELAX_STATE (fragP->fr_subtype))
252b5132 5379 {
fddf5b5b
AM		 5380 case UNCOND_JUMP:
5381 /* Make jmp (0xeb) a (d)word displacement jump. */
47926f60 5382 opcode[0] = 0xe9;
252b5132 5383 fragP->fr_fix += size;
062cd5e7
AS		 5384 fix_new (fragP, old_fr_fix, size,
5385 fragP->fr_symbol,
5386 fragP->fr_offset, 1,
5387 reloc_type);
252b5132
RH		 5388 break;
5389
fddf5b5b 5390 case COND_JUMP86:
412167cb
AM		 5391 if (size == 2
5392 && (!no_cond_jump_promotion || fragP->fr_var != NO_RELOC))
fddf5b5b
AM		 5393 {
5394 /* Negate the condition, and branch past an
5395 unconditional jump. */
5396 opcode[0] ^= 1;
5397 opcode[1] = 3;
5398 /* Insert an unconditional jump. */
5399 opcode[2] = 0xe9;
5400 /* We added two extra opcode bytes, and have a two byte
5401 offset. */
5402 fragP->fr_fix += 2 + 2;
062cd5e7
AS		 5403 fix_new (fragP, old_fr_fix + 2, 2,
5404 fragP->fr_symbol,
5405 fragP->fr_offset, 1,
5406 reloc_type);
fddf5b5b
AM		 5407 break;
5408 }
5409 /* Fall through. */
5410
5411 case COND_JUMP:
412167cb
AM		 5412 if (no_cond_jump_promotion && fragP->fr_var == NO_RELOC)
5413 {
3e02c1cc
AM		 5414 fixS *fixP;
5415
412167cb 5416 fragP->fr_fix += 1;
3e02c1cc
AM		 5417 fixP = fix_new (fragP, old_fr_fix, 1,
5418 fragP->fr_symbol,
5419 fragP->fr_offset, 1,
5420 BFD_RELOC_8_PCREL);
5421 fixP->fx_signed = 1;
412167cb
AM		 5422 break;
5423 }
93c2a809 5424
24eab124 5425 /* This changes the byte-displacement jump 0x7N
fddf5b5b 5426 to the (d)word-displacement jump 0x0f,0x8N. */
252b5132 5427 opcode[1] = opcode[0] + 0x10;
f6af82bd 5428 opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
47926f60
KH		 5429 /* We've added an opcode byte. */
5430 fragP->fr_fix += 1 + size;
062cd5e7
AS		 5431 fix_new (fragP, old_fr_fix + 1, size,
5432 fragP->fr_symbol,
5433 fragP->fr_offset, 1,
5434 reloc_type);
252b5132 5435 break;
fddf5b5b
AM		 5436
5437 default:
5438 BAD_CASE (fragP->fr_subtype);
5439 break;
252b5132
RH		 5440 }
5441 frag_wane (fragP);
ee7fcc42 5442 return fragP->fr_fix - old_fr_fix;
252b5132 5443 }
93c2a809 5444
93c2a809
AM		 5445 /* Guess size depending on current relax state. Initially the relax
5446 state will correspond to a short jump and we return 1, because
5447 the variable part of the frag (the branch offset) is one byte
5448 long. However, we can relax a section more than once and in that
5449 case we must either set fr_subtype back to the unrelaxed state,
5450 or return the value for the appropriate branch. */
5451 return md_relax_table[fragP->fr_subtype].rlx_length;
ee7fcc42
AM		 5452}
5453
47926f60
KH		 5454/* Called after relax() is finished.
5455
5456 In: Address of frag.
5457 fr_type == rs_machine_dependent.
5458 fr_subtype is what the address relaxed to.
5459
5460 Out: Any fixSs and constants are set up.
5461 Caller will turn frag into a ".space 0". */
5462
252b5132
RH		 5463void
5464md_convert_frag (abfd, sec, fragP)
ab9da554
ILT		 5465 bfd *abfd ATTRIBUTE_UNUSED;
5466 segT sec ATTRIBUTE_UNUSED;
29b0f896 5467 fragS *fragP;
252b5132 5468{
29b0f896 5469 unsigned char *opcode;
252b5132 5470 unsigned char *where_to_put_displacement = NULL;
847f7ad4
AM		 5471 offsetT target_address;
5472 offsetT opcode_address;
252b5132 5473 unsigned int extension = 0;
847f7ad4 5474 offsetT displacement_from_opcode_start;
252b5132
RH		 5475
5476 opcode = (unsigned char *) fragP->fr_opcode;
5477
47926f60 5478 /* Address we want to reach in file space. */
252b5132 5479 target_address = S_GET_VALUE (fragP->fr_symbol) + fragP->fr_offset;
252b5132 5480
47926f60 5481 /* Address opcode resides at in file space. */
252b5132
RH		 5482 opcode_address = fragP->fr_address + fragP->fr_fix;
5483
47926f60 5484 /* Displacement from opcode start to fill into instruction. */
252b5132
RH		 5485 displacement_from_opcode_start = target_address - opcode_address;
5486
fddf5b5b 5487 if ((fragP->fr_subtype & BIG) == 0)
252b5132 5488 {
47926f60
KH		 5489 /* Don't have to change opcode. */
5490 extension = 1; /* 1 opcode + 1 displacement */
252b5132 5491 where_to_put_displacement = &opcode[1];
fddf5b5b
AM		 5492 }
5493 else
5494 {
5495 if (no_cond_jump_promotion
5496 && TYPE_FROM_RELAX_STATE (fragP->fr_subtype) != UNCOND_JUMP)
4eed87de
AM		 5497 as_warn_where (fragP->fr_file, fragP->fr_line,
5498 _("long jump required"));
252b5132 5499
fddf5b5b
AM		 5500 switch (fragP->fr_subtype)
5501 {
5502 case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG):
5503 extension = 4; /* 1 opcode + 4 displacement */
5504 opcode[0] = 0xe9;
5505 where_to_put_displacement = &opcode[1];
5506 break;
252b5132 5507
fddf5b5b
AM		 5508 case ENCODE_RELAX_STATE (UNCOND_JUMP, BIG16):
5509 extension = 2; /* 1 opcode + 2 displacement */
5510 opcode[0] = 0xe9;
5511 where_to_put_displacement = &opcode[1];
5512 break;
252b5132 5513
fddf5b5b
AM		 5514 case ENCODE_RELAX_STATE (COND_JUMP, BIG):
5515 case ENCODE_RELAX_STATE (COND_JUMP86, BIG):
5516 extension = 5; /* 2 opcode + 4 displacement */
5517 opcode[1] = opcode[0] + 0x10;
5518 opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
5519 where_to_put_displacement = &opcode[2];
5520 break;
252b5132 5521
fddf5b5b
AM		 5522 case ENCODE_RELAX_STATE (COND_JUMP, BIG16):
5523 extension = 3; /* 2 opcode + 2 displacement */
5524 opcode[1] = opcode[0] + 0x10;
5525 opcode[0] = TWO_BYTE_OPCODE_ESCAPE;
5526 where_to_put_displacement = &opcode[2];
5527 break;
252b5132 5528
fddf5b5b
AM		 5529 case ENCODE_RELAX_STATE (COND_JUMP86, BIG16):
5530 extension = 4;
5531 opcode[0] ^= 1;
5532 opcode[1] = 3;
5533 opcode[2] = 0xe9;
5534 where_to_put_displacement = &opcode[3];
5535 break;
5536
5537 default:
5538 BAD_CASE (fragP->fr_subtype);
5539 break;
5540 }
252b5132 5541 }
fddf5b5b 5542
7b81dfbb
AJ		 5543 /* If size if less then four we are sure that the operand fits,
5544 but if it's 4, then it could be that the displacement is larger
5545 then -/+ 2GB. */
5546 if (DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype) == 4
5547 && object_64bit
5548 && ((addressT) (displacement_from_opcode_start - extension
4eed87de
AM		 5549 + ((addressT) 1 << 31))
5550 > (((addressT) 2 << 31) - 1)))
7b81dfbb
AJ		 5551 {
5552 as_bad_where (fragP->fr_file, fragP->fr_line,
5553 _("jump target out of range"));
5554 /* Make us emit 0. */
5555 displacement_from_opcode_start = extension;
5556 }
47926f60 5557 /* Now put displacement after opcode. */
252b5132
RH		 5558 md_number_to_chars ((char *) where_to_put_displacement,
5559 (valueT) (displacement_from_opcode_start - extension),
fddf5b5b 5560 DISP_SIZE_FROM_RELAX_STATE (fragP->fr_subtype));
252b5132
RH		 5561 fragP->fr_fix += extension;
5562}
5563\f
47926f60
KH		 5564/* Size of byte displacement jmp. */
5565int md_short_jump_size = 2;
5566
5567/* Size of dword displacement jmp. */
5568int md_long_jump_size = 5;
252b5132 5569
252b5132
RH		 5570void
5571md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
5572 char *ptr;
5573 addressT from_addr, to_addr;
ab9da554
ILT		 5574 fragS *frag ATTRIBUTE_UNUSED;
5575 symbolS *to_symbol ATTRIBUTE_UNUSED;
252b5132 5576{
847f7ad4 5577 offsetT offset;
252b5132
RH		 5578
5579 offset = to_addr - (from_addr + 2);
47926f60
KH		 5580 /* Opcode for byte-disp jump. */
5581 md_number_to_chars (ptr, (valueT) 0xeb, 1);
252b5132
RH		 5582 md_number_to_chars (ptr + 1, (valueT) offset, 1);
5583}
5584
5585void
5586md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
5587 char *ptr;
5588 addressT from_addr, to_addr;
a38cf1db
AM		 5589 fragS *frag ATTRIBUTE_UNUSED;
5590 symbolS *to_symbol ATTRIBUTE_UNUSED;
252b5132 5591{
847f7ad4 5592 offsetT offset;
252b5132 5593
a38cf1db
AM		 5594 offset = to_addr - (from_addr + 5);
5595 md_number_to_chars (ptr, (valueT) 0xe9, 1);
5596 md_number_to_chars (ptr + 1, (valueT) offset, 4);
252b5132
RH		 5597}
5598\f
5599/* Apply a fixup (fixS) to segment data, once it has been determined
5600 by our caller that we have all the info we need to fix it up.
5601
5602 On the 386, immediates, displacements, and data pointers are all in
5603 the same (little-endian) format, so we don't need to care about which
5604 we are handling. */
5605
94f592af 5606void
55cf6793 5607md_apply_fix (fixP, valP, seg)
47926f60
KH		 5608 /* The fix we're to put in. */
5609 fixS *fixP;
47926f60 5610 /* Pointer to the value of the bits. */
c6682705 5611 valueT *valP;
47926f60
KH		 5612 /* Segment fix is from. */
5613 segT seg ATTRIBUTE_UNUSED;
252b5132 5614{
94f592af 5615 char *p = fixP->fx_where + fixP->fx_frag->fr_literal;
c6682705 5616 valueT value = *valP;
252b5132 5617
f86103b7 5618#if !defined (TE_Mach)
93382f6d
AM		 5619 if (fixP->fx_pcrel)
5620 {
5621 switch (fixP->fx_r_type)
5622 {
5865bb77
ILT		 5623 default:
5624 break;
5625
d6ab8113
JB		 5626 case BFD_RELOC_64:
5627 fixP->fx_r_type = BFD_RELOC_64_PCREL;
5628 break;
93382f6d 5629 case BFD_RELOC_32:
ae8887b5 5630 case BFD_RELOC_X86_64_32S:
93382f6d
AM		 5631 fixP->fx_r_type = BFD_RELOC_32_PCREL;
5632 break;
5633 case BFD_RELOC_16:
5634 fixP->fx_r_type = BFD_RELOC_16_PCREL;
5635 break;
5636 case BFD_RELOC_8:
5637 fixP->fx_r_type = BFD_RELOC_8_PCREL;
5638 break;
5639 }
5640 }
252b5132 5641
a161fe53 5642 if (fixP->fx_addsy != NULL
31312f95 5643 && (fixP->fx_r_type == BFD_RELOC_32_PCREL
d6ab8113 5644 || fixP->fx_r_type == BFD_RELOC_64_PCREL
31312f95
AM		 5645 || fixP->fx_r_type == BFD_RELOC_16_PCREL
5646 || fixP->fx_r_type == BFD_RELOC_8_PCREL)
5647 && !use_rela_relocations)
252b5132 5648 {
31312f95
AM		 5649 /* This is a hack. There should be a better way to handle this.
5650 This covers for the fact that bfd_install_relocation will
5651 subtract the current location (for partial_inplace, PC relative
5652 relocations); see more below. */
252b5132 5653#ifndef OBJ_AOUT
718ddfc0 5654 if (IS_ELF
252b5132
RH		 5655#ifdef TE_PE
5656 || OUTPUT_FLAVOR == bfd_target_coff_flavour
5657#endif
5658 )
5659 value += fixP->fx_where + fixP->fx_frag->fr_address;
5660#endif
5661#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
718ddfc0 5662 if (IS_ELF)
252b5132 5663 {
6539b54b 5664 segT sym_seg = S_GET_SEGMENT (fixP->fx_addsy);
2f66722d 5665
6539b54b 5666 if ((sym_seg == seg
2f66722d 5667 || (symbol_section_p (fixP->fx_addsy)
6539b54b 5668 && sym_seg != absolute_section))
ae6063d4 5669 && !generic_force_reloc (fixP))
2f66722d
AM		 5670 {
5671 /* Yes, we add the values in twice. This is because
6539b54b
AM		 5672 bfd_install_relocation subtracts them out again. I think
5673 bfd_install_relocation is broken, but I don't dare change
2f66722d
AM		 5674 it. FIXME. */
5675 value += fixP->fx_where + fixP->fx_frag->fr_address;
5676 }
252b5132
RH		 5677 }
5678#endif
5679#if defined (OBJ_COFF) && defined (TE_PE)
977cdf5a
NC		 5680 /* For some reason, the PE format does not store a
5681 section address offset for a PC relative symbol. */
5682 if (S_GET_SEGMENT (fixP->fx_addsy) != seg
7be1c489 5683 || S_IS_WEAK (fixP->fx_addsy))
252b5132
RH		 5684 value += md_pcrel_from (fixP);
5685#endif
5686 }
5687
5688 /* Fix a few things - the dynamic linker expects certain values here,
0234cb7c 5689 and we must not disappoint it. */
252b5132 5690#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
718ddfc0 5691 if (IS_ELF && fixP->fx_addsy)
47926f60
KH		 5692 switch (fixP->fx_r_type)
5693 {
5694 case BFD_RELOC_386_PLT32:
3e73aa7c 5695 case BFD_RELOC_X86_64_PLT32:
47926f60
KH		 5696 /* Make the jump instruction point to the address of the operand. At
5697 runtime we merely add the offset to the actual PLT entry. */
5698 value = -4;
5699 break;
31312f95 5700
13ae64f3
JJ		 5701 case BFD_RELOC_386_TLS_GD:
5702 case BFD_RELOC_386_TLS_LDM:
13ae64f3 5703 case BFD_RELOC_386_TLS_IE_32:
37e55690
JJ		 5704 case BFD_RELOC_386_TLS_IE:
5705 case BFD_RELOC_386_TLS_GOTIE:
67a4f2b7 5706 case BFD_RELOC_386_TLS_GOTDESC:
bffbf940
JJ		 5707 case BFD_RELOC_X86_64_TLSGD:
5708 case BFD_RELOC_X86_64_TLSLD:
5709 case BFD_RELOC_X86_64_GOTTPOFF:
67a4f2b7 5710 case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
00f7efb6
JJ		 5711 value = 0; /* Fully resolved at runtime. No addend. */
5712 /* Fallthrough */
5713 case BFD_RELOC_386_TLS_LE:
5714 case BFD_RELOC_386_TLS_LDO_32:
5715 case BFD_RELOC_386_TLS_LE_32:
5716 case BFD_RELOC_X86_64_DTPOFF32:
d6ab8113 5717 case BFD_RELOC_X86_64_DTPOFF64:
00f7efb6 5718 case BFD_RELOC_X86_64_TPOFF32:
d6ab8113 5719 case BFD_RELOC_X86_64_TPOFF64:
00f7efb6
JJ		 5720 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5721 break;
5722
67a4f2b7
AO		 5723 case BFD_RELOC_386_TLS_DESC_CALL:
5724 case BFD_RELOC_X86_64_TLSDESC_CALL:
5725 value = 0; /* Fully resolved at runtime. No addend. */
5726 S_SET_THREAD_LOCAL (fixP->fx_addsy);
5727 fixP->fx_done = 0;
5728 return;
5729
00f7efb6
JJ		 5730 case BFD_RELOC_386_GOT32:
5731 case BFD_RELOC_X86_64_GOT32:
47926f60
KH		 5732 value = 0; /* Fully resolved at runtime. No addend. */
5733 break;
47926f60
KH		 5734
5735 case BFD_RELOC_VTABLE_INHERIT:
5736 case BFD_RELOC_VTABLE_ENTRY:
5737 fixP->fx_done = 0;
94f592af 5738 return;
47926f60
KH		 5739
5740 default:
5741 break;
5742 }
5743#endif /* defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) */
c6682705 5744 *valP = value;
f86103b7 5745#endif /* !defined (TE_Mach) */
3e73aa7c 5746
3e73aa7c 5747 /* Are we finished with this relocation now? */
c6682705 5748 if (fixP->fx_addsy == NULL)
3e73aa7c
JH		 5749 fixP->fx_done = 1;
5750 else if (use_rela_relocations)
5751 {
5752 fixP->fx_no_overflow = 1;
062cd5e7
AS		 5753 /* Remember value for tc_gen_reloc. */
5754 fixP->fx_addnumber = value;
3e73aa7c
JH		 5755 value = 0;
5756 }
f86103b7 5757
94f592af 5758 md_number_to_chars (p, value, fixP->fx_size);
252b5132 5759}
252b5132 5760\f
252b5132
RH		 5761#define MAX_LITTLENUMS 6
5762
47926f60
KH		 5763/* Turn the string pointed to by litP into a floating point constant
5764 of type TYPE, and emit the appropriate bytes. The number of
5765 LITTLENUMS emitted is stored in *SIZEP. An error message is
5766 returned, or NULL on OK. */
5767
252b5132
RH		 5768char *
5769md_atof (type, litP, sizeP)
2ab9b79e 5770 int type;
252b5132
RH		 5771 char *litP;
5772 int *sizeP;
5773{
5774 int prec;
5775 LITTLENUM_TYPE words[MAX_LITTLENUMS];
5776 LITTLENUM_TYPE *wordP;
5777 char *t;
5778
5779 switch (type)
5780 {
5781 case 'f':
5782 case 'F':
5783 prec = 2;
5784 break;
5785
5786 case 'd':
5787 case 'D':
5788 prec = 4;
5789 break;
5790
5791 case 'x':
5792 case 'X':
5793 prec = 5;
5794 break;
5795
5796 default:
5797 *sizeP = 0;
5798 return _("Bad call to md_atof ()");
5799 }
5800 t = atof_ieee (input_line_pointer, type, words);
5801 if (t)
5802 input_line_pointer = t;
5803
5804 *sizeP = prec * sizeof (LITTLENUM_TYPE);
5805 /* This loops outputs the LITTLENUMs in REVERSE order; in accord with
5806 the bigendian 386. */
5807 for (wordP = words + prec - 1; prec--;)
5808 {
5809 md_number_to_chars (litP, (valueT) (*wordP--), sizeof (LITTLENUM_TYPE));
5810 litP += sizeof (LITTLENUM_TYPE);
5811 }
5812 return 0;
5813}
5814\f
2d545b82 5815static char output_invalid_buf[sizeof (unsigned char) * 2 + 6];
252b5132 5816
252b5132 5817static char *
e3bb37b5 5818output_invalid (int c)
252b5132 5819{
3882b010 5820 if (ISPRINT (c))
f9f21a03
L		 5821 snprintf (output_invalid_buf, sizeof (output_invalid_buf),
5822 "'%c'", c);
252b5132 5823 else
f9f21a03 5824 snprintf (output_invalid_buf, sizeof (output_invalid_buf),
2d545b82 5825 "(0x%x)", (unsigned char) c);
252b5132
RH		 5826 return output_invalid_buf;
5827}
5828
af6bdddf 5829/* REG_STRING starts *before* REGISTER_PREFIX. */
252b5132
RH		 5830
5831static const reg_entry *
4d1bb795 5832parse_real_register (char *reg_string, char **end_op)
252b5132 5833{
af6bdddf
AM		 5834 char *s = reg_string;
5835 char *p;
252b5132
RH		 5836 char reg_name_given[MAX_REG_NAME_SIZE + 1];
5837 const reg_entry *r;
5838
5839 /* Skip possible REGISTER_PREFIX and possible whitespace. */
5840 if (*s == REGISTER_PREFIX)
5841 ++s;
5842
5843 if (is_space_char (*s))
5844 ++s;
5845
5846 p = reg_name_given;
af6bdddf 5847 while ((*p++ = register_chars[(unsigned char) *s]) != '\0')
252b5132
RH		 5848 {
5849 if (p >= reg_name_given + MAX_REG_NAME_SIZE)
af6bdddf
AM		 5850 return (const reg_entry *) NULL;
5851 s++;
252b5132
RH		 5852 }
5853
6588847e
DN		 5854 /* For naked regs, make sure that we are not dealing with an identifier.
5855 This prevents confusing an identifier like `eax_var' with register
5856 `eax'. */
5857 if (allow_naked_reg && identifier_chars[(unsigned char) *s])
5858 return (const reg_entry *) NULL;
5859
af6bdddf 5860 *end_op = s;
252b5132
RH		 5861
5862 r = (const reg_entry *) hash_find (reg_hash, reg_name_given);
5863
5f47d35b 5864 /* Handle floating point regs, allowing spaces in the (i) part. */
47926f60 5865 if (r == i386_regtab /* %st is first entry of table */)
5f47d35b 5866 {
5f47d35b
AM		 5867 if (is_space_char (*s))
5868 ++s;
5869 if (*s == '(')
5870 {
af6bdddf 5871 ++s;
5f47d35b
AM		 5872 if (is_space_char (*s))
5873 ++s;
5874 if (*s >= '0' && *s <= '7')
5875 {
db557034 5876 int fpr = *s - '0';
af6bdddf 5877 ++s;
5f47d35b
AM		 5878 if (is_space_char (*s))
5879 ++s;
5880 if (*s == ')')
5881 {
5882 *end_op = s + 1;
db557034
AM		 5883 r = hash_find (reg_hash, "st(0)");
5884 know (r);
5885 return r + fpr;
5f47d35b 5886 }
5f47d35b 5887 }
47926f60 5888 /* We have "%st(" then garbage. */
5f47d35b
AM		 5889 return (const reg_entry *) NULL;
5890 }
5891 }
5892
1ae00879 5893 if (r != NULL
20f0a1fc 5894 && ((r->reg_flags & (RegRex64 | RegRex)) | (r->reg_type & Reg64)) != 0
c4a530c5 5895 && (r->reg_type != Control || !(cpu_arch_flags & CpuSledgehammer))
1ae00879 5896 && flag_code != CODE_64BIT)
20f0a1fc 5897 return (const reg_entry *) NULL;
1ae00879 5898
252b5132
RH		 5899 return r;
5900}
4d1bb795
JB		 5901
5902/* REG_STRING starts *before* REGISTER_PREFIX. */
5903
5904static const reg_entry *
5905parse_register (char *reg_string, char **end_op)
5906{
5907 const reg_entry *r;
5908
5909 if (*reg_string == REGISTER_PREFIX || allow_naked_reg)
5910 r = parse_real_register (reg_string, end_op);
5911 else
5912 r = NULL;
5913 if (!r)
5914 {
5915 char *save = input_line_pointer;
5916 char c;
5917 symbolS *symbolP;
5918
5919 input_line_pointer = reg_string;
5920 c = get_symbol_end ();
5921 symbolP = symbol_find (reg_string);
5922 if (symbolP && S_GET_SEGMENT (symbolP) == reg_section)
5923 {
5924 const expressionS *e = symbol_get_value_expression (symbolP);
5925
5926 know (e->X_op == O_register);
4eed87de 5927 know (e->X_add_number >= 0
c3fe08fa 5928 && (valueT) e->X_add_number < i386_regtab_size);
4d1bb795
JB		 5929 r = i386_regtab + e->X_add_number;
5930 *end_op = input_line_pointer;
5931 }
5932 *input_line_pointer = c;
5933 input_line_pointer = save;
5934 }
5935 return r;
5936}
5937
5938int
5939i386_parse_name (char *name, expressionS *e, char *nextcharP)
5940{
5941 const reg_entry *r;
5942 char *end = input_line_pointer;
5943
5944 *end = *nextcharP;
5945 r = parse_register (name, &input_line_pointer);
5946 if (r && end <= input_line_pointer)
5947 {
5948 *nextcharP = *input_line_pointer;
5949 *input_line_pointer = 0;
5950 e->X_op = O_register;
5951 e->X_add_number = r - i386_regtab;
5952 return 1;
5953 }
5954 input_line_pointer = end;
5955 *end = 0;
5956 return 0;
5957}
5958
5959void
5960md_operand (expressionS *e)
5961{
5962 if (*input_line_pointer == REGISTER_PREFIX)
5963 {
5964 char *end;
5965 const reg_entry *r = parse_real_register (input_line_pointer, &end);
5966
5967 if (r)
5968 {
5969 e->X_op = O_register;
5970 e->X_add_number = r - i386_regtab;
5971 input_line_pointer = end;
5972 }
5973 }
5974}
5975
252b5132 5976\f
4cc782b5 5977#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
12b55ccc 5978const char *md_shortopts = "kVQ:sqn";
252b5132 5979#else
12b55ccc 5980const char *md_shortopts = "qn";
252b5132 5981#endif
6e0b89ee 5982
3e73aa7c 5983#define OPTION_32 (OPTION_MD_BASE + 0)
b3b91714
AM		 5984#define OPTION_64 (OPTION_MD_BASE + 1)
5985#define OPTION_DIVIDE (OPTION_MD_BASE + 2)
9103f4f4
L		 5986#define OPTION_MARCH (OPTION_MD_BASE + 3)
5987#define OPTION_MTUNE (OPTION_MD_BASE + 4)
b3b91714 5988
99ad8390
NC		 5989struct option md_longopts[] =
5990{
3e73aa7c 5991 {"32", no_argument, NULL, OPTION_32},
99ad8390 5992#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined(TE_PEP)
3e73aa7c 5993 {"64", no_argument, NULL, OPTION_64},
6e0b89ee 5994#endif
b3b91714 5995 {"divide", no_argument, NULL, OPTION_DIVIDE},
9103f4f4
L		 5996 {"march", required_argument, NULL, OPTION_MARCH},
5997 {"mtune", required_argument, NULL, OPTION_MTUNE},
252b5132
RH		 5998 {NULL, no_argument, NULL, 0}
5999};
6000size_t md_longopts_size = sizeof (md_longopts);
6001
6002int
9103f4f4 6003md_parse_option (int c, char *arg)
252b5132 6004{
9103f4f4
L		 6005 unsigned int i;
6006
252b5132
RH		 6007 switch (c)
6008 {
12b55ccc
L		 6009 case 'n':
6010 optimize_align_code = 0;
6011 break;
6012
a38cf1db
AM		 6013 case 'q':
6014 quiet_warnings = 1;
252b5132
RH		 6015 break;
6016
6017#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
a38cf1db
AM		 6018 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
6019 should be emitted or not. FIXME: Not implemented. */
6020 case 'Q':
252b5132
RH		 6021 break;
6022
6023 /* -V: SVR4 argument to print version ID. */
6024 case 'V':
6025 print_version_id ();
6026 break;
6027
a38cf1db
AM		 6028 /* -k: Ignore for FreeBSD compatibility. */
6029 case 'k':
252b5132 6030 break;
4cc782b5
ILT		 6031
6032 case 's':
6033 /* -s: On i386 Solaris, this tells the native assembler to use
29b0f896 6034 .stab instead of .stab.excl. We always use .stab anyhow. */
4cc782b5 6035 break;
99ad8390
NC		 6036#endif
6037#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined(TE_PEP)
3e73aa7c
JH		 6038 case OPTION_64:
6039 {
6040 const char **list, **l;
6041
3e73aa7c
JH		 6042 list = bfd_target_list ();
6043 for (l = list; *l != NULL; l++)
8620418b 6044 if (CONST_STRNEQ (*l, "elf64-x86-64")
99ad8390
NC		 6045 || strcmp (*l, "coff-x86-64") == 0
6046 || strcmp (*l, "pe-x86-64") == 0
6047 || strcmp (*l, "pei-x86-64") == 0)
6e0b89ee
AM		 6048 {
6049 default_arch = "x86_64";
6050 break;
6051 }
3e73aa7c 6052 if (*l == NULL)
6e0b89ee 6053 as_fatal (_("No compiled in support for x86_64"));
3e73aa7c
JH		 6054 free (list);
6055 }
6056 break;
6057#endif
252b5132 6058
6e0b89ee
AM		 6059 case OPTION_32:
6060 default_arch = "i386";
6061 break;
6062
b3b91714
AM		 6063 case OPTION_DIVIDE:
6064#ifdef SVR4_COMMENT_CHARS
6065 {
6066 char *n, *t;
6067 const char *s;
6068
6069 n = (char *) xmalloc (strlen (i386_comment_chars) + 1);
6070 t = n;
6071 for (s = i386_comment_chars; *s != '\0'; s++)
6072 if (*s != '/')
6073 *t++ = *s;
6074 *t = '\0';
6075 i386_comment_chars = n;
6076 }
6077#endif
6078 break;
6079
9103f4f4
L		 6080 case OPTION_MARCH:
6081 if (*arg == '.')
6082 as_fatal (_("Invalid -march= option: `%s'"), arg);
6083 for (i = 0; i < ARRAY_SIZE (cpu_arch); i++)
6084 {
6085 if (strcmp (arg, cpu_arch [i].name) == 0)
6086 {
ccc9c027 6087 cpu_arch_isa = cpu_arch[i].type;
9103f4f4 6088 cpu_arch_isa_flags = cpu_arch[i].flags;
ccc9c027
L		 6089 if (!cpu_arch_tune_set)
6090 {
6091 cpu_arch_tune = cpu_arch_isa;
6092 cpu_arch_tune_flags = cpu_arch_isa_flags;
6093 }
9103f4f4
L		 6094 break;
6095 }
6096 }
6097 if (i >= ARRAY_SIZE (cpu_arch))
6098 as_fatal (_("Invalid -march= option: `%s'"), arg);
6099 break;
6100
6101 case OPTION_MTUNE:
6102 if (*arg == '.')
6103 as_fatal (_("Invalid -mtune= option: `%s'"), arg);
6104 for (i = 0; i < ARRAY_SIZE (cpu_arch); i++)
6105 {
6106 if (strcmp (arg, cpu_arch [i].name) == 0)
6107 {
ccc9c027 6108 cpu_arch_tune_set = 1;
9103f4f4
L		 6109 cpu_arch_tune = cpu_arch [i].type;
6110 cpu_arch_tune_flags = cpu_arch[i].flags;
6111 break;
6112 }
6113 }
6114 if (i >= ARRAY_SIZE (cpu_arch))
6115 as_fatal (_("Invalid -mtune= option: `%s'"), arg);
6116 break;
6117
252b5132
RH		 6118 default:
6119 return 0;
6120 }
6121 return 1;
6122}
6123
6124void
6125md_show_usage (stream)
6126 FILE *stream;
6127{
4cc782b5
ILT		 6128#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
6129 fprintf (stream, _("\
a38cf1db
AM		 6130 -Q ignored\n\
6131 -V print assembler version number\n\
b3b91714
AM		 6132 -k ignored\n"));
6133#endif
6134 fprintf (stream, _("\
12b55ccc 6135 -n Do not optimize code alignment\n\
b3b91714
AM		 6136 -q quieten some warnings\n"));
6137#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
6138 fprintf (stream, _("\
a38cf1db 6139 -s ignored\n"));
b3b91714 6140#endif
751d281c
L		 6141#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined(TE_PEP)
6142 fprintf (stream, _("\
6143 --32/--64 generate 32bit/64bit code\n"));
6144#endif
b3b91714
AM		 6145#ifdef SVR4_COMMENT_CHARS
6146 fprintf (stream, _("\
6147 --divide do not treat `/' as a comment character\n"));
a38cf1db
AM		 6148#else
6149 fprintf (stream, _("\
b3b91714 6150 --divide ignored\n"));
4cc782b5 6151#endif
9103f4f4
L		 6152 fprintf (stream, _("\
6153 -march=CPU/-mtune=CPU generate code/optimize for CPU, where CPU is one of:\n\
6154 i386, i486, pentium, pentiumpro, pentium4, nocona,\n\
4eed87de 6155 core, core2, k6, athlon, k8, generic32, generic64\n"));
9103f4f4 6156
252b5132
RH		 6157}
6158
3e73aa7c 6159#if ((defined (OBJ_MAYBE_COFF) && defined (OBJ_MAYBE_AOUT)) \
872ce6ff 6160 || defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF) || defined (TE_PEP))
252b5132
RH		 6161
6162/* Pick the target format to use. */
6163
47926f60 6164const char *
e3bb37b5 6165i386_target_format (void)
252b5132 6166{
3e73aa7c 6167 if (!strcmp (default_arch, "x86_64"))
9103f4f4
L		 6168 {
6169 set_code_flag (CODE_64BIT);
6170 if (cpu_arch_isa_flags == 0)
d32cad65 6171 cpu_arch_isa_flags = Cpu186|Cpu286|Cpu386|Cpu486
9103f4f4
L		 6172 |Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2
6173 |CpuSSE|CpuSSE2;
ccc9c027 6174 if (cpu_arch_tune_flags == 0)
d32cad65 6175 cpu_arch_tune_flags = Cpu186|Cpu286|Cpu386|Cpu486
ccc9c027
L		 6176 |Cpu586|Cpu686|CpuP4|CpuMMX|CpuMMX2
6177 |CpuSSE|CpuSSE2;
9103f4f4 6178 }
3e73aa7c 6179 else if (!strcmp (default_arch, "i386"))
9103f4f4
L		 6180 {
6181 set_code_flag (CODE_32BIT);
6182 if (cpu_arch_isa_flags == 0)
d32cad65 6183 cpu_arch_isa_flags = Cpu186|Cpu286|Cpu386;
ccc9c027 6184 if (cpu_arch_tune_flags == 0)
d32cad65 6185 cpu_arch_tune_flags = Cpu186|Cpu286|Cpu386;
9103f4f4 6186 }
3e73aa7c
JH		 6187 else
6188 as_fatal (_("Unknown architecture"));
252b5132
RH		 6189 switch (OUTPUT_FLAVOR)
6190 {
872ce6ff
L		 6191#ifdef TE_PEP
6192 case bfd_target_coff_flavour:
6193 return flag_code == CODE_64BIT ? COFF_TARGET_FORMAT : "coff-i386";
6194 break;
6195#endif
4c63da97
AM		 6196#ifdef OBJ_MAYBE_AOUT
6197 case bfd_target_aout_flavour:
47926f60 6198 return AOUT_TARGET_FORMAT;
4c63da97
AM		 6199#endif
6200#ifdef OBJ_MAYBE_COFF
252b5132
RH		 6201 case bfd_target_coff_flavour:
6202 return "coff-i386";
4c63da97 6203#endif
3e73aa7c 6204#if defined (OBJ_MAYBE_ELF) || defined (OBJ_ELF)
252b5132 6205 case bfd_target_elf_flavour:
3e73aa7c 6206 {
e5cb08ac 6207 if (flag_code == CODE_64BIT)
4fa24527
JB		 6208 {
6209 object_64bit = 1;
6210 use_rela_relocations = 1;
6211 }
9d7cbccd 6212 return flag_code == CODE_64BIT ? ELF_TARGET_FORMAT64 : ELF_TARGET_FORMAT;
3e73aa7c 6213 }
4c63da97 6214#endif
252b5132
RH		 6215 default:
6216 abort ();
6217 return NULL;
6218 }
6219}
6220
47926f60 6221#endif /* OBJ_MAYBE_ more than one */
a847613f
AM		 6222
6223#if (defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF))
e3bb37b5
L		 6224void
6225i386_elf_emit_arch_note (void)
a847613f 6226{
718ddfc0 6227 if (IS_ELF && cpu_arch_name != NULL)
a847613f
AM		 6228 {
6229 char *p;
6230 asection *seg = now_seg;
6231 subsegT subseg = now_subseg;
6232 Elf_Internal_Note i_note;
6233 Elf_External_Note e_note;
6234 asection *note_secp;
6235 int len;
6236
6237 /* Create the .note section. */
6238 note_secp = subseg_new (".note", 0);
6239 bfd_set_section_flags (stdoutput,
6240 note_secp,
6241 SEC_HAS_CONTENTS | SEC_READONLY);
6242
6243 /* Process the arch string. */
6244 len = strlen (cpu_arch_name);
6245
6246 i_note.namesz = len + 1;
6247 i_note.descsz = 0;
6248 i_note.type = NT_ARCH;
6249 p = frag_more (sizeof (e_note.namesz));
6250 md_number_to_chars (p, (valueT) i_note.namesz, sizeof (e_note.namesz));
6251 p = frag_more (sizeof (e_note.descsz));
6252 md_number_to_chars (p, (valueT) i_note.descsz, sizeof (e_note.descsz));
6253 p = frag_more (sizeof (e_note.type));
6254 md_number_to_chars (p, (valueT) i_note.type, sizeof (e_note.type));
6255 p = frag_more (len + 1);
6256 strcpy (p, cpu_arch_name);
6257
6258 frag_align (2, 0, 0);
6259
6260 subseg_set (seg, subseg);
6261 }
6262}
6263#endif
252b5132 6264\f
252b5132
RH		 6265symbolS *
6266md_undefined_symbol (name)
6267 char *name;
6268{
18dc2407
ILT		 6269 if (name[0] == GLOBAL_OFFSET_TABLE_NAME[0]
6270 && name[1] == GLOBAL_OFFSET_TABLE_NAME[1]
6271 && name[2] == GLOBAL_OFFSET_TABLE_NAME[2]
6272 && strcmp (name, GLOBAL_OFFSET_TABLE_NAME) == 0)
24eab124
AM		 6273 {
6274 if (!GOT_symbol)
6275 {
6276 if (symbol_find (name))
6277 as_bad (_("GOT already in symbol table"));
6278 GOT_symbol = symbol_new (name, undefined_section,
6279 (valueT) 0, &zero_address_frag);
6280 };
6281 return GOT_symbol;
6282 }
252b5132
RH		 6283 return 0;
6284}
6285
6286/* Round up a section size to the appropriate boundary. */
47926f60 6287
252b5132
RH		 6288valueT
6289md_section_align (segment, size)
ab9da554 6290 segT segment ATTRIBUTE_UNUSED;
252b5132
RH		 6291 valueT size;
6292{
4c63da97
AM		 6293#if (defined (OBJ_AOUT) || defined (OBJ_MAYBE_AOUT))
6294 if (OUTPUT_FLAVOR == bfd_target_aout_flavour)
6295 {
6296 /* For a.out, force the section size to be aligned. If we don't do
6297 this, BFD will align it for us, but it will not write out the
6298 final bytes of the section. This may be a bug in BFD, but it is
6299 easier to fix it here since that is how the other a.out targets
6300 work. */
6301 int align;
6302
6303 align = bfd_get_section_alignment (stdoutput, segment);
6304 size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
6305 }
252b5132
RH		 6306#endif
6307
6308 return size;
6309}
6310
6311/* On the i386, PC-relative offsets are relative to the start of the
6312 next instruction. That is, the address of the offset, plus its
6313 size, since the offset is always the last part of the insn. */
6314
6315long
e3bb37b5 6316md_pcrel_from (fixS *fixP)
252b5132
RH		 6317{
6318 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
6319}
6320
6321#ifndef I386COFF
6322
6323static void
e3bb37b5 6324s_bss (int ignore ATTRIBUTE_UNUSED)
252b5132 6325{
29b0f896 6326 int temp;
252b5132 6327
8a75718c
JB		 6328#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
6329 if (IS_ELF)
6330 obj_elf_section_change_hook ();
6331#endif
252b5132
RH		 6332 temp = get_absolute_expression ();
6333 subseg_set (bss_section, (subsegT) temp);
6334 demand_empty_rest_of_line ();
6335}
6336
6337#endif
6338
252b5132 6339void
e3bb37b5 6340i386_validate_fix (fixS *fixp)
252b5132
RH		 6341{
6342 if (fixp->fx_subsy && fixp->fx_subsy == GOT_symbol)
6343 {
23df1078
JH		 6344 if (fixp->fx_r_type == BFD_RELOC_32_PCREL)
6345 {
4fa24527 6346 if (!object_64bit)
23df1078
JH		 6347 abort ();
6348 fixp->fx_r_type = BFD_RELOC_X86_64_GOTPCREL;
6349 }
6350 else
6351 {
4fa24527 6352 if (!object_64bit)
d6ab8113
JB		 6353 fixp->fx_r_type = BFD_RELOC_386_GOTOFF;
6354 else
6355 fixp->fx_r_type = BFD_RELOC_X86_64_GOTOFF64;
23df1078 6356 }
252b5132
RH		 6357 fixp->fx_subsy = 0;
6358 }
6359}
6360
252b5132
RH		 6361arelent *
6362tc_gen_reloc (section, fixp)
ab9da554 6363 asection *section ATTRIBUTE_UNUSED;
252b5132
RH		 6364 fixS *fixp;
6365{
6366 arelent *rel;
6367 bfd_reloc_code_real_type code;
6368
6369 switch (fixp->fx_r_type)
6370 {
3e73aa7c
JH		 6371 case BFD_RELOC_X86_64_PLT32:
6372 case BFD_RELOC_X86_64_GOT32:
6373 case BFD_RELOC_X86_64_GOTPCREL:
252b5132
RH		 6374 case BFD_RELOC_386_PLT32:
6375 case BFD_RELOC_386_GOT32:
6376 case BFD_RELOC_386_GOTOFF:
6377 case BFD_RELOC_386_GOTPC:
13ae64f3
JJ		 6378 case BFD_RELOC_386_TLS_GD:
6379 case BFD_RELOC_386_TLS_LDM:
6380 case BFD_RELOC_386_TLS_LDO_32:
6381 case BFD_RELOC_386_TLS_IE_32:
37e55690
JJ		 6382 case BFD_RELOC_386_TLS_IE:
6383 case BFD_RELOC_386_TLS_GOTIE:
13ae64f3
JJ		 6384 case BFD_RELOC_386_TLS_LE_32:
6385 case BFD_RELOC_386_TLS_LE:
67a4f2b7
AO		 6386 case BFD_RELOC_386_TLS_GOTDESC:
6387 case BFD_RELOC_386_TLS_DESC_CALL:
bffbf940
JJ		 6388 case BFD_RELOC_X86_64_TLSGD:
6389 case BFD_RELOC_X86_64_TLSLD:
6390 case BFD_RELOC_X86_64_DTPOFF32:
d6ab8113 6391 case BFD_RELOC_X86_64_DTPOFF64:
bffbf940
JJ		 6392 case BFD_RELOC_X86_64_GOTTPOFF:
6393 case BFD_RELOC_X86_64_TPOFF32:
d6ab8113
JB		 6394 case BFD_RELOC_X86_64_TPOFF64:
6395 case BFD_RELOC_X86_64_GOTOFF64:
6396 case BFD_RELOC_X86_64_GOTPC32:
7b81dfbb
AJ		 6397 case BFD_RELOC_X86_64_GOT64:
6398 case BFD_RELOC_X86_64_GOTPCREL64:
6399 case BFD_RELOC_X86_64_GOTPC64:
6400 case BFD_RELOC_X86_64_GOTPLT64:
6401 case BFD_RELOC_X86_64_PLTOFF64:
67a4f2b7
AO		 6402 case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
6403 case BFD_RELOC_X86_64_TLSDESC_CALL:
252b5132
RH		 6404 case BFD_RELOC_RVA:
6405 case BFD_RELOC_VTABLE_ENTRY:
6406 case BFD_RELOC_VTABLE_INHERIT:
6482c264
NC		 6407#ifdef TE_PE
6408 case BFD_RELOC_32_SECREL:
6409#endif
252b5132
RH		 6410 code = fixp->fx_r_type;
6411 break;
dbbaec26
L		 6412 case BFD_RELOC_X86_64_32S:
6413 if (!fixp->fx_pcrel)
6414 {
6415 /* Don't turn BFD_RELOC_X86_64_32S into BFD_RELOC_32. */
6416 code = fixp->fx_r_type;
6417 break;
6418 }
252b5132 6419 default:
93382f6d 6420 if (fixp->fx_pcrel)
252b5132 6421 {
93382f6d
AM		 6422 switch (fixp->fx_size)
6423 {
6424 default:
b091f402
AM		 6425 as_bad_where (fixp->fx_file, fixp->fx_line,
6426 _("can not do %d byte pc-relative relocation"),
6427 fixp->fx_size);
93382f6d
AM		 6428 code = BFD_RELOC_32_PCREL;
6429 break;
6430 case 1: code = BFD_RELOC_8_PCREL; break;
6431 case 2: code = BFD_RELOC_16_PCREL; break;
6432 case 4: code = BFD_RELOC_32_PCREL; break;
d6ab8113
JB		 6433#ifdef BFD64
6434 case 8: code = BFD_RELOC_64_PCREL; break;
6435#endif
93382f6d
AM		 6436 }
6437 }
6438 else
6439 {
6440 switch (fixp->fx_size)
6441 {
6442 default:
b091f402
AM		 6443 as_bad_where (fixp->fx_file, fixp->fx_line,
6444 _("can not do %d byte relocation"),
6445 fixp->fx_size);
93382f6d
AM		 6446 code = BFD_RELOC_32;
6447 break;
6448 case 1: code = BFD_RELOC_8; break;
6449 case 2: code = BFD_RELOC_16; break;
6450 case 4: code = BFD_RELOC_32; break;
937149dd 6451#ifdef BFD64
3e73aa7c 6452 case 8: code = BFD_RELOC_64; break;
937149dd 6453#endif
93382f6d 6454 }
252b5132
RH		 6455 }
6456 break;
6457 }
252b5132 6458
d182319b
JB		 6459 if ((code == BFD_RELOC_32
6460 || code == BFD_RELOC_32_PCREL
6461 || code == BFD_RELOC_X86_64_32S)
252b5132
RH		 6462 && GOT_symbol
6463 && fixp->fx_addsy == GOT_symbol)
3e73aa7c 6464 {
4fa24527 6465 if (!object_64bit)
d6ab8113
JB		 6466 code = BFD_RELOC_386_GOTPC;
6467 else
6468 code = BFD_RELOC_X86_64_GOTPC32;
3e73aa7c 6469 }
7b81dfbb
AJ		 6470 if ((code == BFD_RELOC_64 || code == BFD_RELOC_64_PCREL)
6471 && GOT_symbol
6472 && fixp->fx_addsy == GOT_symbol)
6473 {
6474 code = BFD_RELOC_X86_64_GOTPC64;
6475 }
252b5132
RH		 6476
6477 rel = (arelent *) xmalloc (sizeof (arelent));
49309057
ILT		 6478 rel->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6479 *rel->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
252b5132
RH		 6480
6481 rel->address = fixp->fx_frag->fr_address + fixp->fx_where;
c87db184 6482
3e73aa7c
JH		 6483 if (!use_rela_relocations)
6484 {
6485 /* HACK: Since i386 ELF uses Rel instead of Rela, encode the
6486 vtable entry to be used in the relocation's section offset. */
6487 if (fixp->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
6488 rel->address = fixp->fx_offset;
252b5132 6489
c6682705 6490 rel->addend = 0;
3e73aa7c
JH		 6491 }
6492 /* Use the rela in 64bit mode. */
252b5132 6493 else
3e73aa7c 6494 {
062cd5e7
AS		 6495 if (!fixp->fx_pcrel)
6496 rel->addend = fixp->fx_offset;
6497 else
6498 switch (code)
6499 {
6500 case BFD_RELOC_X86_64_PLT32:
6501 case BFD_RELOC_X86_64_GOT32:
6502 case BFD_RELOC_X86_64_GOTPCREL:
bffbf940
JJ		 6503 case BFD_RELOC_X86_64_TLSGD:
6504 case BFD_RELOC_X86_64_TLSLD:
6505 case BFD_RELOC_X86_64_GOTTPOFF:
67a4f2b7
AO		 6506 case BFD_RELOC_X86_64_GOTPC32_TLSDESC:
6507 case BFD_RELOC_X86_64_TLSDESC_CALL:
062cd5e7
AS		 6508 rel->addend = fixp->fx_offset - fixp->fx_size;
6509 break;
6510 default:
6511 rel->addend = (section->vma
6512 - fixp->fx_size
6513 + fixp->fx_addnumber
6514 + md_pcrel_from (fixp));
6515 break;
6516 }
3e73aa7c
JH		 6517 }
6518
252b5132
RH		 6519 rel->howto = bfd_reloc_type_lookup (stdoutput, code);
6520 if (rel->howto == NULL)
6521 {
6522 as_bad_where (fixp->fx_file, fixp->fx_line,
d0b47220 6523 _("cannot represent relocation type %s"),
252b5132
RH		 6524 bfd_get_reloc_code_name (code));
6525 /* Set howto to a garbage value so that we can keep going. */
6526 rel->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_32);
6527 assert (rel->howto != NULL);
6528 }
6529
6530 return rel;
6531}
6532
64a0c779
DN		 6533\f
6534/* Parse operands using Intel syntax. This implements a recursive descent
6535 parser based on the BNF grammar published in Appendix B of the MASM 6.1
6536 Programmer's Guide.
6537
6538 FIXME: We do not recognize the full operand grammar defined in the MASM
6539 documentation. In particular, all the structure/union and
6540 high-level macro operands are missing.
6541
6542 Uppercase words are terminals, lower case words are non-terminals.
6543 Objects surrounded by double brackets '[[' ']]' are optional. Vertical
6544 bars '|' denote choices. Most grammar productions are implemented in
6545 functions called 'intel_<production>'.
6546
6547 Initial production is 'expr'.
6548
9306ca4a 6549 addOp + | -
64a0c779
DN		 6550
6551 alpha [a-zA-Z]
6552
9306ca4a
JB		 6553 binOp & | AND | \| | OR | ^ | XOR
6554
64a0c779
DN		 6555 byteRegister AL | AH | BL | BH | CL | CH | DL | DH
6556
6557 constant digits [[ radixOverride ]]
6558
9306ca4a 6559 dataType BYTE | WORD | DWORD | FWORD | QWORD | TBYTE | OWORD | XMMWORD
64a0c779
DN		 6560
6561 digits decdigit
b77a7acd
AJ		 6562 | digits decdigit
6563 | digits hexdigit
64a0c779
DN		 6564
6565 decdigit [0-9]
6566
9306ca4a
JB		 6567 e04 e04 addOp e05
6568 | e05
6569
6570 e05 e05 binOp e06
b77a7acd 6571 | e06
64a0c779
DN		 6572
6573 e06 e06 mulOp e09
b77a7acd 6574 | e09
64a0c779
DN		 6575
6576 e09 OFFSET e10
a724f0f4
JB		 6577 | SHORT e10
6578 | + e10
6579 | - e10
9306ca4a
JB		 6580 | ~ e10
6581 | NOT e10
64a0c779
DN		 6582 | e09 PTR e10
6583 | e09 : e10
6584 | e10
6585
6586 e10 e10 [ expr ]
b77a7acd 6587 | e11
64a0c779
DN		 6588
6589 e11 ( expr )
b77a7acd 6590 | [ expr ]
64a0c779
DN		 6591 | constant
6592 | dataType
6593 | id
6594 | $
6595 | register
6596
a724f0f4 6597 => expr expr cmpOp e04
9306ca4a 6598 | e04
64a0c779
DN		 6599
6600 gpRegister AX | EAX | BX | EBX | CX | ECX | DX | EDX
b77a7acd 6601 | BP | EBP | SP | ESP | DI | EDI | SI | ESI
64a0c779
DN		 6602
6603 hexdigit a | b | c | d | e | f
b77a7acd 6604 | A | B | C | D | E | F
64a0c779
DN		 6605
6606 id alpha
b77a7acd 6607 | id alpha
64a0c779
DN		 6608 | id decdigit
6609
9306ca4a 6610 mulOp * | / | % | MOD | << | SHL | >> | SHR
64a0c779
DN		 6611
6612 quote " | '
6613
6614 register specialRegister
b77a7acd 6615 | gpRegister
64a0c779
DN		 6616 | byteRegister
6617
6618 segmentRegister CS | DS | ES | FS | GS | SS
6619
9306ca4a 6620 specialRegister CR0 | CR2 | CR3 | CR4
b77a7acd 6621 | DR0 | DR1 | DR2 | DR3 | DR6 | DR7
64a0c779
DN		 6622 | TR3 | TR4 | TR5 | TR6 | TR7
6623
64a0c779
DN		 6624 We simplify the grammar in obvious places (e.g., register parsing is
6625 done by calling parse_register) and eliminate immediate left recursion
6626 to implement a recursive-descent parser.
6627
a724f0f4
JB		 6628 expr e04 expr'
6629
6630 expr' cmpOp e04 expr'
6631 | Empty
9306ca4a
JB		 6632
6633 e04 e05 e04'
6634
6635 e04' addOp e05 e04'
6636 | Empty
64a0c779
DN		 6637
6638 e05 e06 e05'
6639
9306ca4a 6640 e05' binOp e06 e05'
b77a7acd 6641 | Empty
64a0c779
DN		 6642
6643 e06 e09 e06'
6644
6645 e06' mulOp e09 e06'
b77a7acd 6646 | Empty
64a0c779
DN		 6647
6648 e09 OFFSET e10 e09'
a724f0f4
JB		 6649 | SHORT e10'
6650 | + e10'
6651 | - e10'
6652 | ~ e10'
6653 | NOT e10'
b77a7acd 6654 | e10 e09'
64a0c779
DN		 6655
6656 e09' PTR e10 e09'
b77a7acd 6657 | : e10 e09'
64a0c779
DN		 6658 | Empty
6659
6660 e10 e11 e10'
6661
6662 e10' [ expr ] e10'
b77a7acd 6663 | Empty
64a0c779
DN		 6664
6665 e11 ( expr )
b77a7acd 6666 | [ expr ]
64a0c779
DN		 6667 | BYTE
6668 | WORD
6669 | DWORD
9306ca4a 6670 | FWORD
64a0c779 6671 | QWORD
9306ca4a
JB		 6672 | TBYTE
6673 | OWORD
6674 | XMMWORD
64a0c779
DN		 6675 | .
6676 | $
6677 | register
6678 | id
6679 | constant */
6680
6681/* Parsing structure for the intel syntax parser. Used to implement the
6682 semantic actions for the operand grammar. */
6683struct intel_parser_s
6684 {
6685 char *op_string; /* The string being parsed. */
6686 int got_a_float; /* Whether the operand is a float. */
4a1805b1 6687 int op_modifier; /* Operand modifier. */
64a0c779 6688 int is_mem; /* 1 if operand is memory reference. */
4eed87de
AM		 6689 int in_offset; /* >=1 if parsing operand of offset. */
6690 int in_bracket; /* >=1 if parsing operand in brackets. */
64a0c779
DN		 6691 const reg_entry *reg; /* Last register reference found. */
6692 char *disp; /* Displacement string being built. */
a724f0f4 6693 char *next_operand; /* Resume point when splitting operands. */
64a0c779
DN		 6694 };
6695
6696static struct intel_parser_s intel_parser;
6697
6698/* Token structure for parsing intel syntax. */
6699struct intel_token
6700 {
6701 int code; /* Token code. */
6702 const reg_entry *reg; /* Register entry for register tokens. */
6703 char *str; /* String representation. */
6704 };
6705
6706static struct intel_token cur_token, prev_token;
6707
50705ef4
AM		 6708/* Token codes for the intel parser. Since T_SHORT is already used
6709 by COFF, undefine it first to prevent a warning. */
64a0c779
DN		 6710#define T_NIL -1
6711#define T_CONST 1
6712#define T_REG 2
6713#define T_BYTE 3
6714#define T_WORD 4
9306ca4a
JB		 6715#define T_DWORD 5
6716#define T_FWORD 6
6717#define T_QWORD 7
6718#define T_TBYTE 8
6719#define T_XMMWORD 9
50705ef4 6720#undef T_SHORT
9306ca4a
JB		 6721#define T_SHORT 10
6722#define T_OFFSET 11
6723#define T_PTR 12
6724#define T_ID 13
6725#define T_SHL 14
6726#define T_SHR 15
64a0c779
DN		 6727
6728/* Prototypes for intel parser functions. */
e3bb37b5
L		 6729static int intel_match_token (int);
6730static void intel_putback_token (void);
6731static void intel_get_token (void);
6732static int intel_expr (void);
6733static int intel_e04 (void);
6734static int intel_e05 (void);
6735static int intel_e06 (void);
6736static int intel_e09 (void);
6737static int intel_e10 (void);
6738static int intel_e11 (void);
64a0c779 6739
64a0c779 6740static int
e3bb37b5 6741i386_intel_operand (char *operand_string, int got_a_float)
64a0c779
DN		 6742{
6743 int ret;
6744 char *p;
6745
a724f0f4
JB		 6746 p = intel_parser.op_string = xstrdup (operand_string);
6747 intel_parser.disp = (char *) xmalloc (strlen (operand_string) + 1);
6748
6749 for (;;)
64a0c779 6750 {
a724f0f4
JB		 6751 /* Initialize token holders. */
6752 cur_token.code = prev_token.code = T_NIL;
6753 cur_token.reg = prev_token.reg = NULL;
6754 cur_token.str = prev_token.str = NULL;
6755
6756 /* Initialize parser structure. */
6757 intel_parser.got_a_float = got_a_float;
6758 intel_parser.op_modifier = 0;
6759 intel_parser.is_mem = 0;
6760 intel_parser.in_offset = 0;
6761 intel_parser.in_bracket = 0;
6762 intel_parser.reg = NULL;
6763 intel_parser.disp[0] = '\0';
6764 intel_parser.next_operand = NULL;
6765
6766 /* Read the first token and start the parser. */
6767 intel_get_token ();
6768 ret = intel_expr ();
6769
6770 if (!ret)
6771 break;
6772
9306ca4a
JB		 6773 if (cur_token.code != T_NIL)
6774 {
6775 as_bad (_("invalid operand for '%s' ('%s' unexpected)"),
6776 current_templates->start->name, cur_token.str);
6777 ret = 0;
6778 }
64a0c779
DN		 6779 /* If we found a memory reference, hand it over to i386_displacement
6780 to fill in the rest of the operand fields. */
9306ca4a 6781 else if (intel_parser.is_mem)
64a0c779
DN		 6782 {
6783 if ((i.mem_operands == 1
6784 && (current_templates->start->opcode_modifier & IsString) == 0)
6785 || i.mem_operands == 2)
6786 {
6787 as_bad (_("too many memory references for '%s'"),
6788 current_templates->start->name);
6789 ret = 0;
6790 }
6791 else
6792 {
6793 char *s = intel_parser.disp;
6794 i.mem_operands++;
6795
a724f0f4
JB		 6796 if (!quiet_warnings && intel_parser.is_mem < 0)
6797 /* See the comments in intel_bracket_expr. */
6798 as_warn (_("Treating `%s' as memory reference"), operand_string);
6799
64a0c779
DN		 6800 /* Add the displacement expression. */
6801 if (*s != '\0')
a4622f40
AM		 6802 ret = i386_displacement (s, s + strlen (s));
6803 if (ret)
a724f0f4
JB		 6804 {
6805 /* Swap base and index in 16-bit memory operands like
6806 [si+bx]. Since i386_index_check is also used in AT&T
6807 mode we have to do that here. */
6808 if (i.base_reg
6809 && i.index_reg
6810 && (i.base_reg->reg_type & Reg16)
6811 && (i.index_reg->reg_type & Reg16)
6812 && i.base_reg->reg_num >= 6
6813 && i.index_reg->reg_num < 6)
6814 {
6815 const reg_entry *base = i.index_reg;
6816
6817 i.index_reg = i.base_reg;
6818 i.base_reg = base;
6819 }
6820 ret = i386_index_check (operand_string);
6821 }
64a0c779
DN		 6822 }
6823 }
6824
6825 /* Constant and OFFSET expressions are handled by i386_immediate. */
a724f0f4 6826 else if ((intel_parser.op_modifier & (1 << T_OFFSET))
64a0c779
DN		 6827 || intel_parser.reg == NULL)
6828 ret = i386_immediate (intel_parser.disp);
a724f0f4
JB		 6829
6830 if (intel_parser.next_operand && this_operand >= MAX_OPERANDS - 1)
4eed87de 6831 ret = 0;
a724f0f4
JB		 6832 if (!ret || !intel_parser.next_operand)
6833 break;
6834 intel_parser.op_string = intel_parser.next_operand;
6835 this_operand = i.operands++;
64a0c779
DN		 6836 }
6837
6838 free (p);
6839 free (intel_parser.disp);
6840
6841 return ret;
6842}
6843
a724f0f4
JB		 6844#define NUM_ADDRESS_REGS (!!i.base_reg + !!i.index_reg)
6845
6846/* expr e04 expr'
6847
6848 expr' cmpOp e04 expr'
6849 | Empty */
64a0c779 6850static int
e3bb37b5 6851intel_expr (void)
64a0c779 6852{
a724f0f4
JB		 6853 /* XXX Implement the comparison operators. */
6854 return intel_e04 ();
9306ca4a
JB		 6855}
6856
a724f0f4 6857/* e04 e05 e04'
9306ca4a 6858
a724f0f4 6859 e04' addOp e05 e04'
9306ca4a
JB		 6860 | Empty */
6861static int
e3bb37b5 6862intel_e04 (void)
9306ca4a 6863{
a724f0f4 6864 int nregs = -1;
9306ca4a 6865
a724f0f4 6866 for (;;)
9306ca4a 6867 {
a724f0f4
JB		 6868 if (!intel_e05())
6869 return 0;
9306ca4a 6870
a724f0f4
JB		 6871 if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
6872 i.base_reg = i386_regtab + REGNAM_AL; /* al is invalid as base */
9306ca4a 6873
a724f0f4
JB		 6874 if (cur_token.code == '+')
6875 nregs = -1;
6876 else if (cur_token.code == '-')
6877 nregs = NUM_ADDRESS_REGS;
6878 else
6879 return 1;
64a0c779 6880
a724f0f4
JB		 6881 strcat (intel_parser.disp, cur_token.str);
6882 intel_match_token (cur_token.code);
6883 }
64a0c779
DN		 6884}
6885
64a0c779
DN		 6886/* e05 e06 e05'
6887
9306ca4a 6888 e05' binOp e06 e05'
64a0c779
DN		 6889 | Empty */
6890static int
e3bb37b5 6891intel_e05 (void)
64a0c779 6892{
a724f0f4 6893 int nregs = ~NUM_ADDRESS_REGS;
64a0c779 6894
a724f0f4 6895 for (;;)
64a0c779 6896 {
a724f0f4
JB		 6897 if (!intel_e06())
6898 return 0;
6899
4eed87de
AM		 6900 if (cur_token.code == '&'
6901 || cur_token.code == '|'
6902 || cur_token.code == '^')
a724f0f4
JB		 6903 {
6904 char str[2];
6905
6906 str[0] = cur_token.code;
6907 str[1] = 0;
6908 strcat (intel_parser.disp, str);
6909 }
6910 else
6911 break;
9306ca4a 6912
64a0c779
DN		 6913 intel_match_token (cur_token.code);
6914
a724f0f4
JB		 6915 if (nregs < 0)
6916 nregs = ~nregs;
64a0c779 6917 }
a724f0f4
JB		 6918 if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
6919 i.base_reg = i386_regtab + REGNAM_AL + 1; /* cl is invalid as base */
6920 return 1;
4a1805b1 6921}
64a0c779
DN		 6922
6923/* e06 e09 e06'
6924
6925 e06' mulOp e09 e06'
b77a7acd 6926 | Empty */
64a0c779 6927static int
e3bb37b5 6928intel_e06 (void)
64a0c779 6929{
a724f0f4 6930 int nregs = ~NUM_ADDRESS_REGS;
64a0c779 6931
a724f0f4 6932 for (;;)
64a0c779 6933 {
a724f0f4
JB		 6934 if (!intel_e09())
6935 return 0;
9306ca4a 6936
4eed87de
AM		 6937 if (cur_token.code == '*'
6938 || cur_token.code == '/'
6939 || cur_token.code == '%')
a724f0f4
JB		 6940 {
6941 char str[2];
9306ca4a 6942
a724f0f4
JB		 6943 str[0] = cur_token.code;
6944 str[1] = 0;
6945 strcat (intel_parser.disp, str);
6946 }
6947 else if (cur_token.code == T_SHL)
6948 strcat (intel_parser.disp, "<<");
6949 else if (cur_token.code == T_SHR)
6950 strcat (intel_parser.disp, ">>");
6951 else
6952 break;
9306ca4a 6953
64e74474 6954 intel_match_token (cur_token.code);
64a0c779 6955
a724f0f4
JB		 6956 if (nregs < 0)
6957 nregs = ~nregs;
64a0c779 6958 }
a724f0f4
JB		 6959 if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
6960 i.base_reg = i386_regtab + REGNAM_AL + 2; /* dl is invalid as base */
6961 return 1;
64a0c779
DN		 6962}
6963
a724f0f4
JB		 6964/* e09 OFFSET e09
6965 | SHORT e09
6966 | + e09
6967 | - e09
6968 | ~ e09
6969 | NOT e09
9306ca4a
JB		 6970 | e10 e09'
6971
64a0c779 6972 e09' PTR e10 e09'
b77a7acd 6973 | : e10 e09'
64a0c779
DN		 6974 | Empty */
6975static int
e3bb37b5 6976intel_e09 (void)
64a0c779 6977{
a724f0f4
JB		 6978 int nregs = ~NUM_ADDRESS_REGS;
6979 int in_offset = 0;
6980
6981 for (;;)
64a0c779 6982 {
a724f0f4
JB		 6983 /* Don't consume constants here. */
6984 if (cur_token.code == '+' || cur_token.code == '-')
6985 {
6986 /* Need to look one token ahead - if the next token
6987 is a constant, the current token is its sign. */
6988 int next_code;
6989
6990 intel_match_token (cur_token.code);
6991 next_code = cur_token.code;
6992 intel_putback_token ();
6993 if (next_code == T_CONST)
6994 break;
6995 }
6996
6997 /* e09 OFFSET e09 */
6998 if (cur_token.code == T_OFFSET)
6999 {
7000 if (!in_offset++)
7001 ++intel_parser.in_offset;
7002 }
7003
7004 /* e09 SHORT e09 */
7005 else if (cur_token.code == T_SHORT)
7006 intel_parser.op_modifier |= 1 << T_SHORT;
7007
7008 /* e09 + e09 */
7009 else if (cur_token.code == '+')
7010 strcat (intel_parser.disp, "+");
7011
7012 /* e09 - e09
7013 | ~ e09
7014 | NOT e09 */
7015 else if (cur_token.code == '-' || cur_token.code == '~')
7016 {
7017 char str[2];
64a0c779 7018
a724f0f4
JB		 7019 if (nregs < 0)
7020 nregs = ~nregs;
7021 str[0] = cur_token.code;
7022 str[1] = 0;
7023 strcat (intel_parser.disp, str);
7024 }
7025
7026 /* e09 e10 e09' */
7027 else
7028 break;
7029
7030 intel_match_token (cur_token.code);
64a0c779
DN		 7031 }
7032
a724f0f4 7033 for (;;)
9306ca4a 7034 {
a724f0f4
JB		 7035 if (!intel_e10 ())
7036 return 0;
9306ca4a 7037
a724f0f4
JB		 7038 /* e09' PTR e10 e09' */
7039 if (cur_token.code == T_PTR)
7040 {
7041 char suffix;
9306ca4a 7042
a724f0f4
JB		 7043 if (prev_token.code == T_BYTE)
7044 suffix = BYTE_MNEM_SUFFIX;
9306ca4a 7045
a724f0f4
JB		 7046 else if (prev_token.code == T_WORD)
7047 {
7048 if (current_templates->start->name[0] == 'l'
7049 && current_templates->start->name[2] == 's'
7050 && current_templates->start->name[3] == 0)
7051 suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */
7052 else if (intel_parser.got_a_float == 2) /* "fi..." */
7053 suffix = SHORT_MNEM_SUFFIX;
7054 else
7055 suffix = WORD_MNEM_SUFFIX;
7056 }
64a0c779 7057
a724f0f4
JB		 7058 else if (prev_token.code == T_DWORD)
7059 {
7060 if (current_templates->start->name[0] == 'l'
7061 && current_templates->start->name[2] == 's'
7062 && current_templates->start->name[3] == 0)
7063 suffix = WORD_MNEM_SUFFIX;
7064 else if (flag_code == CODE_16BIT
7065 && (current_templates->start->opcode_modifier
435acd52 7066 & (Jump | JumpDword)))
a724f0f4
JB		 7067 suffix = LONG_DOUBLE_MNEM_SUFFIX;
7068 else if (intel_parser.got_a_float == 1) /* "f..." */
7069 suffix = SHORT_MNEM_SUFFIX;
7070 else
7071 suffix = LONG_MNEM_SUFFIX;
7072 }
9306ca4a 7073
a724f0f4
JB		 7074 else if (prev_token.code == T_FWORD)
7075 {
7076 if (current_templates->start->name[0] == 'l'
7077 && current_templates->start->name[2] == 's'
7078 && current_templates->start->name[3] == 0)
7079 suffix = LONG_MNEM_SUFFIX;
7080 else if (!intel_parser.got_a_float)
7081 {
7082 if (flag_code == CODE_16BIT)
7083 add_prefix (DATA_PREFIX_OPCODE);
7084 suffix = LONG_DOUBLE_MNEM_SUFFIX;
7085 }
7086 else
7087 suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */
7088 }
64a0c779 7089
a724f0f4
JB		 7090 else if (prev_token.code == T_QWORD)
7091 {
7092 if (intel_parser.got_a_float == 1) /* "f..." */
7093 suffix = LONG_MNEM_SUFFIX;
7094 else
7095 suffix = QWORD_MNEM_SUFFIX;
7096 }
64a0c779 7097
a724f0f4
JB		 7098 else if (prev_token.code == T_TBYTE)
7099 {
7100 if (intel_parser.got_a_float == 1)
7101 suffix = LONG_DOUBLE_MNEM_SUFFIX;
7102 else
7103 suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */
7104 }
9306ca4a 7105
a724f0f4 7106 else if (prev_token.code == T_XMMWORD)
9306ca4a 7107 {
a724f0f4
JB		 7108 /* XXX ignored for now, but accepted since gcc uses it */
7109 suffix = 0;
9306ca4a 7110 }
64a0c779 7111
f16b83df 7112 else
a724f0f4
JB		 7113 {
7114 as_bad (_("Unknown operand modifier `%s'"), prev_token.str);
7115 return 0;
7116 }
7117
435acd52
JB		 7118 /* Operands for jump/call using 'ptr' notation denote absolute
7119 addresses. */
7120 if (current_templates->start->opcode_modifier & (Jump | JumpDword))
7121 i.types[this_operand] |= JumpAbsolute;
7122
a724f0f4
JB		 7123 if (current_templates->start->base_opcode == 0x8d /* lea */)
7124 ;
7125 else if (!i.suffix)
7126 i.suffix = suffix;
7127 else if (i.suffix != suffix)
7128 {
7129 as_bad (_("Conflicting operand modifiers"));
7130 return 0;
7131 }
64a0c779 7132
9306ca4a
JB		 7133 }
7134
a724f0f4
JB		 7135 /* e09' : e10 e09' */
7136 else if (cur_token.code == ':')
9306ca4a 7137 {
a724f0f4
JB		 7138 if (prev_token.code != T_REG)
7139 {
7140 /* While {call,jmp} SSSS:OOOO is MASM syntax only when SSSS is a
7141 segment/group identifier (which we don't have), using comma
7142 as the operand separator there is even less consistent, since
7143 there all branches only have a single operand. */
7144 if (this_operand != 0
7145 || intel_parser.in_offset
7146 || intel_parser.in_bracket
7147 || (!(current_templates->start->opcode_modifier
7148 & (Jump|JumpDword|JumpInterSegment))
7149 && !(current_templates->start->operand_types[0]
7150 & JumpAbsolute)))
7151 return intel_match_token (T_NIL);
7152 /* Remember the start of the 2nd operand and terminate 1st
7153 operand here.
7154 XXX This isn't right, yet (when SSSS:OOOO is right operand of
7155 another expression), but it gets at least the simplest case
7156 (a plain number or symbol on the left side) right. */
7157 intel_parser.next_operand = intel_parser.op_string;
7158 *--intel_parser.op_string = '\0';
7159 return intel_match_token (':');
7160 }
9306ca4a 7161 }
64a0c779 7162
a724f0f4 7163 /* e09' Empty */
64a0c779 7164 else
a724f0f4 7165 break;
64a0c779 7166
a724f0f4
JB		 7167 intel_match_token (cur_token.code);
7168
7169 }
7170
7171 if (in_offset)
7172 {
7173 --intel_parser.in_offset;
7174 if (nregs < 0)
7175 nregs = ~nregs;
7176 if (NUM_ADDRESS_REGS > nregs)
9306ca4a 7177 {
a724f0f4 7178 as_bad (_("Invalid operand to `OFFSET'"));
9306ca4a
JB		 7179 return 0;
7180 }
a724f0f4
JB		 7181 intel_parser.op_modifier |= 1 << T_OFFSET;
7182 }
9306ca4a 7183
a724f0f4
JB		 7184 if (nregs >= 0 && NUM_ADDRESS_REGS > nregs)
7185 i.base_reg = i386_regtab + REGNAM_AL + 3; /* bl is invalid as base */
7186 return 1;
7187}
64a0c779 7188
a724f0f4 7189static int
e3bb37b5 7190intel_bracket_expr (void)
a724f0f4
JB		 7191{
7192 int was_offset = intel_parser.op_modifier & (1 << T_OFFSET);
7193 const char *start = intel_parser.op_string;
7194 int len;
7195
7196 if (i.op[this_operand].regs)
7197 return intel_match_token (T_NIL);
7198
7199 intel_match_token ('[');
7200
7201 /* Mark as a memory operand only if it's not already known to be an
7202 offset expression. If it's an offset expression, we need to keep
7203 the brace in. */
7204 if (!intel_parser.in_offset)
7205 {
7206 ++intel_parser.in_bracket;
435acd52
JB		 7207
7208 /* Operands for jump/call inside brackets denote absolute addresses. */
7209 if (current_templates->start->opcode_modifier & (Jump | JumpDword))
7210 i.types[this_operand] |= JumpAbsolute;
7211
a724f0f4
JB		 7212 /* Unfortunately gas always diverged from MASM in a respect that can't
7213 be easily fixed without risking to break code sequences likely to be
7214 encountered (the testsuite even check for this): MASM doesn't consider
7215 an expression inside brackets unconditionally as a memory reference.
7216 When that is e.g. a constant, an offset expression, or the sum of the
7217 two, this is still taken as a constant load. gas, however, always
7218 treated these as memory references. As a compromise, we'll try to make
7219 offset expressions inside brackets work the MASM way (since that's
7220 less likely to be found in real world code), but make constants alone
7221 continue to work the traditional gas way. In either case, issue a
7222 warning. */
7223 intel_parser.op_modifier &= ~was_offset;
64a0c779 7224 }
a724f0f4 7225 else
64e74474 7226 strcat (intel_parser.disp, "[");
a724f0f4
JB		 7227
7228 /* Add a '+' to the displacement string if necessary. */
7229 if (*intel_parser.disp != '\0'
7230 && *(intel_parser.disp + strlen (intel_parser.disp) - 1) != '+')
7231 strcat (intel_parser.disp, "+");
64a0c779 7232
a724f0f4
JB		 7233 if (intel_expr ()
7234 && (len = intel_parser.op_string - start - 1,
7235 intel_match_token (']')))
64a0c779 7236 {
a724f0f4
JB		 7237 /* Preserve brackets when the operand is an offset expression. */
7238 if (intel_parser.in_offset)
7239 strcat (intel_parser.disp, "]");
7240 else
7241 {
7242 --intel_parser.in_bracket;
7243 if (i.base_reg || i.index_reg)
7244 intel_parser.is_mem = 1;
7245 if (!intel_parser.is_mem)
7246 {
7247 if (!(intel_parser.op_modifier & (1 << T_OFFSET)))
7248 /* Defer the warning until all of the operand was parsed. */
7249 intel_parser.is_mem = -1;
7250 else if (!quiet_warnings)
4eed87de
AM		 7251 as_warn (_("`[%.*s]' taken to mean just `%.*s'"),
7252 len, start, len, start);
a724f0f4
JB		 7253 }
7254 }
7255 intel_parser.op_modifier |= was_offset;
64a0c779 7256
a724f0f4 7257 return 1;
64a0c779 7258 }
a724f0f4 7259 return 0;
64a0c779
DN		 7260}
7261
7262/* e10 e11 e10'
7263
7264 e10' [ expr ] e10'
b77a7acd 7265 | Empty */
64a0c779 7266static int
e3bb37b5 7267intel_e10 (void)
64a0c779 7268{
a724f0f4
JB		 7269 if (!intel_e11 ())
7270 return 0;
64a0c779 7271
a724f0f4 7272 while (cur_token.code == '[')
64a0c779 7273 {
a724f0f4 7274 if (!intel_bracket_expr ())
21d6c4af 7275 return 0;
64a0c779
DN		 7276 }
7277
a724f0f4 7278 return 1;
64a0c779
DN		 7279}
7280
64a0c779 7281/* e11 ( expr )
b77a7acd 7282 | [ expr ]
64a0c779
DN		 7283 | BYTE
7284 | WORD
7285 | DWORD
9306ca4a 7286 | FWORD
64a0c779 7287 | QWORD
9306ca4a
JB		 7288 | TBYTE
7289 | OWORD
7290 | XMMWORD
4a1805b1 7291 | $
64a0c779
DN		 7292 | .
7293 | register
7294 | id
7295 | constant */
7296static int
e3bb37b5 7297intel_e11 (void)
64a0c779 7298{
a724f0f4 7299 switch (cur_token.code)
64a0c779 7300 {
a724f0f4
JB		 7301 /* e11 ( expr ) */
7302 case '(':
64a0c779
DN		 7303 intel_match_token ('(');
7304 strcat (intel_parser.disp, "(");
7305
7306 if (intel_expr () && intel_match_token (')'))
e5cb08ac
KH		 7307 {
7308 strcat (intel_parser.disp, ")");
7309 return 1;
7310 }
a724f0f4 7311 return 0;
4a1805b1 7312
a724f0f4
JB		 7313 /* e11 [ expr ] */
7314 case '[':
a724f0f4 7315 return intel_bracket_expr ();
64a0c779 7316
a724f0f4
JB		 7317 /* e11 $
7318 | . */
7319 case '.':
64a0c779
DN		 7320 strcat (intel_parser.disp, cur_token.str);
7321 intel_match_token (cur_token.code);
21d6c4af
DN		 7322
7323 /* Mark as a memory operand only if it's not already known to be an
7324 offset expression. */
a724f0f4 7325 if (!intel_parser.in_offset)
21d6c4af 7326 intel_parser.is_mem = 1;
64a0c779
DN		 7327
7328 return 1;
64a0c779 7329
a724f0f4
JB		 7330 /* e11 register */
7331 case T_REG:
7332 {
7333 const reg_entry *reg = intel_parser.reg = cur_token.reg;
64a0c779 7334
a724f0f4 7335 intel_match_token (T_REG);
64a0c779 7336
a724f0f4
JB		 7337 /* Check for segment change. */
7338 if (cur_token.code == ':')
7339 {
7340 if (!(reg->reg_type & (SReg2 | SReg3)))
7341 {
4eed87de
AM		 7342 as_bad (_("`%s' is not a valid segment register"),
7343 reg->reg_name);
a724f0f4
JB		 7344 return 0;
7345 }
7346 else if (i.seg[i.mem_operands])
7347 as_warn (_("Extra segment override ignored"));
7348 else
7349 {
7350 if (!intel_parser.in_offset)
7351 intel_parser.is_mem = 1;
7352 switch (reg->reg_num)
7353 {
7354 case 0:
7355 i.seg[i.mem_operands] = &es;
7356 break;
7357 case 1:
7358 i.seg[i.mem_operands] = &cs;
7359 break;
7360 case 2:
7361 i.seg[i.mem_operands] = &ss;
7362 break;
7363 case 3:
7364 i.seg[i.mem_operands] = &ds;
7365 break;
7366 case 4:
7367 i.seg[i.mem_operands] = &fs;
7368 break;
7369 case 5:
7370 i.seg[i.mem_operands] = &gs;
7371 break;
7372 }
7373 }
7374 }
64a0c779 7375
a724f0f4
JB		 7376 /* Not a segment register. Check for register scaling. */
7377 else if (cur_token.code == '*')
7378 {
7379 if (!intel_parser.in_bracket)
7380 {
7381 as_bad (_("Register scaling only allowed in memory operands"));
7382 return 0;
7383 }
64a0c779 7384
a724f0f4
JB		 7385 if (reg->reg_type & Reg16) /* Disallow things like [si*1]. */
7386 reg = i386_regtab + REGNAM_AX + 4; /* sp is invalid as index */
7387 else if (i.index_reg)
7388 reg = i386_regtab + REGNAM_EAX + 4; /* esp is invalid as index */
64a0c779 7389
a724f0f4
JB		 7390 /* What follows must be a valid scale. */
7391 intel_match_token ('*');
7392 i.index_reg = reg;
7393 i.types[this_operand] |= BaseIndex;
64a0c779 7394
a724f0f4
JB		 7395 /* Set the scale after setting the register (otherwise,
7396 i386_scale will complain) */
7397 if (cur_token.code == '+' || cur_token.code == '-')
7398 {
7399 char *str, sign = cur_token.code;
7400 intel_match_token (cur_token.code);
7401 if (cur_token.code != T_CONST)
7402 {
7403 as_bad (_("Syntax error: Expecting a constant, got `%s'"),
7404 cur_token.str);
7405 return 0;
7406 }
7407 str = (char *) xmalloc (strlen (cur_token.str) + 2);
7408 strcpy (str + 1, cur_token.str);
7409 *str = sign;
7410 if (!i386_scale (str))
7411 return 0;
7412 free (str);
7413 }
7414 else if (!i386_scale (cur_token.str))
64a0c779 7415 return 0;
a724f0f4
JB		 7416 intel_match_token (cur_token.code);
7417 }
64a0c779 7418
a724f0f4
JB		 7419 /* No scaling. If this is a memory operand, the register is either a
7420 base register (first occurrence) or an index register (second
7421 occurrence). */
7b0441f6 7422 else if (intel_parser.in_bracket)
a724f0f4 7423 {
64a0c779 7424
a724f0f4
JB		 7425 if (!i.base_reg)
7426 i.base_reg = reg;
7427 else if (!i.index_reg)
7428 i.index_reg = reg;
7429 else
7430 {
7431 as_bad (_("Too many register references in memory operand"));
7432 return 0;
7433 }
64a0c779 7434
a724f0f4
JB		 7435 i.types[this_operand] |= BaseIndex;
7436 }
4a1805b1 7437
4d1bb795
JB		 7438 /* It's neither base nor index. */
7439 else if (!intel_parser.in_offset && !intel_parser.is_mem)
a724f0f4
JB		 7440 {
7441 i.types[this_operand] |= reg->reg_type & ~BaseIndex;
7442 i.op[this_operand].regs = reg;
7443 i.reg_operands++;
7444 }
7445 else
7446 {
7447 as_bad (_("Invalid use of register"));
7448 return 0;
7449 }
64a0c779 7450
a724f0f4
JB		 7451 /* Since registers are not part of the displacement string (except
7452 when we're parsing offset operands), we may need to remove any
7453 preceding '+' from the displacement string. */
7454 if (*intel_parser.disp != '\0'
7455 && !intel_parser.in_offset)
7456 {
7457 char *s = intel_parser.disp;
7458 s += strlen (s) - 1;
7459 if (*s == '+')
7460 *s = '\0';
7461 }
4a1805b1 7462
a724f0f4
JB		 7463 return 1;
7464 }
7465
7466 /* e11 BYTE
7467 | WORD
7468 | DWORD
7469 | FWORD
7470 | QWORD
7471 | TBYTE
7472 | OWORD
7473 | XMMWORD */
7474 case T_BYTE:
7475 case T_WORD:
7476 case T_DWORD:
7477 case T_FWORD:
7478 case T_QWORD:
7479 case T_TBYTE:
7480 case T_XMMWORD:
7481 intel_match_token (cur_token.code);
64a0c779 7482
a724f0f4
JB		 7483 if (cur_token.code == T_PTR)
7484 return 1;
7485
7486 /* It must have been an identifier. */
7487 intel_putback_token ();
7488 cur_token.code = T_ID;
7489 /* FALLTHRU */
7490
7491 /* e11 id
7492 | constant */
7493 case T_ID:
7494 if (!intel_parser.in_offset && intel_parser.is_mem <= 0)
9306ca4a
JB		 7495 {
7496 symbolS *symbolP;
7497
a724f0f4
JB		 7498 /* The identifier represents a memory reference only if it's not
7499 preceded by an offset modifier and if it's not an equate. */
9306ca4a
JB		 7500 symbolP = symbol_find(cur_token.str);
7501 if (!symbolP || S_GET_SEGMENT(symbolP) != absolute_section)
7502 intel_parser.is_mem = 1;
7503 }
a724f0f4 7504 /* FALLTHRU */
64a0c779 7505
a724f0f4
JB		 7506 case T_CONST:
7507 case '-':
7508 case '+':
7509 {
7510 char *save_str, sign = 0;
64a0c779 7511
a724f0f4
JB		 7512 /* Allow constants that start with `+' or `-'. */
7513 if (cur_token.code == '-' || cur_token.code == '+')
7514 {
7515 sign = cur_token.code;
7516 intel_match_token (cur_token.code);
7517 if (cur_token.code != T_CONST)
7518 {
7519 as_bad (_("Syntax error: Expecting a constant, got `%s'"),
7520 cur_token.str);
7521 return 0;
7522 }
7523 }
64a0c779 7524
a724f0f4
JB		 7525 save_str = (char *) xmalloc (strlen (cur_token.str) + 2);
7526 strcpy (save_str + !!sign, cur_token.str);
7527 if (sign)
7528 *save_str = sign;
64a0c779 7529
a724f0f4
JB		 7530 /* Get the next token to check for register scaling. */
7531 intel_match_token (cur_token.code);
64a0c779 7532
4eed87de
AM		 7533 /* Check if this constant is a scaling factor for an
7534 index register. */
a724f0f4
JB		 7535 if (cur_token.code == '*')
7536 {
7537 if (intel_match_token ('*') && cur_token.code == T_REG)
7538 {
7539 const reg_entry *reg = cur_token.reg;
7540
7541 if (!intel_parser.in_bracket)
7542 {
4eed87de
AM		 7543 as_bad (_("Register scaling only allowed "
7544 "in memory operands"));
a724f0f4
JB		 7545 return 0;
7546 }
7547
4eed87de
AM		 7548 /* Disallow things like [1*si].
7549 sp and esp are invalid as index. */
7550 if (reg->reg_type & Reg16)
7551 reg = i386_regtab + REGNAM_AX + 4;
a724f0f4 7552 else if (i.index_reg)
4eed87de 7553 reg = i386_regtab + REGNAM_EAX + 4;
a724f0f4
JB		 7554
7555 /* The constant is followed by `* reg', so it must be
7556 a valid scale. */
7557 i.index_reg = reg;
7558 i.types[this_operand] |= BaseIndex;
7559
7560 /* Set the scale after setting the register (otherwise,
7561 i386_scale will complain) */
7562 if (!i386_scale (save_str))
64a0c779 7563 return 0;
a724f0f4
JB		 7564 intel_match_token (T_REG);
7565
7566 /* Since registers are not part of the displacement
7567 string, we may need to remove any preceding '+' from
7568 the displacement string. */
7569 if (*intel_parser.disp != '\0')
7570 {
7571 char *s = intel_parser.disp;
7572 s += strlen (s) - 1;
7573 if (*s == '+')
7574 *s = '\0';
7575 }
7576
7577 free (save_str);
7578
7579 return 1;
7580 }
64a0c779 7581
a724f0f4
JB		 7582 /* The constant was not used for register scaling. Since we have
7583 already consumed the token following `*' we now need to put it
7584 back in the stream. */
64a0c779 7585 intel_putback_token ();
a724f0f4 7586 }
64a0c779 7587
a724f0f4
JB		 7588 /* Add the constant to the displacement string. */
7589 strcat (intel_parser.disp, save_str);
7590 free (save_str);
64a0c779 7591
a724f0f4
JB		 7592 return 1;
7593 }
64a0c779
DN		 7594 }
7595
64a0c779
DN		 7596 as_bad (_("Unrecognized token '%s'"), cur_token.str);
7597 return 0;
7598}
7599
64a0c779
DN		 7600/* Match the given token against cur_token. If they match, read the next
7601 token from the operand string. */
7602static int
e3bb37b5 7603intel_match_token (int code)
64a0c779
DN		 7604{
7605 if (cur_token.code == code)
7606 {
7607 intel_get_token ();
7608 return 1;
7609 }
7610 else
7611 {
0477af35 7612 as_bad (_("Unexpected token `%s'"), cur_token.str);
64a0c779
DN		 7613 return 0;
7614 }
7615}
7616
64a0c779
DN		 7617/* Read a new token from intel_parser.op_string and store it in cur_token. */
7618static void
e3bb37b5 7619intel_get_token (void)
64a0c779
DN		 7620{
7621 char *end_op;
7622 const reg_entry *reg;
7623 struct intel_token new_token;
7624
7625 new_token.code = T_NIL;
7626 new_token.reg = NULL;
7627 new_token.str = NULL;
7628
4a1805b1 7629 /* Free the memory allocated to the previous token and move
64a0c779
DN		 7630 cur_token to prev_token. */
7631 if (prev_token.str)
7632 free (prev_token.str);
7633
7634 prev_token = cur_token;
7635
7636 /* Skip whitespace. */
7637 while (is_space_char (*intel_parser.op_string))
7638 intel_parser.op_string++;
7639
7640 /* Return an empty token if we find nothing else on the line. */
7641 if (*intel_parser.op_string == '\0')
7642 {
7643 cur_token = new_token;
7644 return;
7645 }
7646
7647 /* The new token cannot be larger than the remainder of the operand
7648 string. */
a724f0f4 7649 new_token.str = (char *) xmalloc (strlen (intel_parser.op_string) + 1);
64a0c779
DN		 7650 new_token.str[0] = '\0';
7651
7652 if (strchr ("0123456789", *intel_parser.op_string))
7653 {
7654 char *p = new_token.str;
7655 char *q = intel_parser.op_string;
7656 new_token.code = T_CONST;
7657
7658 /* Allow any kind of identifier char to encompass floating point and
7659 hexadecimal numbers. */
7660 while (is_identifier_char (*q))
7661 *p++ = *q++;
7662 *p = '\0';
7663
7664 /* Recognize special symbol names [0-9][bf]. */
7665 if (strlen (intel_parser.op_string) == 2
4a1805b1 7666 && (intel_parser.op_string[1] == 'b'
64a0c779
DN		 7667 || intel_parser.op_string[1] == 'f'))
7668 new_token.code = T_ID;
7669 }
7670
4d1bb795 7671 else if ((reg = parse_register (intel_parser.op_string, &end_op)) != NULL)
64a0c779 7672 {
4d1bb795
JB		 7673 size_t len = end_op - intel_parser.op_string;
7674
64a0c779
DN		 7675 new_token.code = T_REG;
7676 new_token.reg = reg;
7677
4d1bb795
JB		 7678 memcpy (new_token.str, intel_parser.op_string, len);
7679 new_token.str[len] = '\0';
64a0c779
DN		 7680 }
7681
7682 else if (is_identifier_char (*intel_parser.op_string))
7683 {
7684 char *p = new_token.str;
7685 char *q = intel_parser.op_string;
7686
7687 /* A '.' or '$' followed by an identifier char is an identifier.
7688 Otherwise, it's operator '.' followed by an expression. */
7689 if ((*q == '.' || *q == '$') && !is_identifier_char (*(q + 1)))
7690 {
9306ca4a
JB		 7691 new_token.code = '.';
7692 new_token.str[0] = '.';
64a0c779
DN		 7693 new_token.str[1] = '\0';
7694 }
7695 else
7696 {
7697 while (is_identifier_char (*q) || *q == '@')
7698 *p++ = *q++;
7699 *p = '\0';
7700
9306ca4a
JB		 7701 if (strcasecmp (new_token.str, "NOT") == 0)
7702 new_token.code = '~';
7703
7704 else if (strcasecmp (new_token.str, "MOD") == 0)
7705 new_token.code = '%';
7706
7707 else if (strcasecmp (new_token.str, "AND") == 0)
7708 new_token.code = '&';
7709
7710 else if (strcasecmp (new_token.str, "OR") == 0)
7711 new_token.code = '|';
7712
7713 else if (strcasecmp (new_token.str, "XOR") == 0)
7714 new_token.code = '^';
7715
7716 else if (strcasecmp (new_token.str, "SHL") == 0)
7717 new_token.code = T_SHL;
7718
7719 else if (strcasecmp (new_token.str, "SHR") == 0)
7720 new_token.code = T_SHR;
7721
7722 else if (strcasecmp (new_token.str, "BYTE") == 0)
64a0c779
DN		 7723 new_token.code = T_BYTE;
7724
7725 else if (strcasecmp (new_token.str, "WORD") == 0)
7726 new_token.code = T_WORD;
7727
7728 else if (strcasecmp (new_token.str, "DWORD") == 0)
7729 new_token.code = T_DWORD;
7730
9306ca4a
JB		 7731 else if (strcasecmp (new_token.str, "FWORD") == 0)
7732 new_token.code = T_FWORD;
7733
64a0c779
DN		 7734 else if (strcasecmp (new_token.str, "QWORD") == 0)
7735 new_token.code = T_QWORD;
7736
9306ca4a
JB		 7737 else if (strcasecmp (new_token.str, "TBYTE") == 0
7738 /* XXX remove (gcc still uses it) */
7739 || strcasecmp (new_token.str, "XWORD") == 0)
7740 new_token.code = T_TBYTE;
7741
7742 else if (strcasecmp (new_token.str, "XMMWORD") == 0
7743 || strcasecmp (new_token.str, "OWORD") == 0)
7744 new_token.code = T_XMMWORD;
64a0c779
DN		 7745
7746 else if (strcasecmp (new_token.str, "PTR") == 0)
7747 new_token.code = T_PTR;
7748
7749 else if (strcasecmp (new_token.str, "SHORT") == 0)
7750 new_token.code = T_SHORT;
7751
7752 else if (strcasecmp (new_token.str, "OFFSET") == 0)
7753 {
7754 new_token.code = T_OFFSET;
7755
7756 /* ??? This is not mentioned in the MASM grammar but gcc
7757 makes use of it with -mintel-syntax. OFFSET may be
7758 followed by FLAT: */
7759 if (strncasecmp (q, " FLAT:", 6) == 0)
7760 strcat (new_token.str, " FLAT:");
7761 }
7762
7763 /* ??? This is not mentioned in the MASM grammar. */
7764 else if (strcasecmp (new_token.str, "FLAT") == 0)
a724f0f4
JB		 7765 {
7766 new_token.code = T_OFFSET;
7767 if (*q == ':')
7768 strcat (new_token.str, ":");
7769 else
7770 as_bad (_("`:' expected"));
7771 }
64a0c779
DN		 7772
7773 else
7774 new_token.code = T_ID;
7775 }
7776 }
7777
9306ca4a
JB		 7778 else if (strchr ("+-/*%|&^:[]()~", *intel_parser.op_string))
7779 {
7780 new_token.code = *intel_parser.op_string;
7781 new_token.str[0] = *intel_parser.op_string;
7782 new_token.str[1] = '\0';
7783 }
7784
7785 else if (strchr ("<>", *intel_parser.op_string)
7786 && *intel_parser.op_string == *(intel_parser.op_string + 1))
7787 {
7788 new_token.code = *intel_parser.op_string == '<' ? T_SHL : T_SHR;
7789 new_token.str[0] = *intel_parser.op_string;
7790 new_token.str[1] = *intel_parser.op_string;
7791 new_token.str[2] = '\0';
7792 }
7793
64a0c779 7794 else
0477af35 7795 as_bad (_("Unrecognized token `%s'"), intel_parser.op_string);
64a0c779
DN		 7796
7797 intel_parser.op_string += strlen (new_token.str);
7798 cur_token = new_token;
7799}
7800
64a0c779
DN		 7801/* Put cur_token back into the token stream and make cur_token point to
7802 prev_token. */
7803static void
e3bb37b5 7804intel_putback_token (void)
64a0c779 7805{
a724f0f4
JB		 7806 if (cur_token.code != T_NIL)
7807 {
7808 intel_parser.op_string -= strlen (cur_token.str);
7809 free (cur_token.str);
7810 }
64a0c779 7811 cur_token = prev_token;
4a1805b1 7812
64a0c779
DN		 7813 /* Forget prev_token. */
7814 prev_token.code = T_NIL;
7815 prev_token.reg = NULL;
7816 prev_token.str = NULL;
7817}
54cfded0 7818
a4447b93 7819int
1df69f4f 7820tc_x86_regname_to_dw2regnum (char *regname)
54cfded0
AM		 7821{
7822 unsigned int regnum;
7823 unsigned int regnames_count;
089dfecd 7824 static const char *const regnames_32[] =
54cfded0 7825 {
a4447b93
RH		 7826 "eax", "ecx", "edx", "ebx",
7827 "esp", "ebp", "esi", "edi",
089dfecd
JB		 7828 "eip", "eflags", NULL,
7829 "st0", "st1", "st2", "st3",
7830 "st4", "st5", "st6", "st7",
7831 NULL, NULL,
7832 "xmm0", "xmm1", "xmm2", "xmm3",
7833 "xmm4", "xmm5", "xmm6", "xmm7",
7834 "mm0", "mm1", "mm2", "mm3",
43fd16e4
JB		 7835 "mm4", "mm5", "mm6", "mm7",
7836 "fcw", "fsw", "mxcsr",
7837 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
7838 "tr", "ldtr"
54cfded0 7839 };
089dfecd 7840 static const char *const regnames_64[] =
54cfded0 7841 {
089dfecd
JB		 7842 "rax", "rdx", "rcx", "rbx",
7843 "rsi", "rdi", "rbp", "rsp",
7844 "r8", "r9", "r10", "r11",
54cfded0 7845 "r12", "r13", "r14", "r15",
089dfecd
JB		 7846 "rip",
7847 "xmm0", "xmm1", "xmm2", "xmm3",
7848 "xmm4", "xmm5", "xmm6", "xmm7",
7849 "xmm8", "xmm9", "xmm10", "xmm11",
7850 "xmm12", "xmm13", "xmm14", "xmm15",
7851 "st0", "st1", "st2", "st3",
7852 "st4", "st5", "st6", "st7",
7853 "mm0", "mm1", "mm2", "mm3",
43fd16e4
JB		 7854 "mm4", "mm5", "mm6", "mm7",
7855 "rflags",
7856 "es", "cs", "ss", "ds", "fs", "gs", NULL, NULL,
7857 "fs.base", "gs.base", NULL, NULL,
7858 "tr", "ldtr",
7859 "mxcsr", "fcw", "fsw"
54cfded0 7860 };
089dfecd 7861 const char *const *regnames;
54cfded0
AM		 7862
7863 if (flag_code == CODE_64BIT)
7864 {
7865 regnames = regnames_64;
0cea6190 7866 regnames_count = ARRAY_SIZE (regnames_64);
54cfded0
AM		 7867 }
7868 else
7869 {
7870 regnames = regnames_32;
0cea6190 7871 regnames_count = ARRAY_SIZE (regnames_32);
54cfded0
AM		 7872 }
7873
7874 for (regnum = 0; regnum < regnames_count; regnum++)
089dfecd
JB		 7875 if (regnames[regnum] != NULL
7876 && strcmp (regname, regnames[regnum]) == 0)
54cfded0
AM		 7877 return regnum;
7878
54cfded0
AM		 7879 return -1;
7880}
7881
7882void
7883tc_x86_frame_initial_instructions (void)
7884{
a4447b93
RH		 7885 static unsigned int sp_regno;
7886
7887 if (!sp_regno)
7888 sp_regno = tc_x86_regname_to_dw2regnum (flag_code == CODE_64BIT
7889 ? "rsp" : "esp");
7890
7891 cfi_add_CFA_def_cfa (sp_regno, -x86_cie_data_alignment);
7892 cfi_add_CFA_offset (x86_dwarf2_return_column, x86_cie_data_alignment);
54cfded0 7893}
d2b2c203
DJ		 7894
7895int
7896i386_elf_section_type (const char *str, size_t len)
7897{
7898 if (flag_code == CODE_64BIT
7899 && len == sizeof ("unwind") - 1
7900 && strncmp (str, "unwind", 6) == 0)
7901 return SHT_X86_64_UNWIND;
7902
7903 return -1;
7904}
bb41ade5
AM		 7905
7906#ifdef TE_PE
7907void
7908tc_pe_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
7909{
7910 expressionS expr;
7911
7912 expr.X_op = O_secrel;
7913 expr.X_add_symbol = symbol;
7914 expr.X_add_number = 0;
7915 emit_expr (&expr, size);
7916}
7917#endif
3b22753a
L		 7918
7919#if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
7920/* For ELF on x86-64, add support for SHF_X86_64_LARGE. */
7921
7922int
7923x86_64_section_letter (int letter, char **ptr_msg)
7924{
7925 if (flag_code == CODE_64BIT)
7926 {
7927 if (letter == 'l')
7928 return SHF_X86_64_LARGE;
7929
7930 *ptr_msg = _("Bad .section directive: want a,l,w,x,M,S,G,T in string");
64e74474 7931 }
3b22753a 7932 else
64e74474 7933 *ptr_msg = _("Bad .section directive: want a,w,x,M,S,G,T in string");
3b22753a
L		 7934 return -1;
7935}
7936
7937int
7938x86_64_section_word (char *str, size_t len)
7939{
8620418b 7940 if (len == 5 && flag_code == CODE_64BIT && CONST_STRNEQ (str, "large"))
3b22753a
L		 7941 return SHF_X86_64_LARGE;
7942
7943 return -1;
7944}
7945
7946static void
7947handle_large_common (int small ATTRIBUTE_UNUSED)
7948{
7949 if (flag_code != CODE_64BIT)
7950 {
7951 s_comm_internal (0, elf_common_parse);
7952 as_warn (_(".largecomm supported only in 64bit mode, producing .comm"));
7953 }
7954 else
7955 {
7956 static segT lbss_section;
7957 asection *saved_com_section_ptr = elf_com_section_ptr;
7958 asection *saved_bss_section = bss_section;
7959
7960 if (lbss_section == NULL)
7961 {
7962 flagword applicable;
7963 segT seg = now_seg;
7964 subsegT subseg = now_subseg;
7965
7966 /* The .lbss section is for local .largecomm symbols. */
7967 lbss_section = subseg_new (".lbss", 0);
7968 applicable = bfd_applicable_section_flags (stdoutput);
7969 bfd_set_section_flags (stdoutput, lbss_section,
7970 applicable & SEC_ALLOC);
7971 seg_info (lbss_section)->bss = 1;
7972
7973 subseg_set (seg, subseg);
7974 }
7975
7976 elf_com_section_ptr = &_bfd_elf_large_com_section;
7977 bss_section = lbss_section;
7978
7979 s_comm_internal (0, elf_common_parse);
7980
7981 elf_com_section_ptr = saved_com_section_ptr;
7982 bss_section = saved_bss_section;
7983 }
7984}
7985#endif /* OBJ_ELF || OBJ_MAYBE_ELF */
GDB Binutils - Deliverables
This page took 1.063111 seconds and 4 git commands to generate.