1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011-2015 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program 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 of the License, or
9 (at your option) any later version.
11 This program 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.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "bfd_stdint.h"
26 #include "libiberty.h"
28 #define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
30 #define RL78REL(n,sz,bit,shift,complain,pcrel) \
31 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
32 bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
34 static bfd_reloc_status_type rl78_special_reloc (bfd *, arelent *, asymbol *, void *,
35 asection *, bfd *, char **);
37 /* FIXME: We could omit the SHIFT parameter, it is always zero. */
38 #define RL78_OP_REL(n,sz,bit,shift,complain,pcrel) \
39 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
40 rl78_special_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
42 /* Note that the relocations around 0x7f are internal to this file;
43 feel free to move them as needed to avoid conflicts with published
44 relocation numbers. */
46 static reloc_howto_type rl78_elf_howto_table [] =
48 RL78REL (NONE, 3, 0, 0, dont, FALSE),
49 RL78REL (DIR32, 2, 32, 0, signed, FALSE),
50 RL78REL (DIR24S, 2, 24, 0, signed, FALSE),
51 RL78REL (DIR16, 1, 16, 0, dont, FALSE),
52 RL78REL (DIR16U, 1, 16, 0, unsigned, FALSE),
53 RL78REL (DIR16S, 1, 16, 0, signed, FALSE),
54 RL78REL (DIR8, 0, 8, 0, dont, FALSE),
55 RL78REL (DIR8U, 0, 8, 0, unsigned, FALSE),
56 RL78REL (DIR8S, 0, 8, 0, signed, FALSE),
57 RL78REL (DIR24S_PCREL, 2, 24, 0, signed, TRUE),
58 RL78REL (DIR16S_PCREL, 1, 16, 0, signed, TRUE),
59 RL78REL (DIR8S_PCREL, 0, 8, 0, signed, TRUE),
60 RL78REL (DIR16UL, 1, 16, 2, unsigned, FALSE),
61 RL78REL (DIR16UW, 1, 16, 1, unsigned, FALSE),
62 RL78REL (DIR8UL, 0, 8, 2, unsigned, FALSE),
63 RL78REL (DIR8UW, 0, 8, 1, unsigned, FALSE),
64 RL78REL (DIR32_REV, 1, 16, 0, dont, FALSE),
65 RL78REL (DIR16_REV, 1, 16, 0, dont, FALSE),
66 RL78REL (DIR3U_PCREL, 0, 3, 0, dont, TRUE),
95 RL78REL (RH_RELAX, 0, 0, 0, dont, FALSE),
98 RL78REL (RH_SADDR, 0, 0, 0, dont, FALSE),
117 RL78_OP_REL (ABS32, 2, 32, 0, dont, FALSE),
118 RL78_OP_REL (ABS24S, 2, 24, 0, signed, FALSE),
119 RL78_OP_REL (ABS16, 1, 16, 0, dont, FALSE),
120 RL78_OP_REL (ABS16U, 1, 16, 0, unsigned, FALSE),
121 RL78_OP_REL (ABS16S, 1, 16, 0, signed, FALSE),
122 RL78_OP_REL (ABS8, 0, 8, 0, dont, FALSE),
123 RL78_OP_REL (ABS8U, 0, 8, 0, unsigned, FALSE),
124 RL78_OP_REL (ABS8S, 0, 8, 0, signed, FALSE),
125 RL78_OP_REL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
126 RL78_OP_REL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
127 RL78_OP_REL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
128 RL78_OP_REL (ABS16UL, 1, 16, 0, unsigned, FALSE),
129 RL78_OP_REL (ABS16UW, 1, 16, 0, unsigned, FALSE),
130 RL78_OP_REL (ABS8UL, 0, 8, 0, unsigned, FALSE),
131 RL78_OP_REL (ABS8UW, 0, 8, 0, unsigned, FALSE),
132 RL78_OP_REL (ABS32_REV, 2, 32, 0, dont, FALSE),
133 RL78_OP_REL (ABS16_REV, 1, 16, 0, dont, FALSE),
135 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
185 RL78_OP_REL (SYM, 2, 32, 0, dont, FALSE),
186 RL78_OP_REL (OPneg, 2, 32, 0, dont, FALSE),
187 RL78_OP_REL (OPadd, 2, 32, 0, dont, FALSE),
188 RL78_OP_REL (OPsub, 2, 32, 0, dont, FALSE),
189 RL78_OP_REL (OPmul, 2, 32, 0, dont, FALSE),
190 RL78_OP_REL (OPdiv, 2, 32, 0, dont, FALSE),
191 RL78_OP_REL (OPshla, 2, 32, 0, dont, FALSE),
192 RL78_OP_REL (OPshra, 2, 32, 0, dont, FALSE),
193 RL78_OP_REL (OPsctsize, 2, 32, 0, dont, FALSE),
198 RL78_OP_REL (OPscttop, 2, 32, 0, dont, FALSE),
201 RL78_OP_REL (OPand, 2, 32, 0, dont, FALSE),
202 RL78_OP_REL (OPor, 2, 32, 0, dont, FALSE),
203 RL78_OP_REL (OPxor, 2, 32, 0, dont, FALSE),
204 RL78_OP_REL (OPnot, 2, 32, 0, dont, FALSE),
205 RL78_OP_REL (OPmod, 2, 32, 0, dont, FALSE),
206 RL78_OP_REL (OPromtop, 2, 32, 0, dont, FALSE),
207 RL78_OP_REL (OPramtop, 2, 32, 0, dont, FALSE)
210 /* Map BFD reloc types to RL78 ELF reloc types. */
212 struct rl78_reloc_map
214 bfd_reloc_code_real_type bfd_reloc_val;
215 unsigned int rl78_reloc_val;
218 static const struct rl78_reloc_map rl78_reloc_map [] =
220 { BFD_RELOC_NONE, R_RL78_NONE },
221 { BFD_RELOC_8, R_RL78_DIR8S },
222 { BFD_RELOC_16, R_RL78_DIR16S },
223 { BFD_RELOC_24, R_RL78_DIR24S },
224 { BFD_RELOC_32, R_RL78_DIR32 },
225 { BFD_RELOC_RL78_16_OP, R_RL78_DIR16 },
226 { BFD_RELOC_RL78_DIR3U_PCREL, R_RL78_DIR3U_PCREL },
227 { BFD_RELOC_8_PCREL, R_RL78_DIR8S_PCREL },
228 { BFD_RELOC_16_PCREL, R_RL78_DIR16S_PCREL },
229 { BFD_RELOC_24_PCREL, R_RL78_DIR24S_PCREL },
230 { BFD_RELOC_RL78_8U, R_RL78_DIR8U },
231 { BFD_RELOC_RL78_16U, R_RL78_DIR16U },
232 { BFD_RELOC_RL78_SYM, R_RL78_SYM },
233 { BFD_RELOC_RL78_OP_SUBTRACT, R_RL78_OPsub },
234 { BFD_RELOC_RL78_OP_NEG, R_RL78_OPneg },
235 { BFD_RELOC_RL78_OP_AND, R_RL78_OPand },
236 { BFD_RELOC_RL78_OP_SHRA, R_RL78_OPshra },
237 { BFD_RELOC_RL78_ABS8, R_RL78_ABS8 },
238 { BFD_RELOC_RL78_ABS16, R_RL78_ABS16 },
239 { BFD_RELOC_RL78_ABS16_REV, R_RL78_ABS16_REV },
240 { BFD_RELOC_RL78_ABS32, R_RL78_ABS32 },
241 { BFD_RELOC_RL78_ABS32_REV, R_RL78_ABS32_REV },
242 { BFD_RELOC_RL78_ABS16UL, R_RL78_ABS16UL },
243 { BFD_RELOC_RL78_ABS16UW, R_RL78_ABS16UW },
244 { BFD_RELOC_RL78_ABS16U, R_RL78_ABS16U },
245 { BFD_RELOC_RL78_SADDR, R_RL78_RH_SADDR },
246 { BFD_RELOC_RL78_RELAX, R_RL78_RH_RELAX }
249 static reloc_howto_type *
250 rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
251 bfd_reloc_code_real_type code)
255 if (code == BFD_RELOC_RL78_32_OP)
256 return rl78_elf_howto_table + R_RL78_DIR32;
258 for (i = ARRAY_SIZE (rl78_reloc_map); i--;)
259 if (rl78_reloc_map [i].bfd_reloc_val == code)
260 return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
265 static reloc_howto_type *
266 rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
270 for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
271 if (rl78_elf_howto_table[i].name != NULL
272 && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
273 return rl78_elf_howto_table + i;
278 /* Set the howto pointer for an RL78 ELF reloc. */
281 rl78_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
283 Elf_Internal_Rela * dst)
287 r_type = ELF32_R_TYPE (dst->r_info);
288 if (r_type >= (unsigned int) R_RL78_max)
290 _bfd_error_handler (_("%B: invalid RL78 reloc number: %d"), abfd, r_type);
293 cache_ptr->howto = rl78_elf_howto_table + r_type;
297 get_symbol_value (const char * name,
298 bfd_reloc_status_type * status,
299 struct bfd_link_info * info,
301 asection * input_section,
304 struct bfd_link_hash_entry * h;
309 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
312 || (h->type != bfd_link_hash_defined
313 && h->type != bfd_link_hash_defweak))
315 bfd_reloc_status_type res;
317 res = info->callbacks->undefined_symbol
318 (info, name, input_bfd, input_section, offset, TRUE);
324 return (h->u.def.value
325 + h->u.def.section->output_section->vma
326 + h->u.def.section->output_offset);
330 get_romstart (bfd_reloc_status_type * status,
331 struct bfd_link_info * info,
336 static bfd_boolean cached = FALSE;
337 static bfd_vma cached_value = 0;
338 static bfd_reloc_status_type cached_status;
342 cached_value = get_symbol_value ("_start", & cached_status, info, abfd, sec, offset);
346 * status = cached_status;
351 get_ramstart (bfd_reloc_status_type * status,
352 struct bfd_link_info * info,
357 static bfd_boolean cached = FALSE;
358 static bfd_vma cached_value = 0;
359 static bfd_reloc_status_type cached_status;
363 cached_value = get_symbol_value ("__datastart", & cached_status, info, abfd, sec, offset);
367 * status = cached_status;
371 #define NUM_STACK_ENTRIES 16
372 static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
373 static unsigned int rl78_stack_top;
375 #define RL78_STACK_PUSH(val) \
378 if (rl78_stack_top < NUM_STACK_ENTRIES) \
379 rl78_stack [rl78_stack_top ++] = (val); \
381 _bfd_error_handler (_("Internal Error: RL78 reloc stack overflow")); \
385 #define RL78_STACK_POP(dest) \
388 if (rl78_stack_top > 0) \
389 (dest) = rl78_stack [-- rl78_stack_top];\
392 _bfd_error_handler (_("Internal Error: RL78 reloc stack underflow")); \
398 /* Special handling for RL78 complex relocs. Returns the
399 value of the reloc, or 0 for relocs which do not generate
400 a result. SYMVAL is the value of the symbol for relocs
401 which use a symbolic argument. */
404 rl78_compute_complex_reloc (unsigned long r_type,
406 asection * input_section)
416 case R_RL78_ABS24S_PCREL:
417 case R_RL78_ABS16S_PCREL:
418 case R_RL78_ABS8S_PCREL:
419 RL78_STACK_POP (relocation);
420 relocation -= input_section->output_section->vma + input_section->output_offset;
424 case R_RL78_ABS32_REV:
426 case R_RL78_ABS16_REV:
432 RL78_STACK_POP (relocation);
437 RL78_STACK_POP (relocation);
438 return relocation >> 2;
442 RL78_STACK_POP (relocation);
443 return relocation >> 1;
445 /* The rest of the relocs compute values and then push them onto the stack. */
446 case R_RL78_OPramtop:
447 case R_RL78_OPromtop:
449 RL78_STACK_PUSH (symval);
453 RL78_STACK_POP (tmp1);
455 RL78_STACK_PUSH (tmp1);
459 RL78_STACK_POP (tmp2);
460 RL78_STACK_POP (tmp1);
462 RL78_STACK_PUSH (tmp1);
466 /* For the expression "A - B", the assembler pushes A,
467 then B, then OPSUB. So the first op we pop is B, not A. */
468 RL78_STACK_POP (tmp2); /* B */
469 RL78_STACK_POP (tmp1); /* A */
470 tmp1 -= tmp2; /* A - B */
471 RL78_STACK_PUSH (tmp1);
475 RL78_STACK_POP (tmp2);
476 RL78_STACK_POP (tmp1);
478 RL78_STACK_PUSH (tmp1);
482 RL78_STACK_POP (tmp2);
483 RL78_STACK_POP (tmp1);
485 RL78_STACK_PUSH (tmp1);
489 RL78_STACK_POP (tmp2);
490 RL78_STACK_POP (tmp1);
492 RL78_STACK_PUSH (tmp1);
496 RL78_STACK_POP (tmp2);
497 RL78_STACK_POP (tmp1);
499 RL78_STACK_PUSH (tmp1);
502 case R_RL78_OPsctsize:
503 RL78_STACK_PUSH (input_section->size);
506 case R_RL78_OPscttop:
507 RL78_STACK_PUSH (input_section->output_section->vma);
511 RL78_STACK_POP (tmp2);
512 RL78_STACK_POP (tmp1);
514 RL78_STACK_PUSH (tmp1);
518 RL78_STACK_POP (tmp2);
519 RL78_STACK_POP (tmp1);
521 RL78_STACK_PUSH (tmp1);
525 RL78_STACK_POP (tmp2);
526 RL78_STACK_POP (tmp1);
528 RL78_STACK_PUSH (tmp1);
532 RL78_STACK_POP (tmp1);
534 RL78_STACK_PUSH (tmp1);
538 RL78_STACK_POP (tmp2);
539 RL78_STACK_POP (tmp1);
541 RL78_STACK_PUSH (tmp1);
546 #undef RL78_STACK_PUSH
547 #undef RL78_STACK_POP
549 #define OP(i) (contents[reloc->address + (i)])
551 static bfd_reloc_status_type
552 rl78_special_reloc (bfd * input_bfd,
556 asection * input_section,
557 bfd * output_bfd ATTRIBUTE_UNUSED,
558 char ** error_message ATTRIBUTE_UNUSED)
560 bfd_reloc_status_type r = bfd_reloc_ok;
561 bfd_vma relocation = 0;
562 unsigned long r_type = reloc->howto->type;
563 bfd_byte * contents = data;
565 /* If necessary, compute the symbolic value of the relocation. */
569 relocation = (symbol->value
570 + symbol->section->output_section->vma
571 + symbol->section->output_offset
575 case R_RL78_OPromtop:
576 relocation = get_romstart (&r, NULL, input_bfd, input_section,
580 case R_RL78_OPramtop:
581 relocation = get_ramstart (&r, NULL, input_bfd, input_section,
586 /* Get the value of the relocation. */
587 relocation = rl78_compute_complex_reloc (r_type, relocation, input_section);
589 /* If the relocation alters the contents of the section then apply it now.
590 Note - since this function is called from
591 bfd_generic_get_relocated_section_contents via bfd_perform_relocation,
592 and not from the linker, we do not perform any range checking. The
593 clients who are calling us are only interested in some relocated section
594 contents, and not any linkage problems that might occur later. */
599 OP (1) = relocation >> 8;
600 OP (2) = relocation >> 16;
601 OP (3) = relocation >> 24;
604 case R_RL78_ABS32_REV:
606 OP (2) = relocation >> 8;
607 OP (1) = relocation >> 16;
608 OP (0) = relocation >> 24;
611 case R_RL78_ABS24S_PCREL:
614 OP (1) = relocation >> 8;
615 OP (2) = relocation >> 16;
618 case R_RL78_ABS16_REV:
620 OP (0) = relocation >> 8;
623 case R_RL78_ABS16S_PCREL:
630 OP (1) = relocation >> 8;
633 case R_RL78_ABS8S_PCREL:
650 #define OP(i) (contents[rel->r_offset + (i)])
652 /* Relocate an RL78 ELF section.
653 There is some attempt to make this function usable for many architectures,
654 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
655 if only to serve as a learning tool.
657 The RELOCATE_SECTION function is called by the new ELF backend linker
658 to handle the relocations for a section.
660 The relocs are always passed as Rela structures; if the section
661 actually uses Rel structures, the r_addend field will always be
664 This function is responsible for adjusting the section contents as
665 necessary, and (if using Rela relocs and generating a relocatable
666 output file) adjusting the reloc addend as necessary.
668 This function does not have to worry about setting the reloc
669 address or the reloc symbol index.
671 LOCAL_SYMS is a pointer to the swapped in local symbols.
673 LOCAL_SECTIONS is an array giving the section in the input file
674 corresponding to the st_shndx field of each local symbol.
676 The global hash table entry for the global symbols can be found
677 via elf_sym_hashes (input_bfd).
679 When generating relocatable output, this function must handle
680 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
681 going to be the section symbol corresponding to the output
682 section, which means that the addend must be adjusted
686 rl78_elf_relocate_section
688 struct bfd_link_info * info,
690 asection * input_section,
692 Elf_Internal_Rela * relocs,
693 Elf_Internal_Sym * local_syms,
694 asection ** local_sections)
696 Elf_Internal_Shdr * symtab_hdr;
697 struct elf_link_hash_entry ** sym_hashes;
698 Elf_Internal_Rela * rel;
699 Elf_Internal_Rela * relend;
703 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
704 sym_hashes = elf_sym_hashes (input_bfd);
705 relend = relocs + input_section->reloc_count;
707 dynobj = elf_hash_table (info)->dynobj;
710 splt = bfd_get_linker_section (dynobj, ".plt");
712 for (rel = relocs; rel < relend; rel ++)
714 reloc_howto_type * howto;
715 unsigned long r_symndx;
716 Elf_Internal_Sym * sym;
718 struct elf_link_hash_entry * h;
720 bfd_reloc_status_type r;
721 const char * name = NULL;
722 bfd_boolean unresolved_reloc = TRUE;
725 r_type = ELF32_R_TYPE (rel->r_info);
726 r_symndx = ELF32_R_SYM (rel->r_info);
728 howto = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
734 if (r_symndx < symtab_hdr->sh_info)
736 sym = local_syms + r_symndx;
737 sec = local_sections [r_symndx];
738 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
740 name = bfd_elf_string_from_elf_section
741 (input_bfd, symtab_hdr->sh_link, sym->st_name);
742 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
746 bfd_boolean warned ATTRIBUTE_UNUSED;
747 bfd_boolean ignored ATTRIBUTE_UNUSED;
749 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
750 r_symndx, symtab_hdr, sym_hashes, h,
751 sec, relocation, unresolved_reloc,
754 name = h->root.root.string;
757 if (sec != NULL && discarded_section (sec))
758 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
759 rel, 1, relend, howto, 0, contents);
761 if (bfd_link_relocatable (info))
763 /* This is a relocatable link. We don't have to change
764 anything, unless the reloc is against a section symbol,
765 in which case we have to adjust according to where the
766 section symbol winds up in the output section. */
767 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
768 rel->r_addend += sec->output_offset;
772 switch (ELF32_R_TYPE (rel->r_info))
779 plt_offset = &h->plt.offset;
781 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
783 if (! valid_16bit_address (relocation))
785 /* If this is the first time we've processed this symbol,
786 fill in the plt entry with the correct symbol address. */
787 if ((*plt_offset & 1) == 0)
791 x = 0x000000ec; /* br !!abs24 */
792 x |= (relocation << 8) & 0xffffff00;
793 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
797 relocation = (splt->output_section->vma
798 + splt->output_offset
799 + (*plt_offset & -2));
802 char *newname = bfd_malloc (strlen(name)+5);
803 strcpy (newname, name);
804 strcat(newname, ".plt");
805 _bfd_generic_link_add_one_symbol (info,
808 BSF_FUNCTION | BSF_WEAK,
821 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
822 /* If the symbol is undefined and weak
823 then the relocation resolves to zero. */
827 if (howto->pc_relative)
829 relocation -= (input_section->output_section->vma
830 + input_section->output_offset
832 relocation -= bfd_get_reloc_size (howto);
835 relocation += rel->r_addend;
840 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
842 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
848 case R_RL78_RH_RELAX:
851 case R_RL78_DIR8S_PCREL:
866 case R_RL78_DIR16S_PCREL:
867 RANGE (-32768, 32767);
869 OP (1) = relocation >> 8;
873 if ((relocation & 0xf0000) == 0xf0000)
874 relocation &= 0xffff;
875 RANGE (-32768, 65535);
877 OP (1) = relocation >> 8;
883 OP (1) = relocation >> 8;
887 RANGE (-32768, 65536);
889 OP (1) = relocation >> 8;
892 case R_RL78_DIR16_REV:
893 RANGE (-32768, 65536);
895 OP (0) = relocation >> 8;
898 case R_RL78_DIR3U_PCREL:
901 OP (0) |= relocation & 0x07;
904 case R_RL78_DIR24S_PCREL:
905 RANGE (-0x800000, 0x7fffff);
907 OP (1) = relocation >> 8;
908 OP (2) = relocation >> 16;
912 RANGE (-0x800000, 0x7fffff);
914 OP (1) = relocation >> 8;
915 OP (2) = relocation >> 16;
920 OP (1) = relocation >> 8;
921 OP (2) = relocation >> 16;
922 OP (3) = relocation >> 24;
925 case R_RL78_DIR32_REV:
927 OP (2) = relocation >> 8;
928 OP (1) = relocation >> 16;
929 OP (0) = relocation >> 24;
933 RANGE (0xfff00, 0xfffff);
934 OP (0) = relocation & 0xff;
937 case R_RL78_RH_SADDR:
938 RANGE (0xffe20, 0xfff1f);
939 OP (0) = relocation & 0xff;
942 /* Complex reloc handling: */
944 case R_RL78_ABS32_REV:
945 case R_RL78_ABS24S_PCREL:
948 case R_RL78_ABS16_REV:
949 case R_RL78_ABS16S_PCREL:
958 case R_RL78_ABS8S_PCREL:
967 case R_RL78_OPsctsize:
968 case R_RL78_OPscttop:
974 relocation = rl78_compute_complex_reloc (r_type, 0, input_section);
980 OP (1) = relocation >> 8;
981 OP (2) = relocation >> 16;
982 OP (3) = relocation >> 24;
985 case R_RL78_ABS32_REV:
987 OP (2) = relocation >> 8;
988 OP (1) = relocation >> 16;
989 OP (0) = relocation >> 24;
992 case R_RL78_ABS24S_PCREL:
994 RANGE (-0x800000, 0x7fffff);
996 OP (1) = relocation >> 8;
997 OP (2) = relocation >> 16;
1001 RANGE (-32768, 65535);
1002 OP (0) = relocation;
1003 OP (1) = relocation >> 8;
1006 case R_RL78_ABS16_REV:
1007 RANGE (-32768, 65535);
1008 OP (1) = relocation;
1009 OP (0) = relocation >> 8;
1012 case R_RL78_ABS16S_PCREL:
1014 RANGE (-32768, 32767);
1015 OP (0) = relocation;
1016 OP (1) = relocation >> 8;
1020 case R_RL78_ABS16UL:
1021 case R_RL78_ABS16UW:
1023 OP (0) = relocation;
1024 OP (1) = relocation >> 8;
1029 OP (0) = relocation;
1036 OP (0) = relocation;
1039 case R_RL78_ABS8S_PCREL:
1042 OP (0) = relocation;
1051 if (r_symndx < symtab_hdr->sh_info)
1052 relocation = sec->output_section->vma + sec->output_offset
1053 + sym->st_value + rel->r_addend;
1055 && (h->root.type == bfd_link_hash_defined
1056 || h->root.type == bfd_link_hash_defweak))
1057 relocation = h->root.u.def.value
1058 + sec->output_section->vma
1059 + sec->output_offset
1064 if (h->root.type != bfd_link_hash_undefweak)
1065 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
1067 (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
1070 case R_RL78_OPromtop:
1071 relocation = get_romstart (&r, info, input_bfd, input_section, rel->r_offset);
1072 (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
1075 case R_RL78_OPramtop:
1076 relocation = get_ramstart (&r, info, input_bfd, input_section, rel->r_offset);
1077 (void) rl78_compute_complex_reloc (r_type, relocation, input_section);
1081 r = bfd_reloc_notsupported;
1085 if (r != bfd_reloc_ok)
1087 const char * msg = NULL;
1091 case bfd_reloc_overflow:
1092 /* Catch the case of a missing function declaration
1093 and emit a more helpful error message. */
1094 if (r_type == R_RL78_DIR24S_PCREL)
1095 msg = _("%B(%A): error: call to undefined function '%s'");
1097 r = info->callbacks->reloc_overflow
1098 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
1099 input_bfd, input_section, rel->r_offset);
1102 case bfd_reloc_undefined:
1103 r = info->callbacks->undefined_symbol
1104 (info, name, input_bfd, input_section, rel->r_offset,
1108 case bfd_reloc_other:
1109 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1112 case bfd_reloc_outofrange:
1113 msg = _("%B(%A): internal error: out of range error");
1116 case bfd_reloc_notsupported:
1117 msg = _("%B(%A): internal error: unsupported relocation error");
1120 case bfd_reloc_dangerous:
1121 msg = _("%B(%A): internal error: dangerous relocation");
1125 msg = _("%B(%A): internal error: unknown error");
1130 _bfd_error_handler (msg, input_bfd, input_section, name);
1140 /* Function to set the ELF flag bits. */
1143 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
1145 elf_elfheader (abfd)->e_flags = flags;
1146 elf_flags_init (abfd) = TRUE;
1150 static bfd_boolean no_warn_mismatch = FALSE;
1152 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1155 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1157 no_warn_mismatch = user_no_warn_mismatch;
1161 rl78_cpu_name (flagword flags)
1163 switch (flags & E_FLAG_RL78_CPU_MASK)
1166 case E_FLAG_RL78_G10: return "G10";
1167 case E_FLAG_RL78_G13: return "G13";
1168 case E_FLAG_RL78_G14: return "G14";
1172 /* Merge backend specific data from an object file to the output
1173 object file when linking. */
1176 rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1180 bfd_boolean error = FALSE;
1182 new_flags = elf_elfheader (ibfd)->e_flags;
1183 old_flags = elf_elfheader (obfd)->e_flags;
1185 if (!elf_flags_init (obfd))
1187 /* First call, no flags set. */
1188 elf_flags_init (obfd) = TRUE;
1189 elf_elfheader (obfd)->e_flags = new_flags;
1191 else if (old_flags != new_flags)
1193 flagword changed_flags = old_flags ^ new_flags;
1195 if (changed_flags & E_FLAG_RL78_CPU_MASK)
1197 flagword out_cpu = old_flags & E_FLAG_RL78_CPU_MASK;
1198 flagword in_cpu = new_flags & E_FLAG_RL78_CPU_MASK;
1200 if (in_cpu == E_FLAG_RL78_ANY_CPU || in_cpu == out_cpu)
1201 /* It does not matter what new_cpu may have. */;
1202 else if (out_cpu == E_FLAG_RL78_ANY_CPU)
1204 if (in_cpu == E_FLAG_RL78_G10)
1206 /* G10 files can only be linked with other G10 files.
1207 If the output is set to "any" this means that it is
1208 a G14 file that does not use hardware multiply/divide,
1209 but that is still incompatible with the G10 ABI. */
1212 (*_bfd_error_handler)
1213 (_("RL78 ABI conflict: G10 file %s cannot be linked with %s file %s"),
1214 bfd_get_filename (ibfd),
1215 rl78_cpu_name (out_cpu), bfd_get_filename (obfd));
1219 old_flags &= ~ E_FLAG_RL78_CPU_MASK;
1220 old_flags |= in_cpu;
1221 elf_elfheader (obfd)->e_flags = old_flags;
1228 (*_bfd_error_handler)
1229 (_("RL78 ABI conflict: cannot link %s file %s with %s file %s"),
1230 rl78_cpu_name (in_cpu), bfd_get_filename (ibfd),
1231 rl78_cpu_name (out_cpu), bfd_get_filename (obfd));
1235 if (changed_flags & E_FLAG_RL78_64BIT_DOUBLES)
1237 (*_bfd_error_handler)
1238 (_("RL78 merge conflict: cannot link 32-bit and 64-bit objects together"));
1240 if (old_flags & E_FLAG_RL78_64BIT_DOUBLES)
1241 (*_bfd_error_handler) (_("- %s is 64-bit, %s is not"),
1242 bfd_get_filename (obfd), bfd_get_filename (ibfd));
1244 (*_bfd_error_handler) (_("- %s is 64-bit, %s is not"),
1245 bfd_get_filename (ibfd), bfd_get_filename (obfd));
1254 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1256 FILE * file = (FILE *) ptr;
1259 BFD_ASSERT (abfd != NULL && ptr != NULL);
1261 /* Print normal ELF private data. */
1262 _bfd_elf_print_private_bfd_data (abfd, ptr);
1264 flags = elf_elfheader (abfd)->e_flags;
1265 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1267 if (flags & E_FLAG_RL78_CPU_MASK)
1268 fprintf (file, " [%s]", rl78_cpu_name (flags));
1270 if (flags & E_FLAG_RL78_64BIT_DOUBLES)
1271 fprintf (file, _(" [64-bit doubles]"));
1277 /* Return the MACH for an e_flags value. */
1280 elf32_rl78_machine (bfd * abfd ATTRIBUTE_UNUSED)
1282 return bfd_mach_rl78;
1286 rl78_elf_object_p (bfd * abfd)
1288 bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1289 elf32_rl78_machine (abfd));
1293 /* support PLT for 16-bit references to 24-bit functions. */
1295 /* We support 16-bit pointers to code above 64k by generating a thunk
1296 below 64k containing a JMP instruction to the final address. */
1299 rl78_elf_check_relocs
1301 struct bfd_link_info * info,
1303 const Elf_Internal_Rela * relocs)
1305 Elf_Internal_Shdr * symtab_hdr;
1306 struct elf_link_hash_entry ** sym_hashes;
1307 const Elf_Internal_Rela * rel;
1308 const Elf_Internal_Rela * rel_end;
1309 bfd_vma *local_plt_offsets;
1313 if (bfd_link_relocatable (info))
1316 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1317 sym_hashes = elf_sym_hashes (abfd);
1318 local_plt_offsets = elf_local_got_offsets (abfd);
1320 dynobj = elf_hash_table(info)->dynobj;
1322 rel_end = relocs + sec->reloc_count;
1323 for (rel = relocs; rel < rel_end; rel++)
1325 struct elf_link_hash_entry *h;
1326 unsigned long r_symndx;
1329 r_symndx = ELF32_R_SYM (rel->r_info);
1330 if (r_symndx < symtab_hdr->sh_info)
1334 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1335 while (h->root.type == bfd_link_hash_indirect
1336 || h->root.type == bfd_link_hash_warning)
1337 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1339 /* PR15323, ref flags aren't set for references in the same
1341 h->root.non_ir_ref = 1;
1344 switch (ELF32_R_TYPE (rel->r_info))
1346 /* This relocation describes a 16-bit pointer to a function.
1347 We may need to allocate a thunk in low memory; reserve memory
1351 elf_hash_table (info)->dynobj = dynobj = abfd;
1354 splt = bfd_get_linker_section (dynobj, ".plt");
1357 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1358 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1359 | SEC_READONLY | SEC_CODE);
1360 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1363 || ! bfd_set_section_alignment (dynobj, splt, 1))
1369 offset = &h->plt.offset;
1372 if (local_plt_offsets == NULL)
1377 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1378 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1379 if (local_plt_offsets == NULL)
1381 elf_local_got_offsets (abfd) = local_plt_offsets;
1383 for (i = 0; i < symtab_hdr->sh_info; i++)
1384 local_plt_offsets[i] = (bfd_vma) -1;
1386 offset = &local_plt_offsets[r_symndx];
1389 if (*offset == (bfd_vma) -1)
1391 *offset = splt->size;
1401 /* This must exist if dynobj is ever set. */
1404 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1405 struct bfd_link_info *info)
1410 if (!elf_hash_table (info)->dynamic_sections_created)
1413 /* As an extra sanity check, verify that all plt entries have been
1414 filled in. However, relaxing might have changed the relocs so
1415 that some plt entries don't get filled in, so we have to skip
1416 this check if we're relaxing. Unfortunately, check_relocs is
1417 called before relaxation. */
1419 if (info->relax_trip > 0)
1422 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1423 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
1425 bfd_byte *contents = splt->contents;
1426 unsigned int i, size = splt->size;
1428 for (i = 0; i < size; i += 4)
1430 unsigned int x = bfd_get_32 (dynobj, contents + i);
1431 BFD_ASSERT (x != 0);
1439 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1440 struct bfd_link_info *info)
1445 if (bfd_link_relocatable (info))
1448 dynobj = elf_hash_table (info)->dynobj;
1452 splt = bfd_get_linker_section (dynobj, ".plt");
1453 BFD_ASSERT (splt != NULL);
1455 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1456 if (splt->contents == NULL)
1464 /* Handle relaxing. */
1466 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1467 is within the low 64k, remove any entry for it in the plt. */
1469 struct relax_plt_data
1476 rl78_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
1478 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1480 if (h->plt.offset != (bfd_vma) -1)
1484 if (h->root.type == bfd_link_hash_undefined
1485 || h->root.type == bfd_link_hash_undefweak)
1488 address = (h->root.u.def.section->output_section->vma
1489 + h->root.u.def.section->output_offset
1490 + h->root.u.def.value);
1492 if (valid_16bit_address (address))
1495 data->splt->size -= 4;
1496 *data->again = TRUE;
1503 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1504 previously had a plt entry, give it a new entry offset. */
1507 rl78_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
1509 bfd_vma *entry = (bfd_vma *) xdata;
1511 if (h->plt.offset != (bfd_vma) -1)
1513 h->plt.offset = *entry;
1521 rl78_elf_relax_plt_section (bfd *dynobj,
1523 struct bfd_link_info *info,
1526 struct relax_plt_data relax_plt_data;
1529 /* Assume nothing changes. */
1532 if (bfd_link_relocatable (info))
1535 /* We only relax the .plt section at the moment. */
1536 if (dynobj != elf_hash_table (info)->dynobj
1537 || strcmp (splt->name, ".plt") != 0)
1540 /* Quick check for an empty plt. */
1541 if (splt->size == 0)
1544 /* Map across all global symbols; see which ones happen to
1545 fall in the low 64k. */
1546 relax_plt_data.splt = splt;
1547 relax_plt_data.again = again;
1548 elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1551 /* Likewise for local symbols, though that's somewhat less convenient
1552 as we have to walk the list of input bfds and swap in symbol data. */
1553 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
1555 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1556 Elf_Internal_Shdr *symtab_hdr;
1557 Elf_Internal_Sym *isymbuf = NULL;
1560 if (! local_plt_offsets)
1563 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1564 if (symtab_hdr->sh_info != 0)
1566 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1567 if (isymbuf == NULL)
1568 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1569 symtab_hdr->sh_info, 0,
1571 if (isymbuf == NULL)
1575 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1577 Elf_Internal_Sym *isym;
1581 if (local_plt_offsets[idx] == (bfd_vma) -1)
1584 isym = &isymbuf[idx];
1585 if (isym->st_shndx == SHN_UNDEF)
1587 else if (isym->st_shndx == SHN_ABS)
1588 tsec = bfd_abs_section_ptr;
1589 else if (isym->st_shndx == SHN_COMMON)
1590 tsec = bfd_com_section_ptr;
1592 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1594 address = (tsec->output_section->vma
1595 + tsec->output_offset
1597 if (valid_16bit_address (address))
1599 local_plt_offsets[idx] = -1;
1606 && symtab_hdr->contents != (unsigned char *) isymbuf)
1608 if (! info->keep_memory)
1612 /* Cache the symbols for elf_link_input_bfd. */
1613 symtab_hdr->contents = (unsigned char *) isymbuf;
1618 /* If we changed anything, walk the symbols again to reallocate
1619 .plt entry addresses. */
1620 if (*again && splt->size > 0)
1624 elf_link_hash_traverse (elf_hash_table (info),
1625 rl78_relax_plt_realloc, &entry);
1627 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
1629 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1630 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1633 if (! local_plt_offsets)
1636 for (idx = 0; idx < nlocals; ++idx)
1637 if (local_plt_offsets[idx] != (bfd_vma) -1)
1639 local_plt_offsets[idx] = entry;
1648 /* Delete some bytes from a section while relaxing. */
1651 elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1652 Elf_Internal_Rela *alignment_rel, int force_snip)
1654 Elf_Internal_Shdr * symtab_hdr;
1655 unsigned int sec_shndx;
1656 bfd_byte * contents;
1657 Elf_Internal_Rela * irel;
1658 Elf_Internal_Rela * irelend;
1659 Elf_Internal_Sym * isym;
1660 Elf_Internal_Sym * isymend;
1662 unsigned int symcount;
1663 struct elf_link_hash_entry ** sym_hashes;
1664 struct elf_link_hash_entry ** end_hashes;
1669 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1671 contents = elf_section_data (sec)->this_hdr.contents;
1673 /* The deletion must stop at the next alignment boundary, if
1674 ALIGNMENT_REL is non-NULL. */
1677 toaddr = alignment_rel->r_offset;
1679 irel = elf_section_data (sec)->relocs;
1682 _bfd_elf_link_read_relocs (sec->owner, sec, NULL, NULL, TRUE);
1683 irel = elf_section_data (sec)->relocs;
1686 irelend = irel + sec->reloc_count;
1688 /* Actually delete the bytes. */
1689 memmove (contents + addr, contents + addr + count,
1690 (size_t) (toaddr - addr - count));
1692 /* If we don't have an alignment marker to worry about, we can just
1693 shrink the section. Otherwise, we have to fill in the newly
1694 created gap with NOP insns (0x03). */
1698 memset (contents + toaddr - count, 0x03, count);
1700 /* Adjust all the relocs. */
1701 for (; irel && irel < irelend; irel++)
1703 /* Get the new reloc address. */
1704 if (irel->r_offset > addr
1705 && (irel->r_offset < toaddr
1706 || (force_snip && irel->r_offset == toaddr)))
1707 irel->r_offset -= count;
1709 /* If we see an ALIGN marker at the end of the gap, we move it
1710 to the beginning of the gap, since marking these gaps is what
1712 if (irel->r_offset == toaddr
1713 && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1714 && irel->r_addend & RL78_RELAXA_ALIGN)
1715 irel->r_offset -= count;
1718 /* Adjust the local symbols defined in this section. */
1719 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1720 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1721 isymend = isym + symtab_hdr->sh_info;
1723 for (; isym < isymend; isym++)
1725 /* If the symbol is in the range of memory we just moved, we
1726 have to adjust its value. */
1727 if (isym->st_shndx == sec_shndx
1728 && isym->st_value > addr
1729 && isym->st_value < toaddr)
1730 isym->st_value -= count;
1732 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1733 *end* is in the moved bytes but it's *start* isn't), then we
1734 must adjust its size. */
1735 if (isym->st_shndx == sec_shndx
1736 && isym->st_value < addr
1737 && isym->st_value + isym->st_size > addr
1738 && isym->st_value + isym->st_size < toaddr)
1739 isym->st_size -= count;
1742 /* Now adjust the global symbols defined in this section. */
1743 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1744 - symtab_hdr->sh_info);
1745 sym_hashes = elf_sym_hashes (abfd);
1746 end_hashes = sym_hashes + symcount;
1748 for (; sym_hashes < end_hashes; sym_hashes++)
1750 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1752 if ((sym_hash->root.type == bfd_link_hash_defined
1753 || sym_hash->root.type == bfd_link_hash_defweak)
1754 && sym_hash->root.u.def.section == sec)
1756 /* As above, adjust the value if needed. */
1757 if (sym_hash->root.u.def.value > addr
1758 && sym_hash->root.u.def.value < toaddr)
1759 sym_hash->root.u.def.value -= count;
1761 /* As above, adjust the size if needed. */
1762 if (sym_hash->root.u.def.value < addr
1763 && sym_hash->root.u.def.value + sym_hash->size > addr
1764 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1765 sym_hash->size -= count;
1772 /* Used to sort relocs by address. If relocs have the same address,
1773 we maintain their relative order, except that R_RL78_RH_RELAX
1774 alignment relocs must be the first reloc for any given address. */
1777 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1781 bfd_boolean swappit;
1783 /* This is almost a classic bubblesort. It's the slowest sort, but
1784 we're taking advantage of the fact that the relocations are
1785 mostly in order already (the assembler emits them that way) and
1786 we need relocs with the same address to remain in the same
1792 for (i = 0; i < count - 1; i ++)
1794 if (r[i].r_offset > r[i + 1].r_offset)
1796 else if (r[i].r_offset < r[i + 1].r_offset)
1798 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1799 && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1801 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1802 && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1803 && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1804 && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1811 Elf_Internal_Rela tmp;
1816 /* If we do move a reloc back, re-scan to see if it
1817 needs to be moved even further back. This avoids
1818 most of the O(n^2) behavior for our cases. */
1828 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1829 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1830 lrel, abfd, sec, link_info, scale)
1833 rl78_offset_for_reloc (bfd * abfd,
1834 Elf_Internal_Rela * rel,
1835 Elf_Internal_Shdr * symtab_hdr,
1836 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1837 Elf_Internal_Sym * intsyms,
1838 Elf_Internal_Rela ** lrel,
1840 asection * input_section,
1841 struct bfd_link_info * info,
1848 /* REL is the first of 1..N relocations. We compute the symbol
1849 value for each relocation, then combine them if needed. LREL
1850 gets a pointer to the last relocation used. */
1853 unsigned long r_type;
1855 /* Get the value of the symbol referred to by the reloc. */
1856 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1858 /* A local symbol. */
1859 Elf_Internal_Sym *isym;
1862 isym = intsyms + ELF32_R_SYM (rel->r_info);
1864 if (isym->st_shndx == SHN_UNDEF)
1865 ssec = bfd_und_section_ptr;
1866 else if (isym->st_shndx == SHN_ABS)
1867 ssec = bfd_abs_section_ptr;
1868 else if (isym->st_shndx == SHN_COMMON)
1869 ssec = bfd_com_section_ptr;
1871 ssec = bfd_section_from_elf_index (abfd,
1874 /* Initial symbol value. */
1875 symval = isym->st_value;
1877 /* GAS may have made this symbol relative to a section, in
1878 which case, we have to add the addend to find the
1880 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1881 symval += rel->r_addend;
1885 if ((ssec->flags & SEC_MERGE)
1886 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1887 symval = _bfd_merged_section_offset (abfd, & ssec,
1888 elf_section_data (ssec)->sec_info,
1892 /* Now make the offset relative to where the linker is putting it. */
1895 ssec->output_section->vma + ssec->output_offset;
1897 symval += rel->r_addend;
1902 struct elf_link_hash_entry * h;
1904 /* An external symbol. */
1905 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1906 h = elf_sym_hashes (abfd)[indx];
1907 BFD_ASSERT (h != NULL);
1909 if (h->root.type != bfd_link_hash_defined
1910 && h->root.type != bfd_link_hash_defweak)
1912 /* This appears to be a reference to an undefined
1913 symbol. Just ignore it--it will be caught by the
1914 regular reloc processing. */
1920 symval = (h->root.u.def.value
1921 + h->root.u.def.section->output_section->vma
1922 + h->root.u.def.section->output_offset);
1924 symval += rel->r_addend;
1927 r_type = ELF32_R_TYPE (rel->r_info);
1931 (void) rl78_compute_complex_reloc (r_type, symval, input_section);
1934 case R_RL78_OPromtop:
1935 symval = get_romstart (NULL, info, input_bfd, input_section, rel->r_offset);
1936 (void) rl78_compute_complex_reloc (r_type, symval, input_section);
1939 case R_RL78_OPramtop:
1940 symval = get_ramstart (NULL, info, input_bfd, input_section, rel->r_offset);
1941 (void) rl78_compute_complex_reloc (r_type, symval, input_section);
1951 case R_RL78_OPsctsize:
1952 case R_RL78_OPscttop:
1958 (void) rl78_compute_complex_reloc (r_type, 0, input_section);
1961 case R_RL78_DIR16UL:
1963 case R_RL78_ABS16UL:
1966 goto reloc_computes_value;
1968 case R_RL78_DIR16UW:
1970 case R_RL78_ABS16UW:
1973 goto reloc_computes_value;
1976 reloc_computes_value:
1977 symval = rl78_compute_complex_reloc (r_type, 0, input_section);
1988 int prefix; /* or -1 for "no prefix" */
1989 int insn; /* or -1 for "end of list" */
1990 int insn_for_saddr; /* or -1 for "no alternative" */
1991 int insn_for_sfr; /* or -1 for "no alternative" */
1992 } relax_addr16[] = {
1993 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1994 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1995 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1996 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1998 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1999 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
2000 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
2001 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
2002 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
2003 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
2004 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
2005 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
2007 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
2008 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
2009 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
2010 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
2011 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
2013 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
2014 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
2015 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
2016 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
2018 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
2019 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
2020 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
2022 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
2023 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
2024 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
2025 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
2026 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
2027 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
2029 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
2031 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
2032 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
2033 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
2034 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
2035 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
2036 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
2037 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
2038 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
2040 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
2041 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
2042 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
2043 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
2044 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
2045 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
2046 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
2047 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
2052 /* Relax one section. */
2055 rl78_elf_relax_section
2058 struct bfd_link_info * link_info,
2059 bfd_boolean * again)
2061 Elf_Internal_Shdr * symtab_hdr;
2062 Elf_Internal_Shdr * shndx_hdr;
2063 Elf_Internal_Rela * internal_relocs;
2064 Elf_Internal_Rela * free_relocs = NULL;
2065 Elf_Internal_Rela * irel;
2066 Elf_Internal_Rela * srel;
2067 Elf_Internal_Rela * irelend;
2068 Elf_Internal_Rela * next_alignment;
2069 bfd_byte * contents = NULL;
2070 bfd_byte * free_contents = NULL;
2071 Elf_Internal_Sym * intsyms = NULL;
2072 Elf_Internal_Sym * free_intsyms = NULL;
2073 Elf_External_Sym_Shndx * shndx_buf = NULL;
2075 bfd_vma symval ATTRIBUTE_UNUSED = 0;
2076 int pcrel ATTRIBUTE_UNUSED = 0;
2077 int code ATTRIBUTE_UNUSED = 0;
2078 int section_alignment_glue;
2081 if (abfd == elf_hash_table (link_info)->dynobj
2082 && strcmp (sec->name, ".plt") == 0)
2083 return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2085 /* Assume nothing changes. */
2088 /* We don't have to do anything for a relocatable link, if
2089 this section does not have relocs, or if this is not a
2091 if (bfd_link_relocatable (link_info)
2092 || (sec->flags & SEC_RELOC) == 0
2093 || sec->reloc_count == 0
2094 || (sec->flags & SEC_CODE) == 0)
2097 symtab_hdr = & elf_symtab_hdr (abfd);
2098 if (elf_symtab_shndx_list (abfd))
2099 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2103 /* Get the section contents. */
2104 if (elf_section_data (sec)->this_hdr.contents != NULL)
2105 contents = elf_section_data (sec)->this_hdr.contents;
2106 /* Go get them off disk. */
2109 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2111 elf_section_data (sec)->this_hdr.contents = contents;
2114 /* Read this BFD's symbols. */
2115 /* Get cached copy if it exists. */
2116 if (symtab_hdr->contents != NULL)
2117 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2120 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2121 symtab_hdr->contents = (bfd_byte *) intsyms;
2124 if (shndx_hdr && shndx_hdr->sh_size != 0)
2128 amt = symtab_hdr->sh_info;
2129 amt *= sizeof (Elf_External_Sym_Shndx);
2130 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2131 if (shndx_buf == NULL)
2133 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2134 || bfd_bread (shndx_buf, amt, abfd) != amt)
2136 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2139 /* Get a copy of the native relocations. */
2140 internal_relocs = (_bfd_elf_link_read_relocs
2141 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2142 link_info->keep_memory));
2143 if (internal_relocs == NULL)
2145 if (! link_info->keep_memory)
2146 free_relocs = internal_relocs;
2148 /* The RL_ relocs must be just before the operand relocs they go
2149 with, so we must sort them to guarantee this. We use bubblesort
2150 instead of qsort so we can guarantee that relocs with the same
2151 address remain in the same relative order. */
2152 reloc_bubblesort (internal_relocs, sec->reloc_count);
2154 /* Walk through them looking for relaxing opportunities. */
2155 irelend = internal_relocs + sec->reloc_count;
2158 /* This will either be NULL or a pointer to the next alignment
2160 next_alignment = internal_relocs;
2162 /* We calculate worst case shrinkage caused by alignment directives.
2163 No fool-proof, but better than either ignoring the problem or
2164 doing heavy duty analysis of all the alignment markers in all
2166 section_alignment_glue = 0;
2167 for (irel = internal_relocs; irel < irelend; irel++)
2168 if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2169 && irel->r_addend & RL78_RELAXA_ALIGN)
2171 int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2173 if (section_alignment_glue < this_glue)
2174 section_alignment_glue = this_glue;
2176 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2178 section_alignment_glue *= 2;
2180 for (irel = internal_relocs; irel < irelend; irel++)
2182 unsigned char *insn;
2185 /* The insns we care about are all marked with one of these. */
2186 if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2189 if (irel->r_addend & RL78_RELAXA_ALIGN
2190 || next_alignment == internal_relocs)
2192 /* When we delete bytes, we need to maintain all the alignments
2193 indicated. In addition, we need to be careful about relaxing
2194 jumps across alignment boundaries - these displacements
2195 *grow* when we delete bytes. For now, don't shrink
2196 displacements across an alignment boundary, just in case.
2197 Note that this only affects relocations to the same
2199 next_alignment += 2;
2200 while (next_alignment < irelend
2201 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2202 || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2204 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2205 next_alignment = NULL;
2208 /* When we hit alignment markers, see if we've shrunk enough
2209 before them to reduce the gap without violating the alignment
2211 if (irel->r_addend & RL78_RELAXA_ALIGN)
2213 /* At this point, the next relocation *should* be the ELIGN
2215 Elf_Internal_Rela *erel = irel + 1;
2216 unsigned int alignment, nbytes;
2218 if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2220 if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2223 alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2225 if (erel->r_offset - irel->r_offset < alignment)
2228 nbytes = erel->r_offset - irel->r_offset;
2229 nbytes /= alignment;
2230 nbytes *= alignment;
2232 elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset - nbytes, nbytes,
2233 next_alignment, erel->r_offset == sec->size);
2239 if (irel->r_addend & RL78_RELAXA_ELIGN)
2242 insn = contents + irel->r_offset;
2244 nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2246 /* At this point, we have an insn that is a candidate for linker
2247 relaxation. There are NRELOCS relocs following that may be
2248 relaxed, although each reloc may be made of more than one
2249 reloc entry (such as gp-rel symbols). */
2251 /* Get the value of the symbol referred to by the reloc. Just
2252 in case this is the last reloc in the list, use the RL's
2253 addend to choose between this reloc (no addend) or the next
2254 (yes addend, which means at least one following reloc). */
2256 /* srel points to the "current" reloction for this insn -
2257 actually the last reloc for a given operand, which is the one
2258 we need to update. We check the relaxations in the same
2259 order that the relocations happen, so we'll just push it
2263 pc = sec->output_section->vma + sec->output_offset
2267 BFD_ASSERT (nrelocs > 0); \
2268 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2269 pcrel = symval - pc + srel->r_addend; \
2272 #define SNIPNR(offset, nbytes) \
2273 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2275 #define SNIP(offset, nbytes, newtype) \
2276 SNIPNR (offset, nbytes); \
2277 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2279 /* The order of these bit tests must match the order that the
2280 relocs appear in. Since we sorted those by offset, we can
2283 /*----------------------------------------------------------------------*/
2284 /* EF ad BR $rel8 pcrel
2285 ED al ah BR !abs16 abs
2286 EE al ah BR $!rel16 pcrel
2287 EC al ah as BR !!abs20 abs
2289 FD al ah CALL !abs16 abs
2290 FE al ah CALL $!rel16 pcrel
2291 FC al ah as CALL !!abs20 abs
2299 61 C8 EF ad SKC ; BR $rel8
2300 61 D8 EF ad SKNC ; BR $rel8
2301 61 E8 EF ad SKZ ; BR $rel8
2302 61 F8 EF ad SKNZ ; BR $rel8
2303 61 E3 EF ad SKH ; BR $rel8
2304 61 F3 EF ad SKNH ; BR $rel8
2307 if ((irel->r_addend & RL78_RELAXA_MASK) == RL78_RELAXA_BRA)
2309 /* SKIP opcodes that skip non-branches will have a relax tag
2310 but no corresponding symbol to relax against; we just
2312 if (irel->r_addend & RL78_RELAXA_RNUM)
2319 case 0xec: /* BR !!abs20 */
2326 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2329 else if (symval < 65536)
2332 insn[1] = symval & 0xff;
2333 insn[2] = symval >> 8;
2334 SNIP (2, 1, R_RL78_DIR16S);
2337 else if (pcrel < 32767
2341 insn[1] = pcrel & 0xff;
2342 insn[2] = pcrel >> 8;
2343 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2348 case 0xee: /* BR $!pcrel16 */
2349 case 0xed: /* BR $!abs16 */
2355 SNIP (2, 1, R_RL78_DIR8S_PCREL);
2360 case 0xfc: /* CALL !!abs20 */
2364 insn[1] = symval & 0xff;
2365 insn[2] = symval >> 8;
2366 SNIP (2, 1, R_RL78_DIR16S);
2369 else if (pcrel < 32767
2373 insn[1] = pcrel & 0xff;
2374 insn[2] = pcrel >> 8;
2375 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2380 case 0x61: /* PREFIX */
2381 /* For SKIP/BR, we change the BR opcode and delete the
2382 SKIP. That way, we don't have to find and change the
2383 relocation for the BR. */
2384 /* Note that, for the case where we're skipping some
2385 other insn, we have no "other" reloc but that's safe
2389 case 0xc8: /* SKC */
2390 if (insn[2] == 0xef)
2392 insn[2] = 0xde; /* BNC */
2397 case 0xd8: /* SKNC */
2398 if (insn[2] == 0xef)
2400 insn[2] = 0xdc; /* BC */
2405 case 0xe8: /* SKZ */
2406 if (insn[2] == 0xef)
2408 insn[2] = 0xdf; /* BNZ */
2413 case 0xf8: /* SKNZ */
2414 if (insn[2] == 0xef)
2416 insn[2] = 0xdd; /* BZ */
2421 case 0xe3: /* SKH */
2422 if (insn[2] == 0xef)
2424 insn[2] = 0xd3; /* BNH */
2425 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2429 case 0xf3: /* SKNH */
2430 if (insn[2] == 0xef)
2432 insn[2] = 0xc3; /* BH */
2433 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2441 if ((irel->r_addend & RL78_RELAXA_MASK) == RL78_RELAXA_ADDR16
2444 /*----------------------------------------------------------------------*/
2445 /* Some insns have both a 16-bit address operand and an 8-bit
2446 variant if the address is within a special range:
2448 Address 16-bit operand SADDR range SFR range
2449 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2450 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2452 The RELAX_ADDR16[] array has the insn encodings for the
2453 16-bit operand version, as well as the SFR and SADDR
2454 variants. We only need to replace the encodings and
2457 Note: we intentionally do not attempt to decode and skip
2458 any ES: prefix, as adding ES: means the addr16 (likely)
2459 no longer points to saddr/sfr space.
2469 if (0xffe20 <= symval && symval <= 0xfffff)
2472 is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2473 is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2475 for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2477 if (relax_addr16[idx].prefix != -1
2478 && insn[0] == relax_addr16[idx].prefix
2479 && insn[1] == relax_addr16[idx].insn)
2483 else if (relax_addr16[idx].prefix == -1
2484 && insn[0] == relax_addr16[idx].insn)
2491 /* We have a matched insn, and poff is 0 or 1 depending
2492 on the base pattern size. */
2494 if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2496 insn[poff] = relax_addr16[idx].insn_for_sfr;
2497 SNIP (poff+2, 1, R_RL78_RH_SFR);
2500 else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2502 insn[poff] = relax_addr16[idx].insn_for_saddr;
2503 SNIP (poff+2, 1, R_RL78_RH_SADDR);
2508 /*----------------------------------------------------------------------*/
2514 if (free_relocs != NULL)
2517 if (free_contents != NULL)
2518 free (free_contents);
2520 if (shndx_buf != NULL)
2522 shndx_hdr->contents = NULL;
2526 if (free_intsyms != NULL)
2527 free (free_intsyms);
2534 #define ELF_ARCH bfd_arch_rl78
2535 #define ELF_MACHINE_CODE EM_RL78
2536 #define ELF_MAXPAGESIZE 0x1000
2538 #define TARGET_LITTLE_SYM rl78_elf32_vec
2539 #define TARGET_LITTLE_NAME "elf32-rl78"
2541 #define elf_info_to_howto_rel NULL
2542 #define elf_info_to_howto rl78_info_to_howto_rela
2543 #define elf_backend_object_p rl78_elf_object_p
2544 #define elf_backend_relocate_section rl78_elf_relocate_section
2545 #define elf_symbol_leading_char ('_')
2546 #define elf_backend_can_gc_sections 1
2548 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2549 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2550 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2551 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2552 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2554 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2555 #define elf_backend_check_relocs rl78_elf_check_relocs
2556 #define elf_backend_always_size_sections \
2557 rl78_elf_always_size_sections
2558 #define elf_backend_finish_dynamic_sections \
2559 rl78_elf_finish_dynamic_sections
2561 #include "elf32-target.h"