Commit | Line | Data |
---|---|---|
a40cbfa3 | 1 | /* tc-ip2k.c -- Assembler for the Scenix IP2xxx. |
ae6063d4 | 2 | Copyright (C) 2000, 2002, 2003 Free Software Foundation. |
a40cbfa3 NC |
3 | |
4 | This file is part of GAS, the GNU Assembler. | |
5 | ||
6 | GAS is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2, or (at your option) | |
9 | any later version. | |
10 | ||
11 | GAS is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with GAS; see the file COPYING. If not, write to | |
18 | the Free Software Foundation, 59 Temple Place - Suite 330, | |
19 | Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | #include <stdio.h> | |
22 | #include <ctype.h> | |
23 | ||
24 | #include "as.h" | |
25 | #include "dwarf2dbg.h" | |
26 | #include "subsegs.h" | |
27 | #include "symcat.h" | |
28 | #include "opcodes/ip2k-desc.h" | |
29 | #include "opcodes/ip2k-opc.h" | |
30 | #include "cgen.h" | |
31 | #include "elf/common.h" | |
32 | #include "elf/ip2k.h" | |
33 | #include "libbfd.h" | |
34 | ||
35 | /* Structure to hold all of the different components describing | |
36 | an individual instruction. */ | |
37 | typedef struct | |
38 | { | |
39 | const CGEN_INSN * insn; | |
40 | const CGEN_INSN * orig_insn; | |
41 | CGEN_FIELDS fields; | |
42 | #if CGEN_INT_INSN_P | |
43 | CGEN_INSN_INT buffer [1]; | |
44 | #define INSN_VALUE(buf) (*(buf)) | |
45 | #else | |
46 | unsigned char buffer [CGEN_MAX_INSN_SIZE]; | |
47 | #define INSN_VALUE(buf) (buf) | |
48 | #endif | |
49 | char * addr; | |
50 | fragS * frag; | |
51 | int num_fixups; | |
52 | fixS * fixups [GAS_CGEN_MAX_FIXUPS]; | |
53 | int indices [MAX_OPERAND_INSTANCES]; | |
54 | } | |
55 | ip2k_insn; | |
56 | ||
57 | const char comment_chars[] = ";"; | |
58 | const char line_comment_chars[] = "#"; | |
59 | const char line_separator_chars[] = ""; | |
60 | const char EXP_CHARS[] = "eE"; | |
61 | const char FLT_CHARS[] = "dD"; | |
62 | ||
63 | static void ip2k_elf_section_text (int); | |
64 | static void ip2k_elf_section_rtn (int); | |
65 | ||
66 | /* The target specific pseudo-ops which we support. */ | |
67 | const pseudo_typeS md_pseudo_table[] = | |
68 | { | |
9f1838ed | 69 | { "file", (void (*) PARAMS ((int))) dwarf2_directive_file, 0 }, |
a40cbfa3 NC |
70 | { "loc", dwarf2_directive_loc, 0 }, |
71 | { "text", ip2k_elf_section_text, 0 }, | |
72 | { "sect", ip2k_elf_section_rtn, 0 }, | |
73 | { NULL, NULL, 0 } | |
74 | }; | |
75 | ||
76 | \f | |
77 | ||
78 | #define OPTION_CPU_IP2022 (OPTION_MD_BASE) | |
79 | #define OPTION_CPU_IP2022EXT (OPTION_MD_BASE+1) | |
80 | ||
81 | struct option md_longopts[] = | |
82 | { | |
83 | { "mip2022", no_argument, NULL, OPTION_CPU_IP2022 }, | |
84 | { "mip2022ext", no_argument, NULL, OPTION_CPU_IP2022EXT }, | |
85 | { NULL, no_argument, NULL, 0 }, | |
86 | }; | |
87 | size_t md_longopts_size = sizeof (md_longopts); | |
88 | ||
89 | const char * md_shortopts = ""; | |
90 | ||
91 | /* Flag to detect when switching to code section where insn alignment is | |
92 | implied. */ | |
93 | static int force_code_align = 0; | |
94 | ||
95 | /* Mach selected from command line. */ | |
96 | int ip2k_mach = 0; | |
97 | unsigned ip2k_mach_bitmask = 0; | |
98 | ||
99 | int | |
100 | md_parse_option (c, arg) | |
101 | int c ATTRIBUTE_UNUSED; | |
102 | char * arg ATTRIBUTE_UNUSED; | |
103 | { | |
104 | switch (c) | |
105 | { | |
106 | case OPTION_CPU_IP2022: | |
107 | ip2k_mach = bfd_mach_ip2022; | |
108 | ip2k_mach_bitmask = 1 << MACH_IP2022; | |
109 | break; | |
110 | ||
111 | case OPTION_CPU_IP2022EXT: | |
112 | ip2k_mach = bfd_mach_ip2022ext; | |
113 | ip2k_mach_bitmask = 1 << MACH_IP2022EXT; | |
114 | break; | |
115 | ||
116 | default: | |
117 | return 0; | |
118 | } | |
119 | ||
120 | return 1; | |
121 | } | |
122 | ||
123 | ||
124 | void | |
125 | md_show_usage (stream) | |
126 | FILE * stream; | |
127 | { | |
128 | fprintf (stream, _("IP2K specific command line options:\n")); | |
129 | fprintf (stream, _(" -mip2022 restrict to IP2022 insns \n")); | |
130 | fprintf (stream, _(" -mip2022ext permit extended IP2022 insn\n")); | |
131 | } | |
132 | ||
133 | \f | |
134 | void | |
135 | md_begin () | |
136 | { | |
137 | /* Initialize the `cgen' interface. */ | |
138 | ||
139 | /* Set the machine number and endian. */ | |
140 | gas_cgen_cpu_desc = ip2k_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, | |
141 | ip2k_mach_bitmask, | |
142 | CGEN_CPU_OPEN_ENDIAN, | |
143 | CGEN_ENDIAN_BIG, | |
144 | CGEN_CPU_OPEN_END); | |
145 | ip2k_cgen_init_asm (gas_cgen_cpu_desc); | |
146 | ||
147 | /* This is a callback from cgen to gas to parse operands. */ | |
148 | cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand); | |
149 | ||
150 | /* Set the machine type. */ | |
151 | bfd_default_set_arch_mach (stdoutput, bfd_arch_ip2k, ip2k_mach); | |
152 | } | |
153 | ||
154 | ||
155 | void | |
156 | md_assemble (str) | |
157 | char * str; | |
158 | { | |
159 | ip2k_insn insn; | |
160 | char * errmsg; | |
161 | ||
162 | /* Initialize GAS's cgen interface for a new instruction. */ | |
163 | gas_cgen_init_parse (); | |
164 | ||
165 | insn.insn = ip2k_cgen_assemble_insn | |
166 | (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg); | |
167 | ||
168 | if (!insn.insn) | |
169 | { | |
170 | as_bad ("%s", errmsg); | |
171 | return; | |
172 | } | |
173 | ||
174 | /* Check for special relocation required by SKIP instructions. */ | |
175 | if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_SKIPA)) | |
176 | /* Unconditional skip has a 1-bit relocation of the current pc, so | |
177 | that we emit either sb pcl.0 or snb pcl.0 depending on whether | |
178 | the PCL (pc + 2) >> 1 is odd or even. */ | |
179 | { | |
180 | enum cgen_parse_operand_result result_type; | |
181 | long value; | |
182 | const char *curpc_plus_2 = ".+2"; | |
64384dfd | 183 | const char *err; |
a40cbfa3 | 184 | |
64384dfd AM |
185 | err = cgen_parse_address (gas_cgen_cpu_desc, & curpc_plus_2, |
186 | IP2K_OPERAND_ADDR16CJP, | |
187 | BFD_RELOC_IP2K_PC_SKIP, | |
188 | & result_type, & value); | |
189 | if (err) | |
a40cbfa3 | 190 | { |
64384dfd | 191 | as_bad ("%s", err); |
a40cbfa3 NC |
192 | return; |
193 | } | |
194 | } | |
195 | ||
196 | /* Doesn't really matter what we pass for RELAX_P here. */ | |
197 | gas_cgen_finish_insn (insn.insn, insn.buffer, | |
198 | CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL); | |
199 | } | |
200 | ||
201 | valueT | |
202 | md_section_align (segment, size) | |
203 | segT segment; | |
204 | valueT size; | |
205 | { | |
206 | int align = bfd_get_section_alignment (stdoutput, segment); | |
207 | ||
208 | return ((size + (1 << align) - 1) & (-1 << align)); | |
209 | } | |
210 | ||
211 | ||
212 | symbolS * | |
213 | md_undefined_symbol (name) | |
214 | char * name ATTRIBUTE_UNUSED; | |
215 | { | |
216 | return 0; | |
217 | } | |
218 | \f | |
219 | int | |
220 | md_estimate_size_before_relax (fragP, segment) | |
221 | fragS * fragP ATTRIBUTE_UNUSED; | |
222 | segT segment ATTRIBUTE_UNUSED; | |
223 | { | |
224 | as_fatal (_("md_estimate_size_before_relax\n")); | |
225 | return 1; | |
226 | } | |
227 | ||
228 | ||
229 | /* *fragP has been relaxed to its final size, and now needs to have | |
230 | the bytes inside it modified to conform to the new size. | |
231 | ||
232 | Called after relaxation is finished. | |
233 | fragP->fr_type == rs_machine_dependent. | |
234 | fragP->fr_subtype is the subtype of what the address relaxed to. */ | |
235 | ||
236 | void | |
237 | md_convert_frag (abfd, sec, fragP) | |
238 | bfd * abfd ATTRIBUTE_UNUSED; | |
239 | segT sec ATTRIBUTE_UNUSED; | |
240 | fragS * fragP ATTRIBUTE_UNUSED; | |
241 | { | |
242 | } | |
243 | ||
244 | \f | |
245 | /* Functions concerning relocs. */ | |
246 | ||
247 | long | |
248 | md_pcrel_from (fixP) | |
249 | fixS *fixP; | |
250 | { | |
251 | as_fatal (_("md_pcrel_from\n")); | |
252 | ||
253 | /* Return the address of the delay slot. */ | |
254 | return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address; | |
255 | } | |
256 | ||
257 | ||
258 | /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP. | |
259 | Returns BFD_RELOC_NONE if no reloc type can be found. | |
260 | *FIXP may be modified if desired. */ | |
261 | ||
262 | bfd_reloc_code_real_type | |
263 | md_cgen_lookup_reloc (insn, operand, fixP) | |
264 | const CGEN_INSN * insn ATTRIBUTE_UNUSED; | |
265 | const CGEN_OPERAND * operand; | |
266 | fixS * fixP ATTRIBUTE_UNUSED; | |
267 | { | |
268 | bfd_reloc_code_real_type result; | |
269 | ||
270 | result = BFD_RELOC_NONE; | |
271 | ||
272 | switch (operand->type) | |
273 | { | |
274 | case IP2K_OPERAND_FR: | |
275 | case IP2K_OPERAND_ADDR16L: | |
276 | case IP2K_OPERAND_ADDR16H: | |
277 | case IP2K_OPERAND_LIT8: | |
278 | /* These may have been processed at parse time. */ | |
279 | if (fixP->fx_cgen.opinfo != 0) | |
280 | result = fixP->fx_cgen.opinfo; | |
281 | fixP->fx_no_overflow = 1; | |
282 | break; | |
283 | ||
284 | case IP2K_OPERAND_ADDR16CJP: | |
285 | result = fixP->fx_cgen.opinfo; | |
286 | if (result == 0 || result == BFD_RELOC_NONE) | |
287 | result = BFD_RELOC_IP2K_ADDR16CJP; | |
288 | fixP->fx_no_overflow = 1; | |
289 | break; | |
290 | ||
291 | case IP2K_OPERAND_ADDR16P: | |
292 | result = BFD_RELOC_IP2K_PAGE3; | |
293 | fixP->fx_no_overflow = 1; | |
294 | break; | |
295 | ||
296 | default: | |
297 | result = BFD_RELOC_NONE; | |
298 | break; | |
299 | } | |
300 | ||
301 | return result; | |
302 | } | |
303 | ||
304 | ||
305 | /* Write a value out to the object file, using the appropriate endianness. */ | |
306 | ||
307 | void | |
308 | md_number_to_chars (buf, val, n) | |
309 | char * buf; | |
310 | valueT val; | |
311 | int n; | |
312 | { | |
313 | number_to_chars_bigendian (buf, val, n); | |
314 | } | |
315 | ||
316 | /* Turn a string in input_line_pointer into a floating point constant of type | |
317 | type, and store the appropriate bytes in *litP. The number of LITTLENUMS | |
318 | emitted is stored in *sizeP . An error message is returned, or NULL on | |
319 | OK. */ | |
320 | ||
321 | /* Equal to MAX_PRECISION in atof-ieee.c */ | |
322 | #define MAX_LITTLENUMS 6 | |
323 | ||
324 | char * | |
325 | md_atof (type, litP, sizeP) | |
326 | char type; | |
327 | char * litP; | |
328 | int * sizeP; | |
329 | { | |
330 | int prec; | |
331 | LITTLENUM_TYPE words [MAX_LITTLENUMS]; | |
332 | LITTLENUM_TYPE *wordP; | |
333 | char * t; | |
334 | char * atof_ieee PARAMS ((char *, int, LITTLENUM_TYPE *)); | |
335 | ||
336 | switch (type) | |
337 | { | |
338 | case 'f': | |
339 | case 'F': | |
340 | case 's': | |
341 | case 'S': | |
342 | prec = 2; | |
343 | break; | |
344 | ||
345 | case 'd': | |
346 | case 'D': | |
347 | case 'r': | |
348 | case 'R': | |
349 | prec = 4; | |
350 | break; | |
351 | ||
352 | /* FIXME: Some targets allow other format chars for bigger sizes here. */ | |
353 | ||
354 | default: | |
355 | * sizeP = 0; | |
356 | return _("Bad call to md_atof()"); | |
357 | } | |
358 | ||
359 | t = atof_ieee (input_line_pointer, type, words); | |
360 | if (t) | |
361 | input_line_pointer = t; | |
362 | * sizeP = prec * sizeof (LITTLENUM_TYPE); | |
363 | ||
364 | /* This loops outputs the LITTLENUMs in REVERSE order; in accord with | |
365 | the ip2k endianness. */ | |
366 | for (wordP = words; prec--;) | |
367 | { | |
368 | md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE)); | |
369 | litP += sizeof (LITTLENUM_TYPE); | |
370 | } | |
371 | ||
372 | return 0; | |
373 | } | |
374 | ||
375 | ||
376 | /* See whether we need to force a relocation into the output file. | |
377 | Force most of them, since the linker's bfd relocation engine | |
378 | understands range limits better than gas' cgen fixup engine. | |
379 | Consider the case of a fixup intermediate value being larger than | |
380 | the instruction it will be eventually encoded within. */ | |
381 | ||
382 | int | |
383 | ip2k_force_relocation (fix) | |
384 | fixS * fix; | |
385 | { | |
386 | switch (fix->fx_r_type) | |
387 | { | |
a40cbfa3 NC |
388 | case BFD_RELOC_IP2K_FR9: |
389 | case BFD_RELOC_IP2K_FR_OFFSET: | |
390 | case BFD_RELOC_IP2K_BANK: | |
391 | case BFD_RELOC_IP2K_ADDR16CJP: | |
392 | case BFD_RELOC_IP2K_PAGE3: | |
393 | case BFD_RELOC_IP2K_LO8DATA: | |
394 | case BFD_RELOC_IP2K_HI8DATA: | |
395 | case BFD_RELOC_IP2K_EX8DATA: | |
396 | case BFD_RELOC_IP2K_LO8INSN: | |
397 | case BFD_RELOC_IP2K_HI8INSN: | |
398 | case BFD_RELOC_IP2K_PC_SKIP: | |
399 | case BFD_RELOC_IP2K_TEXT: | |
400 | return 1; | |
401 | ||
402 | case BFD_RELOC_16: | |
a161fe53 | 403 | if (fix->fx_subsy && S_IS_DEFINED (fix->fx_subsy) |
a40cbfa3 NC |
404 | && fix->fx_addsy && S_IS_DEFINED (fix->fx_addsy) |
405 | && (S_GET_SEGMENT (fix->fx_addsy)->flags & SEC_CODE)) | |
406 | { | |
407 | fix->fx_r_type = BFD_RELOC_IP2K_TEXT; | |
408 | return 0; | |
409 | } | |
a161fe53 | 410 | break; |
a40cbfa3 NC |
411 | |
412 | default: | |
a161fe53 | 413 | break; |
a40cbfa3 | 414 | } |
a161fe53 | 415 | |
ae6063d4 | 416 | return generic_force_reloc (fix); |
a40cbfa3 NC |
417 | } |
418 | ||
419 | void | |
420 | ip2k_apply_fix3 (fixP, valueP, seg) | |
421 | fixS *fixP; | |
422 | valueT *valueP; | |
423 | segT seg; | |
424 | { | |
425 | if (fixP->fx_r_type == BFD_RELOC_IP2K_TEXT | |
426 | && ! fixP->fx_addsy | |
427 | && ! fixP->fx_subsy) | |
428 | { | |
429 | *valueP = ((int)(*valueP)) / 2; | |
430 | fixP->fx_r_type = BFD_RELOC_16; | |
431 | } | |
432 | else if (fixP->fx_r_type == BFD_RELOC_UNUSED + IP2K_OPERAND_FR) | |
433 | { | |
434 | /* Must be careful when we are fixing up an FR. We could be | |
435 | fixing up an offset to (SP) or (DP) in which case we don't | |
436 | want to step on the top 2 bits of the FR operand. The | |
437 | gas_cgen_md_apply_fix3 doesn't know any better and overwrites | |
438 | the entire operand. We counter this by adding the bits | |
439 | to the new value. */ | |
440 | char *where = fixP->fx_frag->fr_literal + fixP->fx_where; | |
441 | ||
442 | /* Canonical name, since used a lot. */ | |
443 | CGEN_CPU_DESC cd = gas_cgen_cpu_desc; | |
444 | CGEN_INSN_INT insn_value | |
445 | = cgen_get_insn_value (cd, where, | |
446 | CGEN_INSN_BITSIZE (fixP->fx_cgen.insn)); | |
447 | /* Preserve (DP) or (SP) specification. */ | |
448 | *valueP += (insn_value & 0x180); | |
449 | } | |
450 | ||
451 | gas_cgen_md_apply_fix3 (fixP, valueP, seg); | |
452 | } | |
453 | ||
454 | int | |
455 | ip2k_elf_section_flags (flags, attr, type) | |
456 | int flags; | |
457 | int attr ATTRIBUTE_UNUSED; | |
458 | int type ATTRIBUTE_UNUSED; | |
459 | { | |
460 | /* This is used to detect when the section changes to an executable section. | |
461 | This function is called by the elf section processing. When we note an | |
462 | executable section specifier we set an internal flag to denote when | |
463 | word alignment should be forced. */ | |
464 | if (flags & SEC_CODE) | |
465 | force_code_align = 1; | |
466 | ||
467 | return flags; | |
468 | } | |
469 | ||
470 | static void | |
471 | ip2k_elf_section_rtn (int i) | |
472 | { | |
473 | obj_elf_section(i); | |
474 | ||
475 | if (force_code_align) | |
476 | { | |
477 | /* The s_align_ptwo function expects that we are just after a .align | |
478 | directive and it will either try and read the align value or stop | |
479 | if end of line so we must fake it out so it thinks we are at the | |
480 | end of the line. */ | |
481 | char *old_input_line_pointer = input_line_pointer; | |
482 | input_line_pointer = "\n"; | |
483 | s_align_ptwo (1); | |
484 | force_code_align = 0; | |
485 | /* Restore. */ | |
486 | input_line_pointer = old_input_line_pointer; | |
487 | } | |
488 | } | |
489 | ||
490 | static void | |
491 | ip2k_elf_section_text (int i) | |
492 | { | |
493 | char *old_input_line_pointer; | |
494 | obj_elf_text(i); | |
495 | ||
496 | /* the s_align_ptwo function expects that we are just after a .align | |
497 | directive and it will either try and read the align value or stop if | |
498 | end of line so we must fake it out so it thinks we are at the end of | |
499 | the line. */ | |
500 | old_input_line_pointer = input_line_pointer; | |
501 | input_line_pointer = "\n"; | |
502 | s_align_ptwo (1); | |
503 | force_code_align = 0; | |
504 | /* Restore. */ | |
505 | input_line_pointer = old_input_line_pointer; | |
506 | } |