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