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