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