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