1 /* tc-m68k.c -- Assemble for the m68k family
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
28 #include "opcode/m68k.h"
29 #include "m68k-parse.h"
35 /* This string holds the chars that always start a comment. If the
36 pre-processor is disabled, these aren't very useful. The macro
37 tc_comment_chars points to this. We use this, rather than the
38 usual comment_chars, so that the --bitwise-or option will work. */
39 #if defined (TE_SVR4) || defined (TE_DELTA)
40 const char *m68k_comment_chars
= "|#";
42 const char *m68k_comment_chars
= "|";
45 /* This array holds the chars that only start a comment at the beginning of
46 a line. If the line seems to have the form '# 123 filename'
47 .line and .file directives will appear in the pre-processed output */
48 /* Note that input_file.c hand checks for '#' at the beginning of the
49 first line of the input file. This is because the compiler outputs
50 #NO_APP at the beginning of its output. */
51 /* Also note that comments like this one will always work. */
52 const char line_comment_chars
[] = "#*";
54 const char line_separator_chars
[] = ";";
56 /* Chars that can be used to separate mant from exp in floating point nums */
57 CONST
char EXP_CHARS
[] = "eE";
59 /* Chars that mean this number is a floating point constant, as
60 in "0f12.456" or "0d1.2345e12". */
62 CONST
char FLT_CHARS
[] = "rRsSfFdDxXeEpP";
64 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
65 changed in read.c . Ideally it shouldn't have to know about it at all,
66 but nothing is ideal around here. */
68 const int md_reloc_size
= 8; /* Size of relocation record */
70 /* Are we trying to generate PIC code? If so, absolute references
71 ought to be made into linkage table references or pc-relative
72 references. Not implemented. For ELF there are other means
73 to denote pic relocations. */
76 static int flag_short_refs
; /* -l option */
77 static int flag_long_jumps
; /* -S option */
78 static int flag_keep_pcrel
; /* --pcrel option. */
80 #ifdef REGISTER_PREFIX_OPTIONAL
81 int flag_reg_prefix_optional
= REGISTER_PREFIX_OPTIONAL
;
83 int flag_reg_prefix_optional
;
86 /* Whether --register-prefix-optional was used on the command line. */
87 static int reg_prefix_optional_seen
;
89 /* The floating point coprocessor to use by default. */
90 static enum m68k_register m68k_float_copnum
= COP1
;
92 /* If this is non-zero, then references to number(%pc) will be taken
93 to refer to number, rather than to %pc + number. */
94 static int m68k_abspcadd
;
96 /* If this is non-zero, then the quick forms of the move, add, and sub
97 instructions are used when possible. */
98 static int m68k_quick
= 1;
100 /* If this is non-zero, then if the size is not specified for a base
101 or outer displacement, the assembler assumes that the size should
103 static int m68k_rel32
= 1;
105 /* This is non-zero if m68k_rel32 was set from the command line. */
106 static int m68k_rel32_from_cmdline
;
108 /* The default width to use for an index register when using a base
110 static enum m68k_size m68k_index_width_default
= SIZE_LONG
;
112 /* We want to warn if any text labels are misaligned. In order to get
113 the right line number, we need to record the line number for each
118 struct label_line
*next
;
125 /* The list of labels. */
127 static struct label_line
*labels
;
129 /* The current label. */
131 static struct label_line
*current_label
;
133 /* Its an arbitrary name: This means I don't approve of it */
134 /* See flames below */
135 static struct obstack robyn
;
139 const char *m_operands
;
140 unsigned long m_opcode
;
144 struct m68k_incant
*m_next
;
147 #define getone(x) ((((x)->m_opcode)>>16)&0xffff)
148 #define gettwo(x) (((x)->m_opcode)&0xffff)
150 static const enum m68k_register m68000_control_regs
[] = { 0 };
151 static const enum m68k_register m68010_control_regs
[] = {
155 static const enum m68k_register m68020_control_regs
[] = {
156 SFC
, DFC
, USP
, VBR
, CACR
, CAAR
, MSP
, ISP
,
159 static const enum m68k_register m68040_control_regs
[] = {
160 SFC
, DFC
, CACR
, TC
, ITT0
, ITT1
, DTT0
, DTT1
,
161 USP
, VBR
, MSP
, ISP
, MMUSR
, URP
, SRP
,
164 static const enum m68k_register m68060_control_regs
[] = {
165 SFC
, DFC
, CACR
, TC
, ITT0
, ITT1
, DTT0
, DTT1
, BUSCR
,
166 USP
, VBR
, URP
, SRP
, PCR
,
169 static const enum m68k_register mcf_control_regs
[] = {
170 CACR
, TC
, ITT0
, ITT1
, DTT0
, DTT1
, VBR
, ROMBAR
,
171 RAMBAR0
, RAMBAR1
, MBAR
,
174 #define cpu32_control_regs m68010_control_regs
176 static const enum m68k_register
*control_regs
;
178 /* internal form of a 68020 instruction */
182 const char *args
; /* list of opcode info */
185 int numo
; /* Number of shorts in opcode */
188 struct m68k_op operands
[6];
190 int nexp
; /* number of exprs in use */
191 struct m68k_exp exprs
[4];
193 int nfrag
; /* Number of frags we have to produce */
196 int fragoff
; /* Where in the current opcode the frag ends */
203 int nrel
; /* Num of reloc strucs in use */
210 /* In a pc relative address the difference between the address
211 of the offset and the address that the offset is relative
212 to. This depends on the addressing mode. Basically this
213 is the value to put in the offset field to address the
214 first byte of the offset, without regarding the special
215 significance of some values (in the branch instruction, for
219 /* Whether this expression needs special pic relocation, and if
221 enum pic_relocation pic_reloc
;
224 reloc
[5]; /* Five is enough??? */
227 #define cpu_of_arch(x) ((x) & (m68000up|mcf))
228 #define float_of_arch(x) ((x) & mfloat)
229 #define mmu_of_arch(x) ((x) & mmmu)
230 #define arch_coldfire_p(x) (((x) & mcf) != 0)
232 /* Macros for determining if cpu supports a specific addressing mode */
233 #define HAVE_LONG_BRANCH(x) ((x) & (m68020|m68030|m68040|m68060|cpu32|mcf5407))
235 static struct m68k_it the_ins
; /* the instruction being assembled */
237 #define op(ex) ((ex)->exp.X_op)
238 #define adds(ex) ((ex)->exp.X_add_symbol)
239 #define subs(ex) ((ex)->exp.X_op_symbol)
240 #define offs(ex) ((ex)->exp.X_add_number)
242 /* Macros for adding things to the m68k_it struct */
244 #define addword(w) the_ins.opcode[the_ins.numo++]=(w)
246 /* Static functions. */
248 static void insop
PARAMS ((int, const struct m68k_incant
*));
249 static void add_fix
PARAMS ((int, struct m68k_exp
*, int, int));
250 static void add_frag
PARAMS ((symbolS
*, offsetT
, int));
252 /* Like addword, but goes BEFORE general operands */
256 const struct m68k_incant
*opcode
;
259 for(z
=the_ins
.numo
;z
>opcode
->m_codenum
;--z
)
260 the_ins
.opcode
[z
]=the_ins
.opcode
[z
-1];
261 for(z
=0;z
<the_ins
.nrel
;z
++)
262 the_ins
.reloc
[z
].n
+=2;
263 for (z
= 0; z
< the_ins
.nfrag
; z
++)
264 the_ins
.fragb
[z
].fragoff
++;
265 the_ins
.opcode
[opcode
->m_codenum
]=w
;
269 /* The numo+1 kludge is so we can hit the low order byte of the prev word.
272 add_fix (width
, exp
, pc_rel
, pc_fix
)
274 struct m68k_exp
*exp
;
278 the_ins
.reloc
[the_ins
.nrel
].n
= ((width
== 'B' || width
== '3')
282 : (the_ins
.numo
*2)));
283 the_ins
.reloc
[the_ins
.nrel
].exp
= exp
->exp
;
284 the_ins
.reloc
[the_ins
.nrel
].wid
= width
;
285 the_ins
.reloc
[the_ins
.nrel
].pcrel_fix
= pc_fix
;
287 the_ins
.reloc
[the_ins
.nrel
].pic_reloc
= exp
->pic_reloc
;
289 the_ins
.reloc
[the_ins
.nrel
++].pcrel
= pc_rel
;
292 /* Cause an extra frag to be generated here, inserting up to 10 bytes
293 (that value is chosen in the frag_var call in md_assemble). TYPE
294 is the subtype of the frag to be generated; its primary type is
295 rs_machine_dependent.
297 The TYPE parameter is also used by md_convert_frag_1 and
298 md_estimate_size_before_relax. The appropriate type of fixup will
299 be emitted by md_convert_frag_1.
301 ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET. */
303 add_frag (add
, off
, type
)
308 the_ins
.fragb
[the_ins
.nfrag
].fragoff
=the_ins
.numo
;
309 the_ins
.fragb
[the_ins
.nfrag
].fadd
=add
;
310 the_ins
.fragb
[the_ins
.nfrag
].foff
=off
;
311 the_ins
.fragb
[the_ins
.nfrag
++].fragty
=type
;
315 (op (ex) != O_constant && op (ex) != O_big)
317 static char *crack_operand
PARAMS ((char *str
, struct m68k_op
*opP
));
318 static int get_num
PARAMS ((struct m68k_exp
*exp
, int ok
));
319 static void m68k_ip
PARAMS ((char *));
320 static void insert_reg
PARAMS ((const char *, int));
321 static void select_control_regs
PARAMS ((void));
322 static void init_regtable
PARAMS ((void));
323 static int reverse_16_bits
PARAMS ((int in
));
324 static int reverse_8_bits
PARAMS ((int in
));
325 static void install_gen_operand
PARAMS ((int mode
, int val
));
326 static void install_operand
PARAMS ((int mode
, int val
));
327 static void s_bss
PARAMS ((int));
328 static void s_data1
PARAMS ((int));
329 static void s_data2
PARAMS ((int));
330 static void s_even
PARAMS ((int));
331 static void s_proc
PARAMS ((int));
332 static void mri_chip
PARAMS ((void));
333 static void s_chip
PARAMS ((int));
334 static void s_fopt
PARAMS ((int));
335 static void s_opt
PARAMS ((int));
336 static void s_reg
PARAMS ((int));
337 static void s_restore
PARAMS ((int));
338 static void s_save
PARAMS ((int));
339 static void s_mri_if
PARAMS ((int));
340 static void s_mri_else
PARAMS ((int));
341 static void s_mri_endi
PARAMS ((int));
342 static void s_mri_break
PARAMS ((int));
343 static void s_mri_next
PARAMS ((int));
344 static void s_mri_for
PARAMS ((int));
345 static void s_mri_endf
PARAMS ((int));
346 static void s_mri_repeat
PARAMS ((int));
347 static void s_mri_until
PARAMS ((int));
348 static void s_mri_while
PARAMS ((int));
349 static void s_mri_endw
PARAMS ((int));
350 static void md_apply_fix_2
PARAMS ((fixS
*, offsetT
));
351 static void md_convert_frag_1
PARAMS ((fragS
*));
353 static int current_architecture
;
362 static const struct m68k_cpu archs
[] =
364 { m68000
, "68000", 0 },
365 { m68010
, "68010", 0 },
366 { m68020
, "68020", 0 },
367 { m68030
, "68030", 0 },
368 { m68040
, "68040", 0 },
369 { m68060
, "68060", 0 },
370 { cpu32
, "cpu32", 0 },
371 { m68881
, "68881", 0 },
372 { m68851
, "68851", 0 },
373 { mcf5200
, "5200", 0 },
374 { mcf5206e
, "5206e", 0 },
375 { mcf5307
, "5307", 0},
376 { mcf5407
, "5407", 0},
377 /* Aliases (effectively, so far as gas is concerned) for the above
379 { m68020
, "68k", 1 },
380 { m68000
, "68008", 1 },
381 { m68000
, "68302", 1 },
382 { m68000
, "68306", 1 },
383 { m68000
, "68307", 1 },
384 { m68000
, "68322", 1 },
385 { m68000
, "68356", 1 },
386 { m68000
, "68ec000", 1 },
387 { m68000
, "68hc000", 1 },
388 { m68000
, "68hc001", 1 },
389 { m68020
, "68ec020", 1 },
390 { m68030
, "68ec030", 1 },
391 { m68040
, "68ec040", 1 },
392 { m68060
, "68ec060", 1 },
393 { cpu32
, "68330", 1 },
394 { cpu32
, "68331", 1 },
395 { cpu32
, "68332", 1 },
396 { cpu32
, "68333", 1 },
397 { cpu32
, "68334", 1 },
398 { cpu32
, "68336", 1 },
399 { cpu32
, "68340", 1 },
400 { cpu32
, "68341", 1 },
401 { cpu32
, "68349", 1 },
402 { cpu32
, "68360", 1 },
403 { m68881
, "68882", 1 },
404 { mcf5200
, "5202", 1 },
405 { mcf5200
, "5204", 1 },
406 { mcf5200
, "5206", 1 },
409 static const int n_archs
= sizeof (archs
) / sizeof (archs
[0]);
411 /* This is the assembler relaxation table for m68k. m68k is a rich CISC
412 architecture and we have a lot of relaxation modes. */
414 /* Macros used in the relaxation code. */
415 #define TAB(x,y) (((x) << 2) + (y))
416 #define TABTYPE(x) ((x) >> 2)
418 /* Relaxation states. */
424 /* Here are all the relaxation modes we support. First we can relax ordinary
425 branches. On 68020 and higher and on CPU32 all branch instructions take
426 three forms, so on these CPUs all branches always remain as such. When we
427 have to expand to the LONG form on a 68000, though, we substitute an
428 absolute jump instead. This is a direct replacement for unconditional
429 branches and a branch over a jump for conditional branches. However, if the
430 user requires PIC and disables this with --pcrel, we can only relax between
431 BYTE and SHORT forms, punting if that isn't enough. This gives us four
432 different relaxation modes for branches: */
434 #define BRANCHBWL 1 /* branch byte, word, or long */
435 #define BRABSJUNC 2 /* absolute jump for LONG, unconditional */
436 #define BRABSJCOND 3 /* absolute jump for LONG, conditional */
437 #define BRANCHBW 4 /* branch byte or word */
439 /* We also relax coprocessor branches and DBcc's. All CPUs that support
440 coprocessor branches support them in word and long forms, so we have only
441 one relaxation mode for them. DBcc's are word only on all CPUs. We can
442 relax them to the LONG form with a branch-around sequence. This sequence
443 can use a long branch (if available) or an absolute jump (if acceptable).
444 This gives us two relaxation modes. If long branches are not available and
445 absolute jumps are not acceptable, we don't relax DBcc's. */
447 #define FBRANCH 5 /* coprocessor branch */
448 #define DBCCLBR 6 /* DBcc relaxable with a long branch */
449 #define DBCCABSJ 7 /* DBcc relaxable with an absolute jump */
451 /* That's all for instruction relaxation. However, we also relax PC-relative
452 operands. Specifically, we have three operand relaxation modes. On the
453 68000 PC-relative operands can only be 16-bit, but on 68020 and higher and
454 on CPU32 they may be 16-bit or 32-bit. For the latter we relax between the
455 two. Also PC+displacement+index operands in their simple form (with a non-
456 suppressed index without memory indirection) are supported on all CPUs, but
457 on the 68000 the displacement can be 8-bit only, whereas on 68020 and higher
458 and on CPU32 we relax it to SHORT and LONG forms as well using the extended
459 form of the PC+displacement+index operand. Finally, some absolute operands
460 can be relaxed down to 16-bit PC-relative. */
462 #define PCREL1632 8 /* 16-bit or 32-bit PC-relative */
463 #define PCINDEX 9 /* PC+displacement+index */
464 #define ABSTOPCREL 10 /* absolute relax down to 16-bit PC-relative */
466 /* Note that calls to frag_var need to specify the maximum expansion
467 needed; this is currently 10 bytes for DBCC. */
470 How far Forward this mode will reach:
471 How far Backward this mode will reach:
472 How many bytes this mode will add to the size of the frag
473 Which mode to go to if the offset won't fit in this one
475 relax_typeS md_relax_table
[] =
477 {1, 1, 0, 0}, /* First entries aren't used */
478 {1, 1, 0, 0}, /* For no good reason except */
479 {1, 1, 0, 0}, /* that the VAX doesn't either */
482 {(127), (-128), 0, TAB (BRANCHBWL
, SHORT
)},
483 {(32767), (-32768), 2, TAB (BRANCHBWL
, LONG
)},
487 {(127), (-128), 0, TAB (BRABSJUNC
, SHORT
)},
488 {(32767), (-32768), 2, TAB (BRABSJUNC
, LONG
)},
492 {(127), (-128), 0, TAB (BRABSJCOND
, SHORT
)},
493 {(32767), (-32768), 2, TAB (BRABSJCOND
, LONG
)},
497 {(127), (-128), 0, TAB (BRANCHBW
, SHORT
)},
502 {1, 1, 0, 0}, /* FBRANCH doesn't come BYTE */
503 {(32767), (-32768), 2, TAB (FBRANCH
, LONG
)},
507 {1, 1, 0, 0}, /* DBCC doesn't come BYTE */
508 {(32767), (-32768), 2, TAB (DBCCLBR
, LONG
)},
512 {1, 1, 0, 0}, /* DBCC doesn't come BYTE */
513 {(32767), (-32768), 2, TAB (DBCCABSJ
, LONG
)},
517 {1, 1, 0, 0}, /* PCREL1632 doesn't come BYTE */
518 {32767, -32768, 2, TAB (PCREL1632
, LONG
)},
522 {125, -130, 0, TAB (PCINDEX
, SHORT
)},
523 {32765, -32770, 2, TAB (PCINDEX
, LONG
)},
527 {1, 1, 0, 0}, /* ABSTOPCREL doesn't come BYTE */
528 {(32767), (-32768), 2, TAB (ABSTOPCREL
, LONG
)},
533 /* These are the machine dependent pseudo-ops. These are included so
534 the assembler can work on the output from the SUN C compiler, which
538 /* This table describes all the machine specific pseudo-ops the assembler
539 has to support. The fields are:
540 pseudo-op name without dot
541 function to call to execute this pseudo-op
542 Integer arg to pass to the function
544 const pseudo_typeS md_pseudo_table
[] =
546 {"data1", s_data1
, 0},
547 {"data2", s_data2
, 0},
550 {"skip", s_space
, 0},
552 #if defined (TE_SUN3) || defined (OBJ_ELF)
553 {"align", s_align_bytes
, 0},
556 {"swbeg", s_ignore
, 0},
558 {"extend", float_cons
, 'x'},
559 {"ldouble", float_cons
, 'x'},
561 /* The following pseudo-ops are supported for MRI compatibility. */
563 {"comline", s_space
, 1},
565 {"mask2", s_ignore
, 0},
568 {"restore", s_restore
, 0},
572 {"if.b", s_mri_if
, 'b'},
573 {"if.w", s_mri_if
, 'w'},
574 {"if.l", s_mri_if
, 'l'},
575 {"else", s_mri_else
, 0},
576 {"else.s", s_mri_else
, 's'},
577 {"else.l", s_mri_else
, 'l'},
578 {"endi", s_mri_endi
, 0},
579 {"break", s_mri_break
, 0},
580 {"break.s", s_mri_break
, 's'},
581 {"break.l", s_mri_break
, 'l'},
582 {"next", s_mri_next
, 0},
583 {"next.s", s_mri_next
, 's'},
584 {"next.l", s_mri_next
, 'l'},
585 {"for", s_mri_for
, 0},
586 {"for.b", s_mri_for
, 'b'},
587 {"for.w", s_mri_for
, 'w'},
588 {"for.l", s_mri_for
, 'l'},
589 {"endf", s_mri_endf
, 0},
590 {"repeat", s_mri_repeat
, 0},
591 {"until", s_mri_until
, 0},
592 {"until.b", s_mri_until
, 'b'},
593 {"until.w", s_mri_until
, 'w'},
594 {"until.l", s_mri_until
, 'l'},
595 {"while", s_mri_while
, 0},
596 {"while.b", s_mri_while
, 'b'},
597 {"while.w", s_mri_while
, 'w'},
598 {"while.l", s_mri_while
, 'l'},
599 {"endw", s_mri_endw
, 0},
604 /* The mote pseudo ops are put into the opcode table, since they
605 don't start with a . they look like opcodes to gas.
609 extern void obj_coff_section
PARAMS ((int));
612 CONST pseudo_typeS mote_pseudo_table
[] =
625 {"xdef", s_globl
, 0},
627 {"align", s_align_bytes
, 0},
629 {"align", s_align_ptwo
, 0},
632 {"sect", obj_coff_section
, 0},
633 {"section", obj_coff_section
, 0},
638 #define issbyte(x) ((x)>=-128 && (x)<=127)
639 #define isubyte(x) ((x)>=0 && (x)<=255)
640 #define issword(x) ((x)>=-32768 && (x)<=32767)
641 #define isuword(x) ((x)>=0 && (x)<=65535)
643 #define isbyte(x) ((x)>= -255 && (x)<=255)
644 #define isword(x) ((x)>=-65536 && (x)<=65535)
645 #define islong(x) (1)
647 extern char *input_line_pointer
;
649 static char mklower_table
[256];
650 #define mklower(c) (mklower_table[(unsigned char) (c)])
651 static char notend_table
[256];
652 static char alt_notend_table
[256];
654 (! (notend_table[(unsigned char) *s] \
656 && alt_notend_table[(unsigned char) s[1]])))
658 #if defined (M68KCOFF) && !defined (BFD_ASSEMBLER)
660 #ifdef NO_PCREL_RELOCS
663 make_pcrel_absolute(fixP
, add_number
)
667 register unsigned char *opcode
= fixP
->fx_frag
->fr_opcode
;
669 /* rewrite the PC relative instructions to absolute address ones.
670 * these are rumoured to be faster, and the apollo linker refuses
671 * to deal with the PC relative relocations.
673 if (opcode
[0] == 0x60 && opcode
[1] == 0xff) /* BRA -> JMP */
678 else if (opcode
[0] == 0x61 && opcode
[1] == 0xff) /* BSR -> JSR */
684 as_fatal (_("Unknown PC relative instruction"));
689 #endif /* NO_PCREL_RELOCS */
692 tc_coff_fix2rtype (fixP
)
695 if (fixP
->fx_tcbit
&& fixP
->fx_size
== 4)
696 return R_RELLONG_NEG
;
697 #ifdef NO_PCREL_RELOCS
698 know (fixP
->fx_pcrel
== 0);
699 return (fixP
->fx_size
== 1 ? R_RELBYTE
700 : fixP
->fx_size
== 2 ? R_DIR16
703 return (fixP
->fx_pcrel
?
704 (fixP
->fx_size
== 1 ? R_PCRBYTE
:
705 fixP
->fx_size
== 2 ? R_PCRWORD
:
707 (fixP
->fx_size
== 1 ? R_RELBYTE
:
708 fixP
->fx_size
== 2 ? R_RELWORD
:
717 /* Compute the relocation code for a fixup of SIZE bytes, using pc
718 relative relocation if PCREL is non-zero. PIC says whether a special
719 pic relocation was requested. */
721 static bfd_reloc_code_real_type get_reloc_code
722 PARAMS ((int, int, enum pic_relocation
));
724 static bfd_reloc_code_real_type
725 get_reloc_code (size
, pcrel
, pic
)
728 enum pic_relocation pic
;
736 return BFD_RELOC_8_GOT_PCREL
;
738 return BFD_RELOC_16_GOT_PCREL
;
740 return BFD_RELOC_32_GOT_PCREL
;
748 return BFD_RELOC_8_GOTOFF
;
750 return BFD_RELOC_16_GOTOFF
;
752 return BFD_RELOC_32_GOTOFF
;
760 return BFD_RELOC_8_PLT_PCREL
;
762 return BFD_RELOC_16_PLT_PCREL
;
764 return BFD_RELOC_32_PLT_PCREL
;
772 return BFD_RELOC_8_PLTOFF
;
774 return BFD_RELOC_16_PLTOFF
;
776 return BFD_RELOC_32_PLTOFF
;
786 return BFD_RELOC_8_PCREL
;
788 return BFD_RELOC_16_PCREL
;
790 return BFD_RELOC_32_PCREL
;
810 as_bad (_("Can not do %d byte pc-relative relocation"), size
);
812 as_bad (_("Can not do %d byte pc-relative pic relocation"), size
);
817 as_bad (_("Can not do %d byte relocation"), size
);
819 as_bad (_("Can not do %d byte pic relocation"), size
);
822 return BFD_RELOC_NONE
;
825 /* Here we decide which fixups can be adjusted to make them relative
826 to the beginning of the section instead of the symbol. Basically
827 we need to make sure that the dynamic relocations are done
828 correctly, so in some cases we force the original symbol to be
831 tc_m68k_fix_adjustable (fixP
)
834 /* Prevent all adjustments to global symbols. */
835 if (S_IS_EXTERNAL (fixP
->fx_addsy
)
836 || S_IS_WEAK (fixP
->fx_addsy
))
839 /* adjust_reloc_syms doesn't know about the GOT */
840 switch (fixP
->fx_r_type
)
842 case BFD_RELOC_8_GOT_PCREL
:
843 case BFD_RELOC_16_GOT_PCREL
:
844 case BFD_RELOC_32_GOT_PCREL
:
845 case BFD_RELOC_8_GOTOFF
:
846 case BFD_RELOC_16_GOTOFF
:
847 case BFD_RELOC_32_GOTOFF
:
848 case BFD_RELOC_8_PLT_PCREL
:
849 case BFD_RELOC_16_PLT_PCREL
:
850 case BFD_RELOC_32_PLT_PCREL
:
851 case BFD_RELOC_8_PLTOFF
:
852 case BFD_RELOC_16_PLTOFF
:
853 case BFD_RELOC_32_PLTOFF
:
856 case BFD_RELOC_VTABLE_INHERIT
:
857 case BFD_RELOC_VTABLE_ENTRY
:
867 #define get_reloc_code(SIZE,PCREL,OTHER) NO_RELOC
874 tc_gen_reloc (section
, fixp
)
879 bfd_reloc_code_real_type code
;
881 /* If the tcbit is set, then this was a fixup of a negative value
882 that was never resolved. We do not have a reloc to handle this,
883 so just return. We assume that other code will have detected this
884 situation and produced a helpful error message, so we just tell the
885 user that the reloc cannot be produced. */
889 as_bad (_("Unable to produce reloc against symbol '%s'"),
890 S_GET_NAME (fixp
->fx_addsy
));
894 if (fixp
->fx_r_type
!= BFD_RELOC_NONE
)
896 code
= fixp
->fx_r_type
;
898 /* Since DIFF_EXPR_OK is defined in tc-m68k.h, it is possible
899 that fixup_segment converted a non-PC relative reloc into a
900 PC relative reloc. In such a case, we need to convert the
907 code
= BFD_RELOC_8_PCREL
;
910 code
= BFD_RELOC_16_PCREL
;
913 code
= BFD_RELOC_32_PCREL
;
915 case BFD_RELOC_8_PCREL
:
916 case BFD_RELOC_16_PCREL
:
917 case BFD_RELOC_32_PCREL
:
918 case BFD_RELOC_8_GOT_PCREL
:
919 case BFD_RELOC_16_GOT_PCREL
:
920 case BFD_RELOC_32_GOT_PCREL
:
921 case BFD_RELOC_8_GOTOFF
:
922 case BFD_RELOC_16_GOTOFF
:
923 case BFD_RELOC_32_GOTOFF
:
924 case BFD_RELOC_8_PLT_PCREL
:
925 case BFD_RELOC_16_PLT_PCREL
:
926 case BFD_RELOC_32_PLT_PCREL
:
927 case BFD_RELOC_8_PLTOFF
:
928 case BFD_RELOC_16_PLTOFF
:
929 case BFD_RELOC_32_PLTOFF
:
932 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
933 _("Cannot make %s relocation PC relative"),
934 bfd_get_reloc_code_name (code
));
940 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
941 switch (F (fixp
->fx_size
, fixp
->fx_pcrel
))
943 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
944 MAP (1, 0, BFD_RELOC_8
);
945 MAP (2, 0, BFD_RELOC_16
);
946 MAP (4, 0, BFD_RELOC_32
);
947 MAP (1, 1, BFD_RELOC_8_PCREL
);
948 MAP (2, 1, BFD_RELOC_16_PCREL
);
949 MAP (4, 1, BFD_RELOC_32_PCREL
);
957 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
958 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
959 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
960 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
963 reloc
->addend
= fixp
->fx_addnumber
;
968 reloc
->addend
= fixp
->fx_addnumber
;
970 reloc
->addend
= (section
->vma
971 + (fixp
->fx_pcrel_adjust
== 64
972 ? -1 : fixp
->fx_pcrel_adjust
)
974 + md_pcrel_from (fixp
));
977 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
978 assert (reloc
->howto
!= 0);
983 #endif /* BFD_ASSEMBLER */
985 /* Return zero if the reference to SYMBOL from within the same segment may
989 /* On an ELF system, we can't relax an externally visible symbol,
990 because it may be overridden by a shared library. However, if
991 TARGET_OS is "elf", then we presume that we are assembling for an
992 embedded system, in which case we don't have to worry about shared
993 libraries, and we can relax anything. */
995 #define relaxable_symbol(symbol) \
996 (strcmp (TARGET_OS, "elf") == 0 \
997 || (! S_IS_EXTERNAL (symbol) \
998 && ! S_IS_WEAK (symbol)))
1002 #define relaxable_symbol(symbol) 1
1006 /* Handle of the OPCODE hash table. NULL means any use before
1007 m68k_ip_begin() will crash. */
1008 static struct hash_control
*op_hash
;
1010 /* Assemble an m68k instruction. */
1017 register struct m68k_op
*opP
;
1018 register const struct m68k_incant
*opcode
;
1019 register const char *s
;
1020 register int tmpreg
= 0, baseo
= 0, outro
= 0, nextword
;
1021 char *pdot
, *pdotmove
;
1022 enum m68k_size siz1
, siz2
;
1026 LITTLENUM_TYPE words
[6];
1027 LITTLENUM_TYPE
*wordp
;
1028 unsigned long ok_arch
= 0;
1030 if (*instring
== ' ')
1031 instring
++; /* skip leading whitespace */
1033 /* Scan up to end of operation-code, which MUST end in end-of-string
1034 or exactly 1 space. */
1036 for (p
= instring
; *p
!= '\0'; p
++)
1046 the_ins
.error
= _("No operator");
1050 /* p now points to the end of the opcode name, probably whitespace.
1051 Make sure the name is null terminated by clobbering the
1052 whitespace, look it up in the hash table, then fix it back.
1053 Remove a dot, first, since the opcode tables have none. */
1056 for (pdotmove
= pdot
; pdotmove
< p
; pdotmove
++)
1057 *pdotmove
= pdotmove
[1];
1063 opcode
= (const struct m68k_incant
*) hash_find (op_hash
, instring
);
1068 for (pdotmove
= p
; pdotmove
> pdot
; pdotmove
--)
1069 *pdotmove
= pdotmove
[-1];
1076 the_ins
.error
= _("Unknown operator");
1080 /* found a legitimate opcode, start matching operands */
1084 if (opcode
->m_operands
== 0)
1086 char *old
= input_line_pointer
;
1088 input_line_pointer
= p
;
1089 /* Ahh - it's a motorola style psuedo op */
1090 mote_pseudo_table
[opcode
->m_opnum
].poc_handler
1091 (mote_pseudo_table
[opcode
->m_opnum
].poc_val
);
1092 input_line_pointer
= old
;
1098 if (flag_mri
&& opcode
->m_opnum
== 0)
1100 /* In MRI mode, random garbage is allowed after an instruction
1101 which accepts no operands. */
1102 the_ins
.args
= opcode
->m_operands
;
1103 the_ins
.numargs
= opcode
->m_opnum
;
1104 the_ins
.numo
= opcode
->m_codenum
;
1105 the_ins
.opcode
[0] = getone (opcode
);
1106 the_ins
.opcode
[1] = gettwo (opcode
);
1110 for (opP
= &the_ins
.operands
[0]; *p
; opP
++)
1112 p
= crack_operand (p
, opP
);
1116 the_ins
.error
= opP
->error
;
1121 opsfound
= opP
- &the_ins
.operands
[0];
1123 /* This ugly hack is to support the floating pt opcodes in their
1124 standard form. Essentially, we fake a first enty of type COP#1 */
1125 if (opcode
->m_operands
[0] == 'I')
1129 for (n
= opsfound
; n
> 0; --n
)
1130 the_ins
.operands
[n
] = the_ins
.operands
[n
- 1];
1132 memset ((char *) (&the_ins
.operands
[0]), '\0',
1133 sizeof (the_ins
.operands
[0]));
1134 the_ins
.operands
[0].mode
= CONTROL
;
1135 the_ins
.operands
[0].reg
= m68k_float_copnum
;
1139 /* We've got the operands. Find an opcode that'll accept them */
1142 /* If we didn't get the right number of ops, or we have no
1143 common model with this pattern then reject this pattern. */
1145 ok_arch
|= opcode
->m_arch
;
1146 if (opsfound
!= opcode
->m_opnum
1147 || ((opcode
->m_arch
& current_architecture
) == 0))
1151 for (s
= opcode
->m_operands
, opP
= &the_ins
.operands
[0];
1155 /* Warning: this switch is huge! */
1156 /* I've tried to organize the cases into this order:
1157 non-alpha first, then alpha by letter. Lower-case
1158 goes directly before uppercase counterpart. */
1159 /* Code with multiple case ...: gets sorted by the lowest
1160 case ... it belongs to. I hope this makes sense. */
1266 if (opP
->reg
== PC
|| opP
->reg
== ZPC
)
1283 if (opP
->reg
== PC
|| opP
->reg
== ZPC
)
1302 if (opP
->reg
== PC
|| opP
->reg
== ZPC
)
1312 if (opP
->mode
!= IMMED
)
1314 else if (s
[1] == 'b'
1315 && ! isvar (&opP
->disp
)
1316 && (opP
->disp
.exp
.X_op
!= O_constant
1317 || ! isbyte (opP
->disp
.exp
.X_add_number
)))
1319 else if (s
[1] == 'B'
1320 && ! isvar (&opP
->disp
)
1321 && (opP
->disp
.exp
.X_op
!= O_constant
1322 || ! issbyte (opP
->disp
.exp
.X_add_number
)))
1324 else if (s
[1] == 'w'
1325 && ! isvar (&opP
->disp
)
1326 && (opP
->disp
.exp
.X_op
!= O_constant
1327 || ! isword (opP
->disp
.exp
.X_add_number
)))
1329 else if (s
[1] == 'W'
1330 && ! isvar (&opP
->disp
)
1331 && (opP
->disp
.exp
.X_op
!= O_constant
1332 || ! issword (opP
->disp
.exp
.X_add_number
)))
1338 if (opP
->mode
!= IMMED
)
1343 if (opP
->mode
== AREG
1344 || opP
->mode
== CONTROL
1345 || opP
->mode
== FPREG
1346 || opP
->mode
== IMMED
1347 || opP
->mode
== REGLST
1348 || (opP
->mode
!= ABSL
1350 || opP
->reg
== ZPC
)))
1355 if (opP
->mode
== CONTROL
1356 || opP
->mode
== FPREG
1357 || opP
->mode
== REGLST
1358 || opP
->mode
== IMMED
1359 || (opP
->mode
!= ABSL
1361 || opP
->reg
== ZPC
)))
1389 if (opP
->mode
== CONTROL
1390 || opP
->mode
== FPREG
1391 || opP
->mode
== REGLST
)
1396 if (opP
->mode
!= AINC
)
1401 if (opP
->mode
!= ADEC
)
1451 if (opP
->reg
== PC
|| opP
->reg
== ZPC
)
1472 case '~': /* For now! (JF FOO is this right?) */
1494 if (opP
->mode
!= CONTROL
1495 || (opP
->reg
!= TT0
&& opP
->reg
!= TT1
))
1500 if (opP
->mode
!= AREG
)
1505 if (opP
->mode
!= AINDR
)
1510 if (opP
->mode
!= ABSL
1512 && strncmp (instring
, "jbsr", 4) == 0))
1517 if (opP
->mode
!= CONTROL
|| opP
->reg
!= CCR
)
1522 if (opP
->mode
!= DISP
1524 || opP
->reg
> ADDR7
)
1529 if (opP
->mode
!= DREG
)
1534 if (opP
->reg
!= ACC
)
1539 if (opP
->mode
!= FPREG
)
1544 if (opP
->reg
!= MACSR
)
1549 if (opP
->reg
!= MASK
)
1554 if (opP
->mode
!= CONTROL
1561 if (opP
->mode
!= CONTROL
1563 || opP
->reg
> last_movec_reg
)
1567 const enum m68k_register
*rp
;
1568 for (rp
= control_regs
; *rp
; rp
++)
1569 if (*rp
== opP
->reg
)
1577 if (opP
->mode
!= IMMED
)
1583 if (opP
->mode
== DREG
1584 || opP
->mode
== AREG
1585 || opP
->mode
== FPREG
)
1594 opP
->mask
= 1 << (opP
->reg
- DATA0
);
1597 opP
->mask
= 1 << (opP
->reg
- ADDR0
+ 8);
1600 opP
->mask
= 1 << (opP
->reg
- FP0
+ 16);
1608 else if (opP
->mode
== CONTROL
)
1617 opP
->mask
= 1 << 24;
1620 opP
->mask
= 1 << 25;
1623 opP
->mask
= 1 << 26;
1632 else if (opP
->mode
!= REGLST
)
1634 else if (s
[1] == '8' && (opP
->mask
& 0x0ffffff) != 0)
1636 else if (s
[1] == '3' && (opP
->mask
& 0x7000000) != 0)
1641 if (opP
->mode
!= IMMED
)
1643 else if (opP
->disp
.exp
.X_op
!= O_constant
1644 || ! issbyte (opP
->disp
.exp
.X_add_number
))
1646 else if (! m68k_quick
1647 && instring
[3] != 'q'
1648 && instring
[4] != 'q')
1653 if (opP
->mode
!= DREG
1654 && opP
->mode
!= IMMED
1655 && opP
->mode
!= ABSL
)
1660 if (opP
->mode
!= IMMED
)
1662 else if (opP
->disp
.exp
.X_op
!= O_constant
1663 || opP
->disp
.exp
.X_add_number
< 1
1664 || opP
->disp
.exp
.X_add_number
> 8)
1666 else if (! m68k_quick
1667 && (strncmp (instring
, "add", 3) == 0
1668 || strncmp (instring
, "sub", 3) == 0)
1669 && instring
[3] != 'q')
1674 if (opP
->mode
!= DREG
&& opP
->mode
!= AREG
)
1679 if (opP
->mode
!= AINDR
1680 && (opP
->mode
!= BASE
1682 && opP
->reg
!= ZADDR0
)
1683 || opP
->disp
.exp
.X_op
!= O_absent
1684 || ((opP
->index
.reg
< DATA0
1685 || opP
->index
.reg
> DATA7
)
1686 && (opP
->index
.reg
< ADDR0
1687 || opP
->index
.reg
> ADDR7
))
1688 || opP
->index
.size
!= SIZE_UNSPEC
1689 || opP
->index
.scale
!= 1))
1694 if (opP
->mode
!= CONTROL
1695 || ! (opP
->reg
== FPI
1697 || opP
->reg
== FPC
))
1702 if (opP
->mode
!= CONTROL
|| opP
->reg
!= SR
)
1707 if (opP
->mode
!= IMMED
)
1709 else if (opP
->disp
.exp
.X_op
!= O_constant
1710 || opP
->disp
.exp
.X_add_number
< 0
1711 || opP
->disp
.exp
.X_add_number
> 7)
1716 if (opP
->mode
!= CONTROL
|| opP
->reg
!= USP
)
1720 /* JF these are out of order. We could put them
1721 in order if we were willing to put up with
1722 bunches of #ifdef m68851s in the code.
1724 Don't forget that you need these operands
1725 to use 68030 MMU instructions. */
1727 /* Memory addressing mode used by pflushr */
1729 if (opP
->mode
== CONTROL
1730 || opP
->mode
== FPREG
1731 || opP
->mode
== DREG
1732 || opP
->mode
== AREG
1733 || opP
->mode
== REGLST
)
1735 /* We should accept immediate operands, but they
1736 supposedly have to be quad word, and we don't
1737 handle that. I would like to see what a Motorola
1738 assembler does before doing something here. */
1739 if (opP
->mode
== IMMED
)
1744 if (opP
->mode
!= CONTROL
1745 || (opP
->reg
!= SFC
&& opP
->reg
!= DFC
))
1750 if (opP
->mode
!= CONTROL
|| opP
->reg
!= TC
)
1755 if (opP
->mode
!= CONTROL
|| opP
->reg
!= AC
)
1760 if (opP
->mode
!= CONTROL
1763 && opP
->reg
!= SCC
))
1768 if (opP
->mode
!= CONTROL
1774 if (opP
->mode
!= CONTROL
1777 && opP
->reg
!= CRP
))
1782 if (opP
->mode
!= CONTROL
1783 || (!(opP
->reg
>= BAD
&& opP
->reg
<= BAD
+ 7)
1784 && !(opP
->reg
>= BAC
&& opP
->reg
<= BAC
+ 7)))
1789 if (opP
->mode
!= CONTROL
|| opP
->reg
!= PSR
)
1794 if (opP
->mode
!= CONTROL
|| opP
->reg
!= PCSR
)
1799 if (opP
->mode
!= CONTROL
1806 } /* not a cache specifier. */
1810 if (opP
->mode
!= ABSL
)
1815 if (opP
->reg
< DATA0L
|| opP
->reg
> ADDR7U
)
1817 /* FIXME: kludge instead of fixing parser:
1818 upper/lower registers are *not* CONTROL
1819 registers, but ordinary ones. */
1820 if ((opP
->reg
>= DATA0L
&& opP
->reg
<= DATA7L
)
1821 || (opP
->reg
>= DATA0U
&& opP
->reg
<= DATA7U
))
1829 } /* switch on type of operand */
1833 } /* for each operand */
1834 } /* if immediately wrong */
1841 opcode
= opcode
->m_next
;
1846 && !(ok_arch
& current_architecture
))
1851 _("invalid instruction for this architecture; needs "));
1852 cp
= buf
+ strlen (buf
);
1856 strcpy (cp
, _("fpu (68040, 68060 or 68881/68882)"));
1859 strcpy (cp
, _("mmu (68030 or 68851)"));
1862 strcpy (cp
, _("68020 or higher"));
1865 strcpy (cp
, _("68000 or higher"));
1868 strcpy (cp
, _("68010 or higher"));
1872 int got_one
= 0, idx
;
1874 idx
< (int) (sizeof (archs
) / sizeof (archs
[0]));
1877 if ((archs
[idx
].arch
& ok_arch
)
1878 && ! archs
[idx
].alias
)
1882 strcpy (cp
, " or ");
1886 strcpy (cp
, archs
[idx
].name
);
1892 cp
= xmalloc (strlen (buf
) + 1);
1897 the_ins
.error
= _("operands mismatch");
1899 } /* Fell off the end */
1904 /* now assemble it */
1906 the_ins
.args
= opcode
->m_operands
;
1907 the_ins
.numargs
= opcode
->m_opnum
;
1908 the_ins
.numo
= opcode
->m_codenum
;
1909 the_ins
.opcode
[0] = getone (opcode
);
1910 the_ins
.opcode
[1] = gettwo (opcode
);
1912 for (s
= the_ins
.args
, opP
= &the_ins
.operands
[0]; *s
; s
+= 2, opP
++)
1914 /* This switch is a doozy.
1915 Watch the first step; its a big one! */
1943 tmpreg
= 0x3c; /* 7.4 */
1944 if (strchr ("bwl", s
[1]))
1945 nextword
= get_num (&opP
->disp
, 80);
1947 nextword
= get_num (&opP
->disp
, 0);
1948 if (isvar (&opP
->disp
))
1949 add_fix (s
[1], &opP
->disp
, 0, 0);
1953 if (!isbyte (nextword
))
1954 opP
->error
= _("operand out of range");
1959 if (!isword (nextword
))
1960 opP
->error
= _("operand out of range");
1965 if (!issword (nextword
))
1966 opP
->error
= _("operand out of range");
1971 addword (nextword
>> 16);
1998 /* We gotta put out some float */
1999 if (op (&opP
->disp
) != O_big
)
2004 /* Can other cases happen here? */
2005 if (op (&opP
->disp
) != O_constant
)
2008 val
= (valueT
) offs (&opP
->disp
);
2012 generic_bignum
[gencnt
] = (LITTLENUM_TYPE
) val
;
2013 val
>>= LITTLENUM_NUMBER_OF_BITS
;
2017 offs (&opP
->disp
) = gencnt
;
2019 if (offs (&opP
->disp
) > 0)
2021 if (offs (&opP
->disp
) > baseo
)
2023 as_warn (_("Bignum too big for %c format; truncated"),
2025 offs (&opP
->disp
) = baseo
;
2027 baseo
-= offs (&opP
->disp
);
2030 for (wordp
= generic_bignum
+ offs (&opP
->disp
) - 1;
2031 offs (&opP
->disp
)--;
2036 gen_to_words (words
, baseo
, (long) outro
);
2037 for (wordp
= words
; baseo
--; wordp
++)
2041 tmpreg
= opP
->reg
- DATA
; /* 0.dreg */
2044 tmpreg
= 0x08 + opP
->reg
- ADDR
; /* 1.areg */
2047 tmpreg
= 0x10 + opP
->reg
- ADDR
; /* 2.areg */
2050 tmpreg
= 0x20 + opP
->reg
- ADDR
; /* 4.areg */
2053 tmpreg
= 0x18 + opP
->reg
- ADDR
; /* 3.areg */
2057 nextword
= get_num (&opP
->disp
, 80);
2060 && ! isvar (&opP
->disp
)
2063 opP
->disp
.exp
.X_op
= O_symbol
;
2064 #ifndef BFD_ASSEMBLER
2065 opP
->disp
.exp
.X_add_symbol
= &abs_symbol
;
2067 opP
->disp
.exp
.X_add_symbol
=
2068 section_symbol (absolute_section
);
2072 /* Force into index mode. Hope this works */
2074 /* We do the first bit for 32-bit displacements, and the
2075 second bit for 16 bit ones. It is possible that we
2076 should make the default be WORD instead of LONG, but
2077 I think that'd break GCC, so we put up with a little
2078 inefficiency for the sake of working output. */
2080 if (!issword (nextword
)
2081 || (isvar (&opP
->disp
)
2082 && ((opP
->disp
.size
== SIZE_UNSPEC
2083 && flag_short_refs
== 0
2084 && cpu_of_arch (current_architecture
) >= m68020
2085 && ! arch_coldfire_p (current_architecture
))
2086 || opP
->disp
.size
== SIZE_LONG
)))
2088 if (cpu_of_arch (current_architecture
) < m68020
2089 || arch_coldfire_p (current_architecture
))
2091 _("displacement too large for this architecture; needs 68020 or higher");
2093 tmpreg
= 0x3B; /* 7.3 */
2095 tmpreg
= 0x30 + opP
->reg
- ADDR
; /* 6.areg */
2096 if (isvar (&opP
->disp
))
2100 if (opP
->disp
.size
== SIZE_LONG
2102 /* If the displacement needs pic
2103 relocation it cannot be relaxed. */
2104 || opP
->disp
.pic_reloc
!= pic_none
2109 add_fix ('l', &opP
->disp
, 1, 2);
2113 add_frag (adds (&opP
->disp
),
2115 TAB (PCREL1632
, SZ_UNDEF
));
2122 add_fix ('l', &opP
->disp
, 0, 0);
2127 addword (nextword
>> 16);
2132 tmpreg
= 0x3A; /* 7.2 */
2134 tmpreg
= 0x28 + opP
->reg
- ADDR
; /* 5.areg */
2136 if (isvar (&opP
->disp
))
2140 add_fix ('w', &opP
->disp
, 1, 0);
2143 add_fix ('w', &opP
->disp
, 0, 0);
2153 baseo
= get_num (&opP
->disp
, 80);
2154 if (opP
->mode
== POST
|| opP
->mode
== PRE
)
2155 outro
= get_num (&opP
->odisp
, 80);
2156 /* Figure out the `addressing mode'.
2157 Also turn on the BASE_DISABLE bit, if needed. */
2158 if (opP
->reg
== PC
|| opP
->reg
== ZPC
)
2160 tmpreg
= 0x3b; /* 7.3 */
2161 if (opP
->reg
== ZPC
)
2164 else if (opP
->reg
== 0)
2167 tmpreg
= 0x30; /* 6.garbage */
2169 else if (opP
->reg
>= ZADDR0
&& opP
->reg
<= ZADDR7
)
2172 tmpreg
= 0x30 + opP
->reg
- ZADDR0
;
2175 tmpreg
= 0x30 + opP
->reg
- ADDR
; /* 6.areg */
2177 siz1
= opP
->disp
.size
;
2178 if (opP
->mode
== POST
|| opP
->mode
== PRE
)
2179 siz2
= opP
->odisp
.size
;
2183 /* Index register stuff */
2184 if (opP
->index
.reg
!= 0
2185 && opP
->index
.reg
>= DATA
2186 && opP
->index
.reg
<= ADDR7
)
2188 nextword
|= (opP
->index
.reg
- DATA
) << 12;
2190 if (opP
->index
.size
== SIZE_LONG
2191 || (opP
->index
.size
== SIZE_UNSPEC
2192 && m68k_index_width_default
== SIZE_LONG
))
2195 if ((opP
->index
.scale
!= 1
2196 && cpu_of_arch (current_architecture
) < m68020
)
2197 || (opP
->index
.scale
== 8
2198 && arch_coldfire_p (current_architecture
)))
2201 _("scale factor invalid on this architecture; needs cpu32 or 68020 or higher");
2204 if (arch_coldfire_p (current_architecture
)
2205 && opP
->index
.size
== SIZE_WORD
)
2206 opP
->error
= _("invalid index size for coldfire");
2208 switch (opP
->index
.scale
)
2225 GET US OUT OF HERE! */
2227 /* Must be INDEX, with an index register. Address
2228 register cannot be ZERO-PC, and either :b was
2229 forced, or we know it will fit. For a 68000 or
2230 68010, force this mode anyways, because the
2231 larger modes aren't supported. */
2232 if (opP
->mode
== BASE
2233 && ((opP
->reg
>= ADDR0
2234 && opP
->reg
<= ADDR7
)
2237 if (siz1
== SIZE_BYTE
2238 || cpu_of_arch (current_architecture
) < m68020
2239 || arch_coldfire_p (current_architecture
)
2240 || (siz1
== SIZE_UNSPEC
2241 && ! isvar (&opP
->disp
)
2242 && issbyte (baseo
)))
2244 nextword
+= baseo
& 0xff;
2246 if (isvar (&opP
->disp
))
2248 /* Do a byte relocation. If it doesn't
2249 fit (possible on m68000) let the
2250 fixup processing complain later. */
2252 add_fix ('B', &opP
->disp
, 1, 1);
2254 add_fix ('B', &opP
->disp
, 0, 0);
2256 else if (siz1
!= SIZE_BYTE
)
2258 if (siz1
!= SIZE_UNSPEC
)
2259 as_warn (_("Forcing byte displacement"));
2260 if (! issbyte (baseo
))
2261 opP
->error
= _("byte displacement out of range");
2266 else if (siz1
== SIZE_UNSPEC
2268 && isvar (&opP
->disp
)
2269 && subs (&opP
->disp
) == NULL
2271 /* If the displacement needs pic
2272 relocation it cannot be relaxed. */
2273 && opP
->disp
.pic_reloc
== pic_none
2277 /* The code in md_convert_frag_1 needs to be
2278 able to adjust nextword. Call frag_grow
2279 to ensure that we have enough space in
2280 the frag obstack to make all the bytes
2283 nextword
+= baseo
& 0xff;
2285 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2286 TAB (PCINDEX
, SZ_UNDEF
));
2294 nextword
|= 0x40; /* No index reg */
2295 if (opP
->index
.reg
>= ZDATA0
2296 && opP
->index
.reg
<= ZDATA7
)
2297 nextword
|= (opP
->index
.reg
- ZDATA0
) << 12;
2298 else if (opP
->index
.reg
>= ZADDR0
2299 || opP
->index
.reg
<= ZADDR7
)
2300 nextword
|= (opP
->index
.reg
- ZADDR0
+ 8) << 12;
2303 /* It isn't simple. */
2305 if (cpu_of_arch (current_architecture
) < m68020
2306 || arch_coldfire_p (current_architecture
))
2308 _("invalid operand mode for this architecture; needs 68020 or higher");
2311 /* If the guy specified a width, we assume that it is
2312 wide enough. Maybe it isn't. If so, we lose. */
2316 if (isvar (&opP
->disp
)
2318 : ! issword (baseo
))
2323 else if (! isvar (&opP
->disp
) && baseo
== 0)
2332 as_warn (_(":b not permitted; defaulting to :w"));
2342 /* Figure out innner displacement stuff */
2343 if (opP
->mode
== POST
|| opP
->mode
== PRE
)
2345 if (cpu_of_arch (current_architecture
) & cpu32
)
2346 opP
->error
= _("invalid operand mode for this architecture; needs 68020 or higher");
2350 if (isvar (&opP
->odisp
)
2352 : ! issword (outro
))
2357 else if (! isvar (&opP
->odisp
) && outro
== 0)
2366 as_warn (_(":b not permitted; defaulting to :w"));
2375 if (opP
->mode
== POST
2376 && (nextword
& 0x40) == 0)
2381 if (siz1
!= SIZE_UNSPEC
&& isvar (&opP
->disp
))
2383 if (opP
->reg
== PC
|| opP
->reg
== ZPC
)
2384 add_fix (siz1
== SIZE_LONG
? 'l' : 'w', &opP
->disp
, 1, 2);
2386 add_fix (siz1
== SIZE_LONG
? 'l' : 'w', &opP
->disp
, 0, 0);
2388 if (siz1
== SIZE_LONG
)
2389 addword (baseo
>> 16);
2390 if (siz1
!= SIZE_UNSPEC
)
2393 if (siz2
!= SIZE_UNSPEC
&& isvar (&opP
->odisp
))
2394 add_fix (siz2
== SIZE_LONG
? 'l' : 'w', &opP
->odisp
, 0, 0);
2395 if (siz2
== SIZE_LONG
)
2396 addword (outro
>> 16);
2397 if (siz2
!= SIZE_UNSPEC
)
2403 nextword
= get_num (&opP
->disp
, 80);
2404 switch (opP
->disp
.size
)
2409 if (!isvar (&opP
->disp
) && issword (offs (&opP
->disp
)))
2411 tmpreg
= 0x38; /* 7.0 */
2415 if (isvar (&opP
->disp
)
2416 && !subs (&opP
->disp
)
2417 && adds (&opP
->disp
)
2419 /* If the displacement needs pic relocation it
2420 cannot be relaxed. */
2421 && opP
->disp
.pic_reloc
== pic_none
2424 && !strchr ("~%&$?", s
[0]))
2426 tmpreg
= 0x3A; /* 7.2 */
2427 add_frag (adds (&opP
->disp
),
2429 TAB (ABSTOPCREL
, SZ_UNDEF
));
2432 /* Fall through into long */
2434 if (isvar (&opP
->disp
))
2435 add_fix ('l', &opP
->disp
, 0, 0);
2437 tmpreg
= 0x39;/* 7.1 mode */
2438 addword (nextword
>> 16);
2443 as_bad (_("unsupported byte value; use a different suffix"));
2445 case SIZE_WORD
: /* Word */
2446 if (isvar (&opP
->disp
))
2447 add_fix ('w', &opP
->disp
, 0, 0);
2449 tmpreg
= 0x38;/* 7.0 mode */
2457 as_bad (_("unknown/incorrect operand"));
2460 install_gen_operand (s
[1], tmpreg
);
2466 { /* JF: I hate floating point! */
2481 tmpreg
= get_num (&opP
->disp
, tmpreg
);
2482 if (isvar (&opP
->disp
))
2483 add_fix (s
[1], &opP
->disp
, 0, 0);
2486 case 'b': /* Danger: These do no check for
2487 certain types of overflow.
2489 if (!isbyte (tmpreg
))
2490 opP
->error
= _("out of range");
2491 insop (tmpreg
, opcode
);
2492 if (isvar (&opP
->disp
))
2493 the_ins
.reloc
[the_ins
.nrel
- 1].n
=
2494 (opcode
->m_codenum
) * 2 + 1;
2497 if (!issbyte (tmpreg
))
2498 opP
->error
= _("out of range");
2499 the_ins
.opcode
[the_ins
.numo
- 1] |= tmpreg
& 0xff;
2500 if (isvar (&opP
->disp
))
2501 the_ins
.reloc
[the_ins
.nrel
- 1].n
= opcode
->m_codenum
* 2 - 1;
2504 if (!isword (tmpreg
))
2505 opP
->error
= _("out of range");
2506 insop (tmpreg
, opcode
);
2507 if (isvar (&opP
->disp
))
2508 the_ins
.reloc
[the_ins
.nrel
- 1].n
= (opcode
->m_codenum
) * 2;
2511 if (!issword (tmpreg
))
2512 opP
->error
= _("out of range");
2513 insop (tmpreg
, opcode
);
2514 if (isvar (&opP
->disp
))
2515 the_ins
.reloc
[the_ins
.nrel
- 1].n
= (opcode
->m_codenum
) * 2;
2518 /* Because of the way insop works, we put these two out
2520 insop (tmpreg
, opcode
);
2521 insop (tmpreg
>> 16, opcode
);
2522 if (isvar (&opP
->disp
))
2523 the_ins
.reloc
[the_ins
.nrel
- 1].n
= (opcode
->m_codenum
) * 2;
2530 install_operand (s
[1], tmpreg
);
2541 install_operand (s
[1], opP
->reg
- ADDR
);
2545 tmpreg
= get_num (&opP
->disp
, 80);
2549 /* The pc_fix argument winds up in fx_pcrel_adjust,
2550 which is a char, and may therefore be unsigned. We
2551 want to pass -1, but we pass 64 instead, and convert
2552 back in md_pcrel_from. */
2553 add_fix ('B', &opP
->disp
, 1, 64);
2556 add_fix ('w', &opP
->disp
, 1, 0);
2561 if (! HAVE_LONG_BRANCH (current_architecture
))
2562 as_warn (_("Can't use long branches on 68000/68010/5200"));
2563 the_ins
.opcode
[0] |= 0xff;
2564 add_fix ('l', &opP
->disp
, 1, 0);
2569 if (subs (&opP
->disp
)) /* We can't relax it */
2573 /* If the displacement needs pic relocation it cannot be
2575 if (opP
->disp
.pic_reloc
!= pic_none
)
2578 /* This could either be a symbol, or an absolute
2579 address. If it's an absolute address, turn it into
2580 an absolute jump right here and keep it out of the
2582 if (adds (&opP
->disp
) == 0)
2584 if (the_ins
.opcode
[0] == 0x6000) /* jbra */
2585 the_ins
.opcode
[0] = 0x4EF1;
2586 else if (the_ins
.opcode
[0] == 0x6100) /* jbsr */
2587 the_ins
.opcode
[0] = 0x4EB1;
2590 the_ins
.opcode
[0] ^= 0x0100;
2591 the_ins
.opcode
[0] |= 0x0006;
2594 add_fix ('l', &opP
->disp
, 0, 0);
2600 /* Now we know it's going into the relaxer. Now figure
2601 out which mode. We try in this order of preference:
2602 long branch, absolute jump, byte/word branches only. */
2603 if (HAVE_LONG_BRANCH (current_architecture
))
2604 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2605 TAB (BRANCHBWL
, SZ_UNDEF
));
2606 else if (! flag_keep_pcrel
)
2608 if ((the_ins
.opcode
[0] == 0x6000)
2609 || (the_ins
.opcode
[0] == 0x6100))
2610 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2611 TAB (BRABSJUNC
, SZ_UNDEF
));
2613 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2614 TAB (BRABSJCOND
, SZ_UNDEF
));
2617 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2618 TAB (BRANCHBW
, SZ_UNDEF
));
2621 if (isvar (&opP
->disp
))
2623 /* Check for DBcc instructions. We can relax them,
2624 but only if we have long branches and/or absolute
2626 if (((the_ins
.opcode
[0] & 0xf0f8) == 0x50c8)
2627 && (HAVE_LONG_BRANCH (current_architecture
)
2628 || (! flag_keep_pcrel
)))
2630 if (HAVE_LONG_BRANCH (current_architecture
))
2631 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2632 TAB (DBCCLBR
, SZ_UNDEF
));
2634 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2635 TAB (DBCCABSJ
, SZ_UNDEF
));
2638 add_fix ('w', &opP
->disp
, 1, 0);
2642 case 'C': /* Fixed size LONG coproc branches */
2643 add_fix ('l', &opP
->disp
, 1, 0);
2647 case 'c': /* Var size Coprocesssor branches */
2648 if (subs (&opP
->disp
) || (adds (&opP
->disp
) == 0))
2650 the_ins
.opcode
[the_ins
.numo
- 1] |= 0x40;
2651 add_fix ('l', &opP
->disp
, 1, 0);
2656 add_frag (adds (&opP
->disp
), offs (&opP
->disp
),
2657 TAB (FBRANCH
, SZ_UNDEF
));
2664 case 'C': /* Ignore it */
2667 case 'd': /* JF this is a kludge */
2668 install_operand ('s', opP
->reg
- ADDR
);
2669 tmpreg
= get_num (&opP
->disp
, 80);
2670 if (!issword (tmpreg
))
2672 as_warn (_("Expression out of range, using 0"));
2679 install_operand (s
[1], opP
->reg
- DATA
);
2682 case 'E': /* Ignore it */
2686 install_operand (s
[1], opP
->reg
- FP0
);
2689 case 'G': /* Ignore it */
2694 tmpreg
= opP
->reg
- COP0
;
2695 install_operand (s
[1], tmpreg
);
2698 case 'J': /* JF foo */
2771 install_operand (s
[1], tmpreg
);
2775 tmpreg
= get_num (&opP
->disp
, 55);
2776 install_operand (s
[1], tmpreg
& 0x7f);
2783 if (tmpreg
& 0x7FF0000)
2784 as_bad (_("Floating point register in register list"));
2785 insop (reverse_16_bits (tmpreg
), opcode
);
2789 if (tmpreg
& 0x700FFFF)
2790 as_bad (_("Wrong register in floating-point reglist"));
2791 install_operand (s
[1], reverse_8_bits (tmpreg
>> 16));
2799 if (tmpreg
& 0x7FF0000)
2800 as_bad (_("Floating point register in register list"));
2801 insop (tmpreg
, opcode
);
2803 else if (s
[1] == '8')
2805 if (tmpreg
& 0x0FFFFFF)
2806 as_bad (_("incorrect register in reglist"));
2807 install_operand (s
[1], tmpreg
>> 24);
2811 if (tmpreg
& 0x700FFFF)
2812 as_bad (_("wrong register in floating-point reglist"));
2814 install_operand (s
[1], tmpreg
>> 16);
2819 install_operand (s
[1], get_num (&opP
->disp
, 60));
2823 tmpreg
= ((opP
->mode
== DREG
)
2824 ? 0x20 + (int) (opP
->reg
- DATA
)
2825 : (get_num (&opP
->disp
, 40) & 0x1F));
2826 install_operand (s
[1], tmpreg
);
2830 tmpreg
= get_num (&opP
->disp
, 10);
2833 install_operand (s
[1], tmpreg
);
2837 /* This depends on the fact that ADDR registers are eight
2838 more than their corresponding DATA regs, so the result
2839 will have the ADDR_REG bit set */
2840 install_operand (s
[1], opP
->reg
- DATA
);
2844 if (opP
->mode
== AINDR
)
2845 install_operand (s
[1], opP
->reg
- DATA
);
2847 install_operand (s
[1], opP
->index
.reg
- DATA
);
2851 if (opP
->reg
== FPI
)
2853 else if (opP
->reg
== FPS
)
2855 else if (opP
->reg
== FPC
)
2859 install_operand (s
[1], tmpreg
);
2862 case 'S': /* Ignore it */
2866 install_operand (s
[1], get_num (&opP
->disp
, 30));
2869 case 'U': /* Ignore it */
2888 as_fatal (_("failed sanity check"));
2889 } /* switch on cache token */
2890 install_operand (s
[1], tmpreg
);
2893 /* JF: These are out of order, I fear. */
2906 install_operand (s
[1], tmpreg
);
2932 install_operand (s
[1], tmpreg
);
2936 if (opP
->reg
== VAL
)
2955 install_operand (s
[1], tmpreg
);
2969 tmpreg
= (4 << 10) | ((opP
->reg
- BAD
) << 2);
2980 tmpreg
= (5 << 10) | ((opP
->reg
- BAC
) << 2);
2986 install_operand (s
[1], tmpreg
);
2989 know (opP
->reg
== PSR
);
2992 know (opP
->reg
== PCSR
);
3007 install_operand (s
[1], tmpreg
);
3010 tmpreg
= get_num (&opP
->disp
, 20);
3011 install_operand (s
[1], tmpreg
);
3013 case '_': /* used only for move16 absolute 32-bit address */
3014 if (isvar (&opP
->disp
))
3015 add_fix ('l', &opP
->disp
, 0, 0);
3016 tmpreg
= get_num (&opP
->disp
, 80);
3017 addword (tmpreg
>> 16);
3018 addword (tmpreg
& 0xFFFF);
3021 install_operand (s
[1], opP
->reg
- DATA0L
);
3022 opP
->reg
-= (DATA0L
);
3023 opP
->reg
&= 0x0F; /* remove upper/lower bit */
3030 /* By the time whe get here (FINALLY) the_ins contains the complete
3031 instruction, ready to be emitted. . . */
3035 reverse_16_bits (in
)
3041 static int mask
[16] =
3043 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
3044 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000
3046 for (n
= 0; n
< 16; n
++)
3049 out
|= mask
[15 - n
];
3052 } /* reverse_16_bits() */
3061 static int mask
[8] =
3063 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
3066 for (n
= 0; n
< 8; n
++)
3072 } /* reverse_8_bits() */
3074 /* Cause an extra frag to be generated here, inserting up to 10 bytes
3075 (that value is chosen in the frag_var call in md_assemble). TYPE
3076 is the subtype of the frag to be generated; its primary type is
3077 rs_machine_dependent.
3079 The TYPE parameter is also used by md_convert_frag_1 and
3080 md_estimate_size_before_relax. The appropriate type of fixup will
3081 be emitted by md_convert_frag_1.
3083 ADD becomes the FR_SYMBOL field of the frag, and OFF the FR_OFFSET. */
3085 install_operand (mode
, val
)
3092 the_ins
.opcode
[0] |= val
& 0xFF; /* JF FF is for M kludge */
3095 the_ins
.opcode
[0] |= val
<< 9;
3098 the_ins
.opcode
[1] |= val
<< 12;
3101 the_ins
.opcode
[1] |= val
<< 6;
3104 the_ins
.opcode
[1] |= val
;
3107 the_ins
.opcode
[2] |= val
<< 12;
3110 the_ins
.opcode
[2] |= val
<< 6;
3113 /* DANGER! This is a hack to force cas2l and cas2w cmds to be
3114 three words long! */
3116 the_ins
.opcode
[2] |= val
;
3119 the_ins
.opcode
[1] |= val
<< 7;
3122 the_ins
.opcode
[1] |= val
<< 10;
3126 the_ins
.opcode
[1] |= val
<< 5;
3131 the_ins
.opcode
[1] |= (val
<< 10) | (val
<< 7);
3134 the_ins
.opcode
[1] |= (val
<< 12) | val
;
3137 the_ins
.opcode
[0] |= val
= 0xff;
3140 the_ins
.opcode
[0] |= val
<< 9;
3143 the_ins
.opcode
[1] |= val
;
3146 the_ins
.opcode
[1] |= val
;
3147 the_ins
.numo
++; /* What a hack */
3150 the_ins
.opcode
[1] |= val
<< 4;
3158 the_ins
.opcode
[0] |= (val
<< 6);
3161 the_ins
.opcode
[1] = (val
>> 16);
3162 the_ins
.opcode
[2] = val
& 0xffff;
3165 the_ins
.opcode
[0] |= ((val
& 0x8) << (6 - 3));
3166 the_ins
.opcode
[0] |= ((val
& 0x7) << 9);
3167 the_ins
.opcode
[1] |= ((val
& 0x10) << (7 - 4));
3170 the_ins
.opcode
[0] |= ((val
& 0x8) << (6 - 3));
3171 the_ins
.opcode
[0] |= ((val
& 0x7) << 9);
3174 the_ins
.opcode
[1] |= val
<< 12;
3175 the_ins
.opcode
[1] |= ((val
& 0x10) << (7 - 4));
3178 the_ins
.opcode
[0] |= (val
& 0xF);
3179 the_ins
.opcode
[1] |= ((val
& 0x10) << (6 - 4));
3182 the_ins
.opcode
[1] |= (val
& 0xF);
3183 the_ins
.opcode
[1] |= ((val
& 0x10) << (6 - 4));
3186 the_ins
.opcode
[1] |= ((val
!= 1) << 10);
3190 as_fatal (_("failed sanity check."));
3192 } /* install_operand() */
3195 install_gen_operand (mode
, val
)
3202 the_ins
.opcode
[0] |= val
;
3205 /* This is a kludge!!! */
3206 the_ins
.opcode
[0] |= (val
& 0x07) << 9 | (val
& 0x38) << 3;
3215 the_ins
.opcode
[0] |= val
;
3217 /* more stuff goes here */
3219 as_fatal (_("failed sanity check."));
3221 } /* install_gen_operand() */
3224 * verify that we have some number of paren pairs, do m68k_ip_op(), and
3225 * then deal with the bitfield hack.
3229 crack_operand (str
, opP
)
3231 register struct m68k_op
*opP
;
3233 register int parens
;
3235 register char *beg_str
;
3243 for (parens
= 0; *str
&& (parens
> 0 || inquote
|| notend (str
)); str
++)
3249 else if (*str
== ')')
3253 opP
->error
= _("Extra )");
3259 if (flag_mri
&& *str
== '\'')
3260 inquote
= ! inquote
;
3262 if (!*str
&& parens
)
3264 opP
->error
= _("Missing )");
3269 if (m68k_ip_op (beg_str
, opP
) != 0)
3276 c
= *++str
; /* JF bitfield hack */
3281 as_bad (_("Missing operand"));
3284 /* Detect MRI REG symbols and convert them to REGLSTs. */
3285 if (opP
->mode
== CONTROL
&& (int)opP
->reg
< 0)
3288 opP
->mask
= ~(int)opP
->reg
;
3295 /* This is the guts of the machine-dependent assembler. STR points to a
3296 machine dependent instruction. This function is supposed to emit
3297 the frags/bytes it assembles to.
3301 insert_reg (regname
, regnum
)
3302 const char *regname
;
3308 #ifdef REGISTER_PREFIX
3309 if (!flag_reg_prefix_optional
)
3311 buf
[0] = REGISTER_PREFIX
;
3312 strcpy (buf
+ 1, regname
);
3317 symbol_table_insert (symbol_new (regname
, reg_section
, regnum
,
3318 &zero_address_frag
));
3320 for (i
= 0; regname
[i
]; i
++)
3321 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
3324 symbol_table_insert (symbol_new (buf
, reg_section
, regnum
,
3325 &zero_address_frag
));
3334 static const struct init_entry init_table
[] =
3393 /* control registers */
3394 { "sfc", SFC
}, /* Source Function Code */
3396 { "dfc", DFC
}, /* Destination Function Code */
3398 { "cacr", CACR
}, /* Cache Control Register */
3399 { "caar", CAAR
}, /* Cache Address Register */
3401 { "usp", USP
}, /* User Stack Pointer */
3402 { "vbr", VBR
}, /* Vector Base Register */
3403 { "msp", MSP
}, /* Master Stack Pointer */
3404 { "isp", ISP
}, /* Interrupt Stack Pointer */
3406 { "itt0", ITT0
}, /* Instruction Transparent Translation Reg 0 */
3407 { "itt1", ITT1
}, /* Instruction Transparent Translation Reg 1 */
3408 { "dtt0", DTT0
}, /* Data Transparent Translation Register 0 */
3409 { "dtt1", DTT1
}, /* Data Transparent Translation Register 1 */
3411 /* 68ec040 versions of same */
3412 { "iacr0", ITT0
}, /* Instruction Access Control Register 0 */
3413 { "iacr1", ITT1
}, /* Instruction Access Control Register 0 */
3414 { "dacr0", DTT0
}, /* Data Access Control Register 0 */
3415 { "dacr1", DTT1
}, /* Data Access Control Register 0 */
3417 /* mcf5200 versions of same. The ColdFire programmer's reference
3418 manual indicated that the order is 2,3,0,1, but Ken Rose
3419 <rose@netcom.com> says that 0,1,2,3 is the correct order. */
3420 { "acr0", ITT0
}, /* Access Control Unit 0 */
3421 { "acr1", ITT1
}, /* Access Control Unit 1 */
3422 { "acr2", DTT0
}, /* Access Control Unit 2 */
3423 { "acr3", DTT1
}, /* Access Control Unit 3 */
3425 { "tc", TC
}, /* MMU Translation Control Register */
3428 { "mmusr", MMUSR
}, /* MMU Status Register */
3429 { "srp", SRP
}, /* User Root Pointer */
3430 { "urp", URP
}, /* Supervisor Root Pointer */
3435 { "rombar", ROMBAR
}, /* ROM Base Address Register */
3436 { "rambar0", RAMBAR0
}, /* ROM Base Address Register */
3437 { "rambar1", RAMBAR1
}, /* ROM Base Address Register */
3438 { "mbar", MBAR
}, /* Module Base Address Register */
3439 /* end of control registers */
3473 /* 68ec030 versions of same */
3476 /* 68ec030 access control unit, identical to 030 MMU status reg */
3479 /* Suppressed data and address registers. */
3497 /* Upper and lower data and address registers, used by macw and msacw. */
3541 for (i
= 0; init_table
[i
].name
; i
++)
3542 insert_reg (init_table
[i
].name
, init_table
[i
].number
);
3545 static int no_68851
, no_68881
;
3548 /* a.out machine type. Default to 68020. */
3549 int m68k_aout_machtype
= 2;
3561 int shorts_this_frag
;
3564 /* In MRI mode, the instruction and operands are separated by a
3565 space. Anything following the operands is a comment. The label
3566 has already been removed. */
3574 for (s
= str
; *s
!= '\0'; s
++)
3576 if ((*s
== ' ' || *s
== '\t') && ! inquote
)
3594 inquote
= ! inquote
;
3599 memset ((char *) (&the_ins
), '\0', sizeof (the_ins
));
3604 for (n
= 0; n
< the_ins
.numargs
; n
++)
3605 if (the_ins
.operands
[n
].error
)
3607 er
= the_ins
.operands
[n
].error
;
3613 as_bad (_("%s -- statement `%s' ignored"), er
, str
);
3617 /* If there is a current label, record that it marks an instruction. */
3618 if (current_label
!= NULL
)
3620 current_label
->text
= 1;
3621 current_label
= NULL
;
3624 if (the_ins
.nfrag
== 0)
3626 /* No frag hacking involved; just put it out */
3627 toP
= frag_more (2 * the_ins
.numo
);
3628 fromP
= &the_ins
.opcode
[0];
3629 for (m
= the_ins
.numo
; m
; --m
)
3631 md_number_to_chars (toP
, (long) (*fromP
), 2);
3635 /* put out symbol-dependent info */
3636 for (m
= 0; m
< the_ins
.nrel
; m
++)
3638 switch (the_ins
.reloc
[m
].wid
)
3657 as_fatal (_("Don't know how to figure width of %c in md_assemble()"),
3658 the_ins
.reloc
[m
].wid
);
3661 fixP
= fix_new_exp (frag_now
,
3662 ((toP
- frag_now
->fr_literal
)
3663 - the_ins
.numo
* 2 + the_ins
.reloc
[m
].n
),
3665 &the_ins
.reloc
[m
].exp
,
3666 the_ins
.reloc
[m
].pcrel
,
3667 get_reloc_code (n
, the_ins
.reloc
[m
].pcrel
,
3668 the_ins
.reloc
[m
].pic_reloc
));
3669 fixP
->fx_pcrel_adjust
= the_ins
.reloc
[m
].pcrel_fix
;
3670 if (the_ins
.reloc
[m
].wid
== 'B')
3671 fixP
->fx_signed
= 1;
3676 /* There's some frag hacking */
3677 for (n
= 0, fromP
= &the_ins
.opcode
[0]; n
< the_ins
.nfrag
; n
++)
3682 wid
= 2 * the_ins
.fragb
[n
].fragoff
;
3684 wid
= 2 * (the_ins
.numo
- the_ins
.fragb
[n
- 1].fragoff
);
3685 toP
= frag_more (wid
);
3687 shorts_this_frag
= 0;
3688 for (m
= wid
/ 2; m
; --m
)
3690 md_number_to_chars (toP
, (long) (*fromP
), 2);
3695 for (m
= 0; m
< the_ins
.nrel
; m
++)
3697 if ((the_ins
.reloc
[m
].n
) >= 2 * shorts_this_frag
)
3699 the_ins
.reloc
[m
].n
-= 2 * shorts_this_frag
;
3702 wid
= the_ins
.reloc
[m
].wid
;
3705 the_ins
.reloc
[m
].wid
= 0;
3706 wid
= (wid
== 'b') ? 1 : (wid
== 'w') ? 2 : (wid
== 'l') ? 4 : 4000;
3708 fixP
= fix_new_exp (frag_now
,
3709 ((toP
- frag_now
->fr_literal
)
3710 - the_ins
.numo
* 2 + the_ins
.reloc
[m
].n
),
3712 &the_ins
.reloc
[m
].exp
,
3713 the_ins
.reloc
[m
].pcrel
,
3714 get_reloc_code (wid
, the_ins
.reloc
[m
].pcrel
,
3715 the_ins
.reloc
[m
].pic_reloc
));
3716 fixP
->fx_pcrel_adjust
= the_ins
.reloc
[m
].pcrel_fix
;
3718 (void) frag_var (rs_machine_dependent
, 10, 0,
3719 (relax_substateT
) (the_ins
.fragb
[n
].fragty
),
3720 the_ins
.fragb
[n
].fadd
, the_ins
.fragb
[n
].foff
, to_beg_P
);
3722 n
= (the_ins
.numo
- the_ins
.fragb
[n
- 1].fragoff
);
3723 shorts_this_frag
= 0;
3726 toP
= frag_more (n
* sizeof (short));
3729 md_number_to_chars (toP
, (long) (*fromP
), 2);
3735 for (m
= 0; m
< the_ins
.nrel
; m
++)
3739 wid
= the_ins
.reloc
[m
].wid
;
3742 the_ins
.reloc
[m
].wid
= 0;
3743 wid
= (wid
== 'b') ? 1 : (wid
== 'w') ? 2 : (wid
== 'l') ? 4 : 4000;
3745 fixP
= fix_new_exp (frag_now
,
3746 ((the_ins
.reloc
[m
].n
+ toP
- frag_now
->fr_literal
)
3747 - shorts_this_frag
* 2),
3749 &the_ins
.reloc
[m
].exp
,
3750 the_ins
.reloc
[m
].pcrel
,
3751 get_reloc_code (wid
, the_ins
.reloc
[m
].pcrel
,
3752 the_ins
.reloc
[m
].pic_reloc
));
3753 fixP
->fx_pcrel_adjust
= the_ins
.reloc
[m
].pcrel_fix
;
3761 * md_begin -- set up hash tables with 68000 instructions.
3762 * similar to what the vax assembler does. ---phr
3764 /* RMS claims the thing to do is take the m68k-opcode.h table, and make
3765 a copy of it at runtime, adding in the information we want but isn't
3766 there. I think it'd be better to have an awk script hack the table
3767 at compile time. Or even just xstr the table and use it as-is. But
3768 my lord ghod hath spoken, so we do it this way. Excuse the ugly var
3771 register const struct m68k_opcode
*ins
;
3772 register struct m68k_incant
*hack
, *slak
;
3773 register const char *retval
= 0; /* empty string, or error msg text */
3779 flag_reg_prefix_optional
= 1;
3781 if (! m68k_rel32_from_cmdline
)
3785 op_hash
= hash_new ();
3787 obstack_begin (&robyn
, 4000);
3788 for (i
= 0; i
< m68k_numopcodes
; i
++)
3790 hack
= slak
= (struct m68k_incant
*) obstack_alloc (&robyn
, sizeof (struct m68k_incant
));
3793 ins
= &m68k_opcodes
[i
];
3794 /* We *could* ignore insns that don't match our arch here
3795 but just leaving them out of the hash. */
3796 slak
->m_operands
= ins
->args
;
3797 slak
->m_opnum
= strlen (slak
->m_operands
) / 2;
3798 slak
->m_arch
= ins
->arch
;
3799 slak
->m_opcode
= ins
->opcode
;
3800 /* This is kludgey */
3801 slak
->m_codenum
= ((ins
->match
) & 0xffffL
) ? 2 : 1;
3802 if (i
+ 1 != m68k_numopcodes
3803 && !strcmp (ins
->name
, m68k_opcodes
[i
+ 1].name
))
3805 slak
->m_next
= (struct m68k_incant
*) obstack_alloc (&robyn
, sizeof (struct m68k_incant
));
3810 slak
= slak
->m_next
;
3814 retval
= hash_insert (op_hash
, ins
->name
, (char *) hack
);
3816 as_fatal (_("Internal Error: Can't hash %s: %s"), ins
->name
, retval
);
3819 for (i
= 0; i
< m68k_numaliases
; i
++)
3821 const char *name
= m68k_opcode_aliases
[i
].primary
;
3822 const char *alias
= m68k_opcode_aliases
[i
].alias
;
3823 PTR val
= hash_find (op_hash
, name
);
3825 as_fatal (_("Internal Error: Can't find %s in hash table"), name
);
3826 retval
= hash_insert (op_hash
, alias
, val
);
3828 as_fatal (_("Internal Error: Can't hash %s: %s"), alias
, retval
);
3831 /* In MRI mode, all unsized branches are variable sized. Normally,
3832 they are word sized. */
3835 static struct m68k_opcode_alias mri_aliases
[] =
3856 i
< (int) (sizeof mri_aliases
/ sizeof mri_aliases
[0]);
3859 const char *name
= mri_aliases
[i
].primary
;
3860 const char *alias
= mri_aliases
[i
].alias
;
3861 PTR val
= hash_find (op_hash
, name
);
3863 as_fatal (_("Internal Error: Can't find %s in hash table"), name
);
3864 retval
= hash_jam (op_hash
, alias
, val
);
3866 as_fatal (_("Internal Error: Can't hash %s: %s"), alias
, retval
);
3870 for (i
= 0; i
< (int) sizeof (mklower_table
); i
++)
3871 mklower_table
[i
] = (isupper (c
= (char) i
)) ? tolower (c
) : c
;
3873 for (i
= 0; i
< (int) sizeof (notend_table
); i
++)
3875 notend_table
[i
] = 0;
3876 alt_notend_table
[i
] = 0;
3878 notend_table
[','] = 1;
3879 notend_table
['{'] = 1;
3880 notend_table
['}'] = 1;
3881 alt_notend_table
['a'] = 1;
3882 alt_notend_table
['A'] = 1;
3883 alt_notend_table
['d'] = 1;
3884 alt_notend_table
['D'] = 1;
3885 alt_notend_table
['#'] = 1;
3886 alt_notend_table
['&'] = 1;
3887 alt_notend_table
['f'] = 1;
3888 alt_notend_table
['F'] = 1;
3889 #ifdef REGISTER_PREFIX
3890 alt_notend_table
[REGISTER_PREFIX
] = 1;
3893 /* We need to put '(' in alt_notend_table to handle
3894 cas2 %d0:%d2,%d3:%d4,(%a0):(%a1)
3896 alt_notend_table
['('] = 1;
3898 /* We need to put '@' in alt_notend_table to handle
3899 cas2 %d0:%d2,%d3:%d4,@(%d0):@(%d1)
3901 alt_notend_table
['@'] = 1;
3903 /* We need to put digits in alt_notend_table to handle
3904 bfextu %d0{24:1},%d0
3906 alt_notend_table
['0'] = 1;
3907 alt_notend_table
['1'] = 1;
3908 alt_notend_table
['2'] = 1;
3909 alt_notend_table
['3'] = 1;
3910 alt_notend_table
['4'] = 1;
3911 alt_notend_table
['5'] = 1;
3912 alt_notend_table
['6'] = 1;
3913 alt_notend_table
['7'] = 1;
3914 alt_notend_table
['8'] = 1;
3915 alt_notend_table
['9'] = 1;
3917 #ifndef MIT_SYNTAX_ONLY
3918 /* Insert pseudo ops, these have to go into the opcode table since
3919 gas expects pseudo ops to start with a dot */
3922 while (mote_pseudo_table
[n
].poc_name
)
3924 hack
= (struct m68k_incant
*)
3925 obstack_alloc (&robyn
, sizeof (struct m68k_incant
));
3926 hash_insert (op_hash
,
3927 mote_pseudo_table
[n
].poc_name
, (char *) hack
);
3928 hack
->m_operands
= 0;
3938 record_alignment (text_section
, 2);
3939 record_alignment (data_section
, 2);
3940 record_alignment (bss_section
, 2);
3945 select_control_regs ()
3947 /* Note which set of "movec" control registers is available. */
3948 switch (cpu_of_arch (current_architecture
))
3951 control_regs
= m68000_control_regs
;
3954 control_regs
= m68010_control_regs
;
3958 control_regs
= m68020_control_regs
;
3961 control_regs
= m68040_control_regs
;
3964 control_regs
= m68060_control_regs
;
3967 control_regs
= cpu32_control_regs
;
3973 control_regs
= mcf_control_regs
;
3981 m68k_init_after_args ()
3983 if (cpu_of_arch (current_architecture
) == 0)
3986 const char *default_cpu
= TARGET_CPU
;
3988 if (*default_cpu
== 'm')
3990 for (i
= 0; i
< n_archs
; i
++)
3991 if (strcasecmp (default_cpu
, archs
[i
].name
) == 0)
3995 as_bad (_("unrecognized default cpu `%s' ???"), TARGET_CPU
);
3996 current_architecture
|= m68020
;
3999 current_architecture
|= archs
[i
].arch
;
4001 /* Permit m68881 specification with all cpus; those that can't work
4002 with a coprocessor could be doing emulation. */
4003 if (current_architecture
& m68851
)
4005 if (current_architecture
& m68040
)
4007 as_warn (_("68040 and 68851 specified; mmu instructions may assemble incorrectly"));
4010 /* What other incompatibilities could we check for? */
4012 /* Toss in some default assumptions about coprocessors. */
4014 && (cpu_of_arch (current_architecture
)
4015 /* Can CPU32 have a 68881 coprocessor?? */
4016 & (m68020
| m68030
| cpu32
)))
4018 current_architecture
|= m68881
;
4021 && (cpu_of_arch (current_architecture
) & m68020up
) != 0
4022 && (cpu_of_arch (current_architecture
) & m68040up
) == 0)
4024 current_architecture
|= m68851
;
4026 if (no_68881
&& (current_architecture
& m68881
))
4027 as_bad (_("options for 68881 and no-68881 both given"));
4028 if (no_68851
&& (current_architecture
& m68851
))
4029 as_bad (_("options for 68851 and no-68851 both given"));
4032 /* Work out the magic number. This isn't very general. */
4033 if (current_architecture
& m68000
)
4034 m68k_aout_machtype
= 0;
4035 else if (current_architecture
& m68010
)
4036 m68k_aout_machtype
= 1;
4037 else if (current_architecture
& m68020
)
4038 m68k_aout_machtype
= 2;
4040 m68k_aout_machtype
= 2;
4043 /* Note which set of "movec" control registers is available. */
4044 select_control_regs ();
4046 if (cpu_of_arch (current_architecture
) < m68020
4047 || arch_coldfire_p (current_architecture
))
4048 md_relax_table
[TAB (PCINDEX
, BYTE
)].rlx_more
= 0;
4051 /* This is called when a label is defined. */
4054 m68k_frob_label (sym
)
4057 struct label_line
*n
;
4059 n
= (struct label_line
*) xmalloc (sizeof *n
);
4062 as_where (&n
->file
, &n
->line
);
4068 /* This is called when a value that is not an instruction is emitted. */
4071 m68k_flush_pending_output ()
4073 current_label
= NULL
;
4076 /* This is called at the end of the assembly, when the final value of
4077 the label is known. We warn if this is a text symbol aligned at an
4081 m68k_frob_symbol (sym
)
4084 if (S_GET_SEGMENT (sym
) == reg_section
4085 && (int) S_GET_VALUE (sym
) < 0)
4087 S_SET_SEGMENT (sym
, absolute_section
);
4088 S_SET_VALUE (sym
, ~(int)S_GET_VALUE (sym
));
4090 else if ((S_GET_VALUE (sym
) & 1) != 0)
4092 struct label_line
*l
;
4094 for (l
= labels
; l
!= NULL
; l
= l
->next
)
4096 if (l
->label
== sym
)
4099 as_warn_where (l
->file
, l
->line
,
4100 _("text label `%s' aligned to odd boundary"),
4108 /* This is called if we go in or out of MRI mode because of the .mri
4112 m68k_mri_mode_change (on
)
4117 if (! flag_reg_prefix_optional
)
4119 flag_reg_prefix_optional
= 1;
4120 #ifdef REGISTER_PREFIX
4125 if (! m68k_rel32_from_cmdline
)
4130 if (! reg_prefix_optional_seen
)
4132 #ifdef REGISTER_PREFIX_OPTIONAL
4133 flag_reg_prefix_optional
= REGISTER_PREFIX_OPTIONAL
;
4135 flag_reg_prefix_optional
= 0;
4137 #ifdef REGISTER_PREFIX
4142 if (! m68k_rel32_from_cmdline
)
4147 /* Equal to MAX_PRECISION in atof-ieee.c */
4148 #define MAX_LITTLENUMS 6
4150 /* Turn a string in input_line_pointer into a floating point constant
4151 of type TYPE, and store the appropriate bytes in *LITP. The number
4152 of LITTLENUMS emitted is stored in *SIZEP. An error message is
4153 returned, or NULL on OK. */
4156 md_atof (type
, litP
, sizeP
)
4162 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
4163 LITTLENUM_TYPE
*wordP
;
4194 return _("Bad call to MD_ATOF()");
4196 t
= atof_ieee (input_line_pointer
, type
, words
);
4198 input_line_pointer
= t
;
4200 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
4201 for (wordP
= words
; prec
--;)
4203 md_number_to_chars (litP
, (long) (*wordP
++), sizeof (LITTLENUM_TYPE
));
4204 litP
+= sizeof (LITTLENUM_TYPE
);
4210 md_number_to_chars (buf
, val
, n
)
4215 number_to_chars_bigendian (buf
, val
, n
);
4219 md_apply_fix_2 (fixP
, val
)
4223 addressT upper_limit
;
4224 offsetT lower_limit
;
4226 /* This is unnecessary but it convinces the native rs6000 compiler
4227 to generate the code we want. */
4228 char *buf
= fixP
->fx_frag
->fr_literal
;
4229 buf
+= fixP
->fx_where
;
4230 /* end ibm compiler workaround */
4232 if (val
& 0x80000000)
4233 val
|= ~(addressT
)0x7fffffff;
4240 memset (buf
, 0, fixP
->fx_size
);
4241 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
4243 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
4244 && !S_IS_DEFINED (fixP
->fx_addsy
)
4245 && !S_IS_WEAK (fixP
->fx_addsy
))
4246 S_SET_WEAK (fixP
->fx_addsy
);
4251 #ifdef BFD_ASSEMBLER
4252 if (fixP
->fx_r_type
== BFD_RELOC_VTABLE_INHERIT
4253 || fixP
->fx_r_type
== BFD_RELOC_VTABLE_ENTRY
)
4257 switch (fixP
->fx_size
)
4259 /* The cast to offsetT below are necessary to make code correct for
4260 machines where ints are smaller than offsetT */
4264 lower_limit
= - (offsetT
) 0x80;
4267 *buf
++ = (val
>> 8);
4269 upper_limit
= 0x7fff;
4270 lower_limit
= - (offsetT
) 0x8000;
4273 *buf
++ = (val
>> 24);
4274 *buf
++ = (val
>> 16);
4275 *buf
++ = (val
>> 8);
4277 upper_limit
= 0x7fffffff;
4278 lower_limit
= - (offsetT
) 0x7fffffff - 1; /* avoid constant overflow */
4281 BAD_CASE (fixP
->fx_size
);
4284 /* Fix up a negative reloc. */
4285 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_subsy
!= NULL
)
4287 fixP
->fx_addsy
= fixP
->fx_subsy
;
4288 fixP
->fx_subsy
= NULL
;
4292 /* For non-pc-relative values, it's conceivable we might get something
4293 like "0xff" for a byte field. So extend the upper part of the range
4294 to accept such numbers. We arbitrarily disallow "-0xff" or "0xff+0xff",
4295 so that we can do any range checking at all. */
4296 if (! fixP
->fx_pcrel
&& ! fixP
->fx_signed
)
4297 upper_limit
= upper_limit
* 2 + 1;
4299 if ((addressT
) val
> upper_limit
4300 && (val
> 0 || val
< lower_limit
))
4301 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("value out of range"));
4303 /* A one byte PC-relative reloc means a short branch. We can't use
4304 a short branch with a value of 0 or -1, because those indicate
4305 different opcodes (branches with longer offsets). fixup_segment
4306 in write.c may have clobbered fx_pcrel, so we need to examine the
4309 #ifdef BFD_ASSEMBLER
4310 || fixP
->fx_r_type
== BFD_RELOC_8_PCREL
4313 && fixP
->fx_size
== 1
4314 && (fixP
->fx_addsy
== NULL
4315 || S_IS_DEFINED (fixP
->fx_addsy
))
4316 && (val
== 0 || val
== -1))
4317 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("invalid byte branch offset"));
4320 #ifdef BFD_ASSEMBLER
4322 md_apply_fix (fixP
, valp
)
4326 md_apply_fix_2 (fixP
, (addressT
) *valp
);
4330 void md_apply_fix (fixP
, val
)
4334 md_apply_fix_2 (fixP
, (addressT
) val
);
4338 /* *fragP has been relaxed to its final size, and now needs to have
4339 the bytes inside it modified to conform to the new size There is UGLY
4343 md_convert_frag_1 (fragP
)
4344 register fragS
*fragP
;
4349 /* Address in object code of the displacement. */
4350 register int object_address
= fragP
->fr_fix
+ fragP
->fr_address
;
4352 /* Address in gas core of the place to store the displacement. */
4353 /* This convinces the native rs6000 compiler to generate the code we
4355 register char *buffer_address
= fragP
->fr_literal
;
4356 buffer_address
+= fragP
->fr_fix
;
4357 /* end ibm compiler workaround */
4359 /* The displacement of the address, from current location. */
4360 disp
= fragP
->fr_symbol
? S_GET_VALUE (fragP
->fr_symbol
) : 0;
4361 disp
= (disp
+ fragP
->fr_offset
) - object_address
;
4363 #ifdef BFD_ASSEMBLER
4364 disp
+= symbol_get_frag (fragP
->fr_symbol
)->fr_address
;
4367 switch (fragP
->fr_subtype
)
4369 case TAB (BRANCHBWL
, BYTE
):
4370 case TAB (BRABSJUNC
, BYTE
):
4371 case TAB (BRABSJCOND
, BYTE
):
4372 case TAB (BRANCHBW
, BYTE
):
4373 know (issbyte (disp
));
4375 as_bad (_("short branch with zero offset: use :w"));
4376 fixP
= fix_new (fragP
, fragP
->fr_fix
- 1, 1, fragP
->fr_symbol
,
4377 fragP
->fr_offset
, 1, RELAX_RELOC_PC8
);
4378 fixP
->fx_pcrel_adjust
= -1;
4380 case TAB (BRANCHBWL
, SHORT
):
4381 case TAB (BRABSJUNC
, SHORT
):
4382 case TAB (BRABSJCOND
, SHORT
):
4383 case TAB (BRANCHBW
, SHORT
):
4384 fragP
->fr_opcode
[1] = 0x00;
4385 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
4386 1, RELAX_RELOC_PC16
);
4389 case TAB (BRANCHBWL
, LONG
):
4390 fragP
->fr_opcode
[1] = (char) 0xFF;
4391 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
,
4392 1, RELAX_RELOC_PC32
);
4395 case TAB (BRABSJUNC
, LONG
):
4396 if (fragP
->fr_opcode
[0] == 0x61) /* jbsr */
4398 fragP
->fr_opcode
[0] = 0x4E;
4399 fragP
->fr_opcode
[1] = (char) 0xB9; /* JSR with ABSL LONG operand */
4400 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
,
4401 0, RELAX_RELOC_ABS32
);
4404 else if (fragP
->fr_opcode
[0] == 0x60) /* jbra */
4406 fragP
->fr_opcode
[0] = 0x4E;
4407 fragP
->fr_opcode
[1] = (char) 0xF9; /* JMP with ABSL LONG operand */
4408 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
,
4409 0, RELAX_RELOC_ABS32
);
4414 /* This cannot happen, because jbsr and jbra are the only two
4415 unconditional branches. */
4419 case TAB (BRABSJCOND
, LONG
):
4420 /* Only Bcc 68000 instructions can come here. */
4421 /* Change bcc into b!cc/jmp absl long. */
4423 fragP
->fr_opcode
[0] ^= 0x01; /* invert bcc */
4424 fragP
->fr_opcode
[1] = 0x6;/* branch offset = 6 */
4426 /* JF: these used to be fr_opcode[2,3], but they may be in a
4427 different frag, in which case refering to them is a no-no.
4428 Only fr_opcode[0,1] are guaranteed to work. */
4429 *buffer_address
++ = 0x4e; /* put in jmp long (0x4ef9) */
4430 *buffer_address
++ = (char) 0xf9;
4431 fragP
->fr_fix
+= 2; /* account for jmp instruction */
4432 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
,
4433 fragP
->fr_offset
, 0, RELAX_RELOC_ABS32
);
4436 case TAB (FBRANCH
, SHORT
):
4437 know ((fragP
->fr_opcode
[1] & 0x40) == 0);
4438 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
4439 1, RELAX_RELOC_PC16
);
4442 case TAB (FBRANCH
, LONG
):
4443 fragP
->fr_opcode
[1] |= 0x40; /* Turn on LONG bit */
4444 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
,
4445 1, RELAX_RELOC_PC32
);
4448 case TAB (DBCCLBR
, SHORT
):
4449 case TAB (DBCCABSJ
, SHORT
):
4450 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
4451 1, RELAX_RELOC_PC16
);
4454 case TAB (DBCCLBR
, LONG
):
4455 /* only DBcc instructions can come here */
4456 /* Change dbcc into dbcc/bral. */
4458 /* JF: these used to be fr_opcode[2-7], but that's wrong */
4459 *buffer_address
++ = 0x00; /* branch offset = 4 */
4460 *buffer_address
++ = 0x04;
4461 *buffer_address
++ = 0x60; /* put in bra pc+6 */
4462 *buffer_address
++ = 0x06;
4463 *buffer_address
++ = 0x60; /* Put in bral (0x60ff). */
4464 *buffer_address
++ = (char) 0xff;
4466 fragP
->fr_fix
+= 6; /* account for bra/jmp instructions */
4467 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
, 1,
4471 case TAB (DBCCABSJ
, LONG
):
4472 /* only DBcc instructions can come here */
4473 /* Change dbcc into dbcc/jmp. */
4475 /* JF: these used to be fr_opcode[2-7], but that's wrong */
4476 *buffer_address
++ = 0x00; /* branch offset = 4 */
4477 *buffer_address
++ = 0x04;
4478 *buffer_address
++ = 0x60; /* put in bra pc+6 */
4479 *buffer_address
++ = 0x06;
4480 *buffer_address
++ = 0x4e; /* Put in jmp long (0x4ef9). */
4481 *buffer_address
++ = (char) 0xf9;
4483 fragP
->fr_fix
+= 6; /* account for bra/jmp instructions */
4484 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
, 0,
4488 case TAB (PCREL1632
, SHORT
):
4489 fragP
->fr_opcode
[1] &= ~0x3F;
4490 fragP
->fr_opcode
[1] |= 0x3A; /* 072 - mode 7.2 */
4491 fix_new (fragP
, (int) (fragP
->fr_fix
), 2, fragP
->fr_symbol
,
4492 fragP
->fr_offset
, 1, RELAX_RELOC_PC16
);
4495 case TAB (PCREL1632
, LONG
):
4496 /* Already set to mode 7.3; this indicates: PC indirect with
4497 suppressed index, 32-bit displacement. */
4498 *buffer_address
++ = 0x01;
4499 *buffer_address
++ = 0x70;
4501 fixP
= fix_new (fragP
, (int) (fragP
->fr_fix
), 4, fragP
->fr_symbol
,
4502 fragP
->fr_offset
, 1, RELAX_RELOC_PC32
);
4503 fixP
->fx_pcrel_adjust
= 2;
4506 case TAB (PCINDEX
, BYTE
):
4507 assert (fragP
->fr_fix
>= 2);
4508 buffer_address
[-2] &= ~1;
4509 fixP
= fix_new (fragP
, fragP
->fr_fix
- 1, 1, fragP
->fr_symbol
,
4510 fragP
->fr_offset
, 1, RELAX_RELOC_PC8
);
4511 fixP
->fx_pcrel_adjust
= 1;
4513 case TAB (PCINDEX
, SHORT
):
4514 assert (fragP
->fr_fix
>= 2);
4515 buffer_address
[-2] |= 0x1;
4516 buffer_address
[-1] = 0x20;
4517 fixP
= fix_new (fragP
, (int) (fragP
->fr_fix
), 2, fragP
->fr_symbol
,
4518 fragP
->fr_offset
, 1, RELAX_RELOC_PC16
);
4519 fixP
->fx_pcrel_adjust
= 2;
4522 case TAB (PCINDEX
, LONG
):
4523 assert (fragP
->fr_fix
>= 2);
4524 buffer_address
[-2] |= 0x1;
4525 buffer_address
[-1] = 0x30;
4526 fixP
= fix_new (fragP
, (int) (fragP
->fr_fix
), 4, fragP
->fr_symbol
,
4527 fragP
->fr_offset
, 1, RELAX_RELOC_PC32
);
4528 fixP
->fx_pcrel_adjust
= 2;
4531 case TAB (ABSTOPCREL
, SHORT
):
4532 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
4533 1, RELAX_RELOC_PC16
);
4536 case TAB (ABSTOPCREL
, LONG
):
4537 /* The thing to do here is force it to ABSOLUTE LONG, since
4538 ABSTOPCREL is really trying to shorten an ABSOLUTE address anyway */
4539 if ((fragP
->fr_opcode
[1] & 0x3F) != 0x3A)
4541 fragP
->fr_opcode
[1] &= ~0x3F;
4542 fragP
->fr_opcode
[1] |= 0x39; /* Mode 7.1 */
4543 fix_new (fragP
, fragP
->fr_fix
, 4, fragP
->fr_symbol
, fragP
->fr_offset
,
4544 0, RELAX_RELOC_ABS32
);
4550 #ifndef BFD_ASSEMBLER
4553 md_convert_frag (headers
, sec
, fragP
)
4554 object_headers
*headers ATTRIBUTE_UNUSED
;
4555 segT sec ATTRIBUTE_UNUSED
;
4558 md_convert_frag_1 (fragP
);
4564 md_convert_frag (abfd
, sec
, fragP
)
4565 bfd
*abfd ATTRIBUTE_UNUSED
;
4566 segT sec ATTRIBUTE_UNUSED
;
4569 md_convert_frag_1 (fragP
);
4573 /* Force truly undefined symbols to their maximum size, and generally set up
4574 the frag list to be relaxed
4577 md_estimate_size_before_relax (fragP
, segment
)
4578 register fragS
*fragP
;
4583 old_fix
= fragP
->fr_fix
;
4585 /* Handle SZ_UNDEF first, it can be changed to BYTE or SHORT. */
4586 switch (fragP
->fr_subtype
)
4588 case TAB (BRANCHBWL
, SZ_UNDEF
):
4589 case TAB (BRABSJUNC
, SZ_UNDEF
):
4591 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4592 && relaxable_symbol (fragP
->fr_symbol
))
4594 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), BYTE
);
4596 else if (flag_short_refs
)
4598 /* Symbol is undefined and we want short ref. */
4599 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), SHORT
);
4604 /* Symbol is still undefined. Make it LONG. */
4605 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), LONG
);
4611 case TAB (BRABSJCOND
, SZ_UNDEF
):
4613 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4614 && relaxable_symbol (fragP
->fr_symbol
))
4616 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), BYTE
);
4618 else if (flag_short_refs
)
4620 /* Symbol is undefined and we want short ref. */
4621 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), SHORT
);
4626 /* Symbol is still undefined. Make it LONG. */
4627 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), LONG
);
4633 case TAB (BRANCHBW
, SZ_UNDEF
):
4635 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4636 && relaxable_symbol (fragP
->fr_symbol
))
4638 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), BYTE
);
4642 /* Symbol is undefined and we don't have long branches. */
4643 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), SHORT
);
4649 case TAB (FBRANCH
, SZ_UNDEF
):
4651 if ((S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4652 && relaxable_symbol (fragP
->fr_symbol
))
4655 fragP
->fr_subtype
= TAB (FBRANCH
, SHORT
);
4660 fragP
->fr_subtype
= TAB (FBRANCH
, LONG
);
4666 case TAB (DBCCLBR
, SZ_UNDEF
):
4667 case TAB (DBCCABSJ
, SZ_UNDEF
):
4669 if ((S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4670 && relaxable_symbol (fragP
->fr_symbol
))
4673 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), SHORT
);
4678 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), LONG
);
4679 fragP
->fr_var
+= 10;
4684 case TAB (PCREL1632
, SZ_UNDEF
):
4686 if (((S_GET_SEGMENT (fragP
->fr_symbol
)) == segment
4687 && relaxable_symbol (fragP
->fr_symbol
))
4690 fragP
->fr_subtype
= TAB (PCREL1632
, SHORT
);
4695 fragP
->fr_subtype
= TAB (PCREL1632
, LONG
);
4701 case TAB (PCINDEX
, SZ_UNDEF
):
4702 if ((S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4703 && relaxable_symbol (fragP
->fr_symbol
)))
4705 fragP
->fr_subtype
= TAB (PCINDEX
, BYTE
);
4709 fragP
->fr_subtype
= TAB (PCINDEX
, LONG
);
4714 case TAB (ABSTOPCREL
, SZ_UNDEF
):
4716 if ((S_GET_SEGMENT (fragP
->fr_symbol
) == segment
4717 && relaxable_symbol (fragP
->fr_symbol
)))
4719 fragP
->fr_subtype
= TAB (ABSTOPCREL
, SHORT
);
4724 fragP
->fr_subtype
= TAB (ABSTOPCREL
, LONG
);
4734 /* Now that SZ_UNDEF are taken care of, check others. */
4735 switch (fragP
->fr_subtype
)
4737 case TAB (BRANCHBWL
, BYTE
):
4738 case TAB (BRABSJUNC
, BYTE
):
4739 case TAB (BRABSJCOND
, BYTE
):
4740 case TAB (BRANCHBW
, BYTE
):
4741 /* We can't do a short jump to the next instruction, so in that
4742 case we force word mode. At this point S_GET_VALUE should
4743 return the offset of the symbol within its frag. If the
4744 symbol is at the start of a frag, and it is the next frag
4745 with any data in it (usually this is just the next frag, but
4746 assembler listings may introduce empty frags), we must use
4748 if (fragP
->fr_symbol
&& S_GET_VALUE (fragP
->fr_symbol
) == 0)
4753 stop
= symbol_get_frag (fragP
->fr_symbol
);
4754 for (l
= fragP
->fr_next
; l
!= stop
; l
= l
->fr_next
)
4755 if (l
->fr_fix
+ l
->fr_var
!= 0)
4759 fragP
->fr_subtype
= TAB (TABTYPE (fragP
->fr_subtype
), SHORT
);
4767 return fragP
->fr_var
+ fragP
->fr_fix
- old_fix
;
4770 #if defined(OBJ_AOUT) | defined(OBJ_BOUT)
4771 /* the bit-field entries in the relocation_info struct plays hell
4772 with the byte-order problems of cross-assembly. So as a hack,
4773 I added this mach. dependent ri twiddler. Ugly, but it gets
4775 /* on m68k: first 4 bytes are normal unsigned long, next three bytes
4776 are symbolnum, most sig. byte first. Last byte is broken up with
4777 bit 7 as pcrel, bits 6 & 5 as length, bit 4 as pcrel, and the lower
4778 nibble as nuthin. (on Sun 3 at least) */
4779 /* Translate the internal relocation information into target-specific
4783 md_ri_to_chars (the_bytes
, ri
)
4785 struct reloc_info_generic
*ri
;
4788 md_number_to_chars (the_bytes
, ri
->r_address
, 4);
4789 /* now the fun stuff */
4790 the_bytes
[4] = (ri
->r_symbolnum
>> 16) & 0x0ff;
4791 the_bytes
[5] = (ri
->r_symbolnum
>> 8) & 0x0ff;
4792 the_bytes
[6] = ri
->r_symbolnum
& 0x0ff;
4793 the_bytes
[7] = (((ri
->r_pcrel
<< 7) & 0x80) | ((ri
->r_length
<< 5) & 0x60) |
4794 ((ri
->r_extern
<< 4) & 0x10));
4797 #endif /* comment */
4799 #ifndef BFD_ASSEMBLER
4801 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
4804 relax_addressT segment_address_in_file
;
4807 * In: length of relocation (or of address) in chars: 1, 2 or 4.
4808 * Out: GNU LD relocation length code: 0, 1, or 2.
4811 static CONST
unsigned char nbytes_r_length
[] = {42, 0, 1, 42, 2};
4814 know (fixP
->fx_addsy
!= NULL
);
4816 md_number_to_chars (where
,
4817 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
4820 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
4821 ? S_GET_TYPE (fixP
->fx_addsy
)
4822 : fixP
->fx_addsy
->sy_number
);
4824 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
4825 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
4826 where
[6] = r_symbolnum
& 0x0ff;
4827 where
[7] = (((fixP
->fx_pcrel
<< 7) & 0x80) | ((nbytes_r_length
[fixP
->fx_size
] << 5) & 0x60) |
4828 (((!S_IS_DEFINED (fixP
->fx_addsy
)) << 4) & 0x10));
4832 #endif /* OBJ_AOUT or OBJ_BOUT */
4834 #ifndef WORKING_DOT_WORD
4835 CONST
int md_short_jump_size
= 4;
4836 CONST
int md_long_jump_size
= 6;
4839 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
4841 addressT from_addr
, to_addr
;
4842 fragS
*frag ATTRIBUTE_UNUSED
;
4843 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
4847 offset
= to_addr
- (from_addr
+ 2);
4849 md_number_to_chars (ptr
, (valueT
) 0x6000, 2);
4850 md_number_to_chars (ptr
+ 2, (valueT
) offset
, 2);
4854 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
4856 addressT from_addr
, to_addr
;
4862 if (!HAVE_LONG_BRANCH(current_architecture
))
4864 offset
= to_addr
- S_GET_VALUE (to_symbol
);
4865 md_number_to_chars (ptr
, (valueT
) 0x4EF9, 2);
4866 md_number_to_chars (ptr
+ 2, (valueT
) offset
, 4);
4867 fix_new (frag
, (ptr
+ 2) - frag
->fr_literal
, 4, to_symbol
, (offsetT
) 0,
4872 offset
= to_addr
- (from_addr
+ 2);
4873 md_number_to_chars (ptr
, (valueT
) 0x60ff, 2);
4874 md_number_to_chars (ptr
+ 2, (valueT
) offset
, 4);
4880 /* Different values of OK tell what its OK to return. Things that
4881 aren't OK are an error (what a shock, no?)
4884 10: Absolute 1:8 only
4885 20: Absolute 0:7 only
4886 30: absolute 0:15 only
4887 40: Absolute 0:31 only
4888 50: absolute 0:127 only
4889 55: absolute -64:63 only
4890 60: absolute -128:127 only
4891 70: absolute 0:4095 only
4898 struct m68k_exp
*exp
;
4901 if (exp
->exp
.X_op
== O_absent
)
4903 /* Do the same thing the VAX asm does */
4904 op (exp
) = O_constant
;
4910 as_warn (_("expression out of range: defaulting to 1"));
4914 else if (exp
->exp
.X_op
== O_constant
)
4919 if (offs (exp
) < 1 || offs (exp
) > 8)
4921 as_warn (_("expression out of range: defaulting to 1"));
4926 if (offs (exp
) < 0 || offs (exp
) > 7)
4930 if (offs (exp
) < 0 || offs (exp
) > 15)
4934 if (offs (exp
) < 0 || offs (exp
) > 32)
4938 if (offs (exp
) < 0 || offs (exp
) > 127)
4942 if (offs (exp
) < -64 || offs (exp
) > 63)
4946 if (offs (exp
) < -128 || offs (exp
) > 127)
4950 if (offs (exp
) < 0 || offs (exp
) > 4095)
4953 as_warn (_("expression out of range: defaulting to 0"));
4961 else if (exp
->exp
.X_op
== O_big
)
4963 if (offs (exp
) <= 0 /* flonum */
4964 && (ok
== 80 /* no bignums */
4965 || (ok
> 10 /* small-int ranges including 0 ok */
4966 /* If we have a flonum zero, a zero integer should
4967 do as well (e.g., in moveq). */
4968 && generic_floating_point_number
.exponent
== 0
4969 && generic_floating_point_number
.low
[0] == 0)))
4971 /* HACK! Turn it into a long */
4972 LITTLENUM_TYPE words
[6];
4974 gen_to_words (words
, 2, 8L); /* These numbers are magic! */
4975 op (exp
) = O_constant
;
4978 offs (exp
) = words
[1] | (words
[0] << 16);
4982 op (exp
) = O_constant
;
4985 offs (exp
) = (ok
== 10) ? 1 : 0;
4986 as_warn (_("Can't deal with expression; defaulting to %ld"),
4992 if (ok
>= 10 && ok
<= 70)
4994 op (exp
) = O_constant
;
4997 offs (exp
) = (ok
== 10) ? 1 : 0;
4998 as_warn (_("Can't deal with expression; defaulting to %ld"),
5003 if (exp
->size
!= SIZE_UNSPEC
)
5011 if (!isbyte (offs (exp
)))
5012 as_warn (_("expression doesn't fit in BYTE"));
5015 if (!isword (offs (exp
)))
5016 as_warn (_("expression doesn't fit in WORD"));
5024 /* These are the back-ends for the various machine dependent pseudo-ops. */
5028 int ignore ATTRIBUTE_UNUSED
;
5030 subseg_set (data_section
, 1);
5031 demand_empty_rest_of_line ();
5036 int ignore ATTRIBUTE_UNUSED
;
5038 subseg_set (data_section
, 2);
5039 demand_empty_rest_of_line ();
5044 int ignore ATTRIBUTE_UNUSED
;
5046 /* We don't support putting frags in the BSS segment, we fake it
5047 by marking in_bss, then looking at s_skip for clues. */
5049 subseg_set (bss_section
, 0);
5050 demand_empty_rest_of_line ();
5055 int ignore ATTRIBUTE_UNUSED
;
5058 register long temp_fill
;
5060 temp
= 1; /* JF should be 2? */
5061 temp_fill
= get_absolute_expression ();
5062 if (!need_pass_2
) /* Never make frag if expect extra pass. */
5063 frag_align (temp
, (int) temp_fill
, 0);
5064 demand_empty_rest_of_line ();
5065 record_alignment (now_seg
, temp
);
5070 int ignore ATTRIBUTE_UNUSED
;
5072 demand_empty_rest_of_line ();
5075 /* Pseudo-ops handled for MRI compatibility. */
5077 /* This function returns non-zero if the argument is a conditional
5078 pseudo-op. This is called when checking whether a pending
5079 alignment is needed. */
5082 m68k_conditional_pseudoop (pop
)
5085 return (pop
->poc_handler
== s_mri_if
5086 || pop
->poc_handler
== s_mri_else
);
5089 /* Handle an MRI style chip specification. */
5098 s
= input_line_pointer
;
5099 /* We can't use get_symbol_end since the processor names are not proper
5101 while (is_part_of_name (c
= *input_line_pointer
++))
5103 *--input_line_pointer
= 0;
5104 for (i
= 0; i
< n_archs
; i
++)
5105 if (strcasecmp (s
, archs
[i
].name
) == 0)
5109 as_bad (_("%s: unrecognized processor name"), s
);
5110 *input_line_pointer
= c
;
5111 ignore_rest_of_line ();
5114 *input_line_pointer
= c
;
5116 if (*input_line_pointer
== '/')
5117 current_architecture
= 0;
5119 current_architecture
&= m68881
| m68851
;
5120 current_architecture
|= archs
[i
].arch
;
5122 while (*input_line_pointer
== '/')
5124 ++input_line_pointer
;
5125 s
= input_line_pointer
;
5126 /* We can't use get_symbol_end since the processor names are not
5128 while (is_part_of_name (c
= *input_line_pointer
++))
5130 *--input_line_pointer
= 0;
5131 if (strcmp (s
, "68881") == 0)
5132 current_architecture
|= m68881
;
5133 else if (strcmp (s
, "68851") == 0)
5134 current_architecture
|= m68851
;
5135 *input_line_pointer
= c
;
5138 /* Update info about available control registers. */
5139 select_control_regs ();
5142 /* The MRI CHIP pseudo-op. */
5146 int ignore ATTRIBUTE_UNUSED
;
5152 stop
= mri_comment_field (&stopc
);
5155 mri_comment_end (stop
, stopc
);
5156 demand_empty_rest_of_line ();
5159 /* The MRI FOPT pseudo-op. */
5163 int ignore ATTRIBUTE_UNUSED
;
5167 if (strncasecmp (input_line_pointer
, "ID=", 3) == 0)
5171 input_line_pointer
+= 3;
5172 temp
= get_absolute_expression ();
5173 if (temp
< 0 || temp
> 7)
5174 as_bad (_("bad coprocessor id"));
5176 m68k_float_copnum
= COP0
+ temp
;
5180 as_bad (_("unrecognized fopt option"));
5181 ignore_rest_of_line ();
5185 demand_empty_rest_of_line ();
5188 /* The structure used to handle the MRI OPT pseudo-op. */
5192 /* The name of the option. */
5195 /* If this is not NULL, just call this function. The first argument
5196 is the ARG field of this structure, the second argument is
5197 whether the option was negated. */
5198 void (*pfn
) PARAMS ((int arg
, int on
));
5200 /* If this is not NULL, and the PFN field is NULL, set the variable
5201 this points to. Set it to the ARG field if the option was not
5202 negated, and the NOTARG field otherwise. */
5205 /* The value to pass to PFN or to assign to *PVAR. */
5208 /* The value to assign to *PVAR if the option is negated. If PFN is
5209 NULL, and PVAR is not NULL, and ARG and NOTARG are the same, then
5210 the option may not be negated. */
5214 /* The table used to handle the MRI OPT pseudo-op. */
5216 static void skip_to_comma
PARAMS ((int, int));
5217 static void opt_nest
PARAMS ((int, int));
5218 static void opt_chip
PARAMS ((int, int));
5219 static void opt_list
PARAMS ((int, int));
5220 static void opt_list_symbols
PARAMS ((int, int));
5222 static const struct opt_action opt_table
[] =
5224 { "abspcadd", 0, &m68k_abspcadd
, 1, 0 },
5226 /* We do relaxing, so there is little use for these options. */
5227 { "b", 0, 0, 0, 0 },
5228 { "brs", 0, 0, 0, 0 },
5229 { "brb", 0, 0, 0, 0 },
5230 { "brl", 0, 0, 0, 0 },
5231 { "brw", 0, 0, 0, 0 },
5233 { "c", 0, 0, 0, 0 },
5234 { "cex", 0, 0, 0, 0 },
5235 { "case", 0, &symbols_case_sensitive
, 1, 0 },
5236 { "cl", 0, 0, 0, 0 },
5237 { "cre", 0, 0, 0, 0 },
5238 { "d", 0, &flag_keep_locals
, 1, 0 },
5239 { "e", 0, 0, 0, 0 },
5240 { "f", 0, &flag_short_refs
, 1, 0 },
5241 { "frs", 0, &flag_short_refs
, 1, 0 },
5242 { "frl", 0, &flag_short_refs
, 0, 1 },
5243 { "g", 0, 0, 0, 0 },
5244 { "i", 0, 0, 0, 0 },
5245 { "m", 0, 0, 0, 0 },
5246 { "mex", 0, 0, 0, 0 },
5247 { "mc", 0, 0, 0, 0 },
5248 { "md", 0, 0, 0, 0 },
5249 { "nest", opt_nest
, 0, 0, 0 },
5250 { "next", skip_to_comma
, 0, 0, 0 },
5251 { "o", 0, 0, 0, 0 },
5252 { "old", 0, 0, 0, 0 },
5253 { "op", skip_to_comma
, 0, 0, 0 },
5254 { "pco", 0, 0, 0, 0 },
5255 { "p", opt_chip
, 0, 0, 0 },
5256 { "pcr", 0, 0, 0, 0 },
5257 { "pcs", 0, 0, 0, 0 },
5258 { "r", 0, 0, 0, 0 },
5259 { "quick", 0, &m68k_quick
, 1, 0 },
5260 { "rel32", 0, &m68k_rel32
, 1, 0 },
5261 { "s", opt_list
, 0, 0, 0 },
5262 { "t", opt_list_symbols
, 0, 0, 0 },
5263 { "w", 0, &flag_no_warnings
, 0, 1 },
5267 #define OPTCOUNT ((int) (sizeof opt_table / sizeof opt_table[0]))
5269 /* The MRI OPT pseudo-op. */
5273 int ignore ATTRIBUTE_UNUSED
;
5281 const struct opt_action
*o
;
5286 if (*input_line_pointer
== '-')
5288 ++input_line_pointer
;
5291 else if (strncasecmp (input_line_pointer
, "NO", 2) == 0)
5293 input_line_pointer
+= 2;
5297 s
= input_line_pointer
;
5298 c
= get_symbol_end ();
5300 for (i
= 0, o
= opt_table
; i
< OPTCOUNT
; i
++, o
++)
5302 if (strcasecmp (s
, o
->name
) == 0)
5306 /* Restore input_line_pointer now in case the option
5308 *input_line_pointer
= c
;
5309 (*o
->pfn
) (o
->arg
, t
);
5311 else if (o
->pvar
!= NULL
)
5313 if (! t
&& o
->arg
== o
->notarg
)
5314 as_bad (_("option `%s' may not be negated"), s
);
5315 *input_line_pointer
= c
;
5316 *o
->pvar
= t
? o
->arg
: o
->notarg
;
5319 *input_line_pointer
= c
;
5325 as_bad (_("option `%s' not recognized"), s
);
5326 *input_line_pointer
= c
;
5329 while (*input_line_pointer
++ == ',');
5331 /* Move back to terminating character. */
5332 --input_line_pointer
;
5333 demand_empty_rest_of_line ();
5336 /* Skip ahead to a comma. This is used for OPT options which we do
5337 not suppor tand which take arguments. */
5340 skip_to_comma (arg
, on
)
5341 int arg ATTRIBUTE_UNUSED
;
5342 int on ATTRIBUTE_UNUSED
;
5344 while (*input_line_pointer
!= ','
5345 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
5346 ++input_line_pointer
;
5349 /* Handle the OPT NEST=depth option. */
5353 int arg ATTRIBUTE_UNUSED
;
5354 int on ATTRIBUTE_UNUSED
;
5356 if (*input_line_pointer
!= '=')
5358 as_bad (_("bad format of OPT NEST=depth"));
5362 ++input_line_pointer
;
5363 max_macro_nest
= get_absolute_expression ();
5366 /* Handle the OPT P=chip option. */
5370 int arg ATTRIBUTE_UNUSED
;
5371 int on ATTRIBUTE_UNUSED
;
5373 if (*input_line_pointer
!= '=')
5375 /* This is just OPT P, which we do not support. */
5379 ++input_line_pointer
;
5383 /* Handle the OPT S option. */
5387 int arg ATTRIBUTE_UNUSED
;
5393 /* Handle the OPT T option. */
5396 opt_list_symbols (arg
, on
)
5397 int arg ATTRIBUTE_UNUSED
;
5401 listing
|= LISTING_SYMBOLS
;
5403 listing
&=~ LISTING_SYMBOLS
;
5406 /* Handle the MRI REG pseudo-op. */
5410 int ignore ATTRIBUTE_UNUSED
;
5419 if (line_label
== NULL
)
5421 as_bad (_("missing label"));
5422 ignore_rest_of_line ();
5427 stop
= mri_comment_field (&stopc
);
5431 s
= input_line_pointer
;
5432 while (isalnum ((unsigned char) *input_line_pointer
)
5433 #ifdef REGISTER_PREFIX
5434 || *input_line_pointer
== REGISTER_PREFIX
5436 || *input_line_pointer
== '/'
5437 || *input_line_pointer
== '-')
5438 ++input_line_pointer
;
5439 c
= *input_line_pointer
;
5440 *input_line_pointer
= '\0';
5442 if (m68k_ip_op (s
, &rop
) != 0)
5444 if (rop
.error
== NULL
)
5445 as_bad (_("bad register list"));
5447 as_bad (_("bad register list: %s"), rop
.error
);
5448 *input_line_pointer
= c
;
5449 ignore_rest_of_line ();
5453 *input_line_pointer
= c
;
5455 if (rop
.mode
== REGLST
)
5457 else if (rop
.mode
== DREG
)
5458 mask
= 1 << (rop
.reg
- DATA0
);
5459 else if (rop
.mode
== AREG
)
5460 mask
= 1 << (rop
.reg
- ADDR0
+ 8);
5461 else if (rop
.mode
== FPREG
)
5462 mask
= 1 << (rop
.reg
- FP0
+ 16);
5463 else if (rop
.mode
== CONTROL
5466 else if (rop
.mode
== CONTROL
5469 else if (rop
.mode
== CONTROL
5474 as_bad (_("bad register list"));
5475 ignore_rest_of_line ();
5479 S_SET_SEGMENT (line_label
, reg_section
);
5480 S_SET_VALUE (line_label
, ~mask
);
5481 symbol_set_frag (line_label
, &zero_address_frag
);
5484 mri_comment_end (stop
, stopc
);
5486 demand_empty_rest_of_line ();
5489 /* This structure is used for the MRI SAVE and RESTORE pseudo-ops. */
5493 struct save_opts
*next
;
5495 int symbols_case_sensitive
;
5503 /* FIXME: We don't save OPT S. */
5506 /* This variable holds the stack of saved options. */
5508 static struct save_opts
*save_stack
;
5510 /* The MRI SAVE pseudo-op. */
5514 int ignore ATTRIBUTE_UNUSED
;
5516 struct save_opts
*s
;
5518 s
= (struct save_opts
*) xmalloc (sizeof (struct save_opts
));
5519 s
->abspcadd
= m68k_abspcadd
;
5520 s
->symbols_case_sensitive
= symbols_case_sensitive
;
5521 s
->keep_locals
= flag_keep_locals
;
5522 s
->short_refs
= flag_short_refs
;
5523 s
->architecture
= current_architecture
;
5524 s
->quick
= m68k_quick
;
5525 s
->rel32
= m68k_rel32
;
5526 s
->listing
= listing
;
5527 s
->no_warnings
= flag_no_warnings
;
5529 s
->next
= save_stack
;
5532 demand_empty_rest_of_line ();
5535 /* The MRI RESTORE pseudo-op. */
5539 int ignore ATTRIBUTE_UNUSED
;
5541 struct save_opts
*s
;
5543 if (save_stack
== NULL
)
5545 as_bad (_("restore without save"));
5546 ignore_rest_of_line ();
5551 save_stack
= s
->next
;
5553 m68k_abspcadd
= s
->abspcadd
;
5554 symbols_case_sensitive
= s
->symbols_case_sensitive
;
5555 flag_keep_locals
= s
->keep_locals
;
5556 flag_short_refs
= s
->short_refs
;
5557 current_architecture
= s
->architecture
;
5558 m68k_quick
= s
->quick
;
5559 m68k_rel32
= s
->rel32
;
5560 listing
= s
->listing
;
5561 flag_no_warnings
= s
->no_warnings
;
5565 demand_empty_rest_of_line ();
5568 /* Types of MRI structured control directives. */
5570 enum mri_control_type
5578 /* This structure is used to stack the MRI structured control
5581 struct mri_control_info
5583 /* The directive within which this one is enclosed. */
5584 struct mri_control_info
*outer
;
5586 /* The type of directive. */
5587 enum mri_control_type type
;
5589 /* Whether an ELSE has been in an IF. */
5592 /* The add or sub statement at the end of a FOR. */
5595 /* The label of the top of a FOR or REPEAT loop. */
5598 /* The label to jump to for the next iteration, or the else
5599 expression of a conditional. */
5602 /* The label to jump to to break out of the loop, or the label past
5603 the end of a conditional. */
5607 /* The stack of MRI structured control directives. */
5609 static struct mri_control_info
*mri_control_stack
;
5611 /* The current MRI structured control directive index number, used to
5612 generate label names. */
5614 static int mri_control_index
;
5616 /* Some function prototypes. */
5618 static void mri_assemble
PARAMS ((char *));
5619 static char *mri_control_label
PARAMS ((void));
5620 static struct mri_control_info
*push_mri_control
5621 PARAMS ((enum mri_control_type
));
5622 static void pop_mri_control
PARAMS ((void));
5623 static int parse_mri_condition
PARAMS ((int *));
5624 static int parse_mri_control_operand
5625 PARAMS ((int *, char **, char **, char **, char **));
5626 static int swap_mri_condition
PARAMS ((int));
5627 static int reverse_mri_condition
PARAMS ((int));
5628 static void build_mri_control_operand
5629 PARAMS ((int, int, char *, char *, char *, char *, const char *,
5630 const char *, int));
5631 static void parse_mri_control_expression
5632 PARAMS ((char *, int, const char *, const char *, int));
5634 /* Assemble an instruction for an MRI structured control directive. */
5642 /* md_assemble expects the opcode to be in lower case. */
5643 for (s
= str
; *s
!= ' ' && *s
!= '\0'; s
++)
5645 if (isupper ((unsigned char) *s
))
5646 *s
= tolower ((unsigned char) *s
);
5652 /* Generate a new MRI label structured control directive label name. */
5655 mri_control_label ()
5659 n
= (char *) xmalloc (20);
5660 sprintf (n
, "%smc%d", FAKE_LABEL_NAME
, mri_control_index
);
5661 ++mri_control_index
;
5665 /* Create a new MRI structured control directive. */
5667 static struct mri_control_info
*
5668 push_mri_control (type
)
5669 enum mri_control_type type
;
5671 struct mri_control_info
*n
;
5673 n
= (struct mri_control_info
*) xmalloc (sizeof (struct mri_control_info
));
5677 if (type
== mri_if
|| type
== mri_while
)
5680 n
->top
= mri_control_label ();
5681 n
->next
= mri_control_label ();
5682 n
->bottom
= mri_control_label ();
5684 n
->outer
= mri_control_stack
;
5685 mri_control_stack
= n
;
5690 /* Pop off the stack of MRI structured control directives. */
5695 struct mri_control_info
*n
;
5697 n
= mri_control_stack
;
5698 mri_control_stack
= n
->outer
;
5706 /* Recognize a condition code in an MRI structured control expression. */
5709 parse_mri_condition (pcc
)
5714 know (*input_line_pointer
== '<');
5716 ++input_line_pointer
;
5717 c1
= *input_line_pointer
++;
5718 c2
= *input_line_pointer
++;
5720 if (*input_line_pointer
!= '>')
5722 as_bad (_("syntax error in structured control directive"));
5726 ++input_line_pointer
;
5734 *pcc
= (c1
<< 8) | c2
;
5739 /* Parse a single operand in an MRI structured control expression. */
5742 parse_mri_control_operand (pcc
, leftstart
, leftstop
, rightstart
, rightstop
)
5759 if (*input_line_pointer
== '<')
5761 /* It's just a condition code. */
5762 return parse_mri_condition (pcc
);
5765 /* Look ahead for the condition code. */
5766 for (s
= input_line_pointer
; *s
!= '\0'; ++s
)
5768 if (*s
== '<' && s
[1] != '\0' && s
[2] != '\0' && s
[3] == '>')
5773 as_bad (_("missing condition code in structured control directive"));
5777 *leftstart
= input_line_pointer
;
5779 if (*leftstop
> *leftstart
5780 && ((*leftstop
)[-1] == ' ' || (*leftstop
)[-1] == '\t'))
5783 input_line_pointer
= s
;
5784 if (! parse_mri_condition (pcc
))
5787 /* Look ahead for AND or OR or end of line. */
5788 for (s
= input_line_pointer
; *s
!= '\0'; ++s
)
5790 if ((strncasecmp (s
, "AND", 3) == 0
5791 && (s
[3] == '.' || ! is_part_of_name (s
[3])))
5792 || (strncasecmp (s
, "OR", 2) == 0
5793 && (s
[2] == '.' || ! is_part_of_name (s
[2]))))
5797 *rightstart
= input_line_pointer
;
5799 if (*rightstop
> *rightstart
5800 && ((*rightstop
)[-1] == ' ' || (*rightstop
)[-1] == '\t'))
5803 input_line_pointer
= s
;
5808 #define MCC(b1, b2) (((b1) << 8) | (b2))
5810 /* Swap the sense of a condition. This changes the condition so that
5811 it generates the same result when the operands are swapped. */
5814 swap_mri_condition (cc
)
5819 case MCC ('h', 'i'): return MCC ('c', 's');
5820 case MCC ('l', 's'): return MCC ('c', 'c');
5821 case MCC ('c', 'c'): return MCC ('l', 's');
5822 case MCC ('c', 's'): return MCC ('h', 'i');
5823 case MCC ('p', 'l'): return MCC ('m', 'i');
5824 case MCC ('m', 'i'): return MCC ('p', 'l');
5825 case MCC ('g', 'e'): return MCC ('l', 'e');
5826 case MCC ('l', 't'): return MCC ('g', 't');
5827 case MCC ('g', 't'): return MCC ('l', 't');
5828 case MCC ('l', 'e'): return MCC ('g', 'e');
5833 /* Reverse the sense of a condition. */
5836 reverse_mri_condition (cc
)
5841 case MCC ('h', 'i'): return MCC ('l', 's');
5842 case MCC ('l', 's'): return MCC ('h', 'i');
5843 case MCC ('c', 'c'): return MCC ('c', 's');
5844 case MCC ('c', 's'): return MCC ('c', 'c');
5845 case MCC ('n', 'e'): return MCC ('e', 'q');
5846 case MCC ('e', 'q'): return MCC ('n', 'e');
5847 case MCC ('v', 'c'): return MCC ('v', 's');
5848 case MCC ('v', 's'): return MCC ('v', 'c');
5849 case MCC ('p', 'l'): return MCC ('m', 'i');
5850 case MCC ('m', 'i'): return MCC ('p', 'l');
5851 case MCC ('g', 'e'): return MCC ('l', 't');
5852 case MCC ('l', 't'): return MCC ('g', 'e');
5853 case MCC ('g', 't'): return MCC ('l', 'e');
5854 case MCC ('l', 'e'): return MCC ('g', 't');
5859 /* Build an MRI structured control expression. This generates test
5860 and branch instructions. It goes to TRUELAB if the condition is
5861 true, and to FALSELAB if the condition is false. Exactly one of
5862 TRUELAB and FALSELAB will be NULL, meaning to fall through. QUAL
5863 is the size qualifier for the expression. EXTENT is the size to
5864 use for the branch. */
5867 build_mri_control_operand (qual
, cc
, leftstart
, leftstop
, rightstart
,
5868 rightstop
, truelab
, falselab
, extent
)
5875 const char *truelab
;
5876 const char *falselab
;
5882 if (leftstart
!= NULL
)
5884 struct m68k_op leftop
, rightop
;
5887 /* Swap the compare operands, if necessary, to produce a legal
5888 m68k compare instruction. Comparing a register operand with
5889 a non-register operand requires the register to be on the
5890 right (cmp, cmpa). Comparing an immediate value with
5891 anything requires the immediate value to be on the left
5896 (void) m68k_ip_op (leftstart
, &leftop
);
5901 (void) m68k_ip_op (rightstart
, &rightop
);
5904 if (rightop
.mode
== IMMED
5905 || ((leftop
.mode
== DREG
|| leftop
.mode
== AREG
)
5906 && (rightop
.mode
!= DREG
&& rightop
.mode
!= AREG
)))
5910 cc
= swap_mri_condition (cc
);
5912 leftstart
= rightstart
;
5915 leftstop
= rightstop
;
5920 if (truelab
== NULL
)
5922 cc
= reverse_mri_condition (cc
);
5926 if (leftstart
!= NULL
)
5928 buf
= (char *) xmalloc (20
5929 + (leftstop
- leftstart
)
5930 + (rightstop
- rightstart
));
5938 memcpy (s
, leftstart
, leftstop
- leftstart
);
5939 s
+= leftstop
- leftstart
;
5941 memcpy (s
, rightstart
, rightstop
- rightstart
);
5942 s
+= rightstop
- rightstart
;
5948 buf
= (char *) xmalloc (20 + strlen (truelab
));
5956 strcpy (s
, truelab
);
5961 /* Parse an MRI structured control expression. This generates test
5962 and branch instructions. STOP is where the expression ends. It
5963 goes to TRUELAB if the condition is true, and to FALSELAB if the
5964 condition is false. Exactly one of TRUELAB and FALSELAB will be
5965 NULL, meaning to fall through. QUAL is the size qualifier for the
5966 expression. EXTENT is the size to use for the branch. */
5969 parse_mri_control_expression (stop
, qual
, truelab
, falselab
, extent
)
5972 const char *truelab
;
5973 const char *falselab
;
5986 if (! parse_mri_control_operand (&cc
, &leftstart
, &leftstop
,
5987 &rightstart
, &rightstop
))
5993 if (strncasecmp (input_line_pointer
, "AND", 3) == 0)
5997 if (falselab
!= NULL
)
6000 flab
= mri_control_label ();
6002 build_mri_control_operand (qual
, cc
, leftstart
, leftstop
, rightstart
,
6003 rightstop
, (const char *) NULL
, flab
, extent
);
6005 input_line_pointer
+= 3;
6006 if (*input_line_pointer
!= '.'
6007 || input_line_pointer
[1] == '\0')
6011 qual
= input_line_pointer
[1];
6012 input_line_pointer
+= 2;
6015 if (! parse_mri_control_operand (&cc
, &leftstart
, &leftstop
,
6016 &rightstart
, &rightstop
))
6022 build_mri_control_operand (qual
, cc
, leftstart
, leftstop
, rightstart
,
6023 rightstop
, truelab
, falselab
, extent
);
6025 if (falselab
== NULL
)
6028 else if (strncasecmp (input_line_pointer
, "OR", 2) == 0)
6032 if (truelab
!= NULL
)
6035 tlab
= mri_control_label ();
6037 build_mri_control_operand (qual
, cc
, leftstart
, leftstop
, rightstart
,
6038 rightstop
, tlab
, (const char *) NULL
, extent
);
6040 input_line_pointer
+= 2;
6041 if (*input_line_pointer
!= '.'
6042 || input_line_pointer
[1] == '\0')
6046 qual
= input_line_pointer
[1];
6047 input_line_pointer
+= 2;
6050 if (! parse_mri_control_operand (&cc
, &leftstart
, &leftstop
,
6051 &rightstart
, &rightstop
))
6057 build_mri_control_operand (qual
, cc
, leftstart
, leftstop
, rightstart
,
6058 rightstop
, truelab
, falselab
, extent
);
6060 if (truelab
== NULL
)
6065 build_mri_control_operand (qual
, cc
, leftstart
, leftstop
, rightstart
,
6066 rightstop
, truelab
, falselab
, extent
);
6070 if (input_line_pointer
!= stop
)
6071 as_bad (_("syntax error in structured control directive"));
6074 /* Handle the MRI IF pseudo-op. This may be a structured control
6075 directive, or it may be a regular assembler conditional, depending
6084 struct mri_control_info
*n
;
6086 /* A structured control directive must end with THEN with an
6087 optional qualifier. */
6088 s
= input_line_pointer
;
6089 while (! is_end_of_line
[(unsigned char) *s
]
6090 && (! flag_mri
|| *s
!= '*'))
6093 while (s
> input_line_pointer
&& (*s
== ' ' || *s
== '\t'))
6096 if (s
- input_line_pointer
> 1
6100 if (s
- input_line_pointer
< 3
6101 || strncasecmp (s
- 3, "THEN", 4) != 0)
6105 as_bad (_("missing then"));
6106 ignore_rest_of_line ();
6110 /* It's a conditional. */
6115 /* Since this might be a conditional if, this pseudo-op will be
6116 called even if we are supported to be ignoring input. Double
6117 check now. Clobber *input_line_pointer so that ignore_input
6118 thinks that this is not a special pseudo-op. */
6119 c
= *input_line_pointer
;
6120 *input_line_pointer
= 0;
6121 if (ignore_input ())
6123 *input_line_pointer
= c
;
6124 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6125 ++input_line_pointer
;
6126 demand_empty_rest_of_line ();
6129 *input_line_pointer
= c
;
6131 n
= push_mri_control (mri_if
);
6133 parse_mri_control_expression (s
- 3, qual
, (const char *) NULL
,
6134 n
->next
, s
[1] == '.' ? s
[2] : '\0');
6137 input_line_pointer
= s
+ 3;
6139 input_line_pointer
= s
+ 1;
6143 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6144 ++input_line_pointer
;
6147 demand_empty_rest_of_line ();
6150 /* Handle the MRI else pseudo-op. If we are currently doing an MRI
6151 structured IF, associate the ELSE with the IF. Otherwise, assume
6152 it is a conditional else. */
6163 && (mri_control_stack
== NULL
6164 || mri_control_stack
->type
!= mri_if
6165 || mri_control_stack
->else_seen
))
6171 c
= *input_line_pointer
;
6172 *input_line_pointer
= 0;
6173 if (ignore_input ())
6175 *input_line_pointer
= c
;
6176 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6177 ++input_line_pointer
;
6178 demand_empty_rest_of_line ();
6181 *input_line_pointer
= c
;
6183 if (mri_control_stack
== NULL
6184 || mri_control_stack
->type
!= mri_if
6185 || mri_control_stack
->else_seen
)
6187 as_bad (_("else without matching if"));
6188 ignore_rest_of_line ();
6192 mri_control_stack
->else_seen
= 1;
6194 buf
= (char *) xmalloc (20 + strlen (mri_control_stack
->bottom
));
6197 sprintf (buf
, "bra%s %s", q
, mri_control_stack
->bottom
);
6201 colon (mri_control_stack
->next
);
6205 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6206 ++input_line_pointer
;
6209 demand_empty_rest_of_line ();
6212 /* Handle the MRI ENDI pseudo-op. */
6216 int ignore ATTRIBUTE_UNUSED
;
6218 if (mri_control_stack
== NULL
6219 || mri_control_stack
->type
!= mri_if
)
6221 as_bad (_("endi without matching if"));
6222 ignore_rest_of_line ();
6226 /* ignore_input will not return true for ENDI, so we don't need to
6227 worry about checking it again here. */
6229 if (! mri_control_stack
->else_seen
)
6230 colon (mri_control_stack
->next
);
6231 colon (mri_control_stack
->bottom
);
6237 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6238 ++input_line_pointer
;
6241 demand_empty_rest_of_line ();
6244 /* Handle the MRI BREAK pseudo-op. */
6247 s_mri_break (extent
)
6250 struct mri_control_info
*n
;
6254 n
= mri_control_stack
;
6256 && n
->type
!= mri_for
6257 && n
->type
!= mri_repeat
6258 && n
->type
!= mri_while
)
6262 as_bad (_("break outside of structured loop"));
6263 ignore_rest_of_line ();
6267 buf
= (char *) xmalloc (20 + strlen (n
->bottom
));
6270 sprintf (buf
, "bra%s %s", ex
, n
->bottom
);
6276 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6277 ++input_line_pointer
;
6280 demand_empty_rest_of_line ();
6283 /* Handle the MRI NEXT pseudo-op. */
6289 struct mri_control_info
*n
;
6293 n
= mri_control_stack
;
6295 && n
->type
!= mri_for
6296 && n
->type
!= mri_repeat
6297 && n
->type
!= mri_while
)
6301 as_bad (_("next outside of structured loop"));
6302 ignore_rest_of_line ();
6306 buf
= (char *) xmalloc (20 + strlen (n
->next
));
6309 sprintf (buf
, "bra%s %s", ex
, n
->next
);
6315 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6316 ++input_line_pointer
;
6319 demand_empty_rest_of_line ();
6322 /* Handle the MRI FOR pseudo-op. */
6328 const char *varstart
, *varstop
;
6329 const char *initstart
, *initstop
;
6330 const char *endstart
, *endstop
;
6331 const char *bystart
, *bystop
;
6335 struct mri_control_info
*n
;
6341 FOR.q var = init { TO | DOWNTO } end [ BY by ] DO.e
6345 varstart
= input_line_pointer
;
6347 /* Look for the '='. */
6348 while (! is_end_of_line
[(unsigned char) *input_line_pointer
]
6349 && *input_line_pointer
!= '=')
6350 ++input_line_pointer
;
6351 if (*input_line_pointer
!= '=')
6353 as_bad (_("missing ="));
6354 ignore_rest_of_line ();
6358 varstop
= input_line_pointer
;
6359 if (varstop
> varstart
6360 && (varstop
[-1] == ' ' || varstop
[-1] == '\t'))
6363 ++input_line_pointer
;
6365 initstart
= input_line_pointer
;
6367 /* Look for TO or DOWNTO. */
6370 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6372 if (strncasecmp (input_line_pointer
, "TO", 2) == 0
6373 && ! is_part_of_name (input_line_pointer
[2]))
6375 initstop
= input_line_pointer
;
6376 input_line_pointer
+= 2;
6379 if (strncasecmp (input_line_pointer
, "DOWNTO", 6) == 0
6380 && ! is_part_of_name (input_line_pointer
[6]))
6382 initstop
= input_line_pointer
;
6384 input_line_pointer
+= 6;
6387 ++input_line_pointer
;
6389 if (initstop
== NULL
)
6391 as_bad (_("missing to or downto"));
6392 ignore_rest_of_line ();
6395 if (initstop
> initstart
6396 && (initstop
[-1] == ' ' || initstop
[-1] == '\t'))
6400 endstart
= input_line_pointer
;
6402 /* Look for BY or DO. */
6405 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6407 if (strncasecmp (input_line_pointer
, "BY", 2) == 0
6408 && ! is_part_of_name (input_line_pointer
[2]))
6410 endstop
= input_line_pointer
;
6412 input_line_pointer
+= 2;
6415 if (strncasecmp (input_line_pointer
, "DO", 2) == 0
6416 && (input_line_pointer
[2] == '.'
6417 || ! is_part_of_name (input_line_pointer
[2])))
6419 endstop
= input_line_pointer
;
6420 input_line_pointer
+= 2;
6423 ++input_line_pointer
;
6425 if (endstop
== NULL
)
6427 as_bad (_("missing do"));
6428 ignore_rest_of_line ();
6431 if (endstop
> endstart
6432 && (endstop
[-1] == ' ' || endstop
[-1] == '\t'))
6438 bystop
= bystart
+ 2;
6443 bystart
= input_line_pointer
;
6447 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6449 if (strncasecmp (input_line_pointer
, "DO", 2) == 0
6450 && (input_line_pointer
[2] == '.'
6451 || ! is_part_of_name (input_line_pointer
[2])))
6453 bystop
= input_line_pointer
;
6454 input_line_pointer
+= 2;
6457 ++input_line_pointer
;
6461 as_bad (_("missing do"));
6462 ignore_rest_of_line ();
6465 if (bystop
> bystart
6466 && (bystop
[-1] == ' ' || bystop
[-1] == '\t'))
6470 if (*input_line_pointer
!= '.')
6474 extent
= input_line_pointer
[1];
6475 input_line_pointer
+= 2;
6478 /* We have fully parsed the FOR operands. Now build the loop. */
6480 n
= push_mri_control (mri_for
);
6482 buf
= (char *) xmalloc (50 + (input_line_pointer
- varstart
));
6493 memcpy (s
, initstart
, initstop
- initstart
);
6494 s
+= initstop
- initstart
;
6496 memcpy (s
, varstart
, varstop
- varstart
);
6497 s
+= varstop
- varstart
;
6511 memcpy (s
, endstart
, endstop
- endstart
);
6512 s
+= endstop
- endstart
;
6514 memcpy (s
, varstart
, varstop
- varstart
);
6515 s
+= varstop
- varstart
;
6523 sprintf (buf
, "blt%s %s", ex
, n
->bottom
);
6525 sprintf (buf
, "bgt%s %s", ex
, n
->bottom
);
6528 /* Put together the add or sub instruction used by ENDF. */
6538 memcpy (s
, bystart
, bystop
- bystart
);
6539 s
+= bystop
- bystart
;
6541 memcpy (s
, varstart
, varstop
- varstart
);
6542 s
+= varstop
- varstart
;
6548 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6549 ++input_line_pointer
;
6552 demand_empty_rest_of_line ();
6555 /* Handle the MRI ENDF pseudo-op. */
6559 int ignore ATTRIBUTE_UNUSED
;
6561 if (mri_control_stack
== NULL
6562 || mri_control_stack
->type
!= mri_for
)
6564 as_bad (_("endf without for"));
6565 ignore_rest_of_line ();
6569 colon (mri_control_stack
->next
);
6571 mri_assemble (mri_control_stack
->incr
);
6573 sprintf (mri_control_stack
->incr
, "bra %s", mri_control_stack
->top
);
6574 mri_assemble (mri_control_stack
->incr
);
6576 free (mri_control_stack
->incr
);
6578 colon (mri_control_stack
->bottom
);
6584 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6585 ++input_line_pointer
;
6588 demand_empty_rest_of_line ();
6591 /* Handle the MRI REPEAT pseudo-op. */
6594 s_mri_repeat (ignore
)
6595 int ignore ATTRIBUTE_UNUSED
;
6597 struct mri_control_info
*n
;
6599 n
= push_mri_control (mri_repeat
);
6603 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6604 ++input_line_pointer
;
6606 demand_empty_rest_of_line ();
6609 /* Handle the MRI UNTIL pseudo-op. */
6617 if (mri_control_stack
== NULL
6618 || mri_control_stack
->type
!= mri_repeat
)
6620 as_bad (_("until without repeat"));
6621 ignore_rest_of_line ();
6625 colon (mri_control_stack
->next
);
6627 for (s
= input_line_pointer
; ! is_end_of_line
[(unsigned char) *s
]; s
++)
6630 parse_mri_control_expression (s
, qual
, (const char *) NULL
,
6631 mri_control_stack
->top
, '\0');
6633 colon (mri_control_stack
->bottom
);
6635 input_line_pointer
= s
;
6641 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6642 ++input_line_pointer
;
6645 demand_empty_rest_of_line ();
6648 /* Handle the MRI WHILE pseudo-op. */
6656 struct mri_control_info
*n
;
6658 s
= input_line_pointer
;
6659 while (! is_end_of_line
[(unsigned char) *s
]
6660 && (! flag_mri
|| *s
!= '*'))
6663 while (*s
== ' ' || *s
== '\t')
6665 if (s
- input_line_pointer
> 1
6668 if (s
- input_line_pointer
< 2
6669 || strncasecmp (s
- 1, "DO", 2) != 0)
6671 as_bad (_("missing do"));
6672 ignore_rest_of_line ();
6676 n
= push_mri_control (mri_while
);
6680 parse_mri_control_expression (s
- 1, qual
, (const char *) NULL
, n
->bottom
,
6681 s
[1] == '.' ? s
[2] : '\0');
6683 input_line_pointer
= s
+ 1;
6684 if (*input_line_pointer
== '.')
6685 input_line_pointer
+= 2;
6689 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6690 ++input_line_pointer
;
6693 demand_empty_rest_of_line ();
6696 /* Handle the MRI ENDW pseudo-op. */
6700 int ignore ATTRIBUTE_UNUSED
;
6704 if (mri_control_stack
== NULL
6705 || mri_control_stack
->type
!= mri_while
)
6707 as_bad (_("endw without while"));
6708 ignore_rest_of_line ();
6712 buf
= (char *) xmalloc (20 + strlen (mri_control_stack
->next
));
6713 sprintf (buf
, "bra %s", mri_control_stack
->next
);
6717 colon (mri_control_stack
->bottom
);
6723 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
6724 ++input_line_pointer
;
6727 demand_empty_rest_of_line ();
6732 * Invocation line includes a switch not recognized by the base assembler.
6733 * See if it's a processor-specific option. These are:
6735 * -[A]m[c]68000, -[A]m[c]68008, -[A]m[c]68010, -[A]m[c]68020, -[A]m[c]68030, -[A]m[c]68040
6736 * -[A]m[c]68881, -[A]m[c]68882, -[A]m[c]68851
6737 * Select the architecture. Instructions or features not
6738 * supported by the selected architecture cause fatal
6739 * errors. More than one may be specified. The default is
6740 * -m68020 -m68851 -m68881. Note that -m68008 is a synonym
6741 * for -m68000, and -m68882 is a synonym for -m68881.
6742 * -[A]m[c]no-68851, -[A]m[c]no-68881
6743 * Don't accept 688?1 instructions. (The "c" is kind of silly,
6744 * so don't use or document it, but that's the way the parsing
6747 * -pic Indicates PIC.
6748 * -k Indicates PIC. (Sun 3 only.)
6749 * --pcrel Never turn PC-relative branches into absolute jumps.
6752 * Permit `|' to be used in expressions.
6757 CONST
char *md_shortopts
= "lSA:m:kQ:V";
6759 CONST
char *md_shortopts
= "lSA:m:k";
6762 struct option md_longopts
[] = {
6763 #define OPTION_PIC (OPTION_MD_BASE)
6764 {"pic", no_argument
, NULL
, OPTION_PIC
},
6765 #define OPTION_REGISTER_PREFIX_OPTIONAL (OPTION_MD_BASE + 1)
6766 {"register-prefix-optional", no_argument
, NULL
,
6767 OPTION_REGISTER_PREFIX_OPTIONAL
},
6768 #define OPTION_BITWISE_OR (OPTION_MD_BASE + 2)
6769 {"bitwise-or", no_argument
, NULL
, OPTION_BITWISE_OR
},
6770 #define OPTION_BASE_SIZE_DEFAULT_16 (OPTION_MD_BASE + 3)
6771 {"base-size-default-16", no_argument
, NULL
, OPTION_BASE_SIZE_DEFAULT_16
},
6772 #define OPTION_BASE_SIZE_DEFAULT_32 (OPTION_MD_BASE + 4)
6773 {"base-size-default-32", no_argument
, NULL
, OPTION_BASE_SIZE_DEFAULT_32
},
6774 #define OPTION_DISP_SIZE_DEFAULT_16 (OPTION_MD_BASE + 5)
6775 {"disp-size-default-16", no_argument
, NULL
, OPTION_DISP_SIZE_DEFAULT_16
},
6776 #define OPTION_DISP_SIZE_DEFAULT_32 (OPTION_MD_BASE + 6)
6777 {"disp-size-default-32", no_argument
, NULL
, OPTION_DISP_SIZE_DEFAULT_32
},
6778 #define OPTION_PCREL (OPTION_MD_BASE + 7)
6779 {"pcrel", no_argument
, NULL
, OPTION_PCREL
},
6780 {NULL
, no_argument
, NULL
, 0}
6782 size_t md_longopts_size
= sizeof (md_longopts
);
6785 md_parse_option (c
, arg
)
6791 case 'l': /* -l means keep external to 2 bit offset
6792 rather than 16 bit one */
6793 flag_short_refs
= 1;
6796 case 'S': /* -S means that jbsr's always turn into
6798 flag_long_jumps
= 1;
6801 case OPTION_PCREL
: /* --pcrel means never turn PC-relative
6802 branches into absolute jumps. */
6803 flag_keep_pcrel
= 1;
6809 /* intentional fall-through */
6812 if (arg
[0] == 'n' && arg
[1] == 'o' && arg
[2] == '-')
6816 const char *oarg
= arg
;
6822 if (arg
[0] == 'c' && arg
[1] == '6')
6825 for (i
= 0; i
< n_archs
; i
++)
6826 if (!strcmp (arg
, archs
[i
].name
))
6831 as_bad (_("unrecognized option `%s'"), oarg
);
6834 arch
= archs
[i
].arch
;
6837 else if (arch
== m68851
)
6846 if (arg
[0] == 'c' && arg
[1] == '6')
6849 for (i
= 0; i
< n_archs
; i
++)
6850 if (!strcmp (arg
, archs
[i
].name
))
6852 unsigned long arch
= archs
[i
].arch
;
6853 if (cpu_of_arch (arch
))
6854 /* It's a cpu spec. */
6856 current_architecture
&= ~m68000up
;
6857 current_architecture
|= arch
;
6859 else if (arch
== m68881
)
6861 current_architecture
|= m68881
;
6864 else if (arch
== m68851
)
6866 current_architecture
|= m68851
;
6876 as_bad (_("unrecognized architecture specification `%s'"), arg
);
6885 break; /* -pic, Position Independent Code */
6887 case OPTION_REGISTER_PREFIX_OPTIONAL
:
6888 flag_reg_prefix_optional
= 1;
6889 reg_prefix_optional_seen
= 1;
6892 /* -V: SVR4 argument to print version ID. */
6894 print_version_id ();
6897 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
6898 should be emitted or not. FIXME: Not implemented. */
6902 case OPTION_BITWISE_OR
:
6907 n
= (char *) xmalloc (strlen (m68k_comment_chars
) + 1);
6909 for (s
= m68k_comment_chars
; *s
!= '\0'; s
++)
6913 m68k_comment_chars
= n
;
6917 case OPTION_BASE_SIZE_DEFAULT_16
:
6918 m68k_index_width_default
= SIZE_WORD
;
6921 case OPTION_BASE_SIZE_DEFAULT_32
:
6922 m68k_index_width_default
= SIZE_LONG
;
6925 case OPTION_DISP_SIZE_DEFAULT_16
:
6927 m68k_rel32_from_cmdline
= 1;
6930 case OPTION_DISP_SIZE_DEFAULT_32
:
6932 m68k_rel32_from_cmdline
= 1;
6943 md_show_usage (stream
)
6946 fprintf (stream
, _("\
6948 -l use 1 word for refs to undefined symbols [default 2]\n\
6949 -m68000 | -m68008 | -m68010 | -m68020 | -m68030 | -m68040 | -m68060\n\
6950 | -m68302 | -m68331 | -m68332 | -m68333 | -m68340 | -m68360\n\
6951 | -mcpu32 | -m5200\n\
6952 specify variant of 680X0 architecture [default 68020]\n\
6953 -m68881 | -m68882 | -mno-68881 | -mno-68882\n\
6954 target has/lacks floating-point coprocessor\n\
6955 [default yes for 68020, 68030, and cpu32]\n"));
6956 fprintf (stream
, _("\
6957 -m68851 | -mno-68851\n\
6958 target has/lacks memory-management unit coprocessor\n\
6959 [default yes for 68020 and up]\n\
6960 -pic, -k generate position independent code\n\
6961 -S turn jbsr into jsr\n\
6962 --pcrel never turn PC-relative branches into absolute jumps\n\
6963 --register-prefix-optional\n\
6964 recognize register names without prefix character\n\
6965 --bitwise-or do not treat `|' as a comment character\n"));
6966 fprintf (stream
, _("\
6967 --base-size-default-16 base reg without size is 16 bits\n\
6968 --base-size-default-32 base reg without size is 32 bits (default)\n\
6969 --disp-size-default-16 displacement with unknown size is 16 bits\n\
6970 --disp-size-default-32 displacement with unknown size is 32 bits (default)\n"));
6975 /* TEST2: Test md_assemble() */
6976 /* Warning, this routine probably doesn't work anymore */
6980 struct m68k_it the_ins
;
6988 if (!gets (buf
) || !*buf
)
6990 if (buf
[0] == '|' || buf
[1] == '.')
6992 for (cp
= buf
; *cp
; cp
++)
6997 memset (&the_ins
, '\0', sizeof (the_ins
));
6998 m68k_ip (&the_ins
, buf
);
7001 printf (_("Error %s in %s\n"), the_ins
.error
, buf
);
7005 printf (_("Opcode(%d.%s): "), the_ins
.numo
, the_ins
.args
);
7006 for (n
= 0; n
< the_ins
.numo
; n
++)
7007 printf (" 0x%x", the_ins
.opcode
[n
] & 0xffff);
7009 print_the_insn (&the_ins
.opcode
[0], stdout
);
7010 (void) putchar ('\n');
7012 for (n
= 0; n
< strlen (the_ins
.args
) / 2; n
++)
7014 if (the_ins
.operands
[n
].error
)
7016 printf ("op%d Error %s in %s\n", n
, the_ins
.operands
[n
].error
, buf
);
7019 printf ("mode %d, reg %d, ", the_ins
.operands
[n
].mode
, the_ins
.operands
[n
].reg
);
7020 if (the_ins
.operands
[n
].b_const
)
7021 printf ("Constant: '%.*s', ", 1 + the_ins
.operands
[n
].e_const
- the_ins
.operands
[n
].b_const
, the_ins
.operands
[n
].b_const
);
7022 printf ("ireg %d, isiz %d, imul %d, ", the_ins
.operands
[n
].ireg
, the_ins
.operands
[n
].isiz
, the_ins
.operands
[n
].imul
);
7023 if (the_ins
.operands
[n
].b_iadd
)
7024 printf ("Iadd: '%.*s',", 1 + the_ins
.operands
[n
].e_iadd
- the_ins
.operands
[n
].b_iadd
, the_ins
.operands
[n
].b_iadd
);
7025 (void) putchar ('\n');
7037 while (*str
&& *str
!= ' ')
7039 if (str
[-1] == ':' || str
[1] == '=')
7046 /* Possible states for relaxation:
7048 0 0 branch offset byte (bra, etc)
7052 1 0 indexed offsets byte a0@(32,d4:w:1) etc
7056 2 0 two-offset index word-word a0@(32,d4)@(45) etc
7063 /* We have no need to default values of symbols. */
7066 md_undefined_symbol (name
)
7067 char *name ATTRIBUTE_UNUSED
;
7072 /* Round up a section size to the appropriate boundary. */
7074 md_section_align (segment
, size
)
7075 segT segment ATTRIBUTE_UNUSED
;
7079 #ifdef BFD_ASSEMBLER
7080 /* For a.out, force the section size to be aligned. If we don't do
7081 this, BFD will align it for us, but it will not write out the
7082 final bytes of the section. This may be a bug in BFD, but it is
7083 easier to fix it here since that is how the other a.out targets
7087 align
= bfd_get_section_alignment (stdoutput
, segment
);
7088 size
= ((size
+ (1 << align
) - 1) & ((valueT
) -1 << align
));
7095 /* Exactly what point is a PC-relative offset relative TO?
7096 On the 68k, it is relative to the address of the first extension
7097 word. The difference between the addresses of the offset and the
7098 first extension word is stored in fx_pcrel_adjust. */
7100 md_pcrel_from (fixP
)
7105 /* Because fx_pcrel_adjust is a char, and may be unsigned, we store
7107 adjust
= fixP
->fx_pcrel_adjust
;
7110 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
- adjust
;
7113 #ifndef BFD_ASSEMBLER
7117 tc_coff_symbol_emit_hook (ignore
)
7118 symbolS
*ignore ATTRIBUTE_UNUSED
;
7123 tc_coff_sizemachdep (frag
)
7126 switch (frag
->fr_subtype
& 0x3)
7143 void m68k_elf_final_processing()
7145 /* Set file-specific flags if this is a cpu32 processor */
7146 if (cpu_of_arch (current_architecture
) & cpu32
)
7147 elf_elfheader (stdoutput
)->e_flags
|= EF_CPU32
;