1 /* Matsushita 10200 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 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. */
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 if (info->relocatable)
349 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
350 sym_hashes = elf_sym_hashes (input_bfd);
353 relend = relocs + input_section->reloc_count;
354 for (; rel < relend; rel++)
357 reloc_howto_type *howto;
358 unsigned long r_symndx;
359 Elf_Internal_Sym *sym;
361 struct elf_link_hash_entry *h;
363 bfd_reloc_status_type r;
365 r_symndx = ELF32_R_SYM (rel->r_info);
366 r_type = ELF32_R_TYPE (rel->r_info);
367 howto = elf_mn10200_howto_table + r_type;
372 if (r_symndx < symtab_hdr->sh_info)
374 sym = local_syms + r_symndx;
375 sec = local_sections[r_symndx];
376 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
380 bfd_boolean unresolved_reloc, warned;
382 RELOC_FOR_GLOBAL_SYMBOL (h, sym_hashes, r_symndx, symtab_hdr,
383 relocation, sec, unresolved_reloc,
387 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
389 contents, rel->r_offset,
390 relocation, rel->r_addend,
391 info, sec, h == NULL);
393 if (r != bfd_reloc_ok)
396 const char *msg = (const char *) 0;
399 name = h->root.root.string;
402 name = (bfd_elf_string_from_elf_section
403 (input_bfd, symtab_hdr->sh_link, sym->st_name));
404 if (name == NULL || *name == '\0')
405 name = bfd_section_name (input_bfd, sec);
410 case bfd_reloc_overflow:
411 if (! ((*info->callbacks->reloc_overflow)
412 (info, name, howto->name, (bfd_vma) 0,
413 input_bfd, input_section, rel->r_offset)))
417 case bfd_reloc_undefined:
418 if (! ((*info->callbacks->undefined_symbol)
419 (info, name, input_bfd, input_section,
420 rel->r_offset, TRUE)))
424 case bfd_reloc_outofrange:
425 msg = _("internal error: out of range error");
428 case bfd_reloc_notsupported:
429 msg = _("internal error: unsupported relocation error");
432 case bfd_reloc_dangerous:
433 msg = _("internal error: dangerous error");
437 msg = _("internal error: unknown error");
441 if (!((*info->callbacks->warning)
442 (info, msg, name, input_bfd, input_section,
453 /* This function handles relaxing for the mn10200.
455 There are quite a few relaxing opportunities available on the mn10200:
457 * jsr:24 -> jsr:16 2 bytes
459 * jmp:24 -> jmp:16 2 bytes
460 * jmp:16 -> bra:8 1 byte
462 * If the previous instruction is a conditional branch
463 around the jump/bra, we may be able to reverse its condition
464 and change its target to the jump's target. The jump/bra
465 can then be deleted. 2 bytes
467 * mov abs24 -> mov abs16 2 byte savings
469 * Most instructions which accept imm24 can relax to imm16 2 bytes
470 - Most instructions which accept imm16 can relax to imm8 1 byte
472 * Most instructions which accept d24 can relax to d16 2 bytes
473 - Most instructions which accept d16 can relax to d8 1 byte
475 abs24, imm24, d24 all look the same at the reloc level. It
476 might make the code simpler if we had different relocs for
477 the various relaxable operand types.
479 We don't handle imm16->imm8 or d16->d8 as they're very rare
480 and somewhat more difficult to support. */
483 mn10200_elf_relax_section (abfd, sec, link_info, again)
486 struct bfd_link_info *link_info;
489 Elf_Internal_Shdr *symtab_hdr;
490 Elf_Internal_Rela *internal_relocs;
491 Elf_Internal_Rela *irel, *irelend;
492 bfd_byte *contents = NULL;
493 Elf_Internal_Sym *isymbuf = NULL;
495 /* Assume nothing changes. */
498 /* We don't have to do anything for a relocatable link, if
499 this section does not have relocs, or if this is not a
501 if (link_info->relocatable
502 || (sec->flags & SEC_RELOC) == 0
503 || sec->reloc_count == 0
504 || (sec->flags & SEC_CODE) == 0)
507 /* If this is the first time we have been called for this section,
508 initialize the cooked size. */
509 if (sec->_cooked_size == 0)
510 sec->_cooked_size = sec->_raw_size;
512 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
514 /* Get a copy of the native relocations. */
515 internal_relocs = (_bfd_elf_link_read_relocs
516 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
517 link_info->keep_memory));
518 if (internal_relocs == NULL)
521 /* Walk through them looking for relaxing opportunities. */
522 irelend = internal_relocs + sec->reloc_count;
523 for (irel = internal_relocs; irel < irelend; irel++)
527 /* If this isn't something that can be relaxed, then ignore
529 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
530 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
531 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
534 /* Get the section contents if we haven't done so already. */
535 if (contents == NULL)
537 /* Get cached copy if it exists. */
538 if (elf_section_data (sec)->this_hdr.contents != NULL)
539 contents = elf_section_data (sec)->this_hdr.contents;
542 /* Go get them off disk. */
543 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
544 if (contents == NULL)
547 if (! bfd_get_section_contents (abfd, sec, contents,
548 (file_ptr) 0, sec->_raw_size))
553 /* Read this BFD's local symbols if we haven't done so already. */
554 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
556 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
558 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
559 symtab_hdr->sh_info, 0,
565 /* Get the value of the symbol referred to by the reloc. */
566 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
568 /* A local symbol. */
569 Elf_Internal_Sym *isym;
572 isym = isymbuf + ELF32_R_SYM (irel->r_info);
573 if (isym->st_shndx == SHN_UNDEF)
574 sym_sec = bfd_und_section_ptr;
575 else if (isym->st_shndx == SHN_ABS)
576 sym_sec = bfd_abs_section_ptr;
577 else if (isym->st_shndx == SHN_COMMON)
578 sym_sec = bfd_com_section_ptr;
580 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
581 symval = (isym->st_value
582 + sym_sec->output_section->vma
583 + sym_sec->output_offset);
588 struct elf_link_hash_entry *h;
590 /* An external symbol. */
591 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
592 h = elf_sym_hashes (abfd)[indx];
593 BFD_ASSERT (h != NULL);
594 if (h->root.type != bfd_link_hash_defined
595 && h->root.type != bfd_link_hash_defweak)
597 /* This appears to be a reference to an undefined
598 symbol. Just ignore it--it will be caught by the
599 regular reloc processing. */
603 symval = (h->root.u.def.value
604 + h->root.u.def.section->output_section->vma
605 + h->root.u.def.section->output_offset);
608 /* For simplicity of coding, we are going to modify the section
609 contents, the section relocs, and the BFD symbol table. We
610 must tell the rest of the code not to free up this
611 information. It would be possible to instead create a table
612 of changes which have to be made, as is done in coff-mips.c;
613 that would be more work, but would require less memory when
614 the linker is run. */
616 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
618 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
620 bfd_vma value = symval;
622 /* Deal with pc-relative gunk. */
623 value -= (sec->output_section->vma + sec->output_offset);
624 value -= (irel->r_offset + 3);
625 value += irel->r_addend;
627 /* See if the value will fit in 16 bits, note the high value is
628 0x7fff + 2 as the target will be two bytes closer if we are
630 if ((long) value < 0x8001 && (long) value > -0x8000)
634 /* Get the opcode. */
635 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
637 if (code != 0xe0 && code != 0xe1)
640 /* Note that we've changed the relocs, section contents, etc. */
641 elf_section_data (sec)->relocs = internal_relocs;
642 elf_section_data (sec)->this_hdr.contents = contents;
643 symtab_hdr->contents = (unsigned char *) isymbuf;
645 /* Fix the opcode. */
647 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
648 else if (code == 0xe1)
649 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
651 /* Fix the relocation's type. */
652 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
655 /* The opcode got shorter too, so we have to fix the offset. */
658 /* Delete two bytes of data. */
659 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
660 irel->r_offset + 1, 2))
663 /* That will change things, so, we should relax again.
664 Note that this is not required, and it may be slow. */
669 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
671 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
673 bfd_vma value = symval;
675 /* Deal with pc-relative gunk. */
676 value -= (sec->output_section->vma + sec->output_offset);
677 value -= (irel->r_offset + 2);
678 value += irel->r_addend;
680 /* See if the value will fit in 8 bits, note the high value is
681 0x7f + 1 as the target will be one bytes closer if we are
683 if ((long) value < 0x80 && (long) value > -0x80)
687 /* Get the opcode. */
688 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
693 /* Note that we've changed the relocs, section contents, etc. */
694 elf_section_data (sec)->relocs = internal_relocs;
695 elf_section_data (sec)->this_hdr.contents = contents;
696 symtab_hdr->contents = (unsigned char *) isymbuf;
698 /* Fix the opcode. */
699 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
701 /* Fix the relocation's type. */
702 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
705 /* Delete one byte of data. */
706 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
707 irel->r_offset + 1, 1))
710 /* That will change things, so, we should relax again.
711 Note that this is not required, and it may be slow. */
716 /* Try to eliminate an unconditional 8 bit pc-relative branch
717 which immediately follows a conditional 8 bit pc-relative
718 branch around the unconditional branch.
725 This happens when the bCC can't reach lab2 at assembly time,
726 but due to other relaxations it can reach at link time. */
727 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
729 Elf_Internal_Rela *nrel;
730 bfd_vma value = symval;
733 /* Deal with pc-relative gunk. */
734 value -= (sec->output_section->vma + sec->output_offset);
735 value -= (irel->r_offset + 1);
736 value += irel->r_addend;
738 /* Do nothing if this reloc is the last byte in the section. */
739 if (irel->r_offset == sec->_cooked_size)
742 /* See if the next instruction is an unconditional pc-relative
743 branch, more often than not this test will fail, so we
744 test it first to speed things up. */
745 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
749 /* Also make sure the next relocation applies to the next
750 instruction and that it's a pc-relative 8 bit branch. */
753 || irel->r_offset + 2 != nrel->r_offset
754 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
757 /* Make sure our destination immediately follows the
758 unconditional branch. */
759 if (symval != (sec->output_section->vma + sec->output_offset
760 + irel->r_offset + 3))
763 /* Now make sure we are a conditional branch. This may not
764 be necessary, but why take the chance.
766 Note these checks assume that R_MN10200_PCREL8 relocs
767 only occur on bCC and bCCx insns. If they occured
768 elsewhere, we'd need to know the start of this insn
769 for this check to be accurate. */
770 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
771 if (code != 0xe0 && code != 0xe1 && code != 0xe2
772 && code != 0xe3 && code != 0xe4 && code != 0xe5
773 && code != 0xe6 && code != 0xe7 && code != 0xe8
774 && code != 0xe9 && code != 0xec && code != 0xed
775 && code != 0xee && code != 0xef && code != 0xfc
776 && code != 0xfd && code != 0xfe && code != 0xff)
779 /* We also have to be sure there is no symbol/label
780 at the unconditional branch. */
781 if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf,
785 /* Note that we've changed the relocs, section contents, etc. */
786 elf_section_data (sec)->relocs = internal_relocs;
787 elf_section_data (sec)->this_hdr.contents = contents;
788 symtab_hdr->contents = (unsigned char *) isymbuf;
790 /* Reverse the condition of the first branch. */
848 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
850 /* Set the reloc type and symbol for the first branch
851 from the second branch. */
852 irel->r_info = nrel->r_info;
854 /* Make the reloc for the second branch a null reloc. */
855 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
858 /* Delete two bytes of data. */
859 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
860 irel->r_offset + 1, 2))
863 /* That will change things, so, we should relax again.
864 Note that this is not required, and it may be slow. */
868 /* Try to turn a 24bit immediate, displacement or absolute address
869 into a 16bit immediate, displacement or absolute address. */
870 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
872 bfd_vma value = symval;
874 /* See if the value will fit in 16 bits.
875 We allow any 16bit match here. We prune those we can't
877 if ((long) value < 0x7fff && (long) value > -0x8000)
881 /* All insns which have 24bit operands are 5 bytes long,
882 the first byte will always be 0xf4, but we double check
885 /* Get the first opcode. */
886 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
891 /* Get the second opcode. */
892 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
896 /* mov imm24,dn -> mov imm16,dn */
898 /* Not safe if the high bit is on as relaxing may
899 move the value out of high mem and thus not fit
900 in a signed 16bit value. */
904 /* Note that we've changed the relocation contents, etc. */
905 elf_section_data (sec)->relocs = internal_relocs;
906 elf_section_data (sec)->this_hdr.contents = contents;
907 symtab_hdr->contents = (unsigned char *) isymbuf;
909 /* Fix the opcode. */
910 bfd_put_8 (abfd, 0xf8 + (code & 0x03),
911 contents + irel->r_offset - 2);
913 /* Fix the relocation's type. */
914 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
917 /* The opcode got shorter too, so we have to fix the
921 /* Delete two bytes of data. */
922 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
923 irel->r_offset + 1, 2))
926 /* That will change things, so, we should relax again.
927 Note that this is not required, and it may be slow. */
931 /* mov imm24,an -> mov imm16,an
932 cmp imm24,an -> cmp imm16,an
933 mov (abs24),dn -> mov (abs16),dn
934 mov dn,(abs24) -> mov dn,(abs16)
935 movb dn,(abs24) -> movb dn,(abs16)
936 movbu (abs24),dn -> movbu (abs16),dn */
943 /* Note that we've changed the relocation contents, etc. */
944 elf_section_data (sec)->relocs = internal_relocs;
945 elf_section_data (sec)->this_hdr.contents = contents;
946 symtab_hdr->contents = (unsigned char *) isymbuf;
948 if ((code & 0xfc) == 0x74)
949 code = 0xdc + (code & 0x03);
950 else if ((code & 0xfc) == 0x7c)
951 code = 0xec + (code & 0x03);
952 else if ((code & 0xfc) == 0xc0)
953 code = 0xc8 + (code & 0x03);
954 else if ((code & 0xfc) == 0x40)
955 code = 0xc0 + (code & 0x03);
956 else if ((code & 0xfc) == 0x44)
957 code = 0xc4 + (code & 0x03);
958 else if ((code & 0xfc) == 0xc8)
959 code = 0xcc + (code & 0x03);
961 /* Fix the opcode. */
962 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
964 /* Fix the relocation's type. */
965 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
968 /* The opcode got shorter too, so we have to fix the
972 /* Delete two bytes of data. */
973 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
974 irel->r_offset + 1, 2))
977 /* That will change things, so, we should relax again.
978 Note that this is not required, and it may be slow. */
982 /* cmp imm24,dn -> cmp imm16,dn
983 mov (abs24),an -> mov (abs16),an
984 mov an,(abs24) -> mov an,(abs16)
985 add imm24,dn -> add imm16,dn
986 add imm24,an -> add imm16,an
987 sub imm24,dn -> sub imm16,dn
988 sub imm24,an -> sub imm16,an
989 And all d24->d16 in memory ops. */
1006 /* Not safe if the high bit is on as relaxing may
1007 move the value out of high mem and thus not fit
1008 in a signed 16bit value. */
1009 if (((code & 0xfc) == 0x78
1010 || (code & 0xfc) == 0x60
1011 || (code & 0xfc) == 0x64
1012 || (code & 0xfc) == 0x68
1013 || (code & 0xfc) == 0x6c
1014 || (code & 0xfc) == 0x80
1015 || (code & 0xfc) == 0xf0
1016 || (code & 0xfc) == 0x00
1017 || (code & 0xfc) == 0x10
1018 || (code & 0xfc) == 0xb0
1019 || (code & 0xfc) == 0x30
1020 || (code & 0xfc) == 0xa0
1021 || (code & 0xfc) == 0x20
1022 || (code & 0xfc) == 0x90)
1023 && (value & 0x8000) != 0)
1026 /* Note that we've changed the relocation contents, etc. */
1027 elf_section_data (sec)->relocs = internal_relocs;
1028 elf_section_data (sec)->this_hdr.contents = contents;
1029 symtab_hdr->contents = (unsigned char *) isymbuf;
1031 /* Fix the opcode. */
1032 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1034 if ((code & 0xfc) == 0x78)
1035 code = 0x48 + (code & 0x03);
1036 else if ((code & 0xfc) == 0xd0)
1037 code = 0x30 + (code & 0x03);
1038 else if ((code & 0xfc) == 0x50)
1039 code = 0x20 + (code & 0x03);
1040 else if ((code & 0xfc) == 0x60)
1041 code = 0x18 + (code & 0x03);
1042 else if ((code & 0xfc) == 0x64)
1043 code = 0x08 + (code & 0x03);
1044 else if ((code & 0xfc) == 0x68)
1045 code = 0x1c + (code & 0x03);
1046 else if ((code & 0xfc) == 0x6c)
1047 code = 0x0c + (code & 0x03);
1048 else if ((code & 0xfc) == 0x80)
1049 code = 0xc0 + (code & 0x07);
1050 else if ((code & 0xfc) == 0xf0)
1051 code = 0xb0 + (code & 0x07);
1052 else if ((code & 0xfc) == 0x00)
1053 code = 0x80 + (code & 0x07);
1054 else if ((code & 0xfc) == 0x10)
1055 code = 0xa0 + (code & 0x07);
1056 else if ((code & 0xfc) == 0xb0)
1057 code = 0x70 + (code & 0x07);
1058 else if ((code & 0xfc) == 0x30)
1059 code = 0x60 + (code & 0x07);
1060 else if ((code & 0xfc) == 0xa0)
1061 code = 0xd0 + (code & 0x07);
1062 else if ((code & 0xfc) == 0x20)
1063 code = 0x90 + (code & 0x07);
1064 else if ((code & 0xfc) == 0x90)
1065 code = 0x50 + (code & 0x07);
1067 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1069 /* Fix the relocation's type. */
1070 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1073 /* Delete one bytes of data. */
1074 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1075 irel->r_offset + 2, 1))
1078 /* That will change things, so, we should relax again.
1079 Note that this is not required, and it may be slow. */
1083 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1085 /* Note that we've changed the reldection contents, etc. */
1086 elf_section_data (sec)->relocs = internal_relocs;
1087 elf_section_data (sec)->this_hdr.contents = contents;
1088 symtab_hdr->contents = (unsigned char *) isymbuf;
1090 bfd_put_8 (abfd, 0xcc + (code & 0x03),
1091 contents + irel->r_offset - 2);
1093 bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1094 contents + irel->r_offset - 1);
1096 /* Fix the relocation's type. */
1097 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1100 /* The reloc will be applied one byte in front of its
1101 current location. */
1102 irel->r_offset -= 1;
1104 /* Delete one bytes of data. */
1105 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1106 irel->r_offset + 2, 1))
1109 /* That will change things, so, we should relax again.
1110 Note that this is not required, and it may be slow. */
1119 && symtab_hdr->contents != (unsigned char *) isymbuf)
1121 if (! link_info->keep_memory)
1125 /* Cache the symbols for elf_link_input_bfd. */
1126 symtab_hdr->contents = (unsigned char *) isymbuf;
1130 if (contents != NULL
1131 && elf_section_data (sec)->this_hdr.contents != contents)
1133 if (! link_info->keep_memory)
1137 /* Cache the section contents for elf_link_input_bfd. */
1138 elf_section_data (sec)->this_hdr.contents = contents;
1142 if (internal_relocs != NULL
1143 && elf_section_data (sec)->relocs != internal_relocs)
1144 free (internal_relocs);
1150 && symtab_hdr->contents != (unsigned char *) isymbuf)
1152 if (contents != NULL
1153 && elf_section_data (sec)->this_hdr.contents != contents)
1155 if (internal_relocs != NULL
1156 && elf_section_data (sec)->relocs != internal_relocs)
1157 free (internal_relocs);
1162 /* Delete some bytes from a section while relaxing. */
1165 mn10200_elf_relax_delete_bytes (abfd, sec, addr, count)
1171 Elf_Internal_Shdr *symtab_hdr;
1172 unsigned int sec_shndx;
1174 Elf_Internal_Rela *irel, *irelend;
1175 Elf_Internal_Rela *irelalign;
1177 Elf_Internal_Sym *isym;
1178 Elf_Internal_Sym *isymend;
1179 struct elf_link_hash_entry **sym_hashes;
1180 struct elf_link_hash_entry **end_hashes;
1181 unsigned int symcount;
1183 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1185 contents = elf_section_data (sec)->this_hdr.contents;
1187 /* The deletion must stop at the next ALIGN reloc for an aligment
1188 power larger than the number of bytes we are deleting. */
1191 toaddr = sec->_cooked_size;
1193 irel = elf_section_data (sec)->relocs;
1194 irelend = irel + sec->reloc_count;
1196 /* Actually delete the bytes. */
1197 memmove (contents + addr, contents + addr + count,
1198 (size_t) (toaddr - addr - count));
1199 sec->_cooked_size -= count;
1201 /* Adjust all the relocs. */
1202 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1204 /* Get the new reloc address. */
1205 if ((irel->r_offset > addr
1206 && irel->r_offset < toaddr))
1207 irel->r_offset -= count;
1210 /* Adjust the local symbols defined in this section. */
1211 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1212 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1213 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1215 if (isym->st_shndx == sec_shndx
1216 && isym->st_value > addr
1217 && isym->st_value < toaddr)
1218 isym->st_value -= count;
1221 /* Now adjust the global symbols defined in this section. */
1222 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1223 - symtab_hdr->sh_info);
1224 sym_hashes = elf_sym_hashes (abfd);
1225 end_hashes = sym_hashes + symcount;
1226 for (; sym_hashes < end_hashes; sym_hashes++)
1228 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1229 if ((sym_hash->root.type == bfd_link_hash_defined
1230 || sym_hash->root.type == bfd_link_hash_defweak)
1231 && sym_hash->root.u.def.section == sec
1232 && sym_hash->root.u.def.value > addr
1233 && sym_hash->root.u.def.value < toaddr)
1235 sym_hash->root.u.def.value -= count;
1242 /* Return TRUE if a symbol exists at the given address, else return
1245 mn10200_elf_symbol_address_p (abfd, sec, isym, addr)
1248 Elf_Internal_Sym *isym;
1251 Elf_Internal_Shdr *symtab_hdr;
1252 unsigned int sec_shndx;
1253 Elf_Internal_Sym *isymend;
1254 struct elf_link_hash_entry **sym_hashes;
1255 struct elf_link_hash_entry **end_hashes;
1256 unsigned int symcount;
1258 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1260 /* Examine all the local symbols. */
1261 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1262 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1264 if (isym->st_shndx == sec_shndx
1265 && isym->st_value == addr)
1269 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1270 - symtab_hdr->sh_info);
1271 sym_hashes = elf_sym_hashes (abfd);
1272 end_hashes = sym_hashes + symcount;
1273 for (; sym_hashes < end_hashes; sym_hashes++)
1275 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1276 if ((sym_hash->root.type == bfd_link_hash_defined
1277 || sym_hash->root.type == bfd_link_hash_defweak)
1278 && sym_hash->root.u.def.section == sec
1279 && sym_hash->root.u.def.value == addr)
1286 /* This is a version of bfd_generic_get_relocated_section_contents
1287 which uses mn10200_elf_relocate_section. */
1290 mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1291 data, relocatable, symbols)
1293 struct bfd_link_info *link_info;
1294 struct bfd_link_order *link_order;
1296 bfd_boolean relocatable;
1299 Elf_Internal_Shdr *symtab_hdr;
1300 asection *input_section = link_order->u.indirect.section;
1301 bfd *input_bfd = input_section->owner;
1302 asection **sections = NULL;
1303 Elf_Internal_Rela *internal_relocs = NULL;
1304 Elf_Internal_Sym *isymbuf = NULL;
1306 /* We only need to handle the case of relaxing, or of having a
1307 particular set of section contents, specially. */
1309 || elf_section_data (input_section)->this_hdr.contents == NULL)
1310 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1315 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1317 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1318 (size_t) input_section->_raw_size);
1320 if ((input_section->flags & SEC_RELOC) != 0
1321 && input_section->reloc_count > 0)
1323 Elf_Internal_Sym *isym;
1324 Elf_Internal_Sym *isymend;
1328 internal_relocs = (_bfd_elf_link_read_relocs
1329 (input_bfd, input_section, (PTR) NULL,
1330 (Elf_Internal_Rela *) NULL, FALSE));
1331 if (internal_relocs == NULL)
1334 if (symtab_hdr->sh_info != 0)
1336 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1337 if (isymbuf == NULL)
1338 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1339 symtab_hdr->sh_info, 0,
1341 if (isymbuf == NULL)
1345 amt = symtab_hdr->sh_info;
1346 amt *= sizeof (asection *);
1347 sections = (asection **) bfd_malloc (amt);
1348 if (sections == NULL && amt != 0)
1351 isymend = isymbuf + symtab_hdr->sh_info;
1352 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1356 if (isym->st_shndx == SHN_UNDEF)
1357 isec = bfd_und_section_ptr;
1358 else if (isym->st_shndx == SHN_ABS)
1359 isec = bfd_abs_section_ptr;
1360 else if (isym->st_shndx == SHN_COMMON)
1361 isec = bfd_com_section_ptr;
1363 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1368 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1369 input_section, data, internal_relocs,
1373 if (sections != NULL)
1376 && symtab_hdr->contents != (unsigned char *) isymbuf)
1378 if (elf_section_data (input_section)->relocs != internal_relocs)
1379 free (internal_relocs);
1385 if (sections != NULL)
1388 && symtab_hdr->contents != (unsigned char *) isymbuf)
1390 if (internal_relocs != NULL
1391 && elf_section_data (input_section)->relocs != internal_relocs)
1392 free (internal_relocs);
1396 #define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec
1397 #define TARGET_LITTLE_NAME "elf32-mn10200"
1398 #define ELF_ARCH bfd_arch_mn10200
1399 #define ELF_MACHINE_CODE EM_MN10200
1400 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10200
1401 #define ELF_MAXPAGESIZE 0x1000
1403 #define elf_backend_rela_normal 1
1404 #define elf_info_to_howto mn10200_info_to_howto
1405 #define elf_info_to_howto_rel 0
1406 #define elf_backend_relocate_section mn10200_elf_relocate_section
1407 #define bfd_elf32_bfd_relax_section mn10200_elf_relax_section
1408 #define bfd_elf32_bfd_get_relocated_section_contents \
1409 mn10200_elf_get_relocated_section_contents
1411 #define elf_symbol_leading_char '_'
1413 #include "elf32-target.h"