Commit | Line | Data |
---|---|---|
252b5132 | 1 | /* tc-fr30.c -- Assembler for the Fujitsu FR30. |
aef6203b | 2 | Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2005 |
ae6063d4 | 3 | Free Software Foundation, Inc. |
252b5132 RH |
4 | |
5 | This file is part of GAS, the GNU Assembler. | |
6 | ||
7 | GAS is free software; you can redistribute it and/or modify | |
8 | it under the terms of the GNU General Public License as published by | |
9 | the Free Software Foundation; either version 2, or (at your option) | |
10 | any later version. | |
11 | ||
12 | GAS is distributed in the hope that it will be useful, | |
13 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | GNU General Public License for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
18 | along with GAS; see the file COPYING. If not, write to | |
4b4da160 NC |
19 | the Free Software Foundation, 51 Franklin Street - Fifth Floor, |
20 | Boston, MA 02110-1301, USA. */ | |
252b5132 RH |
21 | |
22 | #include <stdio.h> | |
252b5132 | 23 | #include "as.h" |
3882b010 | 24 | #include "safe-ctype.h" |
81d4177b | 25 | #include "subsegs.h" |
252b5132 RH |
26 | #include "symcat.h" |
27 | #include "opcodes/fr30-desc.h" | |
28 | #include "opcodes/fr30-opc.h" | |
29 | #include "cgen.h" | |
30 | ||
31 | /* Structure to hold all of the different components describing | |
32 | an individual instruction. */ | |
33 | typedef struct | |
34 | { | |
35 | const CGEN_INSN * insn; | |
36 | const CGEN_INSN * orig_insn; | |
37 | CGEN_FIELDS fields; | |
38 | #if CGEN_INT_INSN_P | |
39 | CGEN_INSN_INT buffer [1]; | |
40 | #define INSN_VALUE(buf) (*(buf)) | |
41 | #else | |
42 | unsigned char buffer [CGEN_MAX_INSN_SIZE]; | |
43 | #define INSN_VALUE(buf) (buf) | |
44 | #endif | |
45 | char * addr; | |
46 | fragS * frag; | |
47 | int num_fixups; | |
48 | fixS * fixups [GAS_CGEN_MAX_FIXUPS]; | |
49 | int indices [MAX_OPERAND_INSTANCES]; | |
50 | } | |
51 | fr30_insn; | |
52 | ||
53 | const char comment_chars[] = ";"; | |
54 | const char line_comment_chars[] = "#"; | |
55 | const char line_separator_chars[] = "|"; | |
56 | const char EXP_CHARS[] = "eE"; | |
57 | const char FLT_CHARS[] = "dD"; | |
58 | \f | |
59 | #define FR30_SHORTOPTS "" | |
60 | const char * md_shortopts = FR30_SHORTOPTS; | |
61 | ||
62 | struct option md_longopts[] = | |
63 | { | |
64 | {NULL, no_argument, NULL, 0} | |
65 | }; | |
66 | size_t md_longopts_size = sizeof (md_longopts); | |
67 | ||
68 | int | |
ea1562b3 NC |
69 | md_parse_option (int c ATTRIBUTE_UNUSED, |
70 | char *arg ATTRIBUTE_UNUSED) | |
252b5132 RH |
71 | { |
72 | switch (c) | |
73 | { | |
74 | default: | |
75 | return 0; | |
76 | } | |
77 | return 1; | |
78 | } | |
79 | ||
80 | void | |
ea1562b3 | 81 | md_show_usage (FILE * stream) |
252b5132 RH |
82 | { |
83 | fprintf (stream, _(" FR30 specific command line options:\n")); | |
81d4177b | 84 | } |
252b5132 RH |
85 | |
86 | /* The target specific pseudo-ops which we support. */ | |
87 | const pseudo_typeS md_pseudo_table[] = | |
88 | { | |
89 | { "word", cons, 4 }, | |
90 | { NULL, NULL, 0 } | |
91 | }; | |
92 | ||
93 | \f | |
94 | void | |
ea1562b3 | 95 | md_begin (void) |
252b5132 | 96 | { |
252b5132 | 97 | /* Initialize the `cgen' interface. */ |
81d4177b | 98 | |
252b5132 RH |
99 | /* Set the machine number and endian. */ |
100 | gas_cgen_cpu_desc = fr30_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0, | |
101 | CGEN_CPU_OPEN_ENDIAN, | |
102 | CGEN_ENDIAN_BIG, | |
103 | CGEN_CPU_OPEN_END); | |
104 | fr30_cgen_init_asm (gas_cgen_cpu_desc); | |
105 | ||
106 | /* This is a callback from cgen to gas to parse operands. */ | |
107 | cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand); | |
108 | } | |
109 | ||
110 | void | |
ea1562b3 | 111 | md_assemble (char *str) |
252b5132 RH |
112 | { |
113 | static int last_insn_had_delay_slot = 0; | |
114 | fr30_insn insn; | |
33b5881a | 115 | char *errmsg; |
252b5132 RH |
116 | |
117 | /* Initialize GAS's cgen interface for a new instruction. */ | |
118 | gas_cgen_init_parse (); | |
119 | ||
120 | insn.insn = fr30_cgen_assemble_insn | |
121 | (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg); | |
81d4177b | 122 | |
252b5132 RH |
123 | if (!insn.insn) |
124 | { | |
125 | as_bad (errmsg); | |
126 | return; | |
127 | } | |
128 | ||
129 | /* Doesn't really matter what we pass for RELAX_P here. */ | |
130 | gas_cgen_finish_insn (insn.insn, insn.buffer, | |
131 | CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL); | |
132 | ||
133 | /* Warn about invalid insns in delay slots. */ | |
134 | if (last_insn_had_delay_slot | |
135 | && CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_NOT_IN_DELAY_SLOT)) | |
136 | as_warn (_("Instruction %s not allowed in a delay slot."), | |
137 | CGEN_INSN_NAME (insn.insn)); | |
138 | ||
139 | last_insn_had_delay_slot | |
140 | = CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT); | |
141 | } | |
142 | ||
143 | /* The syntax in the manual says constants begin with '#'. | |
144 | We just ignore it. */ | |
145 | ||
81d4177b | 146 | void |
ea1562b3 | 147 | md_operand (expressionS * expressionP) |
252b5132 RH |
148 | { |
149 | if (* input_line_pointer == '#') | |
150 | { | |
151 | input_line_pointer ++; | |
152 | expression (expressionP); | |
153 | } | |
154 | } | |
155 | ||
156 | valueT | |
ea1562b3 | 157 | md_section_align (segT segment, valueT size) |
252b5132 RH |
158 | { |
159 | int align = bfd_get_section_alignment (stdoutput, segment); | |
ea1562b3 | 160 | |
252b5132 RH |
161 | return ((size + (1 << align) - 1) & (-1 << align)); |
162 | } | |
163 | ||
164 | symbolS * | |
ea1562b3 | 165 | md_undefined_symbol (char *name ATTRIBUTE_UNUSED) |
252b5132 | 166 | { |
ea1562b3 | 167 | return NULL; |
252b5132 RH |
168 | } |
169 | \f | |
170 | /* Interface to relax_segment. */ | |
171 | ||
172 | /* FIXME: Build table by hand, get it working, then machine generate. */ | |
173 | ||
174 | const relax_typeS md_relax_table[] = | |
175 | { | |
176 | /* The fields are: | |
177 | 1) most positive reach of this state, | |
178 | 2) most negative reach of this state, | |
179 | 3) how many bytes this mode will add to the size of the current frag | |
180 | 4) which index into the table to try if we can't fit into this one. */ | |
181 | ||
182 | /* The first entry must be unused because an `rlx_more' value of zero ends | |
183 | each list. */ | |
184 | {1, 1, 0, 0}, | |
185 | ||
186 | /* The displacement used by GAS is from the end of the 2 byte insn, | |
187 | so we subtract 2 from the following. */ | |
188 | /* 16 bit insn, 8 bit disp -> 10 bit range. | |
189 | This doesn't handle a branch in the right slot at the border: | |
190 | the "& -4" isn't taken into account. It's not important enough to | |
191 | complicate things over it, so we subtract an extra 2 (or + 2 in -ve | |
192 | case). */ | |
193 | {511 - 2 - 2, -512 - 2 + 2, 0, 2 }, | |
194 | /* 32 bit insn, 24 bit disp -> 26 bit range. */ | |
195 | {0x2000000 - 1 - 2, -0x2000000 - 2, 2, 0 }, | |
196 | /* Same thing, but with leading nop for alignment. */ | |
197 | {0x2000000 - 1 - 2, -0x2000000 - 2, 4, 0 } | |
198 | }; | |
199 | ||
252b5132 RH |
200 | /* Return an initial guess of the length by which a fragment must grow to |
201 | hold a branch to reach its destination. | |
202 | Also updates fr_type/fr_subtype as necessary. | |
203 | ||
204 | Called just before doing relaxation. | |
205 | Any symbol that is now undefined will not become defined. | |
206 | The guess for fr_var is ACTUALLY the growth beyond fr_fix. | |
207 | Whatever we do to grow fr_fix or fr_var contributes to our returned value. | |
208 | Although it may not be explicit in the frag, pretend fr_var starts with a | |
209 | 0 value. */ | |
210 | ||
211 | int | |
ea1562b3 | 212 | md_estimate_size_before_relax (fragS * fragP, segT segment) |
252b5132 | 213 | { |
252b5132 RH |
214 | /* The only thing we have to handle here are symbols outside of the |
215 | current segment. They may be undefined or in a different segment in | |
216 | which case linker scripts may place them anywhere. | |
217 | However, we can't finish the fragment here and emit the reloc as insn | |
218 | alignment requirements may move the insn about. */ | |
219 | ||
220 | if (S_GET_SEGMENT (fragP->fr_symbol) != segment) | |
221 | { | |
222 | /* The symbol is undefined in this segment. | |
223 | Change the relaxation subtype to the max allowable and leave | |
224 | all further handling to md_convert_frag. */ | |
225 | fragP->fr_subtype = 2; | |
226 | ||
252b5132 RH |
227 | { |
228 | const CGEN_INSN * insn; | |
229 | int i; | |
230 | ||
231 | /* Update the recorded insn. | |
232 | Fortunately we don't have to look very far. | |
233 | FIXME: Change this to record in the instruction the next higher | |
234 | relaxable insn to use. */ | |
235 | for (i = 0, insn = fragP->fr_cgen.insn; i < 4; i++, insn++) | |
236 | { | |
237 | if ((strcmp (CGEN_INSN_MNEMONIC (insn), | |
238 | CGEN_INSN_MNEMONIC (fragP->fr_cgen.insn)) | |
239 | == 0) | |
b11dcf4e | 240 | && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_RELAXED)) |
252b5132 RH |
241 | break; |
242 | } | |
243 | if (i == 4) | |
244 | abort (); | |
245 | ||
246 | fragP->fr_cgen.insn = insn; | |
247 | return 2; | |
248 | } | |
252b5132 RH |
249 | } |
250 | ||
606ab118 AM |
251 | /* Return the size of the variable part of the frag. */ |
252 | return md_relax_table[fragP->fr_subtype].rlx_length; | |
81d4177b | 253 | } |
252b5132 RH |
254 | |
255 | /* *fragP has been relaxed to its final size, and now needs to have | |
256 | the bytes inside it modified to conform to the new size. | |
257 | ||
258 | Called after relaxation is finished. | |
259 | fragP->fr_type == rs_machine_dependent. | |
260 | fragP->fr_subtype is the subtype of what the address relaxed to. */ | |
261 | ||
262 | void | |
ea1562b3 NC |
263 | md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED, |
264 | segT sec ATTRIBUTE_UNUSED, | |
265 | fragS *fragP ATTRIBUTE_UNUSED) | |
252b5132 | 266 | { |
252b5132 RH |
267 | } |
268 | \f | |
269 | /* Functions concerning relocs. */ | |
270 | ||
271 | /* The location from which a PC relative jump should be calculated, | |
272 | given a PC relative reloc. */ | |
273 | ||
274 | long | |
ea1562b3 | 275 | md_pcrel_from_section (fixS * fixP, segT sec) |
252b5132 RH |
276 | { |
277 | if (fixP->fx_addsy != (symbolS *) NULL | |
278 | && (! S_IS_DEFINED (fixP->fx_addsy) | |
279 | || S_GET_SEGMENT (fixP->fx_addsy) != sec)) | |
ea1562b3 NC |
280 | /* The symbol is undefined (or is defined but not in this section). |
281 | Let the linker figure it out. */ | |
282 | return 0; | |
252b5132 RH |
283 | |
284 | return (fixP->fx_frag->fr_address + fixP->fx_where) & ~1; | |
285 | } | |
286 | ||
287 | /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP. | |
288 | Returns BFD_RELOC_NONE if no reloc type can be found. | |
289 | *FIXP may be modified if desired. */ | |
290 | ||
291 | bfd_reloc_code_real_type | |
ea1562b3 NC |
292 | md_cgen_lookup_reloc (const CGEN_INSN *insn ATTRIBUTE_UNUSED, |
293 | const CGEN_OPERAND *operand, | |
294 | fixS *fixP) | |
252b5132 RH |
295 | { |
296 | switch (operand->type) | |
297 | { | |
298 | case FR30_OPERAND_LABEL9: fixP->fx_pcrel = 1; return BFD_RELOC_FR30_9_PCREL; | |
299 | case FR30_OPERAND_LABEL12: fixP->fx_pcrel = 1; return BFD_RELOC_FR30_12_PCREL; | |
300 | case FR30_OPERAND_DISP10: return BFD_RELOC_FR30_10_IN_8; | |
301 | case FR30_OPERAND_DISP9: return BFD_RELOC_FR30_9_IN_8; | |
302 | case FR30_OPERAND_DISP8: return BFD_RELOC_FR30_8_IN_8; | |
303 | case FR30_OPERAND_UDISP6: return BFD_RELOC_FR30_6_IN_4; | |
304 | case FR30_OPERAND_I8: return BFD_RELOC_8; | |
305 | case FR30_OPERAND_I32: return BFD_RELOC_FR30_48; | |
306 | case FR30_OPERAND_I20: return BFD_RELOC_FR30_20; | |
ea1562b3 | 307 | default : /* Avoid -Wall warning. */ |
252b5132 RH |
308 | break; |
309 | } | |
310 | ||
311 | return BFD_RELOC_NONE; | |
312 | } | |
252b5132 RH |
313 | \f |
314 | /* Write a value out to the object file, using the appropriate endianness. */ | |
315 | ||
316 | void | |
ea1562b3 | 317 | md_number_to_chars (char * buf, valueT val, int n) |
252b5132 RH |
318 | { |
319 | number_to_chars_bigendian (buf, val, n); | |
320 | } | |
321 | ||
322 | /* Turn a string in input_line_pointer into a floating point constant of type | |
323 | type, and store the appropriate bytes in *litP. The number of LITTLENUMS | |
324 | emitted is stored in *sizeP . An error message is returned, or NULL on OK. | |
325 | */ | |
326 | ||
ea1562b3 | 327 | /* Equal to MAX_PRECISION in atof-ieee.c. */ |
252b5132 RH |
328 | #define MAX_LITTLENUMS 6 |
329 | ||
330 | char * | |
ea1562b3 | 331 | md_atof (int type, char * litP, int * sizeP) |
252b5132 RH |
332 | { |
333 | int i; | |
334 | int prec; | |
335 | LITTLENUM_TYPE words [MAX_LITTLENUMS]; | |
336 | char * t; | |
252b5132 RH |
337 | |
338 | switch (type) | |
339 | { | |
340 | case 'f': | |
341 | case 'F': | |
342 | case 's': | |
343 | case 'S': | |
344 | prec = 2; | |
345 | break; | |
346 | ||
347 | case 'd': | |
348 | case 'D': | |
349 | case 'r': | |
350 | case 'R': | |
351 | prec = 4; | |
352 | break; | |
353 | ||
354 | /* FIXME: Some targets allow other format chars for bigger sizes here. */ | |
355 | ||
356 | default: | |
357 | * sizeP = 0; | |
358 | return _("Bad call to md_atof()"); | |
359 | } | |
360 | ||
361 | t = atof_ieee (input_line_pointer, type, words); | |
362 | if (t) | |
363 | input_line_pointer = t; | |
364 | * sizeP = prec * sizeof (LITTLENUM_TYPE); | |
365 | ||
366 | for (i = 0; i < prec; i++) | |
367 | { | |
368 | md_number_to_chars (litP, (valueT) words[i], | |
369 | sizeof (LITTLENUM_TYPE)); | |
370 | litP += sizeof (LITTLENUM_TYPE); | |
371 | } | |
81d4177b | 372 | |
252b5132 RH |
373 | return 0; |
374 | } | |
375 | ||
376 | /* Worker function for fr30_is_colon_insn(). */ | |
377 | static char | |
ea1562b3 | 378 | restore_colon (int advance_i_l_p_by) |
252b5132 RH |
379 | { |
380 | char c; | |
81d4177b | 381 | |
252b5132 RH |
382 | /* Restore the colon, and advance input_line_pointer to |
383 | the end of the new symbol. */ | |
384 | * input_line_pointer = ':'; | |
385 | input_line_pointer += advance_i_l_p_by; | |
386 | c = * input_line_pointer; | |
387 | * input_line_pointer = 0; | |
81d4177b | 388 | |
252b5132 RH |
389 | return c; |
390 | } | |
391 | ||
392 | /* Determines if the symbol starting at START and ending in | |
393 | a colon that was at the location pointed to by INPUT_LINE_POINTER | |
394 | (but which has now been replaced bu a NUL) is in fact an | |
395 | LDI:8, LDI:20, LDI:32, CALL:D. JMP:D, RET:D or Bcc:D instruction. | |
396 | If it is, then it restores the colon, advances INPUT_LINE_POINTER | |
397 | to the real end of the instruction/symbol, and returns the character | |
398 | that really terminated the symbol. Otherwise it returns 0. */ | |
399 | char | |
ea1562b3 | 400 | fr30_is_colon_insn (char * start) |
252b5132 RH |
401 | { |
402 | char * i_l_p = input_line_pointer; | |
403 | ||
ea1562b3 | 404 | /* Check to see if the symbol parsed so far is 'ldi'. */ |
252b5132 RH |
405 | if ( (start[0] != 'l' && start[0] != 'L') |
406 | || (start[1] != 'd' && start[1] != 'D') | |
407 | || (start[2] != 'i' && start[2] != 'I') | |
408 | || start[3] != 0) | |
409 | { | |
410 | /* Nope - check to see a 'd' follows the colon. */ | |
411 | if ( (i_l_p[1] == 'd' || i_l_p[1] == 'D') | |
412 | && (i_l_p[2] == ' ' || i_l_p[2] == '\t' || i_l_p[2] == '\n')) | |
413 | { | |
414 | /* Yup - it might be delay slot instruction. */ | |
415 | int i; | |
416 | static char * delay_insns [] = | |
417 | { | |
418 | "call", "jmp", "ret", "bra", "bno", | |
419 | "beq", "bne", "bc", "bnc", "bn", | |
420 | "bp", "bv", "bnv", "blt", "bge", | |
421 | "ble", "bgt", "bls", "bhi" | |
422 | }; | |
423 | ||
424 | for (i = sizeof (delay_insns) / sizeof (delay_insns[0]); i--;) | |
425 | { | |
426 | char * insn = delay_insns[i]; | |
427 | int len = strlen (insn); | |
428 | ||
429 | if (start [len] != 0) | |
430 | continue; | |
81d4177b | 431 | |
252b5132 | 432 | while (len --) |
3882b010 | 433 | if (TOLOWER (start [len]) != insn [len]) |
252b5132 | 434 | break; |
81d4177b | 435 | |
252b5132 RH |
436 | if (len == -1) |
437 | return restore_colon (1); | |
438 | } | |
439 | } | |
440 | ||
441 | /* Nope - it is a normal label. */ | |
442 | return 0; | |
443 | } | |
444 | ||
ea1562b3 | 445 | /* Check to see if the text following the colon is '8'. */ |
252b5132 RH |
446 | if (i_l_p[1] == '8' && (i_l_p[2] == ' ' || i_l_p[2] == '\t')) |
447 | return restore_colon (2); | |
448 | ||
ea1562b3 | 449 | /* Check to see if the text following the colon is '20'. */ |
252b5132 RH |
450 | else if (i_l_p[1] == '2' && i_l_p[2] =='0' && (i_l_p[3] == ' ' || i_l_p[3] == '\t')) |
451 | return restore_colon (3); | |
452 | ||
ea1562b3 | 453 | /* Check to see if the text following the colon is '32'. */ |
252b5132 RH |
454 | else if (i_l_p[1] == '3' && i_l_p[2] =='2' && (i_l_p[3] == ' ' || i_l_p[3] == '\t')) |
455 | return restore_colon (3); | |
456 | ||
457 | return 0; | |
458 | } | |
459 | ||
b34976b6 | 460 | bfd_boolean |
ea1562b3 | 461 | fr30_fix_adjustable (fixS * fixP) |
252b5132 | 462 | { |
ea1562b3 | 463 | /* We need the symbol name for the VTABLE entries. */ |
a161fe53 | 464 | if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT |
252b5132 RH |
465 | || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY) |
466 | return 0; | |
467 | ||
468 | return 1; | |
469 | } |