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