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