1 /* Generic support for 32-bit ELF
2 Copyright 1993, 1995, 1998, 1999, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
27 static reloc_howto_type
*elf32_h8_reloc_type_lookup
28 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type code
));
29 static void elf32_h8_info_to_howto
30 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
31 static void elf32_h8_info_to_howto_rel
32 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rel
*));
33 static unsigned long elf32_h8_mach
35 static void elf32_h8_final_write_processing
36 PARAMS ((bfd
*, boolean
));
37 static boolean elf32_h8_object_p
39 static boolean elf32_h8_merge_private_bfd_data
40 PARAMS ((bfd
*, bfd
*));
41 static boolean elf32_h8_relax_section
42 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
43 static boolean elf32_h8_relax_delete_bytes
44 PARAMS ((bfd
*, asection
*, bfd_vma
, int));
45 static boolean elf32_h8_symbol_address_p
46 PARAMS ((bfd
*, asection
*, bfd_vma
));
47 static bfd_byte
*elf32_h8_get_relocated_section_contents
48 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
49 bfd_byte
*, boolean
, asymbol
**));
50 static bfd_reloc_status_type elf32_h8_final_link_relocate
51 PARAMS ((unsigned long, bfd
*, bfd
*, asection
*,
52 bfd_byte
*, bfd_vma
, bfd_vma
, bfd_vma
,
53 struct bfd_link_info
*, asection
*, int));
54 static boolean elf32_h8_relocate_section
55 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
56 bfd_byte
*, Elf_Internal_Rela
*,
57 Elf_Internal_Sym
*, asection
**));
58 static bfd_reloc_status_type special
59 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
61 /* This does not include any relocation information, but should be
62 good enough for GDB or objdump to read the file. */
64 static reloc_howto_type h8_elf_howto_table
[] =
67 HOWTO (R_H8_NONE
, /* type */
69 0, /* size (0 = byte, 1 = short, 2 = long) */
71 false, /* pc_relative */
73 complain_overflow_dont
, /* complain_on_overflow */
74 special
, /* special_function */
75 "R_H8_NONE", /* name */
76 false, /* partial_inplace */
79 false), /* pcrel_offset */
80 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
81 HOWTO (R_H8_DIR32
, /* type */
83 2, /* size (0 = byte, 1 = short, 2 = long) */
85 false, /* pc_relative */
87 complain_overflow_dont
, /* complain_on_overflow */
88 special
, /* special_function */
89 "R_H8_DIR32", /* name */
90 false, /* partial_inplace */
92 0xffffffff, /* dst_mask */
93 false), /* pcrel_offset */
94 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
95 HOWTO (R_H8_DIR16
, /* type */
97 1, /* size (0 = byte, 1 = short, 2 = long) */
99 false, /* pc_relative */
101 complain_overflow_dont
, /* complain_on_overflow */
102 special
, /* special_function */
103 "R_H8_DIR16", /* name */
104 false, /* partial_inplace */
106 0x0000ffff, /* dst_mask */
107 false), /* pcrel_offset */
108 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
109 HOWTO (R_H8_DIR8
, /* type */
111 0, /* size (0 = byte, 1 = short, 2 = long) */
113 false, /* pc_relative */
115 complain_overflow_dont
, /* complain_on_overflow */
116 special
, /* special_function */
117 "R_H8_DIR16", /* name */
118 false, /* partial_inplace */
120 0x000000ff, /* dst_mask */
121 false), /* pcrel_offset */
122 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
123 HOWTO (R_H8_DIR16A8
, /* type */
125 1, /* size (0 = byte, 1 = short, 2 = long) */
127 false, /* pc_relative */
129 complain_overflow_bitfield
, /* complain_on_overflow */
130 special
, /* special_function */
131 "R_H8_DIR16A8", /* name */
132 false, /* partial_inplace */
134 0x0000ffff, /* dst_mask */
135 false), /* pcrel_offset */
136 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
137 HOWTO (R_H8_DIR16R8
, /* type */
139 1, /* size (0 = byte, 1 = short, 2 = long) */
141 false, /* pc_relative */
143 complain_overflow_bitfield
, /* complain_on_overflow */
144 special
, /* special_function */
145 "R_H8_DIR16R8", /* name */
146 false, /* partial_inplace */
148 0x0000ffff, /* dst_mask */
149 false), /* pcrel_offset */
150 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
151 HOWTO (R_H8_DIR24A8
, /* type */
153 2, /* size (0 = byte, 1 = short, 2 = long) */
155 false, /* pc_relative */
157 complain_overflow_bitfield
, /* complain_on_overflow */
158 special
, /* special_function */
159 "R_H8_DIR24A8", /* name */
160 true, /* partial_inplace */
161 0xff000000, /* src_mask */
162 0x00ffffff, /* dst_mask */
163 false), /* pcrel_offset */
164 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
165 HOWTO (R_H8_DIR24R8
, /* type */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
169 false, /* pc_relative */
171 complain_overflow_bitfield
, /* complain_on_overflow */
172 special
, /* special_function */
173 "R_H8_DIR24R8", /* name */
174 true, /* partial_inplace */
175 0xff000000, /* src_mask */
176 0x00ffffff, /* dst_mask */
177 false), /* pcrel_offset */
178 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
179 HOWTO (R_H8_DIR32A16
, /* type */
181 2, /* size (0 = byte, 1 = short, 2 = long) */
183 false, /* pc_relative */
185 complain_overflow_dont
, /* complain_on_overflow */
186 special
, /* special_function */
187 "R_H8_DIR32", /* name */
188 false, /* partial_inplace */
190 0xffffffff, /* dst_mask */
191 false), /* pcrel_offset */
192 #define R_H8_PCREL16_X (R_H8_DIR32A16_X + 1)
193 HOWTO (R_H8_PCREL16
, /* type */
195 1, /* size (0 = byte, 1 = short, 2 = long) */
197 true, /* pc_relative */
199 complain_overflow_signed
, /* complain_on_overflow */
200 special
, /* special_function */
201 "R_H8_PCREL16", /* name */
202 false, /* partial_inplace */
203 0xffff, /* src_mask */
204 0xffff, /* dst_mask */
205 true), /* pcrel_offset */
206 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
207 HOWTO (R_H8_PCREL8
, /* type */
209 0, /* size (0 = byte, 1 = short, 2 = long) */
211 true, /* pc_relative */
213 complain_overflow_signed
, /* complain_on_overflow */
214 special
, /* special_function */
215 "R_H8_PCREL8", /* name */
216 false, /* partial_inplace */
219 true), /* pcrel_offset */
222 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
226 bfd_reloc_code_real_type bfd_reloc_val
;
227 unsigned char howto_index
;
230 /* An array mapping BFD reloc codes to SH ELF relocs. */
232 static const struct elf_reloc_map h8_reloc_map
[] =
234 { BFD_RELOC_NONE
, R_H8_NONE_X
},
235 { BFD_RELOC_32
, R_H8_DIR32_X
},
236 { BFD_RELOC_16
, R_H8_DIR16_X
},
237 { BFD_RELOC_8
, R_H8_DIR8_X
},
238 { BFD_RELOC_H8_DIR16A8
, R_H8_DIR16A8_X
},
239 { BFD_RELOC_H8_DIR16R8
, R_H8_DIR16R8_X
},
240 { BFD_RELOC_H8_DIR24A8
, R_H8_DIR24A8_X
},
241 { BFD_RELOC_H8_DIR24R8
, R_H8_DIR24R8_X
},
242 { BFD_RELOC_H8_DIR32A16
, R_H8_DIR32A16_X
},
243 { BFD_RELOC_16_PCREL
, R_H8_PCREL16_X
},
244 { BFD_RELOC_8_PCREL
, R_H8_PCREL8_X
},
248 static reloc_howto_type
*
249 elf32_h8_reloc_type_lookup (abfd
, code
)
250 bfd
*abfd ATTRIBUTE_UNUSED
;
251 bfd_reloc_code_real_type code
;
255 for (i
= 0; i
< sizeof (h8_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
257 if (h8_reloc_map
[i
].bfd_reloc_val
== code
)
258 return &h8_elf_howto_table
[(int) h8_reloc_map
[i
].howto_index
];
264 elf32_h8_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
265 bfd
*abfd ATTRIBUTE_UNUSED
;
267 Elf32_Internal_Rela
*elf_reloc
;
272 r
= ELF32_R_TYPE (elf_reloc
->r_info
);
273 for (i
= 0; i
< sizeof (h8_elf_howto_table
) / sizeof (reloc_howto_type
); i
++)
274 if (h8_elf_howto_table
[i
].type
== r
)
276 bfd_reloc
->howto
= &h8_elf_howto_table
[i
];
283 elf32_h8_info_to_howto_rel (abfd
, bfd_reloc
, elf_reloc
)
284 bfd
*abfd ATTRIBUTE_UNUSED
;
286 Elf32_Internal_Rel
*elf_reloc ATTRIBUTE_UNUSED
;
291 r
= ELF32_R_TYPE (elf_reloc
->r_info
);
292 bfd_reloc
->howto
= &h8_elf_howto_table
[r
];
295 /* Special handling for H8/300 relocs.
296 We only come here for pcrel stuff and return normally if not an -r link.
297 When doing -r, we can't do any arithmetic for the pcrel stuff, because
298 we support relaxing on the H8/300 series chips. */
299 static bfd_reloc_status_type
300 special (abfd
, reloc_entry
, symbol
, data
, input_section
, output_bfd
,
302 bfd
*abfd ATTRIBUTE_UNUSED
;
303 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
304 asymbol
*symbol ATTRIBUTE_UNUSED
;
305 PTR data ATTRIBUTE_UNUSED
;
306 asection
*input_section ATTRIBUTE_UNUSED
;
308 char **error_message ATTRIBUTE_UNUSED
;
310 if (output_bfd
== (bfd
*) NULL
)
311 return bfd_reloc_continue
;
313 /* Adjust the reloc address to that in the output section. */
314 reloc_entry
->address
+= input_section
->output_offset
;
318 /* Perform a relocation as part of a final link. */
319 static bfd_reloc_status_type
320 elf32_h8_final_link_relocate (r_type
, input_bfd
, output_bfd
,
321 input_section
, contents
, offset
, value
,
322 addend
, info
, sym_sec
, is_local
)
323 unsigned long r_type
;
325 bfd
*output_bfd ATTRIBUTE_UNUSED
;
326 asection
*input_section ATTRIBUTE_UNUSED
;
331 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
332 asection
*sym_sec ATTRIBUTE_UNUSED
;
333 int is_local ATTRIBUTE_UNUSED
;
335 bfd_byte
*hit_data
= contents
+ offset
;
347 bfd_put_32 (input_bfd
, value
, hit_data
);
354 bfd_put_16 (input_bfd
, value
, hit_data
);
361 bfd_put_8 (input_bfd
, value
, hit_data
);
367 /* HIT_DATA is the address for the first byte for the relocated
368 value. Subtract 1 so that we can manipulate the data in 32bit
372 /* Clear out the top byte in value. */
375 /* Retrieve the type byte for value from the section contents. */
376 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xff000000);
378 /* Now scribble it out in one 32bit hunk. */
379 bfd_put_32 (input_bfd
, value
, hit_data
);
383 value
-= (input_section
->output_section
->vma
384 + input_section
->output_offset
);
388 /* The value is relative to the start of the instruction,
389 not the relocation offset. Subtract 2 to account for
393 bfd_put_16 (input_bfd
, value
, hit_data
);
397 value
-= (input_section
->output_section
->vma
398 + input_section
->output_offset
);
402 /* The value is relative to the start of the instruction,
403 not the relocation offset. Subtract 1 to account for
407 bfd_put_8 (input_bfd
, value
, hit_data
);
411 return bfd_reloc_notsupported
;
415 /* Relocate an H8 ELF section. */
417 elf32_h8_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
418 contents
, relocs
, local_syms
, local_sections
)
420 struct bfd_link_info
*info
;
422 asection
*input_section
;
424 Elf_Internal_Rela
*relocs
;
425 Elf_Internal_Sym
*local_syms
;
426 asection
**local_sections
;
428 Elf_Internal_Shdr
*symtab_hdr
;
429 struct elf_link_hash_entry
**sym_hashes
;
430 Elf_Internal_Rela
*rel
, *relend
;
432 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
433 sym_hashes
= elf_sym_hashes (input_bfd
);
436 relend
= relocs
+ input_section
->reloc_count
;
437 for (; rel
< relend
; rel
++)
440 unsigned long r_symndx
;
441 Elf_Internal_Sym
*sym
;
443 struct elf_link_hash_entry
*h
;
445 bfd_reloc_status_type r
;
447 r_symndx
= ELF32_R_SYM (rel
->r_info
);
448 r_type
= ELF32_R_TYPE (rel
->r_info
);
450 if (info
->relocateable
)
452 /* This is a relocateable link. We don't have to change
453 anything, unless the reloc is against a section symbol,
454 in which case we have to adjust according to where the
455 section symbol winds up in the output section. */
456 if (r_symndx
< symtab_hdr
->sh_info
)
458 sym
= local_syms
+ r_symndx
;
459 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
461 sec
= local_sections
[r_symndx
];
462 rel
->r_addend
+= sec
->output_offset
+ sym
->st_value
;
469 /* This is a final link. */
473 if (r_symndx
< symtab_hdr
->sh_info
)
475 sym
= local_syms
+ r_symndx
;
476 sec
= local_sections
[r_symndx
];
477 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
481 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
482 while (h
->root
.type
== bfd_link_hash_indirect
483 || h
->root
.type
== bfd_link_hash_warning
)
484 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
485 if (h
->root
.type
== bfd_link_hash_defined
486 || h
->root
.type
== bfd_link_hash_defweak
)
488 sec
= h
->root
.u
.def
.section
;
489 relocation
= (h
->root
.u
.def
.value
490 + sec
->output_section
->vma
491 + sec
->output_offset
);
493 else if (h
->root
.type
== bfd_link_hash_undefweak
)
497 if (! ((*info
->callbacks
->undefined_symbol
)
498 (info
, h
->root
.root
.string
, input_bfd
,
499 input_section
, rel
->r_offset
, true)))
505 r
= elf32_h8_final_link_relocate (r_type
, input_bfd
, output_bfd
,
507 contents
, rel
->r_offset
,
508 relocation
, rel
->r_addend
,
509 info
, sec
, h
== NULL
);
511 if (r
!= bfd_reloc_ok
)
514 const char *msg
= (const char *) 0;
516 reloc_howto_type
*howto
;
518 elf32_h8_info_to_howto (input_bfd
, &bfd_reloc
, rel
);
519 howto
= bfd_reloc
.howto
;
522 name
= h
->root
.root
.string
;
525 name
= (bfd_elf_string_from_elf_section
526 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
527 if (name
== NULL
|| *name
== '\0')
528 name
= bfd_section_name (input_bfd
, sec
);
533 case bfd_reloc_overflow
:
534 if (! ((*info
->callbacks
->reloc_overflow
)
535 (info
, name
, howto
->name
, (bfd_vma
) 0,
536 input_bfd
, input_section
, rel
->r_offset
)))
540 case bfd_reloc_undefined
:
541 if (! ((*info
->callbacks
->undefined_symbol
)
542 (info
, name
, input_bfd
, input_section
,
543 rel
->r_offset
, true)))
547 case bfd_reloc_outofrange
:
548 msg
= _("internal error: out of range error");
551 case bfd_reloc_notsupported
:
552 msg
= _("internal error: unsupported relocation error");
555 case bfd_reloc_dangerous
:
556 msg
= _("internal error: dangerous error");
560 msg
= _("internal error: unknown error");
564 if (!((*info
->callbacks
->warning
)
565 (info
, msg
, name
, input_bfd
, input_section
,
576 /* Object files encode the specific H8 model they were compiled
577 for in the ELF flags field.
579 Examine that field and return the proper BFD machine type for
582 elf32_h8_mach (flags
)
585 switch (flags
& EF_H8_MACH
)
587 case E_H8_MACH_H8300
:
589 return bfd_mach_h8300
;
591 case E_H8_MACH_H8300H
:
592 return bfd_mach_h8300h
;
594 case E_H8_MACH_H8300S
:
595 return bfd_mach_h8300s
;
599 /* The final processing done just before writing out a H8 ELF object
600 file. We use this opportunity to encode the BFD machine type
601 into the flags field in the object file. */
604 elf32_h8_final_write_processing (abfd
, linker
)
606 boolean linker ATTRIBUTE_UNUSED
;
610 switch (bfd_get_mach (abfd
))
614 val
= E_H8_MACH_H8300
;
617 case bfd_mach_h8300h
:
618 val
= E_H8_MACH_H8300H
;
621 case bfd_mach_h8300s
:
622 val
= E_H8_MACH_H8300S
;
626 elf_elfheader (abfd
)->e_flags
&= ~ (EF_H8_MACH
);
627 elf_elfheader (abfd
)->e_flags
|= val
;
630 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
631 record the encoded machine type found in the ELF flags. */
634 elf32_h8_object_p (abfd
)
637 bfd_default_set_arch_mach (abfd
, bfd_arch_h8300
,
638 elf32_h8_mach (elf_elfheader (abfd
)->e_flags
));
642 /* Merge backend specific data from an object file to the output
643 object file when linking. The only data we need to copy at this
644 time is the architecture/machine information. */
647 elf32_h8_merge_private_bfd_data (ibfd
, obfd
)
651 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
652 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
655 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
656 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
658 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
659 bfd_get_mach (ibfd
)))
666 /* This function handles relaxing for the H8..
668 There's a few relaxing opportunites available on the H8:
670 jmp/jsr:24 -> bra/bsr:8 2 bytes
671 The jmp may be completely eliminated if the previous insn is a
672 conditional branch to the insn after the jump. In that case
673 we invert the branch and delete the jump and save 4 bytes.
675 bCC:16 -> bCC:8 2 bytes
676 bsr:16 -> bsr:8 2 bytes
678 mov.b:16 -> mov.b:8 2 bytes
679 mov.b:24/32 -> mov.b:8 4 bytes
681 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
684 elf32_h8_relax_section (abfd
, sec
, link_info
, again
)
687 struct bfd_link_info
*link_info
;
690 Elf_Internal_Shdr
*symtab_hdr
;
691 Elf_Internal_Shdr
*shndx_hdr
;
692 Elf_Internal_Rela
*internal_relocs
;
693 Elf_Internal_Rela
*free_relocs
= NULL
;
694 Elf_Internal_Rela
*irel
, *irelend
;
695 bfd_byte
*contents
= NULL
;
696 bfd_byte
*free_contents
= NULL
;
697 Elf32_External_Sym
*extsyms
= NULL
;
698 Elf32_External_Sym
*free_extsyms
= NULL
;
699 Elf_External_Sym_Shndx
*shndx_buf
= 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
;
721 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
723 /* Get a copy of the native relocations. */
724 internal_relocs
= (_bfd_elf32_link_read_relocs
725 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
726 link_info
->keep_memory
));
727 if (internal_relocs
== NULL
)
729 if (! link_info
->keep_memory
)
730 free_relocs
= internal_relocs
;
732 if (sec
!= last_input_section
)
735 last_input_section
= sec
;
737 /* Walk through the relocs looking for relaxing opportunities. */
738 irelend
= internal_relocs
+ sec
->reloc_count
;
739 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
743 /* Keep track of the previous reloc so that we can delete
744 some long jumps created by the compiler. */
745 if (irel
!= internal_relocs
)
746 last_reloc
= irel
- 1;
748 if (ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR24R8
749 && ELF32_R_TYPE (irel
->r_info
) != R_H8_PCREL16
750 && ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR16A8
751 && ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR24A8
752 && ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR32A16
)
755 /* Get the section contents if we haven't done so already. */
756 if (contents
== NULL
)
758 /* Get cached copy if it exists. */
759 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
760 contents
= elf_section_data (sec
)->this_hdr
.contents
;
763 /* Go get them off disk. */
764 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
765 if (contents
== NULL
)
767 free_contents
= contents
;
769 if (! bfd_get_section_contents (abfd
, sec
, contents
,
770 (file_ptr
) 0, sec
->_raw_size
))
775 /* Read this BFD's local symbols if we haven't done so already. */
778 /* Get cached copy if it exists. */
779 if (symtab_hdr
->contents
!= NULL
)
780 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
783 /* Go get them off disk. */
786 amt
= symtab_hdr
->sh_info
* sizeof (Elf32_External_Sym
);
787 extsyms
= (Elf32_External_Sym
*) bfd_malloc (amt
);
790 free_extsyms
= extsyms
;
791 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
792 || bfd_bread ((PTR
) extsyms
, amt
, abfd
) != amt
)
794 symtab_hdr
->contents
= (PTR
) extsyms
;
797 if (shndx_hdr
->sh_size
!= 0)
801 amt
= symtab_hdr
->sh_info
* sizeof (Elf_External_Sym_Shndx
);
802 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
803 if (shndx_buf
== NULL
)
805 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
806 || bfd_bread ((PTR
) shndx_buf
, amt
, abfd
) != amt
)
808 shndx_hdr
->contents
= (PTR
) shndx_buf
;
812 /* Get the value of the symbol referred to by the reloc. */
813 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
815 Elf32_External_Sym
*esym
;
816 Elf_External_Sym_Shndx
*shndx
;
817 Elf_Internal_Sym isym
;
820 /* A local symbol. */
821 esym
= extsyms
+ ELF32_R_SYM (irel
->r_info
);
822 shndx
= shndx_buf
+ (shndx_buf
? ELF32_R_SYM (irel
->r_info
) : 0);
823 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
, (const PTR
) shndx
,
826 sym_sec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
827 symval
= (isym
.st_value
828 + sym_sec
->output_section
->vma
829 + sym_sec
->output_offset
);
834 struct elf_link_hash_entry
*h
;
836 /* An external symbol. */
837 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
838 h
= elf_sym_hashes (abfd
)[indx
];
839 BFD_ASSERT (h
!= NULL
);
840 if (h
->root
.type
!= bfd_link_hash_defined
841 && h
->root
.type
!= bfd_link_hash_defweak
)
843 /* This appears to be a reference to an undefined
844 symbol. Just ignore it--it will be caught by the
845 regular reloc processing. */
849 symval
= (h
->root
.u
.def
.value
850 + h
->root
.u
.def
.section
->output_section
->vma
851 + h
->root
.u
.def
.section
->output_offset
);
854 /* For simplicity of coding, we are going to modify the section
855 contents, the section relocs, and the BFD symbol table. We
856 must tell the rest of the code not to free up this
857 information. It would be possible to instead create a table
858 of changes which have to be made, as is done in coff-mips.c;
859 that would be more work, but would require less memory when
860 the linker is run. */
861 switch (ELF32_R_TYPE (irel
->r_info
))
863 /* Try to turn a 24 bit absolute branch/call into an 8 bit
864 pc-relative branch/call. */
867 bfd_vma value
= symval
+ irel
->r_addend
;
870 /* Get the address of this instruction. */
871 dot
= (sec
->output_section
->vma
872 + sec
->output_offset
+ irel
->r_offset
- 1);
874 /* Compute the distance from this insn to the branch target. */
877 /* If the distance is within -126..+130 inclusive, then we can
878 relax this jump. +130 is valid since the target will move
879 two bytes closer if we do relax this branch. */
880 if ((int) gap
>= -126 && (int) gap
<= 130)
884 /* Note that we've changed the relocs, section contents,
886 elf_section_data (sec
)->relocs
= internal_relocs
;
889 elf_section_data (sec
)->this_hdr
.contents
= contents
;
890 free_contents
= NULL
;
894 /* If the previous instruction conditionally jumped around
895 this instruction, we may be able to reverse the condition
896 and redirect the previous instruction to the target of
899 Such sequences are used by the compiler to deal with
900 long conditional branches. */
904 && ELF32_R_TYPE (last_reloc
->r_info
) == R_H8_PCREL8
905 && ELF32_R_SYM (last_reloc
->r_info
) < symtab_hdr
->sh_info
)
907 Elf32_External_Sym
*esym
;
908 Elf_External_Sym_Shndx
*shndx
;
910 asection
*last_sym_sec
;
911 Elf_Internal_Sym last_symbol
;
913 /* We will need to examine the symbol used by the
914 previous relocation. */
916 esym
= extsyms
+ ELF32_R_SYM (last_reloc
->r_info
);
919 shndx
+= ELF32_R_SYM (last_reloc
->r_info
);
920 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
,
925 = bfd_section_from_elf_index (abfd
, last_symbol
.st_shndx
);
926 last_value
= (last_symbol
.st_value
927 + last_sym_sec
->output_section
->vma
928 + last_sym_sec
->output_offset
);
930 /* Verify that the previous relocation was for a
931 branch around this instruction and that no symbol
932 exists at the current location. */
933 if (last_value
== dot
+ 4
934 && last_reloc
->r_offset
+ 2 == irel
->r_offset
935 && ! elf32_h8_symbol_address_p (abfd
, sec
, dot
))
937 /* We can eliminate this jump. Twiddle the
938 previous relocation as necessary. */
940 = ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
941 ELF32_R_TYPE (R_H8_NONE
));
944 = ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
945 ELF32_R_TYPE (R_H8_PCREL8
));
946 last_reloc
->r_addend
= irel
->r_addend
;
949 code
= bfd_get_8 (abfd
,
950 contents
+ last_reloc
->r_offset
- 1);
954 contents
+ last_reloc
->r_offset
- 1);
956 /* Delete four bytes of data. */
957 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
967 /* We could not eliminate this jump, so just shorten it. */
968 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
971 bfd_put_8 (abfd
, 0x55, contents
+ irel
->r_offset
- 1);
972 else if (code
== 0x5a)
973 bfd_put_8 (abfd
, 0x40, contents
+ irel
->r_offset
- 1);
977 /* Fix the relocation's type. */
978 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
981 /* Delete two bytes of data. */
982 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
983 irel
->r_offset
+ 1, 2))
986 /* That will change things, so, we should relax again.
987 Note that this is not required, and it may be slow. */
993 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
997 bfd_vma value
= symval
+ irel
->r_addend
;
1001 /* Get the address of this instruction. */
1002 dot
= (sec
->output_section
->vma
1003 + sec
->output_offset
1004 + irel
->r_offset
- 2);
1008 /* If the distance is within -126..+130 inclusive, then we can
1009 relax this jump. +130 is valid since the target will move
1010 two bytes closer if we do relax this branch. */
1011 if ((int)gap
>= -126 && (int)gap
<= 130)
1015 /* Note that we've changed the relocs, section contents,
1017 elf_section_data (sec
)->relocs
= internal_relocs
;
1020 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1021 free_contents
= NULL
;
1023 free_extsyms
= NULL
;
1025 /* Get the opcode. */
1026 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
1030 /* bCC:16 -> bCC:8 */
1031 /* Get the condition code from the original insn. */
1032 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1036 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
1038 else if (code
== 0x5c)
1039 bfd_put_8 (abfd
, 0x55, contents
+ irel
->r_offset
- 2);
1043 /* Fix the relocation's type. */
1044 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1048 /* Delete two bytes of data. */
1049 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
1050 irel
->r_offset
+ 1, 2))
1053 /* That will change things, so, we should relax again.
1054 Note that this is not required, and it may be slow. */
1060 /* This is a 16 bit absolute address in a "mov.b" insn, which may
1061 become an 8 bit absolute address if its in the right range. */
1064 bfd_vma value
= symval
+ irel
->r_addend
;
1066 if ((bfd_get_mach (abfd
) == bfd_mach_h8300
1069 || ((bfd_get_mach (abfd
) == bfd_mach_h8300h
1070 || bfd_get_mach (abfd
) == bfd_mach_h8300s
)
1071 && value
>= 0xffff00
1072 && value
<= 0xffffff))
1076 /* Note that we've changed the relocs, section contents,
1078 elf_section_data (sec
)->relocs
= internal_relocs
;
1081 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1082 free_contents
= NULL
;
1084 free_extsyms
= NULL
;
1086 /* Get the opcode. */
1087 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
1093 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1095 if ((code
& 0xf0) == 0x00)
1097 (code
& 0xf) | 0x20,
1098 contents
+ irel
->r_offset
- 2);
1099 else if ((code
& 0xf0) == 0x80)
1101 (code
& 0xf) | 0x30,
1102 contents
+ irel
->r_offset
- 2);
1106 /* Fix the relocation's type. */
1107 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1110 /* Delete two bytes of data. */
1111 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
1112 irel
->r_offset
+ 1, 2))
1115 /* That will change things, so, we should relax again.
1116 Note that this is not required, and it may be slow. */
1122 /* This is a 24 bit absolute address in a "mov.b" insn, which may
1123 become an 8 bit absolute address if its in the right range. */
1126 bfd_vma value
= symval
+ irel
->r_addend
;
1128 if ((bfd_get_mach (abfd
) == bfd_mach_h8300
1131 || ((bfd_get_mach (abfd
) == bfd_mach_h8300h
1132 || bfd_get_mach (abfd
) == bfd_mach_h8300s
)
1133 && value
>= 0xffff00
1134 && value
<= 0xffffff))
1138 /* Note that we've changed the relocs, section contents,
1140 elf_section_data (sec
)->relocs
= internal_relocs
;
1143 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1144 free_contents
= NULL
;
1146 free_extsyms
= NULL
;
1148 /* Get the opcode. */
1149 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
1155 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1157 if ((code
& 0xf0) == 0x00)
1159 (code
& 0xf) | 0x20,
1160 contents
+ irel
->r_offset
- 2);
1161 else if ((code
& 0xf0) == 0x80)
1163 (code
& 0xf) | 0x30,
1164 contents
+ irel
->r_offset
- 2);
1168 /* Fix the relocation's type. */
1169 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1172 /* Delete two bytes of data. */
1173 if (!elf32_h8_relax_delete_bytes (abfd
, sec
, irel
->r_offset
, 2))
1176 /* That will change things, so, we should relax again.
1177 Note that this is not required, and it may be slow. */
1184 /* This is a 24/32bit absolute address in a "mov" insn, which may
1185 become a 16bit absoulte address if it is in the right range. */
1188 bfd_vma value
= symval
+ irel
->r_addend
;
1190 if (value
<= 0x7fff || value
>= 0xff8000)
1194 /* Note that we've changed the relocs, section contents,
1196 elf_section_data (sec
)->relocs
= internal_relocs
;
1199 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1200 free_contents
= NULL
;
1202 free_extsyms
= NULL
;
1204 /* Get the opcode. */
1205 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1207 /* We just need to turn off bit 0x20. */
1210 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
1212 /* Fix the relocation's type. */
1213 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1216 /* Delete two bytes of data. */
1217 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
1218 irel
->r_offset
+ 1, 2))
1221 /* That will change things, so, we should relax again.
1222 Note that this is not required, and it may be slow. */
1233 if (free_relocs
!= NULL
)
1239 if (free_contents
!= NULL
)
1241 if (! link_info
->keep_memory
)
1242 free (free_contents
);
1245 /* Cache the section contents for elf_link_input_bfd. */
1246 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1248 free_contents
= NULL
;
1251 if (shndx_buf
!= NULL
)
1253 shndx_hdr
->contents
= NULL
;
1257 if (free_extsyms
!= NULL
)
1259 if (! link_info
->keep_memory
)
1261 symtab_hdr
->contents
= NULL
;
1262 free (free_extsyms
);
1269 if (free_relocs
!= NULL
)
1271 if (free_contents
!= NULL
)
1272 free (free_contents
);
1273 if (shndx_buf
!= NULL
)
1275 shndx_hdr
->contents
= NULL
;
1278 if (free_extsyms
!= NULL
)
1280 symtab_hdr
->contents
= NULL
;
1281 free (free_extsyms
);
1286 /* Delete some bytes from a section while relaxing. */
1289 elf32_h8_relax_delete_bytes (abfd
, sec
, addr
, count
)
1295 Elf_Internal_Shdr
*symtab_hdr
;
1296 Elf_Internal_Shdr
*shndx_hdr
;
1297 Elf32_External_Sym
*extsyms
;
1298 unsigned int sec_shndx
;
1300 Elf_Internal_Rela
*irel
, *irelend
;
1301 Elf_Internal_Rela
*irelalign
;
1303 Elf32_External_Sym
*esym
, *esymend
;
1304 Elf_External_Sym_Shndx
*shndx
;
1305 struct elf_link_hash_entry
**sym_hashes
;
1306 struct elf_link_hash_entry
**end_hashes
;
1307 unsigned int symcount
;
1309 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1310 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1312 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1314 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1316 /* The deletion must stop at the next ALIGN reloc for an aligment
1317 power larger than the number of bytes we are deleting. */
1320 toaddr
= sec
->_cooked_size
;
1322 irel
= elf_section_data (sec
)->relocs
;
1323 irelend
= irel
+ sec
->reloc_count
;
1325 /* Actually delete the bytes. */
1326 memmove (contents
+ addr
, contents
+ addr
+ count
,
1327 (size_t) (toaddr
- addr
- count
));
1328 sec
->_cooked_size
-= count
;
1330 /* Adjust all the relocs. */
1331 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1333 /* Get the new reloc address. */
1334 if ((irel
->r_offset
> addr
1335 && irel
->r_offset
< toaddr
))
1336 irel
->r_offset
-= count
;
1339 /* Adjust the local symbols defined in this section. */
1340 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1341 shndx
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
1343 esymend
= esym
+ symtab_hdr
->sh_info
;
1344 for (; esym
< esymend
; esym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
1346 Elf_Internal_Sym isym
;
1347 Elf_External_Sym_Shndx dummy
;
1349 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
, (const PTR
) shndx
,
1352 if (isym
.st_shndx
== sec_shndx
1353 && isym
.st_value
> addr
1354 && isym
.st_value
< toaddr
)
1356 isym
.st_value
-= count
;
1357 bfd_elf32_swap_symbol_out (abfd
, &isym
, esym
, &dummy
);
1361 /* Now adjust the global symbols defined in this section. */
1362 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1363 - symtab_hdr
->sh_info
);
1364 sym_hashes
= elf_sym_hashes (abfd
);
1365 end_hashes
= sym_hashes
+ symcount
;
1366 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1368 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1369 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1370 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1371 && sym_hash
->root
.u
.def
.section
== sec
1372 && sym_hash
->root
.u
.def
.value
> addr
1373 && sym_hash
->root
.u
.def
.value
< toaddr
)
1375 sym_hash
->root
.u
.def
.value
-= count
;
1382 /* Return true if a symbol exists at the given address, else return
1385 elf32_h8_symbol_address_p (abfd
, sec
, addr
)
1390 Elf_Internal_Shdr
*symtab_hdr
;
1391 Elf_Internal_Shdr
*shndx_hdr
;
1392 unsigned int sec_shndx
;
1393 Elf32_External_Sym
*esym
, *esymend
;
1394 Elf_External_Sym_Shndx
*shndx
;
1395 struct elf_link_hash_entry
**sym_hashes
;
1396 struct elf_link_hash_entry
**end_hashes
;
1397 unsigned int symcount
;
1399 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1401 /* Examine all the symbols. */
1402 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1403 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1404 shndx
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
1405 esym
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1406 esymend
= esym
+ symtab_hdr
->sh_info
;
1407 for (; esym
< esymend
; esym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
1409 Elf_Internal_Sym isym
;
1411 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
, (const PTR
) shndx
,
1414 if (isym
.st_shndx
== sec_shndx
1415 && isym
.st_value
== addr
)
1419 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1420 - symtab_hdr
->sh_info
);
1421 sym_hashes
= elf_sym_hashes (abfd
);
1422 end_hashes
= sym_hashes
+ symcount
;
1423 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1425 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1426 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1427 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1428 && sym_hash
->root
.u
.def
.section
== sec
1429 && sym_hash
->root
.u
.def
.value
== addr
)
1436 /* This is a version of bfd_generic_get_relocated_section_contents
1437 which uses elf32_h8_relocate_section. */
1440 elf32_h8_get_relocated_section_contents (output_bfd
, link_info
, link_order
,
1441 data
, relocateable
, symbols
)
1443 struct bfd_link_info
*link_info
;
1444 struct bfd_link_order
*link_order
;
1446 boolean relocateable
;
1449 Elf_Internal_Shdr
*symtab_hdr
;
1450 Elf_Internal_Shdr
*shndx_hdr
;
1451 asection
*input_section
= link_order
->u
.indirect
.section
;
1452 bfd
*input_bfd
= input_section
->owner
;
1453 asection
**sections
= NULL
;
1454 Elf_Internal_Rela
*internal_relocs
= NULL
;
1455 Elf32_External_Sym
*external_syms
= NULL
;
1456 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1457 Elf_External_Sym_Shndx
*shndx
;
1458 Elf_Internal_Sym
*internal_syms
= NULL
;
1460 /* We only need to handle the case of relaxing, or of having a
1461 particular set of section contents, specially. */
1463 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1464 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1469 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1470 shndx_hdr
= &elf_tdata (input_bfd
)->symtab_shndx_hdr
;
1472 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1473 (size_t) input_section
->_raw_size
);
1475 if ((input_section
->flags
& SEC_RELOC
) != 0
1476 && input_section
->reloc_count
> 0)
1478 Elf_Internal_Sym
*isymp
;
1480 Elf32_External_Sym
*esym
, *esymend
;
1483 if (symtab_hdr
->contents
!= NULL
)
1484 external_syms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1485 else if (symtab_hdr
->sh_info
!= 0)
1487 amt
= symtab_hdr
->sh_info
;
1488 amt
*= sizeof (Elf32_External_Sym
);
1489 external_syms
= (Elf32_External_Sym
*) bfd_malloc (amt
);
1490 if (external_syms
== NULL
)
1492 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1493 || bfd_bread ((PTR
) external_syms
, amt
, input_bfd
) != amt
)
1497 if (symtab_hdr
->sh_info
!= 0 && shndx_hdr
->sh_size
!= 0)
1499 amt
= symtab_hdr
->sh_info
;
1500 amt
*= sizeof (Elf_External_Sym_Shndx
);
1501 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1502 if (shndx_buf
== NULL
)
1504 if (bfd_seek (input_bfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1505 || bfd_bread ((PTR
) shndx_buf
, amt
, input_bfd
) != amt
)
1509 internal_relocs
= (_bfd_elf32_link_read_relocs
1510 (input_bfd
, input_section
, (PTR
) NULL
,
1511 (Elf_Internal_Rela
*) NULL
, false));
1512 if (internal_relocs
== NULL
)
1515 amt
= symtab_hdr
->sh_info
;
1516 amt
*= sizeof (Elf_Internal_Sym
);
1517 internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
1518 if (internal_syms
== NULL
&& amt
!= 0)
1521 amt
= symtab_hdr
->sh_info
;
1522 amt
*= sizeof (asection
*);
1523 sections
= (asection
**) bfd_malloc (amt
);
1524 if (sections
== NULL
&& amt
!= 0)
1527 for (isymp
= internal_syms
, secpp
= sections
, shndx
= shndx_buf
,
1528 esym
= external_syms
, esymend
= esym
+ symtab_hdr
->sh_info
;
1530 ++esym
, ++isymp
, ++secpp
, shndx
= (shndx
? shndx
+ 1 : NULL
))
1534 bfd_elf32_swap_symbol_in (input_bfd
, (const PTR
) esym
,
1535 (const PTR
) shndx
, isymp
);
1537 if (isymp
->st_shndx
== SHN_UNDEF
)
1538 isec
= bfd_und_section_ptr
;
1539 else if (isymp
->st_shndx
== SHN_ABS
)
1540 isec
= bfd_abs_section_ptr
;
1541 else if (isymp
->st_shndx
== SHN_COMMON
)
1542 isec
= bfd_com_section_ptr
;
1544 isec
= bfd_section_from_elf_index (input_bfd
, isymp
->st_shndx
);
1549 if (! elf32_h8_relocate_section (output_bfd
, link_info
, input_bfd
,
1550 input_section
, data
, internal_relocs
,
1551 internal_syms
, sections
))
1554 if (sections
!= NULL
)
1556 if (internal_syms
!= NULL
)
1557 free (internal_syms
);
1558 if (shndx_buf
!= NULL
)
1560 if (external_syms
!= NULL
&& symtab_hdr
->contents
== NULL
)
1561 free (external_syms
);
1562 if (internal_relocs
!= elf_section_data (input_section
)->relocs
)
1563 free (internal_relocs
);
1569 if (internal_relocs
!= NULL
1570 && internal_relocs
!= elf_section_data (input_section
)->relocs
)
1571 free (internal_relocs
);
1572 if (shndx_buf
!= NULL
)
1574 if (external_syms
!= NULL
&& symtab_hdr
->contents
== NULL
)
1575 free (external_syms
);
1576 if (internal_syms
!= NULL
)
1577 free (internal_syms
);
1578 if (sections
!= NULL
)
1584 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1585 #define TARGET_BIG_NAME "elf32-h8300"
1586 #define ELF_ARCH bfd_arch_h8300
1587 #define ELF_MACHINE_CODE EM_H8_300
1588 #define ELF_MAXPAGESIZE 0x1
1589 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1590 #define elf_info_to_howto elf32_h8_info_to_howto
1591 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1593 /* So we can set/examine bits in e_flags to get the specific
1594 H8 architecture in use. */
1595 #define elf_backend_final_write_processing \
1596 elf32_h8_final_write_processing
1597 #define elf_backend_object_p \
1599 #define bfd_elf32_bfd_merge_private_bfd_data \
1600 elf32_h8_merge_private_bfd_data
1602 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1603 defaults to using _bfd_generic_link_hash_table_create, but
1604 elflink.h:bfd_elf32_size_dynamic_sections uses
1605 dynobj = elf_hash_table (info)->dynobj;
1606 and thus requires an elf hash table. */
1607 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1609 /* Use an H8 specific linker, not the ELF generic linker. */
1610 #define elf_backend_relocate_section elf32_h8_relocate_section
1612 /* And relaxing stuff. */
1613 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1614 #define bfd_elf32_bfd_get_relocated_section_contents \
1615 elf32_h8_get_relocated_section_contents
1618 #include "elf32-target.h"