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