1 /* tc-xstormy16.c -- Assembler for the Sanyo XSTORMY16.
2 Copyright (C) 2000-2016 Free Software Foundation, Inc.
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 3, 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 "as.h"
22 #include "subsegs.h"
23 #include "symcat.h"
24 #include "opcodes/xstormy16-desc.h"
25 #include "opcodes/xstormy16-opc.h"
26 #include "cgen.h"
27
28 /* Structure to hold all of the different components describing
29 an individual instruction. */
30 typedef struct
31 {
32 const CGEN_INSN * insn;
33 const CGEN_INSN * orig_insn;
34 CGEN_FIELDS fields;
35 #if CGEN_INT_INSN_P
36 CGEN_INSN_INT buffer [1];
37 #define INSN_VALUE(buf) (*(buf))
38 #else
39 unsigned char buffer [CGEN_MAX_INSN_SIZE];
40 #define INSN_VALUE(buf) (buf)
41 #endif
42 char * addr;
43 fragS * frag;
44 int num_fixups;
45 fixS * fixups [GAS_CGEN_MAX_FIXUPS];
46 int indices [MAX_OPERAND_INSTANCES];
47 }
48 xstormy16_insn;
49
50 const char comment_chars[] = ";";
51 const char line_comment_chars[] = "#";
52 const char line_separator_chars[] = "|";
53 const char EXP_CHARS[] = "eE";
54 const char FLT_CHARS[] = "dD";
55
56 #define O_fptr_symbol (O_max + 1)
57
58 #define XSTORMY16_SHORTOPTS ""
59 const char * md_shortopts = XSTORMY16_SHORTOPTS;
60
61 struct option md_longopts[] =
62 {
63 {NULL, no_argument, NULL, 0}
64 };
65 size_t md_longopts_size = sizeof (md_longopts);
66
67 int
md_parse_option(int c ATTRIBUTE_UNUSED,const char * arg ATTRIBUTE_UNUSED)68 md_parse_option (int c ATTRIBUTE_UNUSED,
69 const char * arg ATTRIBUTE_UNUSED)
70 {
71 return 0;
72 }
73
74 void
md_show_usage(FILE * stream)75 md_show_usage (FILE * stream)
76 {
77 fprintf (stream, _(" XSTORMY16 specific command line options:\n"));
78 }
79
80 /* The target specific pseudo-ops which we support. */
81 const pseudo_typeS md_pseudo_table[] =
82 {
83 { "word", cons, 4 },
84 { NULL, NULL, 0 }
85 };
86
87
88 void
md_begin(void)89 md_begin (void)
90 {
91 /* Initialize the `cgen' interface. */
92
93 /* Set the machine number and endian. */
94 gas_cgen_cpu_desc = xstormy16_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, 0,
95 CGEN_CPU_OPEN_ENDIAN,
96 CGEN_ENDIAN_LITTLE,
97 CGEN_CPU_OPEN_END);
98 xstormy16_cgen_init_asm (gas_cgen_cpu_desc);
99
100 /* This is a callback from cgen to gas to parse operands. */
101 cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
102 }
103
104 static bfd_boolean skipping_fptr = FALSE;
105
106 void
md_assemble(char * str)107 md_assemble (char * str)
108 {
109 xstormy16_insn insn;
110 char * errmsg;
111
112 /* Make sure that if we had an erroneous input line which triggered
113 the skipping_fptr boolean that it does not affect following lines. */
114 skipping_fptr = FALSE;
115
116 /* Initialize GAS's cgen interface for a new instruction. */
117 gas_cgen_init_parse ();
118
119 insn.insn = xstormy16_cgen_assemble_insn
120 (gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
121
122 if (!insn.insn)
123 {
124 as_bad ("%s", errmsg);
125 return;
126 }
127
128 /* Doesn't really matter what we pass for RELAX_P here. */
129 gas_cgen_finish_insn (insn.insn, insn.buffer,
130 CGEN_FIELDS_BITSIZE (& insn.fields), 0, NULL);
131 }
132
133 void
md_operand(expressionS * e)134 md_operand (expressionS * e)
135 {
136 if (*input_line_pointer != '@')
137 return;
138
139 if (strncmp (input_line_pointer + 1, "fptr", 4) == 0)
140 {
141 input_line_pointer += 5;
142 SKIP_WHITESPACE ();
143 if (*input_line_pointer != '(')
144 {
145 as_bad (_("Expected '('"));
146 goto err;
147 }
148 input_line_pointer++;
149
150 expression (e);
151
152 if (*input_line_pointer != ')')
153 {
154 as_bad (_("Missing ')'"));
155 goto err;
156 }
157 input_line_pointer++;
158 SKIP_WHITESPACE ();
159
160 if (e->X_op != O_symbol)
161 as_bad (_("Not a symbolic expression"));
162 else if (* input_line_pointer == '-')
163 /* We are computing the difference of two function pointers
164 like this:
165
166 .hword @fptr (foo) - @fptr (bar)
167
168 In this situation we do not want to generate O_fptr_symbol
169 operands because the result is an absolute value, not a
170 function pointer.
171
172 We need to make the check here, rather than when the fixup
173 is generated as the function names (foo & bar in the above
174 example) might be local symbols and we want the expression
175 to be evaluated now. This kind of thing can happen when
176 gcc is generating computed gotos. */
177 skipping_fptr = TRUE;
178 else if (skipping_fptr)
179 skipping_fptr = FALSE;
180 else
181 e->X_op = O_fptr_symbol;
182 }
183
184 return;
185 err:
186 ignore_rest_of_line ();
187 }
188
189 /* Called while parsing data to create a fixup.
190 Create BFD_RELOC_XSTORMY16_FPTR16 relocations. */
191
192 void
xstormy16_cons_fix_new(fragS * f,int where,int nbytes,expressionS * exp,bfd_reloc_code_real_type code)193 xstormy16_cons_fix_new (fragS *f,
194 int where,
195 int nbytes,
196 expressionS *exp,
197 bfd_reloc_code_real_type code)
198 {
199 if (exp->X_op == O_fptr_symbol)
200 {
201 switch (nbytes)
202 {
203 case 4:
204 /* This can happen when gcc is generating debug output.
205 For example it can create a stab with the address of
206 a function:
207
208 .stabs "foo:F(0,21)",36,0,0,@fptr(foo)
209
210 Since this does not involve switching code pages, we
211 just allow the reloc to be generated without any
212 @fptr behaviour. */
213 exp->X_op = O_symbol;
214 code = BFD_RELOC_32;
215 break;
216
217 case 2:
218 exp->X_op = O_symbol;
219 code = BFD_RELOC_XSTORMY16_FPTR16;
220 break;
221
222 default:
223 as_bad (_("unsupported fptr fixup size %d"), nbytes);
224 return;
225 }
226 }
227 else if (nbytes == 1)
228 code = BFD_RELOC_8;
229 else if (nbytes == 2)
230 code = BFD_RELOC_16;
231 else if (nbytes == 4)
232 code = BFD_RELOC_32;
233 else
234 {
235 as_bad (_("unsupported fixup size %d"), nbytes);
236 return;
237 }
238
239 fix_new_exp (f, where, nbytes, exp, 0, code);
240 }
241
242 /* Called while parsing an instruction to create a fixup.
243 Create BFD_RELOC_XSTORMY16_FPTR16 relocations. */
244
245 fixS *
xstormy16_cgen_record_fixup_exp(fragS * frag,int where,const CGEN_INSN * insn,int length,const CGEN_OPERAND * operand,int opinfo,expressionS * exp)246 xstormy16_cgen_record_fixup_exp (fragS * frag,
247 int where,
248 const CGEN_INSN * insn,
249 int length,
250 const CGEN_OPERAND * operand,
251 int opinfo,
252 expressionS * exp)
253 {
254 fixS *fixP;
255 operatorT op = exp->X_op;
256
257 if (op == O_fptr_symbol)
258 exp->X_op = O_symbol;
259
260 fixP = gas_cgen_record_fixup_exp (frag, where, insn, length,
261 operand, opinfo, exp);
262
263 if (op == O_fptr_symbol)
264 {
265 if (operand->type != XSTORMY16_OPERAND_IMM16)
266 as_bad (_("unsupported fptr fixup"));
267 else
268 {
269 fixP->fx_r_type = BFD_RELOC_XSTORMY16_FPTR16;
270 fixP->fx_where += 2;
271 }
272 }
273
274 return fixP;
275 }
276
277 valueT
md_section_align(segT segment,valueT size)278 md_section_align (segT segment, valueT size)
279 {
280 int align = bfd_get_section_alignment (stdoutput, segment);
281
282 return ((size + (1 << align) - 1) & -(1 << align));
283 }
284
285 symbolS *
md_undefined_symbol(char * name ATTRIBUTE_UNUSED)286 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
287 {
288 return 0;
289 }
290
291 /* Return an initial guess of the length by which a fragment must grow to
292 hold a branch to reach its destination.
293 Also updates fr_type/fr_subtype as necessary.
294
295 Called just before doing relaxation.
296 Any symbol that is now undefined will not become defined.
297 The guess for fr_var is ACTUALLY the growth beyond fr_fix.
298 Whatever we do to grow fr_fix or fr_var contributes to our returned value.
299 Although it may not be explicit in the frag, pretend fr_var starts with a
300 0 value. */
301
302 int
md_estimate_size_before_relax(fragS * fragP ATTRIBUTE_UNUSED,segT segment ATTRIBUTE_UNUSED)303 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED,
304 segT segment ATTRIBUTE_UNUSED)
305 {
306 /* No assembler relaxation is defined (or necessary) for this port. */
307 abort ();
308 }
309
310 /* *fragP has been relaxed to its final size, and now needs to have
311 the bytes inside it modified to conform to the new size.
312
313 Called after relaxation is finished.
314 fragP->fr_type == rs_machine_dependent.
315 fragP->fr_subtype is the subtype of what the address relaxed to. */
316
317 void
md_convert_frag(bfd * abfd ATTRIBUTE_UNUSED,segT sec ATTRIBUTE_UNUSED,fragS * fragP ATTRIBUTE_UNUSED)318 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
319 segT sec ATTRIBUTE_UNUSED,
320 fragS * fragP ATTRIBUTE_UNUSED)
321 {
322 /* No assembler relaxation is defined (or necessary) for this port. */
323 abort ();
324 }
325
326 /* Functions concerning relocs. */
327
328 /* The location from which a PC relative jump should be calculated,
329 given a PC relative reloc. */
330
331 long
md_pcrel_from_section(fixS * fixP,segT sec)332 md_pcrel_from_section (fixS * fixP, segT sec)
333 {
334 if ((fixP->fx_addsy != (symbolS *) NULL
335 && (! S_IS_DEFINED (fixP->fx_addsy)
336 || S_GET_SEGMENT (fixP->fx_addsy) != sec))
337 || xstormy16_force_relocation (fixP))
338 /* The symbol is undefined,
339 or it is defined but not in this section,
340 or the relocation will be relative to this symbol not the section symbol.
341 Let the linker figure it out. */
342 return 0;
343
344 return fixP->fx_frag->fr_address + fixP->fx_where;
345 }
346
347 /* Return the bfd reloc type for OPERAND of INSN at fixup FIXP.
348 Returns BFD_RELOC_NONE if no reloc type can be found.
349 *FIXP may be modified if desired. */
350
351 bfd_reloc_code_real_type
md_cgen_lookup_reloc(const CGEN_INSN * insn ATTRIBUTE_UNUSED,const CGEN_OPERAND * operand,fixS * fixP)352 md_cgen_lookup_reloc (const CGEN_INSN * insn ATTRIBUTE_UNUSED,
353 const CGEN_OPERAND * operand,
354 fixS * fixP)
355 {
356 switch (operand->type)
357 {
358 case XSTORMY16_OPERAND_IMM2:
359 case XSTORMY16_OPERAND_IMM3:
360 case XSTORMY16_OPERAND_IMM3B:
361 case XSTORMY16_OPERAND_IMM4:
362 case XSTORMY16_OPERAND_HMEM8:
363 return BFD_RELOC_NONE;
364
365 case XSTORMY16_OPERAND_IMM12:
366 fixP->fx_where += 2;
367 return BFD_RELOC_XSTORMY16_12;
368
369 case XSTORMY16_OPERAND_IMM8:
370 case XSTORMY16_OPERAND_LMEM8:
371 return fixP->fx_pcrel ? BFD_RELOC_8_PCREL : BFD_RELOC_8;
372
373 case XSTORMY16_OPERAND_IMM16:
374 /* This might have been processed at parse time. */
375 fixP->fx_where += 2;
376 if (fixP->fx_cgen.opinfo && fixP->fx_cgen.opinfo != BFD_RELOC_NONE)
377 return fixP->fx_cgen.opinfo;
378 return fixP->fx_pcrel ? BFD_RELOC_16_PCREL : BFD_RELOC_16;
379
380 case XSTORMY16_OPERAND_ABS24:
381 return BFD_RELOC_XSTORMY16_24;
382
383 case XSTORMY16_OPERAND_REL8_4:
384 fixP->fx_addnumber -= 2;
385 case XSTORMY16_OPERAND_REL8_2:
386 fixP->fx_addnumber -= 2;
387 fixP->fx_pcrel = 1;
388 return BFD_RELOC_8_PCREL;
389
390 case XSTORMY16_OPERAND_REL12:
391 fixP->fx_where += 2;
392 /* Fall through... */
393 case XSTORMY16_OPERAND_REL12A:
394 fixP->fx_addnumber -= 2;
395 fixP->fx_pcrel = 1;
396 return BFD_RELOC_XSTORMY16_REL_12;
397
398 default : /* avoid -Wall warning */
399 abort ();
400 }
401 }
402
403 /* See whether we need to force a relocation into the output file.
404 This is used to force out switch and PC relative relocations when
405 relaxing. */
406
407 int
xstormy16_force_relocation(fixS * fix)408 xstormy16_force_relocation (fixS * fix)
409 {
410 if (fix->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
411 return 1;
412
413 return generic_force_reloc (fix);
414 }
415
416 /* Return true if a relocation against a symbol may be replaced with
417 a relocation against section+offset. */
418
419 bfd_boolean
xstormy16_fix_adjustable(fixS * fixP)420 xstormy16_fix_adjustable (fixS * fixP)
421 {
422 /* We need the symbol name for the VTABLE entries. */
423 if (fixP->fx_r_type == BFD_RELOC_VTABLE_INHERIT
424 || fixP->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
425 return FALSE;
426
427 if (fixP->fx_r_type == BFD_RELOC_XSTORMY16_FPTR16)
428 return FALSE;
429
430 return TRUE;
431 }
432
433 /* This is a copy of gas_cgen_md_apply_fix, with some enhancements to
434 do various things that would not be valid for all ports. */
435
436 void
xstormy16_md_apply_fix(fixS * fixP,valueT * valueP,segT seg ATTRIBUTE_UNUSED)437 xstormy16_md_apply_fix (fixS * fixP,
438 valueT * valueP,
439 segT seg ATTRIBUTE_UNUSED)
440 {
441 char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
442 valueT value = *valueP;
443 /* Canonical name, since used a lot. */
444 CGEN_CPU_DESC cd = gas_cgen_cpu_desc;
445
446 /* md_cgen_lookup_reloc() will adjust this to compensate for where
447 in the opcode the relocation happens, for pcrel relocations. We
448 have no other way of keeping track of what this offset needs to
449 be. */
450 fixP->fx_addnumber = 0;
451
452 /* This port has pc-relative relocs and DIFF_EXPR_OK defined, so
453 it must deal with turning a BFD_RELOC_{8,16,32,64} into a
454 BFD_RELOC_*_PCREL for the case of
455
456 .word something-. */
457 if (fixP->fx_pcrel)
458 switch (fixP->fx_r_type)
459 {
460 case BFD_RELOC_8:
461 fixP->fx_r_type = BFD_RELOC_8_PCREL;
462 break;
463 case BFD_RELOC_16:
464 fixP->fx_r_type = BFD_RELOC_16_PCREL;
465 break;
466 case BFD_RELOC_32:
467 fixP->fx_r_type = BFD_RELOC_32_PCREL;
468 break;
469 case BFD_RELOC_64:
470 fixP->fx_r_type = BFD_RELOC_64_PCREL;
471 break;
472 default:
473 break;
474 }
475
476 if (fixP->fx_addsy == (symbolS *) NULL)
477 fixP->fx_done = 1;
478
479 /* We don't actually support subtracting a symbol. */
480 if (fixP->fx_subsy != (symbolS *) NULL)
481 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
482
483 if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
484 {
485 int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
486 const CGEN_OPERAND *operand = cgen_operand_lookup_by_num (cd, opindex);
487 const char *errmsg;
488 bfd_reloc_code_real_type reloc_type;
489 const CGEN_INSN *insn = fixP->fx_cgen.insn;
490
491 /* If the reloc has been fully resolved finish the operand here. */
492 /* FIXME: This duplicates the capabilities of code in BFD. */
493 if (fixP->fx_done)
494 {
495 CGEN_FIELDS *fields = xmalloc (CGEN_CPU_SIZEOF_FIELDS (cd));
496
497 CGEN_CPU_SET_FIELDS_BITSIZE (cd) (fields, CGEN_INSN_BITSIZE (insn));
498 CGEN_CPU_SET_VMA_OPERAND (cd) (cd, opindex, fields, (bfd_vma) value);
499
500 #if CGEN_INT_INSN_P
501 {
502 CGEN_INSN_INT insn_value =
503 cgen_get_insn_value (cd, (unsigned char *) where,
504 CGEN_INSN_BITSIZE (insn));
505
506 /* ??? 0 is passed for `pc'. */
507 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
508 &insn_value, (bfd_vma) 0);
509 cgen_put_insn_value (cd, (unsigned char *) where,
510 CGEN_INSN_BITSIZE (insn), insn_value);
511 }
512 #else
513 /* ??? 0 is passed for `pc'. */
514 errmsg = CGEN_CPU_INSERT_OPERAND (cd) (cd, opindex, fields,
515 (unsigned char *) where,
516 (bfd_vma) 0);
517 #endif
518 if (errmsg)
519 as_bad_where (fixP->fx_file, fixP->fx_line, "%s", errmsg);
520
521 free (fields);
522 }
523
524 if (fixP->fx_done)
525 return;
526
527 /* The operand isn't fully resolved. Determine a BFD reloc value
528 based on the operand information and leave it to
529 bfd_install_relocation. Note that this doesn't work when
530 !partial_inplace. */
531
532 reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
533 if (reloc_type != BFD_RELOC_NONE)
534 fixP->fx_r_type = reloc_type;
535 else
536 {
537 as_bad_where (fixP->fx_file, fixP->fx_line,
538 _("unresolved expression that must be resolved"));
539 fixP->fx_done = 1;
540 return;
541 }
542 }
543 else if (fixP->fx_done)
544 {
545 /* We're finished with this fixup. Install it because
546 bfd_install_relocation won't be called to do it. */
547 switch (fixP->fx_r_type)
548 {
549 case BFD_RELOC_8:
550 md_number_to_chars (where, value, 1);
551 break;
552 case BFD_RELOC_16:
553 md_number_to_chars (where, value, 2);
554 break;
555 case BFD_RELOC_32:
556 md_number_to_chars (where, value, 4);
557 break;
558 case BFD_RELOC_64:
559 md_number_to_chars (where, value, 8);
560 break;
561 default:
562 as_bad_where (fixP->fx_file, fixP->fx_line,
563 _("internal error: can't install fix for reloc type %d (`%s')"),
564 fixP->fx_r_type, bfd_get_reloc_code_name (fixP->fx_r_type));
565 break;
566 }
567 }
568 else
569 {
570 /* bfd_install_relocation will be called to finish things up. */
571 }
572
573 /* This is a RELA port. Thus, it does not need to store a
574 value if it is going to make a reloc. What's more, when
575 assembling a line like
576
577 .byte global-0x7f00
578
579 we'll get a spurious error message if we try to stuff 0x7f00 into
580 the byte. */
581 if (! fixP->fx_done)
582 *valueP = 0;
583
584 /* Tuck `value' away for use by tc_gen_reloc.
585 See the comment describing fx_addnumber in write.h.
586 This field is misnamed (or misused :-). */
587 fixP->fx_addnumber += value;
588 }
589
590
591 /* Write a value out to the object file, using the appropriate endianness. */
592
593 void
md_number_to_chars(char * buf,valueT val,int n)594 md_number_to_chars (char * buf, valueT val, int n)
595 {
596 number_to_chars_littleendian (buf, val, n);
597 }
598
599 const char *
md_atof(int type,char * litP,int * sizeP)600 md_atof (int type, char * litP, int * sizeP)
601 {
602 return ieee_md_atof (type, litP, sizeP, FALSE);
603 }
604