1 /* BFD back-end for Renesas H8/300 ELF binaries.
2 Copyright 1993, 1995, 1998, 1999, 2001, 2002, 2003
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
*, Elf_Internal_Rela
*));
33 static unsigned long elf32_h8_mach
35 static void elf32_h8_final_write_processing
36 PARAMS ((bfd
*, bfd_boolean
));
37 static bfd_boolean elf32_h8_object_p
39 static bfd_boolean elf32_h8_merge_private_bfd_data
40 PARAMS ((bfd
*, bfd
*));
41 static bfd_boolean elf32_h8_relax_section
42 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*));
43 static bfd_boolean elf32_h8_relax_delete_bytes
44 PARAMS ((bfd
*, asection
*, bfd_vma
, int));
45 static bfd_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
*, bfd_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 bfd_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
[] = {
66 HOWTO (R_H8_NONE
, /* type */
68 0, /* size (0 = byte, 1 = short, 2 = long) */
70 FALSE
, /* pc_relative */
72 complain_overflow_dont
, /* complain_on_overflow */
73 special
, /* special_function */
74 "R_H8_NONE", /* name */
75 FALSE
, /* partial_inplace */
78 FALSE
), /* pcrel_offset */
79 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
80 HOWTO (R_H8_DIR32
, /* type */
82 2, /* size (0 = byte, 1 = short, 2 = long) */
84 FALSE
, /* pc_relative */
86 complain_overflow_dont
, /* complain_on_overflow */
87 special
, /* special_function */
88 "R_H8_DIR32", /* name */
89 FALSE
, /* partial_inplace */
91 0xffffffff, /* dst_mask */
92 FALSE
), /* pcrel_offset */
93 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
94 HOWTO (R_H8_DIR16
, /* type */
96 1, /* size (0 = byte, 1 = short, 2 = long) */
98 FALSE
, /* pc_relative */
100 complain_overflow_dont
, /* complain_on_overflow */
101 special
, /* special_function */
102 "R_H8_DIR16", /* name */
103 FALSE
, /* partial_inplace */
105 0x0000ffff, /* dst_mask */
106 FALSE
), /* pcrel_offset */
107 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
108 HOWTO (R_H8_DIR8
, /* type */
110 0, /* size (0 = byte, 1 = short, 2 = long) */
112 FALSE
, /* pc_relative */
114 complain_overflow_dont
, /* complain_on_overflow */
115 special
, /* special_function */
116 "R_H8_DIR16", /* name */
117 FALSE
, /* partial_inplace */
119 0x000000ff, /* dst_mask */
120 FALSE
), /* pcrel_offset */
121 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
122 HOWTO (R_H8_DIR16A8
, /* type */
124 1, /* size (0 = byte, 1 = short, 2 = long) */
126 FALSE
, /* pc_relative */
128 complain_overflow_bitfield
, /* complain_on_overflow */
129 special
, /* special_function */
130 "R_H8_DIR16A8", /* name */
131 FALSE
, /* partial_inplace */
133 0x0000ffff, /* dst_mask */
134 FALSE
), /* pcrel_offset */
135 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
136 HOWTO (R_H8_DIR16R8
, /* type */
138 1, /* size (0 = byte, 1 = short, 2 = long) */
140 FALSE
, /* pc_relative */
142 complain_overflow_bitfield
, /* complain_on_overflow */
143 special
, /* special_function */
144 "R_H8_DIR16R8", /* name */
145 FALSE
, /* partial_inplace */
147 0x0000ffff, /* dst_mask */
148 FALSE
), /* pcrel_offset */
149 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
150 HOWTO (R_H8_DIR24A8
, /* type */
152 2, /* size (0 = byte, 1 = short, 2 = long) */
154 FALSE
, /* pc_relative */
156 complain_overflow_bitfield
, /* complain_on_overflow */
157 special
, /* special_function */
158 "R_H8_DIR24A8", /* name */
159 TRUE
, /* partial_inplace */
160 0xff000000, /* src_mask */
161 0x00ffffff, /* dst_mask */
162 FALSE
), /* pcrel_offset */
163 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
164 HOWTO (R_H8_DIR24R8
, /* type */
166 2, /* size (0 = byte, 1 = short, 2 = long) */
168 FALSE
, /* pc_relative */
170 complain_overflow_bitfield
, /* complain_on_overflow */
171 special
, /* special_function */
172 "R_H8_DIR24R8", /* name */
173 TRUE
, /* partial_inplace */
174 0xff000000, /* src_mask */
175 0x00ffffff, /* dst_mask */
176 FALSE
), /* pcrel_offset */
177 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
178 HOWTO (R_H8_DIR32A16
, /* type */
180 2, /* size (0 = byte, 1 = short, 2 = long) */
182 FALSE
, /* pc_relative */
184 complain_overflow_dont
, /* complain_on_overflow */
185 special
, /* special_function */
186 "R_H8_DIR32", /* name */
187 FALSE
, /* partial_inplace */
189 0xffffffff, /* dst_mask */
190 FALSE
), /* pcrel_offset */
191 #define R_H8_PCREL16_X (R_H8_DIR32A16_X + 1)
192 HOWTO (R_H8_PCREL16
, /* type */
194 1, /* size (0 = byte, 1 = short, 2 = long) */
196 TRUE
, /* pc_relative */
198 complain_overflow_signed
, /* complain_on_overflow */
199 special
, /* special_function */
200 "R_H8_PCREL16", /* name */
201 FALSE
, /* partial_inplace */
202 0xffff, /* src_mask */
203 0xffff, /* dst_mask */
204 TRUE
), /* pcrel_offset */
205 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
206 HOWTO (R_H8_PCREL8
, /* type */
208 0, /* size (0 = byte, 1 = short, 2 = long) */
210 TRUE
, /* pc_relative */
212 complain_overflow_signed
, /* complain_on_overflow */
213 special
, /* special_function */
214 "R_H8_PCREL8", /* name */
215 FALSE
, /* partial_inplace */
218 TRUE
), /* pcrel_offset */
221 /* This structure is used to map BFD reloc codes to H8 ELF relocs. */
223 struct elf_reloc_map
{
224 bfd_reloc_code_real_type bfd_reloc_val
;
225 unsigned char howto_index
;
228 /* An array mapping BFD reloc codes to SH ELF relocs. */
230 static const struct elf_reloc_map h8_reloc_map
[] = {
231 { BFD_RELOC_NONE
, R_H8_NONE_X
},
232 { BFD_RELOC_32
, R_H8_DIR32_X
},
233 { BFD_RELOC_16
, R_H8_DIR16_X
},
234 { BFD_RELOC_8
, R_H8_DIR8_X
},
235 { BFD_RELOC_H8_DIR16A8
, R_H8_DIR16A8_X
},
236 { BFD_RELOC_H8_DIR16R8
, R_H8_DIR16R8_X
},
237 { BFD_RELOC_H8_DIR24A8
, R_H8_DIR24A8_X
},
238 { BFD_RELOC_H8_DIR24R8
, R_H8_DIR24R8_X
},
239 { BFD_RELOC_H8_DIR32A16
, R_H8_DIR32A16_X
},
240 { BFD_RELOC_16_PCREL
, R_H8_PCREL16_X
},
241 { BFD_RELOC_8_PCREL
, R_H8_PCREL8_X
},
245 static reloc_howto_type
*
246 elf32_h8_reloc_type_lookup (abfd
, code
)
247 bfd
*abfd ATTRIBUTE_UNUSED
;
248 bfd_reloc_code_real_type code
;
252 for (i
= 0; i
< sizeof (h8_reloc_map
) / sizeof (struct elf_reloc_map
); i
++)
254 if (h8_reloc_map
[i
].bfd_reloc_val
== code
)
255 return &h8_elf_howto_table
[(int) h8_reloc_map
[i
].howto_index
];
261 elf32_h8_info_to_howto (abfd
, bfd_reloc
, elf_reloc
)
262 bfd
*abfd ATTRIBUTE_UNUSED
;
264 Elf_Internal_Rela
*elf_reloc
;
269 r
= ELF32_R_TYPE (elf_reloc
->r_info
);
270 for (i
= 0; i
< sizeof (h8_elf_howto_table
) / sizeof (reloc_howto_type
); i
++)
271 if (h8_elf_howto_table
[i
].type
== r
)
273 bfd_reloc
->howto
= &h8_elf_howto_table
[i
];
280 elf32_h8_info_to_howto_rel (abfd
, bfd_reloc
, elf_reloc
)
281 bfd
*abfd ATTRIBUTE_UNUSED
;
283 Elf_Internal_Rela
*elf_reloc ATTRIBUTE_UNUSED
;
288 r
= ELF32_R_TYPE (elf_reloc
->r_info
);
289 bfd_reloc
->howto
= &h8_elf_howto_table
[r
];
292 /* Special handling for H8/300 relocs.
293 We only come here for pcrel stuff and return normally if not an -r link.
294 When doing -r, we can't do any arithmetic for the pcrel stuff, because
295 we support relaxing on the H8/300 series chips. */
296 static bfd_reloc_status_type
297 special (abfd
, reloc_entry
, symbol
, data
, input_section
, output_bfd
,
299 bfd
*abfd ATTRIBUTE_UNUSED
;
300 arelent
*reloc_entry ATTRIBUTE_UNUSED
;
301 asymbol
*symbol ATTRIBUTE_UNUSED
;
302 PTR data ATTRIBUTE_UNUSED
;
303 asection
*input_section ATTRIBUTE_UNUSED
;
305 char **error_message ATTRIBUTE_UNUSED
;
307 if (output_bfd
== (bfd
*) NULL
)
308 return bfd_reloc_continue
;
310 /* Adjust the reloc address to that in the output section. */
311 reloc_entry
->address
+= input_section
->output_offset
;
315 /* Perform a relocation as part of a final link. */
316 static bfd_reloc_status_type
317 elf32_h8_final_link_relocate (r_type
, input_bfd
, output_bfd
,
318 input_section
, contents
, offset
, value
,
319 addend
, info
, sym_sec
, is_local
)
320 unsigned long r_type
;
322 bfd
*output_bfd ATTRIBUTE_UNUSED
;
323 asection
*input_section ATTRIBUTE_UNUSED
;
328 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
329 asection
*sym_sec ATTRIBUTE_UNUSED
;
330 int is_local ATTRIBUTE_UNUSED
;
332 bfd_byte
*hit_data
= contents
+ offset
;
344 bfd_put_32 (input_bfd
, value
, hit_data
);
351 bfd_put_16 (input_bfd
, value
, hit_data
);
358 bfd_put_8 (input_bfd
, value
, hit_data
);
364 /* HIT_DATA is the address for the first byte for the relocated
365 value. Subtract 1 so that we can manipulate the data in 32bit
369 /* Clear out the top byte in value. */
372 /* Retrieve the type byte for value from the section contents. */
373 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xff000000);
375 /* Now scribble it out in one 32bit hunk. */
376 bfd_put_32 (input_bfd
, value
, hit_data
);
380 value
-= (input_section
->output_section
->vma
381 + input_section
->output_offset
);
385 /* The value is relative to the start of the instruction,
386 not the relocation offset. Subtract 2 to account for
390 bfd_put_16 (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 1 to account for
404 bfd_put_8 (input_bfd
, value
, hit_data
);
408 return bfd_reloc_notsupported
;
412 /* Relocate an H8 ELF section. */
414 elf32_h8_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
415 contents
, relocs
, local_syms
, local_sections
)
417 struct bfd_link_info
*info
;
419 asection
*input_section
;
421 Elf_Internal_Rela
*relocs
;
422 Elf_Internal_Sym
*local_syms
;
423 asection
**local_sections
;
425 Elf_Internal_Shdr
*symtab_hdr
;
426 struct elf_link_hash_entry
**sym_hashes
;
427 Elf_Internal_Rela
*rel
, *relend
;
429 if (info
->relocateable
)
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 /* This is a final link. */
448 r_symndx
= ELF32_R_SYM (rel
->r_info
);
449 r_type
= ELF32_R_TYPE (rel
->r_info
);
453 if (r_symndx
< symtab_hdr
->sh_info
)
455 sym
= local_syms
+ r_symndx
;
456 sec
= local_sections
[r_symndx
];
457 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
461 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
462 while (h
->root
.type
== bfd_link_hash_indirect
463 || h
->root
.type
== bfd_link_hash_warning
)
464 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
465 if (h
->root
.type
== bfd_link_hash_defined
466 || h
->root
.type
== bfd_link_hash_defweak
)
468 sec
= h
->root
.u
.def
.section
;
469 relocation
= (h
->root
.u
.def
.value
470 + sec
->output_section
->vma
471 + sec
->output_offset
);
473 else if (h
->root
.type
== bfd_link_hash_undefweak
)
477 if (! ((*info
->callbacks
->undefined_symbol
)
478 (info
, h
->root
.root
.string
, input_bfd
,
479 input_section
, rel
->r_offset
, TRUE
)))
485 r
= elf32_h8_final_link_relocate (r_type
, input_bfd
, output_bfd
,
487 contents
, rel
->r_offset
,
488 relocation
, rel
->r_addend
,
489 info
, sec
, h
== NULL
);
491 if (r
!= bfd_reloc_ok
)
494 const char *msg
= (const char *) 0;
496 reloc_howto_type
*howto
;
498 elf32_h8_info_to_howto (input_bfd
, &bfd_reloc
, rel
);
499 howto
= bfd_reloc
.howto
;
502 name
= h
->root
.root
.string
;
505 name
= (bfd_elf_string_from_elf_section
506 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
507 if (name
== NULL
|| *name
== '\0')
508 name
= bfd_section_name (input_bfd
, sec
);
513 case bfd_reloc_overflow
:
514 if (! ((*info
->callbacks
->reloc_overflow
)
515 (info
, name
, howto
->name
, (bfd_vma
) 0,
516 input_bfd
, input_section
, rel
->r_offset
)))
520 case bfd_reloc_undefined
:
521 if (! ((*info
->callbacks
->undefined_symbol
)
522 (info
, name
, input_bfd
, input_section
,
523 rel
->r_offset
, TRUE
)))
527 case bfd_reloc_outofrange
:
528 msg
= _("internal error: out of range error");
531 case bfd_reloc_notsupported
:
532 msg
= _("internal error: unsupported relocation error");
535 case bfd_reloc_dangerous
:
536 msg
= _("internal error: dangerous error");
540 msg
= _("internal error: unknown error");
544 if (!((*info
->callbacks
->warning
)
545 (info
, msg
, name
, input_bfd
, input_section
,
556 /* Object files encode the specific H8 model they were compiled
557 for in the ELF flags field.
559 Examine that field and return the proper BFD machine type for
562 elf32_h8_mach (flags
)
565 switch (flags
& EF_H8_MACH
)
567 case E_H8_MACH_H8300
:
569 return bfd_mach_h8300
;
571 case E_H8_MACH_H8300H
:
572 return bfd_mach_h8300h
;
574 case E_H8_MACH_H8300S
:
575 return bfd_mach_h8300s
;
577 case E_H8_MACH_H8300HN
:
578 return bfd_mach_h8300hn
;
580 case E_H8_MACH_H8300SN
:
581 return bfd_mach_h8300sn
;
585 /* The final processing done just before writing out a H8 ELF object
586 file. We use this opportunity to encode the BFD machine type
587 into the flags field in the object file. */
590 elf32_h8_final_write_processing (abfd
, linker
)
592 bfd_boolean linker ATTRIBUTE_UNUSED
;
596 switch (bfd_get_mach (abfd
))
600 val
= E_H8_MACH_H8300
;
603 case bfd_mach_h8300h
:
604 val
= E_H8_MACH_H8300H
;
607 case bfd_mach_h8300s
:
608 val
= E_H8_MACH_H8300S
;
611 case bfd_mach_h8300hn
:
612 val
= E_H8_MACH_H8300HN
;
615 case bfd_mach_h8300sn
:
616 val
= E_H8_MACH_H8300SN
;
620 elf_elfheader (abfd
)->e_flags
&= ~ (EF_H8_MACH
);
621 elf_elfheader (abfd
)->e_flags
|= val
;
624 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
625 record the encoded machine type found in the ELF flags. */
628 elf32_h8_object_p (abfd
)
631 bfd_default_set_arch_mach (abfd
, bfd_arch_h8300
,
632 elf32_h8_mach (elf_elfheader (abfd
)->e_flags
));
636 /* Merge backend specific data from an object file to the output
637 object file when linking. The only data we need to copy at this
638 time is the architecture/machine information. */
641 elf32_h8_merge_private_bfd_data (ibfd
, 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's a few relaxing opportunites 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 mov.b:16 -> mov.b:8 2 bytes
673 mov.b:24/32 -> mov.b:8 4 bytes
675 mov.[bwl]:24/32 -> mov.[bwl]:16 2 bytes */
678 elf32_h8_relax_section (abfd
, sec
, link_info
, again
)
681 struct bfd_link_info
*link_info
;
684 Elf_Internal_Shdr
*symtab_hdr
;
685 Elf_Internal_Rela
*internal_relocs
;
686 Elf_Internal_Rela
*irel
, *irelend
;
687 bfd_byte
*contents
= NULL
;
688 Elf_Internal_Sym
*isymbuf
= NULL
;
689 static asection
*last_input_section
= NULL
;
690 static Elf_Internal_Rela
*last_reloc
= NULL
;
692 /* Assume nothing changes. */
695 /* We don't have to do anything for a relocateable link, if
696 this section does not have relocs, or if this is not a
698 if (link_info
->relocateable
699 || (sec
->flags
& SEC_RELOC
) == 0
700 || sec
->reloc_count
== 0
701 || (sec
->flags
& SEC_CODE
) == 0)
704 /* If this is the first time we have been called for this section,
705 initialize the cooked size. */
706 if (sec
->_cooked_size
== 0)
707 sec
->_cooked_size
= sec
->_raw_size
;
709 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
711 /* Get a copy of the native relocations. */
712 internal_relocs
= (_bfd_elf32_link_read_relocs
713 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
714 link_info
->keep_memory
));
715 if (internal_relocs
== NULL
)
718 if (sec
!= last_input_section
)
721 last_input_section
= sec
;
723 /* Walk through the relocs looking for relaxing opportunities. */
724 irelend
= internal_relocs
+ sec
->reloc_count
;
725 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
729 /* Keep track of the previous reloc so that we can delete
730 some long jumps created by the compiler. */
731 if (irel
!= internal_relocs
)
732 last_reloc
= irel
- 1;
734 if (ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR24R8
735 && ELF32_R_TYPE (irel
->r_info
) != R_H8_PCREL16
736 && ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR16A8
737 && ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR24A8
738 && ELF32_R_TYPE (irel
->r_info
) != R_H8_DIR32A16
)
741 /* Get the section contents if we haven't done so already. */
742 if (contents
== NULL
)
744 /* Get cached copy if it exists. */
745 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
746 contents
= elf_section_data (sec
)->this_hdr
.contents
;
749 /* Go get them off disk. */
750 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
751 if (contents
== NULL
)
754 if (! bfd_get_section_contents (abfd
, sec
, contents
,
755 (file_ptr
) 0, sec
->_raw_size
))
760 /* Read this BFD's local symbols if we haven't done so already. */
761 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
763 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
765 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
766 symtab_hdr
->sh_info
, 0,
772 /* Get the value of the symbol referred to by the reloc. */
773 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
775 /* A local symbol. */
776 Elf_Internal_Sym
*isym
;
779 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
780 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
781 symval
= (isym
->st_value
782 + sym_sec
->output_section
->vma
783 + sym_sec
->output_offset
);
788 struct elf_link_hash_entry
*h
;
790 /* An external symbol. */
791 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
792 h
= elf_sym_hashes (abfd
)[indx
];
793 BFD_ASSERT (h
!= NULL
);
794 if (h
->root
.type
!= bfd_link_hash_defined
795 && h
->root
.type
!= bfd_link_hash_defweak
)
797 /* This appears to be a reference to an undefined
798 symbol. Just ignore it--it will be caught by the
799 regular reloc processing. */
803 symval
= (h
->root
.u
.def
.value
804 + h
->root
.u
.def
.section
->output_section
->vma
805 + h
->root
.u
.def
.section
->output_offset
);
808 /* For simplicity of coding, we are going to modify the section
809 contents, the section relocs, and the BFD symbol table. We
810 must tell the rest of the code not to free up this
811 information. It would be possible to instead create a table
812 of changes which have to be made, as is done in coff-mips.c;
813 that would be more work, but would require less memory when
814 the linker is run. */
815 switch (ELF32_R_TYPE (irel
->r_info
))
817 /* Try to turn a 24 bit absolute branch/call into an 8 bit
818 pc-relative branch/call. */
821 bfd_vma value
= symval
+ irel
->r_addend
;
824 /* Get the address of this instruction. */
825 dot
= (sec
->output_section
->vma
826 + sec
->output_offset
+ irel
->r_offset
- 1);
828 /* Compute the distance from this insn to the branch target. */
831 /* If the distance is within -126..+130 inclusive, then we can
832 relax this jump. +130 is valid since the target will move
833 two bytes closer if we do relax this branch. */
834 if ((int) gap
>= -126 && (int) gap
<= 130)
838 /* Note that we've changed the relocs, section contents,
840 elf_section_data (sec
)->relocs
= internal_relocs
;
841 elf_section_data (sec
)->this_hdr
.contents
= contents
;
842 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
844 /* Get the instruction code being relaxed. */
845 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
847 /* If the previous instruction conditionally jumped around
848 this instruction, we may be able to reverse the condition
849 and redirect the previous instruction to the target of
852 Such sequences are used by the compiler to deal with
853 long conditional branches.
855 Only perform this optimisation for jumps (code 0x5a) not
856 subroutine calls, as otherwise it could transform:
869 which changes the call (jsr) into a branch (bne). */
874 && ELF32_R_TYPE (last_reloc
->r_info
) == R_H8_PCREL8
875 && ELF32_R_SYM (last_reloc
->r_info
) < symtab_hdr
->sh_info
)
878 asection
*last_sym_sec
;
879 Elf_Internal_Sym
*last_sym
;
881 /* We will need to examine the symbol used by the
882 previous relocation. */
884 last_sym
= isymbuf
+ ELF32_R_SYM (last_reloc
->r_info
);
886 = bfd_section_from_elf_index (abfd
, last_sym
->st_shndx
);
887 last_value
= (last_sym
->st_value
888 + last_sym_sec
->output_section
->vma
889 + last_sym_sec
->output_offset
);
891 /* Verify that the previous relocation was for a
892 branch around this instruction and that no symbol
893 exists at the current location. */
894 if (last_value
== dot
+ 4
895 && last_reloc
->r_offset
+ 2 == irel
->r_offset
896 && ! elf32_h8_symbol_address_p (abfd
, sec
, dot
))
898 /* We can eliminate this jump. Twiddle the
899 previous relocation as necessary. */
901 = ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
902 ELF32_R_TYPE (R_H8_NONE
));
905 = ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
906 ELF32_R_TYPE (R_H8_PCREL8
));
907 last_reloc
->r_addend
= irel
->r_addend
;
909 code
= bfd_get_8 (abfd
,
910 contents
+ last_reloc
->r_offset
- 1);
914 contents
+ last_reloc
->r_offset
- 1);
916 /* Delete four bytes of data. */
917 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
928 bfd_put_8 (abfd
, 0x55, contents
+ irel
->r_offset
- 1);
929 else if (code
== 0x5a)
930 bfd_put_8 (abfd
, 0x40, contents
+ irel
->r_offset
- 1);
934 /* Fix the relocation's type. */
935 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
938 /* Delete two bytes of data. */
939 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
940 irel
->r_offset
+ 1, 2))
943 /* That will change things, so, we should relax again.
944 Note that this is not required, and it may be slow. */
950 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
954 bfd_vma value
= symval
+ irel
->r_addend
;
958 /* Get the address of this instruction. */
959 dot
= (sec
->output_section
->vma
961 + irel
->r_offset
- 2);
965 /* If the distance is within -126..+130 inclusive, then we can
966 relax this jump. +130 is valid since the target will move
967 two bytes closer if we do relax this branch. */
968 if ((int) gap
>= -126 && (int) gap
<= 130)
972 /* Note that we've changed the relocs, section contents,
974 elf_section_data (sec
)->relocs
= internal_relocs
;
975 elf_section_data (sec
)->this_hdr
.contents
= contents
;
976 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
978 /* Get the opcode. */
979 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
983 /* bCC:16 -> bCC:8 */
984 /* Get the condition code from the original insn. */
985 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
989 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
991 else if (code
== 0x5c)
992 bfd_put_8 (abfd
, 0x55, contents
+ irel
->r_offset
- 2);
996 /* Fix the relocation's type. */
997 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1001 /* Delete two bytes of data. */
1002 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
1003 irel
->r_offset
+ 1, 2))
1006 /* That will change things, so, we should relax again.
1007 Note that this is not required, and it may be slow. */
1013 /* This is a 16 bit absolute address in a "mov.b" insn, which may
1014 become an 8 bit absolute address if its in the right range. */
1017 bfd_vma value
= symval
+ irel
->r_addend
;
1019 if ((bfd_get_mach (abfd
) == bfd_mach_h8300
1022 || ((bfd_get_mach (abfd
) == bfd_mach_h8300h
1023 || bfd_get_mach (abfd
) == bfd_mach_h8300s
)
1024 && value
>= 0xffff00
1025 && value
<= 0xffffff))
1029 /* Note that we've changed the relocs, section contents,
1031 elf_section_data (sec
)->relocs
= internal_relocs
;
1032 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1033 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1035 /* Get the opcode. */
1036 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
1042 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1044 if ((code
& 0xf0) == 0x00)
1046 (code
& 0xf) | 0x20,
1047 contents
+ irel
->r_offset
- 2);
1048 else if ((code
& 0xf0) == 0x80)
1050 (code
& 0xf) | 0x30,
1051 contents
+ irel
->r_offset
- 2);
1055 /* Fix the relocation's type. */
1056 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1059 /* Delete two bytes of data. */
1060 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
1061 irel
->r_offset
+ 1, 2))
1064 /* That will change things, so, we should relax again.
1065 Note that this is not required, and it may be slow. */
1071 /* This is a 24 bit absolute address in a "mov.b" insn, which may
1072 become an 8 bit absolute address if its in the right range. */
1075 bfd_vma value
= symval
+ irel
->r_addend
;
1077 if ((bfd_get_mach (abfd
) == bfd_mach_h8300
1080 || ((bfd_get_mach (abfd
) == bfd_mach_h8300h
1081 || bfd_get_mach (abfd
) == bfd_mach_h8300s
)
1082 && value
>= 0xffff00
1083 && value
<= 0xffffff))
1087 /* Note that we've changed the relocs, section contents,
1089 elf_section_data (sec
)->relocs
= internal_relocs
;
1090 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1091 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1093 /* Get the opcode. */
1094 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
1100 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1102 if ((code
& 0xf0) == 0x00)
1104 (code
& 0xf) | 0x20,
1105 contents
+ irel
->r_offset
- 2);
1106 else if ((code
& 0xf0) == 0x80)
1108 (code
& 0xf) | 0x30,
1109 contents
+ irel
->r_offset
- 2);
1113 /* Fix the relocation's type. */
1114 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1117 /* Delete two bytes of data. */
1118 if (!elf32_h8_relax_delete_bytes (abfd
, sec
, irel
->r_offset
, 2))
1121 /* That will change things, so, we should relax again.
1122 Note that this is not required, and it may be slow. */
1129 /* This is a 24/32bit absolute address in a "mov" insn, which may
1130 become a 16bit absoulte address if it is in the right range. */
1133 bfd_vma value
= symval
+ irel
->r_addend
;
1135 if (value
<= 0x7fff || value
>= 0xff8000)
1139 /* Note that we've changed the relocs, section contents,
1141 elf_section_data (sec
)->relocs
= internal_relocs
;
1142 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1143 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1145 /* Get the opcode. */
1146 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1148 /* We just need to turn off bit 0x20. */
1151 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
1153 /* Fix the relocation's type. */
1154 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1157 /* Delete two bytes of data. */
1158 if (!elf32_h8_relax_delete_bytes (abfd
, sec
,
1159 irel
->r_offset
+ 1, 2))
1162 /* That will change things, so, we should relax again.
1163 Note that this is not required, and it may be slow. */
1175 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1177 if (! link_info
->keep_memory
)
1180 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1183 if (contents
!= NULL
1184 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1186 if (! link_info
->keep_memory
)
1190 /* Cache the section contents for elf_link_input_bfd. */
1191 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1195 if (internal_relocs
!= NULL
1196 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1197 free (internal_relocs
);
1203 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1205 if (contents
!= NULL
1206 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1208 if (internal_relocs
!= NULL
1209 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1210 free (internal_relocs
);
1214 /* Delete some bytes from a section while relaxing. */
1217 elf32_h8_relax_delete_bytes (abfd
, sec
, addr
, count
)
1223 Elf_Internal_Shdr
*symtab_hdr
;
1224 unsigned int sec_shndx
;
1226 Elf_Internal_Rela
*irel
, *irelend
;
1227 Elf_Internal_Rela
*irelalign
;
1228 Elf_Internal_Sym
*isym
;
1229 Elf_Internal_Sym
*isymend
;
1231 struct elf_link_hash_entry
**sym_hashes
;
1232 struct elf_link_hash_entry
**end_hashes
;
1233 unsigned int symcount
;
1235 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1237 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1239 /* The deletion must stop at the next ALIGN reloc for an aligment
1240 power larger than the number of bytes we are deleting. */
1243 toaddr
= sec
->_cooked_size
;
1245 irel
= elf_section_data (sec
)->relocs
;
1246 irelend
= irel
+ sec
->reloc_count
;
1248 /* Actually delete the bytes. */
1249 memmove (contents
+ addr
, contents
+ addr
+ count
,
1250 (size_t) (toaddr
- addr
- count
));
1251 sec
->_cooked_size
-= count
;
1253 /* Adjust all the relocs. */
1254 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1256 /* Get the new reloc address. */
1257 if ((irel
->r_offset
> addr
1258 && irel
->r_offset
< toaddr
))
1259 irel
->r_offset
-= count
;
1262 /* Adjust the local symbols defined in this section. */
1263 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1264 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1265 isymend
= isym
+ symtab_hdr
->sh_info
;
1266 for (; isym
< isymend
; isym
++)
1268 if (isym
->st_shndx
== sec_shndx
1269 && isym
->st_value
> addr
1270 && isym
->st_value
< toaddr
)
1271 isym
->st_value
-= count
;
1274 /* Now adjust the global symbols defined in this section. */
1275 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1276 - symtab_hdr
->sh_info
);
1277 sym_hashes
= elf_sym_hashes (abfd
);
1278 end_hashes
= sym_hashes
+ symcount
;
1279 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1281 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1282 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1283 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1284 && sym_hash
->root
.u
.def
.section
== sec
1285 && sym_hash
->root
.u
.def
.value
> addr
1286 && sym_hash
->root
.u
.def
.value
< toaddr
)
1288 sym_hash
->root
.u
.def
.value
-= count
;
1295 /* Return TRUE if a symbol exists at the given address, else return
1298 elf32_h8_symbol_address_p (abfd
, sec
, addr
)
1303 Elf_Internal_Shdr
*symtab_hdr
;
1304 unsigned int sec_shndx
;
1305 Elf_Internal_Sym
*isym
;
1306 Elf_Internal_Sym
*isymend
;
1307 struct elf_link_hash_entry
**sym_hashes
;
1308 struct elf_link_hash_entry
**end_hashes
;
1309 unsigned int symcount
;
1311 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1313 /* Examine all the symbols. */
1314 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1315 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1316 isymend
= isym
+ symtab_hdr
->sh_info
;
1317 for (; isym
< isymend
; isym
++)
1319 if (isym
->st_shndx
== sec_shndx
1320 && isym
->st_value
== addr
)
1324 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1325 - symtab_hdr
->sh_info
);
1326 sym_hashes
= elf_sym_hashes (abfd
);
1327 end_hashes
= sym_hashes
+ symcount
;
1328 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1330 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1331 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1332 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1333 && sym_hash
->root
.u
.def
.section
== sec
1334 && sym_hash
->root
.u
.def
.value
== addr
)
1341 /* This is a version of bfd_generic_get_relocated_section_contents
1342 which uses elf32_h8_relocate_section. */
1345 elf32_h8_get_relocated_section_contents (output_bfd
, link_info
, link_order
,
1346 data
, relocateable
, symbols
)
1348 struct bfd_link_info
*link_info
;
1349 struct bfd_link_order
*link_order
;
1351 bfd_boolean relocateable
;
1354 Elf_Internal_Shdr
*symtab_hdr
;
1355 asection
*input_section
= link_order
->u
.indirect
.section
;
1356 bfd
*input_bfd
= input_section
->owner
;
1357 asection
**sections
= NULL
;
1358 Elf_Internal_Rela
*internal_relocs
= NULL
;
1359 Elf_Internal_Sym
*isymbuf
= NULL
;
1361 /* We only need to handle the case of relaxing, or of having a
1362 particular set of section contents, specially. */
1364 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1365 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1370 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1372 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1373 (size_t) input_section
->_raw_size
);
1375 if ((input_section
->flags
& SEC_RELOC
) != 0
1376 && input_section
->reloc_count
> 0)
1379 Elf_Internal_Sym
*isym
, *isymend
;
1382 internal_relocs
= (_bfd_elf32_link_read_relocs
1383 (input_bfd
, input_section
, (PTR
) NULL
,
1384 (Elf_Internal_Rela
*) NULL
, FALSE
));
1385 if (internal_relocs
== NULL
)
1388 if (symtab_hdr
->sh_info
!= 0)
1390 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1391 if (isymbuf
== NULL
)
1392 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1393 symtab_hdr
->sh_info
, 0,
1395 if (isymbuf
== NULL
)
1399 amt
= symtab_hdr
->sh_info
;
1400 amt
*= sizeof (asection
*);
1401 sections
= (asection
**) bfd_malloc (amt
);
1402 if (sections
== NULL
&& amt
!= 0)
1405 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1406 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1410 if (isym
->st_shndx
== SHN_UNDEF
)
1411 isec
= bfd_und_section_ptr
;
1412 else if (isym
->st_shndx
== SHN_ABS
)
1413 isec
= bfd_abs_section_ptr
;
1414 else if (isym
->st_shndx
== SHN_COMMON
)
1415 isec
= bfd_com_section_ptr
;
1417 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1422 if (! elf32_h8_relocate_section (output_bfd
, link_info
, input_bfd
,
1423 input_section
, data
, internal_relocs
,
1427 if (sections
!= NULL
)
1430 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1432 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1433 free (internal_relocs
);
1439 if (sections
!= NULL
)
1442 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1444 if (internal_relocs
!= NULL
1445 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
1446 free (internal_relocs
);
1451 #define TARGET_BIG_SYM bfd_elf32_h8300_vec
1452 #define TARGET_BIG_NAME "elf32-h8300"
1453 #define ELF_ARCH bfd_arch_h8300
1454 #define ELF_MACHINE_CODE EM_H8_300
1455 #define ELF_MAXPAGESIZE 0x1
1456 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1457 #define elf_info_to_howto elf32_h8_info_to_howto
1458 #define elf_info_to_howto_rel elf32_h8_info_to_howto_rel
1460 /* So we can set/examine bits in e_flags to get the specific
1461 H8 architecture in use. */
1462 #define elf_backend_final_write_processing \
1463 elf32_h8_final_write_processing
1464 #define elf_backend_object_p \
1466 #define bfd_elf32_bfd_merge_private_bfd_data \
1467 elf32_h8_merge_private_bfd_data
1469 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1470 defaults to using _bfd_generic_link_hash_table_create, but
1471 elflink.h:bfd_elf32_size_dynamic_sections uses
1472 dynobj = elf_hash_table (info)->dynobj;
1473 and thus requires an elf hash table. */
1474 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1476 /* Use an H8 specific linker, not the ELF generic linker. */
1477 #define elf_backend_relocate_section elf32_h8_relocate_section
1478 #define elf_backend_rela_normal 1
1480 /* And relaxing stuff. */
1481 #define bfd_elf32_bfd_relax_section elf32_h8_relax_section
1482 #define bfd_elf32_bfd_get_relocated_section_contents \
1483 elf32_h8_get_relocated_section_contents
1486 #include "elf32-target.h"