1 /* m88k.c -- Assembler for the Motorola 88000
2 Contributed by Devon Bowen of Buffalo University
3 and Torbjorn Granlund of the Swedish Institute of Computer Science.
4 Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1999,
6 Free Software Foundation, Inc.
8 This file is part of GAS, the GNU Assembler.
10 GAS is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GAS is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GAS; see the file COPYING. If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
28 #include "m88k-opcode.h"
30 struct field_val_assoc
36 struct field_val_assoc cr_regs
[] =
63 struct field_val_assoc fcr_regs
[] =
81 struct field_val_assoc cmpslot
[] =
83 /* Integer Floating point */
94 {"lo", 10}, {"in", 10},
95 {"hs", 11}, {"ob", 11},
96 {"be", 12}, {"ue", 12},
97 {"nb", 13}, {"lg", 13},
98 {"he", 14}, {"ug", 14},
99 {"nh", 15}, {"ule", 15},
106 struct field_val_assoc cndmsk
[] =
120 unsigned long opcode
;
122 enum reloc_type reloc
;
125 static char *get_bf
PARAMS ((char *param
, unsigned *valp
));
126 static char *get_cmp
PARAMS ((char *param
, unsigned *valp
));
127 static char *get_cnd
PARAMS ((char *param
, unsigned *valp
));
128 static char *get_cr
PARAMS ((char *param
, unsigned *regnop
));
129 static char *get_fcr
PARAMS ((char *param
, unsigned *regnop
));
130 static char *get_imm16
PARAMS ((char *param
, struct m88k_insn
*insn
));
131 static char *get_o6
PARAMS ((char *param
, unsigned *valp
));
132 static char *get_reg
PARAMS ((char *param
, unsigned *regnop
, int reg_prefix
));
133 static char *get_vec9
PARAMS ((char *param
, unsigned *valp
));
134 static char *getval
PARAMS ((char *param
, unsigned int *valp
));
136 static char *get_pcr
PARAMS ((char *param
, struct m88k_insn
*insn
,
137 enum reloc_type reloc
));
139 static int calcop
PARAMS ((struct m88k_opcode
*format
,
140 char *param
, struct m88k_insn
*insn
));
143 static struct hash_control
*op_hash
= NULL
;
145 /* These bits should be turned off in the first address of every segment */
146 int md_seg_align
= 7;
148 /* These chars start a comment anywhere in a source file (except inside
150 const char comment_chars
[] = ";";
152 /* These chars only start a comment at the beginning of a line. */
153 const char line_comment_chars
[] = "#";
155 const char line_separator_chars
[] = "";
157 /* Chars that can be used to separate mant from exp in floating point nums */
158 const char EXP_CHARS
[] = "eE";
160 /* Chars that mean this number is a floating point constant */
161 /* as in 0f123.456 */
162 /* or 0H1.234E-12 (see exp chars above) */
163 const char FLT_CHARS
[] = "dDfF";
165 extern void float_cons (), cons (), s_globl (), s_space (),
166 s_set (), s_lcomm ();
168 const pseudo_typeS md_pseudo_table
[] =
170 {"align", s_align_bytes
, 4},
172 {"dfloat", float_cons
, 'd'},
173 {"ffloat", float_cons
, 'f'},
174 {"global", s_globl
, 0},
177 {"string", stringer
, 0},
179 /* Force set to be treated as an instruction. */
188 const char *retval
= NULL
;
191 /* initialize hash table */
193 op_hash
= hash_new ();
195 /* loop until you see the end of the list */
197 while (*m88k_opcodes
[i
].name
)
199 char *name
= m88k_opcodes
[i
].name
;
201 /* hash each mnemonic and record its position */
203 retval
= hash_insert (op_hash
, name
, &m88k_opcodes
[i
]);
206 as_fatal (_("Can't hash instruction '%s':%s"),
207 m88k_opcodes
[i
].name
, retval
);
209 /* skip to next unique mnemonic or end of list */
211 for (i
++; !strcmp (m88k_opcodes
[i
].name
, name
); i
++)
216 CONST
char *md_shortopts
= "";
217 struct option md_longopts
[] = {
218 {NULL
, no_argument
, NULL
, 0}
220 size_t md_longopts_size
= sizeof (md_longopts
);
223 md_parse_option (c
, arg
)
231 md_show_usage (stream
)
240 char *param
, *thisfrag
;
242 struct m88k_opcode
*format
;
243 struct m88k_insn insn
;
247 /* skip over instruction to find parameters */
249 for (param
= op
; *param
!= 0 && !isspace (*param
); param
++)
254 /* try to find the instruction in the hash table */
256 if ((format
= (struct m88k_opcode
*) hash_find (op_hash
, op
)) == NULL
)
258 as_bad (_("Invalid mnemonic '%s'"), op
);
262 /* try parsing this instruction into insn */
264 insn
.exp
.X_add_symbol
= 0;
265 insn
.exp
.X_op_symbol
= 0;
266 insn
.exp
.X_add_number
= 0;
267 insn
.exp
.X_op
= O_illegal
;
268 insn
.reloc
= NO_RELOC
;
270 while (!calcop (format
, param
, &insn
))
272 /* if it doesn't parse try the next instruction */
274 if (!strcmp (format
[0].name
, format
[1].name
))
278 as_fatal (_("Parameter syntax error"));
283 /* grow the current frag and plop in the opcode */
285 thisfrag
= frag_more (4);
286 md_number_to_chars (thisfrag
, insn
.opcode
, 4);
288 /* if this instruction requires labels mark it for later */
297 fix_new_exp (frag_now
,
298 thisfrag
- frag_now
->fr_literal
+ 2,
306 fix_new_exp (frag_now
,
307 thisfrag
- frag_now
->fr_literal
,
315 fix_new_exp (frag_now
,
316 thisfrag
- frag_now
->fr_literal
+ 2,
324 fix_new_exp (frag_now
,
325 thisfrag
- frag_now
->fr_literal
,
333 as_fatal (_("Unknown relocation type"));
339 calcop (format
, param
, insn
)
340 struct m88k_opcode
*format
;
342 struct m88k_insn
*insn
;
344 char *fmt
= format
->op_spec
;
348 int reg_prefix
= 'r';
350 insn
->opcode
= format
->opcode
;
361 insn
->opcode
|= opcode
;
362 return (*param
== 0 || *param
== '\n');
370 param
= get_reg (param
, &val
, reg_prefix
);
376 param
= get_o6 (param
, &val
);
377 opcode
|= ((val
>> 2) << 7);
385 param
= get_reg (param
, &val
, reg_prefix
);
391 param
= get_reg (param
, &val
, reg_prefix
);
397 param
= get_reg (param
, &val
, 'r');
398 opcode
|= (val
<< 16) | val
;
402 param
= get_imm16 (param
, insn
);
406 param
= get_bf (param
, &val
);
411 param
= get_pcr (param
, insn
, RELOC_PC16
);
415 param
= get_pcr (param
, insn
, RELOC_PC26
);
419 param
= get_cmp (param
, &val
);
424 param
= get_cnd (param
, &val
);
429 param
= get_cr (param
, &val
);
434 param
= get_fcr (param
, &val
);
439 param
= get_vec9 (param
, &val
);
444 /* Having this here repeats the warning somtimes.
445 But can't we stand that? */
446 as_warn (_("Use of obsolete instruction"));
453 match_name (param
, assoc_tab
, valp
)
455 struct field_val_assoc
*assoc_tab
;
464 name
= assoc_tab
[i
].name
;
467 name_len
= strlen (name
);
468 if (!strncmp (param
, name
, name_len
))
470 *valp
= assoc_tab
[i
].val
;
471 return param
+ name_len
;
477 get_reg (param
, regnop
, reg_prefix
)
488 regno
= *param
++ - '0';
499 regno
= regno
* 10 + c
;
514 else if (c
== 's' && param
[0] == 'p')
524 get_imm16 (param
, insn
)
526 struct m88k_insn
*insn
;
528 enum reloc_type reloc
= NO_RELOC
;
532 if (!strncmp (param
, "hi16", 4) && !isalnum (param
[4]))
537 else if (!strncmp (param
, "lo16", 4) && !isalnum (param
[4]))
542 else if (!strncmp (param
, "iw16", 4) && !isalnum (param
[4]))
548 save_ptr
= input_line_pointer
;
549 input_line_pointer
= param
;
550 expression (&insn
->exp
);
551 param
= input_line_pointer
;
552 input_line_pointer
= save_ptr
;
554 val
= insn
->exp
.X_add_number
;
556 if (insn
->exp
.X_op
== O_constant
)
558 /* Insert the value now, and reset reloc to NO_RELOC. */
559 if (reloc
== NO_RELOC
)
561 /* Warn about too big expressions if not surrounded by xx16. */
563 as_warn (_("Expression truncated to 16 bits"));
566 if (reloc
== RELOC_HI16
)
569 insn
->opcode
|= val
& 0xffff;
572 else if (reloc
== NO_RELOC
)
573 /* We accept a symbol even without lo16, hi16, etc, and assume
574 lo16 was intended. */
583 get_pcr (param
, insn
, reloc
)
585 struct m88k_insn
*insn
;
586 enum reloc_type reloc
;
588 char *saveptr
, *saveparam
;
590 saveptr
= input_line_pointer
;
591 input_line_pointer
= param
;
593 expression (&insn
->exp
);
595 saveparam
= input_line_pointer
;
596 input_line_pointer
= saveptr
;
598 /* Botch: We should relocate now if O_constant. */
605 get_cmp (param
, valp
)
614 param
= match_name (param
, cmpslot
, valp
);
621 save_ptr
= input_line_pointer
;
622 input_line_pointer
= param
;
623 val
= get_absolute_expression ();
624 param
= input_line_pointer
;
625 input_line_pointer
= save_ptr
;
629 as_warn (_("Expression truncated to 5 bits"));
639 get_cnd (param
, valp
)
645 if (isdigit (*param
))
647 param
= getval (param
, &val
);
651 as_warn (_("Expression truncated to 5 bits"));
657 if (isupper (*param
))
658 *param
= tolower (*param
);
660 if (isupper (param
[1]))
661 param
[1] = tolower (param
[1]);
663 param
= match_name (param
, cndmsk
, valp
);
692 else if (c
== bc
&& depth
<= 0)
699 get_bf_offset_expression (param
, offsetp
)
705 if (isalpha (param
[0]))
707 if (isupper (param
[0]))
708 param
[0] = tolower (param
[0]);
709 if (isupper (param
[1]))
710 param
[1] = tolower (param
[1]);
712 param
= match_name (param
, cmpslot
, offsetp
);
718 input_line_pointer
= param
;
719 offset
= get_absolute_expression ();
720 param
= input_line_pointer
;
737 xp
= get_bf2 (param
, '<');
739 save_ptr
= input_line_pointer
;
740 input_line_pointer
= param
;
743 /* We did not find '<'. We have an offset (width implicitly 32). */
744 param
= get_bf_offset_expression (param
, &offset
);
745 input_line_pointer
= save_ptr
;
751 *xp
++ = 0; /* Overwrite the '<' */
752 param
= get_bf2 (xp
, '>');
755 *param
++ = 0; /* Overwrite the '>' */
757 width
= get_absolute_expression ();
758 xp
= get_bf_offset_expression (xp
, &offset
);
759 input_line_pointer
= save_ptr
;
765 *valp
= ((width
% 32) << 5) | (offset
% 32);
771 get_cr (param
, regnop
)
778 if (!strncmp (param
, "cr", 2))
782 regno
= *param
++ - '0';
793 regno
= regno
* 10 + c
;
809 param
= match_name (param
, cr_regs
, regnop
);
815 get_fcr (param
, regnop
)
822 if (!strncmp (param
, "fcr", 3))
826 regno
= *param
++ - '0';
837 regno
= regno
* 10 + c
;
853 param
= match_name (param
, fcr_regs
, regnop
);
859 get_vec9 (param
, valp
)
866 save_ptr
= input_line_pointer
;
867 input_line_pointer
= param
;
868 val
= get_absolute_expression ();
869 param
= input_line_pointer
;
870 input_line_pointer
= save_ptr
;
873 as_warn (_("Expression truncated to 9 bits"));
875 *valp
= val
% (1 << 9);
888 save_ptr
= input_line_pointer
;
889 input_line_pointer
= param
;
890 val
= get_absolute_expression ();
891 param
= input_line_pointer
;
892 input_line_pointer
= save_ptr
;
895 as_warn (_("Removed lower 2 bits of expression"));
903 (isdigit (z) ? (z) - '0' : \
904 islower (z) ? (z) - 'a' + 10 : \
905 isupper (z) ? (z) - 'A' + 10 : -1)
912 unsigned int val
= 0;
919 if (c
== 'x' || c
== 'X')
955 md_number_to_chars (buf
, val
, nbytes
)
960 number_to_chars_bigendian (buf
, val
, nbytes
);
965 /* This routine is never called. What is it for?
966 Ian Taylor, Cygnus Support 13 Jul 1993 */
969 md_number_to_imm (buf
, val
, nbytes
, fixP
, seg_type
)
976 if (seg_type
!= N_TEXT
|| fixP
->fx_r_type
== NO_RELOC
)
995 switch (fixP
->fx_r_type
)
1020 buf
[0] |= (val
>> 26) & 0x03;
1034 as_fatal (_("Bad relocation type"));
1042 md_number_to_disp (buf
, val
, nbytes
)
1047 as_fatal (_("md_number_to_disp not defined"));
1048 md_number_to_chars (buf
, val
, nbytes
);
1052 md_number_to_field (buf
, val
, nbytes
)
1057 as_fatal (_("md_number_to_field not defined"));
1058 md_number_to_chars (buf
, val
, nbytes
);
1061 #define MAX_LITTLENUMS 6
1063 /* Turn a string in input_line_pointer into a floating point constant of type
1064 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1065 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1068 md_atof (type
, litP
, sizeP
)
1074 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
1075 LITTLENUM_TYPE
*wordP
;
1106 return _("Bad call to MD_ATOF()");
1108 t
= atof_ieee (input_line_pointer
, type
, words
);
1110 input_line_pointer
= t
;
1112 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
1113 for (wordP
= words
; prec
--;)
1115 md_number_to_chars (litP
, (long) (*wordP
++), sizeof (LITTLENUM_TYPE
));
1116 litP
+= sizeof (LITTLENUM_TYPE
);
1121 int md_short_jump_size
= 4;
1124 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1126 addressT from_addr
, to_addr
;
1130 ptr
[0] = (char) 0xc0;
1135 ptr
- frag
->fr_literal
,
1140 RELOC_PC26
); /* Botch: Shouldn't this be RELOC_PC16? */
1143 int md_long_jump_size
= 4;
1146 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
1148 addressT from_addr
, to_addr
;
1152 ptr
[0] = (char) 0xc0;
1157 ptr
- frag
->fr_literal
,
1166 md_estimate_size_before_relax (fragP
, segment_type
)
1170 as_fatal (_("Relaxation should never occur"));
1176 /* As far as I can tell, this routine is never called. What is it
1178 Ian Taylor, Cygnus Support 13 Jul 1993 */
1181 * Risc relocations are completely different, so it needs
1182 * this machine dependent routine to emit them.
1185 emit_relocations (fixP
, segment_address_in_file
)
1187 relax_addressT segment_address_in_file
;
1189 struct reloc_info_m88k ri
;
1191 extern char *next_object_file_charP
;
1193 bzero ((char *) &ri
, sizeof (ri
));
1194 for (; fixP
; fixP
= fixP
->fx_next
)
1196 if (fixP
->fx_r_type
>= NO_RELOC
)
1198 fprintf (stderr
, "fixP->fx_r_type = %d\n", fixP
->fx_r_type
);
1202 if ((symbolP
= fixP
->fx_addsy
) != NULL
)
1204 ri
.r_address
= fixP
->fx_frag
->fr_address
+
1205 fixP
->fx_where
- segment_address_in_file
;
1206 if ((symbolP
->sy_type
& N_TYPE
) == N_UNDF
)
1209 ri
.r_symbolnum
= symbolP
->sy_number
;
1214 ri
.r_symbolnum
= symbolP
->sy_type
& N_TYPE
;
1216 if (symbolP
&& symbol_get_frag (symbolP
))
1218 ri
.r_addend
= symbol_get_frag (symbolP
)->fr_address
;
1220 ri
.r_type
= fixP
->fx_r_type
;
1223 ri
.r_addend
-= ri
.r_address
;
1227 ri
.r_addend
= fixP
->fx_addnumber
;
1230 append (&next_object_file_charP
, (char *) &ri
, sizeof (ri
));
1239 /* This routine can be subsumed by s_lcomm in read.c.
1240 Ian Taylor, Cygnus Support 13 Jul 1993 */
1248 int temp
, bss_align
;
1251 name
= input_line_pointer
;
1252 c
= get_symbol_end ();
1253 p
= input_line_pointer
;
1256 if (*input_line_pointer
!= ',')
1258 as_warn (_("Expected comma after name"));
1259 ignore_rest_of_line ();
1262 input_line_pointer
++;
1263 if ((temp
= get_absolute_expression ()) < 0)
1265 as_warn (_("BSS length (%d.) <0! Ignored."), temp
);
1266 ignore_rest_of_line ();
1270 symbolP
= symbol_find_or_make (name
);
1272 if (*input_line_pointer
== ',')
1274 input_line_pointer
++;
1275 bss_align
= get_absolute_expression ();
1280 if (!S_IS_DEFINED(symbolP
)
1281 || S_GET_SEGMENT(symbolP
) == SEG_BSS
)
1286 segT current_seg
= now_seg
;
1287 subsegT current_subseg
= now_subseg
;
1289 subseg_set (SEG_BSS
, 1); /* switch to bss */
1292 frag_align (bss_align
, 0, 0);
1294 /* detach from old frag */
1295 if (symbolP
->sy_type
== N_BSS
&& symbol_get_frag (symbolP
) != NULL
)
1296 symbol_get_frag (symbolP
)->fr_symbol
= NULL
;
1298 symbol_set_frag (symbolP
, frag_now
);
1299 p
= frag_var (rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
1300 (offsetT
) temp
, (char *)0);
1302 S_SET_SEGMENT (symbolP
, SEG_BSS
);
1304 subseg_set (current_seg
, current_subseg
);
1309 as_warn (_("Ignoring attempt to re-define symbol %s."), name
);
1312 while (!is_end_of_line
[(unsigned char) *input_line_pointer
])
1314 input_line_pointer
++;
1322 /* These functions are needed if we are linking with obj-coffbfd.c.
1323 That file may be replaced by a more BFD oriented version at some
1324 point. If that happens, these functions should be rexamined.
1326 Ian Lance Taylor, Cygnus Support, 13 July 1993. */
1328 /* Given a fixS structure (created by a call to fix_new, above),
1329 return the BFD relocation type to use for it. */
1332 tc_coff_fix2rtype (fixp
)
1335 switch (fixp
->fx_r_type
)
1354 /* Apply a fixS to the object file. Since COFF does not use addends
1355 in relocs, the addend is actually stored directly in the object
1359 md_apply_fix (fixp
, val
)
1365 buf
= fixp
->fx_frag
->fr_literal
+ fixp
->fx_where
;
1366 fixp
->fx_offset
= 0;
1368 switch (fixp
->fx_r_type
)
1371 fixp
->fx_offset
= val
>> 16;
1377 fixp
->fx_offset
= val
>> 16;
1383 fixp
->fx_offset
= val
>> 16;
1394 buf
[0] |= (val
>> 26) & 0x03;
1412 /* Where a PC relative offset is calculated from. On the m88k they
1413 are calculated from just after the instruction. */
1416 md_pcrel_from (fixp
)
1419 switch (fixp
->fx_r_type
)
1422 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
- 2;
1424 return fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
1431 /* Fill in rs_align_code fragments. */
1434 m88k_handle_align (fragp
)
1437 static const unsigned char nop_pattern
[] = { 0xf4, 0x00, 0x58, 0x00 };
1442 if (fragp
->fr_type
!= rs_align_code
)
1445 bytes
= fragp
->fr_next
->fr_address
- fragp
->fr_address
- fragp
->fr_fix
;
1446 p
= fragp
->fr_literal
+ fragp
->fr_fix
;
1450 int fix
= bytes
& 3;
1454 fragp
->fr_fix
+= fix
;
1457 memcpy (p
, nop_pattern
, 4);
1461 #endif /* M88KCOFF */