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