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