1 /* Generic support for 32-bit ELF
2 Copyright 1993, 1995, 1998, 1999, 2001 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 static reloc_howto_type *elf32_h8_reloc_type_lookup
27 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
28 static void elf32_h8_info_to_howto
29 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
30 static void elf32_h8_info_to_howto_rel
31 PARAMS ((bfd *, arelent *, Elf32_Internal_Rel *));
32 static unsigned long elf32_h8_mach
34 static void elf32_h8_final_write_processing
35 PARAMS ((bfd *, boolean));
36 static boolean elf32_h8_object_p
38 static boolean elf32_h8_merge_private_bfd_data
39 PARAMS ((bfd *, bfd *));
40 static boolean elf32_h8_relax_section
41 PARAMS ((bfd *, asection *, struct bfd_link_info *, boolean *));
42 static boolean elf32_h8_relax_delete_bytes
43 PARAMS ((bfd *, asection *, bfd_vma, int));
44 static boolean elf32_h8_symbol_address_p
45 PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
46 static bfd_byte *elf32_h8_get_relocated_section_contents
47 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *,
48 bfd_byte *, boolean, asymbol **));
49 static bfd_reloc_status_type elf32_h8_final_link_relocate
50 PARAMS ((unsigned long, bfd *, bfd *, asection *,
51 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
52 struct bfd_link_info *, asection *, int));
53 static boolean elf32_h8_relocate_section
54 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
55 bfd_byte *, Elf_Internal_Rela *,
56 Elf_Internal_Sym *, asection **));
57 static bfd_reloc_status_type special
58 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
60 /* This does not include any relocation information, but should be
61 good enough for GDB or objdump to read the file. */
63 static reloc_howto_type h8_elf_howto_table[] =
66 HOWTO (R_H8_NONE, /* type */
68 0, /* size (0 = byte, 1 = short, 2 = long) */
70 false, /* pc_relative */
72 complain_overflow_dont, /* complain_on_overflow */
73 special, /* special_function */
74 "R_H8_NONE", /* name */
75 false, /* partial_inplace */
78 false), /* pcrel_offset */
79 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
80 HOWTO (R_H8_DIR32, /* type */
82 2, /* size (0 = byte, 1 = short, 2 = long) */
84 false, /* pc_relative */
86 complain_overflow_dont, /* complain_on_overflow */
87 special, /* special_function */
88 "R_H8_DIR32", /* name */
89 false, /* partial_inplace */
91 0xffffffff, /* dst_mask */
92 false), /* pcrel_offset */
93 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
94 HOWTO (R_H8_DIR16, /* type */
96 1, /* size (0 = byte, 1 = short, 2 = long) */
98 false, /* pc_relative */
100 complain_overflow_dont, /* complain_on_overflow */
101 special, /* special_function */
102 "R_H8_DIR16", /* name */
103 false, /* partial_inplace */
105 0x0000ffff, /* dst_mask */
106 false), /* pcrel_offset */
107 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
108 HOWTO (R_H8_DIR8, /* type */
110 0, /* size (0 = byte, 1 = short, 2 = long) */
112 false, /* pc_relative */
114 complain_overflow_dont, /* complain_on_overflow */
115 special, /* special_function */
116 "R_H8_DIR16", /* name */
117 false, /* partial_inplace */
119 0x000000ff, /* dst_mask */
120 false), /* pcrel_offset */
121 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
122 HOWTO (R_H8_DIR16A8, /* type */
124 1, /* size (0 = byte, 1 = short, 2 = long) */
126 false, /* pc_relative */
128 complain_overflow_bitfield, /* complain_on_overflow */
129 special, /* special_function */
130 "R_H8_DIR16A8", /* name */
131 false, /* partial_inplace */
133 0x0000ffff, /* dst_mask */
134 false), /* pcrel_offset */
135 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
136 HOWTO (R_H8_DIR16R8, /* type */
138 1, /* size (0 = byte, 1 = short, 2 = long) */
140 false, /* pc_relative */
142 complain_overflow_bitfield, /* complain_on_overflow */
143 special, /* special_function */
144 "R_H8_DIR16R8", /* name */
145 false, /* partial_inplace */
147 0x0000ffff, /* dst_mask */
148 false), /* pcrel_offset */
149 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
150 HOWTO (R_H8_DIR24A8, /* type */
152 2, /* size (0 = byte, 1 = short, 2 = long) */
154 false, /* pc_relative */
156 complain_overflow_bitfield, /* complain_on_overflow */
157 special, /* special_function */
158 "R_H8_DIR24A8", /* name */
159 true, /* partial_inplace */
160 0xff000000, /* src_mask */
161 0x00ffffff, /* dst_mask */
162 false), /* pcrel_offset */
163 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
164 HOWTO (R_H8_DIR24R8, /* type */
166 2, /* size (0 = byte, 1 = short, 2 = long) */
168 false, /* pc_relative */
170 complain_overflow_bitfield, /* complain_on_overflow */
171 special, /* special_function */
172 "R_H8_DIR24R8", /* name */
173 true, /* partial_inplace */
174 0xff000000, /* src_mask */
175 0x00ffffff, /* dst_mask */
176 false), /* pcrel_offset */
177 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
178 HOWTO (R_H8_DIR32A16, /* type */
180 2, /* size (0 = byte, 1 = short, 2 = long) */
182 false, /* pc_relative */
184 complain_overflow_dont, /* complain_on_overflow */
185 special, /* special_function */
186 "R_H8_DIR32", /* name */
187 false, /* partial_inplace */
189 0xffffffff, /* dst_mask */
190 false), /* pcrel_offset */
191 #define R_H8_PCREL16_X (R_H8_DIR32A16_X + 1)
192 HOWTO (R_H8_PCREL16, /* type */
194 1, /* size (0 = byte, 1 = short, 2 = long) */
196 true, /* pc_relative */
198 complain_overflow_signed, /* complain_on_overflow */
199 special, /* special_function */
200 "R_H8_PCREL16", /* name */
201 false, /* partial_inplace */
202 0xffff, /* src_mask */
203 0xffff, /* dst_mask */
204 true), /* pcrel_offset */
205 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
206 HOWTO (R_H8_PCREL8, /* type */
208 0, /* size (0 = byte, 1 = short, 2 = long) */
210 true, /* pc_relative */
212 complain_overflow_signed, /* complain_on_overflow */
213 special, /* special_function */
214 "R_H8_PCREL8", /* name */
215 false, /* partial_inplace */
218 true), /* pcrel_offset */
221 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
225 bfd_reloc_code_real_type bfd_reloc_val;
226 unsigned char howto_index;
229 /* An array mapping BFD reloc codes to SH ELF relocs. */
231 static const struct elf_reloc_map h8_reloc_map[] =
233 { BFD_RELOC_NONE, R_H8_NONE_X },
234 { BFD_RELOC_32, R_H8_DIR32_X },
235 { BFD_RELOC_16, R_H8_DIR16_X },
236 { BFD_RELOC_8, R_H8_DIR8_X },
237 { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
238 { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
239 { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
240 { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
241 { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
242 { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
243 { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
247 static reloc_howto_type *
248 elf32_h8_reloc_type_lookup (abfd, code)
249 bfd *abfd ATTRIBUTE_UNUSED;
250 bfd_reloc_code_real_type code;
254 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
256 if (h8_reloc_map[i].bfd_reloc_val == code)
257 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
263 elf32_h8_info_to_howto (abfd, bfd_reloc, elf_reloc)
264 bfd *abfd ATTRIBUTE_UNUSED;
266 Elf32_Internal_Rela *elf_reloc;
271 r = ELF32_R_TYPE (elf_reloc->r_info);
272 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
273 if (h8_elf_howto_table[i].type== r)
275 bfd_reloc->howto = &h8_elf_howto_table[i];
282 elf32_h8_info_to_howto_rel (abfd, bfd_reloc, elf_reloc)
283 bfd *abfd ATTRIBUTE_UNUSED;
285 Elf32_Internal_Rel *elf_reloc ATTRIBUTE_UNUSED;
290 r = ELF32_R_TYPE (elf_reloc->r_info);
291 bfd_reloc->howto = &h8_elf_howto_table[r];
294 /* Special handling for H8/300 relocs.
295 We only come here for pcrel stuff and return normally if not an -r link.
296 When doing -r, we can't do any arithmetic for the pcrel stuff, because
297 we support relaxing on the H8/300 series chips. */
298 static bfd_reloc_status_type
299 special (abfd, reloc_entry, symbol, data, input_section, output_bfd,
301 bfd *abfd ATTRIBUTE_UNUSED;
302 arelent *reloc_entry ATTRIBUTE_UNUSED;
303 asymbol *symbol ATTRIBUTE_UNUSED;
304 PTR data ATTRIBUTE_UNUSED;
305 asection *input_section ATTRIBUTE_UNUSED;
307 char **error_message ATTRIBUTE_UNUSED;
309 if (output_bfd == (bfd *) NULL)
310 return bfd_reloc_continue;
312 /* Adjust the reloc address to that in the output section. */
313 reloc_entry->address += input_section->output_offset;
317 /* Perform a relocation as part of a final link. */
318 static bfd_reloc_status_type
319 elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
320 input_section, contents, offset, value,
321 addend, info, sym_sec, is_local)
322 unsigned long r_type;
324 bfd *output_bfd ATTRIBUTE_UNUSED;
325 asection *input_section ATTRIBUTE_UNUSED;
330 struct bfd_link_info *info ATTRIBUTE_UNUSED;
331 asection *sym_sec ATTRIBUTE_UNUSED;
332 int is_local ATTRIBUTE_UNUSED;
334 bfd_byte *hit_data = contents + offset;
346 bfd_put_32 (input_bfd, value, hit_data);
353 bfd_put_16 (input_bfd, value, hit_data);
360 bfd_put_8 (input_bfd, value, hit_data);
366 /* HIT_DATA is the address for the first byte for the relocated
367 value. Subtract 1 so that we can manipulate the data in 32bit
371 /* Clear out the top byte in value. */
374 /* Retrieve the type byte for value from the section contents. */
375 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
377 /* Now scribble it out in one 32bit hunk. */
378 bfd_put_32 (input_bfd, value, hit_data);
382 value -= (input_section->output_section->vma
383 + input_section->output_offset);
387 /* The value is relative to the start of the instruction,
388 not the relocation offset. Subtract 2 to account for
392 bfd_put_16 (input_bfd, value, hit_data);
396 value -= (input_section->output_section->vma
397 + input_section->output_offset);
401 /* The value is relative to the start of the instruction,
402 not the relocation offset. Subtract 1 to account for
406 bfd_put_8 (input_bfd, value, hit_data);
410 return bfd_reloc_notsupported;
414 /* Relocate an H8 ELF section. */
416 elf32_h8_relocate_section (output_bfd, info, input_bfd, input_section,
417 contents, relocs, local_syms, local_sections)
419 struct bfd_link_info *info;
421 asection *input_section;
423 Elf_Internal_Rela *relocs;
424 Elf_Internal_Sym *local_syms;
425 asection **local_sections;
427 Elf_Internal_Shdr *symtab_hdr;
428 struct elf_link_hash_entry **sym_hashes;
429 Elf_Internal_Rela *rel, *relend;
431 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
432 sym_hashes = elf_sym_hashes (input_bfd);
435 relend = relocs + input_section->reloc_count;
436 for (; rel < relend; rel++)
439 unsigned long r_symndx;
440 Elf_Internal_Sym *sym;
442 struct elf_link_hash_entry *h;
444 bfd_reloc_status_type r;
446 r_symndx = ELF32_R_SYM (rel->r_info);
447 r_type = ELF32_R_TYPE (rel->r_info);
449 if (info->relocateable)
451 /* This is a relocateable link. We don't have to change
452 anything, unless the reloc is against a section symbol,
453 in which case we have to adjust according to where the
454 section symbol winds up in the output section. */
455 if (r_symndx < symtab_hdr->sh_info)
457 sym = local_syms + r_symndx;
458 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
460 sec = local_sections[r_symndx];
461 rel->r_addend += sec->output_offset + sym->st_value;
468 /* This is a final link. */
472 if (r_symndx < symtab_hdr->sh_info)
474 sym = local_syms + r_symndx;
475 sec = local_sections[r_symndx];
476 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
480 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
481 while (h->root.type == bfd_link_hash_indirect
482 || h->root.type == bfd_link_hash_warning)
483 h = (struct elf_link_hash_entry *) h->root.u.i.link;
484 if (h->root.type == bfd_link_hash_defined
485 || h->root.type == bfd_link_hash_defweak)
487 sec = h->root.u.def.section;
488 relocation = (h->root.u.def.value
489 + sec->output_section->vma
490 + sec->output_offset);
492 else if (h->root.type == bfd_link_hash_undefweak)
496 if (! ((*info->callbacks->undefined_symbol)
497 (info, h->root.root.string, input_bfd,
498 input_section, rel->r_offset, true)))
504 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
506 contents, rel->r_offset,
507 relocation, rel->r_addend,
508 info, sec, h == NULL);
510 if (r != bfd_reloc_ok)
513 const char *msg = (const char *) 0;
515 reloc_howto_type *howto;
517 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
518 howto = bfd_reloc.howto;
521 name = h->root.root.string;
524 name = (bfd_elf_string_from_elf_section
525 (input_bfd, symtab_hdr->sh_link, sym->st_name));
526 if (name == NULL || *name == '\0')
527 name = bfd_section_name (input_bfd, sec);
532 case bfd_reloc_overflow:
533 if (! ((*info->callbacks->reloc_overflow)
534 (info, name, howto->name, (bfd_vma) 0,
535 input_bfd, input_section, rel->r_offset)))
539 case bfd_reloc_undefined:
540 if (! ((*info->callbacks->undefined_symbol)
541 (info, name, input_bfd, input_section,
542 rel->r_offset, true)))
546 case bfd_reloc_outofrange:
547 msg = _("internal error: out of range error");
550 case bfd_reloc_notsupported:
551 msg = _("internal error: unsupported relocation error");
554 case bfd_reloc_dangerous:
555 msg = _("internal error: dangerous error");
559 msg = _("internal error: unknown error");
563 if (!((*info->callbacks->warning)
564 (info, msg, name, input_bfd, input_section,
575 /* Object files encode the specific H8 model they were compiled
576 for in the ELF flags field.
578 Examine that field and return the proper BFD machine type for
581 elf32_h8_mach (flags)
584 switch (flags & EF_H8_MACH)
586 case E_H8_MACH_H8300:
588 return bfd_mach_h8300;
590 case E_H8_MACH_H8300H:
591 return bfd_mach_h8300h;
593 case E_H8_MACH_H8300S:
594 return bfd_mach_h8300s;
598 /* The final processing done just before writing out a H8 ELF object
599 file. We use this opportunity to encode the BFD machine type
600 into the flags field in the object file. */
603 elf32_h8_final_write_processing (abfd, linker)
605 boolean linker ATTRIBUTE_UNUSED;
609 switch (bfd_get_mach (abfd))
613 val = E_H8_MACH_H8300;
616 case bfd_mach_h8300h:
617 val = E_H8_MACH_H8300H;
620 case bfd_mach_h8300s:
621 val = E_H8_MACH_H8300S;
625 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
626 elf_elfheader (abfd)->e_flags |= val;
629 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
630 record the encoded machine type found in the ELF flags. */
633 elf32_h8_object_p (abfd)
636 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
637 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
641 /* Merge backend specific data from an object file to the output
642 object file when linking. The only data we need to copy at this
643 time is the architecture/machine information. */
646 elf32_h8_merge_private_bfd_data (ibfd, obfd)
650 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
651 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
654 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
655 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
657 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
658 bfd_get_mach (ibfd)))
665 /* This function handles relaxing for the H8..
667 There's a few relaxing opportunites available on the H8:
669 jmp/jsr:24 -> bra/bsr:8 2 bytes
670 The jmp may be completely eliminated if the previous insn is a
671 conditional branch to the insn after the jump. In that case
672 we invert the branch and delete the jump and save 4 bytes.
674 bCC:16 -> bCC:8 2 bytes
675 bsr:16 -> bsr:8 2 bytes
677 mov.b:16 -> mov.b:8 2 bytes
678 mov.b:24/32 -> mov.b:8 4 bytes
680 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes
686 elf32_h8_relax_section (abfd, sec, link_info, again)
689 struct bfd_link_info *link_info;
692 Elf_Internal_Shdr *symtab_hdr;
693 Elf_Internal_Rela *internal_relocs;
694 Elf_Internal_Rela *free_relocs = NULL;
695 Elf_Internal_Rela *irel, *irelend;
696 bfd_byte *contents = NULL;
697 bfd_byte *free_contents = NULL;
698 Elf32_External_Sym *extsyms = NULL;
699 Elf32_External_Sym *free_extsyms = NULL;
700 static asection *last_input_section = NULL;
701 static Elf_Internal_Rela *last_reloc = NULL;
703 /* Assume nothing changes. */
706 /* We don't have to do anything for a relocateable link, if
707 this section does not have relocs, or if this is not a
709 if (link_info->relocateable
710 || (sec->flags & SEC_RELOC) == 0
711 || sec->reloc_count == 0
712 || (sec->flags & SEC_CODE) == 0)
715 /* If this is the first time we have been called for this section,
716 initialize the cooked size. */
717 if (sec->_cooked_size == 0)
718 sec->_cooked_size = sec->_raw_size;
720 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
722 /* Get a copy of the native relocations. */
723 internal_relocs = (_bfd_elf32_link_read_relocs
724 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
725 link_info->keep_memory));
726 if (internal_relocs == NULL)
728 if (! link_info->keep_memory)
729 free_relocs = internal_relocs;
731 if (sec != last_input_section)
734 last_input_section = sec;
736 /* Walk through the relocs looking for relaxing opportunities. */
737 irelend = internal_relocs + sec->reloc_count;
738 for (irel = internal_relocs; irel < irelend; irel++)
742 /* Keep track of the previous reloc so that we can delete
743 some long jumps created by the compiler. */
744 if (irel != internal_relocs)
745 last_reloc = irel - 1;
747 /* Get the section contents if we haven't done so already. */
748 if (contents == NULL)
750 /* Get cached copy if it exists. */
751 if (elf_section_data (sec)->this_hdr.contents != NULL)
752 contents = elf_section_data (sec)->this_hdr.contents;
755 /* Go get them off disk. */
756 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
757 if (contents == NULL)
759 free_contents = contents;
761 if (! bfd_get_section_contents (abfd, sec, contents,
762 (file_ptr) 0, sec->_raw_size))
767 /* Read this BFD's symbols if we haven't done so already. */
770 /* Get cached copy if it exists. */
771 if (symtab_hdr->contents != NULL)
772 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
775 /* Go get them off disk. */
776 extsyms = ((Elf32_External_Sym *)
777 bfd_malloc (symtab_hdr->sh_size));
780 free_extsyms = extsyms;
781 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
782 || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
783 != symtab_hdr->sh_size))
788 /* Get the value of the symbol referred to by the reloc. */
789 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
791 Elf_Internal_Sym isym;
794 /* A local symbol. */
795 bfd_elf32_swap_symbol_in (abfd,
796 extsyms + ELF32_R_SYM (irel->r_info),
799 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
800 symval = (isym.st_value
801 + sym_sec->output_section->vma
802 + sym_sec->output_offset);
807 struct elf_link_hash_entry *h;
809 /* An external symbol. */
810 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
811 h = elf_sym_hashes (abfd)[indx];
812 BFD_ASSERT (h != NULL);
813 if (h->root.type != bfd_link_hash_defined
814 && h->root.type != bfd_link_hash_defweak)
816 /* This appears to be a reference to an undefined
817 symbol. Just ignore it--it will be caught by the
818 regular reloc processing. */
822 symval = (h->root.u.def.value
823 + h->root.u.def.section->output_section->vma
824 + h->root.u.def.section->output_offset);
827 /* For simplicity of coding, we are going to modify the section
828 contents, the section relocs, and the BFD symbol table. We
829 must tell the rest of the code not to free up this
830 information. It would be possible to instead create a table
831 of changes which have to be made, as is done in coff-mips.c;
832 that would be more work, but would require less memory when
833 the linker is run. */
834 switch (ELF32_R_TYPE (irel->r_info))
836 /* Try to turn a 24 bit absolute branch/call into an 8 bit
837 pc-relative branch/call. */
840 bfd_vma value = symval + irel->r_addend;
843 /* Get the address of this instruction. */
844 dot = (sec->output_section->vma
845 + sec->output_offset + irel->r_offset - 1);
847 /* Compute the distance from this insn to the branch target. */
850 /* If the distance is within -126..+130 inclusive, then we can
851 relax this jump. +130 is valid since the target will move
852 two bytes closer if we do relax this branch. */
853 if ((int) gap >= -126 && (int) gap <= 130)
857 /* Note that we've changed the relocs, section contents,
859 elf_section_data (sec)->relocs = internal_relocs;
862 elf_section_data (sec)->this_hdr.contents = contents;
863 free_contents = NULL;
865 symtab_hdr->contents = (bfd_byte *) extsyms;
868 /* If the previous instruction conditionally jumped around
869 this instruction, we may be able to reverse the condition
870 and redirect the previous instruction to the target of
873 Such sequences are used by the compiler to deal with
874 long conditional branches. */
878 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
879 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
882 asection *last_sym_sec;
883 Elf_Internal_Sym last_symbol;
885 /* We will need to examine the symbol used by the
886 previous relocation. */
888 bfd_elf32_swap_symbol_in (abfd,
889 (extsyms + ELF32_R_SYM (last_reloc->r_info)),
893 = bfd_section_from_elf_index (abfd, last_symbol.st_shndx);
894 last_value = (last_symbol.st_value
895 + last_sym_sec->output_section->vma
896 + last_sym_sec->output_offset);
898 /* Verify that the previous relocation was for a
899 branch around this instruction and that no symbol
900 exists at the current location. */
901 if (last_value == dot + 4
902 && last_reloc->r_offset + 2 == irel->r_offset
903 && ! elf32_h8_symbol_address_p (abfd, sec,
906 /* We can eliminate this jump. Twiddle the
907 previous relocation as necessary. */
909 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
910 ELF32_R_TYPE (R_H8_NONE));
913 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
914 ELF32_R_TYPE (R_H8_PCREL8));
915 last_reloc->r_addend = irel->r_addend;
918 code = bfd_get_8 (abfd,
919 contents + last_reloc->r_offset - 1);
923 contents + last_reloc->r_offset - 1);
925 /* Delete four bytes of data. */
926 if (!elf32_h8_relax_delete_bytes (abfd, sec,
936 /* We could not eliminate this jump, so just shorten it. */
937 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
940 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
941 else if (code == 0x5a)
942 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
946 /* Fix the relocation's type. */
947 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
950 /* Delete two bytes of data. */
951 if (!elf32_h8_relax_delete_bytes (abfd, sec,
952 irel->r_offset + 1, 2))
955 /* That will change things, so, we should relax again.
956 Note that this is not required, and it may be slow. */
962 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
966 bfd_vma value = symval + irel->r_addend;
970 /* Get the address of this instruction. */
971 dot = (sec->output_section->vma
973 + irel->r_offset - 2);
977 /* If the distance is within -126..+130 inclusive, then we can
978 relax this jump. +130 is valid since the target will move
979 two bytes closer if we do relax this branch. */
980 if ((int)gap >= -126 && (int)gap <= 130)
984 /* Note that we've changed the relocs, section contents,
986 elf_section_data (sec)->relocs = internal_relocs;
989 elf_section_data (sec)->this_hdr.contents = contents;
990 free_contents = NULL;
992 symtab_hdr->contents = (bfd_byte *) extsyms;
995 /* Get the opcode. */
996 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1000 /* bCC:16 -> bCC:8 */
1001 /* Get the condition code from the original insn. */
1002 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1006 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1008 else if (code == 0x5c)
1009 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
1013 /* Fix the relocation's type. */
1014 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1018 /* Delete two bytes of data. */
1019 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1020 irel->r_offset + 1, 2))
1023 /* That will change things, so, we should relax again.
1024 Note that this is not required, and it may be slow. */
1030 /* This is a 16 bit absolute address in a "mov.b" insn, which may
1031 become an 8 bit absolute address if its in the right range. */
1034 bfd_vma value = symval + irel->r_addend;
1036 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1039 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1040 || bfd_get_mach (abfd) == bfd_mach_h8300s)
1041 && value >= 0xffff00
1042 && value <= 0xffffff))
1046 /* Note that we've changed the relocs, section contents,
1048 elf_section_data (sec)->relocs = internal_relocs;
1051 elf_section_data (sec)->this_hdr.contents = contents;
1052 free_contents = NULL;
1054 symtab_hdr->contents = (bfd_byte *) extsyms;
1055 free_extsyms = NULL;
1057 /* Get the opcode. */
1058 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1064 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1066 if ((code & 0xf0) == 0x00)
1068 (code & 0xf) | 0x20,
1069 contents + irel->r_offset - 2);
1070 else if ((code & 0xf0) == 0x80)
1072 (code & 0xf) | 0x30,
1073 contents + irel->r_offset - 2);
1077 /* Fix the relocation's type. */
1078 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1081 /* Delete two bytes of data. */
1082 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1083 irel->r_offset + 1, 2))
1086 /* That will change things, so, we should relax again.
1087 Note that this is not required, and it may be slow. */
1093 /* This is a 24 bit absolute address in a "mov.b" insn, which may
1094 become an 8 bit absolute address if its in the right range. */
1097 bfd_vma value = symval + irel->r_addend;
1099 if ((bfd_get_mach (abfd) == bfd_mach_h8300
1102 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1103 || bfd_get_mach (abfd) == bfd_mach_h8300s)
1104 && value >= 0xffff00
1105 && value <= 0xffffff))
1109 /* Note that we've changed the relocs, section contents,
1111 elf_section_data (sec)->relocs = internal_relocs;
1114 elf_section_data (sec)->this_hdr.contents = contents;
1115 free_contents = NULL;
1117 symtab_hdr->contents = (bfd_byte *) extsyms;
1118 free_extsyms = NULL;
1120 /* Get the opcode. */
1121 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1127 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1129 if ((code & 0xf0) == 0x00)
1131 (code & 0xf) | 0x20,
1132 contents + irel->r_offset - 2);
1133 else if ((code & 0xf0) == 0x80)
1135 (code & 0xf) | 0x30,
1136 contents + irel->r_offset - 2);
1140 /* Fix the relocation's type. */
1141 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1144 /* Delete two bytes of data. */
1145 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
1148 /* That will change things, so, we should relax again.
1149 Note that this is not required, and it may be slow. */
1156 /* This is a 24/32bit absolute address in a "mov" insn, which may
1157 become a 16bit absoulte address if it is in the right range. */
1160 bfd_vma value = symval + irel->r_addend;
1162 if (value <= 0x7fff || value >= 0xff8000)
1166 /* Note that we've changed the relocs, section contents,
1168 elf_section_data (sec)->relocs = internal_relocs;
1171 elf_section_data (sec)->this_hdr.contents = contents;
1172 free_contents = NULL;
1174 symtab_hdr->contents = (bfd_byte *) extsyms;
1175 free_extsyms = NULL;
1177 /* Get the opcode. */
1178 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1180 /* We just need to turn off bit 0x20. */
1183 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1185 /* Fix the relocation's type. */
1186 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1189 /* Delete two bytes of data. */
1190 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1191 irel->r_offset + 1, 2))
1194 /* That will change things, so, we should relax again.
1195 Note that this is not required, and it may be slow. */
1206 if (free_relocs != NULL)
1212 if (free_contents != NULL)
1214 if (! link_info->keep_memory)
1215 free (free_contents);
1218 /* Cache the section contents for elf_link_input_bfd. */
1219 elf_section_data (sec)->this_hdr.contents = contents;
1221 free_contents = NULL;
1224 if (free_extsyms != NULL)
1226 if (! link_info->keep_memory)
1227 free (free_extsyms);
1230 /* Cache the symbols for elf_link_input_bfd. */
1231 symtab_hdr->contents = (unsigned char *) extsyms;
1233 free_extsyms = NULL;
1239 if (free_relocs != NULL)
1241 if (free_contents != NULL)
1242 free (free_contents);
1243 if (free_extsyms != NULL)
1244 free (free_extsyms);
1248 /* Delete some bytes from a section while relaxing. */
1251 elf32_h8_relax_delete_bytes (abfd, sec, addr, count)
1257 Elf_Internal_Shdr *symtab_hdr;
1258 Elf32_External_Sym *extsyms;
1261 Elf_Internal_Rela *irel, *irelend;
1262 Elf_Internal_Rela *irelalign;
1264 Elf32_External_Sym *esym, *esymend;
1265 struct elf_link_hash_entry *sym_hash;
1267 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1268 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1270 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1272 contents = elf_section_data (sec)->this_hdr.contents;
1274 /* The deletion must stop at the next ALIGN reloc for an aligment
1275 power larger than the number of bytes we are deleting. */
1278 toaddr = sec->_cooked_size;
1280 irel = elf_section_data (sec)->relocs;
1281 irelend = irel + sec->reloc_count;
1283 /* Actually delete the bytes. */
1284 memmove (contents + addr, contents + addr + count,
1285 (size_t) (toaddr - addr - count));
1286 sec->_cooked_size -= count;
1288 /* Adjust all the relocs. */
1289 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1291 /* Get the new reloc address. */
1292 if ((irel->r_offset > addr
1293 && irel->r_offset < toaddr))
1294 irel->r_offset -= count;
1297 /* Adjust the local symbols defined in this section. */
1299 esymend = esym + symtab_hdr->sh_info;
1300 for (; esym < esymend; esym++)
1302 Elf_Internal_Sym isym;
1304 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1306 if (isym.st_shndx == shndx
1307 && isym.st_value > addr
1308 && isym.st_value < toaddr)
1310 isym.st_value -= count;
1311 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1315 /* Now adjust the global symbols defined in this section. */
1316 esym = extsyms + symtab_hdr->sh_info;
1317 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1318 for (index = 0; esym < esymend; esym++, index++)
1320 Elf_Internal_Sym isym;
1322 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1323 sym_hash = elf_sym_hashes (abfd)[index];
1324 if (isym.st_shndx == shndx
1325 && ((sym_hash)->root.type == bfd_link_hash_defined
1326 || (sym_hash)->root.type == bfd_link_hash_defweak)
1327 && (sym_hash)->root.u.def.section == sec
1328 && (sym_hash)->root.u.def.value > addr
1329 && (sym_hash)->root.u.def.value < toaddr)
1331 (sym_hash)->root.u.def.value -= count;
1338 /* Return true if a symbol exists at the given address, else return
1341 elf32_h8_symbol_address_p (abfd, sec, extsyms, addr)
1344 Elf32_External_Sym *extsyms;
1347 Elf_Internal_Shdr *symtab_hdr;
1349 Elf32_External_Sym *esym, *esymend;
1350 struct elf_link_hash_entry **sym_hash, **sym_hash_end;
1352 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1353 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1355 /* Examine all the symbols. */
1357 esymend = esym + symtab_hdr->sh_info;
1358 for (; esym < esymend; esym++)
1360 Elf_Internal_Sym isym;
1362 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1364 if (isym.st_shndx == shndx
1365 && isym.st_value == addr)
1369 sym_hash = elf_sym_hashes (abfd);
1370 sym_hash_end = (sym_hash
1371 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1372 - symtab_hdr->sh_info));
1373 for (; sym_hash < sym_hash_end; sym_hash++)
1375 if (((*sym_hash)->root.type == bfd_link_hash_defined
1376 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1377 && (*sym_hash)->root.u.def.section == sec
1378 && (*sym_hash)->root.u.def.value == addr)
1384 /* This is a version of bfd_generic_get_relocated_section_contents
1385 which uses elf32_h8_relocate_section. */
1388 elf32_h8_get_relocated_section_contents (output_bfd, link_info, link_order,
1389 data, relocateable, symbols)
1391 struct bfd_link_info *link_info;
1392 struct bfd_link_order *link_order;
1394 boolean relocateable;
1397 Elf_Internal_Shdr *symtab_hdr;
1398 asection *input_section = link_order->u.indirect.section;
1399 bfd *input_bfd = input_section->owner;
1400 asection **sections = NULL;
1401 Elf_Internal_Rela *internal_relocs = NULL;
1402 Elf32_External_Sym *external_syms = NULL;
1403 Elf_Internal_Sym *internal_syms = NULL;
1405 /* We only need to handle the case of relaxing, or of having a
1406 particular set of section contents, specially. */
1408 || elf_section_data (input_section)->this_hdr.contents == NULL)
1409 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1414 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1416 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1417 (size_t) input_section->_raw_size);
1419 if ((input_section->flags & SEC_RELOC) != 0
1420 && input_section->reloc_count > 0)
1422 Elf_Internal_Sym *isymp;
1424 Elf32_External_Sym *esym, *esymend;
1426 if (symtab_hdr->contents != NULL)
1427 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1432 amt = symtab_hdr->sh_info;
1433 amt *= sizeof (Elf32_External_Sym);
1434 external_syms = (Elf32_External_Sym *) bfd_malloc (amt);
1435 if (external_syms == NULL && symtab_hdr->sh_info > 0)
1437 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1438 || bfd_bread (external_syms, amt, input_bfd) != amt)
1442 internal_relocs = (_bfd_elf32_link_read_relocs
1443 (input_bfd, input_section, (PTR) NULL,
1444 (Elf_Internal_Rela *) NULL, false));
1445 if (internal_relocs == NULL)
1448 internal_syms = ((Elf_Internal_Sym *)
1449 bfd_malloc ((bfd_size_type) symtab_hdr->sh_info
1450 * sizeof (Elf_Internal_Sym)));
1451 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1454 sections = (asection **) bfd_malloc ((bfd_size_type) symtab_hdr->sh_info
1455 * sizeof (asection *));
1456 if (sections == NULL && symtab_hdr->sh_info > 0)
1459 isymp = internal_syms;
1461 esym = external_syms;
1462 esymend = esym + symtab_hdr->sh_info;
1463 for (; esym < esymend; ++esym, ++isymp, ++secpp)
1467 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1469 if (isymp->st_shndx == SHN_UNDEF)
1470 isec = bfd_und_section_ptr;
1471 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
1472 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1473 else if (isymp->st_shndx == SHN_ABS)
1474 isec = bfd_abs_section_ptr;
1475 else if (isymp->st_shndx == SHN_COMMON)
1476 isec = bfd_com_section_ptr;
1486 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1487 input_section, data, internal_relocs,
1488 internal_syms, sections))
1491 if (sections != NULL)
1494 if (internal_syms != NULL)
1495 free (internal_syms);
1496 internal_syms = NULL;
1497 if (external_syms != NULL && symtab_hdr->contents == NULL)
1498 free (external_syms);
1499 external_syms = NULL;
1500 if (internal_relocs != elf_section_data (input_section)->relocs)
1501 free (internal_relocs);
1502 internal_relocs = NULL;
1508 if (internal_relocs != NULL
1509 && internal_relocs != elf_section_data (input_section)->relocs)
1510 free (internal_relocs);
1511 if (external_syms != NULL && symtab_hdr->contents == NULL)
1512 free (external_syms);
1513 if (internal_syms != NULL)
1514 free (internal_syms);
1515 if (sections != NULL)
1521 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1522 #define TARGET_BIG_NAME "elf32-h8300"
1523 #define ELF_ARCH bfd_arch_h8300
1524 #define ELF_MACHINE_CODE EM_H8_300
1525 #define ELF_MAXPAGESIZE 0x1
1526 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1527 #define elf_info_to_howto elf32_h8_info_to_howto
1528 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1530 /* So we can set/examine bits in e_flags to get the specific
1531 H8 architecture in use. */
1532 #define elf_backend_final_write_processing \
1533 elf32_h8_final_write_processing
1534 #define elf_backend_object_p \
1536 #define bfd_elf32_bfd_merge_private_bfd_data \
1537 elf32_h8_merge_private_bfd_data
1539 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1540 defaults to using _bfd_generic_link_hash_table_create, but
1541 elflink.h:bfd_elf32_size_dynamic_sections uses
1542 dynobj = elf_hash_table (info)->dynobj;
1543 and thus requires an elf hash table. */
1544 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1546 /* Use an H8 specific linker, not the ELF generic linker. */
1547 #define elf_backend_relocate_section elf32_h8_relocate_section
1549 /* And relaxing stuff. */
1550 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1551 #define bfd_elf32_bfd_get_relocated_section_contents \
1552 elf32_h8_get_relocated_section_contents
1555 #include "elf32-target.h"