1 /* Matsushita 10200 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007
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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
26 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
27 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type code
));
28 static void mn10200_info_to_howto
29 PARAMS ((bfd
*, arelent
*, Elf_Internal_Rela
*));
30 static bfd_boolean mn10200_elf_relax_delete_bytes
31 PARAMS ((bfd
*, asection
*, bfd_vma
, int));
32 static bfd_boolean mn10200_elf_symbol_address_p
33 PARAMS ((bfd
*, asection
*, Elf_Internal_Sym
*, bfd_vma
));
34 static bfd_reloc_status_type mn10200_elf_final_link_relocate
35 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*,
36 bfd_byte
*, bfd_vma
, bfd_vma
, bfd_vma
,
37 struct bfd_link_info
*, asection
*, int));
38 static bfd_boolean mn10200_elf_relocate_section
39 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*,
40 bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Sym
*,
42 static bfd_boolean mn10200_elf_relax_section
43 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*));
44 static bfd_byte
* mn10200_elf_get_relocated_section_contents
45 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
46 bfd_byte
*, bfd_boolean
, asymbol
**));
60 static reloc_howto_type elf_mn10200_howto_table
[] = {
61 /* Dummy relocation. Does nothing. */
62 HOWTO (R_MN10200_NONE
,
68 complain_overflow_bitfield
,
69 bfd_elf_generic_reloc
,
75 /* Standard 32 bit reloc. */
82 complain_overflow_bitfield
,
83 bfd_elf_generic_reloc
,
89 /* Standard 16 bit reloc. */
96 complain_overflow_bitfield
,
97 bfd_elf_generic_reloc
,
103 /* Standard 8 bit reloc. */
110 complain_overflow_bitfield
,
111 bfd_elf_generic_reloc
,
117 /* Standard 24 bit reloc. */
124 complain_overflow_bitfield
,
125 bfd_elf_generic_reloc
,
131 /* Simple 8 pc-relative reloc. */
132 HOWTO (R_MN10200_PCREL8
,
138 complain_overflow_bitfield
,
139 bfd_elf_generic_reloc
,
145 /* Simple 16 pc-relative reloc. */
146 HOWTO (R_MN10200_PCREL16
,
152 complain_overflow_bitfield
,
153 bfd_elf_generic_reloc
,
159 /* Simple 32bit pc-relative reloc with a 1 byte adjustment
160 to get the pc-relative offset correct. */
161 HOWTO (R_MN10200_PCREL24
,
167 complain_overflow_bitfield
,
168 bfd_elf_generic_reloc
,
176 struct mn10200_reloc_map
{
177 bfd_reloc_code_real_type bfd_reloc_val
;
178 unsigned char elf_reloc_val
;
181 static const struct mn10200_reloc_map mn10200_reloc_map
[] = {
182 { BFD_RELOC_NONE
, R_MN10200_NONE
, },
183 { BFD_RELOC_32
, R_MN10200_32
, },
184 { BFD_RELOC_16
, R_MN10200_16
, },
185 { BFD_RELOC_8
, R_MN10200_8
, },
186 { BFD_RELOC_24
, R_MN10200_24
, },
187 { BFD_RELOC_8_PCREL
, R_MN10200_PCREL8
, },
188 { BFD_RELOC_16_PCREL
, R_MN10200_PCREL16
, },
189 { BFD_RELOC_24_PCREL
, R_MN10200_PCREL24
, },
192 static reloc_howto_type
*
193 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
194 bfd
*abfd ATTRIBUTE_UNUSED
;
195 bfd_reloc_code_real_type code
;
200 i
< sizeof (mn10200_reloc_map
) / sizeof (struct mn10200_reloc_map
);
203 if (mn10200_reloc_map
[i
].bfd_reloc_val
== code
)
204 return &elf_mn10200_howto_table
[mn10200_reloc_map
[i
].elf_reloc_val
];
210 /* Set the howto pointer for an MN10200 ELF reloc. */
213 mn10200_info_to_howto (abfd
, cache_ptr
, dst
)
214 bfd
*abfd ATTRIBUTE_UNUSED
;
216 Elf_Internal_Rela
*dst
;
220 r_type
= ELF32_R_TYPE (dst
->r_info
);
221 BFD_ASSERT (r_type
< (unsigned int) R_MN10200_MAX
);
222 cache_ptr
->howto
= &elf_mn10200_howto_table
[r_type
];
225 /* Perform a relocation as part of a final link. */
227 static bfd_reloc_status_type
228 mn10200_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
229 input_section
, contents
, offset
, value
,
230 addend
, info
, sym_sec
, is_local
)
231 reloc_howto_type
*howto
;
233 bfd
*output_bfd ATTRIBUTE_UNUSED
;
234 asection
*input_section
;
239 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
240 asection
*sym_sec ATTRIBUTE_UNUSED
;
241 int is_local ATTRIBUTE_UNUSED
;
243 unsigned long r_type
= howto
->type
;
244 bfd_byte
*hit_data
= contents
+ offset
;
254 bfd_put_32 (input_bfd
, value
, hit_data
);
260 if ((long) value
> 0x7fff || (long) value
< -0x8000)
261 return bfd_reloc_overflow
;
263 bfd_put_16 (input_bfd
, value
, hit_data
);
269 if ((long) value
> 0x7f || (long) value
< -0x80)
270 return bfd_reloc_overflow
;
272 bfd_put_8 (input_bfd
, value
, hit_data
);
278 if ((long) value
> 0x7fffff || (long) value
< -0x800000)
279 return bfd_reloc_overflow
;
282 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xff000000);
283 bfd_put_32 (input_bfd
, value
, hit_data
);
286 case R_MN10200_PCREL8
:
287 value
-= (input_section
->output_section
->vma
288 + input_section
->output_offset
);
289 value
-= (offset
+ 1);
292 if ((long) value
> 0xff || (long) value
< -0x100)
293 return bfd_reloc_overflow
;
295 bfd_put_8 (input_bfd
, value
, hit_data
);
298 case R_MN10200_PCREL16
:
299 value
-= (input_section
->output_section
->vma
300 + input_section
->output_offset
);
301 value
-= (offset
+ 2);
304 if ((long) value
> 0xffff || (long) value
< -0x10000)
305 return bfd_reloc_overflow
;
307 bfd_put_16 (input_bfd
, value
, hit_data
);
310 case R_MN10200_PCREL24
:
311 value
-= (input_section
->output_section
->vma
312 + input_section
->output_offset
);
313 value
-= (offset
+ 3);
316 if ((long) value
> 0xffffff || (long) value
< -0x1000000)
317 return bfd_reloc_overflow
;
320 value
|= (bfd_get_32 (input_bfd
, hit_data
) & 0xff000000);
321 bfd_put_32 (input_bfd
, value
, hit_data
);
325 return bfd_reloc_notsupported
;
329 /* Relocate an MN10200 ELF section. */
331 mn10200_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
332 contents
, relocs
, local_syms
, local_sections
)
334 struct bfd_link_info
*info
;
336 asection
*input_section
;
338 Elf_Internal_Rela
*relocs
;
339 Elf_Internal_Sym
*local_syms
;
340 asection
**local_sections
;
342 Elf_Internal_Shdr
*symtab_hdr
;
343 struct elf_link_hash_entry
**sym_hashes
;
344 Elf_Internal_Rela
*rel
, *relend
;
346 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
347 sym_hashes
= elf_sym_hashes (input_bfd
);
350 relend
= relocs
+ input_section
->reloc_count
;
351 for (; rel
< relend
; rel
++)
354 reloc_howto_type
*howto
;
355 unsigned long r_symndx
;
356 Elf_Internal_Sym
*sym
;
358 struct elf_link_hash_entry
*h
;
360 bfd_reloc_status_type r
;
362 r_symndx
= ELF32_R_SYM (rel
->r_info
);
363 r_type
= ELF32_R_TYPE (rel
->r_info
);
364 howto
= elf_mn10200_howto_table
+ r_type
;
369 if (r_symndx
< symtab_hdr
->sh_info
)
371 sym
= local_syms
+ r_symndx
;
372 sec
= local_sections
[r_symndx
];
373 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
377 bfd_boolean unresolved_reloc
, warned
;
379 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
380 r_symndx
, symtab_hdr
, sym_hashes
,
382 unresolved_reloc
, warned
);
385 if (sec
!= NULL
&& elf_discarded_section (sec
))
387 /* For relocs against symbols from removed linkonce sections,
388 or sections discarded by a linker script, we just want the
389 section contents zeroed. Avoid any special processing. */
390 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
396 if (info
->relocatable
)
399 r
= mn10200_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
401 contents
, rel
->r_offset
,
402 relocation
, rel
->r_addend
,
403 info
, sec
, h
== NULL
);
405 if (r
!= bfd_reloc_ok
)
408 const char *msg
= (const char *) 0;
411 name
= h
->root
.root
.string
;
414 name
= (bfd_elf_string_from_elf_section
415 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
416 if (name
== NULL
|| *name
== '\0')
417 name
= bfd_section_name (input_bfd
, sec
);
422 case bfd_reloc_overflow
:
423 if (! ((*info
->callbacks
->reloc_overflow
)
424 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
425 (bfd_vma
) 0, input_bfd
, input_section
,
430 case bfd_reloc_undefined
:
431 if (! ((*info
->callbacks
->undefined_symbol
)
432 (info
, name
, input_bfd
, input_section
,
433 rel
->r_offset
, TRUE
)))
437 case bfd_reloc_outofrange
:
438 msg
= _("internal error: out of range error");
441 case bfd_reloc_notsupported
:
442 msg
= _("internal error: unsupported relocation error");
445 case bfd_reloc_dangerous
:
446 msg
= _("internal error: dangerous error");
450 msg
= _("internal error: unknown error");
454 if (!((*info
->callbacks
->warning
)
455 (info
, msg
, name
, input_bfd
, input_section
,
466 /* This function handles relaxing for the mn10200.
468 There are quite a few relaxing opportunities available on the mn10200:
470 * jsr:24 -> jsr:16 2 bytes
472 * jmp:24 -> jmp:16 2 bytes
473 * jmp:16 -> bra:8 1 byte
475 * If the previous instruction is a conditional branch
476 around the jump/bra, we may be able to reverse its condition
477 and change its target to the jump's target. The jump/bra
478 can then be deleted. 2 bytes
480 * mov abs24 -> mov abs16 2 byte savings
482 * Most instructions which accept imm24 can relax to imm16 2 bytes
483 - Most instructions which accept imm16 can relax to imm8 1 byte
485 * Most instructions which accept d24 can relax to d16 2 bytes
486 - Most instructions which accept d16 can relax to d8 1 byte
488 abs24, imm24, d24 all look the same at the reloc level. It
489 might make the code simpler if we had different relocs for
490 the various relaxable operand types.
492 We don't handle imm16->imm8 or d16->d8 as they're very rare
493 and somewhat more difficult to support. */
496 mn10200_elf_relax_section (abfd
, sec
, link_info
, again
)
499 struct bfd_link_info
*link_info
;
502 Elf_Internal_Shdr
*symtab_hdr
;
503 Elf_Internal_Rela
*internal_relocs
;
504 Elf_Internal_Rela
*irel
, *irelend
;
505 bfd_byte
*contents
= NULL
;
506 Elf_Internal_Sym
*isymbuf
= NULL
;
508 /* Assume nothing changes. */
511 /* We don't have to do anything for a relocatable link, if
512 this section does not have relocs, or if this is not a
514 if (link_info
->relocatable
515 || (sec
->flags
& SEC_RELOC
) == 0
516 || sec
->reloc_count
== 0
517 || (sec
->flags
& SEC_CODE
) == 0)
520 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
522 /* Get a copy of the native relocations. */
523 internal_relocs
= (_bfd_elf_link_read_relocs
524 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
525 link_info
->keep_memory
));
526 if (internal_relocs
== NULL
)
529 /* Walk through them looking for relaxing opportunities. */
530 irelend
= internal_relocs
+ sec
->reloc_count
;
531 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
535 /* If this isn't something that can be relaxed, then ignore
537 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_NONE
538 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_8
539 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_MAX
)
542 /* Get the section contents if we haven't done so already. */
543 if (contents
== NULL
)
545 /* Get cached copy if it exists. */
546 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
547 contents
= elf_section_data (sec
)->this_hdr
.contents
;
550 /* Go get them off disk. */
551 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
556 /* Read this BFD's local symbols if we haven't done so already. */
557 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
559 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
561 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
562 symtab_hdr
->sh_info
, 0,
568 /* Get the value of the symbol referred to by the reloc. */
569 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
571 /* A local symbol. */
572 Elf_Internal_Sym
*isym
;
575 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
576 if (isym
->st_shndx
== SHN_UNDEF
)
577 sym_sec
= bfd_und_section_ptr
;
578 else if (isym
->st_shndx
== SHN_ABS
)
579 sym_sec
= bfd_abs_section_ptr
;
580 else if (isym
->st_shndx
== SHN_COMMON
)
581 sym_sec
= bfd_com_section_ptr
;
583 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
584 symval
= (isym
->st_value
585 + sym_sec
->output_section
->vma
586 + sym_sec
->output_offset
);
591 struct elf_link_hash_entry
*h
;
593 /* An external symbol. */
594 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
595 h
= elf_sym_hashes (abfd
)[indx
];
596 BFD_ASSERT (h
!= NULL
);
597 if (h
->root
.type
!= bfd_link_hash_defined
598 && h
->root
.type
!= bfd_link_hash_defweak
)
600 /* This appears to be a reference to an undefined
601 symbol. Just ignore it--it will be caught by the
602 regular reloc processing. */
606 symval
= (h
->root
.u
.def
.value
607 + h
->root
.u
.def
.section
->output_section
->vma
608 + h
->root
.u
.def
.section
->output_offset
);
611 /* For simplicity of coding, we are going to modify the section
612 contents, the section relocs, and the BFD symbol table. We
613 must tell the rest of the code not to free up this
614 information. It would be possible to instead create a table
615 of changes which have to be made, as is done in coff-mips.c;
616 that would be more work, but would require less memory when
617 the linker is run. */
619 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
621 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_PCREL24
)
623 bfd_vma value
= symval
;
625 /* Deal with pc-relative gunk. */
626 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
627 value
-= (irel
->r_offset
+ 3);
628 value
+= irel
->r_addend
;
630 /* See if the value will fit in 16 bits, note the high value is
631 0x7fff + 2 as the target will be two bytes closer if we are
633 if ((long) value
< 0x8001 && (long) value
> -0x8000)
637 /* Get the opcode. */
638 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
640 if (code
!= 0xe0 && code
!= 0xe1)
643 /* Note that we've changed the relocs, section contents, etc. */
644 elf_section_data (sec
)->relocs
= internal_relocs
;
645 elf_section_data (sec
)->this_hdr
.contents
= contents
;
646 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
648 /* Fix the opcode. */
650 bfd_put_8 (abfd
, 0xfc, contents
+ irel
->r_offset
- 2);
651 else if (code
== 0xe1)
652 bfd_put_8 (abfd
, 0xfd, contents
+ irel
->r_offset
- 2);
654 /* Fix the relocation's type. */
655 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
658 /* The opcode got shorter too, so we have to fix the offset. */
661 /* Delete two bytes of data. */
662 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
663 irel
->r_offset
+ 1, 2))
666 /* That will change things, so, we should relax again.
667 Note that this is not required, and it may be slow. */
672 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
674 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_PCREL16
)
676 bfd_vma value
= symval
;
678 /* Deal with pc-relative gunk. */
679 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
680 value
-= (irel
->r_offset
+ 2);
681 value
+= irel
->r_addend
;
683 /* See if the value will fit in 8 bits, note the high value is
684 0x7f + 1 as the target will be one bytes closer if we are
686 if ((long) value
< 0x80 && (long) value
> -0x80)
690 /* Get the opcode. */
691 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
696 /* Note that we've changed the relocs, section contents, etc. */
697 elf_section_data (sec
)->relocs
= internal_relocs
;
698 elf_section_data (sec
)->this_hdr
.contents
= contents
;
699 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
701 /* Fix the opcode. */
702 bfd_put_8 (abfd
, 0xea, contents
+ irel
->r_offset
- 1);
704 /* Fix the relocation's type. */
705 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
708 /* Delete one byte of data. */
709 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
710 irel
->r_offset
+ 1, 1))
713 /* That will change things, so, we should relax again.
714 Note that this is not required, and it may be slow. */
719 /* Try to eliminate an unconditional 8 bit pc-relative branch
720 which immediately follows a conditional 8 bit pc-relative
721 branch around the unconditional branch.
728 This happens when the bCC can't reach lab2 at assembly time,
729 but due to other relaxations it can reach at link time. */
730 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_PCREL8
)
732 Elf_Internal_Rela
*nrel
;
733 bfd_vma value
= symval
;
736 /* Deal with pc-relative gunk. */
737 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
738 value
-= (irel
->r_offset
+ 1);
739 value
+= irel
->r_addend
;
741 /* Do nothing if this reloc is the last byte in the section. */
742 if (irel
->r_offset
== sec
->size
)
745 /* See if the next instruction is an unconditional pc-relative
746 branch, more often than not this test will fail, so we
747 test it first to speed things up. */
748 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 1);
752 /* Also make sure the next relocation applies to the next
753 instruction and that it's a pc-relative 8 bit branch. */
756 || irel
->r_offset
+ 2 != nrel
->r_offset
757 || ELF32_R_TYPE (nrel
->r_info
) != (int) R_MN10200_PCREL8
)
760 /* Make sure our destination immediately follows the
761 unconditional branch. */
762 if (symval
!= (sec
->output_section
->vma
+ sec
->output_offset
763 + irel
->r_offset
+ 3))
766 /* Now make sure we are a conditional branch. This may not
767 be necessary, but why take the chance.
769 Note these checks assume that R_MN10200_PCREL8 relocs
770 only occur on bCC and bCCx insns. If they occured
771 elsewhere, we'd need to know the start of this insn
772 for this check to be accurate. */
773 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
774 if (code
!= 0xe0 && code
!= 0xe1 && code
!= 0xe2
775 && code
!= 0xe3 && code
!= 0xe4 && code
!= 0xe5
776 && code
!= 0xe6 && code
!= 0xe7 && code
!= 0xe8
777 && code
!= 0xe9 && code
!= 0xec && code
!= 0xed
778 && code
!= 0xee && code
!= 0xef && code
!= 0xfc
779 && code
!= 0xfd && code
!= 0xfe && code
!= 0xff)
782 /* We also have to be sure there is no symbol/label
783 at the unconditional branch. */
784 if (mn10200_elf_symbol_address_p (abfd
, sec
, isymbuf
,
788 /* Note that we've changed the relocs, section contents, etc. */
789 elf_section_data (sec
)->relocs
= internal_relocs
;
790 elf_section_data (sec
)->this_hdr
.contents
= contents
;
791 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
793 /* Reverse the condition of the first branch. */
851 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
853 /* Set the reloc type and symbol for the first branch
854 from the second branch. */
855 irel
->r_info
= nrel
->r_info
;
857 /* Make the reloc for the second branch a null reloc. */
858 nrel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (nrel
->r_info
),
861 /* Delete two bytes of data. */
862 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
863 irel
->r_offset
+ 1, 2))
866 /* That will change things, so, we should relax again.
867 Note that this is not required, and it may be slow. */
871 /* Try to turn a 24bit immediate, displacement or absolute address
872 into a 16bit immediate, displacement or absolute address. */
873 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10200_24
)
875 bfd_vma value
= symval
;
877 /* See if the value will fit in 16 bits.
878 We allow any 16bit match here. We prune those we can't
880 if ((long) value
< 0x7fff && (long) value
> -0x8000)
884 /* All insns which have 24bit operands are 5 bytes long,
885 the first byte will always be 0xf4, but we double check
888 /* Get the first opcode. */
889 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
894 /* Get the second opcode. */
895 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
899 /* mov imm24,dn -> mov imm16,dn */
901 /* Not safe if the high bit is on as relaxing may
902 move the value out of high mem and thus not fit
903 in a signed 16bit value. */
907 /* Note that we've changed the relocation contents, etc. */
908 elf_section_data (sec
)->relocs
= internal_relocs
;
909 elf_section_data (sec
)->this_hdr
.contents
= contents
;
910 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
912 /* Fix the opcode. */
913 bfd_put_8 (abfd
, 0xf8 + (code
& 0x03),
914 contents
+ irel
->r_offset
- 2);
916 /* Fix the relocation's type. */
917 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
920 /* The opcode got shorter too, so we have to fix the
924 /* Delete two bytes of data. */
925 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
926 irel
->r_offset
+ 1, 2))
929 /* That will change things, so, we should relax again.
930 Note that this is not required, and it may be slow. */
934 /* mov imm24,an -> mov imm16,an
935 cmp imm24,an -> cmp imm16,an
936 mov (abs24),dn -> mov (abs16),dn
937 mov dn,(abs24) -> mov dn,(abs16)
938 movb dn,(abs24) -> movb dn,(abs16)
939 movbu (abs24),dn -> movbu (abs16),dn */
946 /* Note that we've changed the relocation contents, etc. */
947 elf_section_data (sec
)->relocs
= internal_relocs
;
948 elf_section_data (sec
)->this_hdr
.contents
= contents
;
949 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
951 if ((code
& 0xfc) == 0x74)
952 code
= 0xdc + (code
& 0x03);
953 else if ((code
& 0xfc) == 0x7c)
954 code
= 0xec + (code
& 0x03);
955 else if ((code
& 0xfc) == 0xc0)
956 code
= 0xc8 + (code
& 0x03);
957 else if ((code
& 0xfc) == 0x40)
958 code
= 0xc0 + (code
& 0x03);
959 else if ((code
& 0xfc) == 0x44)
960 code
= 0xc4 + (code
& 0x03);
961 else if ((code
& 0xfc) == 0xc8)
962 code
= 0xcc + (code
& 0x03);
964 /* Fix the opcode. */
965 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
967 /* Fix the relocation's type. */
968 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
971 /* The opcode got shorter too, so we have to fix the
975 /* Delete two bytes of data. */
976 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
977 irel
->r_offset
+ 1, 2))
980 /* That will change things, so, we should relax again.
981 Note that this is not required, and it may be slow. */
985 /* cmp imm24,dn -> cmp imm16,dn
986 mov (abs24),an -> mov (abs16),an
987 mov an,(abs24) -> mov an,(abs16)
988 add imm24,dn -> add imm16,dn
989 add imm24,an -> add imm16,an
990 sub imm24,dn -> sub imm16,dn
991 sub imm24,an -> sub imm16,an
992 And all d24->d16 in memory ops. */
1009 /* Not safe if the high bit is on as relaxing may
1010 move the value out of high mem and thus not fit
1011 in a signed 16bit value. */
1012 if (((code
& 0xfc) == 0x78
1013 || (code
& 0xfc) == 0x60
1014 || (code
& 0xfc) == 0x64
1015 || (code
& 0xfc) == 0x68
1016 || (code
& 0xfc) == 0x6c
1017 || (code
& 0xfc) == 0x80
1018 || (code
& 0xfc) == 0xf0
1019 || (code
& 0xfc) == 0x00
1020 || (code
& 0xfc) == 0x10
1021 || (code
& 0xfc) == 0xb0
1022 || (code
& 0xfc) == 0x30
1023 || (code
& 0xfc) == 0xa0
1024 || (code
& 0xfc) == 0x20
1025 || (code
& 0xfc) == 0x90)
1026 && (value
& 0x8000) != 0)
1029 /* Note that we've changed the relocation contents, etc. */
1030 elf_section_data (sec
)->relocs
= internal_relocs
;
1031 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1032 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1034 /* Fix the opcode. */
1035 bfd_put_8 (abfd
, 0xf7, contents
+ irel
->r_offset
- 2);
1037 if ((code
& 0xfc) == 0x78)
1038 code
= 0x48 + (code
& 0x03);
1039 else if ((code
& 0xfc) == 0xd0)
1040 code
= 0x30 + (code
& 0x03);
1041 else if ((code
& 0xfc) == 0x50)
1042 code
= 0x20 + (code
& 0x03);
1043 else if ((code
& 0xfc) == 0x60)
1044 code
= 0x18 + (code
& 0x03);
1045 else if ((code
& 0xfc) == 0x64)
1046 code
= 0x08 + (code
& 0x03);
1047 else if ((code
& 0xfc) == 0x68)
1048 code
= 0x1c + (code
& 0x03);
1049 else if ((code
& 0xfc) == 0x6c)
1050 code
= 0x0c + (code
& 0x03);
1051 else if ((code
& 0xfc) == 0x80)
1052 code
= 0xc0 + (code
& 0x07);
1053 else if ((code
& 0xfc) == 0xf0)
1054 code
= 0xb0 + (code
& 0x07);
1055 else if ((code
& 0xfc) == 0x00)
1056 code
= 0x80 + (code
& 0x07);
1057 else if ((code
& 0xfc) == 0x10)
1058 code
= 0xa0 + (code
& 0x07);
1059 else if ((code
& 0xfc) == 0xb0)
1060 code
= 0x70 + (code
& 0x07);
1061 else if ((code
& 0xfc) == 0x30)
1062 code
= 0x60 + (code
& 0x07);
1063 else if ((code
& 0xfc) == 0xa0)
1064 code
= 0xd0 + (code
& 0x07);
1065 else if ((code
& 0xfc) == 0x20)
1066 code
= 0x90 + (code
& 0x07);
1067 else if ((code
& 0xfc) == 0x90)
1068 code
= 0x50 + (code
& 0x07);
1070 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
1072 /* Fix the relocation's type. */
1073 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1076 /* Delete one bytes of data. */
1077 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
1078 irel
->r_offset
+ 2, 1))
1081 /* That will change things, so, we should relax again.
1082 Note that this is not required, and it may be slow. */
1086 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1088 /* Note that we've changed the reldection contents, etc. */
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 bfd_put_8 (abfd
, 0xcc + (code
& 0x03),
1094 contents
+ irel
->r_offset
- 2);
1096 bfd_put_8 (abfd
, 0xb8 + (code
& 0x03),
1097 contents
+ irel
->r_offset
- 1);
1099 /* Fix the relocation's type. */
1100 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1103 /* The reloc will be applied one byte in front of its
1104 current location. */
1105 irel
->r_offset
-= 1;
1107 /* Delete one bytes of data. */
1108 if (!mn10200_elf_relax_delete_bytes (abfd
, sec
,
1109 irel
->r_offset
+ 2, 1))
1112 /* That will change things, so, we should relax again.
1113 Note that this is not required, and it may be slow. */
1122 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1124 if (! link_info
->keep_memory
)
1128 /* Cache the symbols for elf_link_input_bfd. */
1129 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1133 if (contents
!= NULL
1134 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1136 if (! link_info
->keep_memory
)
1140 /* Cache the section contents for elf_link_input_bfd. */
1141 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1145 if (internal_relocs
!= NULL
1146 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1147 free (internal_relocs
);
1153 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1155 if (contents
!= NULL
1156 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1158 if (internal_relocs
!= NULL
1159 && elf_section_data (sec
)->relocs
!= internal_relocs
)
1160 free (internal_relocs
);
1165 /* Delete some bytes from a section while relaxing. */
1168 mn10200_elf_relax_delete_bytes (abfd
, sec
, addr
, count
)
1174 Elf_Internal_Shdr
*symtab_hdr
;
1175 unsigned int sec_shndx
;
1177 Elf_Internal_Rela
*irel
, *irelend
;
1178 Elf_Internal_Rela
*irelalign
;
1180 Elf_Internal_Sym
*isym
;
1181 Elf_Internal_Sym
*isymend
;
1182 struct elf_link_hash_entry
**sym_hashes
;
1183 struct elf_link_hash_entry
**end_hashes
;
1184 unsigned int symcount
;
1186 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1188 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1190 /* The deletion must stop at the next ALIGN reloc for an aligment
1191 power larger than the number of bytes we are deleting. */
1196 irel
= elf_section_data (sec
)->relocs
;
1197 irelend
= irel
+ sec
->reloc_count
;
1199 /* Actually delete the bytes. */
1200 memmove (contents
+ addr
, contents
+ addr
+ count
,
1201 (size_t) (toaddr
- addr
- count
));
1204 /* Adjust all the relocs. */
1205 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1207 /* Get the new reloc address. */
1208 if ((irel
->r_offset
> addr
1209 && irel
->r_offset
< toaddr
))
1210 irel
->r_offset
-= count
;
1213 /* Adjust the local symbols defined in this section. */
1214 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1215 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1216 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1218 if (isym
->st_shndx
== sec_shndx
1219 && isym
->st_value
> addr
1220 && isym
->st_value
< toaddr
)
1221 isym
->st_value
-= count
;
1224 /* Now adjust the global symbols defined in this section. */
1225 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1226 - symtab_hdr
->sh_info
);
1227 sym_hashes
= elf_sym_hashes (abfd
);
1228 end_hashes
= sym_hashes
+ symcount
;
1229 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1231 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1232 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1233 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1234 && sym_hash
->root
.u
.def
.section
== sec
1235 && sym_hash
->root
.u
.def
.value
> addr
1236 && sym_hash
->root
.u
.def
.value
< toaddr
)
1238 sym_hash
->root
.u
.def
.value
-= count
;
1245 /* Return TRUE if a symbol exists at the given address, else return
1248 mn10200_elf_symbol_address_p (abfd
, sec
, isym
, addr
)
1251 Elf_Internal_Sym
*isym
;
1254 Elf_Internal_Shdr
*symtab_hdr
;
1255 unsigned int sec_shndx
;
1256 Elf_Internal_Sym
*isymend
;
1257 struct elf_link_hash_entry
**sym_hashes
;
1258 struct elf_link_hash_entry
**end_hashes
;
1259 unsigned int symcount
;
1261 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1263 /* Examine all the local symbols. */
1264 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1265 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1267 if (isym
->st_shndx
== sec_shndx
1268 && isym
->st_value
== addr
)
1272 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1273 - symtab_hdr
->sh_info
);
1274 sym_hashes
= elf_sym_hashes (abfd
);
1275 end_hashes
= sym_hashes
+ symcount
;
1276 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1278 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1279 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1280 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1281 && sym_hash
->root
.u
.def
.section
== sec
1282 && sym_hash
->root
.u
.def
.value
== addr
)
1289 /* This is a version of bfd_generic_get_relocated_section_contents
1290 which uses mn10200_elf_relocate_section. */
1293 mn10200_elf_get_relocated_section_contents (output_bfd
, link_info
, link_order
,
1294 data
, relocatable
, symbols
)
1296 struct bfd_link_info
*link_info
;
1297 struct bfd_link_order
*link_order
;
1299 bfd_boolean relocatable
;
1302 Elf_Internal_Shdr
*symtab_hdr
;
1303 asection
*input_section
= link_order
->u
.indirect
.section
;
1304 bfd
*input_bfd
= input_section
->owner
;
1305 asection
**sections
= NULL
;
1306 Elf_Internal_Rela
*internal_relocs
= NULL
;
1307 Elf_Internal_Sym
*isymbuf
= NULL
;
1309 /* We only need to handle the case of relaxing, or of having a
1310 particular set of section contents, specially. */
1312 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1313 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1318 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1320 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1321 (size_t) input_section
->size
);
1323 if ((input_section
->flags
& SEC_RELOC
) != 0
1324 && input_section
->reloc_count
> 0)
1326 Elf_Internal_Sym
*isym
;
1327 Elf_Internal_Sym
*isymend
;
1331 internal_relocs
= (_bfd_elf_link_read_relocs
1332 (input_bfd
, input_section
, (PTR
) NULL
,
1333 (Elf_Internal_Rela
*) NULL
, FALSE
));
1334 if (internal_relocs
== NULL
)
1337 if (symtab_hdr
->sh_info
!= 0)
1339 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1340 if (isymbuf
== NULL
)
1341 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1342 symtab_hdr
->sh_info
, 0,
1344 if (isymbuf
== NULL
)
1348 amt
= symtab_hdr
->sh_info
;
1349 amt
*= sizeof (asection
*);
1350 sections
= (asection
**) bfd_malloc (amt
);
1351 if (sections
== NULL
&& amt
!= 0)
1354 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1355 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1359 if (isym
->st_shndx
== SHN_UNDEF
)
1360 isec
= bfd_und_section_ptr
;
1361 else if (isym
->st_shndx
== SHN_ABS
)
1362 isec
= bfd_abs_section_ptr
;
1363 else if (isym
->st_shndx
== SHN_COMMON
)
1364 isec
= bfd_com_section_ptr
;
1366 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1371 if (! mn10200_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
1372 input_section
, data
, internal_relocs
,
1376 if (sections
!= NULL
)
1379 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1381 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1382 free (internal_relocs
);
1388 if (sections
!= NULL
)
1391 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1393 if (internal_relocs
!= NULL
1394 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
1395 free (internal_relocs
);
1399 #define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec
1400 #define TARGET_LITTLE_NAME "elf32-mn10200"
1401 #define ELF_ARCH bfd_arch_mn10200
1402 #define ELF_MACHINE_CODE EM_MN10200
1403 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10200
1404 #define ELF_MAXPAGESIZE 0x1000
1406 #define elf_backend_rela_normal 1
1407 #define elf_info_to_howto mn10200_info_to_howto
1408 #define elf_info_to_howto_rel 0
1409 #define elf_backend_relocate_section mn10200_elf_relocate_section
1410 #define bfd_elf32_bfd_relax_section mn10200_elf_relax_section
1411 #define bfd_elf32_bfd_get_relocated_section_contents \
1412 mn10200_elf_get_relocated_section_contents
1414 #define elf_symbol_leading_char '_'
1416 #include "elf32-target.h"