1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011-2013 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 /* Note that the relocations around 0x7f are internal to this file;
35 feel free to move them as needed to avoid conflicts with published
36 relocation numbers. */
38 static reloc_howto_type rl78_elf_howto_table [] =
40 RL78REL (NONE, 0, 0, 0, dont, FALSE),
41 RL78REL (DIR32, 2, 32, 0, signed, FALSE),
42 RL78REL (DIR24S, 2, 24, 0, signed, FALSE),
43 RL78REL (DIR16, 1, 16, 0, dont, FALSE),
44 RL78REL (DIR16U, 1, 16, 0, unsigned, FALSE),
45 RL78REL (DIR16S, 1, 16, 0, signed, FALSE),
46 RL78REL (DIR8, 0, 8, 0, dont, FALSE),
47 RL78REL (DIR8U, 0, 8, 0, unsigned, FALSE),
48 RL78REL (DIR8S, 0, 8, 0, signed, FALSE),
49 RL78REL (DIR24S_PCREL, 2, 24, 0, signed, TRUE),
50 RL78REL (DIR16S_PCREL, 1, 16, 0, signed, TRUE),
51 RL78REL (DIR8S_PCREL, 0, 8, 0, signed, TRUE),
52 RL78REL (DIR16UL, 1, 16, 2, unsigned, FALSE),
53 RL78REL (DIR16UW, 1, 16, 1, unsigned, FALSE),
54 RL78REL (DIR8UL, 0, 8, 2, unsigned, FALSE),
55 RL78REL (DIR8UW, 0, 8, 1, unsigned, FALSE),
56 RL78REL (DIR32_REV, 1, 16, 0, dont, FALSE),
57 RL78REL (DIR16_REV, 1, 16, 0, dont, FALSE),
58 RL78REL (DIR3U_PCREL, 0, 3, 0, dont, TRUE),
87 RL78REL (RH_RELAX, 0, 0, 0, dont, FALSE),
109 RL78REL (ABS32, 2, 32, 0, dont, FALSE),
110 RL78REL (ABS24S, 2, 24, 0, signed, FALSE),
111 RL78REL (ABS16, 1, 16, 0, dont, FALSE),
112 RL78REL (ABS16U, 1, 16, 0, unsigned, FALSE),
113 RL78REL (ABS16S, 1, 16, 0, signed, FALSE),
114 RL78REL (ABS8, 0, 8, 0, dont, FALSE),
115 RL78REL (ABS8U, 0, 8, 0, unsigned, FALSE),
116 RL78REL (ABS8S, 0, 8, 0, signed, FALSE),
117 RL78REL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
118 RL78REL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
119 RL78REL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
120 RL78REL (ABS16UL, 1, 16, 0, unsigned, FALSE),
121 RL78REL (ABS16UW, 1, 16, 0, unsigned, FALSE),
122 RL78REL (ABS8UL, 0, 8, 0, unsigned, FALSE),
123 RL78REL (ABS8UW, 0, 8, 0, unsigned, FALSE),
124 RL78REL (ABS32_REV, 2, 32, 0, dont, FALSE),
125 RL78REL (ABS16_REV, 1, 16, 0, dont, FALSE),
127 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
177 RL78REL (SYM, 2, 32, 0, dont, FALSE),
178 RL78REL (OPneg, 2, 32, 0, dont, FALSE),
179 RL78REL (OPadd, 2, 32, 0, dont, FALSE),
180 RL78REL (OPsub, 2, 32, 0, dont, FALSE),
181 RL78REL (OPmul, 2, 32, 0, dont, FALSE),
182 RL78REL (OPdiv, 2, 32, 0, dont, FALSE),
183 RL78REL (OPshla, 2, 32, 0, dont, FALSE),
184 RL78REL (OPshra, 2, 32, 0, dont, FALSE),
185 RL78REL (OPsctsize, 2, 32, 0, dont, FALSE),
190 RL78REL (OPscttop, 2, 32, 0, dont, FALSE),
193 RL78REL (OPand, 2, 32, 0, dont, FALSE),
194 RL78REL (OPor, 2, 32, 0, dont, FALSE),
195 RL78REL (OPxor, 2, 32, 0, dont, FALSE),
196 RL78REL (OPnot, 2, 32, 0, dont, FALSE),
197 RL78REL (OPmod, 2, 32, 0, dont, FALSE),
198 RL78REL (OPromtop, 2, 32, 0, dont, FALSE),
199 RL78REL (OPramtop, 2, 32, 0, dont, FALSE)
202 /* Map BFD reloc types to RL78 ELF reloc types. */
204 struct rl78_reloc_map
206 bfd_reloc_code_real_type bfd_reloc_val;
207 unsigned int rl78_reloc_val;
210 static const struct rl78_reloc_map rl78_reloc_map [] =
212 { BFD_RELOC_NONE, R_RL78_NONE },
213 { BFD_RELOC_8, R_RL78_DIR8S },
214 { BFD_RELOC_16, R_RL78_DIR16S },
215 { BFD_RELOC_24, R_RL78_DIR24S },
216 { BFD_RELOC_32, R_RL78_DIR32 },
217 { BFD_RELOC_RL78_16_OP, R_RL78_DIR16 },
218 { BFD_RELOC_RL78_DIR3U_PCREL, R_RL78_DIR3U_PCREL },
219 { BFD_RELOC_8_PCREL, R_RL78_DIR8S_PCREL },
220 { BFD_RELOC_16_PCREL, R_RL78_DIR16S_PCREL },
221 { BFD_RELOC_24_PCREL, R_RL78_DIR24S_PCREL },
222 { BFD_RELOC_RL78_8U, R_RL78_DIR8U },
223 { BFD_RELOC_RL78_16U, R_RL78_DIR16U },
224 { BFD_RELOC_RL78_SYM, R_RL78_SYM },
225 { BFD_RELOC_RL78_OP_SUBTRACT, R_RL78_OPsub },
226 { BFD_RELOC_RL78_OP_NEG, R_RL78_OPneg },
227 { BFD_RELOC_RL78_OP_AND, R_RL78_OPand },
228 { BFD_RELOC_RL78_OP_SHRA, R_RL78_OPshra },
229 { BFD_RELOC_RL78_ABS8, R_RL78_ABS8 },
230 { BFD_RELOC_RL78_ABS16, R_RL78_ABS16 },
231 { BFD_RELOC_RL78_ABS16_REV, R_RL78_ABS16_REV },
232 { BFD_RELOC_RL78_ABS32, R_RL78_ABS32 },
233 { BFD_RELOC_RL78_ABS32_REV, R_RL78_ABS32_REV },
234 { BFD_RELOC_RL78_ABS16UL, R_RL78_ABS16UL },
235 { BFD_RELOC_RL78_ABS16UW, R_RL78_ABS16UW },
236 { BFD_RELOC_RL78_ABS16U, R_RL78_ABS16U },
237 { BFD_RELOC_RL78_RELAX, R_RL78_RH_RELAX }
240 static reloc_howto_type *
241 rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
242 bfd_reloc_code_real_type code)
246 if (code == BFD_RELOC_RL78_32_OP)
247 return rl78_elf_howto_table + R_RL78_DIR32;
249 for (i = ARRAY_SIZE (rl78_reloc_map); --i;)
250 if (rl78_reloc_map [i].bfd_reloc_val == code)
251 return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
256 static reloc_howto_type *
257 rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
261 for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
262 if (rl78_elf_howto_table[i].name != NULL
263 && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
264 return rl78_elf_howto_table + i;
269 /* Set the howto pointer for an RL78 ELF reloc. */
272 rl78_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
274 Elf_Internal_Rela * dst)
278 r_type = ELF32_R_TYPE (dst->r_info);
279 BFD_ASSERT (r_type < (unsigned int) R_RL78_max);
280 cache_ptr->howto = rl78_elf_howto_table + r_type;
284 get_symbol_value (const char * name,
285 bfd_reloc_status_type * status,
286 struct bfd_link_info * info,
288 asection * input_section,
292 struct bfd_link_hash_entry * h;
294 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
297 || (h->type != bfd_link_hash_defined
298 && h->type != bfd_link_hash_defweak))
299 * status = info->callbacks->undefined_symbol
300 (info, name, input_bfd, input_section, offset, TRUE);
302 value = (h->u.def.value
303 + h->u.def.section->output_section->vma
304 + h->u.def.section->output_offset);
310 get_romstart (bfd_reloc_status_type * status,
311 struct bfd_link_info * info,
316 static bfd_boolean cached = FALSE;
317 static bfd_vma cached_value = 0;
321 cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
328 get_ramstart (bfd_reloc_status_type * status,
329 struct bfd_link_info * info,
334 static bfd_boolean cached = FALSE;
335 static bfd_vma cached_value = 0;
339 cached_value = get_symbol_value ("__datastart", status, info, abfd, sec, offset);
345 #define NUM_STACK_ENTRIES 16
346 static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
347 static unsigned int rl78_stack_top;
349 #define RL78_STACK_PUSH(val) \
352 if (rl78_stack_top < NUM_STACK_ENTRIES) \
353 rl78_stack [rl78_stack_top ++] = (val); \
355 r = bfd_reloc_dangerous; \
359 #define RL78_STACK_POP(dest) \
362 if (rl78_stack_top > 0) \
363 (dest) = rl78_stack [-- rl78_stack_top]; \
365 (dest) = 0, r = bfd_reloc_dangerous; \
369 /* Relocate an RL78 ELF section.
370 There is some attempt to make this function usable for many architectures,
371 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
372 if only to serve as a learning tool.
374 The RELOCATE_SECTION function is called by the new ELF backend linker
375 to handle the relocations for a section.
377 The relocs are always passed as Rela structures; if the section
378 actually uses Rel structures, the r_addend field will always be
381 This function is responsible for adjusting the section contents as
382 necessary, and (if using Rela relocs and generating a relocatable
383 output file) adjusting the reloc addend as necessary.
385 This function does not have to worry about setting the reloc
386 address or the reloc symbol index.
388 LOCAL_SYMS is a pointer to the swapped in local symbols.
390 LOCAL_SECTIONS is an array giving the section in the input file
391 corresponding to the st_shndx field of each local symbol.
393 The global hash table entry for the global symbols can be found
394 via elf_sym_hashes (input_bfd).
396 When generating relocatable output, this function must handle
397 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
398 going to be the section symbol corresponding to the output
399 section, which means that the addend must be adjusted
403 rl78_elf_relocate_section
405 struct bfd_link_info * info,
407 asection * input_section,
409 Elf_Internal_Rela * relocs,
410 Elf_Internal_Sym * local_syms,
411 asection ** local_sections)
413 Elf_Internal_Shdr * symtab_hdr;
414 struct elf_link_hash_entry ** sym_hashes;
415 Elf_Internal_Rela * rel;
416 Elf_Internal_Rela * relend;
420 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
421 sym_hashes = elf_sym_hashes (input_bfd);
422 relend = relocs + input_section->reloc_count;
424 dynobj = elf_hash_table (info)->dynobj;
427 splt = bfd_get_linker_section (dynobj, ".plt");
429 for (rel = relocs; rel < relend; rel ++)
431 reloc_howto_type * howto;
432 unsigned long r_symndx;
433 Elf_Internal_Sym * sym;
435 struct elf_link_hash_entry * h;
437 bfd_reloc_status_type r;
438 const char * name = NULL;
439 bfd_boolean unresolved_reloc = TRUE;
442 r_type = ELF32_R_TYPE (rel->r_info);
443 r_symndx = ELF32_R_SYM (rel->r_info);
445 howto = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
451 if (r_symndx < symtab_hdr->sh_info)
453 sym = local_syms + r_symndx;
454 sec = local_sections [r_symndx];
455 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
457 name = bfd_elf_string_from_elf_section
458 (input_bfd, symtab_hdr->sh_link, sym->st_name);
459 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
463 bfd_boolean warned ATTRIBUTE_UNUSED;
464 bfd_boolean ignored ATTRIBUTE_UNUSED;
466 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
467 r_symndx, symtab_hdr, sym_hashes, h,
468 sec, relocation, unresolved_reloc,
471 name = h->root.root.string;
474 if (sec != NULL && discarded_section (sec))
475 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
476 rel, 1, relend, howto, 0, contents);
478 if (info->relocatable)
480 /* This is a relocatable link. We don't have to change
481 anything, unless the reloc is against a section symbol,
482 in which case we have to adjust according to where the
483 section symbol winds up in the output section. */
484 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
485 rel->r_addend += sec->output_offset;
489 switch (ELF32_R_TYPE (rel->r_info))
496 plt_offset = &h->plt.offset;
498 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
500 if (! valid_16bit_address (relocation))
502 /* If this is the first time we've processed this symbol,
503 fill in the plt entry with the correct symbol address. */
504 if ((*plt_offset & 1) == 0)
508 x = 0x000000ec; /* br !!abs24 */
509 x |= (relocation << 8) & 0xffffff00;
510 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
514 relocation = (splt->output_section->vma
515 + splt->output_offset
516 + (*plt_offset & -2));
519 char *newname = bfd_malloc (strlen(name)+5);
520 strcpy (newname, name);
521 strcat(newname, ".plt");
522 _bfd_generic_link_add_one_symbol (info,
525 BSF_FUNCTION | BSF_WEAK,
538 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
539 /* If the symbol is undefined and weak
540 then the relocation resolves to zero. */
544 if (howto->pc_relative)
546 relocation -= (input_section->output_section->vma
547 + input_section->output_offset
549 relocation -= bfd_get_reloc_size (howto);
552 relocation += rel->r_addend;
557 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
558 #define ALIGN(m) if (relocation & m) r = bfd_reloc_other;
559 #define OP(i) (contents[rel->r_offset + (i)])
561 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
567 case R_RL78_RH_RELAX:
570 case R_RL78_DIR8S_PCREL:
585 case R_RL78_DIR16S_PCREL:
586 RANGE (-32768, 32767);
588 OP (1) = relocation >> 8;
592 if ((relocation & 0xf0000) == 0xf0000)
593 relocation &= 0xffff;
594 RANGE (-32768, 65535);
596 OP (1) = relocation >> 8;
602 OP (1) = relocation >> 8;
606 RANGE (-32768, 65536);
608 OP (1) = relocation >> 8;
611 case R_RL78_DIR16_REV:
612 RANGE (-32768, 65536);
614 OP (0) = relocation >> 8;
617 case R_RL78_DIR3U_PCREL:
620 OP (0) |= relocation & 0x07;
623 case R_RL78_DIR24S_PCREL:
624 RANGE (-0x800000, 0x7fffff);
626 OP (1) = relocation >> 8;
627 OP (2) = relocation >> 16;
631 RANGE (-0x800000, 0x7fffff);
633 OP (1) = relocation >> 8;
634 OP (2) = relocation >> 16;
639 OP (1) = relocation >> 8;
640 OP (2) = relocation >> 16;
641 OP (3) = relocation >> 24;
644 case R_RL78_DIR32_REV:
646 OP (2) = relocation >> 8;
647 OP (1) = relocation >> 16;
648 OP (0) = relocation >> 24;
652 RANGE (0xfff00, 0xfffff);
653 OP (0) = relocation & 0xff;
656 case R_RL78_RH_SADDR:
657 RANGE (0xffe20, 0xfff1f);
658 OP (0) = relocation & 0xff;
661 /* Complex reloc handling: */
664 RL78_STACK_POP (relocation);
666 OP (1) = relocation >> 8;
667 OP (2) = relocation >> 16;
668 OP (3) = relocation >> 24;
671 case R_RL78_ABS32_REV:
672 RL78_STACK_POP (relocation);
674 OP (2) = relocation >> 8;
675 OP (1) = relocation >> 16;
676 OP (0) = relocation >> 24;
679 case R_RL78_ABS24S_PCREL:
681 RL78_STACK_POP (relocation);
682 RANGE (-0x800000, 0x7fffff);
684 OP (1) = relocation >> 8;
685 OP (2) = relocation >> 16;
689 RL78_STACK_POP (relocation);
690 RANGE (-32768, 65535);
692 OP (1) = relocation >> 8;
695 case R_RL78_ABS16_REV:
696 RL78_STACK_POP (relocation);
697 RANGE (-32768, 65535);
699 OP (0) = relocation >> 8;
702 case R_RL78_ABS16S_PCREL:
704 RL78_STACK_POP (relocation);
705 RANGE (-32768, 32767);
707 OP (1) = relocation >> 8;
711 RL78_STACK_POP (relocation);
714 OP (1) = relocation >> 8;
718 RL78_STACK_POP (relocation);
722 OP (1) = relocation >> 8;
726 RL78_STACK_POP (relocation);
730 OP (1) = relocation >> 8;
734 RL78_STACK_POP (relocation);
740 RL78_STACK_POP (relocation);
746 RL78_STACK_POP (relocation);
753 RL78_STACK_POP (relocation);
759 case R_RL78_ABS8S_PCREL:
761 RL78_STACK_POP (relocation);
767 if (r_symndx < symtab_hdr->sh_info)
768 RL78_STACK_PUSH (sec->output_section->vma
775 && (h->root.type == bfd_link_hash_defined
776 || h->root.type == bfd_link_hash_defweak))
777 RL78_STACK_PUSH (h->root.u.def.value
778 + sec->output_section->vma
781 else if (h->root.type == bfd_link_hash_undefweak)
784 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
792 RL78_STACK_POP (tmp);
794 RL78_STACK_PUSH (tmp);
802 RL78_STACK_POP (tmp2);
803 RL78_STACK_POP (tmp1);
805 RL78_STACK_PUSH (tmp1);
813 /* For the expression "A - B", the assembler pushes A,
814 then B, then OPSUB. So the first op we pop is B, not
816 RL78_STACK_POP (tmp2); /* B */
817 RL78_STACK_POP (tmp1); /* A */
818 tmp1 -= tmp2; /* A - B */
819 RL78_STACK_PUSH (tmp1);
827 RL78_STACK_POP (tmp2);
828 RL78_STACK_POP (tmp1);
830 RL78_STACK_PUSH (tmp1);
838 RL78_STACK_POP (tmp2);
839 RL78_STACK_POP (tmp1);
841 RL78_STACK_PUSH (tmp1);
849 RL78_STACK_POP (tmp2);
850 RL78_STACK_POP (tmp1);
852 RL78_STACK_PUSH (tmp1);
860 RL78_STACK_POP (tmp2);
861 RL78_STACK_POP (tmp1);
863 RL78_STACK_PUSH (tmp1);
867 case R_RL78_OPsctsize:
868 RL78_STACK_PUSH (input_section->size);
871 case R_RL78_OPscttop:
872 RL78_STACK_PUSH (input_section->output_section->vma);
879 RL78_STACK_POP (tmp2);
880 RL78_STACK_POP (tmp1);
882 RL78_STACK_PUSH (tmp1);
890 RL78_STACK_POP (tmp2);
891 RL78_STACK_POP (tmp1);
893 RL78_STACK_PUSH (tmp1);
901 RL78_STACK_POP (tmp2);
902 RL78_STACK_POP (tmp1);
904 RL78_STACK_PUSH (tmp1);
912 RL78_STACK_POP (tmp);
914 RL78_STACK_PUSH (tmp);
922 RL78_STACK_POP (tmp2);
923 RL78_STACK_POP (tmp1);
925 RL78_STACK_PUSH (tmp1);
929 case R_RL78_OPromtop:
930 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
933 case R_RL78_OPramtop:
934 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
938 r = bfd_reloc_notsupported;
942 if (r != bfd_reloc_ok)
944 const char * msg = NULL;
948 case bfd_reloc_overflow:
949 /* Catch the case of a missing function declaration
950 and emit a more helpful error message. */
951 if (r_type == R_RL78_DIR24S_PCREL)
952 msg = _("%B(%A): error: call to undefined function '%s'");
954 r = info->callbacks->reloc_overflow
955 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
956 input_bfd, input_section, rel->r_offset);
959 case bfd_reloc_undefined:
960 r = info->callbacks->undefined_symbol
961 (info, name, input_bfd, input_section, rel->r_offset,
965 case bfd_reloc_other:
966 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
969 case bfd_reloc_outofrange:
970 msg = _("%B(%A): internal error: out of range error");
973 case bfd_reloc_notsupported:
974 msg = _("%B(%A): internal error: unsupported relocation error");
977 case bfd_reloc_dangerous:
978 msg = _("%B(%A): internal error: dangerous relocation");
982 msg = _("%B(%A): internal error: unknown error");
987 _bfd_error_handler (msg, input_bfd, input_section, name);
997 /* Function to set the ELF flag bits. */
1000 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
1002 elf_elfheader (abfd)->e_flags = flags;
1003 elf_flags_init (abfd) = TRUE;
1007 static bfd_boolean no_warn_mismatch = FALSE;
1009 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1012 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1014 no_warn_mismatch = user_no_warn_mismatch;
1017 /* Merge backend specific data from an object file to the output
1018 object file when linking. */
1021 rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1025 bfd_boolean error = FALSE;
1027 new_flags = elf_elfheader (ibfd)->e_flags;
1028 old_flags = elf_elfheader (obfd)->e_flags;
1030 if (!elf_flags_init (obfd))
1032 /* First call, no flags set. */
1033 elf_flags_init (obfd) = TRUE;
1034 elf_elfheader (obfd)->e_flags = new_flags;
1036 else if (old_flags != new_flags)
1038 flagword changed_flags = old_flags ^ new_flags;
1040 if (changed_flags & E_FLAG_RL78_G10)
1042 (*_bfd_error_handler)
1043 (_("RL78/G10 ABI conflict: cannot link G10 and non-G10 objects together"));
1045 if (old_flags & E_FLAG_RL78_G10)
1046 (*_bfd_error_handler) (_("- %s is G10, %s is not"),
1047 bfd_get_filename (obfd), bfd_get_filename (ibfd));
1049 (*_bfd_error_handler) (_("- %s is G10, %s is not"),
1050 bfd_get_filename (ibfd), bfd_get_filename (obfd));
1058 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1060 FILE * file = (FILE *) ptr;
1063 BFD_ASSERT (abfd != NULL && ptr != NULL);
1065 /* Print normal ELF private data. */
1066 _bfd_elf_print_private_bfd_data (abfd, ptr);
1068 flags = elf_elfheader (abfd)->e_flags;
1069 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1071 if (flags & E_FLAG_RL78_G10)
1072 fprintf (file, _(" [G10]"));
1078 /* Return the MACH for an e_flags value. */
1081 elf32_rl78_machine (bfd * abfd)
1083 if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1084 return bfd_mach_rl78;
1090 rl78_elf_object_p (bfd * abfd)
1092 bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1093 elf32_rl78_machine (abfd));
1097 /* support PLT for 16-bit references to 24-bit functions. */
1099 /* We support 16-bit pointers to code above 64k by generating a thunk
1100 below 64k containing a JMP instruction to the final address. */
1103 rl78_elf_check_relocs
1105 struct bfd_link_info * info,
1107 const Elf_Internal_Rela * relocs)
1109 Elf_Internal_Shdr * symtab_hdr;
1110 struct elf_link_hash_entry ** sym_hashes;
1111 const Elf_Internal_Rela * rel;
1112 const Elf_Internal_Rela * rel_end;
1113 bfd_vma *local_plt_offsets;
1117 if (info->relocatable)
1120 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1121 sym_hashes = elf_sym_hashes (abfd);
1122 local_plt_offsets = elf_local_got_offsets (abfd);
1124 dynobj = elf_hash_table(info)->dynobj;
1126 rel_end = relocs + sec->reloc_count;
1127 for (rel = relocs; rel < rel_end; rel++)
1129 struct elf_link_hash_entry *h;
1130 unsigned long r_symndx;
1133 r_symndx = ELF32_R_SYM (rel->r_info);
1134 if (r_symndx < symtab_hdr->sh_info)
1138 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1139 while (h->root.type == bfd_link_hash_indirect
1140 || h->root.type == bfd_link_hash_warning)
1141 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1143 /* PR15323, ref flags aren't set for references in the same
1145 h->root.non_ir_ref = 1;
1148 switch (ELF32_R_TYPE (rel->r_info))
1150 /* This relocation describes a 16-bit pointer to a function.
1151 We may need to allocate a thunk in low memory; reserve memory
1155 elf_hash_table (info)->dynobj = dynobj = abfd;
1158 splt = bfd_get_linker_section (dynobj, ".plt");
1161 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1162 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1163 | SEC_READONLY | SEC_CODE);
1164 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1167 || ! bfd_set_section_alignment (dynobj, splt, 1))
1173 offset = &h->plt.offset;
1176 if (local_plt_offsets == NULL)
1181 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1182 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1183 if (local_plt_offsets == NULL)
1185 elf_local_got_offsets (abfd) = local_plt_offsets;
1187 for (i = 0; i < symtab_hdr->sh_info; i++)
1188 local_plt_offsets[i] = (bfd_vma) -1;
1190 offset = &local_plt_offsets[r_symndx];
1193 if (*offset == (bfd_vma) -1)
1195 *offset = splt->size;
1205 /* This must exist if dynobj is ever set. */
1208 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1209 struct bfd_link_info *info)
1214 if (!elf_hash_table (info)->dynamic_sections_created)
1217 /* As an extra sanity check, verify that all plt entries have been
1218 filled in. However, relaxing might have changed the relocs so
1219 that some plt entries don't get filled in, so we have to skip
1220 this check if we're relaxing. Unfortunately, check_relocs is
1221 called before relaxation. */
1223 if (info->relax_trip > 0)
1226 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1227 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
1229 bfd_byte *contents = splt->contents;
1230 unsigned int i, size = splt->size;
1232 for (i = 0; i < size; i += 4)
1234 unsigned int x = bfd_get_32 (dynobj, contents + i);
1235 BFD_ASSERT (x != 0);
1243 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1244 struct bfd_link_info *info)
1249 if (info->relocatable)
1252 dynobj = elf_hash_table (info)->dynobj;
1256 splt = bfd_get_linker_section (dynobj, ".plt");
1257 BFD_ASSERT (splt != NULL);
1259 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1260 if (splt->contents == NULL)
1268 /* Handle relaxing. */
1270 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1271 is within the low 64k, remove any entry for it in the plt. */
1273 struct relax_plt_data
1280 rl78_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
1282 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1284 if (h->plt.offset != (bfd_vma) -1)
1288 if (h->root.type == bfd_link_hash_undefined
1289 || h->root.type == bfd_link_hash_undefweak)
1292 address = (h->root.u.def.section->output_section->vma
1293 + h->root.u.def.section->output_offset
1294 + h->root.u.def.value);
1296 if (valid_16bit_address (address))
1299 data->splt->size -= 4;
1300 *data->again = TRUE;
1307 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1308 previously had a plt entry, give it a new entry offset. */
1311 rl78_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
1313 bfd_vma *entry = (bfd_vma *) xdata;
1315 if (h->plt.offset != (bfd_vma) -1)
1317 h->plt.offset = *entry;
1325 rl78_elf_relax_plt_section (bfd *dynobj,
1327 struct bfd_link_info *info,
1330 struct relax_plt_data relax_plt_data;
1333 /* Assume nothing changes. */
1336 if (info->relocatable)
1339 /* We only relax the .plt section at the moment. */
1340 if (dynobj != elf_hash_table (info)->dynobj
1341 || strcmp (splt->name, ".plt") != 0)
1344 /* Quick check for an empty plt. */
1345 if (splt->size == 0)
1348 /* Map across all global symbols; see which ones happen to
1349 fall in the low 64k. */
1350 relax_plt_data.splt = splt;
1351 relax_plt_data.again = again;
1352 elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1355 /* Likewise for local symbols, though that's somewhat less convenient
1356 as we have to walk the list of input bfds and swap in symbol data. */
1357 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1359 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1360 Elf_Internal_Shdr *symtab_hdr;
1361 Elf_Internal_Sym *isymbuf = NULL;
1364 if (! local_plt_offsets)
1367 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1368 if (symtab_hdr->sh_info != 0)
1370 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1371 if (isymbuf == NULL)
1372 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1373 symtab_hdr->sh_info, 0,
1375 if (isymbuf == NULL)
1379 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1381 Elf_Internal_Sym *isym;
1385 if (local_plt_offsets[idx] == (bfd_vma) -1)
1388 isym = &isymbuf[idx];
1389 if (isym->st_shndx == SHN_UNDEF)
1391 else if (isym->st_shndx == SHN_ABS)
1392 tsec = bfd_abs_section_ptr;
1393 else if (isym->st_shndx == SHN_COMMON)
1394 tsec = bfd_com_section_ptr;
1396 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1398 address = (tsec->output_section->vma
1399 + tsec->output_offset
1401 if (valid_16bit_address (address))
1403 local_plt_offsets[idx] = -1;
1410 && symtab_hdr->contents != (unsigned char *) isymbuf)
1412 if (! info->keep_memory)
1416 /* Cache the symbols for elf_link_input_bfd. */
1417 symtab_hdr->contents = (unsigned char *) isymbuf;
1422 /* If we changed anything, walk the symbols again to reallocate
1423 .plt entry addresses. */
1424 if (*again && splt->size > 0)
1428 elf_link_hash_traverse (elf_hash_table (info),
1429 rl78_relax_plt_realloc, &entry);
1431 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1433 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1434 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1437 if (! local_plt_offsets)
1440 for (idx = 0; idx < nlocals; ++idx)
1441 if (local_plt_offsets[idx] != (bfd_vma) -1)
1443 local_plt_offsets[idx] = entry;
1452 /* Delete some bytes from a section while relaxing. */
1455 elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1456 Elf_Internal_Rela *alignment_rel, int force_snip)
1458 Elf_Internal_Shdr * symtab_hdr;
1459 unsigned int sec_shndx;
1460 bfd_byte * contents;
1461 Elf_Internal_Rela * irel;
1462 Elf_Internal_Rela * irelend;
1463 Elf_Internal_Sym * isym;
1464 Elf_Internal_Sym * isymend;
1466 unsigned int symcount;
1467 struct elf_link_hash_entry ** sym_hashes;
1468 struct elf_link_hash_entry ** end_hashes;
1473 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1475 contents = elf_section_data (sec)->this_hdr.contents;
1477 /* The deletion must stop at the next alignment boundary, if
1478 ALIGNMENT_REL is non-NULL. */
1481 toaddr = alignment_rel->r_offset;
1483 irel = elf_section_data (sec)->relocs;
1484 irelend = irel + sec->reloc_count;
1486 /* Actually delete the bytes. */
1487 memmove (contents + addr, contents + addr + count,
1488 (size_t) (toaddr - addr - count));
1490 /* If we don't have an alignment marker to worry about, we can just
1491 shrink the section. Otherwise, we have to fill in the newly
1492 created gap with NOP insns (0x03). */
1496 memset (contents + toaddr - count, 0x03, count);
1498 /* Adjust all the relocs. */
1499 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1501 /* Get the new reloc address. */
1502 if (irel->r_offset > addr
1503 && (irel->r_offset < toaddr
1504 || (force_snip && irel->r_offset == toaddr)))
1505 irel->r_offset -= count;
1507 /* If we see an ALIGN marker at the end of the gap, we move it
1508 to the beginning of the gap, since marking these gaps is what
1510 if (irel->r_offset == toaddr
1511 && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1512 && irel->r_addend & RL78_RELAXA_ALIGN)
1513 irel->r_offset -= count;
1516 /* Adjust the local symbols defined in this section. */
1517 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1518 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1519 isymend = isym + symtab_hdr->sh_info;
1521 for (; isym < isymend; isym++)
1523 /* If the symbol is in the range of memory we just moved, we
1524 have to adjust its value. */
1525 if (isym->st_shndx == sec_shndx
1526 && isym->st_value > addr
1527 && isym->st_value < toaddr)
1528 isym->st_value -= count;
1530 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1531 *end* is in the moved bytes but it's *start* isn't), then we
1532 must adjust its size. */
1533 if (isym->st_shndx == sec_shndx
1534 && isym->st_value < addr
1535 && isym->st_value + isym->st_size > addr
1536 && isym->st_value + isym->st_size < toaddr)
1537 isym->st_size -= count;
1540 /* Now adjust the global symbols defined in this section. */
1541 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1542 - symtab_hdr->sh_info);
1543 sym_hashes = elf_sym_hashes (abfd);
1544 end_hashes = sym_hashes + symcount;
1546 for (; sym_hashes < end_hashes; sym_hashes++)
1548 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1550 if ((sym_hash->root.type == bfd_link_hash_defined
1551 || sym_hash->root.type == bfd_link_hash_defweak)
1552 && sym_hash->root.u.def.section == sec)
1554 /* As above, adjust the value if needed. */
1555 if (sym_hash->root.u.def.value > addr
1556 && sym_hash->root.u.def.value < toaddr)
1557 sym_hash->root.u.def.value -= count;
1559 /* As above, adjust the size if needed. */
1560 if (sym_hash->root.u.def.value < addr
1561 && sym_hash->root.u.def.value + sym_hash->size > addr
1562 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1563 sym_hash->size -= count;
1570 /* Used to sort relocs by address. If relocs have the same address,
1571 we maintain their relative order, except that R_RL78_RH_RELAX
1572 alignment relocs must be the first reloc for any given address. */
1575 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1579 bfd_boolean swappit;
1581 /* This is almost a classic bubblesort. It's the slowest sort, but
1582 we're taking advantage of the fact that the relocations are
1583 mostly in order already (the assembler emits them that way) and
1584 we need relocs with the same address to remain in the same
1590 for (i = 0; i < count - 1; i ++)
1592 if (r[i].r_offset > r[i + 1].r_offset)
1594 else if (r[i].r_offset < r[i + 1].r_offset)
1596 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1597 && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1599 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1600 && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1601 && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1602 && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1609 Elf_Internal_Rela tmp;
1614 /* If we do move a reloc back, re-scan to see if it
1615 needs to be moved even further back. This avoids
1616 most of the O(n^2) behavior for our cases. */
1626 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1627 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1628 lrel, abfd, sec, link_info, scale)
1631 rl78_offset_for_reloc (bfd * abfd,
1632 Elf_Internal_Rela * rel,
1633 Elf_Internal_Shdr * symtab_hdr,
1634 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1635 Elf_Internal_Sym * intsyms,
1636 Elf_Internal_Rela ** lrel,
1638 asection * input_section,
1639 struct bfd_link_info * info,
1643 bfd_reloc_status_type r;
1647 /* REL is the first of 1..N relocations. We compute the symbol
1648 value for each relocation, then combine them if needed. LREL
1649 gets a pointer to the last relocation used. */
1654 /* Get the value of the symbol referred to by the reloc. */
1655 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1657 /* A local symbol. */
1658 Elf_Internal_Sym *isym;
1661 isym = intsyms + ELF32_R_SYM (rel->r_info);
1663 if (isym->st_shndx == SHN_UNDEF)
1664 ssec = bfd_und_section_ptr;
1665 else if (isym->st_shndx == SHN_ABS)
1666 ssec = bfd_abs_section_ptr;
1667 else if (isym->st_shndx == SHN_COMMON)
1668 ssec = bfd_com_section_ptr;
1670 ssec = bfd_section_from_elf_index (abfd,
1673 /* Initial symbol value. */
1674 symval = isym->st_value;
1676 /* GAS may have made this symbol relative to a section, in
1677 which case, we have to add the addend to find the
1679 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1680 symval += rel->r_addend;
1684 if ((ssec->flags & SEC_MERGE)
1685 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1686 symval = _bfd_merged_section_offset (abfd, & ssec,
1687 elf_section_data (ssec)->sec_info,
1691 /* Now make the offset relative to where the linker is putting it. */
1694 ssec->output_section->vma + ssec->output_offset;
1696 symval += rel->r_addend;
1701 struct elf_link_hash_entry * h;
1703 /* An external symbol. */
1704 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1705 h = elf_sym_hashes (abfd)[indx];
1706 BFD_ASSERT (h != NULL);
1708 if (h->root.type != bfd_link_hash_defined
1709 && h->root.type != bfd_link_hash_defweak)
1711 /* This appears to be a reference to an undefined
1712 symbol. Just ignore it--it will be caught by the
1713 regular reloc processing. */
1719 symval = (h->root.u.def.value
1720 + h->root.u.def.section->output_section->vma
1721 + h->root.u.def.section->output_offset);
1723 symval += rel->r_addend;
1726 switch (ELF32_R_TYPE (rel->r_info))
1729 RL78_STACK_PUSH (symval);
1733 RL78_STACK_POP (tmp1);
1735 RL78_STACK_PUSH (tmp1);
1739 RL78_STACK_POP (tmp1);
1740 RL78_STACK_POP (tmp2);
1742 RL78_STACK_PUSH (tmp1);
1746 RL78_STACK_POP (tmp1);
1747 RL78_STACK_POP (tmp2);
1749 RL78_STACK_PUSH (tmp2);
1753 RL78_STACK_POP (tmp1);
1754 RL78_STACK_POP (tmp2);
1756 RL78_STACK_PUSH (tmp1);
1760 RL78_STACK_POP (tmp1);
1761 RL78_STACK_POP (tmp2);
1763 RL78_STACK_PUSH (tmp1);
1767 RL78_STACK_POP (tmp1);
1768 RL78_STACK_POP (tmp2);
1770 RL78_STACK_PUSH (tmp1);
1774 RL78_STACK_POP (tmp1);
1775 RL78_STACK_POP (tmp2);
1777 RL78_STACK_PUSH (tmp1);
1780 case R_RL78_OPsctsize:
1781 RL78_STACK_PUSH (input_section->size);
1784 case R_RL78_OPscttop:
1785 RL78_STACK_PUSH (input_section->output_section->vma);
1789 RL78_STACK_POP (tmp1);
1790 RL78_STACK_POP (tmp2);
1792 RL78_STACK_PUSH (tmp1);
1796 RL78_STACK_POP (tmp1);
1797 RL78_STACK_POP (tmp2);
1799 RL78_STACK_PUSH (tmp1);
1803 RL78_STACK_POP (tmp1);
1804 RL78_STACK_POP (tmp2);
1806 RL78_STACK_PUSH (tmp1);
1810 RL78_STACK_POP (tmp1);
1812 RL78_STACK_PUSH (tmp1);
1816 RL78_STACK_POP (tmp1);
1817 RL78_STACK_POP (tmp2);
1819 RL78_STACK_PUSH (tmp1);
1822 case R_RL78_OPromtop:
1823 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1826 case R_RL78_OPramtop:
1827 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1830 case R_RL78_DIR16UL:
1832 case R_RL78_ABS16UL:
1835 RL78_STACK_POP (symval);
1841 case R_RL78_DIR16UW:
1843 case R_RL78_ABS16UW:
1846 RL78_STACK_POP (symval);
1854 RL78_STACK_POP (symval);
1865 int prefix; /* or -1 for "no prefix" */
1866 int insn; /* or -1 for "end of list" */
1867 int insn_for_saddr; /* or -1 for "no alternative" */
1868 int insn_for_sfr; /* or -1 for "no alternative" */
1869 } relax_addr16[] = {
1870 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1871 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1872 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1873 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1875 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1876 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1877 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1878 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1879 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1880 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1881 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1882 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1884 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1885 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1886 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1887 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1888 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1890 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1891 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1892 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1893 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1895 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1896 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1897 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1899 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1900 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1901 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1902 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1903 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1904 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1906 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1908 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1909 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1910 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1911 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1912 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1913 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1914 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1915 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
1917 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
1918 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
1919 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
1920 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
1921 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
1922 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
1923 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
1924 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
1929 /* Relax one section. */
1932 rl78_elf_relax_section
1935 struct bfd_link_info * link_info,
1936 bfd_boolean * again)
1938 Elf_Internal_Shdr * symtab_hdr;
1939 Elf_Internal_Shdr * shndx_hdr;
1940 Elf_Internal_Rela * internal_relocs;
1941 Elf_Internal_Rela * free_relocs = NULL;
1942 Elf_Internal_Rela * irel;
1943 Elf_Internal_Rela * srel;
1944 Elf_Internal_Rela * irelend;
1945 Elf_Internal_Rela * next_alignment;
1946 bfd_byte * contents = NULL;
1947 bfd_byte * free_contents = NULL;
1948 Elf_Internal_Sym * intsyms = NULL;
1949 Elf_Internal_Sym * free_intsyms = NULL;
1950 Elf_External_Sym_Shndx * shndx_buf = NULL;
1952 bfd_vma symval ATTRIBUTE_UNUSED = 0;
1953 int pcrel ATTRIBUTE_UNUSED = 0;
1954 int code ATTRIBUTE_UNUSED = 0;
1955 int section_alignment_glue;
1958 if (abfd == elf_hash_table (link_info)->dynobj
1959 && strcmp (sec->name, ".plt") == 0)
1960 return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
1962 /* Assume nothing changes. */
1965 /* We don't have to do anything for a relocatable link, if
1966 this section does not have relocs, or if this is not a
1968 if (link_info->relocatable
1969 || (sec->flags & SEC_RELOC) == 0
1970 || sec->reloc_count == 0
1971 || (sec->flags & SEC_CODE) == 0)
1974 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1975 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1977 /* Get the section contents. */
1978 if (elf_section_data (sec)->this_hdr.contents != NULL)
1979 contents = elf_section_data (sec)->this_hdr.contents;
1980 /* Go get them off disk. */
1983 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1985 elf_section_data (sec)->this_hdr.contents = contents;
1988 /* Read this BFD's symbols. */
1989 /* Get cached copy if it exists. */
1990 if (symtab_hdr->contents != NULL)
1991 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1994 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1995 symtab_hdr->contents = (bfd_byte *) intsyms;
1998 if (shndx_hdr->sh_size != 0)
2002 amt = symtab_hdr->sh_info;
2003 amt *= sizeof (Elf_External_Sym_Shndx);
2004 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2005 if (shndx_buf == NULL)
2007 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2008 || bfd_bread (shndx_buf, amt, abfd) != amt)
2010 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2013 /* Get a copy of the native relocations. */
2014 internal_relocs = (_bfd_elf_link_read_relocs
2015 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2016 link_info->keep_memory));
2017 if (internal_relocs == NULL)
2019 if (! link_info->keep_memory)
2020 free_relocs = internal_relocs;
2022 /* The RL_ relocs must be just before the operand relocs they go
2023 with, so we must sort them to guarantee this. We use bubblesort
2024 instead of qsort so we can guarantee that relocs with the same
2025 address remain in the same relative order. */
2026 reloc_bubblesort (internal_relocs, sec->reloc_count);
2028 /* Walk through them looking for relaxing opportunities. */
2029 irelend = internal_relocs + sec->reloc_count;
2032 /* This will either be NULL or a pointer to the next alignment
2034 next_alignment = internal_relocs;
2036 /* We calculate worst case shrinkage caused by alignment directives.
2037 No fool-proof, but better than either ignoring the problem or
2038 doing heavy duty analysis of all the alignment markers in all
2040 section_alignment_glue = 0;
2041 for (irel = internal_relocs; irel < irelend; irel++)
2042 if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2043 && irel->r_addend & RL78_RELAXA_ALIGN)
2045 int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2047 if (section_alignment_glue < this_glue)
2048 section_alignment_glue = this_glue;
2050 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2052 section_alignment_glue *= 2;
2054 for (irel = internal_relocs; irel < irelend; irel++)
2056 unsigned char *insn;
2059 /* The insns we care about are all marked with one of these. */
2060 if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2063 if (irel->r_addend & RL78_RELAXA_ALIGN
2064 || next_alignment == internal_relocs)
2066 /* When we delete bytes, we need to maintain all the alignments
2067 indicated. In addition, we need to be careful about relaxing
2068 jumps across alignment boundaries - these displacements
2069 *grow* when we delete bytes. For now, don't shrink
2070 displacements across an alignment boundary, just in case.
2071 Note that this only affects relocations to the same
2073 next_alignment += 2;
2074 while (next_alignment < irelend
2075 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2076 || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2078 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2079 next_alignment = NULL;
2082 /* When we hit alignment markers, see if we've shrunk enough
2083 before them to reduce the gap without violating the alignment
2085 if (irel->r_addend & RL78_RELAXA_ALIGN)
2087 /* At this point, the next relocation *should* be the ELIGN
2089 Elf_Internal_Rela *erel = irel + 1;
2090 unsigned int alignment, nbytes;
2092 if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2094 if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2097 alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2099 if (erel->r_offset - irel->r_offset < alignment)
2102 nbytes = erel->r_offset - irel->r_offset;
2103 nbytes /= alignment;
2104 nbytes *= alignment;
2106 elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2107 erel->r_offset == sec->size);
2113 if (irel->r_addend & RL78_RELAXA_ELIGN)
2116 insn = contents + irel->r_offset;
2118 nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2120 /* At this point, we have an insn that is a candidate for linker
2121 relaxation. There are NRELOCS relocs following that may be
2122 relaxed, although each reloc may be made of more than one
2123 reloc entry (such as gp-rel symbols). */
2125 /* Get the value of the symbol referred to by the reloc. Just
2126 in case this is the last reloc in the list, use the RL's
2127 addend to choose between this reloc (no addend) or the next
2128 (yes addend, which means at least one following reloc). */
2130 /* srel points to the "current" reloction for this insn -
2131 actually the last reloc for a given operand, which is the one
2132 we need to update. We check the relaxations in the same
2133 order that the relocations happen, so we'll just push it
2137 pc = sec->output_section->vma + sec->output_offset
2141 BFD_ASSERT (nrelocs > 0); \
2142 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2143 pcrel = symval - pc + srel->r_addend; \
2146 #define SNIPNR(offset, nbytes) \
2147 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2148 #define SNIP(offset, nbytes, newtype) \
2149 SNIPNR (offset, nbytes); \
2150 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2152 /* The order of these bit tests must match the order that the
2153 relocs appear in. Since we sorted those by offset, we can
2156 /*----------------------------------------------------------------------*/
2157 /* EF ad BR $rel8 pcrel
2158 ED al ah BR !abs16 abs
2159 EE al ah BR $!rel16 pcrel
2160 EC al ah as BR !!abs20 abs
2162 FD al ah CALL !abs16 abs
2163 FE al ah CALL $!rel16 pcrel
2164 FC al ah as CALL !!abs20 abs
2172 61 C8 EF ad SKC ; BR $rel8
2173 61 D8 EF ad SKNC ; BR $rel8
2174 61 E8 EF ad SKZ ; BR $rel8
2175 61 F8 EF ad SKNZ ; BR $rel8
2176 61 E3 EF ad SKH ; BR $rel8
2177 61 F3 EF ad SKNH ; BR $rel8
2180 if (irel->r_addend & RL78_RELAXA_BRA)
2182 /* SKIP opcodes that skip non-branches will have a relax tag
2183 but no corresponding symbol to relax against; we just
2185 if (irel->r_addend & RL78_RELAXA_RNUM)
2192 case 0xec: /* BR !!abs20 */
2199 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2202 else if (symval < 65536)
2205 insn[1] = symval & 0xff;
2206 insn[2] = symval >> 8;
2207 SNIP (2, 1, R_RL78_DIR16S);
2210 else if (pcrel < 32767
2214 insn[1] = pcrel & 0xff;
2215 insn[2] = pcrel >> 8;
2216 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2221 case 0xee: /* BR $!pcrel16 */
2222 case 0xed: /* BR $!abs16 */
2228 SNIP (2, 1, R_RL78_DIR8S_PCREL);
2233 case 0xfc: /* CALL !!abs20 */
2237 insn[1] = symval & 0xff;
2238 insn[2] = symval >> 8;
2239 SNIP (2, 1, R_RL78_DIR16S);
2242 else if (pcrel < 32767
2246 insn[1] = pcrel & 0xff;
2247 insn[2] = pcrel >> 8;
2248 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2253 case 0x61: /* PREFIX */
2254 /* For SKIP/BR, we change the BR opcode and delete the
2255 SKIP. That way, we don't have to find and change the
2256 relocation for the BR. */
2257 /* Note that, for the case where we're skipping some
2258 other insn, we have no "other" reloc but that's safe
2262 case 0xc8: /* SKC */
2263 if (insn[2] == 0xef)
2265 insn[2] = 0xde; /* BNC */
2270 case 0xd8: /* SKNC */
2271 if (insn[2] == 0xef)
2273 insn[2] = 0xdc; /* BC */
2278 case 0xe8: /* SKZ */
2279 if (insn[2] == 0xef)
2281 insn[2] = 0xdf; /* BNZ */
2286 case 0xf8: /* SKNZ */
2287 if (insn[2] == 0xef)
2289 insn[2] = 0xdd; /* BZ */
2294 case 0xe3: /* SKH */
2295 if (insn[2] == 0xef)
2297 insn[2] = 0xd3; /* BNH */
2298 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2302 case 0xf3: /* SKNH */
2303 if (insn[2] == 0xef)
2305 insn[2] = 0xc3; /* BH */
2306 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2315 if (irel->r_addend & RL78_RELAXA_ADDR16)
2317 /*----------------------------------------------------------------------*/
2318 /* Some insns have both a 16-bit address operand and an 8-bit
2319 variant if the address is within a special range:
2321 Address 16-bit operand SADDR range SFR range
2322 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2323 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2325 The RELAX_ADDR16[] array has the insn encodings for the
2326 16-bit operand version, as well as the SFR and SADDR
2327 variants. We only need to replace the encodings and
2330 Note: we intentionally do not attempt to decode and skip
2331 any ES: prefix, as adding ES: means the addr16 (likely)
2332 no longer points to saddr/sfr space.
2342 if (0xffe20 <= symval && symval <= 0xfffff)
2345 is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2346 is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2348 for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2350 if (relax_addr16[idx].prefix != -1
2351 && insn[0] == relax_addr16[idx].prefix
2352 && insn[1] == relax_addr16[idx].insn)
2356 else if (relax_addr16[idx].prefix == -1
2357 && insn[0] == relax_addr16[idx].insn)
2364 /* We have a matched insn, and poff is 0 or 1 depending
2365 on the base pattern size. */
2367 if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2369 insn[poff] = relax_addr16[idx].insn_for_sfr;
2370 SNIP (poff+2, 1, R_RL78_RH_SFR);
2373 else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2375 insn[poff] = relax_addr16[idx].insn_for_saddr;
2376 SNIP (poff+2, 1, R_RL78_RH_SADDR);
2383 /*----------------------------------------------------------------------*/
2390 if (free_relocs != NULL)
2393 if (free_contents != NULL)
2394 free (free_contents);
2396 if (shndx_buf != NULL)
2398 shndx_hdr->contents = NULL;
2402 if (free_intsyms != NULL)
2403 free (free_intsyms);
2410 #define ELF_ARCH bfd_arch_rl78
2411 #define ELF_MACHINE_CODE EM_RL78
2412 #define ELF_MAXPAGESIZE 0x1000
2414 #define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2415 #define TARGET_LITTLE_NAME "elf32-rl78"
2417 #define elf_info_to_howto_rel NULL
2418 #define elf_info_to_howto rl78_info_to_howto_rela
2419 #define elf_backend_object_p rl78_elf_object_p
2420 #define elf_backend_relocate_section rl78_elf_relocate_section
2421 #define elf_symbol_leading_char ('_')
2422 #define elf_backend_can_gc_sections 1
2424 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2425 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2426 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2427 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2428 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2430 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2431 #define elf_backend_check_relocs rl78_elf_check_relocs
2432 #define elf_backend_always_size_sections \
2433 rl78_elf_always_size_sections
2434 #define elf_backend_finish_dynamic_sections \
2435 rl78_elf_finish_dynamic_sections
2437 #include "elf32-target.h"