1 /* Renesas RL78 specific support for 32-bit ELF.
2 Copyright (C) 2011, 2012
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "bfd_stdint.h"
27 #include "libiberty.h"
29 #define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
31 #define RL78REL(n,sz,bit,shift,complain,pcrel) \
32 HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
33 bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
35 /* Note that the relocations around 0x7f are internal to this file;
36 feel free to move them as needed to avoid conflicts with published
37 relocation numbers. */
39 static reloc_howto_type rl78_elf_howto_table [] =
41 RL78REL (NONE, 0, 0, 0, dont, FALSE),
42 RL78REL (DIR32, 2, 32, 0, signed, FALSE),
43 RL78REL (DIR24S, 2, 24, 0, signed, FALSE),
44 RL78REL (DIR16, 1, 16, 0, dont, FALSE),
45 RL78REL (DIR16U, 1, 16, 0, unsigned, FALSE),
46 RL78REL (DIR16S, 1, 16, 0, signed, FALSE),
47 RL78REL (DIR8, 0, 8, 0, dont, FALSE),
48 RL78REL (DIR8U, 0, 8, 0, unsigned, FALSE),
49 RL78REL (DIR8S, 0, 8, 0, signed, FALSE),
50 RL78REL (DIR24S_PCREL, 2, 24, 0, signed, TRUE),
51 RL78REL (DIR16S_PCREL, 1, 16, 0, signed, TRUE),
52 RL78REL (DIR8S_PCREL, 0, 8, 0, signed, TRUE),
53 RL78REL (DIR16UL, 1, 16, 2, unsigned, FALSE),
54 RL78REL (DIR16UW, 1, 16, 1, unsigned, FALSE),
55 RL78REL (DIR8UL, 0, 8, 2, unsigned, FALSE),
56 RL78REL (DIR8UW, 0, 8, 1, unsigned, FALSE),
57 RL78REL (DIR32_REV, 1, 16, 0, dont, FALSE),
58 RL78REL (DIR16_REV, 1, 16, 0, dont, FALSE),
59 RL78REL (DIR3U_PCREL, 0, 3, 0, dont, TRUE),
88 RL78REL (RH_RELAX, 0, 0, 0, dont, FALSE),
110 RL78REL (ABS32, 2, 32, 0, dont, FALSE),
111 RL78REL (ABS24S, 2, 24, 0, signed, FALSE),
112 RL78REL (ABS16, 1, 16, 0, dont, FALSE),
113 RL78REL (ABS16U, 1, 16, 0, unsigned, FALSE),
114 RL78REL (ABS16S, 1, 16, 0, signed, FALSE),
115 RL78REL (ABS8, 0, 8, 0, dont, FALSE),
116 RL78REL (ABS8U, 0, 8, 0, unsigned, FALSE),
117 RL78REL (ABS8S, 0, 8, 0, signed, FALSE),
118 RL78REL (ABS24S_PCREL, 2, 24, 0, signed, TRUE),
119 RL78REL (ABS16S_PCREL, 1, 16, 0, signed, TRUE),
120 RL78REL (ABS8S_PCREL, 0, 8, 0, signed, TRUE),
121 RL78REL (ABS16UL, 1, 16, 0, unsigned, FALSE),
122 RL78REL (ABS16UW, 1, 16, 0, unsigned, FALSE),
123 RL78REL (ABS8UL, 0, 8, 0, unsigned, FALSE),
124 RL78REL (ABS8UW, 0, 8, 0, unsigned, FALSE),
125 RL78REL (ABS32_REV, 2, 32, 0, dont, FALSE),
126 RL78REL (ABS16_REV, 1, 16, 0, dont, FALSE),
128 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
178 RL78REL (SYM, 2, 32, 0, dont, FALSE),
179 RL78REL (OPneg, 2, 32, 0, dont, FALSE),
180 RL78REL (OPadd, 2, 32, 0, dont, FALSE),
181 RL78REL (OPsub, 2, 32, 0, dont, FALSE),
182 RL78REL (OPmul, 2, 32, 0, dont, FALSE),
183 RL78REL (OPdiv, 2, 32, 0, dont, FALSE),
184 RL78REL (OPshla, 2, 32, 0, dont, FALSE),
185 RL78REL (OPshra, 2, 32, 0, dont, FALSE),
186 RL78REL (OPsctsize, 2, 32, 0, dont, FALSE),
191 RL78REL (OPscttop, 2, 32, 0, dont, FALSE),
194 RL78REL (OPand, 2, 32, 0, dont, FALSE),
195 RL78REL (OPor, 2, 32, 0, dont, FALSE),
196 RL78REL (OPxor, 2, 32, 0, dont, FALSE),
197 RL78REL (OPnot, 2, 32, 0, dont, FALSE),
198 RL78REL (OPmod, 2, 32, 0, dont, FALSE),
199 RL78REL (OPromtop, 2, 32, 0, dont, FALSE),
200 RL78REL (OPramtop, 2, 32, 0, dont, FALSE)
203 /* Map BFD reloc types to RL78 ELF reloc types. */
205 struct rl78_reloc_map
207 bfd_reloc_code_real_type bfd_reloc_val;
208 unsigned int rl78_reloc_val;
211 static const struct rl78_reloc_map rl78_reloc_map [] =
213 { BFD_RELOC_NONE, R_RL78_NONE },
214 { BFD_RELOC_8, R_RL78_DIR8S },
215 { BFD_RELOC_16, R_RL78_DIR16S },
216 { BFD_RELOC_24, R_RL78_DIR24S },
217 { BFD_RELOC_32, R_RL78_DIR32 },
218 { BFD_RELOC_RL78_16_OP, R_RL78_DIR16 },
219 { BFD_RELOC_RL78_DIR3U_PCREL, R_RL78_DIR3U_PCREL },
220 { BFD_RELOC_8_PCREL, R_RL78_DIR8S_PCREL },
221 { BFD_RELOC_16_PCREL, R_RL78_DIR16S_PCREL },
222 { BFD_RELOC_24_PCREL, R_RL78_DIR24S_PCREL },
223 { BFD_RELOC_RL78_8U, R_RL78_DIR8U },
224 { BFD_RELOC_RL78_16U, R_RL78_DIR16U },
225 { BFD_RELOC_RL78_SYM, R_RL78_SYM },
226 { BFD_RELOC_RL78_OP_SUBTRACT, R_RL78_OPsub },
227 { BFD_RELOC_RL78_OP_NEG, R_RL78_OPneg },
228 { BFD_RELOC_RL78_OP_AND, R_RL78_OPand },
229 { BFD_RELOC_RL78_OP_SHRA, R_RL78_OPshra },
230 { BFD_RELOC_RL78_ABS8, R_RL78_ABS8 },
231 { BFD_RELOC_RL78_ABS16, R_RL78_ABS16 },
232 { BFD_RELOC_RL78_ABS16_REV, R_RL78_ABS16_REV },
233 { BFD_RELOC_RL78_ABS32, R_RL78_ABS32 },
234 { BFD_RELOC_RL78_ABS32_REV, R_RL78_ABS32_REV },
235 { BFD_RELOC_RL78_ABS16UL, R_RL78_ABS16UL },
236 { BFD_RELOC_RL78_ABS16UW, R_RL78_ABS16UW },
237 { BFD_RELOC_RL78_ABS16U, R_RL78_ABS16U },
238 { BFD_RELOC_RL78_RELAX, R_RL78_RH_RELAX }
241 static reloc_howto_type *
242 rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
243 bfd_reloc_code_real_type code)
247 if (code == BFD_RELOC_RL78_32_OP)
248 return rl78_elf_howto_table + R_RL78_DIR32;
250 for (i = ARRAY_SIZE (rl78_reloc_map); --i;)
251 if (rl78_reloc_map [i].bfd_reloc_val == code)
252 return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
257 static reloc_howto_type *
258 rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
262 for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
263 if (rl78_elf_howto_table[i].name != NULL
264 && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
265 return rl78_elf_howto_table + i;
270 /* Set the howto pointer for an RL78 ELF reloc. */
273 rl78_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
275 Elf_Internal_Rela * dst)
279 r_type = ELF32_R_TYPE (dst->r_info);
280 BFD_ASSERT (r_type < (unsigned int) R_RL78_max);
281 cache_ptr->howto = rl78_elf_howto_table + r_type;
285 get_symbol_value (const char * name,
286 bfd_reloc_status_type * status,
287 struct bfd_link_info * info,
289 asection * input_section,
293 struct bfd_link_hash_entry * h;
295 h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
298 || (h->type != bfd_link_hash_defined
299 && h->type != bfd_link_hash_defweak))
300 * status = info->callbacks->undefined_symbol
301 (info, name, input_bfd, input_section, offset, TRUE);
303 value = (h->u.def.value
304 + h->u.def.section->output_section->vma
305 + h->u.def.section->output_offset);
311 get_romstart (bfd_reloc_status_type * status,
312 struct bfd_link_info * info,
317 static bfd_boolean cached = FALSE;
318 static bfd_vma cached_value = 0;
322 cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
329 get_ramstart (bfd_reloc_status_type * status,
330 struct bfd_link_info * info,
335 static bfd_boolean cached = FALSE;
336 static bfd_vma cached_value = 0;
340 cached_value = get_symbol_value ("__datastart", status, info, abfd, sec, offset);
346 #define NUM_STACK_ENTRIES 16
347 static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
348 static unsigned int rl78_stack_top;
350 #define RL78_STACK_PUSH(val) \
353 if (rl78_stack_top < NUM_STACK_ENTRIES) \
354 rl78_stack [rl78_stack_top ++] = (val); \
356 r = bfd_reloc_dangerous; \
360 #define RL78_STACK_POP(dest) \
363 if (rl78_stack_top > 0) \
364 (dest) = rl78_stack [-- rl78_stack_top]; \
366 (dest) = 0, r = bfd_reloc_dangerous; \
370 /* Relocate an RL78 ELF section.
371 There is some attempt to make this function usable for many architectures,
372 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
373 if only to serve as a learning tool.
375 The RELOCATE_SECTION function is called by the new ELF backend linker
376 to handle the relocations for a section.
378 The relocs are always passed as Rela structures; if the section
379 actually uses Rel structures, the r_addend field will always be
382 This function is responsible for adjusting the section contents as
383 necessary, and (if using Rela relocs and generating a relocatable
384 output file) adjusting the reloc addend as necessary.
386 This function does not have to worry about setting the reloc
387 address or the reloc symbol index.
389 LOCAL_SYMS is a pointer to the swapped in local symbols.
391 LOCAL_SECTIONS is an array giving the section in the input file
392 corresponding to the st_shndx field of each local symbol.
394 The global hash table entry for the global symbols can be found
395 via elf_sym_hashes (input_bfd).
397 When generating relocatable output, this function must handle
398 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
399 going to be the section symbol corresponding to the output
400 section, which means that the addend must be adjusted
404 rl78_elf_relocate_section
406 struct bfd_link_info * info,
408 asection * input_section,
410 Elf_Internal_Rela * relocs,
411 Elf_Internal_Sym * local_syms,
412 asection ** local_sections)
414 Elf_Internal_Shdr * symtab_hdr;
415 struct elf_link_hash_entry ** sym_hashes;
416 Elf_Internal_Rela * rel;
417 Elf_Internal_Rela * relend;
421 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
422 sym_hashes = elf_sym_hashes (input_bfd);
423 relend = relocs + input_section->reloc_count;
425 dynobj = elf_hash_table (info)->dynobj;
428 splt = bfd_get_linker_section (dynobj, ".plt");
430 for (rel = relocs; rel < relend; rel ++)
432 reloc_howto_type * howto;
433 unsigned long r_symndx;
434 Elf_Internal_Sym * sym;
436 struct elf_link_hash_entry * h;
438 bfd_reloc_status_type r;
439 const char * name = NULL;
440 bfd_boolean unresolved_reloc = TRUE;
443 r_type = ELF32_R_TYPE (rel->r_info);
444 r_symndx = ELF32_R_SYM (rel->r_info);
446 howto = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
452 if (r_symndx < symtab_hdr->sh_info)
454 sym = local_syms + r_symndx;
455 sec = local_sections [r_symndx];
456 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
458 name = bfd_elf_string_from_elf_section
459 (input_bfd, symtab_hdr->sh_link, sym->st_name);
460 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
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
782 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
790 RL78_STACK_POP (tmp);
792 RL78_STACK_PUSH (tmp);
800 RL78_STACK_POP (tmp2);
801 RL78_STACK_POP (tmp1);
803 RL78_STACK_PUSH (tmp1);
811 RL78_STACK_POP (tmp2);
812 RL78_STACK_POP (tmp1);
814 RL78_STACK_PUSH (tmp2);
822 RL78_STACK_POP (tmp2);
823 RL78_STACK_POP (tmp1);
825 RL78_STACK_PUSH (tmp1);
833 RL78_STACK_POP (tmp2);
834 RL78_STACK_POP (tmp1);
836 RL78_STACK_PUSH (tmp1);
844 RL78_STACK_POP (tmp2);
845 RL78_STACK_POP (tmp1);
847 RL78_STACK_PUSH (tmp1);
855 RL78_STACK_POP (tmp2);
856 RL78_STACK_POP (tmp1);
858 RL78_STACK_PUSH (tmp1);
862 case R_RL78_OPsctsize:
863 RL78_STACK_PUSH (input_section->size);
866 case R_RL78_OPscttop:
867 RL78_STACK_PUSH (input_section->output_section->vma);
874 RL78_STACK_POP (tmp2);
875 RL78_STACK_POP (tmp1);
877 RL78_STACK_PUSH (tmp1);
885 RL78_STACK_POP (tmp2);
886 RL78_STACK_POP (tmp1);
888 RL78_STACK_PUSH (tmp1);
896 RL78_STACK_POP (tmp2);
897 RL78_STACK_POP (tmp1);
899 RL78_STACK_PUSH (tmp1);
907 RL78_STACK_POP (tmp);
909 RL78_STACK_PUSH (tmp);
917 RL78_STACK_POP (tmp2);
918 RL78_STACK_POP (tmp1);
920 RL78_STACK_PUSH (tmp1);
924 case R_RL78_OPromtop:
925 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
928 case R_RL78_OPramtop:
929 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
933 r = bfd_reloc_notsupported;
937 if (r != bfd_reloc_ok)
939 const char * msg = NULL;
943 case bfd_reloc_overflow:
944 /* Catch the case of a missing function declaration
945 and emit a more helpful error message. */
946 if (r_type == R_RL78_DIR24S_PCREL)
947 msg = _("%B(%A): error: call to undefined function '%s'");
949 r = info->callbacks->reloc_overflow
950 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
951 input_bfd, input_section, rel->r_offset);
954 case bfd_reloc_undefined:
955 r = info->callbacks->undefined_symbol
956 (info, name, input_bfd, input_section, rel->r_offset,
960 case bfd_reloc_other:
961 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
964 case bfd_reloc_outofrange:
965 msg = _("%B(%A): internal error: out of range error");
968 case bfd_reloc_notsupported:
969 msg = _("%B(%A): internal error: unsupported relocation error");
972 case bfd_reloc_dangerous:
973 msg = _("%B(%A): internal error: dangerous relocation");
977 msg = _("%B(%A): internal error: unknown error");
982 _bfd_error_handler (msg, input_bfd, input_section, name);
992 /* Function to set the ELF flag bits. */
995 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
997 elf_elfheader (abfd)->e_flags = flags;
998 elf_flags_init (abfd) = TRUE;
1002 static bfd_boolean no_warn_mismatch = FALSE;
1004 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1007 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1009 no_warn_mismatch = user_no_warn_mismatch;
1012 /* Merge backend specific data from an object file to the output
1013 object file when linking. */
1016 rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1019 bfd_boolean error = FALSE;
1021 new_flags = elf_elfheader (ibfd)->e_flags;
1023 if (!elf_flags_init (obfd))
1025 /* First call, no flags set. */
1026 elf_flags_init (obfd) = TRUE;
1027 elf_elfheader (obfd)->e_flags = new_flags;
1034 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1036 FILE * file = (FILE *) ptr;
1039 BFD_ASSERT (abfd != NULL && ptr != NULL);
1041 /* Print normal ELF private data. */
1042 _bfd_elf_print_private_bfd_data (abfd, ptr);
1044 flags = elf_elfheader (abfd)->e_flags;
1045 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1051 /* Return the MACH for an e_flags value. */
1054 elf32_rl78_machine (bfd * abfd)
1056 if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1057 return bfd_mach_rl78;
1063 rl78_elf_object_p (bfd * abfd)
1065 bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1066 elf32_rl78_machine (abfd));
1072 rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
1075 Elf_Internal_Sym * isymbuf;
1076 Elf_Internal_Sym * isymend;
1077 Elf_Internal_Sym * isym;
1078 Elf_Internal_Shdr * symtab_hdr;
1079 bfd_boolean free_internal = FALSE, free_external = FALSE;
1081 char * st_info_stb_str;
1082 char * st_other_str;
1083 char * st_shndx_str;
1085 if (! internal_syms)
1087 internal_syms = bfd_malloc (1000);
1090 if (! external_syms)
1092 external_syms = bfd_malloc (1000);
1096 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1097 locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
1099 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1100 symtab_hdr->sh_info, 0,
1101 internal_syms, external_syms, NULL);
1103 isymbuf = internal_syms;
1104 isymend = isymbuf + locsymcount;
1106 for (isym = isymbuf ; isym < isymend ; isym++)
1108 switch (ELF_ST_TYPE (isym->st_info))
1110 case STT_FUNC: st_info_str = "STT_FUNC";
1111 case STT_SECTION: st_info_str = "STT_SECTION";
1112 case STT_FILE: st_info_str = "STT_FILE";
1113 case STT_OBJECT: st_info_str = "STT_OBJECT";
1114 case STT_TLS: st_info_str = "STT_TLS";
1115 default: st_info_str = "";
1117 switch (ELF_ST_BIND (isym->st_info))
1119 case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
1120 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
1121 default: st_info_stb_str = "";
1123 switch (ELF_ST_VISIBILITY (isym->st_other))
1125 case STV_DEFAULT: st_other_str = "STV_DEFAULT";
1126 case STV_INTERNAL: st_other_str = "STV_INTERNAL";
1127 case STV_PROTECTED: st_other_str = "STV_PROTECTED";
1128 default: st_other_str = "";
1130 switch (isym->st_shndx)
1132 case SHN_ABS: st_shndx_str = "SHN_ABS";
1133 case SHN_COMMON: st_shndx_str = "SHN_COMMON";
1134 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
1135 default: st_shndx_str = "";
1139 free (internal_syms);
1141 free (external_syms);
1145 rl78_get_reloc (long reloc)
1147 if (0 <= reloc && reloc < R_RL78_max)
1148 return rl78_elf_howto_table[reloc].name;
1154 /* support PLT for 16-bit references to 24-bit functions. */
1156 /* We support 16-bit pointers to code above 64k by generating a thunk
1157 below 64k containing a JMP instruction to the final address. */
1160 rl78_elf_check_relocs
1162 struct bfd_link_info * info,
1164 const Elf_Internal_Rela * relocs)
1166 Elf_Internal_Shdr * symtab_hdr;
1167 struct elf_link_hash_entry ** sym_hashes;
1168 const Elf_Internal_Rela * rel;
1169 const Elf_Internal_Rela * rel_end;
1170 bfd_vma *local_plt_offsets;
1174 if (info->relocatable)
1177 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1178 sym_hashes = elf_sym_hashes (abfd);
1179 local_plt_offsets = elf_local_got_offsets (abfd);
1181 dynobj = elf_hash_table(info)->dynobj;
1183 rel_end = relocs + sec->reloc_count;
1184 for (rel = relocs; rel < rel_end; rel++)
1186 struct elf_link_hash_entry *h;
1187 unsigned long r_symndx;
1190 r_symndx = ELF32_R_SYM (rel->r_info);
1191 if (r_symndx < symtab_hdr->sh_info)
1195 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1196 while (h->root.type == bfd_link_hash_indirect
1197 || h->root.type == bfd_link_hash_warning)
1198 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1201 switch (ELF32_R_TYPE (rel->r_info))
1203 /* This relocation describes a 16-bit pointer to a function.
1204 We may need to allocate a thunk in low memory; reserve memory
1208 elf_hash_table (info)->dynobj = dynobj = abfd;
1211 splt = bfd_get_linker_section (dynobj, ".plt");
1214 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1215 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1216 | SEC_READONLY | SEC_CODE);
1217 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
1220 || ! bfd_set_section_alignment (dynobj, splt, 1))
1226 offset = &h->plt.offset;
1229 if (local_plt_offsets == NULL)
1234 size = symtab_hdr->sh_info * sizeof (bfd_vma);
1235 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1236 if (local_plt_offsets == NULL)
1238 elf_local_got_offsets (abfd) = local_plt_offsets;
1240 for (i = 0; i < symtab_hdr->sh_info; i++)
1241 local_plt_offsets[i] = (bfd_vma) -1;
1243 offset = &local_plt_offsets[r_symndx];
1246 if (*offset == (bfd_vma) -1)
1248 *offset = splt->size;
1258 /* This must exist if dynobj is ever set. */
1261 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1262 struct bfd_link_info *info)
1267 /* As an extra sanity check, verify that all plt entries have been
1268 filled in. However, relaxing might have changed the relocs so
1269 that some plt entries don't get filled in, so we have to skip
1270 this check if we're relaxing. Unfortunately, check_relocs is
1271 called before relaxation. */
1273 if (info->relax_trip > 0)
1275 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1276 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
1278 bfd_byte *contents = splt->contents;
1279 unsigned int i, size = splt->size;
1280 for (i = 0; i < size; i += 4)
1282 unsigned int x = bfd_get_32 (dynobj, contents + i);
1283 BFD_ASSERT (x != 0);
1292 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1293 struct bfd_link_info *info)
1298 if (info->relocatable)
1301 dynobj = elf_hash_table (info)->dynobj;
1305 splt = bfd_get_linker_section (dynobj, ".plt");
1306 BFD_ASSERT (splt != NULL);
1308 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1309 if (splt->contents == NULL)
1317 /* Handle relaxing. */
1319 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1320 is within the low 64k, remove any entry for it in the plt. */
1322 struct relax_plt_data
1329 rl78_relax_plt_check (struct elf_link_hash_entry *h,
1332 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1334 if (h->plt.offset != (bfd_vma) -1)
1338 if (h->root.type == bfd_link_hash_undefined
1339 || h->root.type == bfd_link_hash_undefweak)
1342 address = (h->root.u.def.section->output_section->vma
1343 + h->root.u.def.section->output_offset
1344 + h->root.u.def.value);
1346 if (valid_16bit_address (address))
1349 data->splt->size -= 4;
1350 *data->again = TRUE;
1357 /* A subroutine of rl78_elf_relax_section. If the global symbol H
1358 previously had a plt entry, give it a new entry offset. */
1361 rl78_relax_plt_realloc (struct elf_link_hash_entry *h,
1364 bfd_vma *entry = (bfd_vma *) xdata;
1366 if (h->plt.offset != (bfd_vma) -1)
1368 h->plt.offset = *entry;
1376 rl78_elf_relax_plt_section (bfd *dynobj,
1378 struct bfd_link_info *info,
1381 struct relax_plt_data relax_plt_data;
1384 /* Assume nothing changes. */
1387 if (info->relocatable)
1390 /* We only relax the .plt section at the moment. */
1391 if (dynobj != elf_hash_table (info)->dynobj
1392 || strcmp (splt->name, ".plt") != 0)
1395 /* Quick check for an empty plt. */
1396 if (splt->size == 0)
1399 /* Map across all global symbols; see which ones happen to
1400 fall in the low 64k. */
1401 relax_plt_data.splt = splt;
1402 relax_plt_data.again = again;
1403 elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1406 /* Likewise for local symbols, though that's somewhat less convenient
1407 as we have to walk the list of input bfds and swap in symbol data. */
1408 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1410 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1411 Elf_Internal_Shdr *symtab_hdr;
1412 Elf_Internal_Sym *isymbuf = NULL;
1415 if (! local_plt_offsets)
1418 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1419 if (symtab_hdr->sh_info != 0)
1421 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1422 if (isymbuf == NULL)
1423 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1424 symtab_hdr->sh_info, 0,
1426 if (isymbuf == NULL)
1430 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1432 Elf_Internal_Sym *isym;
1436 if (local_plt_offsets[idx] == (bfd_vma) -1)
1439 isym = &isymbuf[idx];
1440 if (isym->st_shndx == SHN_UNDEF)
1442 else if (isym->st_shndx == SHN_ABS)
1443 tsec = bfd_abs_section_ptr;
1444 else if (isym->st_shndx == SHN_COMMON)
1445 tsec = bfd_com_section_ptr;
1447 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1449 address = (tsec->output_section->vma
1450 + tsec->output_offset
1452 if (valid_16bit_address (address))
1454 local_plt_offsets[idx] = -1;
1461 && symtab_hdr->contents != (unsigned char *) isymbuf)
1463 if (! info->keep_memory)
1467 /* Cache the symbols for elf_link_input_bfd. */
1468 symtab_hdr->contents = (unsigned char *) isymbuf;
1473 /* If we changed anything, walk the symbols again to reallocate
1474 .plt entry addresses. */
1475 if (*again && splt->size > 0)
1479 elf_link_hash_traverse (elf_hash_table (info),
1480 rl78_relax_plt_realloc, &entry);
1482 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1484 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1485 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1488 if (! local_plt_offsets)
1491 for (idx = 0; idx < nlocals; ++idx)
1492 if (local_plt_offsets[idx] != (bfd_vma) -1)
1494 local_plt_offsets[idx] = entry;
1503 /* Delete some bytes from a section while relaxing. */
1506 elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1507 Elf_Internal_Rela *alignment_rel, int force_snip)
1509 Elf_Internal_Shdr * symtab_hdr;
1510 unsigned int sec_shndx;
1511 bfd_byte * contents;
1512 Elf_Internal_Rela * irel;
1513 Elf_Internal_Rela * irelend;
1514 Elf_Internal_Sym * isym;
1515 Elf_Internal_Sym * isymend;
1517 unsigned int symcount;
1518 struct elf_link_hash_entry ** sym_hashes;
1519 struct elf_link_hash_entry ** end_hashes;
1524 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1526 contents = elf_section_data (sec)->this_hdr.contents;
1528 /* The deletion must stop at the next alignment boundary, if
1529 ALIGNMENT_REL is non-NULL. */
1532 toaddr = alignment_rel->r_offset;
1534 irel = elf_section_data (sec)->relocs;
1535 irelend = irel + sec->reloc_count;
1537 /* Actually delete the bytes. */
1538 memmove (contents + addr, contents + addr + count,
1539 (size_t) (toaddr - addr - count));
1541 /* If we don't have an alignment marker to worry about, we can just
1542 shrink the section. Otherwise, we have to fill in the newly
1543 created gap with NOP insns (0x03). */
1547 memset (contents + toaddr - count, 0x03, count);
1549 /* Adjust all the relocs. */
1550 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1552 /* Get the new reloc address. */
1553 if (irel->r_offset > addr
1554 && (irel->r_offset < toaddr
1555 || (force_snip && irel->r_offset == toaddr)))
1556 irel->r_offset -= count;
1558 /* If we see an ALIGN marker at the end of the gap, we move it
1559 to the beginning of the gap, since marking these gaps is what
1561 if (irel->r_offset == toaddr
1562 && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1563 && irel->r_addend & RL78_RELAXA_ALIGN)
1564 irel->r_offset -= count;
1567 /* Adjust the local symbols defined in this section. */
1568 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1569 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1570 isymend = isym + symtab_hdr->sh_info;
1572 for (; isym < isymend; isym++)
1574 /* If the symbol is in the range of memory we just moved, we
1575 have to adjust its value. */
1576 if (isym->st_shndx == sec_shndx
1577 && isym->st_value > addr
1578 && isym->st_value < toaddr)
1579 isym->st_value -= count;
1581 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1582 *end* is in the moved bytes but it's *start* isn't), then we
1583 must adjust its size. */
1584 if (isym->st_shndx == sec_shndx
1585 && isym->st_value < addr
1586 && isym->st_value + isym->st_size > addr
1587 && isym->st_value + isym->st_size < toaddr)
1588 isym->st_size -= count;
1591 /* Now adjust the global symbols defined in this section. */
1592 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1593 - symtab_hdr->sh_info);
1594 sym_hashes = elf_sym_hashes (abfd);
1595 end_hashes = sym_hashes + symcount;
1597 for (; sym_hashes < end_hashes; sym_hashes++)
1599 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1601 if ((sym_hash->root.type == bfd_link_hash_defined
1602 || sym_hash->root.type == bfd_link_hash_defweak)
1603 && sym_hash->root.u.def.section == sec)
1605 /* As above, adjust the value if needed. */
1606 if (sym_hash->root.u.def.value > addr
1607 && sym_hash->root.u.def.value < toaddr)
1608 sym_hash->root.u.def.value -= count;
1610 /* As above, adjust the size if needed. */
1611 if (sym_hash->root.u.def.value < addr
1612 && sym_hash->root.u.def.value + sym_hash->size > addr
1613 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1614 sym_hash->size -= count;
1621 /* Used to sort relocs by address. If relocs have the same address,
1622 we maintain their relative order, except that R_RL78_RH_RELAX
1623 alignment relocs must be the first reloc for any given address. */
1626 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1630 bfd_boolean swappit;
1632 /* This is almost a classic bubblesort. It's the slowest sort, but
1633 we're taking advantage of the fact that the relocations are
1634 mostly in order already (the assembler emits them that way) and
1635 we need relocs with the same address to remain in the same
1641 for (i = 0; i < count - 1; i ++)
1643 if (r[i].r_offset > r[i + 1].r_offset)
1645 else if (r[i].r_offset < r[i + 1].r_offset)
1647 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1648 && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1650 else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1651 && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1652 && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1653 && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1660 Elf_Internal_Rela tmp;
1665 /* If we do move a reloc back, re-scan to see if it
1666 needs to be moved even further back. This avoids
1667 most of the O(n^2) behavior for our cases. */
1677 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1678 rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1679 lrel, abfd, sec, link_info, scale)
1682 rl78_offset_for_reloc (bfd * abfd,
1683 Elf_Internal_Rela * rel,
1684 Elf_Internal_Shdr * symtab_hdr,
1685 Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1686 Elf_Internal_Sym * intsyms,
1687 Elf_Internal_Rela ** lrel,
1689 asection * input_section,
1690 struct bfd_link_info * info,
1694 bfd_reloc_status_type r;
1698 /* REL is the first of 1..N relocations. We compute the symbol
1699 value for each relocation, then combine them if needed. LREL
1700 gets a pointer to the last relocation used. */
1705 /* Get the value of the symbol referred to by the reloc. */
1706 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1708 /* A local symbol. */
1709 Elf_Internal_Sym *isym;
1712 isym = intsyms + ELF32_R_SYM (rel->r_info);
1714 if (isym->st_shndx == SHN_UNDEF)
1715 ssec = bfd_und_section_ptr;
1716 else if (isym->st_shndx == SHN_ABS)
1717 ssec = bfd_abs_section_ptr;
1718 else if (isym->st_shndx == SHN_COMMON)
1719 ssec = bfd_com_section_ptr;
1721 ssec = bfd_section_from_elf_index (abfd,
1724 /* Initial symbol value. */
1725 symval = isym->st_value;
1727 /* GAS may have made this symbol relative to a section, in
1728 which case, we have to add the addend to find the
1730 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1731 symval += rel->r_addend;
1735 if ((ssec->flags & SEC_MERGE)
1736 && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1737 symval = _bfd_merged_section_offset (abfd, & ssec,
1738 elf_section_data (ssec)->sec_info,
1742 /* Now make the offset relative to where the linker is putting it. */
1745 ssec->output_section->vma + ssec->output_offset;
1747 symval += rel->r_addend;
1752 struct elf_link_hash_entry * h;
1754 /* An external symbol. */
1755 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1756 h = elf_sym_hashes (abfd)[indx];
1757 BFD_ASSERT (h != NULL);
1759 if (h->root.type != bfd_link_hash_defined
1760 && h->root.type != bfd_link_hash_defweak)
1762 /* This appears to be a reference to an undefined
1763 symbol. Just ignore it--it will be caught by the
1764 regular reloc processing. */
1770 symval = (h->root.u.def.value
1771 + h->root.u.def.section->output_section->vma
1772 + h->root.u.def.section->output_offset);
1774 symval += rel->r_addend;
1777 switch (ELF32_R_TYPE (rel->r_info))
1780 RL78_STACK_PUSH (symval);
1784 RL78_STACK_POP (tmp1);
1786 RL78_STACK_PUSH (tmp1);
1790 RL78_STACK_POP (tmp1);
1791 RL78_STACK_POP (tmp2);
1793 RL78_STACK_PUSH (tmp1);
1797 RL78_STACK_POP (tmp1);
1798 RL78_STACK_POP (tmp2);
1800 RL78_STACK_PUSH (tmp2);
1804 RL78_STACK_POP (tmp1);
1805 RL78_STACK_POP (tmp2);
1807 RL78_STACK_PUSH (tmp1);
1811 RL78_STACK_POP (tmp1);
1812 RL78_STACK_POP (tmp2);
1814 RL78_STACK_PUSH (tmp1);
1818 RL78_STACK_POP (tmp1);
1819 RL78_STACK_POP (tmp2);
1821 RL78_STACK_PUSH (tmp1);
1825 RL78_STACK_POP (tmp1);
1826 RL78_STACK_POP (tmp2);
1828 RL78_STACK_PUSH (tmp1);
1831 case R_RL78_OPsctsize:
1832 RL78_STACK_PUSH (input_section->size);
1835 case R_RL78_OPscttop:
1836 RL78_STACK_PUSH (input_section->output_section->vma);
1840 RL78_STACK_POP (tmp1);
1841 RL78_STACK_POP (tmp2);
1843 RL78_STACK_PUSH (tmp1);
1847 RL78_STACK_POP (tmp1);
1848 RL78_STACK_POP (tmp2);
1850 RL78_STACK_PUSH (tmp1);
1854 RL78_STACK_POP (tmp1);
1855 RL78_STACK_POP (tmp2);
1857 RL78_STACK_PUSH (tmp1);
1861 RL78_STACK_POP (tmp1);
1863 RL78_STACK_PUSH (tmp1);
1867 RL78_STACK_POP (tmp1);
1868 RL78_STACK_POP (tmp2);
1870 RL78_STACK_PUSH (tmp1);
1873 case R_RL78_OPromtop:
1874 RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1877 case R_RL78_OPramtop:
1878 RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1881 case R_RL78_DIR16UL:
1883 case R_RL78_ABS16UL:
1886 RL78_STACK_POP (symval);
1892 case R_RL78_DIR16UW:
1894 case R_RL78_ABS16UW:
1897 RL78_STACK_POP (symval);
1905 RL78_STACK_POP (symval);
1916 int prefix; /* or -1 for "no prefix" */
1917 int insn; /* or -1 for "end of list" */
1918 int insn_for_saddr; /* or -1 for "no alternative" */
1919 int insn_for_sfr; /* or -1 for "no alternative" */
1920 } relax_addr16[] = {
1921 { -1, 0x02, 0x06, -1 }, /* ADDW AX, !addr16 */
1922 { -1, 0x22, 0x26, -1 }, /* SUBW AX, !addr16 */
1923 { -1, 0x42, 0x46, -1 }, /* CMPW AX, !addr16 */
1924 { -1, 0x40, 0x4a, -1 }, /* CMP !addr16, #byte */
1926 { -1, 0x0f, 0x0b, -1 }, /* ADD A, !addr16 */
1927 { -1, 0x1f, 0x1b, -1 }, /* ADDC A, !addr16 */
1928 { -1, 0x2f, 0x2b, -1 }, /* SUB A, !addr16 */
1929 { -1, 0x3f, 0x3b, -1 }, /* SUBC A, !addr16 */
1930 { -1, 0x4f, 0x4b, -1 }, /* CMP A, !addr16 */
1931 { -1, 0x5f, 0x5b, -1 }, /* AND A, !addr16 */
1932 { -1, 0x6f, 0x6b, -1 }, /* OR A, !addr16 */
1933 { -1, 0x7f, 0x7b, -1 }, /* XOR A, !addr16 */
1935 { -1, 0x8f, 0x8d, 0x8e }, /* MOV A, !addr16 */
1936 { -1, 0x9f, 0x9d, 0x9e }, /* MOV !addr16, A */
1937 { -1, 0xaf, 0xad, 0xae }, /* MOVW AX, !addr16 */
1938 { -1, 0xbf, 0xbd, 0xbe }, /* MOVW !addr16, AX */
1939 { -1, 0xcf, 0xcd, 0xce }, /* MOVW !addr16, #word */
1941 { -1, 0xa0, 0xa4, -1 }, /* INC !addr16 */
1942 { -1, 0xa2, 0xa6, -1 }, /* INCW !addr16 */
1943 { -1, 0xb0, 0xb4, -1 }, /* DEC !addr16 */
1944 { -1, 0xb2, 0xb6, -1 }, /* DECW !addr16 */
1946 { -1, 0xd5, 0xd4, -1 }, /* CMP0 !addr16 */
1947 { -1, 0xe5, 0xe4, -1 }, /* ONEB !addr16 */
1948 { -1, 0xf5, 0xf4, -1 }, /* CLRB !addr16 */
1950 { -1, 0xd9, 0xd8, -1 }, /* MOV X, !addr16 */
1951 { -1, 0xe9, 0xe8, -1 }, /* MOV B, !addr16 */
1952 { -1, 0xf9, 0xf8, -1 }, /* MOV C, !addr16 */
1953 { -1, 0xdb, 0xda, -1 }, /* MOVW BC, !addr16 */
1954 { -1, 0xeb, 0xea, -1 }, /* MOVW DE, !addr16 */
1955 { -1, 0xfb, 0xfa, -1 }, /* MOVW HL, !addr16 */
1957 { 0x61, 0xaa, 0xa8, -1 }, /* XCH A, !addr16 */
1959 { 0x71, 0x00, 0x02, 0x0a }, /* SET1 !addr16.0 */
1960 { 0x71, 0x10, 0x12, 0x1a }, /* SET1 !addr16.0 */
1961 { 0x71, 0x20, 0x22, 0x2a }, /* SET1 !addr16.0 */
1962 { 0x71, 0x30, 0x32, 0x3a }, /* SET1 !addr16.0 */
1963 { 0x71, 0x40, 0x42, 0x4a }, /* SET1 !addr16.0 */
1964 { 0x71, 0x50, 0x52, 0x5a }, /* SET1 !addr16.0 */
1965 { 0x71, 0x60, 0x62, 0x6a }, /* SET1 !addr16.0 */
1966 { 0x71, 0x70, 0x72, 0x7a }, /* SET1 !addr16.0 */
1968 { 0x71, 0x08, 0x03, 0x0b }, /* CLR1 !addr16.0 */
1969 { 0x71, 0x18, 0x13, 0x1b }, /* CLR1 !addr16.0 */
1970 { 0x71, 0x28, 0x23, 0x2b }, /* CLR1 !addr16.0 */
1971 { 0x71, 0x38, 0x33, 0x3b }, /* CLR1 !addr16.0 */
1972 { 0x71, 0x48, 0x43, 0x4b }, /* CLR1 !addr16.0 */
1973 { 0x71, 0x58, 0x53, 0x5b }, /* CLR1 !addr16.0 */
1974 { 0x71, 0x68, 0x63, 0x6b }, /* CLR1 !addr16.0 */
1975 { 0x71, 0x78, 0x73, 0x7b }, /* CLR1 !addr16.0 */
1980 /* Relax one section. */
1983 rl78_elf_relax_section
1986 struct bfd_link_info * link_info,
1987 bfd_boolean * again)
1989 Elf_Internal_Shdr * symtab_hdr;
1990 Elf_Internal_Shdr * shndx_hdr;
1991 Elf_Internal_Rela * internal_relocs;
1992 Elf_Internal_Rela * free_relocs = NULL;
1993 Elf_Internal_Rela * irel;
1994 Elf_Internal_Rela * srel;
1995 Elf_Internal_Rela * irelend;
1996 Elf_Internal_Rela * next_alignment;
1997 bfd_byte * contents = NULL;
1998 bfd_byte * free_contents = NULL;
1999 Elf_Internal_Sym * intsyms = NULL;
2000 Elf_Internal_Sym * free_intsyms = NULL;
2001 Elf_External_Sym_Shndx * shndx_buf = NULL;
2003 bfd_vma symval ATTRIBUTE_UNUSED = 0;
2004 int pcrel ATTRIBUTE_UNUSED = 0;
2005 int code ATTRIBUTE_UNUSED = 0;
2006 int section_alignment_glue;
2009 if (abfd == elf_hash_table (link_info)->dynobj
2010 && strcmp (sec->name, ".plt") == 0)
2011 return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2013 /* Assume nothing changes. */
2016 /* We don't have to do anything for a relocatable link, if
2017 this section does not have relocs, or if this is not a
2019 if (link_info->relocatable
2020 || (sec->flags & SEC_RELOC) == 0
2021 || sec->reloc_count == 0
2022 || (sec->flags & SEC_CODE) == 0)
2025 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2026 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2028 /* Get the section contents. */
2029 if (elf_section_data (sec)->this_hdr.contents != NULL)
2030 contents = elf_section_data (sec)->this_hdr.contents;
2031 /* Go get them off disk. */
2034 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2036 elf_section_data (sec)->this_hdr.contents = contents;
2039 /* Read this BFD's symbols. */
2040 /* Get cached copy if it exists. */
2041 if (symtab_hdr->contents != NULL)
2042 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2045 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2046 symtab_hdr->contents = (bfd_byte *) intsyms;
2049 if (shndx_hdr->sh_size != 0)
2053 amt = symtab_hdr->sh_info;
2054 amt *= sizeof (Elf_External_Sym_Shndx);
2055 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2056 if (shndx_buf == NULL)
2058 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2059 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
2061 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2064 /* Get a copy of the native relocations. */
2065 internal_relocs = (_bfd_elf_link_read_relocs
2066 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2067 link_info->keep_memory));
2068 if (internal_relocs == NULL)
2070 if (! link_info->keep_memory)
2071 free_relocs = internal_relocs;
2073 /* The RL_ relocs must be just before the operand relocs they go
2074 with, so we must sort them to guarantee this. We use bubblesort
2075 instead of qsort so we can guarantee that relocs with the same
2076 address remain in the same relative order. */
2077 reloc_bubblesort (internal_relocs, sec->reloc_count);
2079 /* Walk through them looking for relaxing opportunities. */
2080 irelend = internal_relocs + sec->reloc_count;
2083 /* This will either be NULL or a pointer to the next alignment
2085 next_alignment = internal_relocs;
2087 /* We calculate worst case shrinkage caused by alignment directives.
2088 No fool-proof, but better than either ignoring the problem or
2089 doing heavy duty analysis of all the alignment markers in all
2091 section_alignment_glue = 0;
2092 for (irel = internal_relocs; irel < irelend; irel++)
2093 if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2094 && irel->r_addend & RL78_RELAXA_ALIGN)
2096 int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2098 if (section_alignment_glue < this_glue)
2099 section_alignment_glue = this_glue;
2101 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2103 section_alignment_glue *= 2;
2105 for (irel = internal_relocs; irel < irelend; irel++)
2107 unsigned char *insn;
2110 /* The insns we care about are all marked with one of these. */
2111 if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2114 if (irel->r_addend & RL78_RELAXA_ALIGN
2115 || next_alignment == internal_relocs)
2117 /* When we delete bytes, we need to maintain all the alignments
2118 indicated. In addition, we need to be careful about relaxing
2119 jumps across alignment boundaries - these displacements
2120 *grow* when we delete bytes. For now, don't shrink
2121 displacements across an alignment boundary, just in case.
2122 Note that this only affects relocations to the same
2124 next_alignment += 2;
2125 while (next_alignment < irelend
2126 && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2127 || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2129 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2130 next_alignment = NULL;
2133 /* When we hit alignment markers, see if we've shrunk enough
2134 before them to reduce the gap without violating the alignment
2136 if (irel->r_addend & RL78_RELAXA_ALIGN)
2138 /* At this point, the next relocation *should* be the ELIGN
2140 Elf_Internal_Rela *erel = irel + 1;
2141 unsigned int alignment, nbytes;
2143 if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2145 if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2148 alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2150 if (erel->r_offset - irel->r_offset < alignment)
2153 nbytes = erel->r_offset - irel->r_offset;
2154 nbytes /= alignment;
2155 nbytes *= alignment;
2157 elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2158 erel->r_offset == sec->size);
2164 if (irel->r_addend & RL78_RELAXA_ELIGN)
2167 insn = contents + irel->r_offset;
2169 nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2171 /* At this point, we have an insn that is a candidate for linker
2172 relaxation. There are NRELOCS relocs following that may be
2173 relaxed, although each reloc may be made of more than one
2174 reloc entry (such as gp-rel symbols). */
2176 /* Get the value of the symbol referred to by the reloc. Just
2177 in case this is the last reloc in the list, use the RL's
2178 addend to choose between this reloc (no addend) or the next
2179 (yes addend, which means at least one following reloc). */
2181 /* srel points to the "current" reloction for this insn -
2182 actually the last reloc for a given operand, which is the one
2183 we need to update. We check the relaxations in the same
2184 order that the relocations happen, so we'll just push it
2188 pc = sec->output_section->vma + sec->output_offset
2192 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2193 pcrel = symval - pc + srel->r_addend; \
2196 #define SNIPNR(offset, nbytes) \
2197 elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2198 #define SNIP(offset, nbytes, newtype) \
2199 SNIPNR (offset, nbytes); \
2200 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2202 /* The order of these bit tests must match the order that the
2203 relocs appear in. Since we sorted those by offset, we can
2206 /*----------------------------------------------------------------------*/
2207 /* EF ad BR $rel8 pcrel
2208 ED al ah BR !abs16 abs
2209 EE al ah BR $!rel16 pcrel
2210 EC al ah as BR !!abs20 abs
2212 FD al ah CALL !abs16 abs
2213 FE al ah CALL $!rel16 pcrel
2214 FC al ah as CALL !!abs20 abs
2222 61 C8 EF ad SKC ; BR $rel8
2223 61 D8 EF ad SKNC ; BR $rel8
2224 61 E8 EF ad SKZ ; BR $rel8
2225 61 F8 EF ad SKNZ ; BR $rel8
2226 61 E3 EF ad SKH ; BR $rel8
2227 61 F3 EF ad SKNH ; BR $rel8
2230 if (irel->r_addend & RL78_RELAXA_BRA)
2236 case 0xec: /* BR !!abs20 */
2243 SNIP (2, 2, R_RL78_DIR8S_PCREL);
2246 else if (symval < 65536)
2249 insn[1] = symval & 0xff;
2250 insn[2] = symval >> 8;
2251 SNIP (2, 1, R_RL78_DIR16S);
2254 else if (pcrel < 32767
2258 insn[1] = pcrel & 0xff;
2259 insn[2] = pcrel >> 8;
2260 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2265 case 0xee: /* BR $!pcrel16 */
2266 case 0xed: /* BR $!abs16 */
2272 SNIP (2, 1, R_RL78_DIR8S_PCREL);
2277 case 0xfc: /* CALL !!abs20 */
2281 insn[1] = symval & 0xff;
2282 insn[2] = symval >> 8;
2283 SNIP (2, 1, R_RL78_DIR16S);
2286 else if (pcrel < 32767
2290 insn[1] = pcrel & 0xff;
2291 insn[2] = pcrel >> 8;
2292 SNIP (2, 1, R_RL78_DIR16S_PCREL);
2297 case 0x61: /* PREFIX */
2298 /* For SKIP/BR, we change the BR opcode and delete the
2299 SKIP. That way, we don't have to find and change the
2300 relocation for the BR. */
2303 case 0xc8: /* SKC */
2304 if (insn[2] == 0xef)
2306 insn[2] = 0xde; /* BNC */
2311 case 0xd8: /* SKNC */
2312 if (insn[2] == 0xef)
2314 insn[2] = 0xdc; /* BC */
2319 case 0xe8: /* SKZ */
2320 if (insn[2] == 0xef)
2322 insn[2] = 0xdf; /* BNZ */
2327 case 0xf8: /* SKNZ */
2328 if (insn[2] == 0xef)
2330 insn[2] = 0xdd; /* BZ */
2335 case 0xe3: /* SKH */
2336 if (insn[2] == 0xef)
2338 insn[2] = 0xd3; /* BNH */
2339 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2343 case 0xf3: /* SKNH */
2344 if (insn[2] == 0xef)
2346 insn[2] = 0xc3; /* BH */
2347 SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2356 if (irel->r_addend & RL78_RELAXA_ADDR16)
2358 /*----------------------------------------------------------------------*/
2359 /* Some insns have both a 16-bit address operand and an 8-bit
2360 variant if the address is within a special range:
2362 Address 16-bit operand SADDR range SFR range
2363 FFF00-FFFFF 0xff00-0xffff 0x00-0xff
2364 FFE20-FFF1F 0xfe20-0xff1f 0x00-0xff
2366 The RELAX_ADDR16[] array has the insn encodings for the
2367 16-bit operand version, as well as the SFR and SADDR
2368 variants. We only need to replace the encodings and
2371 Note: we intentionally do not attempt to decode and skip
2372 any ES: prefix, as adding ES: means the addr16 (likely)
2373 no longer points to saddr/sfr space.
2383 if (0xffe20 <= symval && symval <= 0xfffff)
2386 is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2387 is_sfr = (0xfff00 <= symval && symval <= 0xfffff);
2389 for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2391 if (relax_addr16[idx].prefix != -1
2392 && insn[0] == relax_addr16[idx].prefix
2393 && insn[1] == relax_addr16[idx].insn)
2397 else if (relax_addr16[idx].prefix == -1
2398 && insn[0] == relax_addr16[idx].insn)
2405 /* We have a matched insn, and poff is 0 or 1 depending
2406 on the base pattern size. */
2408 if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2410 insn[poff] = relax_addr16[idx].insn_for_sfr;
2411 SNIP (poff+2, 1, R_RL78_RH_SFR);
2414 else if (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2416 insn[poff] = relax_addr16[idx].insn_for_saddr;
2417 SNIP (poff+2, 1, R_RL78_RH_SADDR);
2424 /*----------------------------------------------------------------------*/
2431 if (free_relocs != NULL)
2434 if (free_contents != NULL)
2435 free (free_contents);
2437 if (shndx_buf != NULL)
2439 shndx_hdr->contents = NULL;
2443 if (free_intsyms != NULL)
2444 free (free_intsyms);
2451 #define ELF_ARCH bfd_arch_rl78
2452 #define ELF_MACHINE_CODE EM_RL78
2453 #define ELF_MAXPAGESIZE 0x1000
2455 #define TARGET_LITTLE_SYM bfd_elf32_rl78_vec
2456 #define TARGET_LITTLE_NAME "elf32-rl78"
2458 #define elf_info_to_howto_rel NULL
2459 #define elf_info_to_howto rl78_info_to_howto_rela
2460 #define elf_backend_object_p rl78_elf_object_p
2461 #define elf_backend_relocate_section rl78_elf_relocate_section
2462 #define elf_symbol_leading_char ('_')
2463 #define elf_backend_can_gc_sections 1
2465 #define bfd_elf32_bfd_reloc_type_lookup rl78_reloc_type_lookup
2466 #define bfd_elf32_bfd_reloc_name_lookup rl78_reloc_name_lookup
2467 #define bfd_elf32_bfd_set_private_flags rl78_elf_set_private_flags
2468 #define bfd_elf32_bfd_merge_private_bfd_data rl78_elf_merge_private_bfd_data
2469 #define bfd_elf32_bfd_print_private_bfd_data rl78_elf_print_private_bfd_data
2471 #define bfd_elf32_bfd_relax_section rl78_elf_relax_section
2472 #define elf_backend_check_relocs rl78_elf_check_relocs
2473 #define elf_backend_always_size_sections \
2474 rl78_elf_always_size_sections
2475 #define elf_backend_finish_dynamic_sections \
2476 rl78_elf_finish_dynamic_sections
2478 #include "elf32-target.h"