]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gas/config/tc-m68k.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Make -mlittle-endian switch set the target_big_endian variable to false.
[thirdparty/binutils-gdb.git] / gas / config / tc-m68k.c
CommitLineData
252b5132 1/* tc-m68k.c -- Assemble for the m68k family
f7e42eb4 2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
f17c130b 3 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
252b5132
RH		 4
5 This file is part of GAS, the GNU Assembler.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
252b5132 22#include "as.h"
3882b010 23#include "safe-ctype.h"
252b5132
RH		 24#include "obstack.h"
25#include "subsegs.h"
f27a3839 26#include "dwarf2dbg.h"
c04898f8 27#include "dw2gencfi.h"
252b5132
RH		 28
29#include "opcode/m68k.h"
30#include "m68k-parse.h"
31
0d96863f
CM		 32#if defined (OBJ_ELF)
33#include "elf/m68k.h"
34#endif
35
31302357
AS		 36#ifdef M68KCOFF
37#include "obj-coff.h"
38#endif
39
252b5132
RH		 40/* This string holds the chars that always start a comment. If the
41 pre-processor is disabled, these aren't very useful. The macro
42 tc_comment_chars points to this. We use this, rather than the
43 usual comment_chars, so that the --bitwise-or option will work. */
44#if defined (TE_SVR4) || defined (TE_DELTA)
45const char *m68k_comment_chars = "|#";
46#else
47const char *m68k_comment_chars = "|";
48#endif
49
50/* This array holds the chars that only start a comment at the beginning of
51 a line. If the line seems to have the form '# 123 filename'
52 .line and .file directives will appear in the pre-processed output */
53/* Note that input_file.c hand checks for '#' at the beginning of the
54 first line of the input file. This is because the compiler outputs
92774660
KH		 55 #NO_APP at the beginning of its output. */
56/* Also note that comments like this one will always work. */
252b5132
RH		 57const char line_comment_chars[] = "#*";
58
63a0b638 59const char line_separator_chars[] = ";";
252b5132 60
36759679 61/* Chars that can be used to separate mant from exp in floating point nums. */
5a38dc70 62const char EXP_CHARS[] = "eE";
252b5132
RH		 63
64/* Chars that mean this number is a floating point constant, as
65 in "0f12.456" or "0d1.2345e12". */
66
5a38dc70 67const char FLT_CHARS[] = "rRsSfFdDxXeEpP";
252b5132
RH		 68
69/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
70 changed in read.c . Ideally it shouldn't have to know about it at all,
71 but nothing is ideal around here. */
72
36759679 73const int md_reloc_size = 8; /* Size of relocation record. */
252b5132
RH		 74
75/* Are we trying to generate PIC code? If so, absolute references
76 ought to be made into linkage table references or pc-relative
92774660 77 references. Not implemented. For ELF there are other means
252b5132
RH		 78 to denote pic relocations. */
79int flag_want_pic;
80
36759679
NC		 81static int flag_short_refs; /* -l option. */
82static int flag_long_jumps; /* -S option. */
28e7409f 83static int flag_keep_pcrel; /* --pcrel option. */
252b5132
RH		 84
85#ifdef REGISTER_PREFIX_OPTIONAL
86int flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL;
87#else
88int flag_reg_prefix_optional;
89#endif
90
91/* Whether --register-prefix-optional was used on the command line. */
92static int reg_prefix_optional_seen;
93
94/* The floating point coprocessor to use by default. */
95static enum m68k_register m68k_float_copnum = COP1;
96
97/* If this is non-zero, then references to number(%pc) will be taken
98 to refer to number, rather than to %pc + number. */
99static int m68k_abspcadd;
100
101/* If this is non-zero, then the quick forms of the move, add, and sub
102 instructions are used when possible. */
103static int m68k_quick = 1;
104
105/* If this is non-zero, then if the size is not specified for a base
106 or outer displacement, the assembler assumes that the size should
107 be 32 bits. */
108static int m68k_rel32 = 1;
109
110/* This is non-zero if m68k_rel32 was set from the command line. */
111static int m68k_rel32_from_cmdline;
112
113/* The default width to use for an index register when using a base
114 displacement. */
115static enum m68k_size m68k_index_width_default = SIZE_LONG;
116
117/* We want to warn if any text labels are misaligned. In order to get
118 the right line number, we need to record the line number for each
119 label. */
252b5132
RH		 120struct label_line
121{
122 struct label_line *next;
123 symbolS *label;
124 char *file;
125 unsigned int line;
126 int text;
127};
128
129/* The list of labels. */
130
131static struct label_line *labels;
132
133/* The current label. */
134
135static struct label_line *current_label;
136
60fed2d3
NC		 137/* Pointer to list holding the opcodes sorted by name. */
138static struct m68k_opcode const ** m68k_sorted_opcodes;
139
36759679
NC		 140/* Its an arbitrary name: This means I don't approve of it.
141 See flames below. */
252b5132
RH		 142static struct obstack robyn;
143
252b5132
RH		 144struct m68k_incant
145 {
146 const char *m_operands;
147 unsigned long m_opcode;
148 short m_opnum;
149 short m_codenum;
150 int m_arch;
151 struct m68k_incant *m_next;
152 };
153
154#define getone(x) ((((x)->m_opcode)>>16)&0xffff)
155#define gettwo(x) (((x)->m_opcode)&0xffff)
156
157static const enum m68k_register m68000_control_regs[] = { 0 };
158static const enum m68k_register m68010_control_regs[] = {
159 SFC, DFC, USP, VBR,
160 0
161};
162static const enum m68k_register m68020_control_regs[] = {
163 SFC, DFC, USP, VBR, CACR, CAAR, MSP, ISP,
164 0
165};
166static const enum m68k_register m68040_control_regs[] = {
167 SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1,
168 USP, VBR, MSP, ISP, MMUSR, URP, SRP,
169 0
170};
171static const enum m68k_register m68060_control_regs[] = {
172 SFC, DFC, CACR, TC, ITT0, ITT1, DTT0, DTT1, BUSCR,
173 USP, VBR, URP, SRP, PCR,
174 0
175};
6da466c7 176static const enum m68k_register mcf_control_regs[] = {
3e602632 177 CACR, TC, ACR0, ACR1, ACR2, ACR3, VBR, ROMBAR,
252b5132
RH		 178 RAMBAR0, RAMBAR1, MBAR,
179 0
180};
e80e0390
NC		 181static const enum m68k_register mcf5249_control_regs[] = {
182 CACR, ACR0, ACR1, VBR, RAMBAR0, RAMBAR1, MBAR, MBAR2,
183 0
184};
3e602632
NC		 185static const enum m68k_register mcf528x_control_regs[] = {
186 CACR, ACR0, ACR1, VBR, FLASHBAR, RAMBAR,
187 0
188};
189static const enum m68k_register mcfv4e_control_regs[] = {
190 CACR, TC, ITT0, ITT1, DTT0, DTT1, BUSCR, VBR, PC, ROMBAR,
191 ROMBAR1, RAMBAR0, RAMBAR1, MPCR, EDRAMBAR, SECMBAR, MBAR, MBAR0, MBAR1,
192 PCR1U0, PCR1L0, PCR1U1, PCR1L1, PCR2U0, PCR2L0, PCR2U1, PCR2L1,
193 PCR3U0, PCR3L0, PCR3U1, PCR3L1,
194 0
195};
252b5132
RH		 196#define cpu32_control_regs m68010_control_regs
197
198static const enum m68k_register *control_regs;
199
36759679 200/* Internal form of a 68020 instruction. */
252b5132
RH		 201struct m68k_it
202{
203 const char *error;
36759679 204 const char *args; /* List of opcode info. */
252b5132
RH		 205 int numargs;
206
36759679 207 int numo; /* Number of shorts in opcode. */
252b5132
RH		 208 short opcode[11];
209
210 struct m68k_op operands[6];
211
36759679 212 int nexp; /* Number of exprs in use. */
252b5132
RH		 213 struct m68k_exp exprs[4];
214
36759679 215 int nfrag; /* Number of frags we have to produce. */
252b5132
RH		 216 struct
217 {
36759679 218 int fragoff; /* Where in the current opcode the frag ends. */
252b5132
RH		 219 symbolS *fadd;
220 offsetT foff;
221 int fragty;
222 }
223 fragb[4];
224
36759679 225 int nrel; /* Num of reloc strucs in use. */
252b5132
RH		 226 struct
227 {
228 int n;
229 expressionS exp;
230 char wid;
231 char pcrel;
232 /* In a pc relative address the difference between the address
233 of the offset and the address that the offset is relative
234 to. This depends on the addressing mode. Basically this
235 is the value to put in the offset field to address the
236 first byte of the offset, without regarding the special
237 significance of some values (in the branch instruction, for
238 example). */
239 int pcrel_fix;
240#ifdef OBJ_ELF
241 /* Whether this expression needs special pic relocation, and if
242 so, which. */
243 enum pic_relocation pic_reloc;
244#endif
245 }
36759679 246 reloc[5]; /* Five is enough??? */
252b5132
RH		 247};
248
6b6e92f4 249#define cpu_of_arch(x) ((x) & (m68000up | mcfisa_a))
252b5132
RH		 250#define float_of_arch(x) ((x) & mfloat)
251#define mmu_of_arch(x) ((x) & mmmu)
6b6e92f4
NC		 252#define arch_coldfire_p(x) ((x) & mcfisa_a)
253#define arch_coldfire_fpu(x) ((x) & cfloat)
252b5132 254
36759679 255/* Macros for determining if cpu supports a specific addressing mode. */
6b6e92f4 256#define HAVE_LONG_BRANCH(x) ((x) & (m68020|m68030|m68040|m68060|cpu32|mcfisa_b))
252b5132 257
36759679 258static struct m68k_it the_ins; /* The instruction being assembled. */
252b5132
RH		 259
260#define op(ex) ((ex)->exp.X_op)
261#define adds(ex) ((ex)->exp.X_add_symbol)
262#define subs(ex) ((ex)->exp.X_op_symbol)
263#define offs(ex) ((ex)->exp.X_add_number)
264
36759679 265/* Macros for adding things to the m68k_it struct. */
31302357 266#define addword(w) (the_ins.opcode[the_ins.numo++] = (w))
252b5132 267
36759679
NC		 268/* Like addword, but goes BEFORE general operands. */
269
252b5132 270static void
31302357 271insop (int w, const struct m68k_incant *opcode)
252b5132
RH		 272{
273 int z;
07726851 274 for (z = the_ins.numo; z > opcode->m_codenum; --z)
8a104df9
KH		 275 the_ins.opcode[z] = the_ins.opcode[z - 1];
276 for (z = 0; z < the_ins.nrel; z++)
277 the_ins.reloc[z].n += 2;
252b5132
RH		 278 for (z = 0; z < the_ins.nfrag; z++)
279 the_ins.fragb[z].fragoff++;
8a104df9 280 the_ins.opcode[opcode->m_codenum] = w;
252b5132
RH		 281 the_ins.numo++;
282}
283
284/* The numo+1 kludge is so we can hit the low order byte of the prev word.
285 Blecch. */
286static void
31302357 287add_fix (int width, struct m68k_exp *exp, int pc_rel, int pc_fix)
252b5132 288{
31302357
AS		 289 the_ins.reloc[the_ins.nrel].n = (width == 'B' || width == '3'
290 ? the_ins.numo * 2 - 1
291 : (width == 'b'
292 ? the_ins.numo * 2 + 1
293 : the_ins.numo * 2));
252b5132
RH		 294 the_ins.reloc[the_ins.nrel].exp = exp->exp;
295 the_ins.reloc[the_ins.nrel].wid = width;
296 the_ins.reloc[the_ins.nrel].pcrel_fix = pc_fix;
297#ifdef OBJ_ELF
298 the_ins.reloc[the_ins.nrel].pic_reloc = exp->pic_reloc;
299#endif
300 the_ins.reloc[the_ins.nrel++].pcrel = pc_rel;
301}
302
303/* Cause an extra frag to be generated here, inserting up to 10 bytes
304 (that value is chosen in the frag_var call in md_assemble). TYPE
305 is the subtype of the frag to be generated; its primary type is
306 rs_machine_dependent.
307
308 The TYPE parameter is also used by md_convert_frag_1 and
309 md_estimate_size_before_relax. The appropriate type of fixup will
310 be emitted by md_convert_frag_1.
311
312 ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET. */
313static void
31302357 314add_frag (symbolS *add, offsetT off, int type)
252b5132 315{
8a104df9
KH		 316 the_ins.fragb[the_ins.nfrag].fragoff = the_ins.numo;
317 the_ins.fragb[the_ins.nfrag].fadd = add;
318 the_ins.fragb[the_ins.nfrag].foff = off;
319 the_ins.fragb[the_ins.nfrag++].fragty = type;
252b5132
RH		 320}
321
322#define isvar(ex) \
323 (op (ex) != O_constant && op (ex) != O_big)
324
31302357
AS		 325static char *crack_operand (char *str, struct m68k_op *opP);
326static int get_num (struct m68k_exp *exp, int ok);
327static int reverse_16_bits (int in);
328static int reverse_8_bits (int in);
329static void install_gen_operand (int mode, int val);
330static void install_operand (int mode, int val);
331static void s_bss (int);
332static void s_data1 (int);
333static void s_data2 (int);
334static void s_even (int);
335static void s_proc (int);
336static void s_chip (int);
337static void s_fopt (int);
338static void s_opt (int);
339static void s_reg (int);
340static void s_restore (int);
341static void s_save (int);
342static void s_mri_if (int);
343static void s_mri_else (int);
344static void s_mri_endi (int);
345static void s_mri_break (int);
346static void s_mri_next (int);
347static void s_mri_for (int);
348static void s_mri_endf (int);
349static void s_mri_repeat (int);
350static void s_mri_until (int);
351static void s_mri_while (int);
352static void s_mri_endw (int);
252b5132
RH		 353
354static int current_architecture;
6b6e92f4 355static int current_chip;
252b5132 356
dc84e067
NC		 357struct m68k_cpu
358 {
359 unsigned long arch;
6b6e92f4 360 unsigned long chip;
dc84e067
NC		 361 const char *name;
362 int alias;
363 };
252b5132 364
dc84e067
NC		 365static const struct m68k_cpu archs[] =
366 {
6b6e92f4
NC		 367 { m68000, m68000, "68000", 0 },
368 { m68010, m68010, "68010", 0 },
369 { m68020, m68020, "68020", 0 },
370 { m68030, m68030, "68030", 0 },
371 { m68040, m68040, "68040", 0 },
372 { m68060, m68060, "68060", 0 },
373 { cpu32, cpu32, "cpu32", 0 },
374 { m68881, m68881, "68881", 0 },
375 { m68851, m68851, "68851", 0 },
376 { mcfisa_a, mcf5200, "5200", 0 },
377 { mcfisa_a|mcfhwdiv|mcfmac, mcf5206e, "5206e", 0 },
378 { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf521x, "521x", 0 },
379 { mcfisa_a|mcfhwdiv|mcfemac, mcf5249, "5249", 0 },
380 { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac|mcfusp, mcf528x, "528x", 0 },
381 { mcfisa_a|mcfhwdiv|mcfmac, mcf5307, "5307", 0 },
382 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfmac, mcf5407, "5407", 0 },
383 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "547x", 0 },
384 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5480, "548x", 0 },
dc84e067
NC		 385 /* Aliases (effectively, so far as gas is concerned) for the above
386 cpus. */
6b6e92f4
NC		 387 { m68020, m68020, "68k", 1 },
388 { m68000, m68000, "68008", 1 },
389 { m68000, m68000, "68302", 1 },
390 { m68000, m68000, "68306", 1 },
391 { m68000, m68000, "68307", 1 },
392 { m68000, m68000, "68322", 1 },
393 { m68000, m68000, "68356", 1 },
394 { m68000, m68000, "68ec000", 1 },
395 { m68000, m68000, "68hc000", 1 },
396 { m68000, m68000, "68hc001", 1 },
397 { m68020, m68020, "68ec020", 1 },
398 { m68030, m68030, "68ec030", 1 },
399 { m68040, m68040, "68ec040", 1 },
400 { m68060, m68060, "68ec060", 1 },
401 { cpu32, cpu32, "68330", 1 },
402 { cpu32, cpu32, "68331", 1 },
403 { cpu32, cpu32, "68332", 1 },
404 { cpu32, cpu32, "68333", 1 },
405 { cpu32, cpu32, "68334", 1 },
406 { cpu32, cpu32, "68336", 1 },
407 { cpu32, cpu32, "68340", 1 },
408 { cpu32, cpu32, "68341", 1 },
409 { cpu32, cpu32, "68349", 1 },
410 { cpu32, cpu32, "68360", 1 },
411 { m68881, m68881, "68882", 1 },
412 { mcfisa_a, mcf5200, "5202", 1 },
413 { mcfisa_a, mcf5200, "5204", 1 },
414 { mcfisa_a, mcf5200, "5206", 1 },
415 { mcfisa_a|mcfhwdiv|mcfisa_aa|mcfemac, mcf521x, "5214", 1 },
416 { mcfisa_a|mcfhwdiv|mcfisa_aa|mcfemac, mcf521x, "5216", 1 },
417 { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac, mcf528x, "5280", 1 },
418 { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac, mcf528x, "5281", 1 },
419 { mcfisa_a|mcfisa_aa|mcfhwdiv|mcfemac, mcf528x, "5282", 1 },
420 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfmac, mcf5407, "cfv4", 1 },
421 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5470", 1 },
422 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5471", 1 },
423 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5472", 1 },
424 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5473", 1 },
425 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5474", 1 },
426 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5475", 1 },
427 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5480", 1 },
428 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5481", 1 },
429 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5482", 1 },
430 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5483", 1 },
431 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5484", 1 },
432 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "5485", 1 },
433 { mcfisa_a|mcfhwdiv|mcfisa_b|mcfemac|mcfusp|cfloat, mcf5470, "cfv4e", 1 },
dc84e067 434 };
252b5132
RH		 435
436static const int n_archs = sizeof (archs) / sizeof (archs[0]);
437
151337e8
NC		 438/* This is the assembler relaxation table for m68k. m68k is a rich CISC
439 architecture and we have a lot of relaxation modes. */
252b5132 440
151337e8
NC		 441/* Macros used in the relaxation code. */
442#define TAB(x,y) (((x) << 2) + (y))
443#define TABTYPE(x) ((x) >> 2)
444
445/* Relaxation states. */
446#define BYTE 0
447#define SHORT 1
448#define LONG 2
449#define SZ_UNDEF 3
450
451/* Here are all the relaxation modes we support. First we can relax ordinary
452 branches. On 68020 and higher and on CPU32 all branch instructions take
453 three forms, so on these CPUs all branches always remain as such. When we
454 have to expand to the LONG form on a 68000, though, we substitute an
455 absolute jump instead. This is a direct replacement for unconditional
456 branches and a branch over a jump for conditional branches. However, if the
457 user requires PIC and disables this with --pcrel, we can only relax between
458 BYTE and SHORT forms, punting if that isn't enough. This gives us four
459 different relaxation modes for branches: */
460
36759679
NC		 461#define BRANCHBWL 0 /* Branch byte, word, or long. */
462#define BRABSJUNC 1 /* Absolute jump for LONG, unconditional. */
463#define BRABSJCOND 2 /* Absolute jump for LONG, conditional. */
464#define BRANCHBW 3 /* Branch byte or word. */
151337e8
NC		 465
466/* We also relax coprocessor branches and DBcc's. All CPUs that support
467 coprocessor branches support them in word and long forms, so we have only
468 one relaxation mode for them. DBcc's are word only on all CPUs. We can
469 relax them to the LONG form with a branch-around sequence. This sequence
470 can use a long branch (if available) or an absolute jump (if acceptable).
471 This gives us two relaxation modes. If long branches are not available and
472 absolute jumps are not acceptable, we don't relax DBcc's. */
473
36759679
NC		 474#define FBRANCH 4 /* Coprocessor branch. */
475#define DBCCLBR 5 /* DBcc relaxable with a long branch. */
476#define DBCCABSJ 6 /* DBcc relaxable with an absolute jump. */
151337e8
NC		 477
478/* That's all for instruction relaxation. However, we also relax PC-relative
479 operands. Specifically, we have three operand relaxation modes. On the
480 68000 PC-relative operands can only be 16-bit, but on 68020 and higher and
481 on CPU32 they may be 16-bit or 32-bit. For the latter we relax between the
482 two. Also PC+displacement+index operands in their simple form (with a non-
483 suppressed index without memory indirection) are supported on all CPUs, but
484 on the 68000 the displacement can be 8-bit only, whereas on 68020 and higher
485 and on CPU32 we relax it to SHORT and LONG forms as well using the extended
486 form of the PC+displacement+index operand. Finally, some absolute operands
487 can be relaxed down to 16-bit PC-relative. */
488
36759679
NC		 489#define PCREL1632 7 /* 16-bit or 32-bit PC-relative. */
490#define PCINDEX 8 /* PC + displacement + index. */
491#define ABSTOPCREL 9 /* Absolute relax down to 16-bit PC-relative. */
252b5132
RH		 492
493/* Note that calls to frag_var need to specify the maximum expansion
494 needed; this is currently 10 bytes for DBCC. */
495
496/* The fields are:
497 How far Forward this mode will reach:
498 How far Backward this mode will reach:
499 How many bytes this mode will add to the size of the frag
500 Which mode to go to if the offset won't fit in this one
d7861ad2
AM		 501
502 Please check tc-m68k.h:md_prepare_relax_scan if changing this table. */
252b5132
RH		 503relax_typeS md_relax_table[] =
504{
ac62c346
AM		 505 { 127, -128, 0, TAB (BRANCHBWL, SHORT) },
506 { 32767, -32768, 2, TAB (BRANCHBWL, LONG) },
507 { 0, 0, 4, 0 },
508 { 1, 1, 0, 0 },
509
510 { 127, -128, 0, TAB (BRABSJUNC, SHORT) },
511 { 32767, -32768, 2, TAB (BRABSJUNC, LONG) },
512 { 0, 0, 4, 0 },
513 { 1, 1, 0, 0 },
514
515 { 127, -128, 0, TAB (BRABSJCOND, SHORT) },
516 { 32767, -32768, 2, TAB (BRABSJCOND, LONG) },
517 { 0, 0, 6, 0 },
518 { 1, 1, 0, 0 },
519
520 { 127, -128, 0, TAB (BRANCHBW, SHORT) },
521 { 0, 0, 2, 0 },
522 { 1, 1, 0, 0 },
523 { 1, 1, 0, 0 },
524
36759679 525 { 1, 1, 0, 0 }, /* FBRANCH doesn't come BYTE. */
ac62c346
AM		 526 { 32767, -32768, 2, TAB (FBRANCH, LONG) },
527 { 0, 0, 4, 0 },
528 { 1, 1, 0, 0 },
529
36759679 530 { 1, 1, 0, 0 }, /* DBCC doesn't come BYTE. */
ac62c346
AM		 531 { 32767, -32768, 2, TAB (DBCCLBR, LONG) },
532 { 0, 0, 10, 0 },
533 { 1, 1, 0, 0 },
534
36759679 535 { 1, 1, 0, 0 }, /* DBCC doesn't come BYTE. */
ac62c346
AM		 536 { 32767, -32768, 2, TAB (DBCCABSJ, LONG) },
537 { 0, 0, 10, 0 },
538 { 1, 1, 0, 0 },
539
36759679 540 { 1, 1, 0, 0 }, /* PCREL1632 doesn't come BYTE. */
ac62c346
AM		 541 { 32767, -32768, 2, TAB (PCREL1632, LONG) },
542 { 0, 0, 6, 0 },
543 { 1, 1, 0, 0 },
544
545 { 125, -130, 0, TAB (PCINDEX, SHORT) },
546 { 32765, -32770, 2, TAB (PCINDEX, LONG) },
547 { 0, 0, 4, 0 },
548 { 1, 1, 0, 0 },
549
36759679 550 { 1, 1, 0, 0 }, /* ABSTOPCREL doesn't come BYTE. */
ac62c346
AM		 551 { 32767, -32768, 2, TAB (ABSTOPCREL, LONG) },
552 { 0, 0, 4, 0 },
553 { 1, 1, 0, 0 },
252b5132
RH		 554};
555
556/* These are the machine dependent pseudo-ops. These are included so
557 the assembler can work on the output from the SUN C compiler, which
36759679 558 generates these. */
252b5132
RH		 559
560/* This table describes all the machine specific pseudo-ops the assembler
561 has to support. The fields are:
562 pseudo-op name without dot
563 function to call to execute this pseudo-op
36759679 564 Integer arg to pass to the function. */
252b5132
RH		 565const pseudo_typeS md_pseudo_table[] =
566{
567 {"data1", s_data1, 0},
568 {"data2", s_data2, 0},
569 {"bss", s_bss, 0},
570 {"even", s_even, 0},
571 {"skip", s_space, 0},
572 {"proc", s_proc, 0},
573#if defined (TE_SUN3) || defined (OBJ_ELF)
574 {"align", s_align_bytes, 0},
575#endif
576#ifdef OBJ_ELF
577 {"swbeg", s_ignore, 0},
578#endif
579 {"extend", float_cons, 'x'},
580 {"ldouble", float_cons, 'x'},
581
582 /* The following pseudo-ops are supported for MRI compatibility. */
583 {"chip", s_chip, 0},
584 {"comline", s_space, 1},
585 {"fopt", s_fopt, 0},
586 {"mask2", s_ignore, 0},
587 {"opt", s_opt, 0},
588 {"reg", s_reg, 0},
589 {"restore", s_restore, 0},
590 {"save", s_save, 0},
591
592 {"if", s_mri_if, 0},
593 {"if.b", s_mri_if, 'b'},
594 {"if.w", s_mri_if, 'w'},
595 {"if.l", s_mri_if, 'l'},
596 {"else", s_mri_else, 0},
597 {"else.s", s_mri_else, 's'},
598 {"else.l", s_mri_else, 'l'},
599 {"endi", s_mri_endi, 0},
600 {"break", s_mri_break, 0},
601 {"break.s", s_mri_break, 's'},
602 {"break.l", s_mri_break, 'l'},
603 {"next", s_mri_next, 0},
604 {"next.s", s_mri_next, 's'},
605 {"next.l", s_mri_next, 'l'},
606 {"for", s_mri_for, 0},
607 {"for.b", s_mri_for, 'b'},
608 {"for.w", s_mri_for, 'w'},
609 {"for.l", s_mri_for, 'l'},
610 {"endf", s_mri_endf, 0},
611 {"repeat", s_mri_repeat, 0},
612 {"until", s_mri_until, 0},
613 {"until.b", s_mri_until, 'b'},
614 {"until.w", s_mri_until, 'w'},
615 {"until.l", s_mri_until, 'l'},
616 {"while", s_mri_while, 0},
617 {"while.b", s_mri_while, 'b'},
618 {"while.w", s_mri_while, 'w'},
619 {"while.l", s_mri_while, 'l'},
620 {"endw", s_mri_endw, 0},
621
622 {0, 0, 0}
623};
624
252b5132 625/* The mote pseudo ops are put into the opcode table, since they
31302357 626 don't start with a . they look like opcodes to gas. */
252b5132 627
5a38dc70 628const pseudo_typeS mote_pseudo_table[] =
252b5132
RH		 629{
630
631 {"dcl", cons, 4},
632 {"dc", cons, 2},
633 {"dcw", cons, 2},
634 {"dcb", cons, 1},
635
636 {"dsl", s_space, 4},
637 {"ds", s_space, 2},
638 {"dsw", s_space, 2},
639 {"dsb", s_space, 1},
640
641 {"xdef", s_globl, 0},
642#ifdef OBJ_ELF
643 {"align", s_align_bytes, 0},
644#else
645 {"align", s_align_ptwo, 0},
646#endif
647#ifdef M68KCOFF
648 {"sect", obj_coff_section, 0},
649 {"section", obj_coff_section, 0},
650#endif
651 {0, 0, 0}
652};
653
bd17c2c3
AM		 654/* Truncate and sign-extend at 32 bits, so that building on a 64-bit host
655 gives identical results to a 32-bit host. */
656#define TRUNC(X) ((valueT) (X) & 0xffffffff)
657#define SEXT(X) ((TRUNC (X) ^ 0x80000000) - 0x80000000)
658
659#define issbyte(x) ((valueT) SEXT (x) + 0x80 < 0x100)
660#define isubyte(x) ((valueT) TRUNC (x) < 0x100)
661#define issword(x) ((valueT) SEXT (x) + 0x8000 < 0x10000)
662#define isuword(x) ((valueT) TRUNC (x) < 0x10000)
663
664#define isbyte(x) ((valueT) SEXT (x) + 0xff < 0x1ff)
665#define isword(x) ((valueT) SEXT (x) + 0xffff < 0x1ffff)
252b5132
RH		 666#define islong(x) (1)
667
252b5132
RH		 668static char notend_table[256];
669static char alt_notend_table[256];
670#define notend(s) \
671 (! (notend_table[(unsigned char) *s] \
672 || (*s == ':' \
673 && alt_notend_table[(unsigned char) s[1]])))
674
6b6e92f4
NC		 675/* Return a human readable string holding the list of chips that are
676 valid for a particular architecture, suppressing aliases (unless
677 there is only one of them). */
678
679static char *
680find_cf_chip (int architecture)
681{
682 static char buf[1024];
683 int i, j, n_chips, n_alias;
684 char *cp;
685
686 strcpy (buf, " (");
687 cp = buf + strlen (buf);
688
689 for (i = 0, n_chips = 0, n_alias = 0; i < n_archs; ++i)
690 if (archs[i].arch & architecture)
691 {
692 n_chips++;
693 if (archs[i].alias)
694 n_alias++;
695 }
696
697 if (n_chips == 0)
698 as_fatal (_("no matching ColdFire architectures found"));
699
700 if (n_alias > 1)
701 n_chips -= n_alias;
702
703 for (i = 0, j = 0; i < n_archs && j < n_chips; ++i)
704 if (archs[i].arch & architecture)
705 {
706 if (j)
707 {
31302357 708 if ((j == n_chips - 1 && !(n_alias > 1)) || ! n_alias)
6b6e92f4
NC		 709 {
710 if (n_chips == 2)
711 {
712 strncpy (cp, _(" or "), (sizeof (buf) - (cp - buf)));
713 cp += strlen (cp);
714 }
715 else
716 {
717 strncpy (cp, _(", or "), (sizeof (buf) - (cp - buf)));
718 cp += strlen (cp);
719 }
720 }
721 else
722 {
723 strncpy (cp, ", ", (sizeof (buf) - (cp - buf)));
724 cp += strlen (cp);
725 }
726 }
727 strncpy (cp, archs[i].name, (sizeof (buf) - (cp - buf)));
728 cp += strlen (cp);
729 j++;
730 }
731
732 if (n_alias > 1)
733 {
734 strncpy (cp, _(", or aliases"), (sizeof (buf) - (cp - buf)));
735 cp += strlen (cp);
736 }
737
738 strncpy (cp, ")", (sizeof (buf) - (cp - buf)));
739
740 return buf;
741}
742
252b5132
RH		 743#if defined (M68KCOFF) && !defined (BFD_ASSEMBLER)
744
745#ifdef NO_PCREL_RELOCS
746
747int
31302357 748make_pcrel_absolute (fixS *fixP, long *add_number)
252b5132
RH		 749{
750 register unsigned char *opcode = fixP->fx_frag->fr_opcode;
751
36759679 752 /* Rewrite the PC relative instructions to absolute address ones.
67c1ffbe 753 these are rumored to be faster, and the apollo linker refuses
36759679
NC		 754 to deal with the PC relative relocations. */
755 if (opcode[0] == 0x60 && opcode[1] == 0xff) /* BRA -> JMP. */
252b5132 756 {
36759679 757 if (flag_keep_pcrel)
6b6e92f4 758 as_fatal (_("Tried to convert PC relative branch to absolute jump"));
252b5132
RH		 759 opcode[0] = 0x4e;
760 opcode[1] = 0xf9;
761 }
36759679 762 else if (opcode[0] == 0x61 && opcode[1] == 0xff) /* BSR -> JSR. */
252b5132 763 {
36759679 764 if (flag_keep_pcrel)
6b6e92f4 765 as_fatal (_("Tried to convert PC relative BSR to absolute JSR"));
252b5132
RH		 766 opcode[0] = 0x4e;
767 opcode[1] = 0xb9;
768 }
769 else
770 as_fatal (_("Unknown PC relative instruction"));
771 *add_number -= 4;
772 return 0;
773}
774
775#endif /* NO_PCREL_RELOCS */
776
777short
31302357 778tc_coff_fix2rtype (fixS *fixP)
252b5132
RH		 779{
780 if (fixP->fx_tcbit && fixP->fx_size == 4)
781 return R_RELLONG_NEG;
782#ifdef NO_PCREL_RELOCS
783 know (fixP->fx_pcrel == 0);
784 return (fixP->fx_size == 1 ? R_RELBYTE
785 : fixP->fx_size == 2 ? R_DIR16
786 : R_DIR32);
787#else
31302357
AS		 788 return (fixP->fx_pcrel
789 ? (fixP->fx_size == 1 ? R_PCRBYTE
790 : fixP->fx_size == 2 ? R_PCRWORD
791 : R_PCRLONG)
792 : (fixP->fx_size == 1 ? R_RELBYTE
793 : fixP->fx_size == 2 ? R_RELWORD
794 : R_RELLONG));
252b5132
RH		 795#endif
796}
797
798#endif
799
800#ifdef OBJ_ELF
801
c801568a
AM		 802/* Return zero if the reference to SYMBOL from within the same segment may
803 be relaxed. */
804
805/* On an ELF system, we can't relax an externally visible symbol,
806 because it may be overridden by a shared library. However, if
807 TARGET_OS is "elf", then we presume that we are assembling for an
808 embedded system, in which case we don't have to worry about shared
809 libraries, and we can relax any external sym. */
810
811#define relaxable_symbol(symbol) \
6358301e 812 (!((S_IS_EXTERNAL (symbol) && EXTERN_FORCE_RELOC) \
c801568a
AM		 813 || S_IS_WEAK (symbol)))
814
252b5132
RH		 815/* Compute the relocation code for a fixup of SIZE bytes, using pc
816 relative relocation if PCREL is non-zero. PIC says whether a special
817 pic relocation was requested. */
818
252b5132 819static bfd_reloc_code_real_type
31302357 820get_reloc_code (int size, int pcrel, enum pic_relocation pic)
252b5132
RH		 821{
822 switch (pic)
823 {
824 case pic_got_pcrel:
825 switch (size)
826 {
827 case 1:
828 return BFD_RELOC_8_GOT_PCREL;
829 case 2:
830 return BFD_RELOC_16_GOT_PCREL;
831 case 4:
832 return BFD_RELOC_32_GOT_PCREL;
833 }
834 break;
835
836 case pic_got_off:
837 switch (size)
838 {
839 case 1:
840 return BFD_RELOC_8_GOTOFF;
841 case 2:
842 return BFD_RELOC_16_GOTOFF;
843 case 4:
844 return BFD_RELOC_32_GOTOFF;
845 }
846 break;
847
848 case pic_plt_pcrel:
849 switch (size)
850 {
851 case 1:
852 return BFD_RELOC_8_PLT_PCREL;
853 case 2:
854 return BFD_RELOC_16_PLT_PCREL;
855 case 4:
856 return BFD_RELOC_32_PLT_PCREL;
857 }
858 break;
859
860 case pic_plt_off:
861 switch (size)
862 {
863 case 1:
864 return BFD_RELOC_8_PLTOFF;
865 case 2:
866 return BFD_RELOC_16_PLTOFF;
867 case 4:
868 return BFD_RELOC_32_PLTOFF;
869 }
870 break;
871
872 case pic_none:
873 if (pcrel)
874 {
875 switch (size)
876 {
877 case 1:
878 return BFD_RELOC_8_PCREL;
879 case 2:
880 return BFD_RELOC_16_PCREL;
881 case 4:
882 return BFD_RELOC_32_PCREL;
883 }
884 }
885 else
886 {
887 switch (size)
888 {
889 case 1:
890 return BFD_RELOC_8;
891 case 2:
892 return BFD_RELOC_16;
893 case 4:
894 return BFD_RELOC_32;
895 }
896 }
897 }
898
899 if (pcrel)
900 {
901 if (pic == pic_none)
902 as_bad (_("Can not do %d byte pc-relative relocation"), size);
903 else
904 as_bad (_("Can not do %d byte pc-relative pic relocation"), size);
905 }
906 else
907 {
908 if (pic == pic_none)
909 as_bad (_("Can not do %d byte relocation"), size);
910 else
911 as_bad (_("Can not do %d byte pic relocation"), size);
912 }
913
914 return BFD_RELOC_NONE;
915}
916
917/* Here we decide which fixups can be adjusted to make them relative
918 to the beginning of the section instead of the symbol. Basically
919 we need to make sure that the dynamic relocations are done
920 correctly, so in some cases we force the original symbol to be
921 used. */
922int
31302357 923tc_m68k_fix_adjustable (fixS *fixP)
252b5132 924{
36759679 925 /* Adjust_reloc_syms doesn't know about the GOT. */
252b5132
RH		 926 switch (fixP->fx_r_type)
927 {
928 case BFD_RELOC_8_GOT_PCREL:
929 case BFD_RELOC_16_GOT_PCREL:
930 case BFD_RELOC_32_GOT_PCREL:
931 case BFD_RELOC_8_GOTOFF:
932 case BFD_RELOC_16_GOTOFF:
933 case BFD_RELOC_32_GOTOFF:
934 case BFD_RELOC_8_PLT_PCREL:
935 case BFD_RELOC_16_PLT_PCREL:
936 case BFD_RELOC_32_PLT_PCREL:
937 case BFD_RELOC_8_PLTOFF:
938 case BFD_RELOC_16_PLTOFF:
939 case BFD_RELOC_32_PLTOFF:
940 return 0;
941
942 case BFD_RELOC_VTABLE_INHERIT:
943 case BFD_RELOC_VTABLE_ENTRY:
944 return 0;
945
946 default:
947 return 1;
948 }
949}
950
951#else /* !OBJ_ELF */
952
953#define get_reloc_code(SIZE,PCREL,OTHER) NO_RELOC
954
c801568a
AM		 955#define relaxable_symbol(symbol) 1
956
252b5132
RH		 957#endif /* OBJ_ELF */
958
959#ifdef BFD_ASSEMBLER
960
961arelent *
31302357 962tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
252b5132
RH		 963{
964 arelent *reloc;
965 bfd_reloc_code_real_type code;
966
8ec6253e
NC		 967 /* If the tcbit is set, then this was a fixup of a negative value
968 that was never resolved. We do not have a reloc to handle this,
969 so just return. We assume that other code will have detected this
970 situation and produced a helpful error message, so we just tell the
971 user that the reloc cannot be produced. */
252b5132 972 if (fixp->fx_tcbit)
8ec6253e
NC		 973 {
974 if (fixp->fx_addsy)
b091f402
AM		 975 as_bad_where (fixp->fx_file, fixp->fx_line,
976 _("Unable to produce reloc against symbol '%s'"),
977 S_GET_NAME (fixp->fx_addsy));
8ec6253e
NC		 978 return NULL;
979 }
252b5132
RH		 980
981 if (fixp->fx_r_type != BFD_RELOC_NONE)
982 {
983 code = fixp->fx_r_type;
984
985 /* Since DIFF_EXPR_OK is defined in tc-m68k.h, it is possible
986 that fixup_segment converted a non-PC relative reloc into a
987 PC relative reloc. In such a case, we need to convert the
988 reloc code. */
989 if (fixp->fx_pcrel)
990 {
991 switch (code)
992 {
993 case BFD_RELOC_8:
994 code = BFD_RELOC_8_PCREL;
995 break;
996 case BFD_RELOC_16:
997 code = BFD_RELOC_16_PCREL;
998 break;
999 case BFD_RELOC_32:
1000 code = BFD_RELOC_32_PCREL;
1001 break;
1002 case BFD_RELOC_8_PCREL:
1003 case BFD_RELOC_16_PCREL:
1004 case BFD_RELOC_32_PCREL:
1005 case BFD_RELOC_8_GOT_PCREL:
1006 case BFD_RELOC_16_GOT_PCREL:
1007 case BFD_RELOC_32_GOT_PCREL:
1008 case BFD_RELOC_8_GOTOFF:
1009 case BFD_RELOC_16_GOTOFF:
1010 case BFD_RELOC_32_GOTOFF:
1011 case BFD_RELOC_8_PLT_PCREL:
1012 case BFD_RELOC_16_PLT_PCREL:
1013 case BFD_RELOC_32_PLT_PCREL:
1014 case BFD_RELOC_8_PLTOFF:
1015 case BFD_RELOC_16_PLTOFF:
1016 case BFD_RELOC_32_PLTOFF:
1017 break;
1018 default:
1019 as_bad_where (fixp->fx_file, fixp->fx_line,
1020 _("Cannot make %s relocation PC relative"),
1021 bfd_get_reloc_code_name (code));
1022 }
1023 }
1024 }
1025 else
1026 {
1027#define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
1028 switch (F (fixp->fx_size, fixp->fx_pcrel))
1029 {
1030#define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
1031 MAP (1, 0, BFD_RELOC_8);
1032 MAP (2, 0, BFD_RELOC_16);
1033 MAP (4, 0, BFD_RELOC_32);
1034 MAP (1, 1, BFD_RELOC_8_PCREL);
1035 MAP (2, 1, BFD_RELOC_16_PCREL);
1036 MAP (4, 1, BFD_RELOC_32_PCREL);
1037 default:
1038 abort ();
1039 }
1040 }
1041#undef F
1042#undef MAP
1043
1044 reloc = (arelent *) xmalloc (sizeof (arelent));
49309057
ILT		 1045 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1046 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
252b5132
RH		 1047 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
1048#ifndef OBJ_ELF
1049 if (fixp->fx_pcrel)
1050 reloc->addend = fixp->fx_addnumber;
1051 else
1052 reloc->addend = 0;
1053#else
1054 if (!fixp->fx_pcrel)
1055 reloc->addend = fixp->fx_addnumber;
1056 else
1057 reloc->addend = (section->vma
8390138c
AS		 1058 /* Explicit sign extension in case char is
1059 unsigned. */
1060 + ((fixp->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80
252b5132
RH		 1061 + fixp->fx_addnumber
1062 + md_pcrel_from (fixp));
1063#endif
1064
1065 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
1066 assert (reloc->howto != 0);
1067
1068 return reloc;
1069}
1070
1071#endif /* BFD_ASSEMBLER */
1072
252b5132
RH		 1073/* Handle of the OPCODE hash table. NULL means any use before
1074 m68k_ip_begin() will crash. */
1075static struct hash_control *op_hash;
1076\f
1077/* Assemble an m68k instruction. */
1078
1079static void
31302357 1080m68k_ip (char *instring)
252b5132
RH		 1081{
1082 register char *p;
1083 register struct m68k_op *opP;
1084 register const struct m68k_incant *opcode;
1085 register const char *s;
1086 register int tmpreg = 0, baseo = 0, outro = 0, nextword;
1087 char *pdot, *pdotmove;
1088 enum m68k_size siz1, siz2;
1089 char c;
1090 int losing;
1091 int opsfound;
1092 LITTLENUM_TYPE words[6];
1093 LITTLENUM_TYPE *wordp;
1094 unsigned long ok_arch = 0;
1095
1096 if (*instring == ' ')
36759679 1097 instring++; /* Skip leading whitespace. */
252b5132
RH		 1098
1099 /* Scan up to end of operation-code, which MUST end in end-of-string
92774660 1100 or exactly 1 space. */
252b5132
RH		 1101 pdot = 0;
1102 for (p = instring; *p != '\0'; p++)
1103 {
1104 if (*p == ' ')
1105 break;
1106 if (*p == '.')
1107 pdot = p;
1108 }
1109
1110 if (p == instring)
1111 {
1112 the_ins.error = _("No operator");
1113 return;
1114 }
1115
1116 /* p now points to the end of the opcode name, probably whitespace.
1117 Make sure the name is null terminated by clobbering the
1118 whitespace, look it up in the hash table, then fix it back.
1119 Remove a dot, first, since the opcode tables have none. */
1120 if (pdot != NULL)
1121 {
1122 for (pdotmove = pdot; pdotmove < p; pdotmove++)
1123 *pdotmove = pdotmove[1];
1124 p--;
1125 }
1126
1127 c = *p;
1128 *p = '\0';
1129 opcode = (const struct m68k_incant *) hash_find (op_hash, instring);
1130 *p = c;
1131
1132 if (pdot != NULL)
1133 {
1134 for (pdotmove = p; pdotmove > pdot; pdotmove--)
1135 *pdotmove = pdotmove[-1];
1136 *pdot = '.';
1137 ++p;
1138 }
1139
1140 if (opcode == NULL)
1141 {
1142 the_ins.error = _("Unknown operator");
1143 return;
1144 }
1145
36759679 1146 /* Found a legitimate opcode, start matching operands. */
252b5132
RH		 1147 while (*p == ' ')
1148 ++p;
1149
1150 if (opcode->m_operands == 0)
1151 {
1152 char *old = input_line_pointer;
1153 *old = '\n';
1154 input_line_pointer = p;
36759679 1155 /* Ahh - it's a motorola style psuedo op. */
252b5132
RH		 1156 mote_pseudo_table[opcode->m_opnum].poc_handler
1157 (mote_pseudo_table[opcode->m_opnum].poc_val);
1158 input_line_pointer = old;
1159 *old = 0;
1160
1161 return;
1162 }
1163
1164 if (flag_mri && opcode->m_opnum == 0)
1165 {
1166 /* In MRI mode, random garbage is allowed after an instruction
1167 which accepts no operands. */
1168 the_ins.args = opcode->m_operands;
1169 the_ins.numargs = opcode->m_opnum;
1170 the_ins.numo = opcode->m_codenum;
1171 the_ins.opcode[0] = getone (opcode);
1172 the_ins.opcode[1] = gettwo (opcode);
1173 return;
1174 }
1175
1176 for (opP = &the_ins.operands[0]; *p; opP++)
1177 {
1178 p = crack_operand (p, opP);
1179
1180 if (opP->error)
1181 {
1182 the_ins.error = opP->error;
1183 return;
1184 }
1185 }
1186
1187 opsfound = opP - &the_ins.operands[0];
1188
1189 /* This ugly hack is to support the floating pt opcodes in their
1190 standard form. Essentially, we fake a first enty of type COP#1 */
1191 if (opcode->m_operands[0] == 'I')
1192 {
1193 int n;
1194
1195 for (n = opsfound; n > 0; --n)
1196 the_ins.operands[n] = the_ins.operands[n - 1];
1197
31302357 1198 memset (&the_ins.operands[0], '\0', sizeof (the_ins.operands[0]));
252b5132
RH		 1199 the_ins.operands[0].mode = CONTROL;
1200 the_ins.operands[0].reg = m68k_float_copnum;
1201 opsfound++;
1202 }
1203
36759679 1204 /* We've got the operands. Find an opcode that'll accept them. */
252b5132
RH		 1205 for (losing = 0;;)
1206 {
1207 /* If we didn't get the right number of ops, or we have no
92774660 1208 common model with this pattern then reject this pattern. */
252b5132
RH		 1209
1210 ok_arch |= opcode->m_arch;
1211 if (opsfound != opcode->m_opnum
1212 || ((opcode->m_arch & current_architecture) == 0))
1213 ++losing;
1214 else
1215 {
1216 for (s = opcode->m_operands, opP = &the_ins.operands[0];
1217 *s && !losing;
1218 s += 2, opP++)
1219 {
1220 /* Warning: this switch is huge! */
1221 /* I've tried to organize the cases into this order:
1222 non-alpha first, then alpha by letter. Lower-case
1223 goes directly before uppercase counterpart. */
1224 /* Code with multiple case ...: gets sorted by the lowest
1225 case ... it belongs to. I hope this makes sense. */
1226 switch (*s)
1227 {
1228 case '!':
1229 switch (opP->mode)
1230 {
1231 case IMMED:
1232 case DREG:
1233 case AREG:
1234 case FPREG:
1235 case CONTROL:
1236 case AINC:
1237 case ADEC:
1238 case REGLST:
1239 losing++;
1240 break;
1241 default:
1242 break;
1243 }
1244 break;
1245
1246 case '<':
1247 switch (opP->mode)
1248 {
1249 case DREG:
1250 case AREG:
1251 case FPREG:
1252 case CONTROL:
1253 case IMMED:
1254 case ADEC:
1255 case REGLST:
1256 losing++;
1257 break;
1258 default:
1259 break;
1260 }
1261 break;
1262
1263 case '>':
1264 switch (opP->mode)
1265 {
1266 case DREG:
1267 case AREG:
1268 case FPREG:
1269 case CONTROL:
1270 case IMMED:
1271 case AINC:
1272 case REGLST:
1273 losing++;
1274 break;
1275 case ABSL:
1276 break;
1277 default:
1278 if (opP->reg == PC
1279 || opP->reg == ZPC)
1280 losing++;
1281 break;
1282 }
1283 break;
1284
1285 case 'm':
1286 switch (opP->mode)
1287 {
1288 case DREG:
1289 case AREG:
1290 case AINDR:
1291 case AINC:
1292 case ADEC:
1293 break;
1294 default:
1295 losing++;
1296 }
8a104df9 1297 break;
252b5132
RH		 1298
1299 case 'n':
1300 switch (opP->mode)
1301 {
1302 case DISP:
1303 break;
1304 default:
1305 losing++;
1306 }
8a104df9 1307 break;
252b5132
RH		 1308
1309 case 'o':
1310 switch (opP->mode)
1311 {
1312 case BASE:
1313 case ABSL:
1314 case IMMED:
1315 break;
1316 default:
1317 losing++;
1318 }
8a104df9 1319 break;
252b5132
RH		 1320
1321 case 'p':
1322 switch (opP->mode)
1323 {
1324 case DREG:
1325 case AREG:
1326 case AINDR:
1327 case AINC:
1328 case ADEC:
1329 break;
1330 case DISP:
1331 if (opP->reg == PC || opP->reg == ZPC)
8a104df9 1332 losing++;
252b5132
RH		 1333 break;
1334 default:
1335 losing++;
1336 }
8a104df9 1337 break;
252b5132
RH		 1338
1339 case 'q':
1340 switch (opP->mode)
1341 {
1342 case DREG:
1343 case AINDR:
1344 case AINC:
1345 case ADEC:
1346 break;
1347 case DISP:
1348 if (opP->reg == PC || opP->reg == ZPC)
8a104df9 1349 losing++;
252b5132
RH		 1350 break;
1351 default:
1352 losing++;
1353 break;
1354 }
8a104df9 1355 break;
252b5132
RH		 1356
1357 case 'v':
1358 switch (opP->mode)
1359 {
1360 case DREG:
1361 case AINDR:
1362 case AINC:
1363 case ADEC:
1364 case ABSL:
1365 break;
1366 case DISP:
1367 if (opP->reg == PC || opP->reg == ZPC)
8a104df9 1368 losing++;
252b5132
RH		 1369 break;
1370 default:
1371 losing++;
1372 break;
1373 }
1374 break;
1375
1376 case '#':
1377 if (opP->mode != IMMED)
1378 losing++;
1379 else if (s[1] == 'b'
1380 && ! isvar (&opP->disp)
1381 && (opP->disp.exp.X_op != O_constant
1382 || ! isbyte (opP->disp.exp.X_add_number)))
1383 losing++;
1384 else if (s[1] == 'B'
1385 && ! isvar (&opP->disp)
1386 && (opP->disp.exp.X_op != O_constant
1387 || ! issbyte (opP->disp.exp.X_add_number)))
1388 losing++;
1389 else if (s[1] == 'w'
1390 && ! isvar (&opP->disp)
1391 && (opP->disp.exp.X_op != O_constant
1392 || ! isword (opP->disp.exp.X_add_number)))
1393 losing++;
1394 else if (s[1] == 'W'
1395 && ! isvar (&opP->disp)
1396 && (opP->disp.exp.X_op != O_constant
1397 || ! issword (opP->disp.exp.X_add_number)))
1398 losing++;
1399 break;
1400
1401 case '^':
1402 case 'T':
1403 if (opP->mode != IMMED)
1404 losing++;
1405 break;
1406
1407 case '$':
1408 if (opP->mode == AREG
1409 || opP->mode == CONTROL
1410 || opP->mode == FPREG
1411 || opP->mode == IMMED
1412 || opP->mode == REGLST
1413 || (opP->mode != ABSL
1414 && (opP->reg == PC
1415 || opP->reg == ZPC)))
1416 losing++;
1417 break;
1418
1419 case '%':
1420 if (opP->mode == CONTROL
1421 || opP->mode == FPREG
1422 || opP->mode == REGLST
1423 || opP->mode == IMMED
1424 || (opP->mode != ABSL
1425 && (opP->reg == PC
1426 || opP->reg == ZPC)))
1427 losing++;
1428 break;
1429
1430 case '&':
1431 switch (opP->mode)
1432 {
1433 case DREG:
1434 case AREG:
1435 case FPREG:
1436 case CONTROL:
1437 case IMMED:
1438 case AINC:
1439 case ADEC:
1440 case REGLST:
1441 losing++;
1442 break;
1443 case ABSL:
1444 break;
1445 default:
1446 if (opP->reg == PC
1447 || opP->reg == ZPC)
1448 losing++;
1449 break;
1450 }
1451 break;
1452
1453 case '*':
1454 if (opP->mode == CONTROL
1455 || opP->mode == FPREG
1456 || opP->mode == REGLST)
1457 losing++;
1458 break;
1459
1460 case '+':
1461 if (opP->mode != AINC)
1462 losing++;
1463 break;
1464
1465 case '-':
1466 if (opP->mode != ADEC)
1467 losing++;
1468 break;
1469
1470 case '/':
1471 switch (opP->mode)
1472 {
1473 case AREG:
1474 case CONTROL:
1475 case FPREG:
1476 case AINC:
1477 case ADEC:
1478 case IMMED:
1479 case REGLST:
1480 losing++;
1481 break;
1482 default:
1483 break;
1484 }
1485 break;
1486
1487 case ';':
1488 switch (opP->mode)
1489 {
1490 case AREG:
1491 case CONTROL:
1492 case FPREG:
1493 case REGLST:
1494 losing++;
1495 break;
1496 default:
1497 break;
1498 }
1499 break;
1500
1501 case '?':
1502 switch (opP->mode)
1503 {
1504 case AREG:
1505 case CONTROL:
1506 case FPREG:
1507 case AINC:
1508 case ADEC:
1509 case IMMED:
1510 case REGLST:
1511 losing++;
1512 break;
1513 case ABSL:
1514 break;
1515 default:
1516 if (opP->reg == PC || opP->reg == ZPC)
1517 losing++;
1518 break;
1519 }
1520 break;
1521
1522 case '@':
1523 switch (opP->mode)
1524 {
1525 case AREG:
1526 case CONTROL:
1527 case FPREG:
1528 case IMMED:
1529 case REGLST:
1530 losing++;
1531 break;
1532 default:
1533 break;
1534 }
1535 break;
1536
1537 case '~': /* For now! (JF FOO is this right?) */
1538 switch (opP->mode)
1539 {
1540 case DREG:
1541 case AREG:
1542 case CONTROL:
1543 case FPREG:
1544 case IMMED:
1545 case REGLST:
1546 losing++;
1547 break;
1548 case ABSL:
1549 break;
1550 default:
1551 if (opP->reg == PC
1552 || opP->reg == ZPC)
1553 losing++;
1554 break;
1555 }
1556 break;
1557
1558 case '3':
1559 if (opP->mode != CONTROL
1560 || (opP->reg != TT0 && opP->reg != TT1))
1561 losing++;
1562 break;
1563
1564 case 'A':
1565 if (opP->mode != AREG)
1566 losing++;
1567 break;
1568
1569 case 'a':
1570 if (opP->mode != AINDR)
1571 ++losing;
1572 break;
1573
fd99574b
NC		 1574 case '4':
1575 if (opP->mode != AINDR && opP->mode != AINC && opP->mode != ADEC
1576 && (opP->mode != DISP
1577 || opP->reg < ADDR0
1578 || opP->reg > ADDR7))
1579 ++losing;
1580 break;
1581
252b5132
RH		 1582 case 'B': /* FOO */
1583 if (opP->mode != ABSL
1584 || (flag_long_jumps
1585 && strncmp (instring, "jbsr", 4) == 0))
1586 losing++;
1587 break;
1588
3e602632
NC		 1589 case 'b':
1590 switch (opP->mode)
1591 {
1592 case IMMED:
1593 case ABSL:
1594 case AREG:
1595 case FPREG:
1596 case CONTROL:
1597 case POST:
1598 case PRE:
1599 case REGLST:
1600 losing++;
1601 break;
1602 default:
1603 break;
1604 }
1605 break;
1606
252b5132
RH		 1607 case 'C':
1608 if (opP->mode != CONTROL || opP->reg != CCR)
1609 losing++;
1610 break;
1611
1612 case 'd':
1613 if (opP->mode != DISP
1614 || opP->reg < ADDR0
1615 || opP->reg > ADDR7)
1616 losing++;
1617 break;
1618
1619 case 'D':
1620 if (opP->mode != DREG)
1621 losing++;
1622 break;
1623
6da466c7
ILT		 1624 case 'E':
1625 if (opP->reg != ACC)
1626 losing++;
1627 break;
1628
fd99574b
NC		 1629 case 'e':
1630 if (opP->reg != ACC && opP->reg != ACC1
1631 && opP->reg != ACC2 && opP->reg != ACC3)
1632 losing++;
1633 break;
1634
252b5132
RH		 1635 case 'F':
1636 if (opP->mode != FPREG)
1637 losing++;
1638 break;
1639
6da466c7
ILT		 1640 case 'G':
1641 if (opP->reg != MACSR)
1642 losing++;
1643 break;
1644
fd99574b
NC		 1645 case 'g':
1646 if (opP->reg != ACCEXT01 && opP->reg != ACCEXT23)
1647 losing++;
1648 break;
1649
6da466c7
ILT		 1650 case 'H':
1651 if (opP->reg != MASK)
1652 losing++;
1653 break;
1654
252b5132
RH		 1655 case 'I':
1656 if (opP->mode != CONTROL
1657 || opP->reg < COP0
1658 || opP->reg > COP7)
1659 losing++;
1660 break;
1661
fd99574b
NC		 1662 case 'i':
1663 if (opP->mode != LSH && opP->mode != RSH)
1664 losing++;
1665 break;
1666
252b5132
RH		 1667 case 'J':
1668 if (opP->mode != CONTROL
1669 || opP->reg < USP
1670 || opP->reg > last_movec_reg)
1671 losing++;
1672 else
1673 {
1674 const enum m68k_register *rp;
1675 for (rp = control_regs; *rp; rp++)
1676 if (*rp == opP->reg)
1677 break;
1678 if (*rp == 0)
1679 losing++;
1680 }
1681 break;
1682
1683 case 'k':
1684 if (opP->mode != IMMED)
1685 losing++;
1686 break;
1687
1688 case 'l':
1689 case 'L':
1690 if (opP->mode == DREG
1691 || opP->mode == AREG
1692 || opP->mode == FPREG)
1693 {
1694 if (s[1] == '8')
1695 losing++;
1696 else
1697 {
1698 switch (opP->mode)
1699 {
1700 case DREG:
1701 opP->mask = 1 << (opP->reg - DATA0);
1702 break;
1703 case AREG:
1704 opP->mask = 1 << (opP->reg - ADDR0 + 8);
1705 break;
1706 case FPREG:
1707 opP->mask = 1 << (opP->reg - FP0 + 16);
1708 break;
1709 default:
1710 abort ();
1711 }
1712 opP->mode = REGLST;
1713 }
1714 }
1715 else if (opP->mode == CONTROL)
1716 {
1717 if (s[1] != '8')
1718 losing++;
1719 else
1720 {
1721 switch (opP->reg)
1722 {
1723 case FPI:
1724 opP->mask = 1 << 24;
1725 break;
1726 case FPS:
1727 opP->mask = 1 << 25;
1728 break;
1729 case FPC:
1730 opP->mask = 1 << 26;
1731 break;
1732 default:
1733 losing++;
1734 break;
1735 }
1736 opP->mode = REGLST;
1737 }
1738 }
1739 else if (opP->mode != REGLST)
1740 losing++;
1741 else if (s[1] == '8' && (opP->mask & 0x0ffffff) != 0)
1742 losing++;
1743 else if (s[1] == '3' && (opP->mask & 0x7000000) != 0)
1744 losing++;
1745 break;
1746
1747 case 'M':
1748 if (opP->mode != IMMED)
1749 losing++;
1750 else if (opP->disp.exp.X_op != O_constant
1751 || ! issbyte (opP->disp.exp.X_add_number))
1752 losing++;
1753 else if (! m68k_quick
1754 && instring[3] != 'q'
1755 && instring[4] != 'q')
1756 losing++;
1757 break;
1758
1759 case 'O':
1760 if (opP->mode != DREG
1761 && opP->mode != IMMED
1762 && opP->mode != ABSL)
1763 losing++;
1764 break;
1765
1766 case 'Q':
1767 if (opP->mode != IMMED)
1768 losing++;
1769 else if (opP->disp.exp.X_op != O_constant
bd17c2c3 1770 || TRUNC (opP->disp.exp.X_add_number) - 1 > 7)
252b5132
RH		 1771 losing++;
1772 else if (! m68k_quick
1773 && (strncmp (instring, "add", 3) == 0
1774 || strncmp (instring, "sub", 3) == 0)
1775 && instring[3] != 'q')
1776 losing++;
1777 break;
1778
1779 case 'R':
1780 if (opP->mode != DREG && opP->mode != AREG)
1781 losing++;
1782 break;
1783
1784 case 'r':
1785 if (opP->mode != AINDR
1786 && (opP->mode != BASE
1787 || (opP->reg != 0
1788 && opP->reg != ZADDR0)
1789 || opP->disp.exp.X_op != O_absent
1790 || ((opP->index.reg < DATA0
1791 || opP->index.reg > DATA7)
1792 && (opP->index.reg < ADDR0
1793 || opP->index.reg > ADDR7))
1794 || opP->index.size != SIZE_UNSPEC
1795 || opP->index.scale != 1))
1796 losing++;
1797 break;
1798
1799 case 's':
1800 if (opP->mode != CONTROL
1801 || ! (opP->reg == FPI
1802 || opP->reg == FPS
1803 || opP->reg == FPC))
1804 losing++;
1805 break;
1806
1807 case 'S':
1808 if (opP->mode != CONTROL || opP->reg != SR)
1809 losing++;
1810 break;
1811
1812 case 't':
1813 if (opP->mode != IMMED)
1814 losing++;
1815 else if (opP->disp.exp.X_op != O_constant
bd17c2c3 1816 || TRUNC (opP->disp.exp.X_add_number) > 7)
252b5132
RH		 1817 losing++;
1818 break;
1819
1820 case 'U':
1821 if (opP->mode != CONTROL || opP->reg != USP)
1822 losing++;
1823 break;
1824
3e602632
NC		 1825 case 'x':
1826 if (opP->mode != IMMED)
1827 losing++;
1828 else if (opP->disp.exp.X_op != O_constant
bd17c2c3
AM		 1829 || (TRUNC (opP->disp.exp.X_add_number) != 0xffffffff
1830 && TRUNC (opP->disp.exp.X_add_number) - 1 > 6))
3e602632
NC		 1831 losing++;
1832 break;
1833
252b5132
RH		 1834 /* JF these are out of order. We could put them
1835 in order if we were willing to put up with
1836 bunches of #ifdef m68851s in the code.
1837
1838 Don't forget that you need these operands
1839 to use 68030 MMU instructions. */
1840#ifndef NO_68851
36759679 1841 /* Memory addressing mode used by pflushr. */
252b5132
RH		 1842 case '|':
1843 if (opP->mode == CONTROL
1844 || opP->mode == FPREG
1845 || opP->mode == DREG
1846 || opP->mode == AREG
1847 || opP->mode == REGLST)
1848 losing++;
1849 /* We should accept immediate operands, but they
1850 supposedly have to be quad word, and we don't
1851 handle that. I would like to see what a Motorola
1852 assembler does before doing something here. */
1853 if (opP->mode == IMMED)
1854 losing++;
1855 break;
1856
1857 case 'f':
1858 if (opP->mode != CONTROL
1859 || (opP->reg != SFC && opP->reg != DFC))
1860 losing++;
1861 break;
1862
1863 case '0':
1864 if (opP->mode != CONTROL || opP->reg != TC)
1865 losing++;
1866 break;
1867
1868 case '1':
1869 if (opP->mode != CONTROL || opP->reg != AC)
1870 losing++;
1871 break;
1872
1873 case '2':
1874 if (opP->mode != CONTROL
1875 || (opP->reg != CAL
1876 && opP->reg != VAL
1877 && opP->reg != SCC))
1878 losing++;
1879 break;
1880
1881 case 'V':
1882 if (opP->mode != CONTROL
1883 || opP->reg != VAL)
1884 losing++;
1885 break;
1886
1887 case 'W':
1888 if (opP->mode != CONTROL
1889 || (opP->reg != DRP
1890 && opP->reg != SRP
1891 && opP->reg != CRP))
1892 losing++;
1893 break;
1894
3e602632
NC		 1895 case 'w':
1896 switch (opP->mode)
1897 {
1898 case IMMED:
1899 case ABSL:
1900 case AREG:
1901 case DREG:
1902 case FPREG:
1903 case CONTROL:
1904 case POST:
1905 case PRE:
1906 case REGLST:
1907 losing++;
1908 break;
1909 default:
1910 break;
1911 }
1912 break;
1913
252b5132
RH		 1914 case 'X':
1915 if (opP->mode != CONTROL
1916 || (!(opP->reg >= BAD && opP->reg <= BAD + 7)
1917 && !(opP->reg >= BAC && opP->reg <= BAC + 7)))
1918 losing++;
1919 break;
1920
1921 case 'Y':
1922 if (opP->mode != CONTROL || opP->reg != PSR)
1923 losing++;
1924 break;
1925
1926 case 'Z':
1927 if (opP->mode != CONTROL || opP->reg != PCSR)
1928 losing++;
1929 break;
1930#endif
1931 case 'c':
1932 if (opP->mode != CONTROL
1933 || (opP->reg != NC
1934 && opP->reg != IC
1935 && opP->reg != DC
1936 && opP->reg != BC))
36759679 1937 losing++;
252b5132
RH		 1938 break;
1939
1940 case '_':
1941 if (opP->mode != ABSL)
1942 ++losing;
1943 break;
1944
6da466c7
ILT		 1945 case 'u':
1946 if (opP->reg < DATA0L || opP->reg > ADDR7U)
1947 losing++;
1948 /* FIXME: kludge instead of fixing parser:
1949 upper/lower registers are *not* CONTROL
92774660 1950 registers, but ordinary ones. */
6da466c7
ILT		 1951 if ((opP->reg >= DATA0L && opP->reg <= DATA7L)
1952 || (opP->reg >= DATA0U && opP->reg <= DATA7U))
1953 opP->mode = DREG;
1954 else
1955 opP->mode = AREG;
1956 break;
1957
3e602632
NC		 1958 case 'y':
1959 if (!(opP->mode == AINDR
31302357
AS		 1960 || (opP->mode == DISP
1961 && !(opP->reg == PC || opP->reg == ZPC))))
3e602632
NC		 1962 losing++;
1963 break;
1964
1965 case 'z':
1966 if (!(opP->mode == AINDR || opP->mode == DISP))
1967 losing++;
1968 break;
1969
252b5132
RH		 1970 default:
1971 abort ();
36759679 1972 }
252b5132
RH		 1973
1974 if (losing)
1975 break;
36759679
NC		 1976 }
1977 }
252b5132
RH		 1978
1979 if (!losing)
36759679 1980 break;
252b5132
RH		 1981
1982 opcode = opcode->m_next;
1983
1984 if (!opcode)
1985 {
1986 if (ok_arch
1987 && !(ok_arch & current_architecture))
1988 {
1989 char buf[200], *cp;
1990
6b6e92f4 1991 strncpy (buf,
31302357
AS		 1992 _("invalid instruction for this architecture; needs "),
1993 sizeof (buf));
252b5132
RH		 1994 cp = buf + strlen (buf);
1995 switch (ok_arch)
1996 {
6b6e92f4 1997 case mcfisa_a:
31302357
AS		 1998 strncpy (cp, _("ColdFire ISA_A"),
1999 sizeof (buf) - (cp - buf));
6b6e92f4 2000 cp += strlen (cp);
31302357
AS		 2001 strncpy (cp, find_cf_chip (ok_arch),
2002 sizeof (buf) - (cp - buf));
6b6e92f4
NC		 2003 cp += strlen (cp);
2004 break;
2005 case mcfhwdiv:
31302357
AS		 2006 strncpy (cp, _("ColdFire hardware divide"),
2007 sizeof (buf) - (cp - buf));
6b6e92f4 2008 cp += strlen (cp);
31302357
AS		 2009 strncpy (cp, find_cf_chip (ok_arch),
2010 sizeof (buf) - (cp - buf));
6b6e92f4
NC		 2011 cp += strlen (cp);
2012 break;
2013 case mcfisa_aa:
31302357
AS		 2014 strncpy (cp, _("ColdFire ISA_A+"),
2015 sizeof (buf) - (cp - buf));
6b6e92f4 2016 cp += strlen (cp);
31302357
AS		 2017 strncpy (cp, find_cf_chip (ok_arch),
2018 sizeof (buf) - (cp - buf));
6b6e92f4
NC		 2019 cp += strlen (cp);
2020 break;
2021 case mcfisa_b:
31302357
AS		 2022 strncpy (cp, _("ColdFire ISA_B"),
2023 sizeof (buf) - (cp - buf));
6b6e92f4 2024 cp += strlen (cp);
31302357
AS		 2025 strncpy (cp, find_cf_chip (ok_arch),
2026 sizeof (buf) - (cp - buf));
6b6e92f4
NC		 2027 cp += strlen (cp);
2028 break;
3e602632 2029 case cfloat:
31302357 2030 strncpy (cp, _("ColdFire fpu"), sizeof (buf) - (cp - buf));
6b6e92f4 2031 cp += strlen (cp);
31302357
AS		 2032 strncpy (cp, find_cf_chip (ok_arch),
2033 sizeof (buf) - (cp - buf));
6b6e92f4 2034 cp += strlen (cp);
3e602632 2035 break;
252b5132
RH		 2036 case mfloat:
2037 strcpy (cp, _("fpu (68040, 68060 or 68881/68882)"));
2038 break;
2039 case mmmu:
2040 strcpy (cp, _("mmu (68030 or 68851)"));
2041 break;
2042 case m68020up:
2043 strcpy (cp, _("68020 or higher"));
2044 break;
2045 case m68000up:
2046 strcpy (cp, _("68000 or higher"));
2047 break;
2048 case m68010up:
2049 strcpy (cp, _("68010 or higher"));
2050 break;
2051 default:
2052 {
2053 int got_one = 0, idx;
6b6e92f4
NC		 2054
2055 for (idx = 0; idx < n_archs; idx++)
252b5132
RH		 2056 {
2057 if ((archs[idx].arch & ok_arch)
2058 && ! archs[idx].alias)
2059 {
2060 if (got_one)
2061 {
2062 strcpy (cp, " or ");
2063 cp += strlen (cp);
2064 }
2065 got_one = 1;
2066 strcpy (cp, archs[idx].name);
2067 cp += strlen (cp);
2068 }
2069 }
2070 }
2071 }
2072 cp = xmalloc (strlen (buf) + 1);
2073 strcpy (cp, buf);
2074 the_ins.error = cp;
2075 }
2076 else
2077 the_ins.error = _("operands mismatch");
2078 return;
36759679 2079 }
252b5132
RH		 2080
2081 losing = 0;
2082 }
2083
36759679 2084 /* Now assemble it. */
252b5132
RH		 2085 the_ins.args = opcode->m_operands;
2086 the_ins.numargs = opcode->m_opnum;
2087 the_ins.numo = opcode->m_codenum;
2088 the_ins.opcode[0] = getone (opcode);
2089 the_ins.opcode[1] = gettwo (opcode);
2090
2091 for (s = the_ins.args, opP = &the_ins.operands[0]; *s; s += 2, opP++)
2092 {
2093 /* This switch is a doozy.
31302357 2094 Watch the first step; its a big one! */
252b5132
RH		 2095 switch (s[0])
2096 {
2097
2098 case '*':
2099 case '~':
2100 case '%':
2101 case ';':
2102 case '@':
2103 case '!':
2104 case '&':
2105 case '$':
2106 case '?':
2107 case '/':
2108 case '<':
2109 case '>':
3e602632 2110 case 'b':
252b5132
RH		 2111 case 'm':
2112 case 'n':
2113 case 'o':
2114 case 'p':
2115 case 'q':
2116 case 'v':
3e602632
NC		 2117 case 'w':
2118 case 'y':
2119 case 'z':
fd99574b 2120 case '4':
252b5132
RH		 2121#ifndef NO_68851
2122 case '|':
2123#endif
2124 switch (opP->mode)
2125 {
2126 case IMMED:
2127 tmpreg = 0x3c; /* 7.4 */
2128 if (strchr ("bwl", s[1]))
3e602632 2129 nextword = get_num (&opP->disp, 90);
252b5132
RH		 2130 else
2131 nextword = get_num (&opP->disp, 0);
2132 if (isvar (&opP->disp))
2133 add_fix (s[1], &opP->disp, 0, 0);
2134 switch (s[1])
2135 {
2136 case 'b':
2137 if (!isbyte (nextword))
2138 opP->error = _("operand out of range");
2139 addword (nextword);
2140 baseo = 0;
2141 break;
2142 case 'w':
2143 if (!isword (nextword))
2144 opP->error = _("operand out of range");
2145 addword (nextword);
2146 baseo = 0;
2147 break;
2148 case 'W':
2149 if (!issword (nextword))
2150 opP->error = _("operand out of range");
2151 addword (nextword);
2152 baseo = 0;
2153 break;
2154 case 'l':
2155 addword (nextword >> 16);
2156 addword (nextword);
2157 baseo = 0;
2158 break;
2159
2160 case 'f':
2161 baseo = 2;
2162 outro = 8;
2163 break;
2164 case 'F':
2165 baseo = 4;
2166 outro = 11;
2167 break;
2168 case 'x':
2169 baseo = 6;
2170 outro = 15;
2171 break;
2172 case 'p':
2173 baseo = 6;
2174 outro = -1;
2175 break;
2176 default:
2177 abort ();
2178 }
2179 if (!baseo)
2180 break;
2181
36759679 2182 /* We gotta put out some float. */
252b5132
RH		 2183 if (op (&opP->disp) != O_big)
2184 {
2185 valueT val;
2186 int gencnt;
2187
2188 /* Can other cases happen here? */
2189 if (op (&opP->disp) != O_constant)
2190 abort ();
2191
2192 val = (valueT) offs (&opP->disp);
2193 gencnt = 0;
2194 do
2195 {
2196 generic_bignum[gencnt] = (LITTLENUM_TYPE) val;
2197 val >>= LITTLENUM_NUMBER_OF_BITS;
2198 ++gencnt;
2199 }
2200 while (val != 0);
2201 offs (&opP->disp) = gencnt;
2202 }
2203 if (offs (&opP->disp) > 0)
2204 {
2205 if (offs (&opP->disp) > baseo)
2206 {
2207 as_warn (_("Bignum too big for %c format; truncated"),
2208 s[1]);
2209 offs (&opP->disp) = baseo;
2210 }
2211 baseo -= offs (&opP->disp);
2212 while (baseo--)
2213 addword (0);
2214 for (wordp = generic_bignum + offs (&opP->disp) - 1;
2215 offs (&opP->disp)--;
2216 --wordp)
2217 addword (*wordp);
2218 break;
2219 }
2220 gen_to_words (words, baseo, (long) outro);
2221 for (wordp = words; baseo--; wordp++)
2222 addword (*wordp);
2223 break;
2224 case DREG:
2225 tmpreg = opP->reg - DATA; /* 0.dreg */
2226 break;
2227 case AREG:
2228 tmpreg = 0x08 + opP->reg - ADDR; /* 1.areg */
2229 break;
2230 case AINDR:
2231 tmpreg = 0x10 + opP->reg - ADDR; /* 2.areg */
2232 break;
2233 case ADEC:
2234 tmpreg = 0x20 + opP->reg - ADDR; /* 4.areg */
2235 break;
2236 case AINC:
2237 tmpreg = 0x18 + opP->reg - ADDR; /* 3.areg */
2238 break;
2239 case DISP:
2240
3e602632 2241 nextword = get_num (&opP->disp, 90);
252b5132 2242
580b9172
NC		 2243 /* Convert mode 5 addressing with a zero offset into
2244 mode 2 addressing to reduce the instruction size by a
2245 word. */
2246 if (! isvar (&opP->disp)
2247 && (nextword == 0)
2248 && (opP->disp.size == SIZE_UNSPEC)
2249 && (opP->reg >= ADDR0)
2250 && (opP->reg <= ADDR7))
2251 {
2252 tmpreg = 0x10 + opP->reg - ADDR; /* 2.areg */
2253 break;
2254 }
2255
252b5132
RH		 2256 if (opP->reg == PC
2257 && ! isvar (&opP->disp)
2258 && m68k_abspcadd)
2259 {
2260 opP->disp.exp.X_op = O_symbol;
2261#ifndef BFD_ASSEMBLER
2262 opP->disp.exp.X_add_symbol = &abs_symbol;
2263#else
2264 opP->disp.exp.X_add_symbol =
2265 section_symbol (absolute_section);
2266#endif
2267 }
2268
36759679 2269 /* Force into index mode. Hope this works. */
252b5132
RH		 2270
2271 /* We do the first bit for 32-bit displacements, and the
2272 second bit for 16 bit ones. It is possible that we
2273 should make the default be WORD instead of LONG, but
2274 I think that'd break GCC, so we put up with a little
2275 inefficiency for the sake of working output. */
2276
2277 if (!issword (nextword)
2278 || (isvar (&opP->disp)
2279 && ((opP->disp.size == SIZE_UNSPEC
2280 && flag_short_refs == 0
2281 && cpu_of_arch (current_architecture) >= m68020
6da466c7 2282 && ! arch_coldfire_p (current_architecture))
252b5132
RH		 2283 || opP->disp.size == SIZE_LONG)))
2284 {
2285 if (cpu_of_arch (current_architecture) < m68020
6da466c7 2286 || arch_coldfire_p (current_architecture))
252b5132
RH		 2287 opP->error =
2288 _("displacement too large for this architecture; needs 68020 or higher");
2289 if (opP->reg == PC)
2290 tmpreg = 0x3B; /* 7.3 */
2291 else
2292 tmpreg = 0x30 + opP->reg - ADDR; /* 6.areg */
2293 if (isvar (&opP->disp))
2294 {
2295 if (opP->reg == PC)
2296 {
2297 if (opP->disp.size == SIZE_LONG
2298#ifdef OBJ_ELF
2299 /* If the displacement needs pic
2300 relocation it cannot be relaxed. */
2301 || opP->disp.pic_reloc != pic_none
2302#endif
2303 )
2304 {
2305 addword (0x0170);
2306 add_fix ('l', &opP->disp, 1, 2);
2307 }
2308 else
2309 {
2310 add_frag (adds (&opP->disp),
bd17c2c3 2311 SEXT (offs (&opP->disp)),
151337e8 2312 TAB (PCREL1632, SZ_UNDEF));
252b5132
RH		 2313 break;
2314 }
2315 }
2316 else
2317 {
2318 addword (0x0170);
2319 add_fix ('l', &opP->disp, 0, 0);
2320 }
2321 }
2322 else
2323 addword (0x0170);
2324 addword (nextword >> 16);
2325 }
2326 else
2327 {
2328 if (opP->reg == PC)
2329 tmpreg = 0x3A; /* 7.2 */
2330 else
2331 tmpreg = 0x28 + opP->reg - ADDR; /* 5.areg */
2332
2333 if (isvar (&opP->disp))
2334 {
2335 if (opP->reg == PC)
2336 {
2337 add_fix ('w', &opP->disp, 1, 0);
2338 }
2339 else
2340 add_fix ('w', &opP->disp, 0, 0);
2341 }
2342 }
2343 addword (nextword);
2344 break;
2345
2346 case POST:
2347 case PRE:
2348 case BASE:
2349 nextword = 0;
3e602632 2350 baseo = get_num (&opP->disp, 90);
252b5132 2351 if (opP->mode == POST || opP->mode == PRE)
3e602632 2352 outro = get_num (&opP->odisp, 90);
252b5132
RH		 2353 /* Figure out the `addressing mode'.
2354 Also turn on the BASE_DISABLE bit, if needed. */
2355 if (opP->reg == PC || opP->reg == ZPC)
2356 {
2357 tmpreg = 0x3b; /* 7.3 */
2358 if (opP->reg == ZPC)
2359 nextword |= 0x80;
2360 }
2361 else if (opP->reg == 0)
2362 {
2363 nextword |= 0x80;
2364 tmpreg = 0x30; /* 6.garbage */
2365 }
2366 else if (opP->reg >= ZADDR0 && opP->reg <= ZADDR7)
2367 {
2368 nextword |= 0x80;
2369 tmpreg = 0x30 + opP->reg - ZADDR0;
2370 }
2371 else
2372 tmpreg = 0x30 + opP->reg - ADDR; /* 6.areg */
2373
2374 siz1 = opP->disp.size;
2375 if (opP->mode == POST || opP->mode == PRE)
2376 siz2 = opP->odisp.size;
2377 else
2378 siz2 = SIZE_UNSPEC;
2379
36759679 2380 /* Index register stuff. */
252b5132
RH		 2381 if (opP->index.reg != 0
2382 && opP->index.reg >= DATA
2383 && opP->index.reg <= ADDR7)
2384 {
2385 nextword |= (opP->index.reg - DATA) << 12;
2386
2387 if (opP->index.size == SIZE_LONG
2388 || (opP->index.size == SIZE_UNSPEC
2389 && m68k_index_width_default == SIZE_LONG))
2390 nextword |= 0x800;
2391
92774660 2392 if ((opP->index.scale != 1
252b5132 2393 && cpu_of_arch (current_architecture) < m68020)
92774660 2394 || (opP->index.scale == 8
3e602632 2395 && (arch_coldfire_p (current_architecture)
6b6e92f4 2396 && !arch_coldfire_fpu (current_architecture))))
252b5132
RH		 2397 {
2398 opP->error =
2399 _("scale factor invalid on this architecture; needs cpu32 or 68020 or higher");
2400 }
2401
6da466c7
ILT		 2402 if (arch_coldfire_p (current_architecture)
2403 && opP->index.size == SIZE_WORD)
2404 opP->error = _("invalid index size for coldfire");
2405
252b5132
RH		 2406 switch (opP->index.scale)
2407 {
2408 case 1:
2409 break;
2410 case 2:
2411 nextword |= 0x200;
2412 break;
2413 case 4:
2414 nextword |= 0x400;
2415 break;
2416 case 8:
2417 nextword |= 0x600;
2418 break;
2419 default:
2420 abort ();
2421 }
2422 /* IF its simple,
2423 GET US OUT OF HERE! */
2424
2425 /* Must be INDEX, with an index register. Address
2426 register cannot be ZERO-PC, and either :b was
2427 forced, or we know it will fit. For a 68000 or
2428 68010, force this mode anyways, because the
2429 larger modes aren't supported. */
2430 if (opP->mode == BASE
2431 && ((opP->reg >= ADDR0
2432 && opP->reg <= ADDR7)
2433 || opP->reg == PC))
2434 {
2435 if (siz1 == SIZE_BYTE
2436 || cpu_of_arch (current_architecture) < m68020
6da466c7 2437 || arch_coldfire_p (current_architecture)
252b5132
RH		 2438 || (siz1 == SIZE_UNSPEC
2439 && ! isvar (&opP->disp)
2440 && issbyte (baseo)))
2441 {
2442 nextword += baseo & 0xff;
2443 addword (nextword);
2444 if (isvar (&opP->disp))
2445 {
2446 /* Do a byte relocation. If it doesn't
2447 fit (possible on m68000) let the
2448 fixup processing complain later. */
2449 if (opP->reg == PC)
2450 add_fix ('B', &opP->disp, 1, 1);
2451 else
2452 add_fix ('B', &opP->disp, 0, 0);
2453 }
2454 else if (siz1 != SIZE_BYTE)
2455 {
2456 if (siz1 != SIZE_UNSPEC)
2457 as_warn (_("Forcing byte displacement"));
2458 if (! issbyte (baseo))
2459 opP->error = _("byte displacement out of range");
2460 }
2461
2462 break;
2463 }
2464 else if (siz1 == SIZE_UNSPEC
2465 && opP->reg == PC
2466 && isvar (&opP->disp)
2467 && subs (&opP->disp) == NULL
2468#ifdef OBJ_ELF
2469 /* If the displacement needs pic
2470 relocation it cannot be relaxed. */
2471 && opP->disp.pic_reloc == pic_none
2472#endif
2473 )
2474 {
2475 /* The code in md_convert_frag_1 needs to be
2476 able to adjust nextword. Call frag_grow
2477 to ensure that we have enough space in
2478 the frag obstack to make all the bytes
2479 contiguous. */
2480 frag_grow (14);
8a104df9
KH		 2481 nextword += baseo & 0xff;
2482 addword (nextword);
bd17c2c3
AM		 2483 add_frag (adds (&opP->disp),
2484 SEXT (offs (&opP->disp)),
8a104df9 2485 TAB (PCINDEX, SZ_UNDEF));
252b5132
RH		 2486
2487 break;
8a104df9 2488 }
252b5132
RH		 2489 }
2490 }
2491 else
2492 {
36759679 2493 nextword |= 0x40; /* No index reg. */
252b5132
RH		 2494 if (opP->index.reg >= ZDATA0
2495 && opP->index.reg <= ZDATA7)
2496 nextword |= (opP->index.reg - ZDATA0) << 12;
2497 else if (opP->index.reg >= ZADDR0
2498 || opP->index.reg <= ZADDR7)
2499 nextword |= (opP->index.reg - ZADDR0 + 8) << 12;
2500 }
2501
2502 /* It isn't simple. */
2503
2504 if (cpu_of_arch (current_architecture) < m68020
6da466c7 2505 || arch_coldfire_p (current_architecture))
252b5132
RH		 2506 opP->error =
2507 _("invalid operand mode for this architecture; needs 68020 or higher");
2508
2509 nextword |= 0x100;
2510 /* If the guy specified a width, we assume that it is
2511 wide enough. Maybe it isn't. If so, we lose. */
2512 switch (siz1)
2513 {
2514 case SIZE_UNSPEC:
2515 if (isvar (&opP->disp)
2516 ? m68k_rel32
2517 : ! issword (baseo))
2518 {
2519 siz1 = SIZE_LONG;
2520 nextword |= 0x30;
2521 }
2522 else if (! isvar (&opP->disp) && baseo == 0)
2523 nextword |= 0x10;
2524 else
2525 {
2526 nextword |= 0x20;
2527 siz1 = SIZE_WORD;
2528 }
2529 break;
2530 case SIZE_BYTE:
2531 as_warn (_(":b not permitted; defaulting to :w"));
2532 /* Fall through. */
2533 case SIZE_WORD:
2534 nextword |= 0x20;
2535 break;
2536 case SIZE_LONG:
2537 nextword |= 0x30;
2538 break;
2539 }
2540
67c1ffbe 2541 /* Figure out inner displacement stuff. */
252b5132
RH		 2542 if (opP->mode == POST || opP->mode == PRE)
2543 {
2544 if (cpu_of_arch (current_architecture) & cpu32)
2545 opP->error = _("invalid operand mode for this architecture; needs 68020 or higher");
2546 switch (siz2)
2547 {
2548 case SIZE_UNSPEC:
2549 if (isvar (&opP->odisp)
2550 ? m68k_rel32
2551 : ! issword (outro))
2552 {
2553 siz2 = SIZE_LONG;
2554 nextword |= 0x3;
2555 }
2556 else if (! isvar (&opP->odisp) && outro == 0)
2557 nextword |= 0x1;
2558 else
2559 {
2560 nextword |= 0x2;
2561 siz2 = SIZE_WORD;
2562 }
2563 break;
2564 case 1:
2565 as_warn (_(":b not permitted; defaulting to :w"));
2566 /* Fall through. */
2567 case 2:
2568 nextword |= 0x2;
2569 break;
2570 case 3:
2571 nextword |= 0x3;
2572 break;
2573 }
2574 if (opP->mode == POST
2575 && (nextword & 0x40) == 0)
2576 nextword |= 0x04;
2577 }
2578 addword (nextword);
2579
2580 if (siz1 != SIZE_UNSPEC && isvar (&opP->disp))
2581 {
2582 if (opP->reg == PC || opP->reg == ZPC)
2583 add_fix (siz1 == SIZE_LONG ? 'l' : 'w', &opP->disp, 1, 2);
2584 else
2585 add_fix (siz1 == SIZE_LONG ? 'l' : 'w', &opP->disp, 0, 0);
2586 }
2587 if (siz1 == SIZE_LONG)
2588 addword (baseo >> 16);
2589 if (siz1 != SIZE_UNSPEC)
2590 addword (baseo);
2591
2592 if (siz2 != SIZE_UNSPEC && isvar (&opP->odisp))
2593 add_fix (siz2 == SIZE_LONG ? 'l' : 'w', &opP->odisp, 0, 0);
2594 if (siz2 == SIZE_LONG)
2595 addword (outro >> 16);
2596 if (siz2 != SIZE_UNSPEC)
2597 addword (outro);
2598
2599 break;
2600
2601 case ABSL:
3e602632 2602 nextword = get_num (&opP->disp, 90);
252b5132
RH		 2603 switch (opP->disp.size)
2604 {
2605 default:
2606 abort ();
2607 case SIZE_UNSPEC:
2608 if (!isvar (&opP->disp) && issword (offs (&opP->disp)))
2609 {
2610 tmpreg = 0x38; /* 7.0 */
2611 addword (nextword);
2612 break;
2613 }
252b5132
RH		 2614 if (isvar (&opP->disp)
2615 && !subs (&opP->disp)
2616 && adds (&opP->disp)
2617#ifdef OBJ_ELF
2618 /* If the displacement needs pic relocation it
2619 cannot be relaxed. */
2620 && opP->disp.pic_reloc == pic_none
2621#endif
252b5132
RH		 2622 && !flag_long_jumps
2623 && !strchr ("~%&$?", s[0]))
2624 {
2625 tmpreg = 0x3A; /* 7.2 */
2626 add_frag (adds (&opP->disp),
bd17c2c3 2627 SEXT (offs (&opP->disp)),
151337e8 2628 TAB (ABSTOPCREL, SZ_UNDEF));
252b5132
RH		 2629 break;
2630 }
36759679 2631 /* Fall through into long. */
252b5132
RH		 2632 case SIZE_LONG:
2633 if (isvar (&opP->disp))
2634 add_fix ('l', &opP->disp, 0, 0);
2635
2636 tmpreg = 0x39;/* 7.1 mode */
2637 addword (nextword >> 16);
2638 addword (nextword);
2639 break;
2640
2641 case SIZE_BYTE:
2642 as_bad (_("unsupported byte value; use a different suffix"));
2643 /* Fall through. */
36759679
NC		 2644
2645 case SIZE_WORD:
252b5132
RH		 2646 if (isvar (&opP->disp))
2647 add_fix ('w', &opP->disp, 0, 0);
2648
2649 tmpreg = 0x38;/* 7.0 mode */
2650 addword (nextword);
2651 break;
2652 }
2653 break;
2654 case CONTROL:
2655 case FPREG:
2656 default:
2657 as_bad (_("unknown/incorrect operand"));
bc805888 2658 /* abort (); */
252b5132 2659 }
fd99574b
NC		 2660
2661 /* If s[0] is '4', then this is for the mac instructions
2662 that can have a trailing_ampersand set. If so, set 0x100
2663 bit on tmpreg so install_gen_operand can check for it and
2664 set the appropriate bit (word2, bit 5). */
2665 if (s[0] == '4')
2666 {
2667 if (opP->trailing_ampersand)
2668 tmpreg |= 0x100;
2669 }
252b5132
RH		 2670 install_gen_operand (s[1], tmpreg);
2671 break;
2672
2673 case '#':
2674 case '^':
2675 switch (s[1])
2676 { /* JF: I hate floating point! */
2677 case 'j':
2678 tmpreg = 70;
2679 break;
2680 case '8':
2681 tmpreg = 20;
2682 break;
2683 case 'C':
2684 tmpreg = 50;
2685 break;
2686 case '3':
2687 default:
3e602632 2688 tmpreg = 90;
252b5132
RH		 2689 break;
2690 }
2691 tmpreg = get_num (&opP->disp, tmpreg);
2692 if (isvar (&opP->disp))
2693 add_fix (s[1], &opP->disp, 0, 0);
2694 switch (s[1])
2695 {
2696 case 'b': /* Danger: These do no check for
2697 certain types of overflow.
2698 user beware! */
2699 if (!isbyte (tmpreg))
2700 opP->error = _("out of range");
2701 insop (tmpreg, opcode);
2702 if (isvar (&opP->disp))
2703 the_ins.reloc[the_ins.nrel - 1].n =
2704 (opcode->m_codenum) * 2 + 1;
2705 break;
2706 case 'B':
2707 if (!issbyte (tmpreg))
2708 opP->error = _("out of range");
2709 the_ins.opcode[the_ins.numo - 1] |= tmpreg & 0xff;
2710 if (isvar (&opP->disp))
2711 the_ins.reloc[the_ins.nrel - 1].n = opcode->m_codenum * 2 - 1;
2712 break;
2713 case 'w':
2714 if (!isword (tmpreg))
2715 opP->error = _("out of range");
2716 insop (tmpreg, opcode);
2717 if (isvar (&opP->disp))
2718 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
2719 break;
2720 case 'W':
2721 if (!issword (tmpreg))
2722 opP->error = _("out of range");
2723 insop (tmpreg, opcode);
2724 if (isvar (&opP->disp))
2725 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
2726 break;
2727 case 'l':
2728 /* Because of the way insop works, we put these two out
2729 backwards. */
2730 insop (tmpreg, opcode);
2731 insop (tmpreg >> 16, opcode);
2732 if (isvar (&opP->disp))
2733 the_ins.reloc[the_ins.nrel - 1].n = (opcode->m_codenum) * 2;
2734 break;
2735 case '3':
2736 tmpreg &= 0xFF;
2737 case '8':
2738 case 'C':
2739 case 'j':
2740 install_operand (s[1], tmpreg);
2741 break;
2742 default:
2743 abort ();
2744 }
2745 break;
2746
2747 case '+':
2748 case '-':
2749 case 'A':
2750 case 'a':
2751 install_operand (s[1], opP->reg - ADDR);
2752 break;
2753
2754 case 'B':
3e602632 2755 tmpreg = get_num (&opP->disp, 90);
252b5132
RH		 2756 switch (s[1])
2757 {
2758 case 'B':
8390138c 2759 add_fix ('B', &opP->disp, 1, -1);
252b5132
RH		 2760 break;
2761 case 'W':
2762 add_fix ('w', &opP->disp, 1, 0);
2763 addword (0);
2764 break;
2765 case 'L':
2766 long_branch:
151337e8 2767 if (! HAVE_LONG_BRANCH (current_architecture))
81d4177b 2768 as_warn (_("Can't use long branches on 68000/68010/5200"));
151337e8 2769 the_ins.opcode[0] |= 0xff;
252b5132
RH		 2770 add_fix ('l', &opP->disp, 1, 0);
2771 addword (0);
2772 addword (0);
2773 break;
2774 case 'g':
36759679 2775 if (subs (&opP->disp)) /* We can't relax it. */
252b5132
RH		 2776 goto long_branch;
2777
2778#ifdef OBJ_ELF
2779 /* If the displacement needs pic relocation it cannot be
2780 relaxed. */
2781 if (opP->disp.pic_reloc != pic_none)
2782 goto long_branch;
2783#endif
252b5132 2784 /* This could either be a symbol, or an absolute
151337e8
NC		 2785 address. If it's an absolute address, turn it into
2786 an absolute jump right here and keep it out of the
2787 relaxer. */
2788 if (adds (&opP->disp) == 0)
2789 {
2790 if (the_ins.opcode[0] == 0x6000) /* jbra */
18566f55 2791 the_ins.opcode[0] = 0x4EF9;
151337e8 2792 else if (the_ins.opcode[0] == 0x6100) /* jbsr */
18566f55 2793 the_ins.opcode[0] = 0x4EB9;
151337e8
NC		 2794 else /* jCC */
2795 {
2796 the_ins.opcode[0] ^= 0x0100;
2797 the_ins.opcode[0] |= 0x0006;
18566f55 2798 addword (0x4EF9);
151337e8
NC		 2799 }
2800 add_fix ('l', &opP->disp, 0, 0);
2801 addword (0);
2802 addword (0);
2803 break;
2804 }
2805
2806 /* Now we know it's going into the relaxer. Now figure
2807 out which mode. We try in this order of preference:
2808 long branch, absolute jump, byte/word branches only. */
2809 if (HAVE_LONG_BRANCH (current_architecture))
bd17c2c3
AM		 2810 add_frag (adds (&opP->disp),
2811 SEXT (offs (&opP->disp)),
151337e8
NC		 2812 TAB (BRANCHBWL, SZ_UNDEF));
2813 else if (! flag_keep_pcrel)
2814 {
2815 if ((the_ins.opcode[0] == 0x6000)
2816 || (the_ins.opcode[0] == 0x6100))
bd17c2c3
AM		 2817 add_frag (adds (&opP->disp),
2818 SEXT (offs (&opP->disp)),
151337e8
NC		 2819 TAB (BRABSJUNC, SZ_UNDEF));
2820 else
bd17c2c3
AM		 2821 add_frag (adds (&opP->disp),
2822 SEXT (offs (&opP->disp)),
151337e8
NC		 2823 TAB (BRABSJCOND, SZ_UNDEF));
2824 }
252b5132 2825 else
bd17c2c3
AM		 2826 add_frag (adds (&opP->disp),
2827 SEXT (offs (&opP->disp)),
151337e8 2828 TAB (BRANCHBW, SZ_UNDEF));
252b5132
RH		 2829 break;
2830 case 'w':
2831 if (isvar (&opP->disp))
2832 {
151337e8
NC		 2833 /* Check for DBcc instructions. We can relax them,
2834 but only if we have long branches and/or absolute
2835 jumps. */
2836 if (((the_ins.opcode[0] & 0xf0f8) == 0x50c8)
2837 && (HAVE_LONG_BRANCH (current_architecture)
2838 || (! flag_keep_pcrel)))
252b5132 2839 {
151337e8 2840 if (HAVE_LONG_BRANCH (current_architecture))
bd17c2c3
AM		 2841 add_frag (adds (&opP->disp),
2842 SEXT (offs (&opP->disp)),
151337e8
NC		 2843 TAB (DBCCLBR, SZ_UNDEF));
2844 else
bd17c2c3
AM		 2845 add_frag (adds (&opP->disp),
2846 SEXT (offs (&opP->disp)),
151337e8 2847 TAB (DBCCABSJ, SZ_UNDEF));
252b5132
RH		 2848 break;
2849 }
252b5132
RH		 2850 add_fix ('w', &opP->disp, 1, 0);
2851 }
2852 addword (0);
2853 break;
36759679 2854 case 'C': /* Fixed size LONG coproc branches. */
252b5132
RH		 2855 add_fix ('l', &opP->disp, 1, 0);
2856 addword (0);
2857 addword (0);
2858 break;
36759679 2859 case 'c': /* Var size Coprocesssor branches. */
151337e8 2860 if (subs (&opP->disp) || (adds (&opP->disp) == 0))
252b5132 2861 {
252b5132
RH		 2862 the_ins.opcode[the_ins.numo - 1] |= 0x40;
2863 add_fix ('l', &opP->disp, 1, 0);
2864 addword (0);
2865 addword (0);
2866 }
151337e8 2867 else
bd17c2c3
AM		 2868 add_frag (adds (&opP->disp),
2869 SEXT (offs (&opP->disp)),
151337e8 2870 TAB (FBRANCH, SZ_UNDEF));
252b5132
RH		 2871 break;
2872 default:
2873 abort ();
2874 }
2875 break;
2876
36759679 2877 case 'C': /* Ignore it. */
252b5132
RH		 2878 break;
2879
36759679 2880 case 'd': /* JF this is a kludge. */
252b5132 2881 install_operand ('s', opP->reg - ADDR);
3e602632 2882 tmpreg = get_num (&opP->disp, 90);
252b5132
RH		 2883 if (!issword (tmpreg))
2884 {
2885 as_warn (_("Expression out of range, using 0"));
2886 tmpreg = 0;
2887 }
2888 addword (tmpreg);
2889 break;
2890
2891 case 'D':
2892 install_operand (s[1], opP->reg - DATA);
2893 break;
2894
fd99574b
NC		 2895 case 'e': /* EMAC ACCx, reg/reg. */
2896 install_operand (s[1], opP->reg - ACC);
2897 break;
2898
36759679 2899 case 'E': /* Ignore it. */
6da466c7
ILT		 2900 break;
2901
252b5132
RH		 2902 case 'F':
2903 install_operand (s[1], opP->reg - FP0);
2904 break;
2905
fd99574b
NC		 2906 case 'g': /* EMAC ACCEXTx. */
2907 install_operand (s[1], opP->reg - ACCEXT01);
2908 break;
2909
36759679 2910 case 'G': /* Ignore it. */
6da466c7
ILT		 2911 case 'H':
2912 break;
2913
252b5132
RH		 2914 case 'I':
2915 tmpreg = opP->reg - COP0;
2916 install_operand (s[1], tmpreg);
2917 break;
2918
fd99574b
NC		 2919 case 'i': /* MAC/EMAC scale factor. */
2920 install_operand (s[1], opP->mode == LSH ? 0x1 : 0x3);
2921 break;
2922
36759679 2923 case 'J': /* JF foo. */
252b5132
RH		 2924 switch (opP->reg)
2925 {
2926 case SFC:
2927 tmpreg = 0x000;
2928 break;
2929 case DFC:
2930 tmpreg = 0x001;
2931 break;
2932 case CACR:
2933 tmpreg = 0x002;
2934 break;
2935 case TC:
2936 tmpreg = 0x003;
2937 break;
3e602632 2938 case ACR0:
252b5132
RH		 2939 case ITT0:
2940 tmpreg = 0x004;
2941 break;
3e602632 2942 case ACR1:
252b5132
RH		 2943 case ITT1:
2944 tmpreg = 0x005;
2945 break;
3e602632 2946 case ACR2:
252b5132
RH		 2947 case DTT0:
2948 tmpreg = 0x006;
2949 break;
3e602632 2950 case ACR3:
252b5132
RH		 2951 case DTT1:
2952 tmpreg = 0x007;
2953 break;
2954 case BUSCR:
2955 tmpreg = 0x008;
2956 break;
2957
2958 case USP:
2959 tmpreg = 0x800;
2960 break;
2961 case VBR:
2962 tmpreg = 0x801;
2963 break;
2964 case CAAR:
2965 tmpreg = 0x802;
2966 break;
2967 case MSP:
2968 tmpreg = 0x803;
2969 break;
2970 case ISP:
2971 tmpreg = 0x804;
2972 break;
2973 case MMUSR:
2974 tmpreg = 0x805;
2975 break;
2976 case URP:
2977 tmpreg = 0x806;
2978 break;
2979 case SRP:
2980 tmpreg = 0x807;
2981 break;
2982 case PCR:
2983 tmpreg = 0x808;
2984 break;
2985 case ROMBAR:
2986 tmpreg = 0xC00;
2987 break;
3e602632
NC		 2988 case ROMBAR1:
2989 tmpreg = 0xC01;
2990 break;
2991 case FLASHBAR:
252b5132
RH		 2992 case RAMBAR0:
2993 tmpreg = 0xC04;
2994 break;
3e602632 2995 case RAMBAR:
252b5132
RH		 2996 case RAMBAR1:
2997 tmpreg = 0xC05;
2998 break;
3e602632
NC		 2999 case MPCR:
3000 tmpreg = 0xC0C;
3001 break;
3002 case EDRAMBAR:
3003 tmpreg = 0xC0D;
3004 break;
3005 case MBAR0:
e80e0390 3006 case MBAR2:
3e602632
NC		 3007 case SECMBAR:
3008 tmpreg = 0xC0E;
3009 break;
3010 case MBAR1:
252b5132
RH		 3011 case MBAR:
3012 tmpreg = 0xC0F;
3013 break;
3e602632
NC		 3014 case PCR1U0:
3015 tmpreg = 0xD02;
3016 break;
3017 case PCR1L0:
3018 tmpreg = 0xD03;
3019 break;
3020 case PCR2U0:
3021 tmpreg = 0xD04;
3022 break;
3023 case PCR2L0:
3024 tmpreg = 0xD05;
3025 break;
3026 case PCR3U0:
3027 tmpreg = 0xD06;
3028 break;
3029 case PCR3L0:
3030 tmpreg = 0xD07;
3031 break;
3032 case PCR1L1:
3033 tmpreg = 0xD0A;
3034 break;
3035 case PCR1U1:
3036 tmpreg = 0xD0B;
3037 break;
3038 case PCR2L1:
3039 tmpreg = 0xD0C;
3040 break;
3041 case PCR2U1:
3042 tmpreg = 0xD0D;
3043 break;
3044 case PCR3L1:
3045 tmpreg = 0xD0E;
3046 break;
3047 case PCR3U1:
3048 tmpreg = 0xD0F;
3049 break;
252b5132
RH		 3050 default:
3051 abort ();
3052 }
3053 install_operand (s[1], tmpreg);
3054 break;
3055
3056 case 'k':
3057 tmpreg = get_num (&opP->disp, 55);
3058 install_operand (s[1], tmpreg & 0x7f);
3059 break;
3060
3061 case 'l':
3062 tmpreg = opP->mask;
3063 if (s[1] == 'w')
3064 {
3065 if (tmpreg & 0x7FF0000)
3066 as_bad (_("Floating point register in register list"));
3067 insop (reverse_16_bits (tmpreg), opcode);
3068 }
3069 else
3070 {
3071 if (tmpreg & 0x700FFFF)
3072 as_bad (_("Wrong register in floating-point reglist"));
3073 install_operand (s[1], reverse_8_bits (tmpreg >> 16));
3074 }
3075 break;
3076
3077 case 'L':
3078 tmpreg = opP->mask;
3079 if (s[1] == 'w')
3080 {
3081 if (tmpreg & 0x7FF0000)
3082 as_bad (_("Floating point register in register list"));
3083 insop (tmpreg, opcode);
3084 }
3085 else if (s[1] == '8')
3086 {
3087 if (tmpreg & 0x0FFFFFF)
3088 as_bad (_("incorrect register in reglist"));
3089 install_operand (s[1], tmpreg >> 24);
3090 }
3091 else
3092 {
3093 if (tmpreg & 0x700FFFF)
3094 as_bad (_("wrong register in floating-point reglist"));
3095 else
3096 install_operand (s[1], tmpreg >> 16);
3097 }
3098 break;
3099
3100 case 'M':
3101 install_operand (s[1], get_num (&opP->disp, 60));
3102 break;
3103
3104 case 'O':
3105 tmpreg = ((opP->mode == DREG)
8fce3f5e 3106 ? 0x20 + (int) (opP->reg - DATA)
252b5132
RH		 3107 : (get_num (&opP->disp, 40) & 0x1F));
3108 install_operand (s[1], tmpreg);
3109 break;
3110
3111 case 'Q':
3112 tmpreg = get_num (&opP->disp, 10);
3113 if (tmpreg == 8)
3114 tmpreg = 0;
3115 install_operand (s[1], tmpreg);
3116 break;
3117
3118 case 'R':
3119 /* This depends on the fact that ADDR registers are eight
3120 more than their corresponding DATA regs, so the result
36759679 3121 will have the ADDR_REG bit set. */
252b5132
RH		 3122 install_operand (s[1], opP->reg - DATA);
3123 break;
3124
3125 case 'r':
3126 if (opP->mode == AINDR)
3127 install_operand (s[1], opP->reg - DATA);
3128 else
3129 install_operand (s[1], opP->index.reg - DATA);
3130 break;
3131
3132 case 's':
3133 if (opP->reg == FPI)
3134 tmpreg = 0x1;
3135 else if (opP->reg == FPS)
3136 tmpreg = 0x2;
3137 else if (opP->reg == FPC)
3138 tmpreg = 0x4;
3139 else
3140 abort ();
3141 install_operand (s[1], tmpreg);
3142 break;
3143
36759679 3144 case 'S': /* Ignore it. */
252b5132
RH		 3145 break;
3146
3147 case 'T':
3148 install_operand (s[1], get_num (&opP->disp, 30));
3149 break;
3150
36759679 3151 case 'U': /* Ignore it. */
252b5132
RH		 3152 break;
3153
3154 case 'c':
3155 switch (opP->reg)
3156 {
3157 case NC:
3158 tmpreg = 0;
3159 break;
3160 case DC:
3161 tmpreg = 1;
3162 break;
3163 case IC:
3164 tmpreg = 2;
3165 break;
3166 case BC:
3167 tmpreg = 3;
3168 break;
3169 default:
3170 as_fatal (_("failed sanity check"));
36759679 3171 } /* switch on cache token. */
252b5132
RH		 3172 install_operand (s[1], tmpreg);
3173 break;
3174#ifndef NO_68851
92774660 3175 /* JF: These are out of order, I fear. */
252b5132
RH		 3176 case 'f':
3177 switch (opP->reg)
3178 {
3179 case SFC:
3180 tmpreg = 0;
3181 break;
3182 case DFC:
3183 tmpreg = 1;
3184 break;
3185 default:
3186 abort ();
3187 }
3188 install_operand (s[1], tmpreg);
3189 break;
3190
3191 case '0':
3192 case '1':
3193 case '2':
3194 switch (opP->reg)
3195 {
3196 case TC:
3197 tmpreg = 0;
3198 break;
3199 case CAL:
3200 tmpreg = 4;
3201 break;
3202 case VAL:
3203 tmpreg = 5;
3204 break;
3205 case SCC:
3206 tmpreg = 6;
3207 break;
3208 case AC:
3209 tmpreg = 7;
3210 break;
3211 default:
3212 abort ();
3213 }
3214 install_operand (s[1], tmpreg);
3215 break;
3216
3217 case 'V':
3218 if (opP->reg == VAL)
3219 break;
3220 abort ();
3221
3222 case 'W':
3223 switch (opP->reg)
3224 {
3225 case DRP:
3226 tmpreg = 1;
3227 break;
3228 case SRP:
3229 tmpreg = 2;
3230 break;
3231 case CRP:
3232 tmpreg = 3;
3233 break;
3234 default:
3235 abort ();
3236 }
3237 install_operand (s[1], tmpreg);
3238 break;
3239
3240 case 'X':
3241 switch (opP->reg)
3242 {
3243 case BAD:
3244 case BAD + 1:
3245 case BAD + 2:
3246 case BAD + 3:
3247 case BAD + 4:
3248 case BAD + 5:
3249 case BAD + 6:
3250 case BAD + 7:
3251 tmpreg = (4 << 10) | ((opP->reg - BAD) << 2);
3252 break;
3253
3254 case BAC:
3255 case BAC + 1:
3256 case BAC + 2:
3257 case BAC + 3:
3258 case BAC + 4:
3259 case BAC + 5:
3260 case BAC + 6:
3261 case BAC + 7:
3262 tmpreg = (5 << 10) | ((opP->reg - BAC) << 2);
3263 break;
3264
3265 default:
3266 abort ();
3267 }
3268 install_operand (s[1], tmpreg);
3269 break;
3270 case 'Y':
3271 know (opP->reg == PSR);
3272 break;
3273 case 'Z':
3274 know (opP->reg == PCSR);
3275 break;
3276#endif /* m68851 */
3277 case '3':
3278 switch (opP->reg)
3279 {
3280 case TT0:
3281 tmpreg = 2;
3282 break;
3283 case TT1:
3284 tmpreg = 3;
3285 break;
3286 default:
3287 abort ();
3288 }
3289 install_operand (s[1], tmpreg);
3290 break;
3291 case 't':
3292 tmpreg = get_num (&opP->disp, 20);
3293 install_operand (s[1], tmpreg);
3294 break;
36759679 3295 case '_': /* used only for move16 absolute 32-bit address. */
252b5132
RH		 3296 if (isvar (&opP->disp))
3297 add_fix ('l', &opP->disp, 0, 0);
3e602632 3298 tmpreg = get_num (&opP->disp, 90);
252b5132
RH		 3299 addword (tmpreg >> 16);
3300 addword (tmpreg & 0xFFFF);
3301 break;
6da466c7
ILT		 3302 case 'u':
3303 install_operand (s[1], opP->reg - DATA0L);
3304 opP->reg -= (DATA0L);
36759679 3305 opP->reg &= 0x0F; /* remove upper/lower bit. */
6da466c7 3306 break;
3e602632
NC		 3307 case 'x':
3308 tmpreg = get_num (&opP->disp, 80);
3309 if (tmpreg == -1)
3310 tmpreg = 0;
3311 install_operand (s[1], tmpreg);
3312 break;
252b5132
RH		 3313 default:
3314 abort ();
3315 }
3316 }
3317
3318 /* By the time whe get here (FINALLY) the_ins contains the complete
92774660 3319 instruction, ready to be emitted. . . */
252b5132
RH		 3320}
3321
3322static int
31302357 3323reverse_16_bits (int in)
252b5132
RH		 3324{
3325 int out = 0;
3326 int n;
3327
3328 static int mask[16] =
3329 {
3330 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
3331 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000
3332 };
3333 for (n = 0; n < 16; n++)
3334 {
3335 if (in & mask[n])
3336 out |= mask[15 - n];
3337 }
3338 return out;
3339} /* reverse_16_bits() */
3340
3341static int
31302357 3342reverse_8_bits (int in)
252b5132
RH		 3343{
3344 int out = 0;
3345 int n;
3346
3347 static int mask[8] =
3348 {
3349 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
3350 };
3351
3352 for (n = 0; n < 8; n++)
3353 {
3354 if (in & mask[n])
3355 out |= mask[7 - n];
3356 }
3357 return out;
3358} /* reverse_8_bits() */
3359
3360/* Cause an extra frag to be generated here, inserting up to 10 bytes
3361 (that value is chosen in the frag_var call in md_assemble). TYPE
3362 is the subtype of the frag to be generated; its primary type is
3363 rs_machine_dependent.
3364
3365 The TYPE parameter is also used by md_convert_frag_1 and
3366 md_estimate_size_before_relax. The appropriate type of fixup will
3367 be emitted by md_convert_frag_1.
3368
3369 ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET. */
3370static void
31302357 3371install_operand (int mode, int val)
252b5132
RH		 3372{
3373 switch (mode)
3374 {
3375 case 's':
36759679 3376 the_ins.opcode[0] |= val & 0xFF; /* JF FF is for M kludge. */
252b5132
RH		 3377 break;
3378 case 'd':
3379 the_ins.opcode[0] |= val << 9;
3380 break;
3381 case '1':
3382 the_ins.opcode[1] |= val << 12;
3383 break;
3384 case '2':
3385 the_ins.opcode[1] |= val << 6;
3386 break;
3387 case '3':
3388 the_ins.opcode[1] |= val;
3389 break;
3390 case '4':
3391 the_ins.opcode[2] |= val << 12;
3392 break;
3393 case '5':
3394 the_ins.opcode[2] |= val << 6;
3395 break;
3396 case '6':
3397 /* DANGER! This is a hack to force cas2l and cas2w cmds to be
3398 three words long! */
3399 the_ins.numo++;
3400 the_ins.opcode[2] |= val;
3401 break;
3402 case '7':
3403 the_ins.opcode[1] |= val << 7;
3404 break;
3405 case '8':
3406 the_ins.opcode[1] |= val << 10;
3407 break;
3408#ifndef NO_68851
3409 case '9':
3410 the_ins.opcode[1] |= val << 5;
3411 break;
3412#endif
3413
3414 case 't':
3415 the_ins.opcode[1] |= (val << 10) | (val << 7);
3416 break;
3417 case 'D':
3418 the_ins.opcode[1] |= (val << 12) | val;
3419 break;
3420 case 'g':
3421 the_ins.opcode[0] |= val = 0xff;
3422 break;
3423 case 'i':
3424 the_ins.opcode[0] |= val << 9;
3425 break;
3426 case 'C':
3427 the_ins.opcode[1] |= val;
3428 break;
3429 case 'j':
3430 the_ins.opcode[1] |= val;
36759679 3431 the_ins.numo++; /* What a hack. */
252b5132
RH		 3432 break;
3433 case 'k':
3434 the_ins.opcode[1] |= val << 4;
3435 break;
3436 case 'b':
3437 case 'w':
3438 case 'W':
3439 case 'l':
3440 break;
3441 case 'e':
3442 the_ins.opcode[0] |= (val << 6);
3443 break;
3444 case 'L':
3445 the_ins.opcode[1] = (val >> 16);
3446 the_ins.opcode[2] = val & 0xffff;
3447 break;
6da466c7
ILT		 3448 case 'm':
3449 the_ins.opcode[0] |= ((val & 0x8) << (6 - 3));
3450 the_ins.opcode[0] |= ((val & 0x7) << 9);
3451 the_ins.opcode[1] |= ((val & 0x10) << (7 - 4));
3452 break;
fd99574b 3453 case 'n': /* MAC/EMAC Rx on !load. */
6da466c7
ILT		 3454 the_ins.opcode[0] |= ((val & 0x8) << (6 - 3));
3455 the_ins.opcode[0] |= ((val & 0x7) << 9);
fd99574b 3456 the_ins.opcode[1] |= ((val & 0x10) << (7 - 4));
6da466c7 3457 break;
fd99574b 3458 case 'o': /* MAC/EMAC Rx on load. */
6da466c7
ILT		 3459 the_ins.opcode[1] |= val << 12;
3460 the_ins.opcode[1] |= ((val & 0x10) << (7 - 4));
3461 break;
fd99574b 3462 case 'M': /* MAC/EMAC Ry on !load. */
6da466c7
ILT		 3463 the_ins.opcode[0] |= (val & 0xF);
3464 the_ins.opcode[1] |= ((val & 0x10) << (6 - 4));
3465 break;
fd99574b 3466 case 'N': /* MAC/EMAC Ry on load. */
6da466c7
ILT		 3467 the_ins.opcode[1] |= (val & 0xF);
3468 the_ins.opcode[1] |= ((val & 0x10) << (6 - 4));
3469 break;
3470 case 'h':
3471 the_ins.opcode[1] |= ((val != 1) << 10);
3472 break;
fd99574b
NC		 3473 case 'F':
3474 the_ins.opcode[0] |= ((val & 0x3) << 9);
3475 break;
3476 case 'f':
3477 the_ins.opcode[0] |= ((val & 0x3) << 0);
3478 break;
be8c092b 3479 case 'G': /* EMAC accumulator in a EMAC load instruction. */
fd99574b
NC		 3480 the_ins.opcode[0] |= ((~val & 0x1) << 7);
3481 the_ins.opcode[1] |= ((val & 0x2) << (4 - 1));
3482 break;
be8c092b 3483 case 'H': /* EMAC accumulator in a EMAC non-load instruction. */
fd99574b
NC		 3484 the_ins.opcode[0] |= ((val & 0x1) << 7);
3485 the_ins.opcode[1] |= ((val & 0x2) << (4 - 1));
3486 break;
3487 case 'I':
3488 the_ins.opcode[1] |= ((val & 0x3) << 9);
3489 break;
3490 case ']':
3491 the_ins.opcode[0] |= (val & 0x1) <<10;
3492 break;
252b5132
RH		 3493 case 'c':
3494 default:
3495 as_fatal (_("failed sanity check."));
3496 }
6b6e92f4 3497}
252b5132
RH		 3498
3499static void
31302357 3500install_gen_operand (int mode, int val)
252b5132
RH		 3501{
3502 switch (mode)
3503 {
fd99574b
NC		 3504 case '/': /* Special for mask loads for mac/msac insns with
3505 possible mask; trailing_ampersend set in bit 8. */
3506 the_ins.opcode[0] |= (val & 0x3f);
3507 the_ins.opcode[1] |= (((val & 0x100) >> 8) << 5);
3508 break;
252b5132
RH		 3509 case 's':
3510 the_ins.opcode[0] |= val;
3511 break;
3512 case 'd':
3513 /* This is a kludge!!! */
3514 the_ins.opcode[0] |= (val & 0x07) << 9 | (val & 0x38) << 3;
3515 break;
3516 case 'b':
3517 case 'w':
3518 case 'l':
3519 case 'f':
3520 case 'F':
3521 case 'x':
3522 case 'p':
3523 the_ins.opcode[0] |= val;
3524 break;
36759679 3525 /* more stuff goes here. */
252b5132
RH		 3526 default:
3527 as_fatal (_("failed sanity check."));
3528 }
6b6e92f4 3529}
252b5132 3530
6b6e92f4
NC		 3531/* Verify that we have some number of paren pairs, do m68k_ip_op(), and
3532 then deal with the bitfield hack. */
252b5132
RH		 3533
3534static char *
31302357 3535crack_operand (char *str, struct m68k_op *opP)
252b5132
RH		 3536{
3537 register int parens;
3538 register int c;
3539 register char *beg_str;
3540 int inquote = 0;
3541
3542 if (!str)
3543 {
3544 return str;
3545 }
3546 beg_str = str;
3547 for (parens = 0; *str && (parens > 0 || inquote || notend (str)); str++)
3548 {
3549 if (! inquote)
3550 {
3551 if (*str == '(')
3552 parens++;
3553 else if (*str == ')')
3554 {
3555 if (!parens)
36759679 3556 { /* ERROR. */
252b5132
RH		 3557 opP->error = _("Extra )");
3558 return str;
3559 }
3560 --parens;
3561 }
3562 }
3563 if (flag_mri && *str == '\'')
3564 inquote = ! inquote;
3565 }
3566 if (!*str && parens)
36759679 3567 { /* ERROR. */
252b5132
RH		 3568 opP->error = _("Missing )");
3569 return str;
3570 }
3571 c = *str;
3572 *str = '\0';
3573 if (m68k_ip_op (beg_str, opP) != 0)
3574 {
3575 *str = c;
3576 return str;
3577 }
3578 *str = c;
3579 if (c == '}')
36759679 3580 c = *++str; /* JF bitfield hack. */
252b5132
RH		 3581 if (c)
3582 {
3583 c = *++str;
3584 if (!c)
3585 as_bad (_("Missing operand"));
3586 }
3587
3588 /* Detect MRI REG symbols and convert them to REGLSTs. */
3589 if (opP->mode == CONTROL && (int)opP->reg < 0)
3590 {
3591 opP->mode = REGLST;
3592 opP->mask = ~(int)opP->reg;
3593 opP->reg = 0;
3594 }
3595
3596 return str;
3597}
3598
3599/* This is the guts of the machine-dependent assembler. STR points to a
3600 machine dependent instruction. This function is supposed to emit
3601 the frags/bytes it assembles to.
3602 */
3603
3604static void
31302357 3605insert_reg (const char *regname, int regnum)
252b5132
RH		 3606{
3607 char buf[100];
3608 int i;
3609
3610#ifdef REGISTER_PREFIX
3611 if (!flag_reg_prefix_optional)
3612 {
3613 buf[0] = REGISTER_PREFIX;
3614 strcpy (buf + 1, regname);
3615 regname = buf;
3616 }
3617#endif
3618
3619 symbol_table_insert (symbol_new (regname, reg_section, regnum,
3620 &zero_address_frag));
3621
3622 for (i = 0; regname[i]; i++)
3882b010 3623 buf[i] = TOUPPER (regname[i]);
252b5132
RH		 3624 buf[i] = '\0';
3625
3626 symbol_table_insert (symbol_new (buf, reg_section, regnum,
3627 &zero_address_frag));
3628}
3629
3630struct init_entry
3631 {
3632 const char *name;
3633 int number;
3634 };
3635
3636static const struct init_entry init_table[] =
3637{
3638 { "d0", DATA0 },
3639 { "d1", DATA1 },
3640 { "d2", DATA2 },
3641 { "d3", DATA3 },
3642 { "d4", DATA4 },
3643 { "d5", DATA5 },
3644 { "d6", DATA6 },
3645 { "d7", DATA7 },
3646 { "a0", ADDR0 },
3647 { "a1", ADDR1 },
3648 { "a2", ADDR2 },
3649 { "a3", ADDR3 },
3650 { "a4", ADDR4 },
3651 { "a5", ADDR5 },
3652 { "a6", ADDR6 },
3653 { "fp", ADDR6 },
3654 { "a7", ADDR7 },
3655 { "sp", ADDR7 },
3656 { "ssp", ADDR7 },
3657 { "fp0", FP0 },
3658 { "fp1", FP1 },
3659 { "fp2", FP2 },
3660 { "fp3", FP3 },
3661 { "fp4", FP4 },
3662 { "fp5", FP5 },
3663 { "fp6", FP6 },
3664 { "fp7", FP7 },
3665 { "fpi", FPI },
3666 { "fpiar", FPI },
3667 { "fpc", FPI },
3668 { "fps", FPS },
3669 { "fpsr", FPS },
3670 { "fpc", FPC },
3671 { "fpcr", FPC },
3672 { "control", FPC },
3673 { "status", FPS },
3674 { "iaddr", FPI },
3675
3676 { "cop0", COP0 },
3677 { "cop1", COP1 },
3678 { "cop2", COP2 },
3679 { "cop3", COP3 },
3680 { "cop4", COP4 },
3681 { "cop5", COP5 },
3682 { "cop6", COP6 },
3683 { "cop7", COP7 },
3684 { "pc", PC },
3685 { "zpc", ZPC },
3686 { "sr", SR },
3687
3688 { "ccr", CCR },
3689 { "cc", CCR },
3690
6da466c7 3691 { "acc", ACC },
fd99574b
NC		 3692 { "acc0", ACC },
3693 { "acc1", ACC1 },
3694 { "acc2", ACC2 },
3695 { "acc3", ACC3 },
3696 { "accext01", ACCEXT01 },
3697 { "accext23", ACCEXT23 },
6da466c7
ILT		 3698 { "macsr", MACSR },
3699 { "mask", MASK },
3700
36759679
NC		 3701 /* Control registers. */
3702 { "sfc", SFC }, /* Source Function Code. */
252b5132 3703 { "sfcr", SFC },
36759679 3704 { "dfc", DFC }, /* Destination Function Code. */
252b5132 3705 { "dfcr", DFC },
36759679
NC		 3706 { "cacr", CACR }, /* Cache Control Register. */
3707 { "caar", CAAR }, /* Cache Address Register. */
252b5132 3708
36759679
NC		 3709 { "usp", USP }, /* User Stack Pointer. */
3710 { "vbr", VBR }, /* Vector Base Register. */
3711 { "msp", MSP }, /* Master Stack Pointer. */
3712 { "isp", ISP }, /* Interrupt Stack Pointer. */
252b5132 3713
36759679
NC		 3714 { "itt0", ITT0 }, /* Instruction Transparent Translation Reg 0. */
3715 { "itt1", ITT1 }, /* Instruction Transparent Translation Reg 1. */
3716 { "dtt0", DTT0 }, /* Data Transparent Translation Register 0. */
3717 { "dtt1", DTT1 }, /* Data Transparent Translation Register 1. */
252b5132
RH		 3718
3719 /* 68ec040 versions of same */
36759679
NC		 3720 { "iacr0", ITT0 }, /* Instruction Access Control Register 0. */
3721 { "iacr1", ITT1 }, /* Instruction Access Control Register 0. */
3722 { "dacr0", DTT0 }, /* Data Access Control Register 0. */
3723 { "dacr1", DTT1 }, /* Data Access Control Register 0. */
252b5132
RH		 3724
3725 /* mcf5200 versions of same. The ColdFire programmer's reference
3726 manual indicated that the order is 2,3,0,1, but Ken Rose
3727 <rose@netcom.com> says that 0,1,2,3 is the correct order. */
3e602632
NC		 3728 { "acr0", ACR0 }, /* Access Control Unit 0. */
3729 { "acr1", ACR1 }, /* Access Control Unit 1. */
3730 { "acr2", ACR2 }, /* Access Control Unit 2. */
3731 { "acr3", ACR3 }, /* Access Control Unit 3. */
252b5132 3732
36759679 3733 { "tc", TC }, /* MMU Translation Control Register. */
252b5132
RH		 3734 { "tcr", TC },
3735
36759679
NC		 3736 { "mmusr", MMUSR }, /* MMU Status Register. */
3737 { "srp", SRP }, /* User Root Pointer. */
3738 { "urp", URP }, /* Supervisor Root Pointer. */
252b5132
RH		 3739
3740 { "buscr", BUSCR },
3741 { "pcr", PCR },
3742
36759679
NC		 3743 { "rombar", ROMBAR }, /* ROM Base Address Register. */
3744 { "rambar0", RAMBAR0 }, /* ROM Base Address Register. */
3745 { "rambar1", RAMBAR1 }, /* ROM Base Address Register. */
3746 { "mbar", MBAR }, /* Module Base Address Register. */
3e602632
NC		 3747
3748 { "mbar0", MBAR0 }, /* mcfv4e registers. */
3749 { "mbar1", MBAR1 }, /* mcfv4e registers. */
3750 { "rombar0", ROMBAR }, /* mcfv4e registers. */
3751 { "rombar1", ROMBAR1 }, /* mcfv4e registers. */
3752 { "mpcr", MPCR }, /* mcfv4e registers. */
3753 { "edrambar", EDRAMBAR }, /* mcfv4e registers. */
3754 { "secmbar", SECMBAR }, /* mcfv4e registers. */
3755 { "asid", TC }, /* mcfv4e registers. */
3756 { "mmubar", BUSCR }, /* mcfv4e registers. */
3757 { "pcr1u0", PCR1U0 }, /* mcfv4e registers. */
3758 { "pcr1l0", PCR1L0 }, /* mcfv4e registers. */
3759 { "pcr2u0", PCR2U0 }, /* mcfv4e registers. */
3760 { "pcr2l0", PCR2L0 }, /* mcfv4e registers. */
3761 { "pcr3u0", PCR3U0 }, /* mcfv4e registers. */
3762 { "pcr3l0", PCR3L0 }, /* mcfv4e registers. */
3763 { "pcr1u1", PCR1U1 }, /* mcfv4e registers. */
3764 { "pcr1l1", PCR1L1 }, /* mcfv4e registers. */
3765 { "pcr2u1", PCR2U1 }, /* mcfv4e registers. */
3766 { "pcr2l1", PCR2L1 }, /* mcfv4e registers. */
3767 { "pcr3u1", PCR3U1 }, /* mcfv4e registers. */
3768 { "pcr3l1", PCR3L1 }, /* mcfv4e registers. */
3769
3770 { "flashbar", FLASHBAR }, /* mcf528x registers. */
3771 { "rambar", RAMBAR }, /* mcf528x registers. */
e80e0390
NC		 3772
3773 { "mbar2", MBAR2 }, /* mcf5249 registers. */
36759679 3774 /* End of control registers. */
252b5132
RH		 3775
3776 { "ac", AC },
3777 { "bc", BC },
3778 { "cal", CAL },
3779 { "crp", CRP },
3780 { "drp", DRP },
3781 { "pcsr", PCSR },
3782 { "psr", PSR },
3783 { "scc", SCC },
3784 { "val", VAL },
3785 { "bad0", BAD0 },
3786 { "bad1", BAD1 },
3787 { "bad2", BAD2 },
3788 { "bad3", BAD3 },
3789 { "bad4", BAD4 },
3790 { "bad5", BAD5 },
3791 { "bad6", BAD6 },
3792 { "bad7", BAD7 },
3793 { "bac0", BAC0 },
3794 { "bac1", BAC1 },
3795 { "bac2", BAC2 },
3796 { "bac3", BAC3 },
3797 { "bac4", BAC4 },
3798 { "bac5", BAC5 },
3799 { "bac6", BAC6 },
3800 { "bac7", BAC7 },
3801
3802 { "ic", IC },
3803 { "dc", DC },
3804 { "nc", NC },
3805
3806 { "tt0", TT0 },
3807 { "tt1", TT1 },
36759679 3808 /* 68ec030 versions of same. */
252b5132
RH		 3809 { "ac0", TT0 },
3810 { "ac1", TT1 },
36759679 3811 /* 68ec030 access control unit, identical to 030 MMU status reg. */
252b5132
RH		 3812 { "acusr", PSR },
3813
3814 /* Suppressed data and address registers. */
3815 { "zd0", ZDATA0 },
3816 { "zd1", ZDATA1 },
3817 { "zd2", ZDATA2 },
3818 { "zd3", ZDATA3 },
3819 { "zd4", ZDATA4 },
3820 { "zd5", ZDATA5 },
3821 { "zd6", ZDATA6 },
3822 { "zd7", ZDATA7 },
3823 { "za0", ZADDR0 },
3824 { "za1", ZADDR1 },
3825 { "za2", ZADDR2 },
3826 { "za3", ZADDR3 },
3827 { "za4", ZADDR4 },
3828 { "za5", ZADDR5 },
3829 { "za6", ZADDR6 },
3830 { "za7", ZADDR7 },
3831
92774660 3832 /* Upper and lower data and address registers, used by macw and msacw. */
6da466c7
ILT		 3833 { "d0l", DATA0L },
3834 { "d1l", DATA1L },
3835 { "d2l", DATA2L },
3836 { "d3l", DATA3L },
3837 { "d4l", DATA4L },
3838 { "d5l", DATA5L },
3839 { "d6l", DATA6L },
3840 { "d7l", DATA7L },
3841
3842 { "a0l", ADDR0L },
3843 { "a1l", ADDR1L },
3844 { "a2l", ADDR2L },
3845 { "a3l", ADDR3L },
3846 { "a4l", ADDR4L },
3847 { "a5l", ADDR5L },
3848 { "a6l", ADDR6L },
3849 { "a7l", ADDR7L },
3850
3851 { "d0u", DATA0U },
3852 { "d1u", DATA1U },
3853 { "d2u", DATA2U },
3854 { "d3u", DATA3U },
3855 { "d4u", DATA4U },
3856 { "d5u", DATA5U },
3857 { "d6u", DATA6U },
3858 { "d7u", DATA7U },
3859
3860 { "a0u", ADDR0U },
3861 { "a1u", ADDR1U },
3862 { "a2u", ADDR2U },
3863 { "a3u", ADDR3U },
3864 { "a4u", ADDR4U },
3865 { "a5u", ADDR5U },
3866 { "a6u", ADDR6U },
3867 { "a7u", ADDR7U },
3868
252b5132
RH		 3869 { 0, 0 }
3870};
3871
3872static void
31302357 3873init_regtable (void)
252b5132
RH		 3874{
3875 int i;
3876 for (i = 0; init_table[i].name; i++)
3877 insert_reg (init_table[i].name, init_table[i].number);
3878}
3879
3880static int no_68851, no_68881;
3881
3882#ifdef OBJ_AOUT
3883/* a.out machine type. Default to 68020. */
3884int m68k_aout_machtype = 2;
3885#endif
3886
3887void
31302357 3888md_assemble (char *str)
252b5132
RH		 3889{
3890 const char *er;
3891 short *fromP;
3892 char *toP = NULL;
3893 int m, n = 0;
3894 char *to_beg_P;
3895 int shorts_this_frag;
3896 fixS *fixP;
3897
3898 /* In MRI mode, the instruction and operands are separated by a
3899 space. Anything following the operands is a comment. The label
3900 has already been removed. */
3901 if (flag_mri)
3902 {
3903 char *s;
3904 int fields = 0;
3905 int infield = 0;
3906 int inquote = 0;
3907
3908 for (s = str; *s != '\0'; s++)
3909 {
3910 if ((*s == ' ' || *s == '\t') && ! inquote)
3911 {
3912 if (infield)
3913 {
3914 ++fields;
3915 if (fields >= 2)
3916 {
3917 *s = '\0';
3918 break;
3919 }
3920 infield = 0;
3921 }
3922 }
3923 else
3924 {
3925 if (! infield)
3926 infield = 1;
3927 if (*s == '\'')
3928 inquote = ! inquote;
3929 }
3930 }
3931 }
3932
31302357 3933 memset (&the_ins, '\0', sizeof (the_ins));
252b5132
RH		 3934 m68k_ip (str);
3935 er = the_ins.error;
3936 if (!er)
3937 {
3938 for (n = 0; n < the_ins.numargs; n++)
3939 if (the_ins.operands[n].error)
3940 {
3941 er = the_ins.operands[n].error;
3942 break;
3943 }
3944 }
3945 if (er)
3946 {
3947 as_bad (_("%s -- statement `%s' ignored"), er, str);
3948 return;
3949 }
3950
3951 /* If there is a current label, record that it marks an instruction. */
3952 if (current_label != NULL)
3953 {
3954 current_label->text = 1;
3955 current_label = NULL;
3956 }
3957
f27a3839
AS		 3958#ifdef OBJ_ELF
3959 /* Tie dwarf2 debug info to the address at the start of the insn. */
3960 dwarf2_emit_insn (0);
3961#endif
3962
252b5132
RH		 3963 if (the_ins.nfrag == 0)
3964 {
36759679 3965 /* No frag hacking involved; just put it out. */
252b5132
RH		 3966 toP = frag_more (2 * the_ins.numo);
3967 fromP = &the_ins.opcode[0];
3968 for (m = the_ins.numo; m; --m)
3969 {
3970 md_number_to_chars (toP, (long) (*fromP), 2);
3971 toP += 2;
3972 fromP++;
3973 }
36759679 3974 /* Put out symbol-dependent info. */
252b5132
RH		 3975 for (m = 0; m < the_ins.nrel; m++)
3976 {
3977 switch (the_ins.reloc[m].wid)
3978 {
3979 case 'B':
3980 n = 1;
3981 break;
3982 case 'b':
3983 n = 1;
3984 break;
3985 case '3':
3986 n = 1;
3987 break;
3988 case 'w':
3989 case 'W':
3990 n = 2;
3991 break;
3992 case 'l':
3993 n = 4;
3994 break;
3995 default:
3996 as_fatal (_("Don't know how to figure width of %c in md_assemble()"),
3997 the_ins.reloc[m].wid);
3998 }
3999
4000 fixP = fix_new_exp (frag_now,
4001 ((toP - frag_now->fr_literal)
4002 - the_ins.numo * 2 + the_ins.reloc[m].n),
4003 n,
4004 &the_ins.reloc[m].exp,
4005 the_ins.reloc[m].pcrel,
4006 get_reloc_code (n, the_ins.reloc[m].pcrel,
4007 the_ins.reloc[m].pic_reloc));
4008 fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix;
4009 if (the_ins.reloc[m].wid == 'B')
4010 fixP->fx_signed = 1;
4011 }
4012 return;
4013 }
4014
36759679 4015 /* There's some frag hacking. */
fbe572f9
AM		 4016 {
4017 /* Calculate the max frag size. */
4018 int wid;
4019
4020 wid = 2 * the_ins.fragb[0].fragoff;
4021 for (n = 1; n < the_ins.nfrag; n++)
4022 wid += 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff);
4023 /* frag_var part. */
4024 wid += 10;
4025 /* Make sure the whole insn fits in one chunk, in particular that
4026 the var part is attached, as we access one byte before the
4027 variable frag for byte branches. */
4028 frag_grow (wid);
4029 }
4030
252b5132
RH		 4031 for (n = 0, fromP = &the_ins.opcode[0]; n < the_ins.nfrag; n++)
4032 {
4033 int wid;
4034
4035 if (n == 0)
4036 wid = 2 * the_ins.fragb[n].fragoff;
4037 else
4038 wid = 2 * (the_ins.numo - the_ins.fragb[n - 1].fragoff);
4039 toP = frag_more (wid);
4040 to_beg_P = toP;
4041 shorts_this_frag = 0;
4042 for (m = wid / 2; m; --m)
4043 {
4044 md_number_to_chars (toP, (long) (*fromP), 2);
4045 toP += 2;
4046 fromP++;
4047 shorts_this_frag++;
4048 }
4049 for (m = 0; m < the_ins.nrel; m++)
4050 {
4051 if ((the_ins.reloc[m].n) >= 2 * shorts_this_frag)
4052 {
4053 the_ins.reloc[m].n -= 2 * shorts_this_frag;
4054 break;
4055 }
4056 wid = the_ins.reloc[m].wid;
4057 if (wid == 0)
4058 continue;
4059 the_ins.reloc[m].wid = 0;
4060 wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000;
4061
4062 fixP = fix_new_exp (frag_now,
4063 ((toP - frag_now->fr_literal)
4064 - the_ins.numo * 2 + the_ins.reloc[m].n),
4065 wid,
4066 &the_ins.reloc[m].exp,
4067 the_ins.reloc[m].pcrel,
4068 get_reloc_code (wid, the_ins.reloc[m].pcrel,
4069 the_ins.reloc[m].pic_reloc));
4070 fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix;
4071 }
4072 (void) frag_var (rs_machine_dependent, 10, 0,
4073 (relax_substateT) (the_ins.fragb[n].fragty),
4074 the_ins.fragb[n].fadd, the_ins.fragb[n].foff, to_beg_P);
4075 }
4076 n = (the_ins.numo - the_ins.fragb[n - 1].fragoff);
4077 shorts_this_frag = 0;
4078 if (n)
4079 {
055d1eb0 4080 toP = frag_more (n * 2);
252b5132
RH		 4081 while (n--)
4082 {
4083 md_number_to_chars (toP, (long) (*fromP), 2);
4084 toP += 2;
4085 fromP++;
4086 shorts_this_frag++;
4087 }
4088 }
4089 for (m = 0; m < the_ins.nrel; m++)
4090 {
4091 int wid;
4092
4093 wid = the_ins.reloc[m].wid;
4094 if (wid == 0)
4095 continue;
4096 the_ins.reloc[m].wid = 0;
4097 wid = (wid == 'b') ? 1 : (wid == 'w') ? 2 : (wid == 'l') ? 4 : 4000;
4098
4099 fixP = fix_new_exp (frag_now,
4100 ((the_ins.reloc[m].n + toP - frag_now->fr_literal)
4101 - shorts_this_frag * 2),
4102 wid,
4103 &the_ins.reloc[m].exp,
4104 the_ins.reloc[m].pcrel,
4105 get_reloc_code (wid, the_ins.reloc[m].pcrel,
4106 the_ins.reloc[m].pic_reloc));
4107 fixP->fx_pcrel_adjust = the_ins.reloc[m].pcrel_fix;
4108 }
4109}
4110
60fed2d3
NC		 4111/* Comparison function used by qsort to rank the opcode entries by name. */
4112
4113static int
4114m68k_compare_opcode (const void * v1, const void * v2)
4115{
4116 struct m68k_opcode * op1, * op2;
4117 int ret;
4118
4119 op1 = *(struct m68k_opcode **) v1;
4120 op2 = *(struct m68k_opcode **) v2;
4121
4122 /* Compare the two names. If different, return the comparison.
4123 If the same, return the order they are in the opcode table. */
4124 ret = strcmp (op1->name, op2->name);
4125 if (ret)
4126 return ret;
4127 if (op1 < op2)
4128 return -1;
4129 return 0;
4130}
4131
252b5132 4132void
60fed2d3 4133md_begin (void)
252b5132 4134{
60fed2d3
NC		 4135 const struct m68k_opcode *ins;
4136 struct m68k_incant *hack, *slak;
4137 const char *retval = 0; /* Empty string, or error msg text. */
4138 int i;
4139
4140 /* Set up hash tables with 68000 instructions.
4141 similar to what the vax assembler does. */
252b5132
RH		 4142 /* RMS claims the thing to do is take the m68k-opcode.h table, and make
4143 a copy of it at runtime, adding in the information we want but isn't
4144 there. I think it'd be better to have an awk script hack the table
4145 at compile time. Or even just xstr the table and use it as-is. But
4146 my lord ghod hath spoken, so we do it this way. Excuse the ugly var
4147 names. */
4148
252b5132
RH		 4149 if (flag_mri)
4150 {
4151 flag_reg_prefix_optional = 1;
4152 m68k_abspcadd = 1;
4153 if (! m68k_rel32_from_cmdline)
4154 m68k_rel32 = 0;
4155 }
4156
60fed2d3
NC		 4157 /* First sort the opcode table into alphabetical order to seperate
4158 the order that the assembler wants to see the opcodes from the
4159 order that the disassembler wants to see them. */
4160 m68k_sorted_opcodes = xmalloc (m68k_numopcodes * sizeof (* m68k_sorted_opcodes));
4161 if (!m68k_sorted_opcodes)
4162 as_fatal (_("Internal Error: Can't allocate m68k_sorted_opcodes of size %d"),
045b540e 4163 m68k_numopcodes * ((int) sizeof (* m68k_sorted_opcodes)));
60fed2d3
NC		 4164
4165 for (i = m68k_numopcodes; i--;)
4166 m68k_sorted_opcodes[i] = m68k_opcodes + i;
4167
4168 qsort (m68k_sorted_opcodes, m68k_numopcodes,
4169 sizeof (m68k_sorted_opcodes[0]), m68k_compare_opcode);
4170
252b5132
RH		 4171 op_hash = hash_new ();
4172
4173 obstack_begin (&robyn, 4000);
4174 for (i = 0; i < m68k_numopcodes; i++)
4175 {
4176 hack = slak = (struct m68k_incant *) obstack_alloc (&robyn, sizeof (struct m68k_incant));
4177 do
4178 {
60fed2d3
NC		 4179 ins = m68k_sorted_opcodes[i];
4180
4181 /* We *could* ignore insns that don't match our
4182 arch here by just leaving them out of the hash. */
252b5132
RH		 4183 slak->m_operands = ins->args;
4184 slak->m_opnum = strlen (slak->m_operands) / 2;
4185 slak->m_arch = ins->arch;
4186 slak->m_opcode = ins->opcode;
36759679 4187 /* This is kludgey. */
252b5132
RH		 4188 slak->m_codenum = ((ins->match) & 0xffffL) ? 2 : 1;
4189 if (i + 1 != m68k_numopcodes
60fed2d3 4190 && !strcmp (ins->name, m68k_sorted_opcodes[i + 1]->name))
252b5132 4191 {
60fed2d3 4192 slak->m_next = obstack_alloc (&robyn, sizeof (struct m68k_incant));
252b5132
RH		 4193 i++;
4194 }
4195 else
4196 slak->m_next = 0;
4197 slak = slak->m_next;
4198 }
4199 while (slak);
4200
4201 retval = hash_insert (op_hash, ins->name, (char *) hack);
4202 if (retval)
4203 as_fatal (_("Internal Error: Can't hash %s: %s"), ins->name, retval);
4204 }
4205
4206 for (i = 0; i < m68k_numaliases; i++)
4207 {
4208 const char *name = m68k_opcode_aliases[i].primary;
4209 const char *alias = m68k_opcode_aliases[i].alias;
4210 PTR val = hash_find (op_hash, name);
60fed2d3 4211
252b5132
RH		 4212 if (!val)
4213 as_fatal (_("Internal Error: Can't find %s in hash table"), name);
4214 retval = hash_insert (op_hash, alias, val);
4215 if (retval)
4216 as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval);
4217 }
4218
4219 /* In MRI mode, all unsized branches are variable sized. Normally,
4220 they are word sized. */
4221 if (flag_mri)
4222 {
4223 static struct m68k_opcode_alias mri_aliases[] =
4224 {
4225 { "bhi", "jhi", },
4226 { "bls", "jls", },
4227 { "bcc", "jcc", },
4228 { "bcs", "jcs", },
4229 { "bne", "jne", },
4230 { "beq", "jeq", },
4231 { "bvc", "jvc", },
4232 { "bvs", "jvs", },
4233 { "bpl", "jpl", },
4234 { "bmi", "jmi", },
4235 { "bge", "jge", },
4236 { "blt", "jlt", },
4237 { "bgt", "jgt", },
4238 { "ble", "jle", },
4239 { "bra", "jra", },
4240 { "bsr", "jbsr", },
4241 };
4242
8fce3f5e
AM		 4243 for (i = 0;
4244 i < (int) (sizeof mri_aliases / sizeof mri_aliases[0]);
4245 i++)
252b5132
RH		 4246 {
4247 const char *name = mri_aliases[i].primary;
4248 const char *alias = mri_aliases[i].alias;
4249 PTR val = hash_find (op_hash, name);
60fed2d3 4250
252b5132
RH		 4251 if (!val)
4252 as_fatal (_("Internal Error: Can't find %s in hash table"), name);
4253 retval = hash_jam (op_hash, alias, val);
4254 if (retval)
4255 as_fatal (_("Internal Error: Can't hash %s: %s"), alias, retval);
4256 }
4257 }
4258
8fce3f5e 4259 for (i = 0; i < (int) sizeof (notend_table); i++)
252b5132
RH		 4260 {
4261 notend_table[i] = 0;
4262 alt_notend_table[i] = 0;
4263 }
60fed2d3 4264
252b5132
RH		 4265 notend_table[','] = 1;
4266 notend_table['{'] = 1;
4267 notend_table['}'] = 1;
4268 alt_notend_table['a'] = 1;
4269 alt_notend_table['A'] = 1;
4270 alt_notend_table['d'] = 1;
4271 alt_notend_table['D'] = 1;
4272 alt_notend_table['#'] = 1;
4273 alt_notend_table['&'] = 1;
4274 alt_notend_table['f'] = 1;
4275 alt_notend_table['F'] = 1;
4276#ifdef REGISTER_PREFIX
4277 alt_notend_table[REGISTER_PREFIX] = 1;
4278#endif
4279
4280 /* We need to put '(' in alt_notend_table to handle
60fed2d3 4281 cas2 %d0:%d2,%d3:%d4,(%a0):(%a1) */
252b5132
RH		 4282 alt_notend_table['('] = 1;
4283
4284 /* We need to put '@' in alt_notend_table to handle
60fed2d3 4285 cas2 %d0:%d2,%d3:%d4,@(%d0):@(%d1) */
252b5132
RH		 4286 alt_notend_table['@'] = 1;
4287
4288 /* We need to put digits in alt_notend_table to handle
60fed2d3 4289 bfextu %d0{24:1},%d0 */
252b5132
RH		 4290 alt_notend_table['0'] = 1;
4291 alt_notend_table['1'] = 1;
4292 alt_notend_table['2'] = 1;
4293 alt_notend_table['3'] = 1;
4294 alt_notend_table['4'] = 1;
4295 alt_notend_table['5'] = 1;
4296 alt_notend_table['6'] = 1;
4297 alt_notend_table['7'] = 1;
4298 alt_notend_table['8'] = 1;
4299 alt_notend_table['9'] = 1;
4300
4301#ifndef MIT_SYNTAX_ONLY
4302 /* Insert pseudo ops, these have to go into the opcode table since
36759679 4303 gas expects pseudo ops to start with a dot. */
252b5132
RH		 4304 {
4305 int n = 0;
60fed2d3 4306
252b5132
RH		 4307 while (mote_pseudo_table[n].poc_name)
4308 {
60fed2d3 4309 hack = obstack_alloc (&robyn, sizeof (struct m68k_incant));
252b5132
RH		 4310 hash_insert (op_hash,
4311 mote_pseudo_table[n].poc_name, (char *) hack);
4312 hack->m_operands = 0;
4313 hack->m_opnum = n;
4314 n++;
4315 }
4316 }
4317#endif
4318
4319 init_regtable ();
4320
4321#ifdef OBJ_ELF
4322 record_alignment (text_section, 2);
4323 record_alignment (data_section, 2);
4324 record_alignment (bss_section, 2);
4325#endif
4326}
4327
4328static void
31302357 4329select_control_regs (void)
252b5132
RH		 4330{
4331 /* Note which set of "movec" control registers is available. */
6b6e92f4 4332 switch (current_chip)
252b5132 4333 {
4f2a7c9e 4334 case 0:
6b6e92f4
NC		 4335 if (verbose)
4336 as_warn (_("architecture not yet selected: defaulting to 68020"));
4f2a7c9e
NC		 4337 control_regs = m68020_control_regs;
4338 break;
4339
252b5132
RH		 4340 case m68000:
4341 control_regs = m68000_control_regs;
4342 break;
4343 case m68010:
4344 control_regs = m68010_control_regs;
4345 break;
4346 case m68020:
4347 case m68030:
4348 control_regs = m68020_control_regs;
4349 break;
4350 case m68040:
4351 control_regs = m68040_control_regs;
4352 break;
4353 case m68060:
4354 control_regs = m68060_control_regs;
4355 break;
4356 case cpu32:
4357 control_regs = cpu32_control_regs;
4358 break;
4359 case mcf5200:
6da466c7
ILT		 4360 case mcf5206e:
4361 case mcf5307:
dc84e067 4362 case mcf5407:
6da466c7 4363 control_regs = mcf_control_regs;
252b5132 4364 break;
e80e0390
NC		 4365 case mcf5249:
4366 control_regs = mcf5249_control_regs;
4367 break;
3e602632 4368 case mcf528x:
6b6e92f4 4369 case mcf521x:
3e602632
NC		 4370 control_regs = mcf528x_control_regs;
4371 break;
6b6e92f4
NC		 4372 case mcf5470:
4373 case mcf5480:
3e602632
NC		 4374 control_regs = mcfv4e_control_regs;
4375 break;
252b5132
RH		 4376 default:
4377 abort ();
4378 }
4379}
4380
4381void
31302357 4382m68k_init_after_args (void)
252b5132
RH		 4383{
4384 if (cpu_of_arch (current_architecture) == 0)
4385 {
4386 int i;
4387 const char *default_cpu = TARGET_CPU;
4388
4389 if (*default_cpu == 'm')
4390 default_cpu++;
4391 for (i = 0; i < n_archs; i++)
4392 if (strcasecmp (default_cpu, archs[i].name) == 0)
4393 break;
4394 if (i == n_archs)
4395 {
4396 as_bad (_("unrecognized default cpu `%s' ???"), TARGET_CPU);
4397 current_architecture |= m68020;
4398 }
4399 else
4400 current_architecture |= archs[i].arch;
4401 }
4402 /* Permit m68881 specification with all cpus; those that can't work
4403 with a coprocessor could be doing emulation. */
4404 if (current_architecture & m68851)
4405 {
4406 if (current_architecture & m68040)
60fed2d3 4407 as_warn (_("68040 and 68851 specified; mmu instructions may assemble incorrectly"));
252b5132
RH		 4408 }
4409 /* What other incompatibilities could we check for? */
4410
4411 /* Toss in some default assumptions about coprocessors. */
4412 if (!no_68881
4413 && (cpu_of_arch (current_architecture)
4414 /* Can CPU32 have a 68881 coprocessor?? */
4415 & (m68020 | m68030 | cpu32)))
60fed2d3
NC		 4416 current_architecture |= m68881;
4417
252b5132
RH		 4418 if (!no_68851
4419 && (cpu_of_arch (current_architecture) & m68020up) != 0
4420 && (cpu_of_arch (current_architecture) & m68040up) == 0)
60fed2d3
NC		 4421 current_architecture |= m68851;
4422
252b5132
RH		 4423 if (no_68881 && (current_architecture & m68881))
4424 as_bad (_("options for 68881 and no-68881 both given"));
60fed2d3 4425
252b5132
RH		 4426 if (no_68851 && (current_architecture & m68851))
4427 as_bad (_("options for 68851 and no-68851 both given"));
4428
4429#ifdef OBJ_AOUT
4430 /* Work out the magic number. This isn't very general. */
4431 if (current_architecture & m68000)
4432 m68k_aout_machtype = 0;
4433 else if (current_architecture & m68010)
4434 m68k_aout_machtype = 1;
4435 else if (current_architecture & m68020)
4436 m68k_aout_machtype = 2;
4437 else
4438 m68k_aout_machtype = 2;
4439#endif
4440
4441 /* Note which set of "movec" control registers is available. */
4442 select_control_regs ();
4443
4444 if (cpu_of_arch (current_architecture) < m68020
6da466c7 4445 || arch_coldfire_p (current_architecture))
252b5132
RH		 4446 md_relax_table[TAB (PCINDEX, BYTE)].rlx_more = 0;
4447}
4448\f
4449/* This is called when a label is defined. */
4450
4451void
31302357 4452m68k_frob_label (symbolS *sym)
252b5132
RH		 4453{
4454 struct label_line *n;
4455
4456 n = (struct label_line *) xmalloc (sizeof *n);
4457 n->next = labels;
4458 n->label = sym;
4459 as_where (&n->file, &n->line);
4460 n->text = 0;
4461 labels = n;
4462 current_label = n;
4463}
4464
4465/* This is called when a value that is not an instruction is emitted. */
4466
4467void
31302357 4468m68k_flush_pending_output (void)
252b5132
RH		 4469{
4470 current_label = NULL;
4471}
4472
4473/* This is called at the end of the assembly, when the final value of
4474 the label is known. We warn if this is a text symbol aligned at an
4475 odd location. */
4476
4477void
31302357 4478m68k_frob_symbol (symbolS *sym)
252b5132
RH		 4479{
4480 if (S_GET_SEGMENT (sym) == reg_section
4481 && (int) S_GET_VALUE (sym) < 0)
4482 {
4483 S_SET_SEGMENT (sym, absolute_section);
4484 S_SET_VALUE (sym, ~(int)S_GET_VALUE (sym));
4485 }
4486 else if ((S_GET_VALUE (sym) & 1) != 0)
4487 {
4488 struct label_line *l;
4489
4490 for (l = labels; l != NULL; l = l->next)
4491 {
4492 if (l->label == sym)
4493 {
4494 if (l->text)
4495 as_warn_where (l->file, l->line,
4496 _("text label `%s' aligned to odd boundary"),
4497 S_GET_NAME (sym));
4498 break;
4499 }
4500 }
4501 }
4502}
4503\f
4504/* This is called if we go in or out of MRI mode because of the .mri
4505 pseudo-op. */
4506
4507void
31302357 4508m68k_mri_mode_change (int on)
252b5132
RH		 4509{
4510 if (on)
4511 {
4512 if (! flag_reg_prefix_optional)
4513 {
4514 flag_reg_prefix_optional = 1;
4515#ifdef REGISTER_PREFIX
4516 init_regtable ();
4517#endif
4518 }
4519 m68k_abspcadd = 1;
4520 if (! m68k_rel32_from_cmdline)
4521 m68k_rel32 = 0;
4522 }
4523 else
4524 {
4525 if (! reg_prefix_optional_seen)
4526 {
4527#ifdef REGISTER_PREFIX_OPTIONAL
4528 flag_reg_prefix_optional = REGISTER_PREFIX_OPTIONAL;
4529#else
4530 flag_reg_prefix_optional = 0;
4531#endif
4532#ifdef REGISTER_PREFIX
4533 init_regtable ();
4534#endif
4535 }
4536 m68k_abspcadd = 0;
4537 if (! m68k_rel32_from_cmdline)
4538 m68k_rel32 = 1;
4539 }
4540}
4541
36759679 4542/* Equal to MAX_PRECISION in atof-ieee.c. */
252b5132
RH		 4543#define MAX_LITTLENUMS 6
4544
4545/* Turn a string in input_line_pointer into a floating point constant
bc0d738a
NC		 4546 of type TYPE, and store the appropriate bytes in *LITP. The number
4547 of LITTLENUMS emitted is stored in *SIZEP. An error message is
252b5132
RH		 4548 returned, or NULL on OK. */
4549
4550char *
31302357 4551md_atof (int type, char *litP, int *sizeP)
252b5132
RH		 4552{
4553 int prec;
4554 LITTLENUM_TYPE words[MAX_LITTLENUMS];
4555 LITTLENUM_TYPE *wordP;
4556 char *t;
4557
4558 switch (type)
4559 {
4560 case 'f':
4561 case 'F':
4562 case 's':
4563 case 'S':
4564 prec = 2;
4565 break;
4566
4567 case 'd':
4568 case 'D':
4569 case 'r':
4570 case 'R':
4571 prec = 4;
4572 break;
4573
4574 case 'x':
4575 case 'X':
4576 prec = 6;
4577 break;
4578
4579 case 'p':
4580 case 'P':
4581 prec = 6;
4582 break;
4583
4584 default:
4585 *sizeP = 0;
4586 return _("Bad call to MD_ATOF()");
4587 }
4588 t = atof_ieee (input_line_pointer, type, words);
4589 if (t)
4590 input_line_pointer = t;
4591
4592 *sizeP = prec * sizeof (LITTLENUM_TYPE);
4593 for (wordP = words; prec--;)
4594 {
4595 md_number_to_chars (litP, (long) (*wordP++), sizeof (LITTLENUM_TYPE));
4596 litP += sizeof (LITTLENUM_TYPE);
4597 }
4598 return 0;
4599}
4600
4601void
31302357 4602md_number_to_chars (char *buf, valueT val, int n)
252b5132
RH		 4603{
4604 number_to_chars_bigendian (buf, val, n);
4605}
4606
94f592af 4607void
31302357 4608md_apply_fix3 (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
252b5132 4609{
bbe8ef22 4610 offsetT val = *valP;
252b5132
RH		 4611 addressT upper_limit;
4612 offsetT lower_limit;
4613
4614 /* This is unnecessary but it convinces the native rs6000 compiler
4615 to generate the code we want. */
4616 char *buf = fixP->fx_frag->fr_literal;
4617 buf += fixP->fx_where;
36759679 4618 /* End ibm compiler workaround. */
252b5132 4619
bd17c2c3 4620 val = SEXT (val);
252b5132 4621
94f592af
NC		 4622 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
4623 fixP->fx_done = 1;
4624
252b5132
RH		 4625#ifdef OBJ_ELF
4626 if (fixP->fx_addsy)
4627 {
4628 memset (buf, 0, fixP->fx_size);
36759679 4629 fixP->fx_addnumber = val; /* Remember value for emit_reloc. */
252b5132
RH		 4630
4631 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4632 && !S_IS_DEFINED (fixP->fx_addsy)
4633 && !S_IS_WEAK (fixP->fx_addsy))
4634 S_SET_WEAK (fixP->fx_addsy);
4635 return;
4636 }
4637#endif
4638
4639#ifdef BFD_ASSEMBLER
4640 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
4641 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
4642 return;
4643#endif
4644
4645 switch (fixP->fx_size)
4646 {
94f592af
NC		 4647 /* The cast to offsetT below are necessary to make code
4648 correct for machines where ints are smaller than offsetT. */
252b5132
RH		 4649 case 1:
4650 *buf++ = val;
4651 upper_limit = 0x7f;
4652 lower_limit = - (offsetT) 0x80;
4653 break;
4654 case 2:
4655 *buf++ = (val >> 8);
4656 *buf++ = val;
4657 upper_limit = 0x7fff;
4658 lower_limit = - (offsetT) 0x8000;
4659 break;
4660 case 4:
4661 *buf++ = (val >> 24);
4662 *buf++ = (val >> 16);
4663 *buf++ = (val >> 8);
4664 *buf++ = val;
4665 upper_limit = 0x7fffffff;
36759679 4666 lower_limit = - (offsetT) 0x7fffffff - 1; /* Avoid constant overflow. */
252b5132
RH		 4667 break;
4668 default:
4669 BAD_CASE (fixP->fx_size);
4670 }
4671
4672 /* Fix up a negative reloc. */
4673 if (fixP->fx_addsy == NULL && fixP->fx_subsy != NULL)
4674 {
4675 fixP->fx_addsy = fixP->fx_subsy;
4676 fixP->fx_subsy = NULL;
4677 fixP->fx_tcbit = 1;
4678 }
4679
4680 /* For non-pc-relative values, it's conceivable we might get something
4681 like "0xff" for a byte field. So extend the upper part of the range
4682 to accept such numbers. We arbitrarily disallow "-0xff" or "0xff+0xff",
4683 so that we can do any range checking at all. */
4684 if (! fixP->fx_pcrel && ! fixP->fx_signed)
4685 upper_limit = upper_limit * 2 + 1;
4686
4687 if ((addressT) val > upper_limit
4688 && (val > 0 || val < lower_limit))
4689 as_bad_where (fixP->fx_file, fixP->fx_line, _("value out of range"));
4690
4691 /* A one byte PC-relative reloc means a short branch. We can't use
4692 a short branch with a value of 0 or -1, because those indicate
4693 different opcodes (branches with longer offsets). fixup_segment
4694 in write.c may have clobbered fx_pcrel, so we need to examine the
4695 reloc type. */
4696 if ((fixP->fx_pcrel
4697#ifdef BFD_ASSEMBLER
4698 || fixP->fx_r_type == BFD_RELOC_8_PCREL
4699#endif
4700 )
4701 && fixP->fx_size == 1
4702 && (fixP->fx_addsy == NULL
4703 || S_IS_DEFINED (fixP->fx_addsy))
4704 && (val == 0 || val == -1))
4705 as_bad_where (fixP->fx_file, fixP->fx_line, _("invalid byte branch offset"));
4706}
4707
252b5132
RH		 4708/* *fragP has been relaxed to its final size, and now needs to have
4709 the bytes inside it modified to conform to the new size There is UGLY
4710 MAGIC here. ..
4711 */
4712static void
31302357 4713md_convert_frag_1 (fragS *fragP)
252b5132
RH		 4714{
4715 long disp;
252b5132
RH		 4716 fixS *fixP;
4717
4718 /* Address in object code of the displacement. */
4719 register int object_address = fragP->fr_fix + fragP->fr_address;
4720
4721 /* Address in gas core of the place to store the displacement. */
4722 /* This convinces the native rs6000 compiler to generate the code we
92774660 4723 want. */
252b5132
RH		 4724 register char *buffer_address = fragP->fr_literal;
4725 buffer_address += fragP->fr_fix;
36759679 4726 /* End ibm compiler workaround. */
252b5132
RH		 4727
4728 /* The displacement of the address, from current location. */
4729 disp = fragP->fr_symbol ? S_GET_VALUE (fragP->fr_symbol) : 0;
4730 disp = (disp + fragP->fr_offset) - object_address;
4731
252b5132
RH		 4732 switch (fragP->fr_subtype)
4733 {
151337e8
NC		 4734 case TAB (BRANCHBWL, BYTE):
4735 case TAB (BRABSJUNC, BYTE):
4736 case TAB (BRABSJCOND, BYTE):
4737 case TAB (BRANCHBW, BYTE):
252b5132
RH		 4738 know (issbyte (disp));
4739 if (disp == 0)
b091f402
AM		 4740 as_bad_where (fragP->fr_file, fragP->fr_line,
4741 _("short branch with zero offset: use :w"));
151337e8 4742 fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol,
5cbdaa77 4743 fragP->fr_offset, 1, RELAX_RELOC_PC8);
151337e8 4744 fixP->fx_pcrel_adjust = -1;
252b5132 4745 break;
151337e8
NC		 4746 case TAB (BRANCHBWL, SHORT):
4747 case TAB (BRABSJUNC, SHORT):
4748 case TAB (BRABSJCOND, SHORT):
4749 case TAB (BRANCHBW, SHORT):
252b5132 4750 fragP->fr_opcode[1] = 0x00;
151337e8 4751 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4752 1, RELAX_RELOC_PC16);
151337e8
NC		 4753 fragP->fr_fix += 2;
4754 break;
4755 case TAB (BRANCHBWL, LONG):
4756 fragP->fr_opcode[1] = (char) 0xFF;
4757 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4758 1, RELAX_RELOC_PC32);
151337e8 4759 fragP->fr_fix += 4;
252b5132 4760 break;
151337e8
NC		 4761 case TAB (BRABSJUNC, LONG):
4762 if (fragP->fr_opcode[0] == 0x61) /* jbsr */
252b5132 4763 {
36759679 4764 if (flag_keep_pcrel)
6b6e92f4 4765 as_fatal (_("Tried to convert PC relative BSR to absolute JSR"));
151337e8 4766 fragP->fr_opcode[0] = 0x4E;
36759679 4767 fragP->fr_opcode[1] = (char) 0xB9; /* JSR with ABSL LONG operand. */
151337e8 4768 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
3ae647a0 4769 0, RELAX_RELOC_ABS32);
151337e8
NC		 4770 fragP->fr_fix += 4;
4771 }
4772 else if (fragP->fr_opcode[0] == 0x60) /* jbra */
4773 {
36759679 4774 if (flag_keep_pcrel)
6b6e92f4 4775 as_fatal (_("Tried to convert PC relative branch to absolute jump"));
151337e8 4776 fragP->fr_opcode[0] = 0x4E;
36759679 4777 fragP->fr_opcode[1] = (char) 0xF9; /* JMP with ABSL LONG operand. */
151337e8 4778 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4779 0, RELAX_RELOC_ABS32);
151337e8 4780 fragP->fr_fix += 4;
252b5132
RH		 4781 }
4782 else
4783 {
151337e8
NC		 4784 /* This cannot happen, because jbsr and jbra are the only two
4785 unconditional branches. */
4786 abort ();
252b5132
RH		 4787 }
4788 break;
151337e8 4789 case TAB (BRABSJCOND, LONG):
36759679 4790 if (flag_keep_pcrel)
6b6e92f4 4791 as_fatal (_("Tried to convert PC relative conditional branch to absolute jump"));
92774660 4792
36759679
NC		 4793 /* Only Bcc 68000 instructions can come here
4794 Change bcc into b!cc/jmp absl long. */
4795 fragP->fr_opcode[0] ^= 0x01; /* Invert bcc. */
4796 fragP->fr_opcode[1] = 0x06; /* Branch offset = 6. */
252b5132
RH		 4797
4798 /* JF: these used to be fr_opcode[2,3], but they may be in a
67c1ffbe 4799 different frag, in which case referring to them is a no-no.
92774660 4800 Only fr_opcode[0,1] are guaranteed to work. */
252b5132
RH		 4801 *buffer_address++ = 0x4e; /* put in jmp long (0x4ef9) */
4802 *buffer_address++ = (char) 0xf9;
36759679 4803 fragP->fr_fix += 2; /* Account for jmp instruction. */
252b5132 4804 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol,
5cbdaa77 4805 fragP->fr_offset, 0, RELAX_RELOC_ABS32);
151337e8
NC		 4806 fragP->fr_fix += 4;
4807 break;
4808 case TAB (FBRANCH, SHORT):
4809 know ((fragP->fr_opcode[1] & 0x40) == 0);
4810 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4811 1, RELAX_RELOC_PC16);
151337e8
NC		 4812 fragP->fr_fix += 2;
4813 break;
4814 case TAB (FBRANCH, LONG):
36759679 4815 fragP->fr_opcode[1] |= 0x40; /* Turn on LONG bit. */
151337e8 4816 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4817 1, RELAX_RELOC_PC32);
252b5132 4818 fragP->fr_fix += 4;
252b5132 4819 break;
151337e8
NC		 4820 case TAB (DBCCLBR, SHORT):
4821 case TAB (DBCCABSJ, SHORT):
4822 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4823 1, RELAX_RELOC_PC16);
151337e8
NC		 4824 fragP->fr_fix += 2;
4825 break;
4826 case TAB (DBCCLBR, LONG):
36759679
NC		 4827 /* Only DBcc instructions can come here.
4828 Change dbcc into dbcc/bral.
4829 JF: these used to be fr_opcode[2-7], but that's wrong. */
4830 if (flag_keep_pcrel)
6b6e92f4 4831 as_fatal (_("Tried to convert DBcc to absolute jump"));
28e7409f 4832
36759679 4833 *buffer_address++ = 0x00; /* Branch offset = 4. */
252b5132 4834 *buffer_address++ = 0x04;
36759679 4835 *buffer_address++ = 0x60; /* Put in bra pc+6. */
252b5132 4836 *buffer_address++ = 0x06;
151337e8
NC		 4837 *buffer_address++ = 0x60; /* Put in bral (0x60ff). */
4838 *buffer_address++ = (char) 0xff;
252b5132 4839
36759679 4840 fragP->fr_fix += 6; /* Account for bra/jmp instructions. */
151337e8 4841 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset, 1,
5cbdaa77 4842 RELAX_RELOC_PC32);
252b5132 4843 fragP->fr_fix += 4;
252b5132 4844 break;
151337e8 4845 case TAB (DBCCABSJ, LONG):
36759679
NC		 4846 /* Only DBcc instructions can come here.
4847 Change dbcc into dbcc/jmp.
4848 JF: these used to be fr_opcode[2-7], but that's wrong. */
4849 if (flag_keep_pcrel)
6b6e92f4 4850 as_fatal (_("Tried to convert PC relative conditional branch to absolute jump"));
151337e8 4851
36759679 4852 *buffer_address++ = 0x00; /* Branch offset = 4. */
151337e8 4853 *buffer_address++ = 0x04;
36759679 4854 *buffer_address++ = 0x60; /* Put in bra pc + 6. */
151337e8 4855 *buffer_address++ = 0x06;
36759679 4856 *buffer_address++ = 0x4e; /* Put in jmp long (0x4ef9). */
151337e8
NC		 4857 *buffer_address++ = (char) 0xf9;
4858
36759679 4859 fragP->fr_fix += 6; /* Account for bra/jmp instructions. */
151337e8 4860 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset, 0,
5cbdaa77 4861 RELAX_RELOC_ABS32);
252b5132 4862 fragP->fr_fix += 4;
252b5132 4863 break;
151337e8 4864 case TAB (PCREL1632, SHORT):
252b5132
RH		 4865 fragP->fr_opcode[1] &= ~0x3F;
4866 fragP->fr_opcode[1] |= 0x3A; /* 072 - mode 7.2 */
151337e8 4867 fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
5cbdaa77 4868 fragP->fr_offset, 1, RELAX_RELOC_PC16);
151337e8 4869 fragP->fr_fix += 2;
252b5132 4870 break;
151337e8 4871 case TAB (PCREL1632, LONG):
252b5132
RH		 4872 /* Already set to mode 7.3; this indicates: PC indirect with
4873 suppressed index, 32-bit displacement. */
4874 *buffer_address++ = 0x01;
4875 *buffer_address++ = 0x70;
4876 fragP->fr_fix += 2;
151337e8 4877 fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
5cbdaa77 4878 fragP->fr_offset, 1, RELAX_RELOC_PC32);
151337e8
NC		 4879 fixP->fx_pcrel_adjust = 2;
4880 fragP->fr_fix += 4;
252b5132 4881 break;
252b5132 4882 case TAB (PCINDEX, BYTE):
252b5132
RH		 4883 assert (fragP->fr_fix >= 2);
4884 buffer_address[-2] &= ~1;
151337e8 4885 fixP = fix_new (fragP, fragP->fr_fix - 1, 1, fragP->fr_symbol,
5cbdaa77 4886 fragP->fr_offset, 1, RELAX_RELOC_PC8);
151337e8 4887 fixP->fx_pcrel_adjust = 1;
252b5132
RH		 4888 break;
4889 case TAB (PCINDEX, SHORT):
252b5132
RH		 4890 assert (fragP->fr_fix >= 2);
4891 buffer_address[-2] |= 0x1;
4892 buffer_address[-1] = 0x20;
4893 fixP = fix_new (fragP, (int) (fragP->fr_fix), 2, fragP->fr_symbol,
5cbdaa77 4894 fragP->fr_offset, 1, RELAX_RELOC_PC16);
252b5132 4895 fixP->fx_pcrel_adjust = 2;
151337e8 4896 fragP->fr_fix += 2;
252b5132
RH		 4897 break;
4898 case TAB (PCINDEX, LONG):
252b5132
RH		 4899 assert (fragP->fr_fix >= 2);
4900 buffer_address[-2] |= 0x1;
4901 buffer_address[-1] = 0x30;
151337e8 4902 fixP = fix_new (fragP, (int) (fragP->fr_fix), 4, fragP->fr_symbol,
5cbdaa77 4903 fragP->fr_offset, 1, RELAX_RELOC_PC32);
151337e8
NC		 4904 fixP->fx_pcrel_adjust = 2;
4905 fragP->fr_fix += 4;
4906 break;
4907 case TAB (ABSTOPCREL, SHORT):
4908 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4909 1, RELAX_RELOC_PC16);
151337e8
NC		 4910 fragP->fr_fix += 2;
4911 break;
4912 case TAB (ABSTOPCREL, LONG):
36759679 4913 if (flag_keep_pcrel)
6b6e92f4 4914 as_fatal (_("Tried to convert PC relative conditional branch to absolute jump"));
151337e8 4915 /* The thing to do here is force it to ABSOLUTE LONG, since
36759679 4916 ABSTOPCREL is really trying to shorten an ABSOLUTE address anyway. */
151337e8
NC		 4917 if ((fragP->fr_opcode[1] & 0x3F) != 0x3A)
4918 abort ();
4919 fragP->fr_opcode[1] &= ~0x3F;
4920 fragP->fr_opcode[1] |= 0x39; /* Mode 7.1 */
4921 fix_new (fragP, fragP->fr_fix, 4, fragP->fr_symbol, fragP->fr_offset,
5cbdaa77 4922 0, RELAX_RELOC_ABS32);
151337e8 4923 fragP->fr_fix += 4;
252b5132 4924 break;
252b5132
RH		 4925 }
4926}
4927
4928#ifndef BFD_ASSEMBLER
4929
4930void
31302357
AS		 4931md_convert_frag (object_headers *headers ATTRIBUTE_UNUSED,
4932 segT sec ATTRIBUTE_UNUSED,
4933 fragS *fragP)
252b5132
RH		 4934{
4935 md_convert_frag_1 (fragP);
4936}
4937
4938#else
4939
4940void
31302357
AS		 4941md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
4942 segT sec ATTRIBUTE_UNUSED,
4943 fragS *fragP)
252b5132
RH		 4944{
4945 md_convert_frag_1 (fragP);
4946}
4947#endif
4948
4949/* Force truly undefined symbols to their maximum size, and generally set up
4950 the frag list to be relaxed
4951 */
4952int
31302357 4953md_estimate_size_before_relax (fragS *fragP, segT segment)
252b5132 4954{
151337e8 4955 /* Handle SZ_UNDEF first, it can be changed to BYTE or SHORT. */
252b5132
RH		 4956 switch (fragP->fr_subtype)
4957 {
151337e8
NC		 4958 case TAB (BRANCHBWL, SZ_UNDEF):
4959 case TAB (BRABSJUNC, SZ_UNDEF):
151337e8 4960 case TAB (BRABSJCOND, SZ_UNDEF):
252b5132 4961 {
151337e8
NC		 4962 if (S_GET_SEGMENT (fragP->fr_symbol) == segment
4963 && relaxable_symbol (fragP->fr_symbol))
252b5132 4964 {
151337e8
NC		 4965 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
4966 }
4967 else if (flag_short_refs)
4968 {
4969 /* Symbol is undefined and we want short ref. */
4970 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
252b5132
RH		 4971 }
4972 else
4973 {
151337e8
NC		 4974 /* Symbol is still undefined. Make it LONG. */
4975 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG);
252b5132
RH		 4976 }
4977 break;
151337e8 4978 }
252b5132 4979
151337e8 4980 case TAB (BRANCHBW, SZ_UNDEF):
252b5132 4981 {
151337e8
NC		 4982 if (S_GET_SEGMENT (fragP->fr_symbol) == segment
4983 && relaxable_symbol (fragP->fr_symbol))
252b5132 4984 {
151337e8 4985 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), BYTE);
252b5132
RH		 4986 }
4987 else
4988 {
151337e8
NC		 4989 /* Symbol is undefined and we don't have long branches. */
4990 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
252b5132
RH		 4991 }
4992 break;
151337e8 4993 }
252b5132 4994
151337e8 4995 case TAB (FBRANCH, SZ_UNDEF):
151337e8
NC		 4996 case TAB (DBCCLBR, SZ_UNDEF):
4997 case TAB (DBCCABSJ, SZ_UNDEF):
5c65dbc1 4998 case TAB (PCREL1632, SZ_UNDEF):
252b5132 4999 {
8ec6253e
NC		 5000 if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
5001 && relaxable_symbol (fragP->fr_symbol))
151337e8 5002 || flag_short_refs)
252b5132 5003 {
151337e8 5004 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
252b5132
RH		 5005 }
5006 else
5007 {
151337e8 5008 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), LONG);
252b5132
RH		 5009 }
5010 break;
151337e8 5011 }
81d4177b 5012
252b5132
RH		 5013 case TAB (PCINDEX, SZ_UNDEF):
5014 if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
151337e8 5015 && relaxable_symbol (fragP->fr_symbol)))
252b5132
RH		 5016 {
5017 fragP->fr_subtype = TAB (PCINDEX, BYTE);
5018 }
5019 else
5020 {
5021 fragP->fr_subtype = TAB (PCINDEX, LONG);
252b5132
RH		 5022 }
5023 break;
5024
151337e8
NC		 5025 case TAB (ABSTOPCREL, SZ_UNDEF):
5026 {
5027 if ((S_GET_SEGMENT (fragP->fr_symbol) == segment
5028 && relaxable_symbol (fragP->fr_symbol)))
5029 {
5030 fragP->fr_subtype = TAB (ABSTOPCREL, SHORT);
151337e8
NC		 5031 }
5032 else
5033 {
5034 fragP->fr_subtype = TAB (ABSTOPCREL, LONG);
151337e8
NC		 5035 }
5036 break;
5037 }
5038
252b5132
RH		 5039 default:
5040 break;
5041 }
5042
151337e8 5043 /* Now that SZ_UNDEF are taken care of, check others. */
252b5132
RH		 5044 switch (fragP->fr_subtype)
5045 {
151337e8
NC		 5046 case TAB (BRANCHBWL, BYTE):
5047 case TAB (BRABSJUNC, BYTE):
5048 case TAB (BRABSJCOND, BYTE):
5049 case TAB (BRANCHBW, BYTE):
252b5132 5050 /* We can't do a short jump to the next instruction, so in that
ac62c346
AM		 5051 case we force word mode. If the symbol is at the start of a
5052 frag, and it is the next frag with any data in it (usually
5053 this is just the next frag, but assembler listings may
5054 introduce empty frags), we must use word mode. */
5055 if (fragP->fr_symbol)
252b5132 5056 {
ac62c346 5057 fragS *sym_frag;
252b5132 5058
ac62c346
AM		 5059 sym_frag = symbol_get_frag (fragP->fr_symbol);
5060 if (S_GET_VALUE (fragP->fr_symbol) == sym_frag->fr_address)
252b5132 5061 {
ac62c346
AM		 5062 fragS *l;
5063
23b7f870 5064 for (l = fragP->fr_next; l && l != sym_frag; l = l->fr_next)
ac62c346
AM		 5065 if (l->fr_fix != 0)
5066 break;
5067 if (l == sym_frag)
5068 fragP->fr_subtype = TAB (TABTYPE (fragP->fr_subtype), SHORT);
252b5132
RH		 5069 }
5070 }
5071 break;
5072 default:
5073 break;
5074 }
ac62c346 5075 return md_relax_table[fragP->fr_subtype].rlx_length;
252b5132
RH		 5076}
5077
5078#if defined(OBJ_AOUT) | defined(OBJ_BOUT)
5079/* the bit-field entries in the relocation_info struct plays hell
5080 with the byte-order problems of cross-assembly. So as a hack,
5081 I added this mach. dependent ri twiddler. Ugly, but it gets
36759679 5082 you there. -KWK */
252b5132
RH		 5083/* on m68k: first 4 bytes are normal unsigned long, next three bytes
5084 are symbolnum, most sig. byte first. Last byte is broken up with
5085 bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower
5086 nibble as nuthin. (on Sun 3 at least) */
5087/* Translate the internal relocation information into target-specific
92774660 5088 format. */
252b5132
RH		 5089#ifdef comment
5090void
31302357 5091md_ri_to_chars (char *the_bytes, struct reloc_info_generic *ri)
252b5132 5092{
36759679 5093 /* This is easy. */
252b5132 5094 md_number_to_chars (the_bytes, ri->r_address, 4);
36759679 5095 /* Now the fun stuff. */
252b5132 5096 the_bytes[4] = (ri->r_symbolnum >> 16) & 0x0ff;
36759679
NC		 5097 the_bytes[5] = (ri->r_symbolnum >> 8) & 0x0ff;
5098 the_bytes[6] = ri->r_symbolnum & 0x0ff;
31302357
AS		 5099 the_bytes[7] = (((ri->r_pcrel << 7) & 0x80)
5100 | ((ri->r_length << 5) & 0x60)
5101 | ((ri->r_extern << 4) & 0x10));
252b5132
RH		 5102}
5103
36759679 5104#endif
252b5132
RH		 5105
5106#ifndef BFD_ASSEMBLER
5107void
31302357
AS		 5108tc_aout_fix_to_chars (char *where, fixS *fixP,
5109 relax_addressT segment_address_in_file)
252b5132
RH		 5110{
5111 /*
5112 * In: length of relocation (or of address) in chars: 1, 2 or 4.
5113 * Out: GNU LD relocation length code: 0, 1, or 2.
5114 */
5115
5a38dc70 5116 static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
252b5132
RH		 5117 long r_symbolnum;
5118
5119 know (fixP->fx_addsy != NULL);
5120
5121 md_number_to_chars (where,
31302357
AS		 5122 (fixP->fx_frag->fr_address
5123 + fixP->fx_where - segment_address_in_file), 4);
252b5132
RH		 5124
5125 r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
5126 ? S_GET_TYPE (fixP->fx_addsy)
5127 : fixP->fx_addsy->sy_number);
5128
5129 where[4] = (r_symbolnum >> 16) & 0x0ff;
5130 where[5] = (r_symbolnum >> 8) & 0x0ff;
5131 where[6] = r_symbolnum & 0x0ff;
31302357
AS		 5132 where[7] = (((fixP->fx_pcrel << 7) & 0x80)
5133 | ((nbytes_r_length[fixP->fx_size] << 5) & 0x60)
5134 | ((!S_IS_DEFINED (fixP->fx_addsy) << 4) & 0x10));
252b5132
RH		 5135}
5136#endif
5137
5138#endif /* OBJ_AOUT or OBJ_BOUT */
5139
5140#ifndef WORKING_DOT_WORD
2b4f075a
HPN		 5141int md_short_jump_size = 4;
5142int md_long_jump_size = 6;
252b5132
RH		 5143
5144void
31302357
AS		 5145md_create_short_jump (char *ptr, addressT from_addr, addressT to_addr,
5146 fragS *frag ATTRIBUTE_UNUSED,
5147 symbolS *to_symbol ATTRIBUTE_UNUSED)
252b5132
RH		 5148{
5149 valueT offset;
5150
5151 offset = to_addr - (from_addr + 2);
5152
5153 md_number_to_chars (ptr, (valueT) 0x6000, 2);
5154 md_number_to_chars (ptr + 2, (valueT) offset, 2);
5155}
5156
5157void
31302357
AS		 5158md_create_long_jump (char *ptr, addressT from_addr, addressT to_addr,
5159 fragS *frag, symbolS *to_symbol)
252b5132
RH		 5160{
5161 valueT offset;
5162
6b6e92f4 5163 if (!HAVE_LONG_BRANCH (current_architecture))
252b5132 5164 {
36759679 5165 if (flag_keep_pcrel)
6b6e92f4 5166 as_fatal (_("Tried to convert PC relative branch to absolute jump"));
252b5132
RH		 5167 offset = to_addr - S_GET_VALUE (to_symbol);
5168 md_number_to_chars (ptr, (valueT) 0x4EF9, 2);
5169 md_number_to_chars (ptr + 2, (valueT) offset, 4);
5170 fix_new (frag, (ptr + 2) - frag->fr_literal, 4, to_symbol, (offsetT) 0,
5171 0, NO_RELOC);
5172 }
5173 else
5174 {
5175 offset = to_addr - (from_addr + 2);
5176 md_number_to_chars (ptr, (valueT) 0x60ff, 2);
5177 md_number_to_chars (ptr + 2, (valueT) offset, 4);
5178 }
5179}
5180
5181#endif
5182
5183/* Different values of OK tell what its OK to return. Things that
5184 aren't OK are an error (what a shock, no?)
5185
5186 0: Everything is OK
3e602632
NC		 5187 10: Absolute 1:8 only
5188 20: Absolute 0:7 only
5189 30: absolute 0:15 only
5190 40: Absolute 0:31 only
5191 50: absolute 0:127 only
252b5132 5192 55: absolute -64:63 only
3e602632
NC		 5193 60: absolute -128:127 only
5194 70: absolute 0:4095 only
5195 80: absolute -1, 1:7 only
5196 90: No bignums. */
252b5132
RH		 5197
5198static int
31302357 5199get_num (struct m68k_exp *exp, int ok)
252b5132
RH		 5200{
5201 if (exp->exp.X_op == O_absent)
5202 {
36759679 5203 /* Do the same thing the VAX asm does. */
252b5132
RH		 5204 op (exp) = O_constant;
5205 adds (exp) = 0;
5206 subs (exp) = 0;
5207 offs (exp) = 0;
5208 if (ok == 10)
5209 {
5210 as_warn (_("expression out of range: defaulting to 1"));
5211 offs (exp) = 1;
5212 }
5213 }
5214 else if (exp->exp.X_op == O_constant)
5215 {
5216 switch (ok)
5217 {
5218 case 10:
bd17c2c3 5219 if ((valueT) TRUNC (offs (exp)) - 1 > 7)
252b5132
RH		 5220 {
5221 as_warn (_("expression out of range: defaulting to 1"));
5222 offs (exp) = 1;
5223 }
5224 break;
5225 case 20:
bd17c2c3 5226 if ((valueT) TRUNC (offs (exp)) > 7)
252b5132
RH		 5227 goto outrange;
5228 break;
5229 case 30:
bd17c2c3 5230 if ((valueT) TRUNC (offs (exp)) > 15)
252b5132
RH		 5231 goto outrange;
5232 break;
5233 case 40:
bd17c2c3 5234 if ((valueT) TRUNC (offs (exp)) > 32)
252b5132
RH		 5235 goto outrange;
5236 break;
5237 case 50:
bd17c2c3 5238 if ((valueT) TRUNC (offs (exp)) > 127)
252b5132
RH		 5239 goto outrange;
5240 break;
5241 case 55:
bd17c2c3 5242 if ((valueT) SEXT (offs (exp)) + 64 > 127)
252b5132
RH		 5243 goto outrange;
5244 break;
5245 case 60:
bd17c2c3 5246 if ((valueT) SEXT (offs (exp)) + 128 > 255)
252b5132
RH		 5247 goto outrange;
5248 break;
5249 case 70:
bd17c2c3 5250 if ((valueT) TRUNC (offs (exp)) > 4095)
252b5132
RH		 5251 {
5252 outrange:
5253 as_warn (_("expression out of range: defaulting to 0"));
5254 offs (exp) = 0;
5255 }
5256 break;
3e602632 5257 case 80:
bd17c2c3
AM		 5258 if ((valueT) TRUNC (offs (exp)) != 0xffffffff
5259 && (valueT) TRUNC (offs (exp)) - 1 > 6)
3e602632
NC		 5260 {
5261 as_warn (_("expression out of range: defaulting to 1"));
5262 offs (exp) = 1;
5263 }
5264 break;
252b5132
RH		 5265 default:
5266 break;
5267 }
5268 }
5269 else if (exp->exp.X_op == O_big)
5270 {
36759679 5271 if (offs (exp) <= 0 /* flonum. */
3e602632 5272 && (ok == 90 /* no bignums */
36759679 5273 || (ok > 10 /* Small-int ranges including 0 ok. */
252b5132
RH		 5274 /* If we have a flonum zero, a zero integer should
5275 do as well (e.g., in moveq). */
5276 && generic_floating_point_number.exponent == 0
5277 && generic_floating_point_number.low[0] == 0)))
5278 {
36759679 5279 /* HACK! Turn it into a long. */
252b5132
RH		 5280 LITTLENUM_TYPE words[6];
5281
36759679 5282 gen_to_words (words, 2, 8L); /* These numbers are magic! */
252b5132
RH		 5283 op (exp) = O_constant;
5284 adds (exp) = 0;
5285 subs (exp) = 0;
5286 offs (exp) = words[1] | (words[0] << 16);
5287 }
5288 else if (ok != 0)
5289 {
5290 op (exp) = O_constant;
5291 adds (exp) = 0;
5292 subs (exp) = 0;
5293 offs (exp) = (ok == 10) ? 1 : 0;
5294 as_warn (_("Can't deal with expression; defaulting to %ld"),
045b540e 5295 (long) offs (exp));
252b5132
RH		 5296 }
5297 }
5298 else
5299 {
3e602632 5300 if (ok >= 10 && ok <= 80)
252b5132
RH		 5301 {
5302 op (exp) = O_constant;
5303 adds (exp) = 0;
5304 subs (exp) = 0;
5305 offs (exp) = (ok == 10) ? 1 : 0;
5306 as_warn (_("Can't deal with expression; defaulting to %ld"),
045b540e 5307 (long) offs (exp));
252b5132
RH		 5308 }
5309 }
5310
5311 if (exp->size != SIZE_UNSPEC)
5312 {
5313 switch (exp->size)
5314 {
5315 case SIZE_UNSPEC:
5316 case SIZE_LONG:
5317 break;
5318 case SIZE_BYTE:
5319 if (!isbyte (offs (exp)))
5320 as_warn (_("expression doesn't fit in BYTE"));
5321 break;
5322 case SIZE_WORD:
5323 if (!isword (offs (exp)))
5324 as_warn (_("expression doesn't fit in WORD"));
5325 break;
5326 }
5327 }
5328
5329 return offs (exp);
5330}
5331
5332/* These are the back-ends for the various machine dependent pseudo-ops. */
5333
5334static void
31302357 5335s_data1 (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5336{
5337 subseg_set (data_section, 1);
5338 demand_empty_rest_of_line ();
5339}
5340
5341static void
31302357 5342s_data2 (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5343{
5344 subseg_set (data_section, 2);
5345 demand_empty_rest_of_line ();
5346}
5347
5348static void
31302357 5349s_bss (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5350{
5351 /* We don't support putting frags in the BSS segment, we fake it
5352 by marking in_bss, then looking at s_skip for clues. */
5353
5354 subseg_set (bss_section, 0);
5355 demand_empty_rest_of_line ();
5356}
5357
5358static void
31302357 5359s_even (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5360{
5361 register int temp;
5362 register long temp_fill;
5363
5364 temp = 1; /* JF should be 2? */
5365 temp_fill = get_absolute_expression ();
92774660 5366 if (!need_pass_2) /* Never make frag if expect extra pass. */
252b5132
RH		 5367 frag_align (temp, (int) temp_fill, 0);
5368 demand_empty_rest_of_line ();
5369 record_alignment (now_seg, temp);
5370}
5371
5372static void
31302357 5373s_proc (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5374{
5375 demand_empty_rest_of_line ();
5376}
5377\f
5378/* Pseudo-ops handled for MRI compatibility. */
5379
5380/* This function returns non-zero if the argument is a conditional
5381 pseudo-op. This is called when checking whether a pending
5382 alignment is needed. */
5383
5384int
31302357 5385m68k_conditional_pseudoop (pseudo_typeS *pop)
252b5132
RH		 5386{
5387 return (pop->poc_handler == s_mri_if
5388 || pop->poc_handler == s_mri_else);
5389}
5390
5391/* Handle an MRI style chip specification. */
5392
5393static void
31302357 5394mri_chip (void)
252b5132
RH		 5395{
5396 char *s;
5397 char c;
5398 int i;
5399
5400 s = input_line_pointer;
5401 /* We can't use get_symbol_end since the processor names are not proper
5402 symbols. */
5403 while (is_part_of_name (c = *input_line_pointer++))
5404 ;
5405 *--input_line_pointer = 0;
5406 for (i = 0; i < n_archs; i++)
5407 if (strcasecmp (s, archs[i].name) == 0)
5408 break;
5409 if (i >= n_archs)
5410 {
5411 as_bad (_("%s: unrecognized processor name"), s);
5412 *input_line_pointer = c;
5413 ignore_rest_of_line ();
5414 return;
5415 }
5416 *input_line_pointer = c;
5417
5418 if (*input_line_pointer == '/')
5419 current_architecture = 0;
5420 else
5421 current_architecture &= m68881 | m68851;
5422 current_architecture |= archs[i].arch;
990ae22a 5423 current_chip = archs[i].chip;
252b5132
RH		 5424
5425 while (*input_line_pointer == '/')
5426 {
5427 ++input_line_pointer;
5428 s = input_line_pointer;
5429 /* We can't use get_symbol_end since the processor names are not
5430 proper symbols. */
5431 while (is_part_of_name (c = *input_line_pointer++))
5432 ;
5433 *--input_line_pointer = 0;
5434 if (strcmp (s, "68881") == 0)
5435 current_architecture |= m68881;
5436 else if (strcmp (s, "68851") == 0)
5437 current_architecture |= m68851;
5438 *input_line_pointer = c;
5439 }
5440
5441 /* Update info about available control registers. */
5442 select_control_regs ();
5443}
5444
5445/* The MRI CHIP pseudo-op. */
5446
5447static void
31302357 5448s_chip (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5449{
5450 char *stop = NULL;
5451 char stopc;
5452
5453 if (flag_mri)
5454 stop = mri_comment_field (&stopc);
5455 mri_chip ();
5456 if (flag_mri)
5457 mri_comment_end (stop, stopc);
5458 demand_empty_rest_of_line ();
5459}
5460
5461/* The MRI FOPT pseudo-op. */
5462
5463static void
31302357 5464s_fopt (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5465{
5466 SKIP_WHITESPACE ();
5467
5468 if (strncasecmp (input_line_pointer, "ID=", 3) == 0)
5469 {
5470 int temp;
5471
5472 input_line_pointer += 3;
5473 temp = get_absolute_expression ();
5474 if (temp < 0 || temp > 7)
5475 as_bad (_("bad coprocessor id"));
5476 else
5477 m68k_float_copnum = COP0 + temp;
5478 }
5479 else
5480 {
5481 as_bad (_("unrecognized fopt option"));
5482 ignore_rest_of_line ();
5483 return;
5484 }
5485
5486 demand_empty_rest_of_line ();
5487}
5488
5489/* The structure used to handle the MRI OPT pseudo-op. */
5490
5491struct opt_action
5492{
5493 /* The name of the option. */
5494 const char *name;
5495
5496 /* If this is not NULL, just call this function. The first argument
5497 is the ARG field of this structure, the second argument is
5498 whether the option was negated. */
31302357 5499 void (*pfn) (int arg, int on);
252b5132
RH		 5500
5501 /* If this is not NULL, and the PFN field is NULL, set the variable
5502 this points to. Set it to the ARG field if the option was not
5503 negated, and the NOTARG field otherwise. */
5504 int *pvar;
5505
5506 /* The value to pass to PFN or to assign to *PVAR. */
5507 int arg;
5508
5509 /* The value to assign to *PVAR if the option is negated. If PFN is
5510 NULL, and PVAR is not NULL, and ARG and NOTARG are the same, then
5511 the option may not be negated. */
5512 int notarg;
5513};
5514
5515/* The table used to handle the MRI OPT pseudo-op. */
5516
31302357
AS		 5517static void skip_to_comma (int, int);
5518static void opt_nest (int, int);
5519static void opt_chip (int, int);
5520static void opt_list (int, int);
5521static void opt_list_symbols (int, int);
252b5132
RH		 5522
5523static const struct opt_action opt_table[] =
5524{
5525 { "abspcadd", 0, &m68k_abspcadd, 1, 0 },
5526
5527 /* We do relaxing, so there is little use for these options. */
5528 { "b", 0, 0, 0, 0 },
5529 { "brs", 0, 0, 0, 0 },
5530 { "brb", 0, 0, 0, 0 },
5531 { "brl", 0, 0, 0, 0 },
5532 { "brw", 0, 0, 0, 0 },
5533
5534 { "c", 0, 0, 0, 0 },
5535 { "cex", 0, 0, 0, 0 },
5536 { "case", 0, &symbols_case_sensitive, 1, 0 },
5537 { "cl", 0, 0, 0, 0 },
5538 { "cre", 0, 0, 0, 0 },
5539 { "d", 0, &flag_keep_locals, 1, 0 },
5540 { "e", 0, 0, 0, 0 },
5541 { "f", 0, &flag_short_refs, 1, 0 },
5542 { "frs", 0, &flag_short_refs, 1, 0 },
5543 { "frl", 0, &flag_short_refs, 0, 1 },
5544 { "g", 0, 0, 0, 0 },
5545 { "i", 0, 0, 0, 0 },
5546 { "m", 0, 0, 0, 0 },
5547 { "mex", 0, 0, 0, 0 },
5548 { "mc", 0, 0, 0, 0 },
5549 { "md", 0, 0, 0, 0 },
5550 { "nest", opt_nest, 0, 0, 0 },
5551 { "next", skip_to_comma, 0, 0, 0 },
5552 { "o", 0, 0, 0, 0 },
5553 { "old", 0, 0, 0, 0 },
5554 { "op", skip_to_comma, 0, 0, 0 },
5555 { "pco", 0, 0, 0, 0 },
5556 { "p", opt_chip, 0, 0, 0 },
5557 { "pcr", 0, 0, 0, 0 },
5558 { "pcs", 0, 0, 0, 0 },
5559 { "r", 0, 0, 0, 0 },
5560 { "quick", 0, &m68k_quick, 1, 0 },
5561 { "rel32", 0, &m68k_rel32, 1, 0 },
5562 { "s", opt_list, 0, 0, 0 },
5563 { "t", opt_list_symbols, 0, 0, 0 },
5564 { "w", 0, &flag_no_warnings, 0, 1 },
5565 { "x", 0, 0, 0, 0 }
5566};
5567
8fce3f5e 5568#define OPTCOUNT ((int) (sizeof opt_table / sizeof opt_table[0]))
252b5132
RH		 5569
5570/* The MRI OPT pseudo-op. */
5571
5572static void
31302357 5573s_opt (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5574{
5575 do
5576 {
5577 int t;
5578 char *s;
5579 char c;
5580 int i;
5581 const struct opt_action *o;
5582
5583 SKIP_WHITESPACE ();
5584
5585 t = 1;
5586 if (*input_line_pointer == '-')
5587 {
5588 ++input_line_pointer;
5589 t = 0;
5590 }
5591 else if (strncasecmp (input_line_pointer, "NO", 2) == 0)
5592 {
5593 input_line_pointer += 2;
5594 t = 0;
5595 }
5596
5597 s = input_line_pointer;
5598 c = get_symbol_end ();
5599
5600 for (i = 0, o = opt_table; i < OPTCOUNT; i++, o++)
5601 {
5602 if (strcasecmp (s, o->name) == 0)
5603 {
5604 if (o->pfn)
5605 {
5606 /* Restore input_line_pointer now in case the option
5607 takes arguments. */
5608 *input_line_pointer = c;
5609 (*o->pfn) (o->arg, t);
5610 }
5611 else if (o->pvar != NULL)
5612 {
5613 if (! t && o->arg == o->notarg)
5614 as_bad (_("option `%s' may not be negated"), s);
5615 *input_line_pointer = c;
5616 *o->pvar = t ? o->arg : o->notarg;
5617 }
5618 else
5619 *input_line_pointer = c;
5620 break;
5621 }
5622 }
5623 if (i >= OPTCOUNT)
5624 {
5625 as_bad (_("option `%s' not recognized"), s);
5626 *input_line_pointer = c;
5627 }
5628 }
5629 while (*input_line_pointer++ == ',');
5630
5631 /* Move back to terminating character. */
5632 --input_line_pointer;
5633 demand_empty_rest_of_line ();
5634}
5635
5636/* Skip ahead to a comma. This is used for OPT options which we do
67c1ffbe 5637 not support and which take arguments. */
252b5132
RH		 5638
5639static void
31302357 5640skip_to_comma (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED)
252b5132
RH		 5641{
5642 while (*input_line_pointer != ','
5643 && ! is_end_of_line[(unsigned char) *input_line_pointer])
5644 ++input_line_pointer;
5645}
5646
5647/* Handle the OPT NEST=depth option. */
5648
5649static void
31302357 5650opt_nest (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED)
252b5132
RH		 5651{
5652 if (*input_line_pointer != '=')
5653 {
5654 as_bad (_("bad format of OPT NEST=depth"));
5655 return;
5656 }
5657
5658 ++input_line_pointer;
5659 max_macro_nest = get_absolute_expression ();
5660}
5661
5662/* Handle the OPT P=chip option. */
5663
5664static void
31302357 5665opt_chip (int arg ATTRIBUTE_UNUSED, int on ATTRIBUTE_UNUSED)
252b5132
RH		 5666{
5667 if (*input_line_pointer != '=')
5668 {
5669 /* This is just OPT P, which we do not support. */
5670 return;
5671 }
5672
5673 ++input_line_pointer;
5674 mri_chip ();
5675}
5676
5677/* Handle the OPT S option. */
5678
5679static void
31302357 5680opt_list (int arg ATTRIBUTE_UNUSED, int on)
252b5132
RH		 5681{
5682 listing_list (on);
5683}
5684
5685/* Handle the OPT T option. */
5686
5687static void
31302357 5688opt_list_symbols (int arg ATTRIBUTE_UNUSED, int on)
252b5132
RH		 5689{
5690 if (on)
5691 listing |= LISTING_SYMBOLS;
5692 else
8a104df9 5693 listing &= ~LISTING_SYMBOLS;
252b5132
RH		 5694}
5695
5696/* Handle the MRI REG pseudo-op. */
5697
5698static void
31302357 5699s_reg (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5700{
5701 char *s;
5702 int c;
5703 struct m68k_op rop;
5704 int mask;
5705 char *stop = NULL;
5706 char stopc;
5707
5708 if (line_label == NULL)
5709 {
5710 as_bad (_("missing label"));
5711 ignore_rest_of_line ();
5712 return;
5713 }
5714
5715 if (flag_mri)
5716 stop = mri_comment_field (&stopc);
5717
5718 SKIP_WHITESPACE ();
5719
5720 s = input_line_pointer;
3882b010 5721 while (ISALNUM (*input_line_pointer)
252b5132
RH		 5722#ifdef REGISTER_PREFIX
5723 || *input_line_pointer == REGISTER_PREFIX
5724#endif
5725 || *input_line_pointer == '/'
5726 || *input_line_pointer == '-')
5727 ++input_line_pointer;
5728 c = *input_line_pointer;
5729 *input_line_pointer = '\0';
5730
5731 if (m68k_ip_op (s, &rop) != 0)
5732 {
5733 if (rop.error == NULL)
5734 as_bad (_("bad register list"));
5735 else
5736 as_bad (_("bad register list: %s"), rop.error);
5737 *input_line_pointer = c;
5738 ignore_rest_of_line ();
5739 return;
5740 }
5741
5742 *input_line_pointer = c;
5743
5744 if (rop.mode == REGLST)
5745 mask = rop.mask;
5746 else if (rop.mode == DREG)
5747 mask = 1 << (rop.reg - DATA0);
5748 else if (rop.mode == AREG)
5749 mask = 1 << (rop.reg - ADDR0 + 8);
5750 else if (rop.mode == FPREG)
5751 mask = 1 << (rop.reg - FP0 + 16);
5752 else if (rop.mode == CONTROL
5753 && rop.reg == FPI)
5754 mask = 1 << 24;
5755 else if (rop.mode == CONTROL
5756 && rop.reg == FPS)
5757 mask = 1 << 25;
5758 else if (rop.mode == CONTROL
5759 && rop.reg == FPC)
5760 mask = 1 << 26;
5761 else
5762 {
5763 as_bad (_("bad register list"));
5764 ignore_rest_of_line ();
5765 return;
5766 }
5767
5768 S_SET_SEGMENT (line_label, reg_section);
5769 S_SET_VALUE (line_label, ~mask);
49309057 5770 symbol_set_frag (line_label, &zero_address_frag);
252b5132
RH		 5771
5772 if (flag_mri)
5773 mri_comment_end (stop, stopc);
5774
5775 demand_empty_rest_of_line ();
5776}
5777
5778/* This structure is used for the MRI SAVE and RESTORE pseudo-ops. */
5779
5780struct save_opts
5781{
5782 struct save_opts *next;
5783 int abspcadd;
5784 int symbols_case_sensitive;
5785 int keep_locals;
5786 int short_refs;
5787 int architecture;
6b6e92f4 5788 int chip;
252b5132
RH		 5789 int quick;
5790 int rel32;
5791 int listing;
5792 int no_warnings;
5793 /* FIXME: We don't save OPT S. */
5794};
5795
5796/* This variable holds the stack of saved options. */
5797
5798static struct save_opts *save_stack;
5799
5800/* The MRI SAVE pseudo-op. */
5801
5802static void
31302357 5803s_save (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5804{
5805 struct save_opts *s;
5806
5807 s = (struct save_opts *) xmalloc (sizeof (struct save_opts));
5808 s->abspcadd = m68k_abspcadd;
5809 s->symbols_case_sensitive = symbols_case_sensitive;
5810 s->keep_locals = flag_keep_locals;
5811 s->short_refs = flag_short_refs;
5812 s->architecture = current_architecture;
6b6e92f4 5813 s->chip = current_chip;
252b5132
RH		 5814 s->quick = m68k_quick;
5815 s->rel32 = m68k_rel32;
5816 s->listing = listing;
5817 s->no_warnings = flag_no_warnings;
5818
5819 s->next = save_stack;
5820 save_stack = s;
5821
5822 demand_empty_rest_of_line ();
5823}
5824
5825/* The MRI RESTORE pseudo-op. */
5826
5827static void
31302357 5828s_restore (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 5829{
5830 struct save_opts *s;
5831
5832 if (save_stack == NULL)
5833 {
5834 as_bad (_("restore without save"));
5835 ignore_rest_of_line ();
5836 return;
5837 }
5838
5839 s = save_stack;
5840 save_stack = s->next;
5841
5842 m68k_abspcadd = s->abspcadd;
5843 symbols_case_sensitive = s->symbols_case_sensitive;
5844 flag_keep_locals = s->keep_locals;
5845 flag_short_refs = s->short_refs;
5846 current_architecture = s->architecture;
6b6e92f4 5847 current_chip = s->chip;
252b5132
RH		 5848 m68k_quick = s->quick;
5849 m68k_rel32 = s->rel32;
5850 listing = s->listing;
5851 flag_no_warnings = s->no_warnings;
5852
5853 free (s);
5854
5855 demand_empty_rest_of_line ();
5856}
5857
5858/* Types of MRI structured control directives. */
5859
5860enum mri_control_type
5861{
5862 mri_for,
5863 mri_if,
5864 mri_repeat,
5865 mri_while
5866};
5867
5868/* This structure is used to stack the MRI structured control
5869 directives. */
5870
5871struct mri_control_info
5872{
5873 /* The directive within which this one is enclosed. */
5874 struct mri_control_info *outer;
5875
5876 /* The type of directive. */
5877 enum mri_control_type type;
5878
5879 /* Whether an ELSE has been in an IF. */
5880 int else_seen;
5881
5882 /* The add or sub statement at the end of a FOR. */
5883 char *incr;
5884
5885 /* The label of the top of a FOR or REPEAT loop. */
5886 char *top;
5887
5888 /* The label to jump to for the next iteration, or the else
5889 expression of a conditional. */
5890 char *next;
5891
5892 /* The label to jump to to break out of the loop, or the label past
5893 the end of a conditional. */
5894 char *bottom;
5895};
5896
5897/* The stack of MRI structured control directives. */
5898
5899static struct mri_control_info *mri_control_stack;
5900
5901/* The current MRI structured control directive index number, used to
5902 generate label names. */
5903
5904static int mri_control_index;
5905
252b5132
RH		 5906/* Assemble an instruction for an MRI structured control directive. */
5907
5908static void
31302357 5909mri_assemble (char *str)
252b5132
RH		 5910{
5911 char *s;
5912
5913 /* md_assemble expects the opcode to be in lower case. */
5914 for (s = str; *s != ' ' && *s != '\0'; s++)
3882b010 5915 *s = TOLOWER (*s);
252b5132
RH		 5916
5917 md_assemble (str);
5918}
5919
5920/* Generate a new MRI label structured control directive label name. */
5921
5922static char *
31302357 5923mri_control_label (void)
252b5132
RH		 5924{
5925 char *n;
5926
5927 n = (char *) xmalloc (20);
5928 sprintf (n, "%smc%d", FAKE_LABEL_NAME, mri_control_index);
5929 ++mri_control_index;
5930 return n;
5931}
5932
5933/* Create a new MRI structured control directive. */
5934
5935static struct mri_control_info *
31302357 5936push_mri_control (enum mri_control_type type)
252b5132
RH		 5937{
5938 struct mri_control_info *n;
5939
5940 n = (struct mri_control_info *) xmalloc (sizeof (struct mri_control_info));
5941
5942 n->type = type;
5943 n->else_seen = 0;
5944 if (type == mri_if || type == mri_while)
5945 n->top = NULL;
5946 else
5947 n->top = mri_control_label ();
5948 n->next = mri_control_label ();
5949 n->bottom = mri_control_label ();
5950
5951 n->outer = mri_control_stack;
5952 mri_control_stack = n;
5953
5954 return n;
5955}
5956
5957/* Pop off the stack of MRI structured control directives. */
5958
5959static void
31302357 5960pop_mri_control (void)
252b5132
RH		 5961{
5962 struct mri_control_info *n;
5963
5964 n = mri_control_stack;
5965 mri_control_stack = n->outer;
5966 if (n->top != NULL)
5967 free (n->top);
5968 free (n->next);
5969 free (n->bottom);
5970 free (n);
5971}
5972
5973/* Recognize a condition code in an MRI structured control expression. */
5974
5975static int
31302357 5976parse_mri_condition (int *pcc)
252b5132
RH		 5977{
5978 char c1, c2;
5979
5980 know (*input_line_pointer == '<');
5981
5982 ++input_line_pointer;
5983 c1 = *input_line_pointer++;
5984 c2 = *input_line_pointer++;
5985
5986 if (*input_line_pointer != '>')
5987 {
5988 as_bad (_("syntax error in structured control directive"));
5989 return 0;
5990 }
5991
5992 ++input_line_pointer;
5993 SKIP_WHITESPACE ();
5994
3882b010
L		 5995 c1 = TOLOWER (c1);
5996 c2 = TOLOWER (c2);
252b5132
RH		 5997
5998 *pcc = (c1 << 8) | c2;
5999
6000 return 1;
6001}
6002
6003/* Parse a single operand in an MRI structured control expression. */
6004
6005static int
31302357
AS		 6006parse_mri_control_operand (int *pcc, char **leftstart, char **leftstop,
6007 char **rightstart, char **rightstop)
252b5132
RH		 6008{
6009 char *s;
6010
6011 SKIP_WHITESPACE ();
6012
6013 *pcc = -1;
6014 *leftstart = NULL;
6015 *leftstop = NULL;
6016 *rightstart = NULL;
6017 *rightstop = NULL;
6018
6019 if (*input_line_pointer == '<')
6020 {
6021 /* It's just a condition code. */
6022 return parse_mri_condition (pcc);
6023 }
6024
6025 /* Look ahead for the condition code. */
6026 for (s = input_line_pointer; *s != '\0'; ++s)
6027 {
6028 if (*s == '<' && s[1] != '\0' && s[2] != '\0' && s[3] == '>')
6029 break;
6030 }
6031 if (*s == '\0')
6032 {
6033 as_bad (_("missing condition code in structured control directive"));
6034 return 0;
6035 }
6036
6037 *leftstart = input_line_pointer;
6038 *leftstop = s;
6039 if (*leftstop > *leftstart
6040 && ((*leftstop)[-1] == ' ' || (*leftstop)[-1] == '\t'))
6041 --*leftstop;
6042
6043 input_line_pointer = s;
6044 if (! parse_mri_condition (pcc))
6045 return 0;
6046
6047 /* Look ahead for AND or OR or end of line. */
6048 for (s = input_line_pointer; *s != '\0'; ++s)
6049 {
e1f44d10
NC		 6050 /* We must make sure we don't misinterpret AND/OR at the end of labels!
6051 if d0 <eq> #FOOAND and d1 <ne> #BAROR then
6052 ^^^ ^^ */
8a104df9
KH		 6053 if ((s == input_line_pointer
6054 || *(s-1) == ' '
6055 || *(s-1) == '\t')
6056 && ((strncasecmp (s, "AND", 3) == 0
6057 && (s[3] == '.' || ! is_part_of_name (s[3])))
6058 || (strncasecmp (s, "OR", 2) == 0
6059 && (s[2] == '.' || ! is_part_of_name (s[2])))))
6060 break;
252b5132
RH		 6061 }
6062
6063 *rightstart = input_line_pointer;
6064 *rightstop = s;
6065 if (*rightstop > *rightstart
6066 && ((*rightstop)[-1] == ' ' || (*rightstop)[-1] == '\t'))
6067 --*rightstop;
6068
6069 input_line_pointer = s;
6070
6071 return 1;
6072}
6073
6074#define MCC(b1, b2) (((b1) << 8) | (b2))
6075
6076/* Swap the sense of a condition. This changes the condition so that
6077 it generates the same result when the operands are swapped. */
6078
6079static int
31302357 6080swap_mri_condition (int cc)
252b5132
RH		 6081{
6082 switch (cc)
6083 {
6084 case MCC ('h', 'i'): return MCC ('c', 's');
6085 case MCC ('l', 's'): return MCC ('c', 'c');
36759679 6086 /* <HS> is an alias for <CC>. */
e1f44d10 6087 case MCC ('h', 's'):
252b5132 6088 case MCC ('c', 'c'): return MCC ('l', 's');
36759679 6089 /* <LO> is an alias for <CS>. */
e1f44d10 6090 case MCC ('l', 'o'):
252b5132
RH		 6091 case MCC ('c', 's'): return MCC ('h', 'i');
6092 case MCC ('p', 'l'): return MCC ('m', 'i');
6093 case MCC ('m', 'i'): return MCC ('p', 'l');
6094 case MCC ('g', 'e'): return MCC ('l', 'e');
6095 case MCC ('l', 't'): return MCC ('g', 't');
6096 case MCC ('g', 't'): return MCC ('l', 't');
6097 case MCC ('l', 'e'): return MCC ('g', 'e');
36759679 6098 /* Issue a warning for conditions we can not swap. */
e1f44d10
NC		 6099 case MCC ('n', 'e'): return MCC ('n', 'e'); // no problem here
6100 case MCC ('e', 'q'): return MCC ('e', 'q'); // also no problem
6101 case MCC ('v', 'c'):
6102 case MCC ('v', 's'):
6103 default :
6104 as_warn (_("Condition <%c%c> in structured control directive can not be encoded correctly"),
6105 (char) (cc >> 8), (char) (cc));
6106 break;
252b5132
RH		 6107 }
6108 return cc;
6109}
6110
6111/* Reverse the sense of a condition. */
6112
6113static int
31302357 6114reverse_mri_condition (int cc)
252b5132
RH		 6115{
6116 switch (cc)
6117 {
6118 case MCC ('h', 'i'): return MCC ('l', 's');
6119 case MCC ('l', 's'): return MCC ('h', 'i');
e1f44d10
NC		 6120 /* <HS> is an alias for <CC> */
6121 case MCC ('h', 's'): return MCC ('l', 'o');
252b5132 6122 case MCC ('c', 'c'): return MCC ('c', 's');
e1f44d10
NC		 6123 /* <LO> is an alias for <CS> */
6124 case MCC ('l', 'o'): return MCC ('h', 's');
252b5132
RH		 6125 case MCC ('c', 's'): return MCC ('c', 'c');
6126 case MCC ('n', 'e'): return MCC ('e', 'q');
6127 case MCC ('e', 'q'): return MCC ('n', 'e');
6128 case MCC ('v', 'c'): return MCC ('v', 's');
6129 case MCC ('v', 's'): return MCC ('v', 'c');
6130 case MCC ('p', 'l'): return MCC ('m', 'i');
6131 case MCC ('m', 'i'): return MCC ('p', 'l');
6132 case MCC ('g', 'e'): return MCC ('l', 't');
6133 case MCC ('l', 't'): return MCC ('g', 'e');
6134 case MCC ('g', 't'): return MCC ('l', 'e');
6135 case MCC ('l', 'e'): return MCC ('g', 't');
6136 }
6137 return cc;
6138}
6139
6140/* Build an MRI structured control expression. This generates test
6141 and branch instructions. It goes to TRUELAB if the condition is
6142 true, and to FALSELAB if the condition is false. Exactly one of
6143 TRUELAB and FALSELAB will be NULL, meaning to fall through. QUAL
6144 is the size qualifier for the expression. EXTENT is the size to
6145 use for the branch. */
6146
6147static void
31302357
AS		 6148build_mri_control_operand (int qual, int cc, char *leftstart, char *leftstop,
6149 char *rightstart, char *rightstop,
6150 const char *truelab, const char *falselab,
6151 int extent)
252b5132
RH		 6152{
6153 char *buf;
6154 char *s;
6155
6156 if (leftstart != NULL)
6157 {
6158 struct m68k_op leftop, rightop;
6159 char c;
6160
6161 /* Swap the compare operands, if necessary, to produce a legal
6162 m68k compare instruction. Comparing a register operand with
6163 a non-register operand requires the register to be on the
6164 right (cmp, cmpa). Comparing an immediate value with
6165 anything requires the immediate value to be on the left
6166 (cmpi). */
6167
6168 c = *leftstop;
6169 *leftstop = '\0';
6170 (void) m68k_ip_op (leftstart, &leftop);
6171 *leftstop = c;
6172
6173 c = *rightstop;
6174 *rightstop = '\0';
6175 (void) m68k_ip_op (rightstart, &rightop);
6176 *rightstop = c;
6177
6178 if (rightop.mode == IMMED
6179 || ((leftop.mode == DREG || leftop.mode == AREG)
6180 && (rightop.mode != DREG && rightop.mode != AREG)))
6181 {
6182 char *temp;
6183
31302357
AS		 6184 /* Correct conditional handling:
6185 if #1 <lt> d0 then ;means if (1 < d0)
6186 ...
6187 endi
e1f44d10 6188
31302357 6189 should assemble to:
e1f44d10 6190
31302357
AS		 6191 cmp #1,d0 if we do *not* swap the operands
6192 bgt true we need the swapped condition!
6193 ble false
6194 true:
6195 ...
6196 false:
6197 */
252b5132
RH		 6198 temp = leftstart;
6199 leftstart = rightstart;
6200 rightstart = temp;
6201 temp = leftstop;
6202 leftstop = rightstop;
6203 rightstop = temp;
8a104df9
KH		 6204 }
6205 else
6206 {
e1f44d10 6207 cc = swap_mri_condition (cc);
252b5132
RH		 6208 }
6209 }
6210
6211 if (truelab == NULL)
6212 {
6213 cc = reverse_mri_condition (cc);
6214 truelab = falselab;
6215 }
92774660 6216
252b5132
RH		 6217 if (leftstart != NULL)
6218 {
6219 buf = (char *) xmalloc (20
6220 + (leftstop - leftstart)
6221 + (rightstop - rightstart));
6222 s = buf;
6223 *s++ = 'c';
6224 *s++ = 'm';
6225 *s++ = 'p';
6226 if (qual != '\0')
3882b010 6227 *s++ = TOLOWER (qual);
252b5132
RH		 6228 *s++ = ' ';
6229 memcpy (s, leftstart, leftstop - leftstart);
6230 s += leftstop - leftstart;
6231 *s++ = ',';
6232 memcpy (s, rightstart, rightstop - rightstart);
6233 s += rightstop - rightstart;
6234 *s = '\0';
6235 mri_assemble (buf);
6236 free (buf);
6237 }
92774660 6238
252b5132
RH		 6239 buf = (char *) xmalloc (20 + strlen (truelab));
6240 s = buf;
6241 *s++ = 'b';
6242 *s++ = cc >> 8;
6243 *s++ = cc & 0xff;
6244 if (extent != '\0')
3882b010 6245 *s++ = TOLOWER (extent);
252b5132
RH		 6246 *s++ = ' ';
6247 strcpy (s, truelab);
6248 mri_assemble (buf);
6249 free (buf);
6250}
6251
6252/* Parse an MRI structured control expression. This generates test
6253 and branch instructions. STOP is where the expression ends. It
6254 goes to TRUELAB if the condition is true, and to FALSELAB if the
6255 condition is false. Exactly one of TRUELAB and FALSELAB will be
6256 NULL, meaning to fall through. QUAL is the size qualifier for the
6257 expression. EXTENT is the size to use for the branch. */
6258
6259static void
31302357
AS		 6260parse_mri_control_expression (char *stop, int qual, const char *truelab,
6261 const char *falselab, int extent)
252b5132
RH		 6262{
6263 int c;
6264 int cc;
6265 char *leftstart;
6266 char *leftstop;
6267 char *rightstart;
6268 char *rightstop;
6269
6270 c = *stop;
6271 *stop = '\0';
6272
6273 if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6274 &rightstart, &rightstop))
6275 {
6276 *stop = c;
6277 return;
6278 }
6279
6280 if (strncasecmp (input_line_pointer, "AND", 3) == 0)
6281 {
6282 const char *flab;
6283
6284 if (falselab != NULL)
6285 flab = falselab;
6286 else
6287 flab = mri_control_label ();
6288
6289 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6290 rightstop, (const char *) NULL, flab, extent);
6291
6292 input_line_pointer += 3;
6293 if (*input_line_pointer != '.'
6294 || input_line_pointer[1] == '\0')
6295 qual = '\0';
6296 else
6297 {
6298 qual = input_line_pointer[1];
6299 input_line_pointer += 2;
6300 }
6301
6302 if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6303 &rightstart, &rightstop))
6304 {
6305 *stop = c;
6306 return;
6307 }
6308
6309 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6310 rightstop, truelab, falselab, extent);
6311
6312 if (falselab == NULL)
6313 colon (flab);
6314 }
6315 else if (strncasecmp (input_line_pointer, "OR", 2) == 0)
6316 {
6317 const char *tlab;
6318
6319 if (truelab != NULL)
6320 tlab = truelab;
6321 else
6322 tlab = mri_control_label ();
6323
6324 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6325 rightstop, tlab, (const char *) NULL, extent);
6326
6327 input_line_pointer += 2;
6328 if (*input_line_pointer != '.'
6329 || input_line_pointer[1] == '\0')
6330 qual = '\0';
6331 else
6332 {
6333 qual = input_line_pointer[1];
6334 input_line_pointer += 2;
6335 }
6336
6337 if (! parse_mri_control_operand (&cc, &leftstart, &leftstop,
6338 &rightstart, &rightstop))
6339 {
6340 *stop = c;
6341 return;
6342 }
6343
6344 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6345 rightstop, truelab, falselab, extent);
6346
6347 if (truelab == NULL)
6348 colon (tlab);
6349 }
6350 else
6351 {
6352 build_mri_control_operand (qual, cc, leftstart, leftstop, rightstart,
6353 rightstop, truelab, falselab, extent);
6354 }
6355
6356 *stop = c;
6357 if (input_line_pointer != stop)
6358 as_bad (_("syntax error in structured control directive"));
6359}
6360
6361/* Handle the MRI IF pseudo-op. This may be a structured control
6362 directive, or it may be a regular assembler conditional, depending
6363 on its operands. */
6364
6365static void
31302357 6366s_mri_if (int qual)
252b5132
RH		 6367{
6368 char *s;
6369 int c;
6370 struct mri_control_info *n;
6371
6372 /* A structured control directive must end with THEN with an
6373 optional qualifier. */
6374 s = input_line_pointer;
e1f44d10
NC		 6375 /* We only accept '*' as introduction of comments if preceded by white space
6376 or at first column of a line (I think this can't actually happen here?)
6377 This is important when assembling:
6378 if d0 <ne> 12(a0,d0*2) then
36759679 6379 if d0 <ne> #CONST*20 then. */
31302357
AS		 6380 while (! (is_end_of_line[(unsigned char) *s]
6381 || (flag_mri
6382 && *s == '*'
6383 && (s == input_line_pointer
6384 || *(s-1) == ' '
6385 || *(s-1) == '\t'))))
252b5132
RH		 6386 ++s;
6387 --s;
6388 while (s > input_line_pointer && (*s == ' ' || *s == '\t'))
6389 --s;
6390
6391 if (s - input_line_pointer > 1
6392 && s[-1] == '.')
6393 s -= 2;
6394
6395 if (s - input_line_pointer < 3
6396 || strncasecmp (s - 3, "THEN", 4) != 0)
6397 {
6398 if (qual != '\0')
6399 {
6400 as_bad (_("missing then"));
6401 ignore_rest_of_line ();
6402 return;
6403 }
6404
6405 /* It's a conditional. */
6406 s_if (O_ne);
6407 return;
6408 }
6409
6410 /* Since this might be a conditional if, this pseudo-op will be
6411 called even if we are supported to be ignoring input. Double
6412 check now. Clobber *input_line_pointer so that ignore_input
6413 thinks that this is not a special pseudo-op. */
6414 c = *input_line_pointer;
6415 *input_line_pointer = 0;
6416 if (ignore_input ())
6417 {
6418 *input_line_pointer = c;
6419 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6420 ++input_line_pointer;
6421 demand_empty_rest_of_line ();
6422 return;
6423 }
6424 *input_line_pointer = c;
6425
6426 n = push_mri_control (mri_if);
6427
6428 parse_mri_control_expression (s - 3, qual, (const char *) NULL,
6429 n->next, s[1] == '.' ? s[2] : '\0');
6430
6431 if (s[1] == '.')
6432 input_line_pointer = s + 3;
6433 else
6434 input_line_pointer = s + 1;
6435
6436 if (flag_mri)
6437 {
6438 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6439 ++input_line_pointer;
6440 }
6441
6442 demand_empty_rest_of_line ();
6443}
6444
6445/* Handle the MRI else pseudo-op. If we are currently doing an MRI
6446 structured IF, associate the ELSE with the IF. Otherwise, assume
6447 it is a conditional else. */
6448
6449static void
31302357 6450s_mri_else (int qual)
252b5132
RH		 6451{
6452 int c;
6453 char *buf;
6454 char q[2];
6455
6456 if (qual == '\0'
6457 && (mri_control_stack == NULL
6458 || mri_control_stack->type != mri_if
6459 || mri_control_stack->else_seen))
6460 {
6461 s_else (0);
6462 return;
6463 }
6464
6465 c = *input_line_pointer;
6466 *input_line_pointer = 0;
6467 if (ignore_input ())
6468 {
6469 *input_line_pointer = c;
6470 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6471 ++input_line_pointer;
6472 demand_empty_rest_of_line ();
6473 return;
6474 }
6475 *input_line_pointer = c;
6476
6477 if (mri_control_stack == NULL
6478 || mri_control_stack->type != mri_if
6479 || mri_control_stack->else_seen)
6480 {
6481 as_bad (_("else without matching if"));
6482 ignore_rest_of_line ();
6483 return;
6484 }
6485
6486 mri_control_stack->else_seen = 1;
6487
6488 buf = (char *) xmalloc (20 + strlen (mri_control_stack->bottom));
3882b010 6489 q[0] = TOLOWER (qual);
252b5132
RH		 6490 q[1] = '\0';
6491 sprintf (buf, "bra%s %s", q, mri_control_stack->bottom);
6492 mri_assemble (buf);
6493 free (buf);
6494
6495 colon (mri_control_stack->next);
6496
6497 if (flag_mri)
6498 {
6499 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6500 ++input_line_pointer;
6501 }
6502
6503 demand_empty_rest_of_line ();
6504}
6505
6506/* Handle the MRI ENDI pseudo-op. */
6507
6508static void
31302357 6509s_mri_endi (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 6510{
6511 if (mri_control_stack == NULL
6512 || mri_control_stack->type != mri_if)
6513 {
6514 as_bad (_("endi without matching if"));
6515 ignore_rest_of_line ();
6516 return;
6517 }
6518
6519 /* ignore_input will not return true for ENDI, so we don't need to
6520 worry about checking it again here. */
6521
6522 if (! mri_control_stack->else_seen)
6523 colon (mri_control_stack->next);
6524 colon (mri_control_stack->bottom);
6525
6526 pop_mri_control ();
6527
6528 if (flag_mri)
6529 {
6530 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6531 ++input_line_pointer;
6532 }
6533
6534 demand_empty_rest_of_line ();
6535}
6536
6537/* Handle the MRI BREAK pseudo-op. */
6538
6539static void
31302357 6540s_mri_break (int extent)
252b5132
RH		 6541{
6542 struct mri_control_info *n;
6543 char *buf;
6544 char ex[2];
6545
6546 n = mri_control_stack;
6547 while (n != NULL
6548 && n->type != mri_for
6549 && n->type != mri_repeat
6550 && n->type != mri_while)
6551 n = n->outer;
6552 if (n == NULL)
6553 {
6554 as_bad (_("break outside of structured loop"));
6555 ignore_rest_of_line ();
6556 return;
6557 }
6558
6559 buf = (char *) xmalloc (20 + strlen (n->bottom));
3882b010 6560 ex[0] = TOLOWER (extent);
252b5132
RH		 6561 ex[1] = '\0';
6562 sprintf (buf, "bra%s %s", ex, n->bottom);
6563 mri_assemble (buf);
6564 free (buf);
6565
6566 if (flag_mri)
6567 {
6568 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6569 ++input_line_pointer;
6570 }
6571
6572 demand_empty_rest_of_line ();
6573}
6574
6575/* Handle the MRI NEXT pseudo-op. */
6576
6577static void
31302357 6578s_mri_next (int extent)
252b5132
RH		 6579{
6580 struct mri_control_info *n;
6581 char *buf;
6582 char ex[2];
6583
6584 n = mri_control_stack;
6585 while (n != NULL
6586 && n->type != mri_for
6587 && n->type != mri_repeat
6588 && n->type != mri_while)
6589 n = n->outer;
6590 if (n == NULL)
6591 {
6592 as_bad (_("next outside of structured loop"));
6593 ignore_rest_of_line ();
6594 return;
6595 }
6596
6597 buf = (char *) xmalloc (20 + strlen (n->next));
3882b010 6598 ex[0] = TOLOWER (extent);
252b5132
RH		 6599 ex[1] = '\0';
6600 sprintf (buf, "bra%s %s", ex, n->next);
6601 mri_assemble (buf);
6602 free (buf);
6603
6604 if (flag_mri)
6605 {
6606 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6607 ++input_line_pointer;
6608 }
6609
6610 demand_empty_rest_of_line ();
6611}
6612
6613/* Handle the MRI FOR pseudo-op. */
6614
6615static void
31302357 6616s_mri_for (int qual)
252b5132
RH		 6617{
6618 const char *varstart, *varstop;
6619 const char *initstart, *initstop;
6620 const char *endstart, *endstop;
6621 const char *bystart, *bystop;
6622 int up;
6623 int by;
6624 int extent;
6625 struct mri_control_info *n;
6626 char *buf;
6627 char *s;
6628 char ex[2];
6629
6630 /* The syntax is
6631 FOR.q var = init { TO | DOWNTO } end [ BY by ] DO.e
6632 */
6633
6634 SKIP_WHITESPACE ();
6635 varstart = input_line_pointer;
6636
6637 /* Look for the '='. */
6638 while (! is_end_of_line[(unsigned char) *input_line_pointer]
6639 && *input_line_pointer != '=')
6640 ++input_line_pointer;
6641 if (*input_line_pointer != '=')
6642 {
6643 as_bad (_("missing ="));
6644 ignore_rest_of_line ();
6645 return;
6646 }
6647
6648 varstop = input_line_pointer;
6649 if (varstop > varstart
6650 && (varstop[-1] == ' ' || varstop[-1] == '\t'))
6651 --varstop;
6652
6653 ++input_line_pointer;
6654
6655 initstart = input_line_pointer;
6656
6657 /* Look for TO or DOWNTO. */
6658 up = 1;
6659 initstop = NULL;
6660 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6661 {
6662 if (strncasecmp (input_line_pointer, "TO", 2) == 0
6663 && ! is_part_of_name (input_line_pointer[2]))
6664 {
6665 initstop = input_line_pointer;
6666 input_line_pointer += 2;
6667 break;
6668 }
6669 if (strncasecmp (input_line_pointer, "DOWNTO", 6) == 0
6670 && ! is_part_of_name (input_line_pointer[6]))
6671 {
6672 initstop = input_line_pointer;
6673 up = 0;
6674 input_line_pointer += 6;
6675 break;
6676 }
6677 ++input_line_pointer;
6678 }
6679 if (initstop == NULL)
6680 {
6681 as_bad (_("missing to or downto"));
6682 ignore_rest_of_line ();
6683 return;
6684 }
6685 if (initstop > initstart
6686 && (initstop[-1] == ' ' || initstop[-1] == '\t'))
6687 --initstop;
6688
6689 SKIP_WHITESPACE ();
6690 endstart = input_line_pointer;
6691
6692 /* Look for BY or DO. */
6693 by = 0;
6694 endstop = NULL;
6695 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6696 {
6697 if (strncasecmp (input_line_pointer, "BY", 2) == 0
6698 && ! is_part_of_name (input_line_pointer[2]))
6699 {
6700 endstop = input_line_pointer;
6701 by = 1;
6702 input_line_pointer += 2;
6703 break;
6704 }
6705 if (strncasecmp (input_line_pointer, "DO", 2) == 0
6706 && (input_line_pointer[2] == '.'
6707 || ! is_part_of_name (input_line_pointer[2])))
6708 {
6709 endstop = input_line_pointer;
6710 input_line_pointer += 2;
6711 break;
6712 }
6713 ++input_line_pointer;
6714 }
6715 if (endstop == NULL)
6716 {
6717 as_bad (_("missing do"));
6718 ignore_rest_of_line ();
6719 return;
6720 }
6721 if (endstop > endstart
6722 && (endstop[-1] == ' ' || endstop[-1] == '\t'))
6723 --endstop;
6724
6725 if (! by)
6726 {
6727 bystart = "#1";
6728 bystop = bystart + 2;
6729 }
6730 else
6731 {
6732 SKIP_WHITESPACE ();
6733 bystart = input_line_pointer;
6734
6735 /* Look for DO. */
6736 bystop = NULL;
6737 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6738 {
6739 if (strncasecmp (input_line_pointer, "DO", 2) == 0
6740 && (input_line_pointer[2] == '.'
6741 || ! is_part_of_name (input_line_pointer[2])))
6742 {
6743 bystop = input_line_pointer;
6744 input_line_pointer += 2;
6745 break;
6746 }
6747 ++input_line_pointer;
6748 }
6749 if (bystop == NULL)
6750 {
6751 as_bad (_("missing do"));
6752 ignore_rest_of_line ();
6753 return;
6754 }
6755 if (bystop > bystart
6756 && (bystop[-1] == ' ' || bystop[-1] == '\t'))
6757 --bystop;
6758 }
6759
6760 if (*input_line_pointer != '.')
6761 extent = '\0';
6762 else
6763 {
6764 extent = input_line_pointer[1];
6765 input_line_pointer += 2;
6766 }
6767
6768 /* We have fully parsed the FOR operands. Now build the loop. */
252b5132
RH		 6769 n = push_mri_control (mri_for);
6770
6771 buf = (char *) xmalloc (50 + (input_line_pointer - varstart));
6772
36759679 6773 /* Move init,var. */
252b5132
RH		 6774 s = buf;
6775 *s++ = 'm';
6776 *s++ = 'o';
6777 *s++ = 'v';
6778 *s++ = 'e';
6779 if (qual != '\0')
3882b010 6780 *s++ = TOLOWER (qual);
252b5132
RH		 6781 *s++ = ' ';
6782 memcpy (s, initstart, initstop - initstart);
6783 s += initstop - initstart;
6784 *s++ = ',';
6785 memcpy (s, varstart, varstop - varstart);
6786 s += varstop - varstart;
6787 *s = '\0';
6788 mri_assemble (buf);
6789
6790 colon (n->top);
6791
36759679 6792 /* cmp end,var. */
252b5132
RH		 6793 s = buf;
6794 *s++ = 'c';
6795 *s++ = 'm';
6796 *s++ = 'p';
6797 if (qual != '\0')
3882b010 6798 *s++ = TOLOWER (qual);
252b5132
RH		 6799 *s++ = ' ';
6800 memcpy (s, endstart, endstop - endstart);
6801 s += endstop - endstart;
6802 *s++ = ',';
6803 memcpy (s, varstart, varstop - varstart);
6804 s += varstop - varstart;
6805 *s = '\0';
6806 mri_assemble (buf);
6807
36759679 6808 /* bcc bottom. */
3882b010 6809 ex[0] = TOLOWER (extent);
252b5132
RH		 6810 ex[1] = '\0';
6811 if (up)
6812 sprintf (buf, "blt%s %s", ex, n->bottom);
6813 else
6814 sprintf (buf, "bgt%s %s", ex, n->bottom);
6815 mri_assemble (buf);
6816
6817 /* Put together the add or sub instruction used by ENDF. */
6818 s = buf;
6819 if (up)
6820 strcpy (s, "add");
6821 else
6822 strcpy (s, "sub");
6823 s += 3;
6824 if (qual != '\0')
3882b010 6825 *s++ = TOLOWER (qual);
252b5132
RH		 6826 *s++ = ' ';
6827 memcpy (s, bystart, bystop - bystart);
6828 s += bystop - bystart;
6829 *s++ = ',';
6830 memcpy (s, varstart, varstop - varstart);
6831 s += varstop - varstart;
6832 *s = '\0';
6833 n->incr = buf;
6834
6835 if (flag_mri)
6836 {
6837 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6838 ++input_line_pointer;
6839 }
6840
6841 demand_empty_rest_of_line ();
6842}
6843
6844/* Handle the MRI ENDF pseudo-op. */
6845
6846static void
31302357 6847s_mri_endf (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 6848{
6849 if (mri_control_stack == NULL
6850 || mri_control_stack->type != mri_for)
6851 {
6852 as_bad (_("endf without for"));
6853 ignore_rest_of_line ();
6854 return;
6855 }
6856
6857 colon (mri_control_stack->next);
6858
6859 mri_assemble (mri_control_stack->incr);
6860
6861 sprintf (mri_control_stack->incr, "bra %s", mri_control_stack->top);
6862 mri_assemble (mri_control_stack->incr);
6863
6864 free (mri_control_stack->incr);
6865
6866 colon (mri_control_stack->bottom);
6867
6868 pop_mri_control ();
6869
6870 if (flag_mri)
6871 {
6872 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6873 ++input_line_pointer;
6874 }
6875
6876 demand_empty_rest_of_line ();
6877}
6878
6879/* Handle the MRI REPEAT pseudo-op. */
6880
6881static void
31302357 6882s_mri_repeat (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 6883{
6884 struct mri_control_info *n;
6885
6886 n = push_mri_control (mri_repeat);
6887 colon (n->top);
6888 if (flag_mri)
6889 {
6890 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6891 ++input_line_pointer;
6892 }
6893 demand_empty_rest_of_line ();
6894}
6895
6896/* Handle the MRI UNTIL pseudo-op. */
6897
6898static void
31302357 6899s_mri_until (int qual)
252b5132
RH		 6900{
6901 char *s;
6902
6903 if (mri_control_stack == NULL
6904 || mri_control_stack->type != mri_repeat)
6905 {
6906 as_bad (_("until without repeat"));
6907 ignore_rest_of_line ();
6908 return;
6909 }
6910
6911 colon (mri_control_stack->next);
6912
6913 for (s = input_line_pointer; ! is_end_of_line[(unsigned char) *s]; s++)
6914 ;
6915
6916 parse_mri_control_expression (s, qual, (const char *) NULL,
6917 mri_control_stack->top, '\0');
6918
6919 colon (mri_control_stack->bottom);
6920
6921 input_line_pointer = s;
6922
6923 pop_mri_control ();
6924
6925 if (flag_mri)
6926 {
6927 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6928 ++input_line_pointer;
6929 }
6930
6931 demand_empty_rest_of_line ();
6932}
6933
6934/* Handle the MRI WHILE pseudo-op. */
6935
6936static void
31302357 6937s_mri_while (int qual)
252b5132
RH		 6938{
6939 char *s;
6940
6941 struct mri_control_info *n;
6942
6943 s = input_line_pointer;
e1f44d10
NC		 6944 /* We only accept '*' as introduction of comments if preceded by white space
6945 or at first column of a line (I think this can't actually happen here?)
6946 This is important when assembling:
6947 while d0 <ne> 12(a0,d0*2) do
36759679 6948 while d0 <ne> #CONST*20 do. */
8a104df9
KH		 6949 while (! (is_end_of_line[(unsigned char) *s]
6950 || (flag_mri
6951 && *s == '*'
6952 && (s == input_line_pointer
6953 || *(s-1) == ' '
6954 || *(s-1) == '\t'))))
252b5132
RH		 6955 s++;
6956 --s;
6957 while (*s == ' ' || *s == '\t')
6958 --s;
6959 if (s - input_line_pointer > 1
6960 && s[-1] == '.')
6961 s -= 2;
6962 if (s - input_line_pointer < 2
6963 || strncasecmp (s - 1, "DO", 2) != 0)
6964 {
6965 as_bad (_("missing do"));
6966 ignore_rest_of_line ();
6967 return;
6968 }
6969
6970 n = push_mri_control (mri_while);
6971
6972 colon (n->next);
6973
6974 parse_mri_control_expression (s - 1, qual, (const char *) NULL, n->bottom,
6975 s[1] == '.' ? s[2] : '\0');
6976
6977 input_line_pointer = s + 1;
6978 if (*input_line_pointer == '.')
6979 input_line_pointer += 2;
6980
6981 if (flag_mri)
6982 {
6983 while (! is_end_of_line[(unsigned char) *input_line_pointer])
6984 ++input_line_pointer;
6985 }
6986
6987 demand_empty_rest_of_line ();
6988}
6989
6990/* Handle the MRI ENDW pseudo-op. */
6991
6992static void
31302357 6993s_mri_endw (int ignore ATTRIBUTE_UNUSED)
252b5132
RH		 6994{
6995 char *buf;
6996
6997 if (mri_control_stack == NULL
6998 || mri_control_stack->type != mri_while)
6999 {
7000 as_bad (_("endw without while"));
7001 ignore_rest_of_line ();
7002 return;
7003 }
7004
7005 buf = (char *) xmalloc (20 + strlen (mri_control_stack->next));
7006 sprintf (buf, "bra %s", mri_control_stack->next);
7007 mri_assemble (buf);
7008 free (buf);
7009
7010 colon (mri_control_stack->bottom);
7011
7012 pop_mri_control ();
7013
7014 if (flag_mri)
7015 {
7016 while (! is_end_of_line[(unsigned char) *input_line_pointer])
7017 ++input_line_pointer;
7018 }
7019
7020 demand_empty_rest_of_line ();
7021}
7022\f
31302357
AS		 7023/* md_parse_option
7024 Invocation line includes a switch not recognized by the base assembler.
7025 See if it's a processor-specific option. These are:
7026
7027 -[A]m[c]68000, -[A]m[c]68008, -[A]m[c]68010, -[A]m[c]68020, -[A]m[c]68030, -[A]m[c]68040
7028 -[A]m[c]68881, -[A]m[c]68882, -[A]m[c]68851
7029 Select the architecture. Instructions or features not
7030 supported by the selected architecture cause fatal
7031 errors. More than one may be specified. The default is
7032 -m68020 -m68851 -m68881. Note that -m68008 is a synonym
7033 for -m68000, and -m68882 is a synonym for -m68881.
7034 -[A]m[c]no-68851, -[A]m[c]no-68881
7035 Don't accept 688?1 instructions. (The "c" is kind of silly,
7036 so don't use or document it, but that's the way the parsing
7037 works).
7038
7039 -pic Indicates PIC.
7040 -k Indicates PIC. (Sun 3 only.)
7041 --pcrel
7042 Never turn PC-relative branches into absolute jumps.
7043 --bitwise-or
7044 Permit `|' to be used in expressions. */
252b5132
RH		 7045
7046#ifdef OBJ_ELF
5a38dc70 7047const char *md_shortopts = "lSA:m:kQ:V";
252b5132 7048#else
5a38dc70 7049const char *md_shortopts = "lSA:m:k";
252b5132
RH		 7050#endif
7051
7052struct option md_longopts[] = {
7053#define OPTION_PIC (OPTION_MD_BASE)
7054 {"pic", no_argument, NULL, OPTION_PIC},
7055#define OPTION_REGISTER_PREFIX_OPTIONAL (OPTION_MD_BASE + 1)
7056 {"register-prefix-optional", no_argument, NULL,
7057 OPTION_REGISTER_PREFIX_OPTIONAL},
7058#define OPTION_BITWISE_OR (OPTION_MD_BASE + 2)
7059 {"bitwise-or", no_argument, NULL, OPTION_BITWISE_OR},
7060#define OPTION_BASE_SIZE_DEFAULT_16 (OPTION_MD_BASE + 3)
7061 {"base-size-default-16", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_16},
7062#define OPTION_BASE_SIZE_DEFAULT_32 (OPTION_MD_BASE + 4)
7063 {"base-size-default-32", no_argument, NULL, OPTION_BASE_SIZE_DEFAULT_32},
7064#define OPTION_DISP_SIZE_DEFAULT_16 (OPTION_MD_BASE + 5)
7065 {"disp-size-default-16", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_16},
7066#define OPTION_DISP_SIZE_DEFAULT_32 (OPTION_MD_BASE + 6)
7067 {"disp-size-default-32", no_argument, NULL, OPTION_DISP_SIZE_DEFAULT_32},
28e7409f
NC		 7068#define OPTION_PCREL (OPTION_MD_BASE + 7)
7069 {"pcrel", no_argument, NULL, OPTION_PCREL},
252b5132
RH		 7070 {NULL, no_argument, NULL, 0}
7071};
bc805888 7072size_t md_longopts_size = sizeof (md_longopts);
252b5132
RH		 7073
7074int
31302357 7075md_parse_option (int c, char *arg)
252b5132
RH		 7076{
7077 switch (c)
7078 {
7079 case 'l': /* -l means keep external to 2 bit offset
36759679 7080 rather than 16 bit one. */
252b5132
RH		 7081 flag_short_refs = 1;
7082 break;
7083
7084 case 'S': /* -S means that jbsr's always turn into
7085 jsr's. */
7086 flag_long_jumps = 1;
7087 break;
7088
28e7409f
NC		 7089 case OPTION_PCREL: /* --pcrel means never turn PC-relative
7090 branches into absolute jumps. */
7091 flag_keep_pcrel = 1;
7092 break;
7093
252b5132
RH		 7094 case 'A':
7095 if (*arg == 'm')
8a104df9 7096 arg++;
36759679 7097 /* Intentional fall-through. */
252b5132
RH		 7098 case 'm':
7099
7100 if (arg[0] == 'n' && arg[1] == 'o' && arg[2] == '-')
7101 {
7102 int i;
7103 unsigned long arch;
252b5132
RH		 7104
7105 arg += 3;
7106 if (*arg == 'm')
7107 {
7108 arg++;
7109 if (arg[0] == 'c' && arg[1] == '6')
7110 arg++;
7111 }
7112 for (i = 0; i < n_archs; i++)
7113 if (!strcmp (arg, archs[i].name))
7114 break;
7115 if (i == n_archs)
329e276d
NC		 7116 return 0;
7117
252b5132
RH		 7118 arch = archs[i].arch;
7119 if (arch == m68881)
7120 no_68881 = 1;
7121 else if (arch == m68851)
7122 no_68851 = 1;
7123 else
329e276d 7124 return 0;
252b5132
RH		 7125 }
7126 else
7127 {
7128 int i;
7129
7130 if (arg[0] == 'c' && arg[1] == '6')
7131 arg++;
7132
7133 for (i = 0; i < n_archs; i++)
7134 if (!strcmp (arg, archs[i].name))
7135 {
7136 unsigned long arch = archs[i].arch;
329e276d 7137
252b5132
RH		 7138 if (cpu_of_arch (arch))
7139 /* It's a cpu spec. */
7140 {
7141 current_architecture &= ~m68000up;
7142 current_architecture |= arch;
990ae22a 7143 current_chip = archs[i].chip;
252b5132
RH		 7144 }
7145 else if (arch == m68881)
7146 {
7147 current_architecture |= m68881;
7148 no_68881 = 0;
7149 }
7150 else if (arch == m68851)
7151 {
7152 current_architecture |= m68851;
7153 no_68851 = 0;
7154 }
7155 else
7156 /* ??? */
7157 abort ();
7158 break;
7159 }
7160 if (i == n_archs)
7161 {
7162 as_bad (_("unrecognized architecture specification `%s'"), arg);
7163 return 0;
7164 }
7165 }
7166 break;
7167
7168 case OPTION_PIC:
7169 case 'k':
7170 flag_want_pic = 1;
36759679 7171 break; /* -pic, Position Independent Code. */
252b5132
RH		 7172
7173 case OPTION_REGISTER_PREFIX_OPTIONAL:
7174 flag_reg_prefix_optional = 1;
7175 reg_prefix_optional_seen = 1;
7176 break;
7177
7178 /* -V: SVR4 argument to print version ID. */
7179 case 'V':
7180 print_version_id ();
7181 break;
7182
7183 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
7184 should be emitted or not. FIXME: Not implemented. */
7185 case 'Q':
7186 break;
7187
7188 case OPTION_BITWISE_OR:
7189 {
7190 char *n, *t;
7191 const char *s;
7192
7193 n = (char *) xmalloc (strlen (m68k_comment_chars) + 1);
7194 t = n;
7195 for (s = m68k_comment_chars; *s != '\0'; s++)
7196 if (*s != '|')
7197 *t++ = *s;
7198 *t = '\0';
7199 m68k_comment_chars = n;
7200 }
7201 break;
7202
7203 case OPTION_BASE_SIZE_DEFAULT_16:
7204 m68k_index_width_default = SIZE_WORD;
7205 break;
7206
7207 case OPTION_BASE_SIZE_DEFAULT_32:
7208 m68k_index_width_default = SIZE_LONG;
7209 break;
7210
7211 case OPTION_DISP_SIZE_DEFAULT_16:
7212 m68k_rel32 = 0;
7213 m68k_rel32_from_cmdline = 1;
7214 break;
7215
7216 case OPTION_DISP_SIZE_DEFAULT_32:
7217 m68k_rel32 = 1;
7218 m68k_rel32_from_cmdline = 1;
7219 break;
7220
7221 default:
7222 return 0;
7223 }
7224
7225 return 1;
7226}
7227
7228void
31302357 7229md_show_usage (FILE *stream)
252b5132 7230{
76f57f3a 7231 const char *default_cpu = TARGET_CPU;
f1f5ef86
AM		 7232 int i;
7233 unsigned int default_arch;
76f57f3a 7234
8a104df9 7235 /* Get the canonical name for the default target CPU. */
76f57f3a
JT		 7236 if (*default_cpu == 'm')
7237 default_cpu++;
7238 for (i = 0; i < n_archs; i++)
7239 {
7240 if (strcasecmp (default_cpu, archs[i].name) == 0)
7241 {
7242 default_arch = archs[i].arch;
7243 for (i = 0; i < n_archs; i++)
7244 {
7245 if (archs[i].arch == default_arch
7246 && !archs[i].alias)
7247 {
7248 default_cpu = archs[i].name;
7249 break;
7250 }
7251 }
7252 }
7253 }
7254
bc805888 7255 fprintf (stream, _("\
252b5132
RH		 7256680X0 options:\n\
7257-l use 1 word for refs to undefined symbols [default 2]\n\
98b32482
NC		 7258-m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040 | -m68060 |\n\
7259-m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -m68360 | -mcpu32 |\n\
6b6e92f4
NC		 7260-m5200 | -m5202 | -m5204 | -m5206 | -m5206e | -m521x | -m5249 |\n\
7261-m528x | -m5307 | -m5407 | -m547x | -m548x | -mcfv4 | -mcfv4e\n\
76f57f3a 7262 specify variant of 680X0 architecture [default %s]\n\
252b5132
RH		 7263-m68881 | -m68882 | -mno-68881 | -mno-68882\n\
7264 target has/lacks floating-point coprocessor\n\
76f57f3a
JT		 7265 [default yes for 68020, 68030, and cpu32]\n"),
7266 default_cpu);
bc805888 7267 fprintf (stream, _("\
252b5132
RH		 7268-m68851 | -mno-68851\n\
7269 target has/lacks memory-management unit coprocessor\n\
7270 [default yes for 68020 and up]\n\
7271-pic, -k generate position independent code\n\
7272-S turn jbsr into jsr\n\
28e7409f 7273--pcrel never turn PC-relative branches into absolute jumps\n\
252b5132
RH		 7274--register-prefix-optional\n\
7275 recognize register names without prefix character\n\
7276--bitwise-or do not treat `|' as a comment character\n"));
7277 fprintf (stream, _("\
7278--base-size-default-16 base reg without size is 16 bits\n\
7279--base-size-default-32 base reg without size is 32 bits (default)\n\
7280--disp-size-default-16 displacement with unknown size is 16 bits\n\
7281--disp-size-default-32 displacement with unknown size is 32 bits (default)\n"));
7282}
7283\f
7284#ifdef TEST2
7285
7286/* TEST2: Test md_assemble() */
36759679
NC		 7287/* Warning, this routine probably doesn't work anymore. */
7288int
31302357 7289main (void)
252b5132
RH		 7290{
7291 struct m68k_it the_ins;
7292 char buf[120];
7293 char *cp;
7294 int n;
7295
7296 m68k_ip_begin ();
7297 for (;;)
7298 {
7299 if (!gets (buf) || !*buf)
7300 break;
7301 if (buf[0] == '|' || buf[1] == '.')
7302 continue;
7303 for (cp = buf; *cp; cp++)
7304 if (*cp == '\t')
7305 *cp = ' ';
7306 if (is_label (buf))
7307 continue;
7308 memset (&the_ins, '\0', sizeof (the_ins));
7309 m68k_ip (&the_ins, buf);
7310 if (the_ins.error)
7311 {
7312 printf (_("Error %s in %s\n"), the_ins.error, buf);
7313 }
7314 else
7315 {
7316 printf (_("Opcode(%d.%s): "), the_ins.numo, the_ins.args);
7317 for (n = 0; n < the_ins.numo; n++)
7318 printf (" 0x%x", the_ins.opcode[n] & 0xffff);
7319 printf (" ");
7320 print_the_insn (&the_ins.opcode[0], stdout);
7321 (void) putchar ('\n');
7322 }
7323 for (n = 0; n < strlen (the_ins.args) / 2; n++)
7324 {
7325 if (the_ins.operands[n].error)
7326 {
7327 printf ("op%d Error %s in %s\n", n, the_ins.operands[n].error, buf);
7328 continue;
7329 }
31302357
AS		 7330 printf ("mode %d, reg %d, ", the_ins.operands[n].mode,
7331 the_ins.operands[n].reg);
252b5132 7332 if (the_ins.operands[n].b_const)
31302357
AS		 7333 printf ("Constant: '%.*s', ",
7334 1 + the_ins.operands[n].e_const - the_ins.operands[n].b_const,
7335 the_ins.operands[n].b_const);
7336 printf ("ireg %d, isiz %d, imul %d, ", the_ins.operands[n].ireg,
7337 the_ins.operands[n].isiz, the_ins.operands[n].imul);
252b5132 7338 if (the_ins.operands[n].b_iadd)
31302357
AS		 7339 printf ("Iadd: '%.*s',",
7340 1 + the_ins.operands[n].e_iadd - the_ins.operands[n].b_iadd,
7341 the_ins.operands[n].b_iadd);
7342 putchar ('\n');
252b5132
RH		 7343 }
7344 }
7345 m68k_ip_end ();
7346 return 0;
7347}
7348
31302357
AS		 7349int
7350is_label (char *str)
252b5132
RH		 7351{
7352 while (*str == ' ')
7353 str++;
7354 while (*str && *str != ' ')
7355 str++;
7356 if (str[-1] == ':' || str[1] == '=')
7357 return 1;
7358 return 0;
7359}
7360
7361#endif
7362
7363/* Possible states for relaxation:
7364
7365 0 0 branch offset byte (bra, etc)
7366 0 1 word
7367 0 2 long
7368
7369 1 0 indexed offsets byte a0@(32,d4:w:1) etc
7370 1 1 word
7371 1 2 long
7372
7373 2 0 two-offset index word-word a0@(32,d4)@(45) etc
7374 2 1 word-long
7375 2 2 long-word
7376 2 3 long-long
7377
7378 */
7379
7380/* We have no need to default values of symbols. */
7381
252b5132 7382symbolS *
31302357 7383md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
252b5132
RH		 7384{
7385 return 0;
7386}
7387
7388/* Round up a section size to the appropriate boundary. */
7389valueT
31302357 7390md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
252b5132
RH		 7391{
7392#ifdef OBJ_AOUT
7393#ifdef BFD_ASSEMBLER
7394 /* For a.out, force the section size to be aligned. If we don't do
7395 this, BFD will align it for us, but it will not write out the
7396 final bytes of the section. This may be a bug in BFD, but it is
7397 easier to fix it here since that is how the other a.out targets
7398 work. */
7399 int align;
7400
7401 align = bfd_get_section_alignment (stdoutput, segment);
7402 size = ((size + (1 << align) - 1) & ((valueT) -1 << align));
7403#endif
7404#endif
7405
7406 return size;
7407}
7408
7409/* Exactly what point is a PC-relative offset relative TO?
7410 On the 68k, it is relative to the address of the first extension
7411 word. The difference between the addresses of the offset and the
92774660 7412 first extension word is stored in fx_pcrel_adjust. */
252b5132 7413long
31302357 7414md_pcrel_from (fixS *fixP)
252b5132
RH		 7415{
7416 int adjust;
7417
8390138c
AS		 7418 /* Because fx_pcrel_adjust is a char, and may be unsigned, we explicitly
7419 sign extend the value here. */
7420 adjust = ((fixP->fx_pcrel_adjust & 0xff) ^ 0x80) - 0x80;
252b5132
RH		 7421 if (adjust == 64)
7422 adjust = -1;
7423 return fixP->fx_where + fixP->fx_frag->fr_address - adjust;
7424}
7425
7426#ifndef BFD_ASSEMBLER
7427#ifdef OBJ_COFF
7428
252b5132 7429void
31302357 7430tc_coff_symbol_emit_hook (symbolS *ignore ATTRIBUTE_UNUSED)
252b5132
RH		 7431{
7432}
7433
7434int
31302357 7435tc_coff_sizemachdep (fragS *frag)
252b5132
RH		 7436{
7437 switch (frag->fr_subtype & 0x3)
7438 {
7439 case BYTE:
7440 return 1;
7441 case SHORT:
7442 return 2;
7443 case LONG:
7444 return 4;
7445 default:
7446 abort ();
7447 return 0;
7448 }
7449}
7450
7451#endif
7452#endif
31302357 7453
0d96863f 7454#ifdef OBJ_ELF
8a104df9 7455void
31302357 7456m68k_elf_final_processing (void)
0d96863f 7457{
36759679 7458 /* Set file-specific flags if this is a cpu32 processor. */
238d258f
NC		 7459 if (arch_coldfire_fpu (current_architecture))
7460 elf_elfheader (stdoutput)->e_flags |= EF_CFV4E;
8a104df9
KH		 7461 if (cpu_of_arch (current_architecture) & cpu32)
7462 elf_elfheader (stdoutput)->e_flags |= EF_CPU32;
7463 else if ((cpu_of_arch (current_architecture) & m68000up)
7464 && !(cpu_of_arch (current_architecture) & m68020up))
7465 elf_elfheader (stdoutput)->e_flags |= EF_M68000;
0d96863f
CM		 7466}
7467#endif
c04898f8
AS		 7468
7469int
7470tc_m68k_regname_to_dw2regnum (const char *regname)
7471{
7472 unsigned int regnum;
7473 static const char *const regnames[] =
7474 {
7475 "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",
7476 "a0", "a1", "a2", "a3", "a4", "a5", "a6", "sp",
7477 "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7",
7478 "pc"
7479 };
7480
7481 for (regnum = 0; regnum < ARRAY_SIZE (regnames); regnum++)
7482 if (strcmp (regname, regnames[regnum]) == 0)
7483 return regnum;
7484
7485 return -1;
7486}
7487
7488void
7489tc_m68k_frame_initial_instructions (void)
7490{
7491 static int sp_regno = -1;
7492
7493 if (sp_regno < 0)
7494 sp_regno = tc_m68k_regname_to_dw2regnum ("sp");
7495
7496 cfi_add_CFA_def_cfa (sp_regno, -DWARF2_CIE_DATA_ALIGNMENT);
7497 cfi_add_CFA_offset (DWARF2_DEFAULT_RETURN_COLUMN, DWARF2_CIE_DATA_ALIGNMENT);
7498}
A mirror of the official binutils-gdb repository