1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright (C) 1993-2018 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
37 (bfd *, struct bfd_link_info *);
38 static bfd_boolean elf32_h8_relax_section
39 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
40 static bfd_boolean elf32_h8_relax_delete_bytes
41 (bfd *, asection *, bfd_vma, int);
42 static bfd_boolean elf32_h8_symbol_address_p (bfd *, asection *, bfd_vma);
43 static bfd_byte *elf32_h8_get_relocated_section_contents
44 (bfd *, struct bfd_link_info *, struct bfd_link_order *,
45 bfd_byte *, bfd_boolean, asymbol **);
46 static bfd_reloc_status_type elf32_h8_final_link_relocate
47 (unsigned long, bfd *, bfd *, asection *,
48 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
49 struct bfd_link_info *, asection *, int);
50 static bfd_boolean elf32_h8_relocate_section
51 (bfd *, struct bfd_link_info *, bfd *, asection *,
52 bfd_byte *, Elf_Internal_Rela *,
53 Elf_Internal_Sym *, asection **);
54 static bfd_reloc_status_type special
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
57 /* This does not include any relocation information, but should be
58 good enough for GDB or objdump to read the file. */
60 static reloc_howto_type h8_elf_howto_table[] =
63 HOWTO (R_H8_NONE, /* type */
65 3, /* size (0 = byte, 1 = short, 2 = long) */
67 FALSE, /* pc_relative */
69 complain_overflow_dont,/* complain_on_overflow */
70 special, /* special_function */
71 "R_H8_NONE", /* name */
72 FALSE, /* partial_inplace */
75 FALSE), /* pcrel_offset */
76 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
77 HOWTO (R_H8_DIR32, /* type */
79 2, /* size (0 = byte, 1 = short, 2 = long) */
81 FALSE, /* pc_relative */
83 complain_overflow_dont,/* complain_on_overflow */
84 special, /* special_function */
85 "R_H8_DIR32", /* name */
86 FALSE, /* partial_inplace */
88 0xffffffff, /* dst_mask */
89 FALSE), /* pcrel_offset */
90 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
91 HOWTO (R_H8_DIR16, /* type */
93 1, /* size (0 = byte, 1 = short, 2 = long) */
95 FALSE, /* pc_relative */
97 complain_overflow_dont,/* complain_on_overflow */
98 special, /* special_function */
99 "R_H8_DIR16", /* name */
100 FALSE, /* partial_inplace */
102 0x0000ffff, /* dst_mask */
103 FALSE), /* pcrel_offset */
104 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
105 HOWTO (R_H8_DIR8, /* type */
107 0, /* size (0 = byte, 1 = short, 2 = long) */
109 FALSE, /* pc_relative */
111 complain_overflow_dont,/* complain_on_overflow */
112 special, /* special_function */
113 "R_H8_DIR8", /* name */
114 FALSE, /* partial_inplace */
116 0x000000ff, /* dst_mask */
117 FALSE), /* pcrel_offset */
118 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
119 HOWTO (R_H8_DIR16A8, /* type */
121 1, /* size (0 = byte, 1 = short, 2 = long) */
123 FALSE, /* pc_relative */
125 complain_overflow_bitfield, /* complain_on_overflow */
126 special, /* special_function */
127 "R_H8_DIR16A8", /* name */
128 FALSE, /* partial_inplace */
130 0x0000ffff, /* dst_mask */
131 FALSE), /* pcrel_offset */
132 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
133 HOWTO (R_H8_DIR16R8, /* type */
135 1, /* size (0 = byte, 1 = short, 2 = long) */
137 FALSE, /* pc_relative */
139 complain_overflow_bitfield, /* complain_on_overflow */
140 special, /* special_function */
141 "R_H8_DIR16R8", /* name */
142 FALSE, /* partial_inplace */
144 0x0000ffff, /* dst_mask */
145 FALSE), /* pcrel_offset */
146 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
147 HOWTO (R_H8_DIR24A8, /* type */
149 2, /* size (0 = byte, 1 = short, 2 = long) */
151 FALSE, /* pc_relative */
153 complain_overflow_bitfield, /* complain_on_overflow */
154 special, /* special_function */
155 "R_H8_DIR24A8", /* name */
156 TRUE, /* partial_inplace */
157 0xff000000, /* src_mask */
158 0x00ffffff, /* dst_mask */
159 FALSE), /* pcrel_offset */
160 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
161 HOWTO (R_H8_DIR24R8, /* type */
163 2, /* size (0 = byte, 1 = short, 2 = long) */
165 FALSE, /* pc_relative */
167 complain_overflow_bitfield, /* complain_on_overflow */
168 special, /* special_function */
169 "R_H8_DIR24R8", /* name */
170 TRUE, /* partial_inplace */
171 0xff000000, /* src_mask */
172 0x00ffffff, /* dst_mask */
173 FALSE), /* pcrel_offset */
174 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
175 HOWTO (R_H8_DIR32A16, /* type */
177 2, /* size (0 = byte, 1 = short, 2 = long) */
179 FALSE, /* pc_relative */
181 complain_overflow_dont,/* complain_on_overflow */
182 special, /* special_function */
183 "R_H8_DIR32A16", /* name */
184 FALSE, /* partial_inplace */
186 0xffffffff, /* dst_mask */
187 FALSE), /* pcrel_offset */
188 #define R_H8_DISP32A16_X (R_H8_DIR32A16_X + 1)
189 HOWTO (R_H8_DISP32A16, /* type */
191 2, /* size (0 = byte, 1 = short, 2 = long) */
193 FALSE, /* pc_relative */
195 complain_overflow_dont,/* complain_on_overflow */
196 special, /* special_function */
197 "R_H8_DISP32A16", /* name */
198 FALSE, /* partial_inplace */
200 0xffffffff, /* dst_mask */
201 FALSE), /* pcrel_offset */
202 #define R_H8_PCREL16_X (R_H8_DISP32A16_X + 1)
203 HOWTO (R_H8_PCREL16, /* type */
205 1, /* size (0 = byte, 1 = short, 2 = long) */
207 TRUE, /* pc_relative */
209 complain_overflow_signed,/* complain_on_overflow */
210 special, /* special_function */
211 "R_H8_PCREL16", /* name */
212 FALSE, /* partial_inplace */
213 0xffff, /* src_mask */
214 0xffff, /* dst_mask */
215 TRUE), /* pcrel_offset */
216 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
217 HOWTO (R_H8_PCREL8, /* type */
219 0, /* size (0 = byte, 1 = short, 2 = long) */
221 TRUE, /* pc_relative */
223 complain_overflow_signed,/* complain_on_overflow */
224 special, /* special_function */
225 "R_H8_PCREL8", /* name */
226 FALSE, /* partial_inplace */
229 TRUE), /* pcrel_offset */
232 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
234 struct elf_reloc_map {
235 bfd_reloc_code_real_type bfd_reloc_val;
236 unsigned char howto_index;
239 /* An array mapping BFD reloc codes to H8 ELF relocs. */
241 static const struct elf_reloc_map h8_reloc_map[] = {
242 { BFD_RELOC_NONE, R_H8_NONE_X },
243 { BFD_RELOC_32, R_H8_DIR32_X },
244 { BFD_RELOC_16, R_H8_DIR16_X },
245 { BFD_RELOC_8, R_H8_DIR8_X },
246 { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
247 { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
248 { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
249 { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
250 { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
251 { BFD_RELOC_H8_DISP32A16, R_H8_DISP32A16_X },
252 { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
253 { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
257 static reloc_howto_type *
258 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
259 bfd_reloc_code_real_type code)
263 for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
265 if (h8_reloc_map[i].bfd_reloc_val == code)
266 return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
271 static reloc_howto_type *
272 elf32_h8_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
278 i < sizeof (h8_elf_howto_table) / sizeof (h8_elf_howto_table[0]);
280 if (h8_elf_howto_table[i].name != NULL
281 && strcasecmp (h8_elf_howto_table[i].name, r_name) == 0)
282 return &h8_elf_howto_table[i];
288 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
289 Elf_Internal_Rela *elf_reloc)
294 r = ELF32_R_TYPE (elf_reloc->r_info);
295 for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
296 if (h8_elf_howto_table[i].type == r)
298 bfd_reloc->howto = &h8_elf_howto_table[i];
305 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
306 Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED)
311 r = ELF32_R_TYPE (elf_reloc->r_info);
312 bfd_reloc->howto = &h8_elf_howto_table[r];
315 /* Special handling for H8/300 relocs.
316 We only come here for pcrel stuff and return normally if not an -r link.
317 When doing -r, we can't do any arithmetic for the pcrel stuff, because
318 we support relaxing on the H8/300 series chips. */
319 static bfd_reloc_status_type
320 special (bfd *abfd ATTRIBUTE_UNUSED,
321 arelent *reloc_entry ATTRIBUTE_UNUSED,
322 asymbol *symbol ATTRIBUTE_UNUSED,
323 void * data ATTRIBUTE_UNUSED,
324 asection *input_section ATTRIBUTE_UNUSED,
326 char **error_message ATTRIBUTE_UNUSED)
328 if (output_bfd == (bfd *) NULL)
329 return bfd_reloc_continue;
331 /* Adjust the reloc address to that in the output section. */
332 reloc_entry->address += input_section->output_offset;
336 /* Perform a relocation as part of a final link. */
337 static bfd_reloc_status_type
338 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd,
339 bfd *output_bfd ATTRIBUTE_UNUSED,
340 asection *input_section ATTRIBUTE_UNUSED,
341 bfd_byte *contents, bfd_vma offset,
342 bfd_vma value, bfd_vma addend,
343 struct bfd_link_info *info ATTRIBUTE_UNUSED,
344 asection *sym_sec ATTRIBUTE_UNUSED,
345 int is_local ATTRIBUTE_UNUSED)
347 bfd_byte *hit_data = contents + offset;
359 bfd_put_32 (input_bfd, value, hit_data);
366 bfd_put_16 (input_bfd, value, hit_data);
373 bfd_put_8 (input_bfd, value, hit_data);
379 /* HIT_DATA is the address for the first byte for the relocated
380 value. Subtract 1 so that we can manipulate the data in 32-bit
384 /* Clear out the top byte in value. */
387 /* Retrieve the type byte for value from the section contents. */
388 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
390 /* Now scribble it out in one 32-bit hunk. */
391 bfd_put_32 (input_bfd, value, hit_data);
395 value -= (input_section->output_section->vma
396 + input_section->output_offset);
400 /* The value is relative to the start of the instruction,
401 not the relocation offset. Subtract 2 to account for
405 bfd_put_16 (input_bfd, value, hit_data);
409 value -= (input_section->output_section->vma
410 + input_section->output_offset);
414 /* The value is relative to the start of the instruction,
415 not the relocation offset. Subtract 1 to account for
419 bfd_put_8 (input_bfd, value, hit_data);
423 return bfd_reloc_notsupported;
427 /* Relocate an H8 ELF section. */
429 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
430 bfd *input_bfd, asection *input_section,
431 bfd_byte *contents, Elf_Internal_Rela *relocs,
432 Elf_Internal_Sym *local_syms,
433 asection **local_sections)
435 Elf_Internal_Shdr *symtab_hdr;
436 struct elf_link_hash_entry **sym_hashes;
437 Elf_Internal_Rela *rel, *relend;
439 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
440 sym_hashes = elf_sym_hashes (input_bfd);
443 relend = relocs + input_section->reloc_count;
444 for (; rel < relend; rel++)
447 unsigned long r_symndx;
448 Elf_Internal_Sym *sym;
450 struct elf_link_hash_entry *h;
452 bfd_reloc_status_type r;
454 reloc_howto_type *howto;
456 elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
457 howto = bfd_reloc.howto;
459 r_symndx = ELF32_R_SYM (rel->r_info);
460 r_type = ELF32_R_TYPE (rel->r_info);
464 if (r_symndx < symtab_hdr->sh_info)
466 sym = local_syms + r_symndx;
467 sec = local_sections[r_symndx];
468 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
472 bfd_boolean unresolved_reloc, warned, ignored;
474 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
475 r_symndx, symtab_hdr, sym_hashes,
477 unresolved_reloc, warned, ignored);
480 if (sec != NULL && discarded_section (sec))
481 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
482 rel, 1, relend, howto, 0, contents);
484 if (bfd_link_relocatable (info))
487 r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
489 contents, rel->r_offset,
490 relocation, rel->r_addend,
491 info, sec, h == NULL);
493 if (r != bfd_reloc_ok)
496 const char *msg = (const char *) 0;
499 name = h->root.root.string;
502 name = (bfd_elf_string_from_elf_section
503 (input_bfd, symtab_hdr->sh_link, sym->st_name));
504 if (name == NULL || *name == '\0')
505 name = bfd_section_name (input_bfd, sec);
510 case bfd_reloc_overflow:
511 (*info->callbacks->reloc_overflow)
512 (info, (h ? &h->root : NULL), name, howto->name,
513 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
516 case bfd_reloc_undefined:
517 (*info->callbacks->undefined_symbol)
518 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
521 case bfd_reloc_outofrange:
522 msg = _("internal error: out of range error");
525 case bfd_reloc_notsupported:
526 msg = _("internal error: unsupported relocation error");
529 case bfd_reloc_dangerous:
530 msg = _("internal error: dangerous error");
534 msg = _("internal error: unknown error");
538 (*info->callbacks->warning) (info, msg, name, input_bfd,
539 input_section, rel->r_offset);
548 /* Object files encode the specific H8 model they were compiled
549 for in the ELF flags field.
551 Examine that field and return the proper BFD machine type for
554 elf32_h8_mach (flagword flags)
556 switch (flags & EF_H8_MACH)
558 case E_H8_MACH_H8300:
560 return bfd_mach_h8300;
562 case E_H8_MACH_H8300H:
563 return bfd_mach_h8300h;
565 case E_H8_MACH_H8300S:
566 return bfd_mach_h8300s;
568 case E_H8_MACH_H8300HN:
569 return bfd_mach_h8300hn;
571 case E_H8_MACH_H8300SN:
572 return bfd_mach_h8300sn;
574 case E_H8_MACH_H8300SX:
575 return bfd_mach_h8300sx;
577 case E_H8_MACH_H8300SXN:
578 return bfd_mach_h8300sxn;
582 /* The final processing done just before writing out a H8 ELF object
583 file. We use this opportunity to encode the BFD machine type
584 into the flags field in the object file. */
587 elf32_h8_final_write_processing (bfd *abfd,
588 bfd_boolean linker ATTRIBUTE_UNUSED)
592 switch (bfd_get_mach (abfd))
596 val = E_H8_MACH_H8300;
599 case bfd_mach_h8300h:
600 val = E_H8_MACH_H8300H;
603 case bfd_mach_h8300s:
604 val = E_H8_MACH_H8300S;
607 case bfd_mach_h8300hn:
608 val = E_H8_MACH_H8300HN;
611 case bfd_mach_h8300sn:
612 val = E_H8_MACH_H8300SN;
615 case bfd_mach_h8300sx:
616 val = E_H8_MACH_H8300SX;
619 case bfd_mach_h8300sxn:
620 val = E_H8_MACH_H8300SXN;
624 elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
625 elf_elfheader (abfd)->e_flags |= val;
628 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
629 record the encoded machine type found in the ELF flags. */
632 elf32_h8_object_p (bfd *abfd)
634 bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
635 elf32_h8_mach (elf_elfheader (abfd)->e_flags));
639 /* Merge backend specific data from an object file to the output
640 object file when linking. The only data we need to copy at this
641 time is the architecture/machine information. */
644 elf32_h8_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
646 bfd *obfd = info->output_bfd;
648 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
649 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
652 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
653 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
655 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
656 bfd_get_mach (ibfd)))
663 /* This function handles relaxing for the H8..
665 There are a few relaxing opportunities available on the H8:
667 jmp/jsr:24 -> bra/bsr:8 2 bytes
668 The jmp may be completely eliminated if the previous insn is a
669 conditional branch to the insn after the jump. In that case
670 we invert the branch and delete the jump and save 4 bytes.
672 bCC:16 -> bCC:8 2 bytes
673 bsr:16 -> bsr:8 2 bytes
675 bset:16 -> bset:8 2 bytes
676 bset:24/32 -> bset:8 4 bytes
677 (also applicable to other bit manipulation instructions)
679 mov.b:16 -> mov.b:8 2 bytes
680 mov.b:24/32 -> mov.b:8 4 bytes
682 bset:24/32 -> bset:16 2 bytes
683 (also applicable to other bit manipulation instructions)
685 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes
687 mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes. */
690 elf32_h8_relax_section (bfd *abfd, asection *sec,
691 struct bfd_link_info *link_info, bfd_boolean *again)
693 Elf_Internal_Shdr *symtab_hdr;
694 Elf_Internal_Rela *internal_relocs;
695 Elf_Internal_Rela *irel, *irelend;
696 bfd_byte *contents = NULL;
697 Elf_Internal_Sym *isymbuf = NULL;
698 static asection *last_input_section = NULL;
699 static Elf_Internal_Rela *last_reloc = NULL;
701 /* Assume nothing changes. */
704 /* We don't have to do anything for a relocatable link, if
705 this section does not have relocs, or if this is not a
707 if (bfd_link_relocatable (link_info)
708 || (sec->flags & SEC_RELOC) == 0
709 || sec->reloc_count == 0
710 || (sec->flags & SEC_CODE) == 0)
713 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
715 /* Get a copy of the native relocations. */
716 internal_relocs = (_bfd_elf_link_read_relocs
717 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
718 link_info->keep_memory));
719 if (internal_relocs == NULL)
722 if (sec != last_input_section)
725 last_input_section = sec;
727 /* Walk through the relocs looking for relaxing opportunities. */
728 irelend = internal_relocs + sec->reloc_count;
729 for (irel = internal_relocs; irel < irelend; irel++)
736 elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
738 /* Keep track of the previous reloc so that we can delete
739 some long jumps created by the compiler. */
740 if (irel != internal_relocs)
741 last_reloc = irel - 1;
743 switch(ELF32_R_TYPE (irel->r_info))
756 /* Get the section contents if we haven't done so already. */
757 if (contents == NULL)
759 /* Get cached copy if it exists. */
760 if (elf_section_data (sec)->this_hdr.contents != NULL)
761 contents = elf_section_data (sec)->this_hdr.contents;
764 /* Go get them off disk. */
765 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
770 /* Read this BFD's local symbols if we haven't done so already. */
771 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
773 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
775 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
776 symtab_hdr->sh_info, 0,
782 /* Get the value of the symbol referred to by the reloc. */
783 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
785 /* A local symbol. */
786 Elf_Internal_Sym *isym;
789 isym = isymbuf + ELF32_R_SYM (irel->r_info);
790 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
791 symval = isym->st_value;
792 /* If the reloc is absolute, it will not have
793 a symbol or section associated with it. */
795 symval += sym_sec->output_section->vma
796 + sym_sec->output_offset;
801 struct elf_link_hash_entry *h;
803 /* An external symbol. */
804 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
805 h = elf_sym_hashes (abfd)[indx];
806 BFD_ASSERT (h != NULL);
807 if (h->root.type != bfd_link_hash_defined
808 && h->root.type != bfd_link_hash_defweak)
810 /* This appears to be a reference to an undefined
811 symbol. Just ignore it--it will be caught by the
812 regular reloc processing. */
816 symval = (h->root.u.def.value
817 + h->root.u.def.section->output_section->vma
818 + h->root.u.def.section->output_offset);
821 /* For simplicity of coding, we are going to modify the section
822 contents, the section relocs, and the BFD symbol table. We
823 must tell the rest of the code not to free up this
824 information. It would be possible to instead create a table
825 of changes which have to be made, as is done in coff-mips.c;
826 that would be more work, but would require less memory when
827 the linker is run. */
828 switch (ELF32_R_TYPE (irel->r_info))
830 /* Try to turn a 24-bit absolute branch/call into an 8-bit
831 pc-relative branch/call. */
834 bfd_vma value = symval + irel->r_addend;
837 /* Get the address of this instruction. */
838 dot = (sec->output_section->vma
839 + sec->output_offset + irel->r_offset - 1);
841 /* Compute the distance from this insn to the branch target. */
844 /* If the distance is within -126..+130 inclusive, then we can
845 relax this jump. +130 is valid since the target will move
846 two bytes closer if we do relax this branch. */
847 if ((int) gap >= -126 && (int) gap <= 130)
851 /* Note that we've changed the relocs, section contents,
853 elf_section_data (sec)->relocs = internal_relocs;
854 elf_section_data (sec)->this_hdr.contents = contents;
855 symtab_hdr->contents = (unsigned char *) isymbuf;
857 /* Get the instruction code being relaxed. */
858 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
860 /* If the previous instruction conditionally jumped around
861 this instruction, we may be able to reverse the condition
862 and redirect the previous instruction to the target of
865 Such sequences are used by the compiler to deal with
866 long conditional branches.
868 Only perform this optimisation for jumps (code 0x5a) not
869 subroutine calls, as otherwise it could transform:
882 which changes the call (jsr) into a branch (bne). */
883 if (code == 0x5a /* jmp24. */
887 && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
888 && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
891 asection *last_sym_sec;
892 Elf_Internal_Sym *last_sym;
894 /* We will need to examine the symbol used by the
895 previous relocation. */
897 last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
899 = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
900 last_value = (last_sym->st_value
901 + last_sym_sec->output_section->vma
902 + last_sym_sec->output_offset);
904 /* Verify that the previous relocation was for a
905 branch around this instruction and that no symbol
906 exists at the current location. */
907 if (last_value == dot + 4
908 && last_reloc->r_offset + 2 == irel->r_offset
909 && ! elf32_h8_symbol_address_p (abfd, sec, dot))
911 /* We can eliminate this jump. Twiddle the
912 previous relocation as necessary. */
914 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
915 ELF32_R_TYPE (R_H8_NONE));
918 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
919 ELF32_R_TYPE (R_H8_PCREL8));
920 last_reloc->r_addend = irel->r_addend;
922 code = bfd_get_8 (abfd,
923 contents + last_reloc->r_offset - 1);
927 contents + last_reloc->r_offset - 1);
929 /* Delete four bytes of data. */
930 if (!elf32_h8_relax_delete_bytes (abfd, sec,
942 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1); /* bsr8. */
943 else if (code == 0x5a)
945 bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1); /* bra8. */
949 /* Fix the relocation's type. */
950 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
953 /* Delete two bytes of data. */
954 if (!elf32_h8_relax_delete_bytes (abfd, sec,
955 irel->r_offset + 1, 2))
958 /* That will change things, so, we should relax again.
959 Note that this is not required, and it may be slow. */
965 /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
969 bfd_vma value = symval + irel->r_addend;
973 /* Get the address of this instruction. */
974 dot = (sec->output_section->vma
976 + irel->r_offset - 2);
980 /* If the distance is within -126..+130 inclusive, then we can
981 relax this jump. +130 is valid since the target will move
982 two bytes closer if we do relax this branch. */
983 if ((int) gap >= -126 && (int) gap <= 130)
987 /* Note that we've changed the relocs, section contents,
989 elf_section_data (sec)->relocs = internal_relocs;
990 elf_section_data (sec)->this_hdr.contents = contents;
991 symtab_hdr->contents = (unsigned char *) isymbuf;
993 /* Get the opcode. */
994 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
998 /* bCC:16 -> bCC:8 */
999 /* Get the second byte of the original insn, which
1000 contains the condition code. */
1001 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1003 /* Compute the first byte of the relaxed
1004 instruction. The original sequence 0x58 0xX0
1005 is relaxed to 0x4X, where X represents the
1010 bfd_put_8 (abfd, code, contents + irel->r_offset - 2); /* bCC:8. */
1012 else if (code == 0x5c) /* bsr16. */
1014 bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2); /* bsr8. */
1016 /* Might be MOVSD. */
1019 /* Fix the relocation's type. */
1020 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1024 /* Delete two bytes of data. */
1025 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1026 irel->r_offset + 1, 2))
1029 /* That will change things, so, we should relax again.
1030 Note that this is not required, and it may be slow. */
1036 /* This is a 16-bit absolute address in one of the following
1039 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1040 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1043 We may relax this into an 8-bit absolute address if it's in
1049 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1050 if (value >= 0xffffff00u)
1053 unsigned char temp_code;
1055 /* Note that we've changed the relocs, section contents,
1057 elf_section_data (sec)->relocs = internal_relocs;
1058 elf_section_data (sec)->this_hdr.contents = contents;
1059 symtab_hdr->contents = (unsigned char *) isymbuf;
1061 /* Get the opcode. */
1062 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1064 /* All instructions with R_H8_DIR16A8 start with
1069 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1070 /* If this is a mov.b instruction, clear the lower
1071 nibble, which contains the source/destination
1073 if ((temp_code & 0x10) != 0x10)
1079 /* This is mov.b @aa:16,Rd. */
1080 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1081 contents + irel->r_offset - 2);
1084 /* This is mov.b Rs,@aa:16. */
1085 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1086 contents + irel->r_offset - 2);
1089 /* This is a bit-maniputation instruction that
1090 stores one bit into memory, one of "bclr",
1091 "bist", "bnot", "bset", and "bst". */
1092 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1095 /* This is a bit-maniputation instruction that
1096 loads one bit from memory, one of "band",
1097 "biand", "bild", "bior", "bixor", "bld", "bor",
1098 "btst", and "bxor". */
1099 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1105 /* Fix the relocation's type. */
1106 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1109 /* Move the relocation. */
1112 /* Delete two bytes of data. */
1113 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1114 irel->r_offset + 1, 2))
1117 /* That will change things, so, we should relax again.
1118 Note that this is not required, and it may be slow. */
1124 /* This is a 24-bit absolute address in one of the following
1127 "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1128 "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1131 We may relax this into an 8-bit absolute address if it's in
1137 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1138 if (value >= 0xffffff00u)
1141 unsigned char temp_code;
1143 /* Note that we've changed the relocs, section contents,
1145 elf_section_data (sec)->relocs = internal_relocs;
1146 elf_section_data (sec)->this_hdr.contents = contents;
1147 symtab_hdr->contents = (unsigned char *) isymbuf;
1149 /* Get the opcode. */
1150 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1152 /* All instructions with R_H8_DIR24A8 start with
1157 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1159 /* If this is a mov.b instruction, clear the lower
1160 nibble, which contains the source/destination
1162 if ((temp_code & 0x30) != 0x30)
1168 /* This is mov.b @aa:24/32,Rd. */
1169 bfd_put_8 (abfd, (code & 0xf) | 0x20,
1170 contents + irel->r_offset - 2);
1173 /* This is mov.b Rs,@aa:24/32. */
1174 bfd_put_8 (abfd, (code & 0xf) | 0x30,
1175 contents + irel->r_offset - 2);
1178 /* This is a bit-maniputation instruction that
1179 stores one bit into memory, one of "bclr",
1180 "bist", "bnot", "bset", and "bst". */
1181 bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1184 /* This is a bit-maniputation instruction that
1185 loads one bit from memory, one of "band",
1186 "biand", "bild", "bior", "bixor", "bld", "bor",
1187 "btst", and "bxor". */
1188 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1194 /* Fix the relocation's type. */
1195 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1199 /* Delete four bytes of data. */
1200 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1201 irel->r_offset + 1, 4))
1204 /* That will change things, so, we should relax again.
1205 Note that this is not required, and it may be slow. */
1213 /* This is a 24-/32-bit absolute address in one of the
1214 following instructions:
1216 "band", "bclr", "biand", "bild", "bior", "bist",
1217 "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1218 "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1220 We may relax this into an 16-bit absolute address if it's
1221 in the right range. */
1226 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1227 if (value <= 0x7fff || value >= 0xffff8000u)
1230 unsigned char op0, op1, op2, op3;
1231 unsigned char *op_ptr;
1233 /* Note that we've changed the relocs, section contents,
1235 elf_section_data (sec)->relocs = internal_relocs;
1236 elf_section_data (sec)->this_hdr.contents = contents;
1237 symtab_hdr->contents = (unsigned char *) isymbuf;
1239 if (irel->r_offset >= 4)
1241 /* Check for 4-byte MOVA relaxation (SH-specific). */
1242 int second_reloc = 0;
1244 op_ptr = contents + irel->r_offset - 4;
1249 reloc_howto_type *h;
1250 bfd_vma last_reloc_size;
1252 elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
1253 h = bfd_reloc.howto;
1254 last_reloc_size = 1 << h->size;
1255 if (last_reloc->r_offset + last_reloc_size
1258 op_ptr -= last_reloc_size;
1263 if (irel + 1 < irelend)
1265 Elf_Internal_Rela *next_reloc = irel + 1;
1267 reloc_howto_type *h;
1268 bfd_vma next_reloc_size;
1270 elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
1271 h = bfd_reloc.howto;
1272 next_reloc_size = 1 << h->size;
1273 if (next_reloc->r_offset + next_reloc_size
1276 op_ptr -= next_reloc_size;
1281 op0 = bfd_get_8 (abfd, op_ptr + 0);
1282 op1 = bfd_get_8 (abfd, op_ptr + 1);
1283 op2 = bfd_get_8 (abfd, op_ptr + 2);
1284 op3 = bfd_get_8 (abfd, op_ptr + 3);
1287 && (op1 & 0xdf) == 0x5f
1288 && (op2 & 0x40) == 0x40
1289 && (op3 & 0x80) == 0x80)
1291 if ((op2 & 0x08) == 0)
1297 bfd_put_8 (abfd, op3, op_ptr + 3);
1302 bfd_put_8 (abfd, op2, op_ptr + 2);
1304 goto r_h8_dir32a16_common;
1308 /* Now check for short version of MOVA. (SH-specific) */
1309 op_ptr = contents + irel->r_offset - 2;
1310 op0 = bfd_get_8 (abfd, op_ptr + 0);
1311 op1 = bfd_get_8 (abfd, op_ptr + 1);
1314 && (op1 & 0x88) == 0x80)
1317 bfd_put_8 (abfd, op1, op_ptr + 1);
1318 goto r_h8_dir32a16_common;
1321 /* Get the opcode. */
1322 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1324 /* Fix the opcode. For all the instructions that
1325 belong to this relaxation, we simply need to turn
1326 off bit 0x20 in the previous byte. */
1329 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1331 r_h8_dir32a16_common:
1332 /* Fix the relocation's type. */
1333 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1336 /* Delete two bytes of data. */
1337 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1338 irel->r_offset + 1, 2))
1341 /* That will change things, so, we should relax again.
1342 Note that this is not required, and it may be slow. */
1345 break; /* case R_H8_DIR32A16 */
1348 case R_H8_DISP32A16:
1349 /* mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx) 4 bytes
1350 It is assured that instruction uses at least 4 bytes opcode before
1351 reloc entry addressing mode "register indirect with displacement"
1352 relaxing options (all saving 4 bytes):
1353 0x78 0sss0000 0x6A 0010dddd disp:32 mov.b @(d:32,ERs),Rd ->
1354 0x6E 0sssdddd disp:16 mov.b @(d:16,ERs),Rd
1355 0x78 0sss0000 0x6B 0010dddd disp:32 mov.w @(d:32,ERs),Rd ->
1356 0x6F 0sssdddd disp:16 mov.w @(d:16,ERs),Rd
1357 0x01 0x00 0x78 0sss0000 0x6B 00100ddd disp:32 mov.l @(d:32,ERs),ERd ->
1358 0x01 0x00 0x6F 0sss0ddd disp:16 mov.l @(d:16,ERs),ERd
1360 0x78 0ddd0000 0x6A 1010ssss disp:32 mov.b Rs,@(d:32,ERd) ->
1361 0x6E 1dddssss disp:16 mov.b Rs,@(d:16,ERd)
1362 0x78 0ddd0000 0x6B 1010ssss disp:32 mov.w Rs,@(d:32,ERd) ->
1363 0x6F 1dddssss disp:16 mov.w Rs,@(d:16,ERd)
1364 0x01 0x00 0x78 xddd0000 0x6B 10100sss disp:32 mov.l ERs,@(d:32,ERd) ->
1365 0x01 0x00 0x6F 1ddd0sss disp:16 mov.l ERs,@(d:16,ERd)
1366 mov.l prefix 0x01 0x00 can be left as is and mov.l handled same
1371 value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1372 if (value <= 0x7fff || value >= 0xffff8000u)
1374 unsigned char op0, op1, op2, op3, op0n, op1n;
1377 /* Note that we've changed the relocs, section contents,
1379 elf_section_data (sec)->relocs = internal_relocs;
1380 elf_section_data (sec)->this_hdr.contents = contents;
1381 symtab_hdr->contents = (unsigned char *) isymbuf;
1383 if (irel->r_offset >= 4)
1385 op0 = bfd_get_8 (abfd, contents + irel->r_offset - 4);
1386 op1 = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1387 op2 = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1388 op3 = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1395 if ((op1 & 0x8F) == 0x00 && (op3 & 0x70) == 0x20)
1403 if ((op1 & 0x0F) == 0x00 && (op3 & 0x70) == 0x20)
1418 op1n = (op3 & 0x8F) | (op1 & 0x70);
1419 bfd_put_8 (abfd, op0n, contents + irel->r_offset - 4);
1420 bfd_put_8 (abfd, op1n, contents + irel->r_offset - 3);
1422 /* Fix the relocation's type. */
1423 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_H8_DIR16);
1424 irel->r_offset -= 2;
1426 /* Delete four bytes of data. */
1427 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset + 2, 4))
1430 /* That will change things, so, we should relax again.
1431 Note that this is not required, and it may be slow. */
1444 && symtab_hdr->contents != (unsigned char *) isymbuf)
1446 if (! link_info->keep_memory)
1449 symtab_hdr->contents = (unsigned char *) isymbuf;
1452 if (contents != NULL
1453 && elf_section_data (sec)->this_hdr.contents != contents)
1455 if (! link_info->keep_memory)
1459 /* Cache the section contents for elf_link_input_bfd. */
1460 elf_section_data (sec)->this_hdr.contents = contents;
1464 if (internal_relocs != NULL
1465 && elf_section_data (sec)->relocs != internal_relocs)
1466 free (internal_relocs);
1472 && symtab_hdr->contents != (unsigned char *) isymbuf)
1474 if (contents != NULL
1475 && elf_section_data (sec)->this_hdr.contents != contents)
1477 if (internal_relocs != NULL
1478 && elf_section_data (sec)->relocs != internal_relocs)
1479 free (internal_relocs);
1483 /* Delete some bytes from a section while relaxing. */
1486 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1488 Elf_Internal_Shdr *symtab_hdr;
1489 unsigned int sec_shndx;
1491 Elf_Internal_Rela *irel, *irelend;
1492 Elf_Internal_Sym *isym;
1493 Elf_Internal_Sym *isymend;
1495 struct elf_link_hash_entry **sym_hashes;
1496 struct elf_link_hash_entry **end_hashes;
1497 unsigned int symcount;
1499 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1501 contents = elf_section_data (sec)->this_hdr.contents;
1505 irel = elf_section_data (sec)->relocs;
1506 irelend = irel + sec->reloc_count;
1508 /* Actually delete the bytes. */
1509 memmove (contents + addr, contents + addr + count,
1510 (size_t) (toaddr - addr - count));
1513 /* Adjust all the relocs. */
1514 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1516 /* Get the new reloc address. */
1517 if ((irel->r_offset > addr
1518 && irel->r_offset <= toaddr))
1519 irel->r_offset -= count;
1522 /* Adjust the local symbols defined in this section. */
1523 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1524 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1525 isymend = isym + symtab_hdr->sh_info;
1526 for (; isym < isymend; isym++)
1528 if (isym->st_shndx == sec_shndx
1529 && isym->st_value > addr
1530 && isym->st_value <= toaddr)
1531 isym->st_value -= count;
1534 /* Now adjust the global symbols defined in this section. */
1535 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1536 - symtab_hdr->sh_info);
1537 sym_hashes = elf_sym_hashes (abfd);
1538 end_hashes = sym_hashes + symcount;
1539 for (; sym_hashes < end_hashes; sym_hashes++)
1541 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1543 if ((sym_hash->root.type == bfd_link_hash_defined
1544 || sym_hash->root.type == bfd_link_hash_defweak)
1545 && sym_hash->root.u.def.section == sec
1546 && sym_hash->root.u.def.value > addr
1547 && sym_hash->root.u.def.value <= toaddr)
1548 sym_hash->root.u.def.value -= count;
1554 /* Return TRUE if a symbol exists at the given address, else return
1557 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1559 Elf_Internal_Shdr *symtab_hdr;
1560 unsigned int sec_shndx;
1561 Elf_Internal_Sym *isym;
1562 Elf_Internal_Sym *isymend;
1563 struct elf_link_hash_entry **sym_hashes;
1564 struct elf_link_hash_entry **end_hashes;
1565 unsigned int symcount;
1567 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1569 /* Examine all the symbols. */
1570 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1571 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1572 isymend = isym + symtab_hdr->sh_info;
1573 for (; isym < isymend; isym++)
1575 if (isym->st_shndx == sec_shndx
1576 && isym->st_value == addr)
1580 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1581 - symtab_hdr->sh_info);
1582 sym_hashes = elf_sym_hashes (abfd);
1583 end_hashes = sym_hashes + symcount;
1584 for (; sym_hashes < end_hashes; sym_hashes++)
1586 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1587 if ((sym_hash->root.type == bfd_link_hash_defined
1588 || sym_hash->root.type == bfd_link_hash_defweak)
1589 && sym_hash->root.u.def.section == sec
1590 && sym_hash->root.u.def.value == addr)
1597 /* This is a version of bfd_generic_get_relocated_section_contents
1598 which uses elf32_h8_relocate_section. */
1601 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1602 struct bfd_link_info *link_info,
1603 struct bfd_link_order *link_order,
1605 bfd_boolean relocatable,
1608 Elf_Internal_Shdr *symtab_hdr;
1609 asection *input_section = link_order->u.indirect.section;
1610 bfd *input_bfd = input_section->owner;
1611 asection **sections = NULL;
1612 Elf_Internal_Rela *internal_relocs = NULL;
1613 Elf_Internal_Sym *isymbuf = NULL;
1615 /* We only need to handle the case of relaxing, or of having a
1616 particular set of section contents, specially. */
1618 || elf_section_data (input_section)->this_hdr.contents == NULL)
1619 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1624 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1626 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1627 (size_t) input_section->size);
1629 if ((input_section->flags & SEC_RELOC) != 0
1630 && input_section->reloc_count > 0)
1633 Elf_Internal_Sym *isym, *isymend;
1636 internal_relocs = (_bfd_elf_link_read_relocs
1637 (input_bfd, input_section, NULL,
1638 (Elf_Internal_Rela *) NULL, FALSE));
1639 if (internal_relocs == NULL)
1642 if (symtab_hdr->sh_info != 0)
1644 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1645 if (isymbuf == NULL)
1646 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1647 symtab_hdr->sh_info, 0,
1649 if (isymbuf == NULL)
1653 amt = symtab_hdr->sh_info;
1654 amt *= sizeof (asection *);
1655 sections = (asection **) bfd_malloc (amt);
1656 if (sections == NULL && amt != 0)
1659 isymend = isymbuf + symtab_hdr->sh_info;
1660 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1664 if (isym->st_shndx == SHN_UNDEF)
1665 isec = bfd_und_section_ptr;
1666 else if (isym->st_shndx == SHN_ABS)
1667 isec = bfd_abs_section_ptr;
1668 else if (isym->st_shndx == SHN_COMMON)
1669 isec = bfd_com_section_ptr;
1671 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1676 if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1677 input_section, data, internal_relocs,
1681 if (sections != NULL)
1684 && symtab_hdr->contents != (unsigned char *) isymbuf)
1686 if (elf_section_data (input_section)->relocs != internal_relocs)
1687 free (internal_relocs);
1693 if (sections != NULL)
1696 && symtab_hdr->contents != (unsigned char *) isymbuf)
1698 if (internal_relocs != NULL
1699 && elf_section_data (input_section)->relocs != internal_relocs)
1700 free (internal_relocs);
1705 #define TARGET_BIG_SYM h8300_elf32_vec
1706 #define TARGET_BIG_NAME "elf32-h8300"
1707 #define ELF_ARCH bfd_arch_h8300
1708 #define ELF_MACHINE_CODE EM_H8_300
1709 #define ELF_MAXPAGESIZE 0x1
1710 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1711 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
1712 #define elf_info_to_howto elf32_h8_info_to_howto
1713 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1715 /* So we can set/examine bits in e_flags to get the specific
1716 H8 architecture in use. */
1717 #define elf_backend_final_write_processing \
1718 elf32_h8_final_write_processing
1719 #define elf_backend_object_p \
1721 #define bfd_elf32_bfd_merge_private_bfd_data \
1722 elf32_h8_merge_private_bfd_data
1724 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1725 defaults to using _bfd_generic_link_hash_table_create, but
1726 bfd_elf_size_dynamic_sections uses
1727 dynobj = elf_hash_table (info)->dynobj;
1728 and thus requires an elf hash table. */
1729 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1731 /* Use an H8 specific linker, not the ELF generic linker. */
1732 #define elf_backend_relocate_section elf32_h8_relocate_section
1733 #define elf_backend_rela_normal 1
1734 #define elf_backend_can_gc_sections 1
1736 /* And relaxing stuff. */
1737 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1738 #define bfd_elf32_bfd_get_relocated_section_contents \
1739 elf32_h8_get_relocated_section_contents
1741 #define elf_symbol_leading_char '_'
1743 #include "elf32-target.h"
1745 #undef TARGET_BIG_SYM
1746 #define TARGET_BIG_SYM h8300_elf32_linux_vec
1747 #undef TARGET_BIG_NAME
1748 #define TARGET_BIG_NAME "elf32-h8300-linux"
1749 #undef elf_symbol_leading_char
1750 #define elf32_bed elf32_h8300_linux_bed
1752 #include "elf32-target.h"