projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Copyright update for binutils
[deliverable/binutils-gdb.git] / gas / config / tc-rl78.c
1 /* tc-rl78.c -- Assembler for the Renesas RL78
2 Copyright (C) 2011-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 the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
19 02110-1301, USA. */
20
21 #include "as.h"
22 #include "struc-symbol.h"
23 #include "safe-ctype.h"
24 #include "dwarf2dbg.h"
25 #include "libbfd.h"
26 #include "elf/common.h"
27 #include "elf/rl78.h"
28 #include "rl78-defs.h"
29 #include "filenames.h"
30 #include "listing.h"
31 #include "sb.h"
32 #include "macro.h"
33
34 const char comment_chars[] = ";";
35 /* Note that input_file.c hand checks for '#' at the beginning of the
36 first line of the input file. This is because the compiler outputs
37 #NO_APP at the beginning of its output. */
38 const char line_comment_chars[] = "#";
39 /* Use something that isn't going to be needed by any expressions or
40 other syntax. */
41 const char line_separator_chars[] = "@";
42
43 const char EXP_CHARS[] = "eE";
44 const char FLT_CHARS[] = "dD";
45
46 /* ELF flags to set in the output file header. */
47 static int elf_flags = 0;
48
49 /*------------------------------------------------------------------*/
50
51 char * rl78_lex_start;
52 char * rl78_lex_end;
53
54 typedef struct rl78_bytesT
55 {
56 char prefix[1];
57 int n_prefix;
58 char base[4];
59 int n_base;
60 char ops[8];
61 int n_ops;
62 struct
63 {
64 expressionS exp;
65 char offset;
66 char nbits;
67 char type; /* RL78REL_*. */
68 int reloc;
69 fixS * fixP;
70 } fixups[2];
71 int n_fixups;
72 struct
73 {
74 char type;
75 char field_pos;
76 char val_ofs;
77 } relax[2];
78 int n_relax;
79 int link_relax;
80 fixS *link_relax_fixP;
81 char times_grown;
82 char times_shrank;
83 } rl78_bytesT;
84
85 static rl78_bytesT rl78_bytes;
86
87 void
88 rl78_relax (int type, int pos)
89 {
90 rl78_bytes.relax[rl78_bytes.n_relax].type = type;
91 rl78_bytes.relax[rl78_bytes.n_relax].field_pos = pos;
92 rl78_bytes.relax[rl78_bytes.n_relax].val_ofs = rl78_bytes.n_base + rl78_bytes.n_ops;
93 rl78_bytes.n_relax ++;
94 }
95
96 void
97 rl78_linkrelax_addr16 (void)
98 {
99 rl78_bytes.link_relax |= RL78_RELAXA_ADDR16;
100 }
101
102 void
103 rl78_linkrelax_branch (void)
104 {
105 rl78_relax (RL78_RELAX_BRANCH, 0);
106 rl78_bytes.link_relax |= RL78_RELAXA_BRA;
107 }
108
109 static void
110 rl78_fixup (expressionS exp, int offsetbits, int nbits, int type)
111 {
112 rl78_bytes.fixups[rl78_bytes.n_fixups].exp = exp;
113 rl78_bytes.fixups[rl78_bytes.n_fixups].offset = offsetbits;
114 rl78_bytes.fixups[rl78_bytes.n_fixups].nbits = nbits;
115 rl78_bytes.fixups[rl78_bytes.n_fixups].type = type;
116 rl78_bytes.fixups[rl78_bytes.n_fixups].reloc = exp.X_md;
117 rl78_bytes.n_fixups ++;
118 }
119
120 #define rl78_field_fixup(exp, offset, nbits, type) \
121 rl78_fixup (exp, offset + 8 * rl78_bytes.n_prefix), nbits, type)
122
123 #define rl78_op_fixup(exp, offset, nbits, type) \
124 rl78_fixup (exp, offset + 8 * (rl78_bytes.n_prefix + rl78_bytes.n_base), nbits, type)
125
126 void
127 rl78_prefix (int p)
128 {
129 rl78_bytes.prefix[0] = p;
130 rl78_bytes.n_prefix = 1;
131 }
132
133 int
134 rl78_has_prefix ()
135 {
136 return rl78_bytes.n_prefix;
137 }
138
139 void
140 rl78_base1 (int b1)
141 {
142 rl78_bytes.base[0] = b1;
143 rl78_bytes.n_base = 1;
144 }
145
146 void
147 rl78_base2 (int b1, int b2)
148 {
149 rl78_bytes.base[0] = b1;
150 rl78_bytes.base[1] = b2;
151 rl78_bytes.n_base = 2;
152 }
153
154 void
155 rl78_base3 (int b1, int b2, int b3)
156 {
157 rl78_bytes.base[0] = b1;
158 rl78_bytes.base[1] = b2;
159 rl78_bytes.base[2] = b3;
160 rl78_bytes.n_base = 3;
161 }
162
163 void
164 rl78_base4 (int b1, int b2, int b3, int b4)
165 {
166 rl78_bytes.base[0] = b1;
167 rl78_bytes.base[1] = b2;
168 rl78_bytes.base[2] = b3;
169 rl78_bytes.base[3] = b4;
170 rl78_bytes.n_base = 4;
171 }
172
173 #define F_PRECISION 2
174
175 void
176 rl78_op (expressionS exp, int nbytes, int type)
177 {
178 int v = 0;
179
180 if ((exp.X_op == O_constant || exp.X_op == O_big)
181 && type != RL78REL_PCREL)
182 {
183 if (exp.X_op == O_big && exp.X_add_number <= 0)
184 {
185 LITTLENUM_TYPE w[2];
186 char * ip = rl78_bytes.ops + rl78_bytes.n_ops;
187
188 gen_to_words (w, F_PRECISION, 8);
189 ip[3] = w[0] >> 8;
190 ip[2] = w[0];
191 ip[1] = w[1] >> 8;
192 ip[0] = w[1];
193 rl78_bytes.n_ops += 4;
194 }
195 else
196 {
197 v = exp.X_add_number;
198 while (nbytes)
199 {
200 rl78_bytes.ops[rl78_bytes.n_ops++] =v & 0xff;
201 v >>= 8;
202 nbytes --;
203 }
204 }
205 }
206 else
207 {
208 if (nbytes > 2
209 && exp.X_md == BFD_RELOC_RL78_CODE)
210 exp.X_md = 0;
211
212 if (nbytes == 1
213 && (exp.X_md == BFD_RELOC_RL78_LO16
214 || exp.X_md == BFD_RELOC_RL78_HI16))
215 as_bad (_("16-bit relocation used in 8-bit operand"));
216
217 if (nbytes == 2
218 && exp.X_md == BFD_RELOC_RL78_HI8)
219 as_bad (_("8-bit relocation used in 16-bit operand"));
220
221 rl78_op_fixup (exp, rl78_bytes.n_ops * 8, nbytes * 8, type);
222 memset (rl78_bytes.ops + rl78_bytes.n_ops, 0, nbytes);
223 rl78_bytes.n_ops += nbytes;
224 }
225 }
226
227 /* This gets complicated when the field spans bytes, because fields
228 are numbered from the MSB of the first byte as zero, and bits are
229 stored LSB towards the LSB of the byte. Thus, a simple four-bit
230 insertion of 12 at position 4 of 0x00 yields: 0x0b. A three-bit
231 insertion of b'MXL at position 7 is like this:
232
233 - - - - - - - - - - - - - - - -
234 M X L */
235
236 void
237 rl78_field (int val, int pos, int sz)
238 {
239 int valm;
240 int bytep, bitp;
241
242 if (sz > 0)
243 {
244 if (val < 0 || val >= (1 << sz))
245 as_bad (_("Value %d doesn't fit in unsigned %d-bit field"), val, sz);
246 }
247 else
248 {
249 sz = - sz;
250 if (val < -(1 << (sz - 1)) || val >= (1 << (sz - 1)))
251 as_bad (_("Value %d doesn't fit in signed %d-bit field"), val, sz);
252 }
253
254 /* This code points at 'M' in the above example. */
255 bytep = pos / 8;
256 bitp = pos % 8;
257
258 while (bitp + sz > 8)
259 {
260 int ssz = 8 - bitp;
261 int svalm;
262
263 svalm = val >> (sz - ssz);
264 svalm = svalm & ((1 << ssz) - 1);
265 svalm = svalm << (8 - bitp - ssz);
266 gas_assert (bytep < rl78_bytes.n_base);
267 rl78_bytes.base[bytep] |= svalm;
268
269 bitp = 0;
270 sz -= ssz;
271 bytep ++;
272 }
273 valm = val & ((1 << sz) - 1);
274 valm = valm << (8 - bitp - sz);
275 gas_assert (bytep < rl78_bytes.n_base);
276 rl78_bytes.base[bytep] |= valm;
277 }
278
279 /*------------------------------------------------------------------*/
280
281 enum options
282 {
283 OPTION_RELAX = OPTION_MD_BASE,
284 OPTION_NORELAX,
285 OPTION_G10,
286 OPTION_G13,
287 OPTION_G14,
288 OPTION_32BIT_DOUBLES,
289 OPTION_64BIT_DOUBLES,
290 };
291
292 #define RL78_SHORTOPTS ""
293 const char * md_shortopts = RL78_SHORTOPTS;
294
295 /* Assembler options. */
296 struct option md_longopts[] =
297 {
298 {"relax", no_argument, NULL, OPTION_RELAX},
299 {"norelax", no_argument, NULL, OPTION_NORELAX},
300 {"mg10", no_argument, NULL, OPTION_G10},
301 {"mg13", no_argument, NULL, OPTION_G13},
302 {"mg14", no_argument, NULL, OPTION_G14},
303 {"mrl78", no_argument, NULL, OPTION_G14},
304 {"m32bit-doubles", no_argument, NULL, OPTION_32BIT_DOUBLES},
305 {"m64bit-doubles", no_argument, NULL, OPTION_64BIT_DOUBLES},
306 {NULL, no_argument, NULL, 0}
307 };
308 size_t md_longopts_size = sizeof (md_longopts);
309
310 int
311 md_parse_option (int c, char * arg ATTRIBUTE_UNUSED)
312 {
313 switch (c)
314 {
315 case OPTION_RELAX:
316 linkrelax = 1;
317 return 1;
318 case OPTION_NORELAX:
319 linkrelax = 0;
320 return 1;
321
322 case OPTION_G10:
323 elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
324 elf_flags |= E_FLAG_RL78_G10;
325 return 1;
326
327 case OPTION_G13:
328 elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
329 elf_flags |= E_FLAG_RL78_G13;
330 return 1;
331
332 case OPTION_G14:
333 elf_flags &= ~ E_FLAG_RL78_CPU_MASK;
334 elf_flags |= E_FLAG_RL78_G14;
335 return 1;
336
337 case OPTION_32BIT_DOUBLES:
338 elf_flags &= ~ E_FLAG_RL78_64BIT_DOUBLES;
339 return 1;
340
341 case OPTION_64BIT_DOUBLES:
342 elf_flags |= E_FLAG_RL78_64BIT_DOUBLES;
343 return 1;
344 }
345 return 0;
346 }
347
348 int
349 rl78_isa_g10 (void)
350 {
351 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G10;
352 }
353
354 int
355 rl78_isa_g13 (void)
356 {
357 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G13;
358 }
359
360 int
361 rl78_isa_g14 (void)
362 {
363 return (elf_flags & E_FLAG_RL78_CPU_MASK) == E_FLAG_RL78_G14;
364 }
365
366 void
367 md_show_usage (FILE * stream)
368 {
369 fprintf (stream, _(" RL78 specific command line options:\n"));
370 fprintf (stream, _(" --mrelax Enable link time relaxation\n"));
371 fprintf (stream, _(" --mg10 Enable support for G10 variant\n"));
372 fprintf (stream, _(" --mg13 Selects the G13 core.\n"));
373 fprintf (stream, _(" --mg14 Selects the G14 core [default]\n"));
374 fprintf (stream, _(" --mrl78 Alias for --mg14\n"));
375 fprintf (stream, _(" --m32bit-doubles [default]\n"));
376 fprintf (stream, _(" --m64bit-doubles Source code uses 64-bit doubles\n"));
377 }
378
379 static void
380 s_bss (int ignore ATTRIBUTE_UNUSED)
381 {
382 int temp;
383
384 temp = get_absolute_expression ();
385 subseg_set (bss_section, (subsegT) temp);
386 demand_empty_rest_of_line ();
387 }
388
389 static void
390 rl78_float_cons (int ignore ATTRIBUTE_UNUSED)
391 {
392 if (elf_flags & E_FLAG_RL78_64BIT_DOUBLES)
393 return float_cons ('d');
394 return float_cons ('f');
395 }
396
397 /* The target specific pseudo-ops which we support. */
398 const pseudo_typeS md_pseudo_table[] =
399 {
400 /* Our "standard" pseudos. */
401 { "double", rl78_float_cons, 'd' },
402 { "bss", s_bss, 0 },
403 { "3byte", cons, 3 },
404 { "int", cons, 4 },
405 { "word", cons, 4 },
406
407 /* End of list marker. */
408 { NULL, NULL, 0 }
409 };
410
411 static symbolS * rl78_abs_sym = NULL;
412
413 void
414 md_begin (void)
415 {
416 rl78_abs_sym = symbol_make ("__rl78_abs__");
417 }
418
419 void
420 rl78_md_end (void)
421 {
422 }
423
424 /* Set the ELF specific flags. */
425 void
426 rl78_elf_final_processing (void)
427 {
428 elf_elfheader (stdoutput)->e_flags |= elf_flags;
429 }
430
431 /* Write a value out to the object file, using the appropriate endianness. */
432 void
433 md_number_to_chars (char * buf, valueT val, int n)
434 {
435 number_to_chars_littleendian (buf, val, n);
436 }
437
438 static void
439 require_end_of_expr (char *fname)
440 {
441 while (* input_line_pointer == ' '
442 || * input_line_pointer == '\t')
443 input_line_pointer ++;
444
445 if (! * input_line_pointer
446 || strchr ("\n\r,", * input_line_pointer)
447 || strchr (comment_chars, * input_line_pointer)
448 || strchr (line_comment_chars, * input_line_pointer)
449 || strchr (line_separator_chars, * input_line_pointer))
450 return;
451
452 as_bad (_("%%%s() must be outermost term in expression"), fname);
453 }
454
455 static struct
456 {
457 char * fname;
458 int reloc;
459 }
460 reloc_functions[] =
461 {
462 { "code", BFD_RELOC_RL78_CODE },
463 { "lo16", BFD_RELOC_RL78_LO16 },
464 { "hi16", BFD_RELOC_RL78_HI16 },
465 { "hi8", BFD_RELOC_RL78_HI8 },
466 { 0, 0 }
467 };
468
469 void
470 md_operand (expressionS * exp ATTRIBUTE_UNUSED)
471 {
472 int reloc = 0;
473 int i;
474
475 for (i = 0; reloc_functions[i].fname; i++)
476 {
477 int flen = strlen (reloc_functions[i].fname);
478
479 if (input_line_pointer[0] == '%'
480 && strncasecmp (input_line_pointer + 1, reloc_functions[i].fname, flen) == 0
481 && input_line_pointer[flen + 1] == '(')
482 {
483 reloc = reloc_functions[i].reloc;
484 input_line_pointer += flen + 2;
485 break;
486 }
487 }
488 if (reloc == 0)
489 return;
490
491 expression (exp);
492 if (* input_line_pointer == ')')
493 input_line_pointer ++;
494
495 exp->X_md = reloc;
496
497 require_end_of_expr (reloc_functions[i].fname);
498 }
499
500 void
501 rl78_frag_init (fragS * fragP)
502 {
503 if (rl78_bytes.n_relax || rl78_bytes.link_relax)
504 {
505 fragP->tc_frag_data = malloc (sizeof (rl78_bytesT));
506 memcpy (fragP->tc_frag_data, & rl78_bytes, sizeof (rl78_bytesT));
507 }
508 else
509 fragP->tc_frag_data = 0;
510 }
511
512 /* When relaxing, we need to output a reloc for any .align directive
513 so that we can retain this alignment as we adjust opcode sizes. */
514 void
515 rl78_handle_align (fragS * frag)
516 {
517 if (linkrelax
518 && (frag->fr_type == rs_align
519 || frag->fr_type == rs_align_code)
520 && frag->fr_address + frag->fr_fix > 0
521 && frag->fr_offset > 0
522 && now_seg != bss_section)
523 {
524 fix_new (frag, frag->fr_fix, 0,
525 &abs_symbol, RL78_RELAXA_ALIGN + frag->fr_offset,
526 0, BFD_RELOC_RL78_RELAX);
527 /* For the purposes of relaxation, this relocation is attached
528 to the byte *after* the alignment - i.e. the byte that must
529 remain aligned. */
530 fix_new (frag->fr_next, 0, 0,
531 &abs_symbol, RL78_RELAXA_ELIGN + frag->fr_offset,
532 0, BFD_RELOC_RL78_RELAX);
533 }
534 }
535
536 char *
537 md_atof (int type, char * litP, int * sizeP)
538 {
539 return ieee_md_atof (type, litP, sizeP, target_big_endian);
540 }
541
542 symbolS *
543 md_undefined_symbol (char * name ATTRIBUTE_UNUSED)
544 {
545 return NULL;
546 }
547
548 #define APPEND(B, N_B) \
549 if (rl78_bytes.N_B) \
550 { \
551 memcpy (bytes + idx, rl78_bytes.B, rl78_bytes.N_B); \
552 idx += rl78_bytes.N_B; \
553 }
554
555
556 void
557 md_assemble (char * str)
558 {
559 char * bytes;
560 fragS * frag_then = frag_now;
561 int idx = 0;
562 int i;
563 int rel;
564 expressionS *exp;
565
566 /*printf("\033[32mASM: %s\033[0m\n", str);*/
567
568 dwarf2_emit_insn (0);
569
570 memset (& rl78_bytes, 0, sizeof (rl78_bytes));
571
572 rl78_lex_init (str, str + strlen (str));
573
574 rl78_parse ();
575
576 /* This simplifies the relaxation code. */
577 if (rl78_bytes.n_relax || rl78_bytes.link_relax)
578 {
579 int olen = rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops;
580 /* We do it this way because we want the frag to have the
581 rl78_bytes in it, which we initialize above. The extra bytes
582 are for relaxing. */
583 bytes = frag_more (olen + 3);
584 frag_then = frag_now;
585 frag_variant (rs_machine_dependent,
586 olen /* max_chars */,
587 0 /* var */,
588 olen /* subtype */,
589 0 /* symbol */,
590 0 /* offset */,
591 0 /* opcode */);
592 frag_then->fr_opcode = bytes;
593 frag_then->fr_fix = olen + (bytes - frag_then->fr_literal);
594 frag_then->fr_subtype = olen;
595 frag_then->fr_var = 0;
596 }
597 else
598 {
599 bytes = frag_more (rl78_bytes.n_prefix + rl78_bytes.n_base + rl78_bytes.n_ops);
600 frag_then = frag_now;
601 }
602
603 APPEND (prefix, n_prefix);
604 APPEND (base, n_base);
605 APPEND (ops, n_ops);
606
607 if (rl78_bytes.link_relax)
608 {
609 fixS * f;
610
611 f = fix_new (frag_then,
612 (char *) bytes - frag_then->fr_literal,
613 0,
614 abs_section_sym,
615 rl78_bytes.link_relax | rl78_bytes.n_fixups,
616 0,
617 BFD_RELOC_RL78_RELAX);
618 frag_then->tc_frag_data->link_relax_fixP = f;
619 }
620
621 for (i = 0; i < rl78_bytes.n_fixups; i ++)
622 {
623 /* index: [nbytes][type] */
624 static int reloc_map[5][4] =
625 {
626 { 0, 0 },
627 { BFD_RELOC_8, BFD_RELOC_8_PCREL },
628 { BFD_RELOC_16, BFD_RELOC_16_PCREL },
629 { BFD_RELOC_24, BFD_RELOC_24_PCREL },
630 { BFD_RELOC_32, BFD_RELOC_32_PCREL },
631 };
632 fixS * f;
633
634 idx = rl78_bytes.fixups[i].offset / 8;
635 rel = reloc_map [rl78_bytes.fixups[i].nbits / 8][(int) rl78_bytes.fixups[i].type];
636
637 if (rl78_bytes.fixups[i].reloc)
638 rel = rl78_bytes.fixups[i].reloc;
639
640 if (frag_then->tc_frag_data)
641 exp = & frag_then->tc_frag_data->fixups[i].exp;
642 else
643 exp = & rl78_bytes.fixups[i].exp;
644
645 f = fix_new_exp (frag_then,
646 (char *) bytes + idx - frag_then->fr_literal,
647 rl78_bytes.fixups[i].nbits / 8,
648 exp,
649 rl78_bytes.fixups[i].type == RL78REL_PCREL ? 1 : 0,
650 rel);
651 if (frag_then->tc_frag_data)
652 frag_then->tc_frag_data->fixups[i].fixP = f;
653 }
654 }
655
656 void
657 rl78_cons_fix_new (fragS * frag,
658 int where,
659 int size,
660 expressionS * exp)
661 {
662 bfd_reloc_code_real_type type;
663 fixS *fixP;
664
665 switch (size)
666 {
667 case 1:
668 type = BFD_RELOC_8;
669 break;
670 case 2:
671 type = BFD_RELOC_16;
672 break;
673 case 3:
674 type = BFD_RELOC_24;
675 break;
676 case 4:
677 type = BFD_RELOC_32;
678 break;
679 default:
680 as_bad (_("unsupported constant size %d\n"), size);
681 return;
682 }
683
684 switch (exp->X_md)
685 {
686 case BFD_RELOC_RL78_CODE:
687 if (size == 2)
688 type = exp->X_md;
689 break;
690 case BFD_RELOC_RL78_LO16:
691 case BFD_RELOC_RL78_HI16:
692 if (size != 2)
693 {
694 /* Fixups to assembler generated expressions do not use %hi or %lo. */
695 if (frag->fr_file)
696 as_bad (_("%%hi16/%%lo16 only applies to .short or .hword"));
697 }
698 else
699 type = exp->X_md;
700 break;
701 case BFD_RELOC_RL78_HI8:
702 if (size != 1)
703 {
704 /* Fixups to assembler generated expressions do not use %hi or %lo. */
705 if (frag->fr_file)
706 as_bad (_("%%hi8 only applies to .byte"));
707 }
708 else
709 type = exp->X_md;
710 break;
711 default:
712 break;
713 }
714
715 if (exp->X_op == O_subtract && exp->X_op_symbol)
716 {
717 if (size != 4 && size != 2 && size != 1)
718 as_bad (_("difference of two symbols only supported with .long, .short, or .byte"));
719 else
720 type = BFD_RELOC_RL78_DIFF;
721 }
722
723 fixP = fix_new_exp (frag, where, (int) size, exp, 0, type);
724 switch (exp->X_md)
725 {
726 /* These are intended to have values larger than the container,
727 since the backend puts only the portion we need in it.
728 However, we don't have a backend-specific reloc for them as
729 they're handled with complex relocations. */
730 case BFD_RELOC_RL78_LO16:
731 case BFD_RELOC_RL78_HI16:
732 case BFD_RELOC_RL78_HI8:
733 fixP->fx_no_overflow = 1;
734 break;
735 default:
736 break;
737 }
738 }
739
740 \f
741 /*----------------------------------------------------------------------*/
742 /* To recap: we estimate everything based on md_estimate_size, then
743 adjust based on rl78_relax_frag. When it all settles, we call
744 md_convert frag to update the bytes. The relaxation types and
745 relocations are in fragP->tc_frag_data, which is a copy of that
746 rl78_bytes.
747
748 Our scheme is as follows: fr_fix has the size of the smallest
749 opcode (like BRA.S). We store the number of total bytes we need in
750 fr_subtype. When we're done relaxing, we use fr_subtype and the
751 existing opcode bytes to figure out what actual opcode we need to
752 put in there. If the fixup isn't resolvable now, we use the
753 maximal size. */
754
755 #define TRACE_RELAX 0
756 #define tprintf if (TRACE_RELAX) printf
757
758
759 typedef enum
760 {
761 OT_other,
762 OT_bt,
763 OT_bt_sfr,
764 OT_bt_es,
765 OT_bc,
766 OT_bh,
767 OT_sk,
768 OT_call,
769 OT_br,
770 } op_type_T;
771
772 /* We're looking for these types of relaxations:
773
774 BT 00110001 sbit0cc1 addr---- (cc is 10 (BF) or 01 (BT))
775 B~T 00110001 sbit0cc1 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
776
777 BT sfr 00110001 sbit0cc0 sfr----- addr----
778 BT ES: 00010001 00101110 sbit0cc1 addr----
779
780 BC 110111cc addr----
781 B~C 110111cc 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
782
783 BH 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
784 B~H 01100001 110c0011 00000011 11101110 pcrel16- -------- (BR $!pcrel20)
785 */
786
787 /* Given the opcode bytes at OP, figure out which opcode it is and
788 return the type of opcode. We use this to re-encode the opcode as
789 a different size later. */
790
791 static op_type_T
792 rl78_opcode_type (char * ops)
793 {
794 unsigned char *op = (unsigned char *)ops;
795
796 if (op[0] == 0x31
797 && ((op[1] & 0x0f) == 0x05
798 || (op[1] & 0x0f) == 0x03))
799 return OT_bt;
800
801 if (op[0] == 0x31
802 && ((op[1] & 0x0f) == 0x04
803 || (op[1] & 0x0f) == 0x02))
804 return OT_bt_sfr;
805
806 if (op[0] == 0x11
807 && op[1] == 0x31
808 && ((op[2] & 0x0f) == 0x05
809 || (op[2] & 0x0f) == 0x03))
810 return OT_bt_es;
811
812 if ((op[0] & 0xfc) == 0xdc)
813 return OT_bc;
814
815 if (op[0] == 0x61
816 && (op[1] & 0xef) == 0xc3)
817 return OT_bh;
818
819 if (op[0] == 0x61
820 && (op[1] & 0xcf) == 0xc8)
821 return OT_sk;
822
823 if (op[0] == 0x61
824 && (op[1] & 0xef) == 0xe3)
825 return OT_sk;
826
827 if (op[0] == 0xfc)
828 return OT_call;
829
830 if ((op[0] & 0xec) == 0xec)
831 return OT_br;
832
833 return OT_other;
834 }
835
836 /* Returns zero if *addrP has the target address. Else returns nonzero
837 if we cannot compute the target address yet. */
838
839 static int
840 rl78_frag_fix_value (fragS * fragP,
841 segT segment,
842 int which,
843 addressT * addrP,
844 int need_diff,
845 addressT * sym_addr)
846 {
847 addressT addr = 0;
848 rl78_bytesT * b = fragP->tc_frag_data;
849 expressionS * exp = & b->fixups[which].exp;
850
851 if (need_diff && exp->X_op != O_subtract)
852 return 1;
853
854 if (exp->X_add_symbol)
855 {
856 if (S_FORCE_RELOC (exp->X_add_symbol, 1))
857 return 1;
858 if (S_GET_SEGMENT (exp->X_add_symbol) != segment)
859 return 1;
860 addr += S_GET_VALUE (exp->X_add_symbol);
861 }
862
863 if (exp->X_op_symbol)
864 {
865 if (exp->X_op != O_subtract)
866 return 1;
867 if (S_FORCE_RELOC (exp->X_op_symbol, 1))
868 return 1;
869 if (S_GET_SEGMENT (exp->X_op_symbol) != segment)
870 return 1;
871 addr -= S_GET_VALUE (exp->X_op_symbol);
872 }
873 if (sym_addr)
874 * sym_addr = addr;
875 addr += exp->X_add_number;
876 * addrP = addr;
877 return 0;
878 }
879
880 /* Estimate how big the opcode is after this relax pass. The return
881 value is the difference between fr_fix and the actual size. We
882 compute the total size in rl78_relax_frag and store it in fr_subtype,
883 so we only need to subtract fx_fix and return it. */
884
885 int
886 md_estimate_size_before_relax (fragS * fragP ATTRIBUTE_UNUSED, segT segment ATTRIBUTE_UNUSED)
887 {
888 int opfixsize;
889 int delta;
890
891 /* This is the size of the opcode that's accounted for in fr_fix. */
892 opfixsize = fragP->fr_fix - (fragP->fr_opcode - fragP->fr_literal);
893 /* This is the size of the opcode that isn't. */
894 delta = (fragP->fr_subtype - opfixsize);
895
896 tprintf (" -> opfixsize %d delta %d\n", opfixsize, delta);
897 return delta;
898 }
899
900 /* Given the new addresses for this relax pass, figure out how big
901 each opcode must be. We store the total number of bytes needed in
902 fr_subtype. The return value is the difference between the size
903 after the last pass and the size after this pass, so we use the old
904 fr_subtype to calculate the difference. */
905
906 int
907 rl78_relax_frag (segT segment ATTRIBUTE_UNUSED, fragS * fragP, long stretch)
908 {
909 addressT addr0, sym_addr;
910 addressT mypc;
911 int disp;
912 int oldsize = fragP->fr_subtype;
913 int newsize = oldsize;
914 op_type_T optype;
915 int ri;
916
917 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
918
919 /* If we ever get more than one reloc per opcode, this is the one
920 we're relaxing. */
921 ri = 0;
922
923 optype = rl78_opcode_type (fragP->fr_opcode);
924 /* Try to get the target address. */
925 if (rl78_frag_fix_value (fragP, segment, ri, & addr0,
926 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH,
927 & sym_addr))
928 {
929 /* If we don't expect the linker to do relaxing, don't emit
930 expanded opcodes that only the linker will relax. */
931 if (!linkrelax)
932 return newsize - oldsize;
933
934 /* If we don't, we must use the maximum size for the linker. */
935 switch (fragP->tc_frag_data->relax[ri].type)
936 {
937 case RL78_RELAX_BRANCH:
938 switch (optype)
939 {
940 case OT_bt:
941 newsize = 6;
942 break;
943 case OT_bt_sfr:
944 case OT_bt_es:
945 newsize = 7;
946 break;
947 case OT_bc:
948 newsize = 5;
949 break;
950 case OT_bh:
951 newsize = 6;
952 break;
953 case OT_sk:
954 newsize = 2;
955 break;
956 default:
957 newsize = oldsize;
958 break;
959 }
960 break;
961
962 }
963 fragP->fr_subtype = newsize;
964 tprintf (" -> new %d old %d delta %d (external)\n", newsize, oldsize, newsize-oldsize);
965 return newsize - oldsize;
966 }
967
968 if (sym_addr > mypc)
969 addr0 += stretch;
970
971 switch (fragP->tc_frag_data->relax[ri].type)
972 {
973 case RL78_RELAX_BRANCH:
974 disp = (int) addr0 - (int) mypc;
975
976 switch (optype)
977 {
978 case OT_bt:
979 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
980 newsize = 3;
981 else
982 newsize = 6;
983 break;
984 case OT_bt_sfr:
985 case OT_bt_es:
986 if (disp >= -128 && (disp - (oldsize-3)) <= 127)
987 newsize = 4;
988 else
989 newsize = 7;
990 break;
991 case OT_bc:
992 if (disp >= -128 && (disp - (oldsize-1)) <= 127)
993 newsize = 2;
994 else
995 newsize = 5;
996 break;
997 case OT_bh:
998 if (disp >= -128 && (disp - (oldsize-2)) <= 127)
999 newsize = 3;
1000 else
1001 newsize = 6;
1002 break;
1003 case OT_sk:
1004 newsize = 2;
1005 break;
1006 default:
1007 newsize = oldsize;
1008 break;
1009 }
1010 break;
1011 }
1012
1013 /* This prevents infinite loops in align-heavy sources. */
1014 if (newsize < oldsize)
1015 {
1016 if (fragP->tc_frag_data->times_shrank > 10
1017 && fragP->tc_frag_data->times_grown > 10)
1018 newsize = oldsize;
1019 if (fragP->tc_frag_data->times_shrank < 20)
1020 fragP->tc_frag_data->times_shrank ++;
1021 }
1022 else if (newsize > oldsize)
1023 {
1024 if (fragP->tc_frag_data->times_grown < 20)
1025 fragP->tc_frag_data->times_grown ++;
1026 }
1027
1028 fragP->fr_subtype = newsize;
1029 tprintf (" -> new %d old %d delta %d\n", newsize, oldsize, newsize-oldsize);
1030 return newsize - oldsize;
1031 }
1032
1033 /* This lets us test for the opcode type and the desired size in a
1034 switch statement. */
1035 #define OPCODE(type,size) ((type) * 16 + (size))
1036
1037 /* Given the opcode stored in fr_opcode and the number of bytes we
1038 think we need, encode a new opcode. We stored a pointer to the
1039 fixup for this opcode in the tc_frag_data structure. If we can do
1040 the fixup here, we change the relocation type to "none" (we test
1041 for that in tc_gen_reloc) else we change it to the right type for
1042 the new (biggest) opcode. */
1043
1044 void
1045 md_convert_frag (bfd * abfd ATTRIBUTE_UNUSED,
1046 segT segment ATTRIBUTE_UNUSED,
1047 fragS * fragP ATTRIBUTE_UNUSED)
1048 {
1049 rl78_bytesT * rl78b = fragP->tc_frag_data;
1050 addressT addr0, mypc;
1051 int disp;
1052 int reloc_type, reloc_adjust;
1053 char * op = fragP->fr_opcode;
1054 int keep_reloc = 0;
1055 int ri;
1056 int fi = (rl78b->n_fixups > 1) ? 1 : 0;
1057 fixS * fix = rl78b->fixups[fi].fixP;
1058
1059 /* If we ever get more than one reloc per opcode, this is the one
1060 we're relaxing. */
1061 ri = 0;
1062
1063 /* We used a new frag for this opcode, so the opcode address should
1064 be the frag address. */
1065 mypc = fragP->fr_address + (fragP->fr_opcode - fragP->fr_literal);
1066 tprintf ("\033[32mmypc: 0x%x\033[0m\n", (int)mypc);
1067
1068 /* Try to get the target address. If we fail here, we just use the
1069 largest format. */
1070 if (rl78_frag_fix_value (fragP, segment, 0, & addr0,
1071 fragP->tc_frag_data->relax[ri].type != RL78_RELAX_BRANCH, 0))
1072 {
1073 /* We don't know the target address. */
1074 keep_reloc = 1;
1075 addr0 = 0;
1076 disp = 0;
1077 tprintf ("unknown addr ? - %x = ?\n", (int)mypc);
1078 }
1079 else
1080 {
1081 /* We know the target address, and it's in addr0. */
1082 disp = (int) addr0 - (int) mypc;
1083 tprintf ("known addr %x - %x = %d\n", (int)addr0, (int)mypc, disp);
1084 }
1085
1086 if (linkrelax)
1087 keep_reloc = 1;
1088
1089 reloc_type = BFD_RELOC_NONE;
1090 reloc_adjust = 0;
1091
1092 switch (fragP->tc_frag_data->relax[ri].type)
1093 {
1094 case RL78_RELAX_BRANCH:
1095 switch (OPCODE (rl78_opcode_type (fragP->fr_opcode), fragP->fr_subtype))
1096 {
1097
1098 case OPCODE (OT_bt, 3): /* BT A,$ - no change. */
1099 disp -= 3;
1100 op[2] = disp;
1101 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1102 break;
1103
1104 case OPCODE (OT_bt, 6): /* BT A,$ - long version. */
1105 disp -= 3;
1106 op[1] ^= 0x06; /* toggle conditional. */
1107 op[2] = 3; /* displacement over long branch. */
1108 disp -= 3;
1109 op[3] = 0xEE; /* BR $!addr20 */
1110 op[4] = disp & 0xff;
1111 op[5] = disp >> 8;
1112 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1113 reloc_adjust = 2;
1114 break;
1115
1116 case OPCODE (OT_bt_sfr, 4): /* BT PSW,$ - no change. */
1117 disp -= 4;
1118 op[3] = disp;
1119 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1120 break;
1121
1122 case OPCODE (OT_bt_sfr, 7): /* BT PSW,$ - long version. */
1123 disp -= 4;
1124 op[1] ^= 0x06; /* toggle conditional. */
1125 op[3] = 3; /* displacement over long branch. */
1126 disp -= 3;
1127 op[4] = 0xEE; /* BR $!addr20 */
1128 op[5] = disp & 0xff;
1129 op[6] = disp >> 8;
1130 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1131 reloc_adjust = 2;
1132 break;
1133
1134 case OPCODE (OT_bt_es, 4): /* BT ES:[HL],$ - no change. */
1135 disp -= 4;
1136 op[3] = disp;
1137 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1138 break;
1139
1140 case OPCODE (OT_bt_es, 7): /* BT PSW,$ - long version. */
1141 disp -= 4;
1142 op[2] ^= 0x06; /* toggle conditional. */
1143 op[3] = 3; /* displacement over long branch. */
1144 disp -= 3;
1145 op[4] = 0xEE; /* BR $!addr20 */
1146 op[5] = disp & 0xff;
1147 op[6] = disp >> 8;
1148 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1149 reloc_adjust = 2;
1150 break;
1151
1152 case OPCODE (OT_bc, 2): /* BC $ - no change. */
1153 disp -= 2;
1154 op[1] = disp;
1155 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1156 break;
1157
1158 case OPCODE (OT_bc, 5): /* BC $ - long version. */
1159 disp -= 2;
1160 op[0] ^= 0x02; /* toggle conditional. */
1161 op[1] = 3;
1162 disp -= 3;
1163 op[2] = 0xEE; /* BR $!addr20 */
1164 op[3] = disp & 0xff;
1165 op[4] = disp >> 8;
1166 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1167 reloc_adjust = 2;
1168 break;
1169
1170 case OPCODE (OT_bh, 3): /* BH $ - no change. */
1171 disp -= 3;
1172 op[2] = disp;
1173 reloc_type = keep_reloc ? BFD_RELOC_8_PCREL : BFD_RELOC_NONE;
1174 break;
1175
1176 case OPCODE (OT_bh, 6): /* BC $ - long version. */
1177 disp -= 3;
1178 op[1] ^= 0x10; /* toggle conditional. */
1179 op[2] = 3;
1180 disp -= 3;
1181 op[3] = 0xEE; /* BR $!addr20 */
1182 op[4] = disp & 0xff;
1183 op[5] = disp >> 8;
1184 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1185 reloc_adjust = 2;
1186 break;
1187
1188 case OPCODE (OT_sk, 2): /* SK<cond> - no change */
1189 reloc_type = keep_reloc ? BFD_RELOC_16_PCREL : BFD_RELOC_NONE;
1190 break;
1191
1192 default:
1193 reloc_type = fix ? fix->fx_r_type : BFD_RELOC_NONE;
1194 break;
1195 }
1196 break;
1197
1198 default:
1199 if (rl78b->n_fixups)
1200 {
1201 reloc_type = fix->fx_r_type;
1202 reloc_adjust = 0;
1203 }
1204 break;
1205 }
1206
1207 if (rl78b->n_fixups)
1208 {
1209
1210 fix->fx_r_type = reloc_type;
1211 fix->fx_where += reloc_adjust;
1212 switch (reloc_type)
1213 {
1214 case BFD_RELOC_NONE:
1215 fix->fx_size = 0;
1216 break;
1217 case BFD_RELOC_8:
1218 fix->fx_size = 1;
1219 break;
1220 case BFD_RELOC_16_PCREL:
1221 fix->fx_size = 2;
1222 break;
1223 }
1224 }
1225
1226 fragP->fr_fix = fragP->fr_subtype + (fragP->fr_opcode - fragP->fr_literal);
1227 tprintf ("fragP->fr_fix now %ld (%d + (%p - %p)\n", (long) fragP->fr_fix,
1228 fragP->fr_subtype, fragP->fr_opcode, fragP->fr_literal);
1229 fragP->fr_var = 0;
1230
1231 tprintf ("compare 0x%lx vs 0x%lx - 0x%lx = 0x%lx (%p)\n",
1232 (long)fragP->fr_fix,
1233 (long)fragP->fr_next->fr_address, (long)fragP->fr_address,
1234 (long)(fragP->fr_next->fr_address - fragP->fr_address),
1235 fragP->fr_next);
1236
1237 if (fragP->fr_next != NULL
1238 && ((offsetT) (fragP->fr_next->fr_address - fragP->fr_address)
1239 != fragP->fr_fix))
1240 as_bad (_("bad frag at %p : fix %ld addr %ld %ld \n"), fragP,
1241 (long) fragP->fr_fix,
1242 (long) fragP->fr_address, (long) fragP->fr_next->fr_address);
1243 }
1244
1245 /* End of relaxation code.
1246 ----------------------------------------------------------------------*/
1247 \f
1248
1249 arelent **
1250 tc_gen_reloc (asection * seg ATTRIBUTE_UNUSED, fixS * fixp)
1251 {
1252 static arelent * reloc[8];
1253 int rp;
1254
1255 if (fixp->fx_r_type == BFD_RELOC_NONE)
1256 {
1257 reloc[0] = NULL;
1258 return reloc;
1259 }
1260
1261 if (fixp->fx_r_type == BFD_RELOC_RL78_RELAX && !linkrelax)
1262 {
1263 reloc[0] = NULL;
1264 return reloc;
1265 }
1266
1267 if (fixp->fx_subsy
1268 && S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
1269 {
1270 fixp->fx_offset -= S_GET_VALUE (fixp->fx_subsy);
1271 fixp->fx_subsy = NULL;
1272 }
1273
1274 reloc[0] = (arelent *) xmalloc (sizeof (arelent));
1275 reloc[0]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
1276 * reloc[0]->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
1277 reloc[0]->address = fixp->fx_frag->fr_address + fixp->fx_where;
1278 reloc[0]->addend = fixp->fx_offset;
1279
1280 if (fixp->fx_r_type == BFD_RELOC_RL78_32_OP
1281 && fixp->fx_subsy)
1282 {
1283 fixp->fx_r_type = BFD_RELOC_RL78_DIFF;
1284 }
1285
1286 #define OPX(REL,SYM,ADD) \
1287 reloc[rp] = (arelent *) xmalloc (sizeof (arelent)); \
1288 reloc[rp]->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); \
1289 reloc[rp]->howto = bfd_reloc_type_lookup (stdoutput, REL); \
1290 reloc[rp]->addend = ADD; \
1291 * reloc[rp]->sym_ptr_ptr = SYM; \
1292 reloc[rp]->address = fixp->fx_frag->fr_address + fixp->fx_where; \
1293 reloc[++rp] = NULL
1294 #define OPSYM(SYM) OPX(BFD_RELOC_RL78_SYM, SYM, 0)
1295
1296 /* FIXME: We cannot do the normal thing for an immediate value reloc,
1297 ie creating a RL78_SYM reloc in the *ABS* section with an offset
1298 equal to the immediate value we want to store. This fails because
1299 the reloc processing in bfd_perform_relocation and bfd_install_relocation
1300 will short circuit such relocs and never pass them on to the special
1301 reloc processing code. So instead we create a RL78_SYM reloc against
1302 the __rl78_abs__ symbol and arrange for the linker scripts to place
1303 this symbol at address 0. */
1304 #define OPIMM(IMM) OPX (BFD_RELOC_RL78_SYM, symbol_get_bfdsym (rl78_abs_sym), IMM)
1305
1306 #define OP(OP) OPX(BFD_RELOC_RL78_##OP, *reloc[0]->sym_ptr_ptr, 0)
1307 #define SYM0() reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_SYM)
1308
1309 rp = 1;
1310
1311 /* Certain BFD relocations cannot be translated directly into
1312 a single (non-Red Hat) RL78 relocation, but instead need
1313 multiple RL78 relocations - handle them here. */
1314 switch (fixp->fx_r_type)
1315 {
1316 case BFD_RELOC_RL78_DIFF:
1317 SYM0 ();
1318 OPSYM (symbol_get_bfdsym (fixp->fx_subsy));
1319 OP(OP_SUBTRACT);
1320
1321 switch (fixp->fx_size)
1322 {
1323 case 1:
1324 OP(ABS8);
1325 break;
1326 case 2:
1327 OP (ABS16);
1328 break;
1329 case 4:
1330 OP (ABS32);
1331 break;
1332 }
1333 break;
1334
1335 case BFD_RELOC_RL78_NEG32:
1336 SYM0 ();
1337 OP (OP_NEG);
1338 OP (ABS32);
1339 break;
1340
1341 case BFD_RELOC_RL78_CODE:
1342 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_RL78_16U);
1343 reloc[1] = NULL;
1344 break;
1345
1346 case BFD_RELOC_RL78_LO16:
1347 SYM0 ();
1348 OPIMM (0xffff);
1349 OP (OP_AND);
1350 OP (ABS16);
1351 break;
1352
1353 case BFD_RELOC_RL78_HI16:
1354 SYM0 ();
1355 OPIMM (16);
1356 OP (OP_SHRA);
1357 OP (ABS16);
1358 break;
1359
1360 case BFD_RELOC_RL78_HI8:
1361 SYM0 ();
1362 OPIMM (16);
1363 OP (OP_SHRA);
1364 OPIMM (0xff);
1365 OP (OP_AND);
1366 OP (ABS8);
1367 break;
1368
1369 default:
1370 reloc[0]->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
1371 reloc[1] = NULL;
1372 break;
1373 }
1374
1375 return reloc;
1376 }
1377
1378 int
1379 rl78_validate_fix_sub (struct fix * f)
1380 {
1381 /* We permit the subtraction of two symbols in a few cases. */
1382 /* mov #sym1-sym2, R3 */
1383 if (f->fx_r_type == BFD_RELOC_RL78_32_OP)
1384 return 1;
1385 /* .long sym1-sym2 */
1386 if (f->fx_r_type == BFD_RELOC_RL78_DIFF
1387 && ! f->fx_pcrel
1388 && (f->fx_size == 4 || f->fx_size == 2 || f->fx_size == 1))
1389 return 1;
1390 return 0;
1391 }
1392
1393 long
1394 md_pcrel_from_section (fixS * fixP, segT sec)
1395 {
1396 long rv;
1397
1398 if (fixP->fx_addsy != NULL
1399 && (! S_IS_DEFINED (fixP->fx_addsy)
1400 || S_GET_SEGMENT (fixP->fx_addsy) != sec))
1401 /* The symbol is undefined (or is defined but not in this section).
1402 Let the linker figure it out. */
1403 return 0;
1404
1405 rv = fixP->fx_frag->fr_address + fixP->fx_where;
1406 switch (fixP->fx_r_type)
1407 {
1408 case BFD_RELOC_8_PCREL:
1409 rv += 1;
1410 break;
1411 case BFD_RELOC_16_PCREL:
1412 rv += 2;
1413 break;
1414 default:
1415 break;
1416 }
1417 return rv;
1418 }
1419
1420 void
1421 md_apply_fix (struct fix * f ATTRIBUTE_UNUSED,
1422 valueT * t ATTRIBUTE_UNUSED,
1423 segT s ATTRIBUTE_UNUSED)
1424 {
1425 char * op;
1426 unsigned long val;
1427
1428 /* We always defer overflow checks for these to the linker, as it
1429 needs to do PLT stuff. */
1430 if (f->fx_r_type == BFD_RELOC_RL78_CODE)
1431 f->fx_no_overflow = 1;
1432
1433 if (f->fx_addsy && S_FORCE_RELOC (f->fx_addsy, 1))
1434 return;
1435 if (f->fx_subsy && S_FORCE_RELOC (f->fx_subsy, 1))
1436 return;
1437
1438 op = f->fx_frag->fr_literal + f->fx_where;
1439 val = (unsigned long) * t;
1440
1441 if (f->fx_addsy == NULL)
1442 f->fx_done = 1;
1443
1444 switch (f->fx_r_type)
1445 {
1446 case BFD_RELOC_NONE:
1447 break;
1448
1449 case BFD_RELOC_RL78_RELAX:
1450 f->fx_done = 0;
1451 break;
1452
1453 case BFD_RELOC_8_PCREL:
1454 if ((long)val < -128 || (long)val > 127)
1455 as_bad_where (f->fx_file, f->fx_line,
1456 _("value of %ld too large for 8-bit branch"),
1457 val);
1458 /* Fall through. */
1459 case BFD_RELOC_8:
1460 case BFD_RELOC_RL78_SADDR: /* We need to store the 8 LSB, but this works. */
1461 op[0] = val;
1462 break;
1463
1464 case BFD_RELOC_16_PCREL:
1465 if ((long)val < -32768 || (long)val > 32767)
1466 as_bad_where (f->fx_file, f->fx_line,
1467 _("value of %ld too large for 16-bit branch"),
1468 val);
1469 /* Fall through. */
1470 case BFD_RELOC_16:
1471 case BFD_RELOC_RL78_CODE:
1472 op[0] = val;
1473 op[1] = val >> 8;
1474 break;
1475
1476 case BFD_RELOC_24:
1477 op[0] = val;
1478 op[1] = val >> 8;
1479 op[2] = val >> 16;
1480 break;
1481
1482 case BFD_RELOC_32:
1483 op[0] = val;
1484 op[1] = val >> 8;
1485 op[2] = val >> 16;
1486 op[3] = val >> 24;
1487 break;
1488
1489 case BFD_RELOC_RL78_DIFF:
1490 op[0] = val;
1491 if (f->fx_size > 1)
1492 op[1] = val >> 8;
1493 if (f->fx_size > 2)
1494 op[2] = val >> 16;
1495 if (f->fx_size > 3)
1496 op[3] = val >> 24;
1497 break;
1498
1499 case BFD_RELOC_RL78_HI8:
1500 val = val >> 16;
1501 op[0] = val;
1502 break;
1503
1504 case BFD_RELOC_RL78_HI16:
1505 val = val >> 16;
1506 op[0] = val;
1507 op[1] = val >> 8;
1508 break;
1509
1510 case BFD_RELOC_RL78_LO16:
1511 op[0] = val;
1512 op[1] = val >> 8;
1513 break;
1514
1515 default:
1516 as_bad (_("Unknown reloc in md_apply_fix: %s"),
1517 bfd_get_reloc_code_name (f->fx_r_type));
1518 break;
1519 }
1520
1521 }
1522
1523 valueT
1524 md_section_align (segT segment, valueT size)
1525 {
1526 int align = bfd_get_section_alignment (stdoutput, segment);
1527 return ((size + (1 << align) - 1) & -(1 << align));
1528 }
GDB Binutils - Deliverables
This page took 0.062017 seconds and 4 git commands to generate.