1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright (C) 1993-2016 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
27 static reloc_howto_type *elf32_h8_reloc_type_lookup
28 (bfd *abfd, bfd_reloc_code_real_type code);
29 static void elf32_h8_info_to_howto
30 (bfd *, arelent *, Elf_Internal_Rela *);
31 static void elf32_h8_info_to_howto_rel
32 (bfd *, arelent *, Elf_Internal_Rela *);
33 static unsigned long elf32_h8_mach (flagword);
34 static void elf32_h8_final_write_processing (bfd *, bfd_boolean);
35 static bfd_boolean elf32_h8_object_p (bfd *);
36 static bfd_boolean elf32_h8_merge_private_bfd_data (bfd *, bfd *);
37 static bfd_boolean elf32_h8_relax_section
38 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
39 static bfd_boolean elf32_h8_relax_delete_bytes
40 (bfd *, asection *, bfd_vma, int);
41 static bfd_boolean elf32_h8_symbol_address_p (bfd *, asection *, bfd_vma);
42 static bfd_byte *elf32_h8_get_relocated_section_contents
43 (bfd *, struct bfd_link_info *, struct bfd_link_order *,
44 bfd_byte *, bfd_boolean, asymbol **);
45 static bfd_reloc_status_type elf32_h8_final_link_relocate
46 (unsigned long, bfd *, bfd *, asection *,
47 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
48 struct bfd_link_info *, asection *, int);
49 static bfd_boolean elf32_h8_relocate_section
50 (bfd *, struct bfd_link_info *, bfd *, asection *,
51 bfd_byte *, Elf_Internal_Rela *,
52 Elf_Internal_Sym *, asection **);
53 static bfd_reloc_status_type special
54 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 /* This does not include any relocation information, but should be
57 good enough for GDB or objdump to read the file. */
59 static reloc_howto_type h8_elf_howto_table[] =
62 HOWTO (R_H8_NONE, /* type */
64 3, /* size (0 = byte, 1 = short, 2 = long) */
66 FALSE, /* pc_relative */
68 complain_overflow_dont,/* complain_on_overflow */
69 special, /* special_function */
70 "R_H8_NONE", /* name */
71 FALSE, /* partial_inplace */
74 FALSE), /* pcrel_offset */
75 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
76 HOWTO (R_H8_DIR32, /* type */
78 2, /* size (0 = byte, 1 = short, 2 = long) */
80 FALSE, /* pc_relative */
82 complain_overflow_dont,/* complain_on_overflow */
83 special, /* special_function */
84 "R_H8_DIR32", /* name */
85 FALSE, /* partial_inplace */
87 0xffffffff, /* dst_mask */
88 FALSE), /* pcrel_offset */
89 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
90 HOWTO (R_H8_DIR16, /* type */
92 1, /* size (0 = byte, 1 = short, 2 = long) */
94 FALSE, /* pc_relative */
96 complain_overflow_dont,/* complain_on_overflow */
97 special, /* special_function */
98 "R_H8_DIR16", /* name */
99 FALSE, /* partial_inplace */
101 0x0000ffff, /* dst_mask */
102 FALSE), /* pcrel_offset */
103 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
104 HOWTO (R_H8_DIR8, /* type */
106 0, /* size (0 = byte, 1 = short, 2 = long) */
108 FALSE, /* pc_relative */
110 complain_overflow_dont,/* complain_on_overflow */
111 special, /* special_function */
112 "R_H8_DIR8", /* name */
113 FALSE, /* partial_inplace */
115 0x000000ff, /* dst_mask */
116 FALSE), /* pcrel_offset */
117 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
118 HOWTO (R_H8_DIR16A8, /* type */
120 1, /* size (0 = byte, 1 = short, 2 = long) */
122 FALSE, /* pc_relative */
124 complain_overflow_bitfield, /* complain_on_overflow */
125 special, /* special_function */
126 "R_H8_DIR16A8", /* name */
127 FALSE, /* partial_inplace */
129 0x0000ffff, /* dst_mask */
130 FALSE), /* pcrel_offset */
131 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
132 HOWTO (R_H8_DIR16R8, /* type */
134 1, /* size (0 = byte, 1 = short, 2 = long) */
136 FALSE, /* pc_relative */
138 complain_overflow_bitfield, /* complain_on_overflow */
139 special, /* special_function */
140 "R_H8_DIR16R8", /* name */
141 FALSE, /* partial_inplace */
143 0x0000ffff, /* dst_mask */
144 FALSE), /* pcrel_offset */
145 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
146 HOWTO (R_H8_DIR24A8, /* type */
148 2, /* size (0 = byte, 1 = short, 2 = long) */
150 FALSE, /* pc_relative */
152 complain_overflow_bitfield, /* complain_on_overflow */
153 special, /* special_function */
154 "R_H8_DIR24A8", /* name */
155 TRUE, /* partial_inplace */
156 0xff000000, /* src_mask */
157 0x00ffffff, /* dst_mask */
158 FALSE), /* pcrel_offset */
159 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
160 HOWTO (R_H8_DIR24R8, /* type */
162 2, /* size (0 = byte, 1 = short, 2 = long) */
164 FALSE, /* pc_relative */
166 complain_overflow_bitfield, /* complain_on_overflow */
167 special, /* special_function */
168 "R_H8_DIR24R8", /* name */
169 TRUE, /* partial_inplace */
170 0xff000000, /* src_mask */
171 0x00ffffff, /* dst_mask */
172 FALSE), /* pcrel_offset */
173 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
174 HOWTO (R_H8_DIR32A16, /* type */
176 2, /* size (0 = byte, 1 = short, 2 = long) */
178 FALSE, /* pc_relative */
180 complain_overflow_dont,/* complain_on_overflow */
181 special, /* special_function */
182 "R_H8_DIR32A16", /* name */
183 FALSE, /* partial_inplace */
185 0xffffffff, /* dst_mask */
186 FALSE), /* pcrel_offset */
187 #define R_H8_DISP32A16_X (R_H8_DIR32A16_X + 1)
188 HOWTO (R_H8_DISP32A16, /* type */
190 2, /* size (0 = byte, 1 = short, 2 = long) */
192 FALSE, /* pc_relative */
194 complain_overflow_dont,/* complain_on_overflow */
195 special, /* special_function */
196 "R_H8_DISP32A16", /* name */
197 FALSE, /* partial_inplace */
199 0xffffffff, /* dst_mask */
200 FALSE), /* pcrel_offset */
201 #define R_H8_PCREL16_X (R_H8_DISP32A16_X + 1)
202 HOWTO (R_H8_PCREL16, /* type */
204 1, /* size (0 = byte, 1 = short, 2 = long) */
206 TRUE, /* pc_relative */
208 complain_overflow_signed,/* complain_on_overflow */
209 special, /* special_function */
210 "R_H8_PCREL16", /* name */
211 FALSE, /* partial_inplace */
212 0xffff, /* src_mask */
213 0xffff, /* dst_mask */
214 TRUE), /* pcrel_offset */
215 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
216 HOWTO (R_H8_PCREL8, /* type */
218 0, /* size (0 = byte, 1 = short, 2 = long) */
220 TRUE, /* pc_relative */
222 complain_overflow_signed,/* complain_on_overflow */
223 special, /* special_function */
224 "R_H8_PCREL8", /* name */
225 FALSE, /* partial_inplace */
228 TRUE), /* pcrel_offset */
231 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
233 struct elf_reloc_map {
234 bfd_reloc_code_real_type bfd_reloc_val;
235 unsigned char howto_index;
238 /* An array mapping BFD reloc codes to H8 ELF relocs. */
240 static const struct elf_reloc_map h8_reloc_map[] = {
241 { BFD_RELOC_NONE, R_H8_NONE_X },
242 { BFD_RELOC_32, R_H8_DIR32_X },
243 { BFD_RELOC_16, R_H8_DIR16_X },
244 { BFD_RELOC_8, R_H8_DIR8_X },
245 { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
246 { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
247 { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
248 { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
249 { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
250 { BFD_RELOC_H8_DISP32A16, R_H8_DISP32A16_X },
251 { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
252 { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
256 static reloc_howto_type *
257 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
258 bfd_reloc_code_real_type code)
262 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
264 if (h8_reloc_map[i].bfd_reloc_val == code)
265 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
270 static reloc_howto_type *
271 elf32_h8_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
277 i < sizeof (h8_elf_howto_table) / sizeof (h8_elf_howto_table[0]);
279 if (h8_elf_howto_table[i].name != NULL
280 && strcasecmp (h8_elf_howto_table[i].name, r_name) == 0)
281 return &h8_elf_howto_table[i];
287 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
288 Elf_Internal_Rela *elf_reloc)
293 r = ELF32_R_TYPE (elf_reloc->r_info);
294 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
295 if (h8_elf_howto_table[i].type == r)
297 bfd_reloc->howto = &h8_elf_howto_table[i];
304 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
305 Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED)
310 r = ELF32_R_TYPE (elf_reloc->r_info);
311 bfd_reloc->howto = &h8_elf_howto_table[r];
314 /* Special handling for H8/300 relocs.
315 We only come here for pcrel stuff and return normally if not an -r link.
316 When doing -r, we can't do any arithmetic for the pcrel stuff, because
317 we support relaxing on the H8/300 series chips. */
318 static bfd_reloc_status_type
319 special (bfd *abfd ATTRIBUTE_UNUSED,
320 arelent *reloc_entry ATTRIBUTE_UNUSED,
321 asymbol *symbol ATTRIBUTE_UNUSED,
322 void * data ATTRIBUTE_UNUSED,
323 asection *input_section ATTRIBUTE_UNUSED,
325 char **error_message ATTRIBUTE_UNUSED)
327 if (output_bfd == (bfd *) NULL)
328 return bfd_reloc_continue;
330 /* Adjust the reloc address to that in the output section. */
331 reloc_entry->address += input_section->output_offset;
335 /* Perform a relocation as part of a final link. */
336 static bfd_reloc_status_type
337 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd,
338 bfd *output_bfd ATTRIBUTE_UNUSED,
339 asection *input_section ATTRIBUTE_UNUSED,
340 bfd_byte *contents, bfd_vma offset,
341 bfd_vma value, bfd_vma addend,
342 struct bfd_link_info *info ATTRIBUTE_UNUSED,
343 asection *sym_sec ATTRIBUTE_UNUSED,
344 int is_local ATTRIBUTE_UNUSED)
346 bfd_byte *hit_data = contents + offset;
358 bfd_put_32 (input_bfd, value, hit_data);
365 bfd_put_16 (input_bfd, value, hit_data);
372 bfd_put_8 (input_bfd, value, hit_data);
378 /* HIT_DATA is the address for the first byte for the relocated
379 value. Subtract 1 so that we can manipulate the data in 32-bit
383 /* Clear out the top byte in value. */
386 /* Retrieve the type byte for value from the section contents. */
387 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
389 /* Now scribble it out in one 32-bit hunk. */
390 bfd_put_32 (input_bfd, value, hit_data);
394 value -= (input_section->output_section->vma
395 + input_section->output_offset);
399 /* The value is relative to the start of the instruction,
400 not the relocation offset. Subtract 2 to account for
404 bfd_put_16 (input_bfd, value, hit_data);
408 value -= (input_section->output_section->vma
409 + input_section->output_offset);
413 /* The value is relative to the start of the instruction,
414 not the relocation offset. Subtract 1 to account for
418 bfd_put_8 (input_bfd, value, hit_data);
422 return bfd_reloc_notsupported;
426 /* Relocate an H8 ELF section. */
428 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
429 bfd *input_bfd, asection *input_section,
430 bfd_byte *contents, Elf_Internal_Rela *relocs,
431 Elf_Internal_Sym *local_syms,
432 asection **local_sections)
434 Elf_Internal_Shdr *symtab_hdr;
435 struct elf_link_hash_entry **sym_hashes;
436 Elf_Internal_Rela *rel, *relend;
438 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
439 sym_hashes = elf_sym_hashes (input_bfd);
442 relend = relocs + input_section->reloc_count;
443 for (; rel < relend; rel++)
446 unsigned long r_symndx;
447 Elf_Internal_Sym *sym;
449 struct elf_link_hash_entry *h;
451 bfd_reloc_status_type r;
453 reloc_howto_type *howto;
455 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
456 howto = bfd_reloc.howto;
458 r_symndx = ELF32_R_SYM (rel->r_info);
459 r_type = ELF32_R_TYPE (rel->r_info);
463 if (r_symndx < symtab_hdr->sh_info)
465 sym = local_syms + r_symndx;
466 sec = local_sections[r_symndx];
467 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
471 bfd_boolean unresolved_reloc, warned, ignored;
473 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
474 r_symndx, symtab_hdr, sym_hashes,
476 unresolved_reloc, warned, ignored);
479 if (sec != NULL && discarded_section (sec))
480 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
481 rel, 1, relend, howto, 0, contents);
483 if (bfd_link_relocatable (info))
486 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
488 contents, rel->r_offset,
489 relocation, rel->r_addend,
490 info, sec, h == NULL);
492 if (r != bfd_reloc_ok)
495 const char *msg = (const char *) 0;
498 name = h->root.root.string;
501 name = (bfd_elf_string_from_elf_section
502 (input_bfd, symtab_hdr->sh_link, sym->st_name));
503 if (name == NULL || *name == '\0')
504 name = bfd_section_name (input_bfd, sec);
509 case bfd_reloc_overflow:
510 (*info->callbacks->reloc_overflow)
511 (info, (h ? &h->root : NULL), name, howto->name,
512 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
515 case bfd_reloc_undefined:
516 (*info->callbacks->undefined_symbol)
517 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
520 case bfd_reloc_outofrange:
521 msg = _("internal error: out of range error");
524 case bfd_reloc_notsupported:
525 msg = _("internal error: unsupported relocation error");
528 case bfd_reloc_dangerous:
529 msg = _("internal error: dangerous error");
533 msg = _("internal error: unknown error");
537 (*info->callbacks->warning) (info, msg, name, input_bfd,
538 input_section, rel->r_offset);
547 /* Object files encode the specific H8 model they were compiled
548 for in the ELF flags field.
550 Examine that field and return the proper BFD machine type for
553 elf32_h8_mach (flagword flags)
555 switch (flags & EF_H8_MACH)
557 case E_H8_MACH_H8300:
559 return bfd_mach_h8300;
561 case E_H8_MACH_H8300H:
562 return bfd_mach_h8300h;
564 case E_H8_MACH_H8300S:
565 return bfd_mach_h8300s;
567 case E_H8_MACH_H8300HN:
568 return bfd_mach_h8300hn;
570 case E_H8_MACH_H8300SN:
571 return bfd_mach_h8300sn;
573 case E_H8_MACH_H8300SX:
574 return bfd_mach_h8300sx;
576 case E_H8_MACH_H8300SXN:
577 return bfd_mach_h8300sxn;
581 /* The final processing done just before writing out a H8 ELF object
582 file. We use this opportunity to encode the BFD machine type
583 into the flags field in the object file. */
586 elf32_h8_final_write_processing (bfd *abfd,
587 bfd_boolean linker ATTRIBUTE_UNUSED)
591 switch (bfd_get_mach (abfd))
595 val = E_H8_MACH_H8300;
598 case bfd_mach_h8300h:
599 val = E_H8_MACH_H8300H;
602 case bfd_mach_h8300s:
603 val = E_H8_MACH_H8300S;
606 case bfd_mach_h8300hn:
607 val = E_H8_MACH_H8300HN;
610 case bfd_mach_h8300sn:
611 val = E_H8_MACH_H8300SN;
614 case bfd_mach_h8300sx:
615 val = E_H8_MACH_H8300SX;
618 case bfd_mach_h8300sxn:
619 val = E_H8_MACH_H8300SXN;
623 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
624 elf_elfheader (abfd)->e_flags |= val;
627 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
628 record the encoded machine type found in the ELF flags. */
631 elf32_h8_object_p (bfd *abfd)
633 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
634 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
638 /* Merge backend specific data from an object file to the output
639 object file when linking. The only data we need to copy at this
640 time is the architecture/machine information. */
643 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
645 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
646 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
649 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
650 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
652 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
653 bfd_get_mach (ibfd)))
660 /* This function handles relaxing for the H8..
662 There are a few relaxing opportunities available on the H8:
664 jmp/jsr:24 -> bra/bsr:8 2 bytes
665 The jmp may be completely eliminated if the previous insn is a
666 conditional branch to the insn after the jump. In that case
667 we invert the branch and delete the jump and save 4 bytes.
669 bCC:16 -> bCC:8 2 bytes
670 bsr:16 -> bsr:8 2 bytes
672 bset:16 -> bset:8 2 bytes
673 bset:24/32 -> bset:8 4 bytes
674 (also applicable to other bit manipulation instructions)
676 mov.b:16 -> mov.b:8 2 bytes
677 mov.b:24/32 -> mov.b:8 4 bytes
679 bset:24/32 -> bset:16 2 bytes
680 (also applicable to other bit manipulation instructions)
682 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes
684 mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes. */
687 elf32_h8_relax_section (bfd *abfd, asection *sec,
688 struct bfd_link_info *link_info, bfd_boolean *again)
690 Elf_Internal_Shdr *symtab_hdr;
691 Elf_Internal_Rela *internal_relocs;
692 Elf_Internal_Rela *irel, *irelend;
693 bfd_byte *contents = NULL;
694 Elf_Internal_Sym *isymbuf = NULL;
695 static asection *last_input_section = NULL;
696 static Elf_Internal_Rela *last_reloc = NULL;
698 /* Assume nothing changes. */
701 /* We don't have to do anything for a relocatable link, if
702 this section does not have relocs, or if this is not a
704 if (bfd_link_relocatable (link_info)
705 || (sec->flags & SEC_RELOC) == 0
706 || sec->reloc_count == 0
707 || (sec->flags & SEC_CODE) == 0)
710 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
712 /* Get a copy of the native relocations. */
713 internal_relocs = (_bfd_elf_link_read_relocs
714 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
715 link_info->keep_memory));
716 if (internal_relocs == NULL)
719 if (sec != last_input_section)
722 last_input_section = sec;
724 /* Walk through the relocs looking for relaxing opportunities. */
725 irelend = internal_relocs + sec->reloc_count;
726 for (irel = internal_relocs; irel < irelend; irel++)
733 elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
735 /* Keep track of the previous reloc so that we can delete
736 some long jumps created by the compiler. */
737 if (irel != internal_relocs)
738 last_reloc = irel - 1;
740 switch(ELF32_R_TYPE (irel->r_info))
753 /* Get the section contents if we haven't done so already. */
754 if (contents == NULL)
756 /* Get cached copy if it exists. */
757 if (elf_section_data (sec)->this_hdr.contents != NULL)
758 contents = elf_section_data (sec)->this_hdr.contents;
761 /* Go get them off disk. */
762 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
767 /* Read this BFD's local symbols if we haven't done so already. */
768 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
770 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
772 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
773 symtab_hdr->sh_info, 0,
779 /* Get the value of the symbol referred to by the reloc. */
780 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
782 /* A local symbol. */
783 Elf_Internal_Sym *isym;
786 isym = isymbuf + ELF32_R_SYM (irel->r_info);
787 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
788 symval = isym->st_value;
789 /* If the reloc is absolute, it will not have
790 a symbol or section associated with it. */
792 symval += sym_sec->output_section->vma
793 + sym_sec->output_offset;
798 struct elf_link_hash_entry *h;
800 /* An external symbol. */
801 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
802 h = elf_sym_hashes (abfd)[indx];
803 BFD_ASSERT (h != NULL);
804 if (h->root.type != bfd_link_hash_defined
805 && h->root.type != bfd_link_hash_defweak)
807 /* This appears to be a reference to an undefined
808 symbol. Just ignore it--it will be caught by the
809 regular reloc processing. */
813 symval = (h->root.u.def.value
814 + h->root.u.def.section->output_section->vma
815 + h->root.u.def.section->output_offset);
818 /* For simplicity of coding, we are going to modify the section
819 contents, the section relocs, and the BFD symbol table. We
820 must tell the rest of the code not to free up this
821 information. It would be possible to instead create a table
822 of changes which have to be made, as is done in coff-mips.c;
823 that would be more work, but would require less memory when
824 the linker is run. */
825 switch (ELF32_R_TYPE (irel->r_info))
827 /* Try to turn a 24-bit absolute branch/call into an 8-bit
828 pc-relative branch/call. */
831 bfd_vma value = symval + irel->r_addend;
834 /* Get the address of this instruction. */
835 dot = (sec->output_section->vma
836 + sec->output_offset + irel->r_offset - 1);
838 /* Compute the distance from this insn to the branch target. */
841 /* If the distance is within -126..+130 inclusive, then we can
842 relax this jump. +130 is valid since the target will move
843 two bytes closer if we do relax this branch. */
844 if ((int) gap >= -126 && (int) gap <= 130)
848 /* Note that we've changed the relocs, section contents,
850 elf_section_data (sec)->relocs = internal_relocs;
851 elf_section_data (sec)->this_hdr.contents = contents;
852 symtab_hdr->contents = (unsigned char *) isymbuf;
854 /* Get the instruction code being relaxed. */
855 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
857 /* If the previous instruction conditionally jumped around
858 this instruction, we may be able to reverse the condition
859 and redirect the previous instruction to the target of
862 Such sequences are used by the compiler to deal with
863 long conditional branches.
865 Only perform this optimisation for jumps (code 0x5a) not
866 subroutine calls, as otherwise it could transform:
879 which changes the call (jsr) into a branch (bne). */
880 if (code == 0x5a /* jmp24. */
884 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
885 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
888 asection *last_sym_sec;
889 Elf_Internal_Sym *last_sym;
891 /* We will need to examine the symbol used by the
892 previous relocation. */
894 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
896 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
897 last_value = (last_sym->st_value
898 + last_sym_sec->output_section->vma
899 + last_sym_sec->output_offset);
901 /* Verify that the previous relocation was for a
902 branch around this instruction and that no symbol
903 exists at the current location. */
904 if (last_value == dot + 4
905 && last_reloc->r_offset + 2 == irel->r_offset
906 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
908 /* We can eliminate this jump. Twiddle the
909 previous relocation as necessary. */
911 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
912 ELF32_R_TYPE (R_H8_NONE));
915 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
916 ELF32_R_TYPE (R_H8_PCREL8));
917 last_reloc->r_addend = irel->r_addend;
919 code = bfd_get_8 (abfd,
920 contents + last_reloc->r_offset - 1);
924 contents + last_reloc->r_offset - 1);
926 /* Delete four bytes of data. */
927 if (!elf32_h8_relax_delete_bytes (abfd, sec,
939 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1); /* bsr8. */
940 else if (code == 0x5a)
942 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1); /* bra8. */
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 16-bit pc-relative branch into a 8-bit 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;
987 elf_section_data (sec)->this_hdr.contents = contents;
988 symtab_hdr->contents = (unsigned char *) isymbuf;
990 /* Get the opcode. */
991 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
995 /* bCC:16 -> bCC:8 */
996 /* Get the second byte of the original insn, which
997 contains the condition code. */
998 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1000 /* Compute the first byte of the relaxed
1001 instruction. The original sequence 0x58 0xX0
1002 is relaxed to 0x4X, where X represents the
1007 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); /* bCC:8. */
1009 else if (code == 0x5c) /* bsr16. */
1011 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2); /* bsr8. */
1013 /* Might be MOVSD. */
1016 /* Fix the relocation's type. */
1017 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1021 /* Delete two bytes of data. */
1022 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1023 irel->r_offset + 1, 2))
1026 /* That will change things, so, we should relax again.
1027 Note that this is not required, and it may be slow. */
1033 /* This is a 16-bit absolute address in one of the following
1036 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1037 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1040 We may relax this into an 8-bit absolute address if it's in
1046 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1047 if (value >= 0xffffff00u)
1050 unsigned char temp_code;
1052 /* Note that we've changed the relocs, section contents,
1054 elf_section_data (sec)->relocs = internal_relocs;
1055 elf_section_data (sec)->this_hdr.contents = contents;
1056 symtab_hdr->contents = (unsigned char *) isymbuf;
1058 /* Get the opcode. */
1059 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1061 /* All instructions with R_H8_DIR16A8 start with
1066 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1067 /* If this is a mov.b instruction, clear the lower
1068 nibble, which contains the source/destination
1070 if ((temp_code & 0x10) != 0x10)
1076 /* This is mov.b @aa:16,Rd. */
1077 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1078 contents + irel->r_offset - 2);
1081 /* This is mov.b Rs,@aa:16. */
1082 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1083 contents + irel->r_offset - 2);
1086 /* This is a bit-maniputation instruction that
1087 stores one bit into memory, one of "bclr",
1088 "bist", "bnot", "bset", and "bst". */
1089 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1092 /* This is a bit-maniputation instruction that
1093 loads one bit from memory, one of "band",
1094 "biand", "bild", "bior", "bixor", "bld", "bor",
1095 "btst", and "bxor". */
1096 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1102 /* Fix the relocation's type. */
1103 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1106 /* Move the relocation. */
1109 /* Delete two bytes of data. */
1110 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1111 irel->r_offset + 1, 2))
1114 /* That will change things, so, we should relax again.
1115 Note that this is not required, and it may be slow. */
1121 /* This is a 24-bit absolute address in one of the following
1124 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1125 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1128 We may relax this into an 8-bit absolute address if it's in
1134 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1135 if (value >= 0xffffff00u)
1138 unsigned char temp_code;
1140 /* Note that we've changed the relocs, section contents,
1142 elf_section_data (sec)->relocs = internal_relocs;
1143 elf_section_data (sec)->this_hdr.contents = contents;
1144 symtab_hdr->contents = (unsigned char *) isymbuf;
1146 /* Get the opcode. */
1147 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1149 /* All instructions with R_H8_DIR24A8 start with
1154 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1156 /* If this is a mov.b instruction, clear the lower
1157 nibble, which contains the source/destination
1159 if ((temp_code & 0x30) != 0x30)
1165 /* This is mov.b @aa:24/32,Rd. */
1166 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1167 contents + irel->r_offset - 2);
1170 /* This is mov.b Rs,@aa:24/32. */
1171 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1172 contents + irel->r_offset - 2);
1175 /* This is a bit-maniputation instruction that
1176 stores one bit into memory, one of "bclr",
1177 "bist", "bnot", "bset", and "bst". */
1178 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1181 /* This is a bit-maniputation instruction that
1182 loads one bit from memory, one of "band",
1183 "biand", "bild", "bior", "bixor", "bld", "bor",
1184 "btst", and "bxor". */
1185 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1191 /* Fix the relocation's type. */
1192 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1196 /* Delete four bytes of data. */
1197 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1198 irel->r_offset + 1, 4))
1201 /* That will change things, so, we should relax again.
1202 Note that this is not required, and it may be slow. */
1210 /* This is a 24-/32-bit absolute address in one of the
1211 following instructions:
1213 "band", "bclr", "biand", "bild", "bior", "bist",
1214 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1215 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1217 We may relax this into an 16-bit absolute address if it's
1218 in the right range. */
1223 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1224 if (value <= 0x7fff || value >= 0xffff8000u)
1227 unsigned char op0, op1, op2, op3;
1228 unsigned char *op_ptr;
1230 /* Note that we've changed the relocs, section contents,
1232 elf_section_data (sec)->relocs = internal_relocs;
1233 elf_section_data (sec)->this_hdr.contents = contents;
1234 symtab_hdr->contents = (unsigned char *) isymbuf;
1236 if (irel->r_offset >= 4)
1238 /* Check for 4-byte MOVA relaxation (SH-specific). */
1239 int second_reloc = 0;
1241 op_ptr = contents + irel->r_offset - 4;
1246 reloc_howto_type *h;
1247 bfd_vma last_reloc_size;
1249 elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
1250 h = bfd_reloc.howto;
1251 last_reloc_size = 1 << h->size;
1252 if (last_reloc->r_offset + last_reloc_size
1255 op_ptr -= last_reloc_size;
1260 if (irel + 1 < irelend)
1262 Elf_Internal_Rela *next_reloc = irel + 1;
1264 reloc_howto_type *h;
1265 bfd_vma next_reloc_size;
1267 elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
1268 h = bfd_reloc.howto;
1269 next_reloc_size = 1 << h->size;
1270 if (next_reloc->r_offset + next_reloc_size
1273 op_ptr -= next_reloc_size;
1278 op0 = bfd_get_8 (abfd, op_ptr + 0);
1279 op1 = bfd_get_8 (abfd, op_ptr + 1);
1280 op2 = bfd_get_8 (abfd, op_ptr + 2);
1281 op3 = bfd_get_8 (abfd, op_ptr + 3);
1284 && (op1 & 0xdf) == 0x5f
1285 && (op2 & 0x40) == 0x40
1286 && (op3 & 0x80) == 0x80)
1288 if ((op2 & 0x08) == 0)
1294 bfd_put_8 (abfd, op3, op_ptr + 3);
1299 bfd_put_8 (abfd, op2, op_ptr + 2);
1301 goto r_h8_dir32a16_common;
1305 /* Now check for short version of MOVA. (SH-specific) */
1306 op_ptr = contents + irel->r_offset - 2;
1307 op0 = bfd_get_8 (abfd, op_ptr + 0);
1308 op1 = bfd_get_8 (abfd, op_ptr + 1);
1311 && (op1 & 0x88) == 0x80)
1314 bfd_put_8 (abfd, op1, op_ptr + 1);
1315 goto r_h8_dir32a16_common;
1318 /* Get the opcode. */
1319 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1321 /* Fix the opcode. For all the instructions that
1322 belong to this relaxation, we simply need to turn
1323 off bit 0x20 in the previous byte. */
1326 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1328 r_h8_dir32a16_common:
1329 /* Fix the relocation's type. */
1330 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1333 /* Delete two bytes of data. */
1334 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1335 irel->r_offset + 1, 2))
1338 /* That will change things, so, we should relax again.
1339 Note that this is not required, and it may be slow. */
1342 break; /* case R_H8_DIR32A16 */
1345 case R_H8_DISP32A16:
1346 /* mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes
1347 It is assured that instruction uses at least 4 bytes opcode before
1348 reloc entry addressing mode "register indirect with displacement"
1349 relaxing options (all saving 4 bytes):
1350 0x78 0sss0000 0x6A 0010dddd disp:32 mov.b @(d:32,ERs),Rd ->
1351 0x6E 0sssdddd disp:16 mov.b @(d:16,ERs),Rd
1352 0x78 0sss0000 0x6B 0010dddd disp:32 mov.w @(d:32,ERs),Rd ->
1353 0x6F 0sssdddd disp:16 mov.w @(d:16,ERs),Rd
1354 0x01 0x00 0x78 0sss0000 0x6B 00100ddd disp:32 mov.l @(d:32,ERs),ERd ->
1355 0x01 0x00 0x6F 0sss0ddd disp:16 mov.l @(d:16,ERs),ERd
1357 0x78 0ddd0000 0x6A 1010ssss disp:32 mov.b Rs,@(d:32,ERd) ->
1358 0x6E 1dddssss disp:16 mov.b Rs,@(d:16,ERd)
1359 0x78 0ddd0000 0x6B 1010ssss disp:32 mov.w Rs,@(d:32,ERd) ->
1360 0x6F 1dddssss disp:16 mov.w Rs,@(d:16,ERd)
1361 0x01 0x00 0x78 xddd0000 0x6B 10100sss disp:32 mov.l ERs,@(d:32,ERd) ->
1362 0x01 0x00 0x6F 1ddd0sss disp:16 mov.l ERs,@(d:16,ERd)
1363 mov.l prefix 0x01 0x00 can be left as is and mov.l handled same
1368 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1369 if (value <= 0x7fff || value >= 0xffff8000u)
1371 unsigned char op0, op1, op2, op3, op0n, op1n;
1374 /* Note that we've changed the relocs, section contents,
1376 elf_section_data (sec)->relocs = internal_relocs;
1377 elf_section_data (sec)->this_hdr.contents = contents;
1378 symtab_hdr->contents = (unsigned char *) isymbuf;
1380 if (irel->r_offset >= 4)
1382 op0 = bfd_get_8 (abfd, contents + irel->r_offset - 4);
1383 op1 = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1384 op2 = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1385 op3 = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1392 if ((op1 & 0x8F) == 0x00 && (op3 & 0x70) == 0x20)
1400 if ((op1 & 0x0F) == 0x00 && (op3 & 0x70) == 0x20)
1415 op1n = (op3 & 0x8F) | (op1 & 0x70);
1416 bfd_put_8 (abfd, op0n, contents + irel->r_offset - 4);
1417 bfd_put_8 (abfd, op1n, contents + irel->r_offset - 3);
1419 /* Fix the relocation's type. */
1420 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_H8_DIR16);
1421 irel->r_offset -= 2;
1423 /* Delete four bytes of data. */
1424 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset + 2, 4))
1427 /* That will change things, so, we should relax again.
1428 Note that this is not required, and it may be slow. */
1441 && symtab_hdr->contents != (unsigned char *) isymbuf)
1443 if (! link_info->keep_memory)
1446 symtab_hdr->contents = (unsigned char *) isymbuf;
1449 if (contents != NULL
1450 && elf_section_data (sec)->this_hdr.contents != contents)
1452 if (! link_info->keep_memory)
1456 /* Cache the section contents for elf_link_input_bfd. */
1457 elf_section_data (sec)->this_hdr.contents = contents;
1461 if (internal_relocs != NULL
1462 && elf_section_data (sec)->relocs != internal_relocs)
1463 free (internal_relocs);
1469 && symtab_hdr->contents != (unsigned char *) isymbuf)
1471 if (contents != NULL
1472 && elf_section_data (sec)->this_hdr.contents != contents)
1474 if (internal_relocs != NULL
1475 && elf_section_data (sec)->relocs != internal_relocs)
1476 free (internal_relocs);
1480 /* Delete some bytes from a section while relaxing. */
1483 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1485 Elf_Internal_Shdr *symtab_hdr;
1486 unsigned int sec_shndx;
1488 Elf_Internal_Rela *irel, *irelend;
1489 Elf_Internal_Sym *isym;
1490 Elf_Internal_Sym *isymend;
1492 struct elf_link_hash_entry **sym_hashes;
1493 struct elf_link_hash_entry **end_hashes;
1494 unsigned int symcount;
1496 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1498 contents = elf_section_data (sec)->this_hdr.contents;
1502 irel = elf_section_data (sec)->relocs;
1503 irelend = irel + sec->reloc_count;
1505 /* Actually delete the bytes. */
1506 memmove (contents + addr, contents + addr + count,
1507 (size_t) (toaddr - addr - count));
1510 /* Adjust all the relocs. */
1511 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1513 /* Get the new reloc address. */
1514 if ((irel->r_offset > addr
1515 && irel->r_offset <= toaddr))
1516 irel->r_offset -= count;
1519 /* Adjust the local symbols defined in this section. */
1520 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1521 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1522 isymend = isym + symtab_hdr->sh_info;
1523 for (; isym < isymend; isym++)
1525 if (isym->st_shndx == sec_shndx
1526 && isym->st_value > addr
1527 && isym->st_value <= toaddr)
1528 isym->st_value -= count;
1531 /* Now adjust the global symbols defined in this section. */
1532 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1533 - symtab_hdr->sh_info);
1534 sym_hashes = elf_sym_hashes (abfd);
1535 end_hashes = sym_hashes + symcount;
1536 for (; sym_hashes < end_hashes; sym_hashes++)
1538 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1540 if ((sym_hash->root.type == bfd_link_hash_defined
1541 || sym_hash->root.type == bfd_link_hash_defweak)
1542 && sym_hash->root.u.def.section == sec
1543 && sym_hash->root.u.def.value > addr
1544 && sym_hash->root.u.def.value <= toaddr)
1545 sym_hash->root.u.def.value -= count;
1551 /* Return TRUE if a symbol exists at the given address, else return
1554 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1556 Elf_Internal_Shdr *symtab_hdr;
1557 unsigned int sec_shndx;
1558 Elf_Internal_Sym *isym;
1559 Elf_Internal_Sym *isymend;
1560 struct elf_link_hash_entry **sym_hashes;
1561 struct elf_link_hash_entry **end_hashes;
1562 unsigned int symcount;
1564 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1566 /* Examine all the symbols. */
1567 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1568 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1569 isymend = isym + symtab_hdr->sh_info;
1570 for (; isym < isymend; isym++)
1572 if (isym->st_shndx == sec_shndx
1573 && isym->st_value == addr)
1577 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1578 - symtab_hdr->sh_info);
1579 sym_hashes = elf_sym_hashes (abfd);
1580 end_hashes = sym_hashes + symcount;
1581 for (; sym_hashes < end_hashes; sym_hashes++)
1583 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1584 if ((sym_hash->root.type == bfd_link_hash_defined
1585 || sym_hash->root.type == bfd_link_hash_defweak)
1586 && sym_hash->root.u.def.section == sec
1587 && sym_hash->root.u.def.value == addr)
1594 /* This is a version of bfd_generic_get_relocated_section_contents
1595 which uses elf32_h8_relocate_section. */
1598 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1599 struct bfd_link_info *link_info,
1600 struct bfd_link_order *link_order,
1602 bfd_boolean relocatable,
1605 Elf_Internal_Shdr *symtab_hdr;
1606 asection *input_section = link_order->u.indirect.section;
1607 bfd *input_bfd = input_section->owner;
1608 asection **sections = NULL;
1609 Elf_Internal_Rela *internal_relocs = NULL;
1610 Elf_Internal_Sym *isymbuf = NULL;
1612 /* We only need to handle the case of relaxing, or of having a
1613 particular set of section contents, specially. */
1615 || elf_section_data (input_section)->this_hdr.contents == NULL)
1616 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1621 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1623 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1624 (size_t) input_section->size);
1626 if ((input_section->flags & SEC_RELOC) != 0
1627 && input_section->reloc_count > 0)
1630 Elf_Internal_Sym *isym, *isymend;
1633 internal_relocs = (_bfd_elf_link_read_relocs
1634 (input_bfd, input_section, NULL,
1635 (Elf_Internal_Rela *) NULL, FALSE));
1636 if (internal_relocs == NULL)
1639 if (symtab_hdr->sh_info != 0)
1641 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1642 if (isymbuf == NULL)
1643 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1644 symtab_hdr->sh_info, 0,
1646 if (isymbuf == NULL)
1650 amt = symtab_hdr->sh_info;
1651 amt *= sizeof (asection *);
1652 sections = (asection **) bfd_malloc (amt);
1653 if (sections == NULL && amt != 0)
1656 isymend = isymbuf + symtab_hdr->sh_info;
1657 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1661 if (isym->st_shndx == SHN_UNDEF)
1662 isec = bfd_und_section_ptr;
1663 else if (isym->st_shndx == SHN_ABS)
1664 isec = bfd_abs_section_ptr;
1665 else if (isym->st_shndx == SHN_COMMON)
1666 isec = bfd_com_section_ptr;
1668 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1673 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1674 input_section, data, internal_relocs,
1678 if (sections != NULL)
1681 && symtab_hdr->contents != (unsigned char *) isymbuf)
1683 if (elf_section_data (input_section)->relocs != internal_relocs)
1684 free (internal_relocs);
1690 if (sections != NULL)
1693 && symtab_hdr->contents != (unsigned char *) isymbuf)
1695 if (internal_relocs != NULL
1696 && elf_section_data (input_section)->relocs != internal_relocs)
1697 free (internal_relocs);
1702 #define TARGET_BIG_SYM h8300_elf32_vec
1703 #define TARGET_BIG_NAME "elf32-h8300"
1704 #define ELF_ARCH bfd_arch_h8300
1705 #define ELF_MACHINE_CODE EM_H8_300
1706 #define ELF_MAXPAGESIZE 0x1
1707 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1708 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
1709 #define elf_info_to_howto elf32_h8_info_to_howto
1710 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1712 /* So we can set/examine bits in e_flags to get the specific
1713 H8 architecture in use. */
1714 #define elf_backend_final_write_processing \
1715 elf32_h8_final_write_processing
1716 #define elf_backend_object_p \
1718 #define bfd_elf32_bfd_merge_private_bfd_data \
1719 elf32_h8_merge_private_bfd_data
1721 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1722 defaults to using _bfd_generic_link_hash_table_create, but
1723 bfd_elf_size_dynamic_sections uses
1724 dynobj = elf_hash_table (info)->dynobj;
1725 and thus requires an elf hash table. */
1726 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1728 /* Use an H8 specific linker, not the ELF generic linker. */
1729 #define elf_backend_relocate_section elf32_h8_relocate_section
1730 #define elf_backend_rela_normal 1
1731 #define elf_backend_can_gc_sections 1
1733 /* And relaxing stuff. */
1734 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1735 #define bfd_elf32_bfd_get_relocated_section_contents \
1736 elf32_h8_get_relocated_section_contents
1738 #define elf_symbol_leading_char '_'
1740 #include "elf32-target.h"
1742 #undef TARGET_BIG_SYM
1743 #define TARGET_BIG_SYM h8300_elf32_linux_vec
1744 #undef TARGET_BIG_NAME
1745 #define TARGET_BIG_NAME "elf32-h8300-linux"
1746 #undef elf_symbol_leading_char
1747 #define elf32_bed elf32_h8300_linux_bed
1749 #include "elf32-target.h"