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