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