1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005, 2006, 2007
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. */
26 #include "libiberty.h"
28 /* Forward declarations. */
29 static reloc_howto_type * m32c_reloc_type_lookup
30 (bfd *, bfd_reloc_code_real_type);
31 static void m32c_info_to_howto_rela
32 (bfd *, arelent *, Elf_Internal_Rela *);
33 static bfd_boolean m32c_elf_relocate_section
34 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
35 static bfd_boolean m32c_elf_check_relocs
36 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
37 static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
39 char * m32c_get_reloc (long reloc);
40 void dump_symtab (bfd *, void *, void *);
42 static bfd_boolean m32c_elf_relax_section
43 (bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again);
46 static reloc_howto_type m32c_elf_howto_table [] =
48 /* This reloc does nothing. */
49 HOWTO (R_M32C_NONE, /* type */
51 0, /* size (0 = byte, 1 = short, 2 = long) */
53 FALSE, /* pc_relative */
55 complain_overflow_bitfield, /* complain_on_overflow */
56 bfd_elf_generic_reloc, /* special_function */
57 "R_M32C_NONE", /* name */
58 FALSE, /* partial_inplace */
61 FALSE), /* pcrel_offset */
63 /* GCC intentionally overflows these next two in order to work
64 around limitations in the addressing modes, so don't complain
66 HOWTO (R_M32C_16, /* type */
68 1, /* size (0 = byte, 1 = short, 2 = long) */
70 FALSE, /* pc_relative */
72 complain_overflow_dont, /* complain_on_overflow */
73 bfd_elf_generic_reloc, /* special_function */
74 "R_M32C_16", /* name */
75 FALSE, /* partial_inplace */
77 0xffff, /* dst_mask */
78 FALSE), /* pcrel_offset */
80 HOWTO (R_M32C_24, /* type */
82 2, /* size (0 = byte, 1 = short, 2 = long) */
84 FALSE, /* pc_relative */
86 complain_overflow_dont, /* complain_on_overflow */
87 bfd_elf_generic_reloc, /* special_function */
88 "R_M32C_24", /* name */
89 FALSE, /* partial_inplace */
91 0xffffff, /* dst_mask */
92 FALSE), /* pcrel_offset */
94 HOWTO (R_M32C_32, /* type */
96 2, /* size (0 = byte, 1 = short, 2 = long) */
98 FALSE, /* pc_relative */
100 complain_overflow_bitfield, /* complain_on_overflow */
101 bfd_elf_generic_reloc, /* special_function */
102 "R_M32C_32", /* name */
103 FALSE, /* partial_inplace */
105 0xffffffff, /* dst_mask */
106 FALSE), /* pcrel_offset */
108 HOWTO (R_M32C_8_PCREL, /* type */
110 0, /* size (0 = byte, 1 = short, 2 = long) */
112 TRUE, /* pc_relative */
114 complain_overflow_signed, /* complain_on_overflow */
115 bfd_elf_generic_reloc, /* special_function */
116 "R_M32C_8_PCREL", /* name */
117 FALSE, /* partial_inplace */
120 TRUE), /* pcrel_offset */
122 HOWTO (R_M32C_16_PCREL, /* type */
124 1, /* size (0 = byte, 1 = short, 2 = long) */
126 TRUE, /* pc_relative */
128 complain_overflow_signed, /* complain_on_overflow */
129 bfd_elf_generic_reloc, /* special_function */
130 "R_M32C_16_PCREL", /* name */
131 FALSE, /* partial_inplace */
133 0xffff, /* dst_mask */
134 TRUE), /* pcrel_offset */
136 HOWTO (R_M32C_8, /* type */
138 0, /* size (0 = byte, 1 = short, 2 = long) */
140 FALSE, /* pc_relative */
142 complain_overflow_unsigned, /* complain_on_overflow */
143 bfd_elf_generic_reloc, /* special_function */
144 "R_M32C_8", /* name */
145 FALSE, /* partial_inplace */
148 FALSE), /* pcrel_offset */
150 HOWTO (R_M32C_LO16, /* type */
152 1, /* size (0 = byte, 1 = short, 2 = long) */
154 FALSE, /* pc_relative */
156 complain_overflow_dont, /* complain_on_overflow */
157 bfd_elf_generic_reloc, /* special_function */
158 "R_M32C_LO16", /* name */
159 FALSE, /* partial_inplace */
161 0xffff, /* dst_mask */
162 FALSE), /* pcrel_offset */
164 HOWTO (R_M32C_HI8, /* type */
166 0, /* size (0 = byte, 1 = short, 2 = long) */
168 FALSE, /* pc_relative */
170 complain_overflow_dont, /* complain_on_overflow */
171 bfd_elf_generic_reloc, /* special_function */
172 "R_M32C_HI8", /* name */
173 FALSE, /* partial_inplace */
176 FALSE), /* pcrel_offset */
178 HOWTO (R_M32C_HI16, /* type */
180 1, /* size (0 = byte, 1 = short, 2 = long) */
182 FALSE, /* pc_relative */
184 complain_overflow_dont, /* complain_on_overflow */
185 bfd_elf_generic_reloc, /* special_function */
186 "R_M32C_HI16", /* name */
187 FALSE, /* partial_inplace */
189 0xffff, /* dst_mask */
190 FALSE), /* pcrel_offset */
192 HOWTO (R_M32C_RL_JUMP, /* type */
194 0, /* size (0 = byte, 1 = short, 2 = long) */
196 FALSE, /* pc_relative */
198 complain_overflow_signed, /* complain_on_overflow */
199 bfd_elf_generic_reloc, /* special_function */
200 "R_M32C_RL_JUMP", /* name */
201 FALSE, /* partial_inplace */
204 FALSE), /* pcrel_offset */
206 HOWTO (R_M32C_RL_1ADDR, /* type */
208 0, /* size (0 = byte, 1 = short, 2 = long) */
210 FALSE, /* pc_relative */
212 complain_overflow_signed, /* complain_on_overflow */
213 bfd_elf_generic_reloc, /* special_function */
214 "R_M32C_RL_1ADDR", /* name */
215 FALSE, /* partial_inplace */
218 FALSE), /* pcrel_offset */
220 HOWTO (R_M32C_RL_2ADDR, /* type */
222 0, /* size (0 = byte, 1 = short, 2 = long) */
224 FALSE, /* pc_relative */
226 complain_overflow_signed, /* complain_on_overflow */
227 bfd_elf_generic_reloc, /* special_function */
228 "R_M32C_RL_2ADDR", /* name */
229 FALSE, /* partial_inplace */
232 FALSE), /* pcrel_offset */
236 /* Map BFD reloc types to M32C ELF reloc types. */
238 struct m32c_reloc_map
240 bfd_reloc_code_real_type bfd_reloc_val;
241 unsigned int m32c_reloc_val;
244 static const struct m32c_reloc_map m32c_reloc_map [] =
246 { BFD_RELOC_NONE, R_M32C_NONE },
247 { BFD_RELOC_16, R_M32C_16 },
248 { BFD_RELOC_24, R_M32C_24 },
249 { BFD_RELOC_32, R_M32C_32 },
250 { BFD_RELOC_8_PCREL, R_M32C_8_PCREL },
251 { BFD_RELOC_16_PCREL, R_M32C_16_PCREL },
252 { BFD_RELOC_8, R_M32C_8 },
253 { BFD_RELOC_LO16, R_M32C_LO16 },
254 { BFD_RELOC_HI16, R_M32C_HI16 },
255 { BFD_RELOC_M32C_HI8, R_M32C_HI8 },
256 { BFD_RELOC_M32C_RL_JUMP, R_M32C_RL_JUMP },
257 { BFD_RELOC_M32C_RL_1ADDR, R_M32C_RL_1ADDR },
258 { BFD_RELOC_M32C_RL_2ADDR, R_M32C_RL_2ADDR }
261 static reloc_howto_type *
262 m32c_reloc_type_lookup
263 (bfd * abfd ATTRIBUTE_UNUSED,
264 bfd_reloc_code_real_type code)
268 for (i = ARRAY_SIZE (m32c_reloc_map); --i;)
269 if (m32c_reloc_map [i].bfd_reloc_val == code)
270 return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
275 static reloc_howto_type *
276 m32c_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
281 i < sizeof (m32c_elf_howto_table) / sizeof (m32c_elf_howto_table[0]);
283 if (m32c_elf_howto_table[i].name != NULL
284 && strcasecmp (m32c_elf_howto_table[i].name, r_name) == 0)
285 return &m32c_elf_howto_table[i];
290 /* Set the howto pointer for an M32C ELF reloc. */
293 m32c_info_to_howto_rela
294 (bfd * abfd ATTRIBUTE_UNUSED,
296 Elf_Internal_Rela * dst)
300 r_type = ELF32_R_TYPE (dst->r_info);
301 BFD_ASSERT (r_type < (unsigned int) R_M32C_max);
302 cache_ptr->howto = & m32c_elf_howto_table [r_type];
307 /* Relocate an M32C ELF section.
308 There is some attempt to make this function usable for many architectures,
309 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
310 if only to serve as a learning tool.
312 The RELOCATE_SECTION function is called by the new ELF backend linker
313 to handle the relocations for a section.
315 The relocs are always passed as Rela structures; if the section
316 actually uses Rel structures, the r_addend field will always be
319 This function is responsible for adjusting the section contents as
320 necessary, and (if using Rela relocs and generating a relocatable
321 output file) adjusting the reloc addend as necessary.
323 This function does not have to worry about setting the reloc
324 address or the reloc symbol index.
326 LOCAL_SYMS is a pointer to the swapped in local symbols.
328 LOCAL_SECTIONS is an array giving the section in the input file
329 corresponding to the st_shndx field of each local symbol.
331 The global hash table entry for the global symbols can be found
332 via elf_sym_hashes (input_bfd).
334 When generating relocatable output, this function must handle
335 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
336 going to be the section symbol corresponding to the output
337 section, which means that the addend must be adjusted
341 m32c_elf_relocate_section
342 (bfd * output_bfd ATTRIBUTE_UNUSED,
343 struct bfd_link_info * info,
345 asection * input_section,
347 Elf_Internal_Rela * relocs,
348 Elf_Internal_Sym * local_syms,
349 asection ** local_sections)
351 Elf_Internal_Shdr * symtab_hdr;
352 struct elf_link_hash_entry ** sym_hashes;
353 Elf_Internal_Rela * rel;
354 Elf_Internal_Rela * relend;
358 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
359 sym_hashes = elf_sym_hashes (input_bfd);
360 relend = relocs + input_section->reloc_count;
362 dynobj = elf_hash_table (info)->dynobj;
365 splt = bfd_get_section_by_name (dynobj, ".plt");
367 for (rel = relocs; rel < relend; rel ++)
369 reloc_howto_type * howto;
370 unsigned long r_symndx;
371 Elf_Internal_Sym * sym;
373 struct elf_link_hash_entry * h;
375 bfd_reloc_status_type r;
376 const char * name = NULL;
379 r_type = ELF32_R_TYPE (rel->r_info);
381 /* These are only used for relaxing; we don't actually relocate
382 anything with them, so skip them. */
383 if (r_type == R_M32C_RL_JUMP
384 || r_type == R_M32C_RL_1ADDR
385 || r_type == R_M32C_RL_2ADDR)
388 r_symndx = ELF32_R_SYM (rel->r_info);
390 howto = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
396 if (r_symndx < symtab_hdr->sh_info)
398 sym = local_syms + r_symndx;
399 sec = local_sections [r_symndx];
400 relocation = (sec->output_section->vma
404 name = bfd_elf_string_from_elf_section
405 (input_bfd, symtab_hdr->sh_link, sym->st_name);
406 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
410 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
412 while (h->root.type == bfd_link_hash_indirect
413 || h->root.type == bfd_link_hash_warning)
414 h = (struct elf_link_hash_entry *) h->root.u.i.link;
416 name = h->root.root.string;
418 if (h->root.type == bfd_link_hash_defined
419 || h->root.type == bfd_link_hash_defweak)
421 sec = h->root.u.def.section;
422 relocation = (h->root.u.def.value
423 + sec->output_section->vma
424 + sec->output_offset);
426 else if (h->root.type == bfd_link_hash_undefweak)
428 else if (!info->relocatable)
430 if (! ((*info->callbacks->undefined_symbol)
431 (info, h->root.root.string, input_bfd,
432 input_section, rel->r_offset, TRUE)))
437 if (sec != NULL && elf_discarded_section (sec))
439 /* For relocs against symbols from removed linkonce sections,
440 or sections discarded by a linker script, we just want the
441 section contents zeroed. Avoid any special processing. */
442 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
448 if (info->relocatable)
450 /* This is a relocatable link. We don't have to change
451 anything, unless the reloc is against a section symbol,
452 in which case we have to adjust according to where the
453 section symbol winds up in the output section. */
454 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
455 rel->r_addend += sec->output_offset;
459 switch (ELF32_R_TYPE (rel->r_info))
466 plt_offset = &h->plt.offset;
468 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
470 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
471 relocation, *plt_offset);*/
472 if (relocation <= 0xffff)
474 /* If the symbol is in range for a 16-bit address, we should
475 have deallocated the plt entry in relax_section. */
476 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
480 /* If the symbol is out of range for a 16-bit address,
481 we must have allocated a plt entry. */
482 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
484 /* If this is the first time we've processed this symbol,
485 fill in the plt entry with the correct symbol address. */
486 if ((*plt_offset & 1) == 0)
490 x = 0x000000fc; /* jmpf */
491 x |= (relocation << 8) & 0xffffff00;
492 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
496 relocation = (splt->output_section->vma
497 + splt->output_offset
498 + (*plt_offset & -2));
501 char *newname = bfd_malloc (strlen(name)+5);
502 strcpy (newname, name);
503 strcat(newname, ".plt");
504 _bfd_generic_link_add_one_symbol (info,
507 BSF_FUNCTION | BSF_WEAK,
526 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
527 m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name,
528 rel->r_offset + input_section->output_section->vma + input_section->output_offset,
529 relocation, rel->r_addend);
533 printf (" %02x", contents[rel->r_offset+i]);
537 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
538 contents, rel->r_offset, relocation,
541 if (r != bfd_reloc_ok)
543 const char * msg = (const char *) NULL;
547 case bfd_reloc_overflow:
548 r = info->callbacks->reloc_overflow
549 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
550 input_bfd, input_section, rel->r_offset);
553 case bfd_reloc_undefined:
554 r = info->callbacks->undefined_symbol
555 (info, name, input_bfd, input_section, rel->r_offset,
559 case bfd_reloc_outofrange:
560 msg = _("internal error: out of range error");
563 case bfd_reloc_notsupported:
564 msg = _("internal error: unsupported relocation error");
567 case bfd_reloc_dangerous:
568 msg = _("internal error: dangerous relocation");
572 msg = _("internal error: unknown error");
577 r = info->callbacks->warning
578 (info, msg, name, input_bfd, input_section, rel->r_offset);
588 /* We support 16-bit pointers to code above 64k by generating a thunk
589 below 64k containing a JMP instruction to the final address. */
592 m32c_elf_check_relocs
594 struct bfd_link_info * info,
596 const Elf_Internal_Rela * relocs)
598 Elf_Internal_Shdr * symtab_hdr;
599 struct elf_link_hash_entry ** sym_hashes;
600 const Elf_Internal_Rela * rel;
601 const Elf_Internal_Rela * rel_end;
602 bfd_vma *local_plt_offsets;
606 if (info->relocatable)
609 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
610 sym_hashes = elf_sym_hashes (abfd);
611 local_plt_offsets = elf_local_got_offsets (abfd);
613 dynobj = elf_hash_table(info)->dynobj;
615 rel_end = relocs + sec->reloc_count;
616 for (rel = relocs; rel < rel_end; rel++)
618 struct elf_link_hash_entry *h;
619 unsigned long r_symndx;
622 r_symndx = ELF32_R_SYM (rel->r_info);
623 if (r_symndx < symtab_hdr->sh_info)
627 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
628 while (h->root.type == bfd_link_hash_indirect
629 || h->root.type == bfd_link_hash_warning)
630 h = (struct elf_link_hash_entry *) h->root.u.i.link;
633 switch (ELF32_R_TYPE (rel->r_info))
635 /* This relocation describes a 16-bit pointer to a function.
636 We may need to allocate a thunk in low memory; reserve memory
640 elf_hash_table (info)->dynobj = dynobj = abfd;
643 splt = bfd_get_section_by_name (dynobj, ".plt");
646 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
647 | SEC_IN_MEMORY | SEC_LINKER_CREATED
648 | SEC_READONLY | SEC_CODE);
649 splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
651 || ! bfd_set_section_alignment (dynobj, splt, 1))
657 offset = &h->plt.offset;
660 if (local_plt_offsets == NULL)
665 size = symtab_hdr->sh_info * sizeof (bfd_vma);
666 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
667 if (local_plt_offsets == NULL)
669 elf_local_got_offsets (abfd) = local_plt_offsets;
671 for (i = 0; i < symtab_hdr->sh_info; i++)
672 local_plt_offsets[i] = (bfd_vma) -1;
674 offset = &local_plt_offsets[r_symndx];
677 if (*offset == (bfd_vma) -1)
679 *offset = splt->size;
689 /* This must exist if dynobj is ever set. */
692 m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
693 struct bfd_link_info *info)
698 /* As an extra sanity check, verify that all plt entries have
701 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
702 && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
704 bfd_byte *contents = splt->contents;
705 unsigned int i, size = splt->size;
706 for (i = 0; i < size; i += 4)
708 unsigned int x = bfd_get_32 (dynobj, contents + i);
717 m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
718 struct bfd_link_info *info)
723 if (info->relocatable)
726 dynobj = elf_hash_table (info)->dynobj;
730 splt = bfd_get_section_by_name (dynobj, ".plt");
731 BFD_ASSERT (splt != NULL);
733 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
734 if (splt->contents == NULL)
740 /* Function to set the ELF flag bits. */
743 m32c_elf_set_private_flags (bfd *abfd, flagword flags)
745 elf_elfheader (abfd)->e_flags = flags;
746 elf_flags_init (abfd) = TRUE;
750 /* Merge backend specific data from an object file to the output
751 object file when linking. */
754 m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
756 flagword old_flags, old_partial;
757 flagword new_flags, new_partial;
758 bfd_boolean error = FALSE;
762 new_opt[0] = old_opt[0] = '\0';
763 new_flags = elf_elfheader (ibfd)->e_flags;
764 old_flags = elf_elfheader (obfd)->e_flags;
767 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
768 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
769 bfd_get_filename (ibfd));
772 if (!elf_flags_init (obfd))
774 /* First call, no flags set. */
775 elf_flags_init (obfd) = TRUE;
776 elf_elfheader (obfd)->e_flags = new_flags;
779 else if (new_flags == old_flags)
780 /* Compatible flags are ok. */
783 else /* Possibly incompatible flags. */
785 /* Warn if different cpu is used (allow a specific cpu to override
787 new_partial = (new_flags & EF_M32C_CPU_MASK);
788 old_partial = (old_flags & EF_M32C_CPU_MASK);
789 if (new_partial == old_partial)
796 default: strcat (new_opt, " -m16c"); break;
797 case EF_M32C_CPU_M16C: strcat (new_opt, " -m16c"); break;
798 case EF_M32C_CPU_M32C: strcat (new_opt, " -m32c"); break;
803 default: strcat (old_opt, " -m16c"); break;
804 case EF_M32C_CPU_M16C: strcat (old_opt, " -m16c"); break;
805 case EF_M32C_CPU_M32C: strcat (old_opt, " -m32c"); break;
809 /* Print out any mismatches from above. */
813 (*_bfd_error_handler)
814 (_("%s: compiled with %s and linked with modules compiled with %s"),
815 bfd_get_filename (ibfd), new_opt, old_opt);
818 new_flags &= ~ EF_M32C_ALL_FLAGS;
819 old_flags &= ~ EF_M32C_ALL_FLAGS;
821 /* Warn about any other mismatches. */
822 if (new_flags != old_flags)
825 (*_bfd_error_handler)
826 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
827 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
832 bfd_set_error (bfd_error_bad_value);
839 m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
841 FILE *file = (FILE *) ptr;
844 BFD_ASSERT (abfd != NULL && ptr != NULL);
846 /* Print normal ELF private data. */
847 _bfd_elf_print_private_bfd_data (abfd, ptr);
849 flags = elf_elfheader (abfd)->e_flags;
850 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
852 switch (flags & EF_M32C_CPU_MASK)
855 case EF_M32C_CPU_M16C: fprintf (file, " -m16c"); break;
856 case EF_M32C_CPU_M32C: fprintf (file, " -m32c"); break;
863 /* Return the MACH for an e_flags value. */
866 elf32_m32c_machine (bfd *abfd)
868 switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
870 case EF_M32C_CPU_M16C: return bfd_mach_m16c;
871 case EF_M32C_CPU_M32C: return bfd_mach_m32c;
874 return bfd_mach_m16c;
878 m32c_elf_object_p (bfd *abfd)
880 bfd_default_set_arch_mach (abfd, bfd_arch_m32c,
881 elf32_m32c_machine (abfd));
888 dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
891 Elf_Internal_Sym *isymbuf;
892 Elf_Internal_Sym *isymend;
893 Elf_Internal_Sym *isym;
894 Elf_Internal_Shdr *symtab_hdr;
895 bfd_boolean free_internal = 0, free_external = 0;
897 char * st_info_stb_str;
903 internal_syms = bfd_malloc (1000);
908 external_syms = bfd_malloc (1000);
912 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
913 locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
915 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
916 symtab_hdr->sh_info, 0,
917 internal_syms, external_syms, NULL);
919 isymbuf = internal_syms;
920 isymend = isymbuf + locsymcount;
922 for (isym = isymbuf ; isym < isymend ; isym++)
924 switch (ELF_ST_TYPE (isym->st_info))
926 case STT_FUNC: st_info_str = "STT_FUNC";
927 case STT_SECTION: st_info_str = "STT_SECTION";
928 case STT_FILE: st_info_str = "STT_FILE";
929 case STT_OBJECT: st_info_str = "STT_OBJECT";
930 case STT_TLS: st_info_str = "STT_TLS";
931 default: st_info_str = "";
933 switch (ELF_ST_BIND (isym->st_info))
935 case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
936 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
937 default: st_info_stb_str = "";
939 switch (ELF_ST_VISIBILITY (isym->st_other))
941 case STV_DEFAULT: st_other_str = "STV_DEFAULT";
942 case STV_INTERNAL: st_other_str = "STV_INTERNAL";
943 case STV_PROTECTED: st_other_str = "STV_PROTECTED";
944 default: st_other_str = "";
946 switch (isym->st_shndx)
948 case SHN_ABS: st_shndx_str = "SHN_ABS";
949 case SHN_COMMON: st_shndx_str = "SHN_COMMON";
950 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
951 default: st_shndx_str = "";
954 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
955 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
957 (unsigned long) isym->st_value,
958 (unsigned long) isym->st_size,
960 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
962 isym->st_info, st_info_str, st_info_stb_str,
963 isym->st_other, st_other_str,
964 isym->st_shndx, st_shndx_str);
967 free (internal_syms);
969 free (external_syms);
973 m32c_get_reloc (long reloc)
975 if (0 <= reloc && reloc < R_M32C_max)
976 return m32c_elf_howto_table[reloc].name;
982 /* Handle relaxing. */
984 /* A subroutine of m32c_elf_relax_section. If the global symbol H
985 is within the low 64k, remove any entry for it in the plt. */
987 struct relax_plt_data
994 m32c_relax_plt_check (struct elf_link_hash_entry *h,
997 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
999 if (h->root.type == bfd_link_hash_warning)
1000 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1002 if (h->plt.offset != (bfd_vma) -1)
1006 if (h->root.type == bfd_link_hash_undefined
1007 || h->root.type == bfd_link_hash_undefweak)
1010 address = (h->root.u.def.section->output_section->vma
1011 + h->root.u.def.section->output_offset
1012 + h->root.u.def.value);
1014 if (address <= 0xffff)
1017 data->splt->size -= 4;
1018 *data->again = TRUE;
1025 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1026 previously had a plt entry, give it a new entry offset. */
1029 m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
1032 bfd_vma *entry = (bfd_vma *) xdata;
1034 if (h->root.type == bfd_link_hash_warning)
1035 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1037 if (h->plt.offset != (bfd_vma) -1)
1039 h->plt.offset = *entry;
1047 m32c_elf_relax_plt_section (bfd *dynobj,
1049 struct bfd_link_info *info,
1052 struct relax_plt_data relax_plt_data;
1055 /* Assume nothing changes. */
1058 if (info->relocatable)
1061 /* We only relax the .plt section at the moment. */
1062 if (dynobj != elf_hash_table (info)->dynobj
1063 || strcmp (splt->name, ".plt") != 0)
1066 /* Quick check for an empty plt. */
1067 if (splt->size == 0)
1070 /* Map across all global symbols; see which ones happen to
1071 fall in the low 64k. */
1072 relax_plt_data.splt = splt;
1073 relax_plt_data.again = again;
1074 elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check,
1077 /* Likewise for local symbols, though that's somewhat less convenient
1078 as we have to walk the list of input bfds and swap in symbol data. */
1079 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1081 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1082 Elf_Internal_Shdr *symtab_hdr;
1083 Elf_Internal_Sym *isymbuf = NULL;
1086 if (! local_plt_offsets)
1089 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1090 if (symtab_hdr->sh_info != 0)
1092 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1093 if (isymbuf == NULL)
1094 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1095 symtab_hdr->sh_info, 0,
1097 if (isymbuf == NULL)
1101 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1103 Elf_Internal_Sym *isym;
1107 if (local_plt_offsets[idx] == (bfd_vma) -1)
1110 isym = &isymbuf[idx];
1111 if (isym->st_shndx == SHN_UNDEF)
1113 else if (isym->st_shndx == SHN_ABS)
1114 tsec = bfd_abs_section_ptr;
1115 else if (isym->st_shndx == SHN_COMMON)
1116 tsec = bfd_com_section_ptr;
1118 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1120 address = (tsec->output_section->vma
1121 + tsec->output_offset
1123 if (address <= 0xffff)
1125 local_plt_offsets[idx] = -1;
1132 && symtab_hdr->contents != (unsigned char *) isymbuf)
1134 if (! info->keep_memory)
1138 /* Cache the symbols for elf_link_input_bfd. */
1139 symtab_hdr->contents = (unsigned char *) isymbuf;
1144 /* If we changed anything, walk the symbols again to reallocate
1145 .plt entry addresses. */
1146 if (*again && splt->size > 0)
1150 elf_link_hash_traverse (elf_hash_table (info),
1151 m32c_relax_plt_realloc, &entry);
1153 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1155 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1156 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1159 if (! local_plt_offsets)
1162 for (idx = 0; idx < nlocals; ++idx)
1163 if (local_plt_offsets[idx] != (bfd_vma) -1)
1165 local_plt_offsets[idx] = entry;
1175 compare_reloc (const void *e1, const void *e2)
1177 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
1178 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
1180 if (i1->r_offset == i2->r_offset)
1183 return i1->r_offset < i2->r_offset ? -1 : 1;
1186 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1188 m32c_offset_for_reloc (bfd *abfd,
1189 Elf_Internal_Rela *rel,
1190 Elf_Internal_Shdr *symtab_hdr,
1191 Elf_External_Sym_Shndx *shndx_buf,
1192 Elf_Internal_Sym *intsyms)
1196 /* Get the value of the symbol referred to by the reloc. */
1197 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1199 /* A local symbol. */
1200 Elf_Internal_Sym *isym;
1201 Elf_External_Sym_Shndx *shndx;
1205 isym = intsyms + ELF32_R_SYM (rel->r_info);
1206 ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1207 shndx = shndx_buf + (shndx_buf ? ELF32_R_SYM (rel->r_info) : 0);
1209 symval = isym->st_value;
1211 symval += ssec->output_section->vma
1212 + ssec->output_offset;
1217 struct elf_link_hash_entry *h;
1219 /* An external symbol. */
1220 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1221 h = elf_sym_hashes (abfd)[indx];
1222 BFD_ASSERT (h != NULL);
1224 if (h->root.type != bfd_link_hash_defined
1225 && h->root.type != bfd_link_hash_defweak)
1226 /* This appears to be a reference to an undefined
1227 symbol. Just ignore it--it will be caught by the
1228 regular reloc processing. */
1231 symval = (h->root.u.def.value
1232 + h->root.u.def.section->output_section->vma
1233 + h->root.u.def.section->output_offset);
1238 static int bytes_saved = 0;
1240 static int bytes_to_reloc[] = {
1248 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1250 /* Mask for the number of relocs associated with this insn. */
1251 #define RLA_RELOCS 0x0000000f
1252 /* Number of bytes gas emitted (before gas's relaxing) */
1253 #define RLA_NBYTES 0x00000ff0
1255 /* If the displacement is within the given range and the new encoding
1256 differs from the old encoding (the index), then the insn can be
1257 relaxed to the new encoding. */
1260 unsigned int max_disp;
1261 unsigned char new_encoding;
1264 static EncodingTable m16c_addr_encodings[] = {
1265 { 0, 0, 0 }, /* R0 */
1266 { 0, 0, 1 }, /* R1 */
1267 { 0, 0, 2 }, /* R2 */
1268 { 0, 0, 3 }, /* R3 */
1269 { 0, 0, 4 }, /* A0 */
1270 { 0, 0, 5 }, /* A1 */
1271 { 0, 0, 6 }, /* [A0] */
1272 { 0, 0, 7 }, /* [A1] */
1273 { 1, 0, 6 }, /* udsp:8[A0] */
1274 { 1, 0, 7 }, /* udsp:8[A1] */
1275 { 1, 0, 10 }, /* udsp:8[SB] */
1276 { 1, 0, 11 }, /* sdsp:8[FB] */
1277 { 2, 255, 8 }, /* udsp:16[A0] */
1278 { 2, 255, 9 }, /* udsp:16[A1] */
1279 { 2, 255, 10 }, /* udsp:16[SB] */
1280 { 2, 0, 15 }, /* abs:16 */
1283 static EncodingTable m16c_jmpaddr_encodings[] = {
1284 { 0, 0, 0 }, /* R0 */
1285 { 0, 0, 1 }, /* R1 */
1286 { 0, 0, 2 }, /* R2 */
1287 { 0, 0, 3 }, /* R3 */
1288 { 0, 0, 4 }, /* A0 */
1289 { 0, 0, 5 }, /* A1 */
1290 { 0, 0, 6 }, /* [A0] */
1291 { 0, 0, 7 }, /* [A1] */
1292 { 1, 0, 6 }, /* udsp:8[A0] */
1293 { 1, 0, 7 }, /* udsp:8[A1] */
1294 { 1, 0, 10 }, /* udsp:8[SB] */
1295 { 1, 0, 11 }, /* sdsp:8[FB] */
1296 { 3, 255, 8 }, /* udsp:20[A0] */
1297 { 3, 255, 9 }, /* udsp:20[A1] */
1298 { 2, 255, 10 }, /* udsp:16[SB] */
1299 { 2, 0, 15 }, /* abs:16 */
1302 static EncodingTable m32c_addr_encodings[] = {
1303 { 0, 0, 0 }, /* [A0] */
1304 { 0, 0, 1 }, /* [A1] */
1305 { 0, 0, 2 }, /* A0 */
1306 { 0, 0, 3 }, /* A1 */
1307 { 1, 0, 0 }, /* udsp:8[A0] */
1308 { 1, 0, 1 }, /* udsp:8[A1] */
1309 { 1, 0, 6 }, /* udsp:8[SB] */
1310 { 1, 0, 7 }, /* sdsp:8[FB] */
1311 { 2, 255, 4 }, /* udsp:16[A0] */
1312 { 2, 255, 5 }, /* udsp:16[A1] */
1313 { 2, 255, 6 }, /* udsp:16[SB] */
1314 { 2, 127, 7 }, /* sdsp:16[FB] */
1315 { 3, 65535, 8 }, /* udsp:24[A0] */
1316 { 3, 65535, 9 }, /* udsp:24[A1] */
1317 { 3, 65535, 15 }, /* abs24 */
1318 { 2, 0, 15 }, /* abs16 */
1319 { 0, 0, 16 }, /* R2 */
1320 { 0, 0, 17 }, /* R3 */
1321 { 0, 0, 18 }, /* R0 */
1322 { 0, 0, 19 }, /* R1 */
1338 m32c_elf_relax_section
1341 struct bfd_link_info * link_info,
1342 bfd_boolean * again)
1344 Elf_Internal_Shdr *symtab_hdr;
1345 Elf_Internal_Shdr *shndx_hdr;
1346 Elf_Internal_Rela *internal_relocs;
1347 Elf_Internal_Rela *free_relocs = NULL;
1348 Elf_Internal_Rela *irel, *irelend, *srel;
1349 bfd_byte * contents = NULL;
1350 bfd_byte * free_contents = NULL;
1351 Elf_Internal_Sym *intsyms = NULL;
1352 Elf_Internal_Sym *free_intsyms = NULL;
1353 Elf_External_Sym_Shndx *shndx_buf = NULL;
1356 if (abfd == elf_hash_table (link_info)->dynobj
1357 && strcmp (sec->name, ".plt") == 0)
1358 return m32c_elf_relax_plt_section (abfd, sec, link_info, again);
1360 /* Assume nothing changes. */
1363 machine = elf32_m32c_machine (abfd);
1365 /* We don't have to do anything for a relocatable link, if
1366 this section does not have relocs, or if this is not a
1368 if (link_info->relocatable
1369 || (sec->flags & SEC_RELOC) == 0
1370 || sec->reloc_count == 0
1371 || (sec->flags & SEC_CODE) == 0)
1374 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1375 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1377 /* Get the section contents. */
1378 if (elf_section_data (sec)->this_hdr.contents != NULL)
1379 contents = elf_section_data (sec)->this_hdr.contents;
1380 /* Go get them off disk. */
1381 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1384 /* Read this BFD's symbols. */
1385 /* Get cached copy if it exists. */
1386 if (symtab_hdr->contents != NULL)
1388 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1392 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1393 symtab_hdr->contents = (bfd_byte *) intsyms;
1396 if (shndx_hdr->sh_size != 0)
1400 amt = symtab_hdr->sh_info;
1401 amt *= sizeof (Elf_External_Sym_Shndx);
1402 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1403 if (shndx_buf == NULL)
1405 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1406 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1408 shndx_hdr->contents = (bfd_byte *) shndx_buf;
1411 /* Get a copy of the native relocations. */
1412 internal_relocs = (_bfd_elf_link_read_relocs
1413 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1414 link_info->keep_memory));
1415 if (internal_relocs == NULL)
1417 if (! link_info->keep_memory)
1418 free_relocs = internal_relocs;
1420 /* The RL_ relocs must be just before the operand relocs they go
1421 with, so we must sort them to guarantee this. */
1422 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
1425 /* Walk through them looking for relaxing opportunities. */
1426 irelend = internal_relocs + sec->reloc_count;
1428 for (irel = internal_relocs; irel < irelend; irel++)
1431 unsigned char *insn, *gap, *einsn;
1433 bfd_signed_vma pcrel;
1439 EncodingTable *enctbl;
1442 if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
1443 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
1444 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
1449 /* There will always be room for the relaxed insn, since it is smaller
1450 than the one it would replace. */
1451 BFD_ASSERT (irel->r_offset < sec->size);
1453 insn = contents + irel->r_offset;
1454 relax_relocs = irel->r_addend % 16;
1456 /* Ok, we only have three relocs we care about, and they're all
1457 fake. The lower four bits of the addend is always the number
1458 of following relocs (hence the qsort above) that are assigned
1459 to this opcode. The next 8 bits of the addend indicates the
1460 number of bytes in the insn. We use the rest of them
1461 ourselves as flags for the more expensive operations (defines
1462 above). The three relocs are:
1464 RL_JUMP: This marks all direct jump insns. We check the
1465 displacement and replace them with shorter jumps if
1466 they're in range. We also use this to find JMP.S
1467 insns and manually shorten them when we delete bytes.
1468 We have to decode these insns to figure out what to
1471 RL_1ADDR: This is a :G or :Q insn, which has a single
1472 "standard" operand. We have to extract the type
1473 field, see if it's a wide displacement, then figure
1474 out if we can replace it with a narrow displacement.
1475 We don't have to decode these insns.
1477 RL_2ADDR: Similarly, but two "standard" operands. Note that
1478 r_addend may still be 1, as standard operands don't
1479 always have displacements. Gas shouldn't give us one
1480 with zero operands, but since we don't know which one
1481 has the displacement, we check them both anyway.
1483 These all point to the beginning of the insn itself, not the
1486 Note that we only relax one step at a time, relying on the
1487 linker to call us repeatedly. Thus, there is no code for
1488 JMP.A->JMP.B although that will happen in two steps.
1489 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1492 /* Get the value of the symbol referred to by the reloc. Just
1493 in case this is the last reloc in the list, use the RL's
1494 addend to choose between this reloc (no addend) or the next
1495 (yes addend, which means at least one following reloc). */
1496 srel = irel + (relax_relocs ? 1 : 0);
1497 symval = OFFSET_FOR_RELOC (srel);
1499 /* Setting gap_size nonzero is the flag which means "something
1503 new_type = ELF32_R_TYPE(srel->r_info);
1505 pc = sec->output_section->vma + sec->output_offset
1507 pcrel = symval - pc + srel->r_addend;
1509 if (machine == bfd_mach_m16c)
1513 switch (ELF32_R_TYPE(irel->r_info))
1516 case R_M32C_RL_JUMP:
1519 case 0xfe: /* jmp.b */
1520 if (pcrel >= 2 && pcrel <= 9)
1522 /* Relax JMP.B -> JMP.S. We need to get rid of
1523 the following reloc though. */
1524 insn[0] = 0x60 | (pcrel - 2);
1525 new_type = R_M32C_NONE;
1526 irel->r_addend = 0x10;
1532 case 0xf4: /* jmp.w */
1533 /* 128 is allowed because it will be one byte closer
1534 after relaxing. Likewise for all other pc-rel
1536 if (pcrel <= 128 && pcrel >= -128)
1538 /* Relax JMP.W -> JMP.B */
1541 new_type = R_M32C_8_PCREL;
1547 case 0xfc: /* jmp.a */
1548 if (pcrel <= 32768 && pcrel >= -32768)
1550 /* Relax JMP.A -> JMP.W */
1554 new_type = R_M32C_16_PCREL;
1560 case 0xfd: /* jsr.a */
1561 if (pcrel <= 32768 && pcrel >= -32768)
1563 /* Relax JSR.A -> JSR.W */
1567 new_type = R_M32C_16_PCREL;
1575 case R_M32C_RL_2ADDR:
1576 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1578 enctbl = m16c_addr_encodings;
1580 enc = (insn[1] >> 4) & 0x0f;
1583 if (srel->r_offset == irel->r_offset + posn
1584 && e->new_encoding != enc
1585 && symval <= e->max_disp)
1588 insn[1] |= e->new_encoding << 4;
1589 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1590 gap = insn + posn + enctbl[e->new_encoding].bytes;
1591 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1594 if (relax_relocs == 2)
1600 case R_M32C_RL_1ADDR:
1601 /* xxxx xxxx xxxx dest [disp] */
1603 enctbl = m16c_addr_encodings;
1606 /* Check the opcode for jumps. We know it's safe to
1607 do this because all 2ADDR insns are at least two
1609 enc = insn[0] * 256 + insn[1];
1616 enctbl = m16c_jmpaddr_encodings;
1620 /* srel, posn, and enc must be set here. */
1622 symval = OFFSET_FOR_RELOC (srel);
1623 enc = insn[1] & 0x0f;
1626 if (srel->r_offset == irel->r_offset + posn
1627 && e->new_encoding != enc
1628 && symval <= e->max_disp)
1631 insn[1] |= e->new_encoding;
1632 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1633 gap = insn + posn + enctbl[e->new_encoding].bytes;
1634 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1640 } /* Ends switch (reloc type) for m16c. */
1642 else /* machine == bfd_mach_m32c */
1646 switch (ELF32_R_TYPE(irel->r_info))
1649 case R_M32C_RL_JUMP:
1652 case 0xbb: /* jmp.b */
1653 if (pcrel >= 2 && pcrel <= 9)
1656 /* Relax JMP.B -> JMP.S. We need to get rid of
1657 the following reloc though. */
1658 insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
1659 new_type = R_M32C_NONE;
1660 irel->r_addend = 0x10;
1666 case 0xce: /* jmp.w */
1667 if (pcrel <= 128 && pcrel >= -128)
1669 /* Relax JMP.W -> JMP.B */
1672 new_type = R_M32C_8_PCREL;
1678 case 0xcc: /* jmp.a */
1679 if (pcrel <= 32768 && pcrel >= -32768)
1681 /* Relax JMP.A -> JMP.W */
1685 new_type = R_M32C_16_PCREL;
1691 case 0xcd: /* jsr.a */
1692 if (pcrel <= 32768 && pcrel >= -32768)
1694 /* Relax JSR.A -> JSR.W */
1698 new_type = R_M32C_16_PCREL;
1706 case R_M32C_RL_2ADDR:
1707 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1713 /* prefix; remove it as far as the RL reloc is concerned. */
1718 enctbl = m32c_addr_encodings;
1719 enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
1722 if (srel->r_offset == irel->r_offset + posn
1723 && e->new_encoding != enc
1724 && symval <= e->max_disp)
1727 einsn[0] |= (e->new_encoding & 0x1c) << 2;
1729 einsn[1] |= (e->new_encoding & 0x03) << 4;
1730 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1731 gap = insn + posn + enctbl[e->new_encoding].bytes;
1732 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1735 if (relax_relocs == 2)
1741 case R_M32C_RL_1ADDR:
1742 /* xxxx DDDx DDxx xxxx [disp] */
1748 /* prefix; remove it as far as the RL reloc is concerned. */
1753 enctbl = m32c_addr_encodings;
1756 /* srel, posn, and enc must be set here. */
1758 symval = OFFSET_FOR_RELOC (srel);
1759 enc = ((einsn[0] & 0x0e) << 1) | ((einsn[1] & 0xc0) >> 6);
1762 if (srel->r_offset == irel->r_offset + posn
1763 && e->new_encoding != enc
1764 && symval <= e->max_disp)
1767 einsn[0] |= (e->new_encoding & 0x1c) >> 1;
1769 einsn[1] |= (e->new_encoding & 0x03) << 6;
1770 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1771 gap = insn + posn + enctbl[e->new_encoding].bytes;
1772 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1778 } /* Ends switch (reloc type) for m32c. */
1786 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
1788 /* Note that we've changed the relocs, section contents, etc. */
1789 elf_section_data (sec)->relocs = internal_relocs;
1792 elf_section_data (sec)->this_hdr.contents = contents;
1793 free_contents = NULL;
1795 symtab_hdr->contents = (bfd_byte *) intsyms;
1796 free_intsyms = NULL;
1798 bytes_saved += gap_size;
1800 if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
1803 } /* next relocation */
1805 if (free_relocs != NULL)
1811 if (free_contents != NULL)
1813 if (! link_info->keep_memory)
1814 free (free_contents);
1815 /* Cache the section contents for elf_link_input_bfd. */
1817 elf_section_data (sec)->this_hdr.contents = contents;
1819 free_contents = NULL;
1822 if (shndx_buf != NULL)
1824 shndx_hdr->contents = NULL;
1828 if (free_intsyms != NULL)
1830 if (! link_info->keep_memory)
1831 free (free_intsyms);
1832 /* Cache the symbols for elf_link_input_bfd. */
1835 symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
1838 free_intsyms = NULL;
1844 if (free_relocs != NULL)
1846 if (free_contents != NULL)
1847 free (free_contents);
1848 if (shndx_buf != NULL)
1850 shndx_hdr->contents = NULL;
1853 if (free_intsyms != NULL)
1854 free (free_intsyms);
1858 /* Delete some bytes from a section while relaxing. */
1861 m32c_elf_relax_delete_bytes
1867 Elf_Internal_Shdr *symtab_hdr;
1868 Elf_Internal_Shdr *shndx_hdr;
1871 Elf_Internal_Rela *irel;
1872 Elf_Internal_Rela *irelend;
1873 Elf_Internal_Rela *irelalign;
1875 Elf_Internal_Sym *isym;
1876 Elf_Internal_Sym *isymend;
1877 Elf_Internal_Sym *intsyms;
1878 Elf_External_Sym_Shndx *shndx_buf;
1879 Elf_External_Sym_Shndx *shndx;
1880 struct elf_link_hash_entry ** sym_hashes;
1881 struct elf_link_hash_entry ** end_hashes;
1882 unsigned int symcount;
1884 contents = elf_section_data (sec)->this_hdr.contents;
1886 /* The deletion must stop at the next ALIGN reloc for an aligment
1887 power larger than the number of bytes we are deleting. */
1891 irel = elf_section_data (sec)->relocs;
1892 irelend = irel + sec->reloc_count;
1894 /* Actually delete the bytes. */
1895 memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count));
1898 /* Adjust all the relocs. */
1899 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++)
1901 /* Get the new reloc address. */
1902 if (irel->r_offset > addr && irel->r_offset < toaddr)
1903 irel->r_offset -= count;
1905 if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
1906 && irel->r_addend == 0x10 /* one byte insn, no relocs */
1907 && irel->r_offset + 1 < addr
1908 && irel->r_offset + 7 > addr)
1911 unsigned char *insn = &contents[irel->r_offset];
1913 /* This is a JMP.S, which we have to manually update. */
1914 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1916 if ((*insn & 0xf8) != 0x60)
1922 if ((*insn & 0xce) != 0x4a)
1924 disp = ((disp & 0x30) >> 3) | (disp & 1);
1926 if (irel->r_offset + disp + 2 >= addr+count)
1929 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1931 *insn = (*insn & 0xf8) | disp;
1935 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
1941 /* Adjust the local symbols defined in this section. */
1942 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1943 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1945 isymend = isym + symtab_hdr->sh_info;
1947 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1948 shndx_hdr = & elf_tdata (abfd)->symtab_shndx_hdr;
1949 shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
1952 for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
1955 if ((int) isym->st_shndx == sec_shndx
1956 && isym->st_value > addr
1957 && isym->st_value < toaddr)
1959 isym->st_value -= count;
1963 /* Now adjust the global symbols defined in this section. */
1964 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1965 - symtab_hdr->sh_info);
1966 sym_hashes = elf_sym_hashes (abfd);
1967 // sym_hashes += symtab_hdr->sh_info;
1968 end_hashes = sym_hashes + symcount;
1970 for (; sym_hashes < end_hashes; sym_hashes ++)
1972 struct elf_link_hash_entry * sym_hash = * sym_hashes;
1975 ( sym_hash->root.type == bfd_link_hash_defined
1976 || sym_hash->root.type == bfd_link_hash_defweak)
1977 && sym_hash->root.u.def.section == sec
1978 && sym_hash->root.u.def.value > addr
1979 && sym_hash->root.u.def.value < toaddr)
1981 sym_hash->root.u.def.value -= count;
1989 #define ELF_ARCH bfd_arch_m32c
1990 #define ELF_MACHINE_CODE EM_M32C
1991 #define ELF_MAXPAGESIZE 0x1000
1994 #define TARGET_BIG_SYM bfd_elf32_m32c_vec
1995 #define TARGET_BIG_NAME "elf32-m32c"
1997 #define TARGET_LITTLE_SYM bfd_elf32_m32c_vec
1998 #define TARGET_LITTLE_NAME "elf32-m32c"
2001 #define elf_info_to_howto_rel NULL
2002 #define elf_info_to_howto m32c_info_to_howto_rela
2003 #define elf_backend_object_p m32c_elf_object_p
2004 #define elf_backend_relocate_section m32c_elf_relocate_section
2005 #define elf_backend_check_relocs m32c_elf_check_relocs
2006 #define elf_backend_object_p m32c_elf_object_p
2007 #define elf_symbol_leading_char ('_')
2008 #define elf_backend_always_size_sections \
2009 m32c_elf_always_size_sections
2010 #define elf_backend_finish_dynamic_sections \
2011 m32c_elf_finish_dynamic_sections
2013 #define elf_backend_can_gc_sections 1
2015 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2016 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2017 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2018 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2019 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2020 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2022 #include "elf32-target.h"