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