1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 #include "elf/mn10300.h"
26 struct elf32_mn10300_link_hash_entry
28 /* The basic elf link hash table entry. */
29 struct elf_link_hash_entry root;
31 /* For function symbols, the number of times this function is
32 called directly (ie by name). */
33 unsigned int direct_calls;
35 /* For function symbols, the size of this function's stack
36 (if <= 255 bytes). We stuff this into "call" instructions
37 to this target when it's valid and profitable to do so.
39 This does not include stack allocated by movm! */
40 unsigned char stack_size;
42 /* For function symbols, arguments (if any) for movm instruction
43 in the prologue. We stuff this value into "call" instructions
44 to the target when it's valid and profitable to do so. */
45 unsigned char movm_args;
47 /* For funtion symbols, the amount of stack space that would be allocated
48 by the movm instruction. This is redundant with movm_args, but we
49 add it to the hash table to avoid computing it over and over. */
50 unsigned char movm_stack_size;
52 /* When set, convert all "call" instructions to this target into "calls"
54 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
56 /* Used to mark functions which have had redundant parts of their
58 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
62 /* We derive a hash table from the main elf linker hash table so
63 we can store state variables and a secondary hash table without
64 resorting to global variables. */
65 struct elf32_mn10300_link_hash_table
67 /* The main hash table. */
68 struct elf_link_hash_table root;
70 /* A hash table for static functions. We could derive a new hash table
71 instead of using the full elf32_mn10300_link_hash_table if we wanted
72 to save some memory. */
73 struct elf32_mn10300_link_hash_table *static_hash_table;
75 /* Random linker state flags. */
76 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
80 /* For MN10300 linker hash table. */
82 /* Get the MN10300 ELF linker hash table from a link_info structure. */
84 #define elf32_mn10300_hash_table(p) \
85 ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
87 #define elf32_mn10300_link_hash_traverse(table, func, info) \
88 (elf_link_hash_traverse \
90 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
93 static struct bfd_hash_entry *elf32_mn10300_link_hash_newfunc
94 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
95 static struct bfd_link_hash_table *elf32_mn10300_link_hash_table_create
98 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
99 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
100 static void mn10300_info_to_howto
101 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
102 static boolean mn10300_elf_check_relocs
103 PARAMS ((bfd *, struct bfd_link_info *, asection *,
104 const Elf_Internal_Rela *));
105 static asection *mn10300_elf_gc_mark_hook
106 PARAMS ((bfd *, struct bfd_link_info *info, Elf_Internal_Rela *,
107 struct elf_link_hash_entry *, Elf_Internal_Sym *));
108 static boolean mn10300_elf_relax_delete_bytes
109 PARAMS ((bfd *, asection *, bfd_vma, int));
110 static boolean mn10300_elf_symbol_address_p
111 PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
112 static boolean elf32_mn10300_finish_hash_table_entry
113 PARAMS ((struct bfd_hash_entry *, PTR));
114 static void compute_function_info
115 PARAMS ((bfd *, struct elf32_mn10300_link_hash_entry *,
116 bfd_vma, unsigned char *));
118 /* We have to use RELA instructions since md_apply_fix3 in the assembler
119 does absolutely nothing. */
123 static reloc_howto_type elf_mn10300_howto_table[] =
125 /* Dummy relocation. Does nothing. */
126 HOWTO (R_MN10300_NONE,
132 complain_overflow_bitfield,
133 bfd_elf_generic_reloc,
139 /* Standard 32 bit reloc. */
146 complain_overflow_bitfield,
147 bfd_elf_generic_reloc,
153 /* Standard 16 bit reloc. */
160 complain_overflow_bitfield,
161 bfd_elf_generic_reloc,
167 /* Standard 8 bit reloc. */
174 complain_overflow_bitfield,
175 bfd_elf_generic_reloc,
181 /* Standard 32bit pc-relative reloc. */
182 HOWTO (R_MN10300_PCREL32,
188 complain_overflow_bitfield,
189 bfd_elf_generic_reloc,
195 /* Standard 16bit pc-relative reloc. */
196 HOWTO (R_MN10300_PCREL16,
202 complain_overflow_bitfield,
203 bfd_elf_generic_reloc,
209 /* Standard 8 pc-relative reloc. */
210 HOWTO (R_MN10300_PCREL8,
216 complain_overflow_bitfield,
217 bfd_elf_generic_reloc,
224 /* GNU extension to record C++ vtable hierarchy */
225 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
227 0, /* size (0 = byte, 1 = short, 2 = long) */
229 false, /* pc_relative */
231 complain_overflow_dont, /* complain_on_overflow */
232 NULL, /* special_function */
233 "R_MN10300_GNU_VTINHERIT", /* name */
234 false, /* partial_inplace */
237 false), /* pcrel_offset */
239 /* GNU extension to record C++ vtable member usage */
240 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
242 0, /* size (0 = byte, 1 = short, 2 = long) */
244 false, /* pc_relative */
246 complain_overflow_dont, /* complain_on_overflow */
247 NULL, /* special_function */
248 "R_MN10300_GNU_VTENTRY", /* name */
249 false, /* partial_inplace */
252 false), /* pcrel_offset */
254 /* Standard 24 bit reloc. */
261 complain_overflow_bitfield,
262 bfd_elf_generic_reloc,
271 struct mn10300_reloc_map
273 bfd_reloc_code_real_type bfd_reloc_val;
274 unsigned char elf_reloc_val;
277 static const struct mn10300_reloc_map mn10300_reloc_map[] =
279 { BFD_RELOC_NONE, R_MN10300_NONE, },
280 { BFD_RELOC_32, R_MN10300_32, },
281 { BFD_RELOC_16, R_MN10300_16, },
282 { BFD_RELOC_8, R_MN10300_8, },
283 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
284 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
285 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
286 { BFD_RELOC_24, R_MN10300_24, },
287 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
288 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
291 static reloc_howto_type *
292 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
294 bfd_reloc_code_real_type code;
299 i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map);
302 if (mn10300_reloc_map[i].bfd_reloc_val == code)
303 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
309 /* Set the howto pointer for an MN10300 ELF reloc. */
312 mn10300_info_to_howto (abfd, cache_ptr, dst)
315 Elf32_Internal_Rela *dst;
319 r_type = ELF32_R_TYPE (dst->r_info);
320 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
321 cache_ptr->howto = &elf_mn10300_howto_table[r_type];
324 /* Look through the relocs for a section during the first phase.
325 Since we don't do .gots or .plts, we just need to consider the
326 virtual table relocs for gc. */
329 mn10300_elf_check_relocs (abfd, info, sec, relocs)
331 struct bfd_link_info *info;
333 const Elf_Internal_Rela *relocs;
335 Elf_Internal_Shdr *symtab_hdr;
336 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
337 const Elf_Internal_Rela *rel;
338 const Elf_Internal_Rela *rel_end;
340 if (info->relocateable)
343 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
344 sym_hashes = elf_sym_hashes (abfd);
345 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
346 if (!elf_bad_symtab (abfd))
347 sym_hashes_end -= symtab_hdr->sh_info;
349 rel_end = relocs + sec->reloc_count;
350 for (rel = relocs; rel < rel_end; rel++)
352 struct elf_link_hash_entry *h;
353 unsigned long r_symndx;
355 r_symndx = ELF32_R_SYM (rel->r_info);
356 if (r_symndx < symtab_hdr->sh_info)
359 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
361 switch (ELF32_R_TYPE (rel->r_info))
363 /* This relocation describes the C++ object vtable hierarchy.
364 Reconstruct it for later use during GC. */
365 case R_MN10300_GNU_VTINHERIT:
366 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
370 /* This relocation describes which C++ vtable entries are actually
371 used. Record for later use during GC. */
372 case R_MN10300_GNU_VTENTRY:
373 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
382 /* Return the section that should be marked against GC for a given
386 mn10300_elf_gc_mark_hook (abfd, info, rel, h, sym)
388 struct bfd_link_info *info;
389 Elf_Internal_Rela *rel;
390 struct elf_link_hash_entry *h;
391 Elf_Internal_Sym *sym;
395 switch (ELF32_R_TYPE (rel->r_info))
397 case R_MN10300_GNU_VTINHERIT:
398 case R_MN10300_GNU_VTENTRY:
402 switch (h->root.type)
404 case bfd_link_hash_defined:
405 case bfd_link_hash_defweak:
406 return h->root.u.def.section;
408 case bfd_link_hash_common:
409 return h->root.u.c.p->section;
418 if (!(elf_bad_symtab (abfd)
419 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
420 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
421 && sym->st_shndx != SHN_COMMON))
423 return bfd_section_from_elf_index (abfd, sym->st_shndx);
430 /* Perform a relocation as part of a final link. */
431 static bfd_reloc_status_type
432 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
433 input_section, contents, offset, value,
434 addend, info, sym_sec, is_local)
435 reloc_howto_type *howto;
438 asection *input_section;
443 struct bfd_link_info *info;
447 unsigned long r_type = howto->type;
448 bfd_byte *hit_data = contents + offset;
457 bfd_put_32 (input_bfd, value, hit_data);
463 if ((long)value > 0x7fffff || (long)value < -0x800000)
464 return bfd_reloc_overflow;
466 bfd_put_8 (input_bfd, value & 0xff, hit_data);
467 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
468 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
474 if ((long)value > 0x7fff || (long)value < -0x8000)
475 return bfd_reloc_overflow;
477 bfd_put_16 (input_bfd, value, hit_data);
483 if ((long)value > 0x7f || (long)value < -0x80)
484 return bfd_reloc_overflow;
486 bfd_put_8 (input_bfd, value, hit_data);
489 case R_MN10300_PCREL8:
490 value -= (input_section->output_section->vma
491 + input_section->output_offset);
495 if ((long)value > 0xff || (long)value < -0x100)
496 return bfd_reloc_overflow;
498 bfd_put_8 (input_bfd, value, hit_data);
501 case R_MN10300_PCREL16:
502 value -= (input_section->output_section->vma
503 + input_section->output_offset);
507 if ((long)value > 0xffff || (long)value < -0x10000)
508 return bfd_reloc_overflow;
510 bfd_put_16 (input_bfd, value, hit_data);
513 case R_MN10300_PCREL32:
514 value -= (input_section->output_section->vma
515 + input_section->output_offset);
519 bfd_put_32 (input_bfd, value, hit_data);
522 case R_MN10300_GNU_VTINHERIT:
523 case R_MN10300_GNU_VTENTRY:
527 return bfd_reloc_notsupported;
532 /* Relocate an MN10300 ELF section. */
534 mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
535 contents, relocs, local_syms, local_sections)
537 struct bfd_link_info *info;
539 asection *input_section;
541 Elf_Internal_Rela *relocs;
542 Elf_Internal_Sym *local_syms;
543 asection **local_sections;
545 Elf_Internal_Shdr *symtab_hdr;
546 struct elf32_mn10300_link_hash_entry **sym_hashes;
547 Elf_Internal_Rela *rel, *relend;
549 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
550 sym_hashes = (struct elf32_mn10300_link_hash_entry **)
551 (elf_sym_hashes (input_bfd));
554 relend = relocs + input_section->reloc_count;
555 for (; rel < relend; rel++)
558 reloc_howto_type *howto;
559 unsigned long r_symndx;
560 Elf_Internal_Sym *sym;
562 struct elf32_mn10300_link_hash_entry *h;
564 bfd_reloc_status_type r;
566 r_symndx = ELF32_R_SYM (rel->r_info);
567 r_type = ELF32_R_TYPE (rel->r_info);
568 howto = elf_mn10300_howto_table + r_type;
570 /* Just skip the vtable gc relocs. */
571 if (r_type == R_MN10300_GNU_VTINHERIT
572 || r_type == R_MN10300_GNU_VTENTRY)
575 if (info->relocateable)
577 /* This is a relocateable link. We don't have to change
578 anything, unless the reloc is against a section symbol,
579 in which case we have to adjust according to where the
580 section symbol winds up in the output section. */
581 if (r_symndx < symtab_hdr->sh_info)
583 sym = local_syms + r_symndx;
584 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
586 sec = local_sections[r_symndx];
587 rel->r_addend += sec->output_offset + sym->st_value;
594 /* This is a final link. */
598 if (r_symndx < symtab_hdr->sh_info)
600 sym = local_syms + r_symndx;
601 sec = local_sections[r_symndx];
602 relocation = (sec->output_section->vma
608 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
609 while (h->root.type == bfd_link_hash_indirect
610 || h->root.type == bfd_link_hash_warning)
611 h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
612 if (h->root.root.type == bfd_link_hash_defined
613 || h->root.root.type == bfd_link_hash_defweak)
615 sec = h->root.root.u.def.section;
616 relocation = (h->root.root.u.def.value
617 + sec->output_section->vma
618 + sec->output_offset);
620 else if (h->root.root.type == bfd_link_hash_undefweak)
624 if (! ((*info->callbacks->undefined_symbol)
625 (info, h->root.root.root.string, input_bfd,
626 input_section, rel->r_offset)))
632 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
634 contents, rel->r_offset,
635 relocation, rel->r_addend,
636 info, sec, h == NULL);
638 if (r != bfd_reloc_ok)
641 const char *msg = (const char *)0;
644 name = h->root.root.root.string;
647 name = (bfd_elf_string_from_elf_section
648 (input_bfd, symtab_hdr->sh_link, sym->st_name));
649 if (name == NULL || *name == '\0')
650 name = bfd_section_name (input_bfd, sec);
655 case bfd_reloc_overflow:
656 if (! ((*info->callbacks->reloc_overflow)
657 (info, name, howto->name, (bfd_vma) 0,
658 input_bfd, input_section, rel->r_offset)))
662 case bfd_reloc_undefined:
663 if (! ((*info->callbacks->undefined_symbol)
664 (info, name, input_bfd, input_section,
669 case bfd_reloc_outofrange:
670 msg = _("internal error: out of range error");
673 case bfd_reloc_notsupported:
674 msg = _("internal error: unsupported relocation error");
677 case bfd_reloc_dangerous:
678 msg = _("internal error: dangerous error");
682 msg = _("internal error: unknown error");
686 if (!((*info->callbacks->warning)
687 (info, msg, name, input_bfd, input_section,
698 /* Finish initializing one hash table entry. */
700 elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
701 struct bfd_hash_entry *gen_entry;
704 struct elf32_mn10300_link_hash_entry *entry;
705 unsigned int byte_count = 0;
707 entry = (struct elf32_mn10300_link_hash_entry *)gen_entry;
709 /* If we already know we want to convert "call" to "calls" for calls
710 to this symbol, then return now. */
711 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
714 /* If there are no named calls to this symbol, or there's nothing we
715 can move from the function itself into the "call" instruction, then
716 note that all "call" instructions should be converted into "calls"
717 instructions and return. */
718 if (entry->direct_calls == 0
719 || (entry->stack_size == 0 && entry->movm_args == 0))
721 /* Make a note that we should convert "call" instructions to "calls"
722 instructions for calls to this symbol. */
723 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
727 /* We may be able to move some instructions from the function itself into
728 the "call" instruction. Count how many bytes we might be able to
729 eliminate in the function itself. */
731 /* A movm instruction is two bytes. */
732 if (entry->movm_args)
735 /* Count the insn to allocate stack space too. */
736 if (entry->stack_size > 0 && entry->stack_size <= 128)
738 else if (entry->stack_size > 0 && entry->stack_size < 256)
741 /* If using "call" will result in larger code, then turn all
742 the associated "call" instructions into "calls" instrutions. */
743 if (byte_count < entry->direct_calls)
744 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
746 /* This routine never fails. */
750 /* This function handles relaxing for the mn10300.
752 There's quite a few relaxing opportunites available on the mn10300:
754 * calls:32 -> calls:16 2 bytes
755 * call:32 -> call:16 2 bytes
757 * call:32 -> calls:32 1 byte
758 * call:16 -> calls:16 1 byte
759 * These are done anytime using "calls" would result
760 in smaller code, or when necessary to preserve the
761 meaning of the program.
765 * In some circumstances we can move instructions
766 from a function prologue into a "call" instruction.
767 This is only done if the resulting code is no larger
768 than the original code.
771 * jmp:32 -> jmp:16 2 bytes
772 * jmp:16 -> bra:8 1 byte
774 * If the previous instruction is a conditional branch
775 around the jump/bra, we may be able to reverse its condition
776 and change its target to the jump's target. The jump/bra
777 can then be deleted. 2 bytes
779 * mov abs32 -> mov abs16 1 or 2 bytes
781 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
782 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
784 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
785 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
787 We don't handle imm16->imm8 or d16->d8 as they're very rare
788 and somewhat more difficult to support. */
791 mn10300_elf_relax_section (abfd, sec, link_info, again)
794 struct bfd_link_info *link_info;
797 Elf_Internal_Shdr *symtab_hdr;
798 Elf_Internal_Rela *internal_relocs = NULL;
799 Elf_Internal_Rela *free_relocs = NULL;
800 Elf_Internal_Rela *irel, *irelend;
801 bfd_byte *contents = NULL;
802 bfd_byte *free_contents = NULL;
803 Elf32_External_Sym *extsyms = NULL;
804 Elf32_External_Sym *free_extsyms = NULL;
805 struct elf32_mn10300_link_hash_table *hash_table;
807 /* Assume nothing changes. */
810 /* We need a pointer to the mn10300 specific hash table. */
811 hash_table = elf32_mn10300_hash_table (link_info);
813 /* Initialize fields in each hash table entry the first time through. */
814 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
818 /* Iterate over all the input bfds. */
819 for (input_bfd = link_info->input_bfds;
821 input_bfd = input_bfd->link_next)
825 /* We're going to need all the symbols for each bfd. */
826 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
828 /* Get cached copy if it exists. */
829 if (symtab_hdr->contents != NULL)
830 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
833 /* Go get them off disk. */
834 extsyms = ((Elf32_External_Sym *)
835 bfd_malloc (symtab_hdr->sh_size));
838 free_extsyms = extsyms;
839 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
840 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
841 != symtab_hdr->sh_size))
845 /* Iterate over each section in this bfd. */
846 for (section = input_bfd->sections;
848 section = section->next)
850 struct elf32_mn10300_link_hash_entry *hash;
851 Elf_Internal_Sym *sym;
853 const char *sym_name;
856 /* Get cached copy of section contents if it exists. */
857 if (elf_section_data (section)->this_hdr.contents != NULL)
858 contents = elf_section_data (section)->this_hdr.contents;
859 else if (section->_raw_size != 0)
861 /* Go get them off disk. */
862 contents = (bfd_byte *)bfd_malloc (section->_raw_size);
863 if (contents == NULL)
865 free_contents = contents;
867 if (!bfd_get_section_contents (input_bfd, section,
868 contents, (file_ptr) 0,
875 free_contents = NULL;
878 /* If there aren't any relocs, then there's nothing to do. */
879 if ((section->flags & SEC_RELOC) != 0
880 && section->reloc_count != 0)
883 /* Get a copy of the native relocations. */
884 internal_relocs = (_bfd_elf32_link_read_relocs
885 (input_bfd, section, (PTR) NULL,
886 (Elf_Internal_Rela *) NULL,
887 link_info->keep_memory));
888 if (internal_relocs == NULL)
890 if (! link_info->keep_memory)
891 free_relocs = internal_relocs;
893 /* Now examine each relocation. */
894 irel = internal_relocs;
895 irelend = irel + section->reloc_count;
896 for (; irel < irelend; irel++)
899 unsigned long r_index;
902 r_type = ELF32_R_TYPE (irel->r_info);
903 r_index = ELF32_R_SYM (irel->r_info);
905 if (r_type < 0 || r_type >= (int)R_MN10300_MAX)
908 /* We need the name and hash table entry of the target
914 if (r_index < symtab_hdr->sh_info)
916 /* A local symbol. */
917 Elf_Internal_Sym isym;
919 bfd_elf32_swap_symbol_in (input_bfd,
920 extsyms + r_index, &isym);
922 if (isym.st_shndx == SHN_UNDEF)
923 sym_sec = bfd_und_section_ptr;
924 else if (isym.st_shndx > 0
925 && isym.st_shndx < SHN_LORESERVE)
927 = bfd_section_from_elf_index (input_bfd,
929 else if (isym.st_shndx == SHN_ABS)
930 sym_sec = bfd_abs_section_ptr;
931 else if (isym.st_shndx == SHN_COMMON)
932 sym_sec = bfd_com_section_ptr;
934 sym_name = bfd_elf_string_from_elf_section (input_bfd,
938 /* If it isn't a function, then we don't care
940 if (r_index < symtab_hdr->sh_info
941 && ELF_ST_TYPE (isym.st_info) != STT_FUNC)
944 /* Tack on an ID so we can uniquely identify this
945 local symbol in the global hash table. */
946 new_name = bfd_malloc (strlen (sym_name) + 10);
950 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
953 hash = (struct elf32_mn10300_link_hash_entry *)
954 elf_link_hash_lookup (&hash_table->static_hash_table->root,
961 r_index -= symtab_hdr->sh_info;
962 hash = (struct elf32_mn10300_link_hash_entry *)
963 elf_sym_hashes (input_bfd)[r_index];
966 /* If this is not a "call" instruction, then we
967 should convert "call" instructions to "calls"
969 code = bfd_get_8 (input_bfd,
970 contents + irel->r_offset - 1);
971 if (code != 0xdd && code != 0xcd)
972 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
974 /* If this is a jump/call, then bump the direct_calls
975 counter. Else force "call" to "calls" conversions. */
976 if (r_type == R_MN10300_PCREL32
977 || r_type == R_MN10300_PCREL16)
978 hash->direct_calls++;
980 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
984 /* Now look at the actual contents to get the stack size,
985 and a list of what registers were saved in the prologue
987 if ((section->flags & SEC_CODE) != 0)
990 Elf32_External_Sym *esym, *esymend;
993 shndx = _bfd_elf_section_from_bfd_section (input_bfd,
997 /* Look at each function defined in this section and
998 update info for that function. */
1000 esymend = esym + symtab_hdr->sh_info;
1001 for (; esym < esymend; esym++)
1003 Elf_Internal_Sym isym;
1005 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1006 if (isym.st_shndx == shndx
1007 && ELF_ST_TYPE (isym.st_info) == STT_FUNC)
1009 if (isym.st_shndx == SHN_UNDEF)
1010 sym_sec = bfd_und_section_ptr;
1011 else if (isym.st_shndx > 0
1012 && isym.st_shndx < SHN_LORESERVE)
1014 = bfd_section_from_elf_index (input_bfd,
1016 else if (isym.st_shndx == SHN_ABS)
1017 sym_sec = bfd_abs_section_ptr;
1018 else if (isym.st_shndx == SHN_COMMON)
1019 sym_sec = bfd_com_section_ptr;
1021 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1022 symtab_hdr->sh_link,
1025 /* Tack on an ID so we can uniquely identify this
1026 local symbol in the global hash table. */
1027 new_name = bfd_malloc (strlen (sym_name) + 10);
1031 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1032 sym_name = new_name;
1034 hash = (struct elf32_mn10300_link_hash_entry *)
1035 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1039 compute_function_info (input_bfd, hash,
1040 isym.st_value, contents);
1044 esym = extsyms + symtab_hdr->sh_info;
1045 esymend = extsyms + (symtab_hdr->sh_size
1046 / sizeof (Elf32_External_Sym));
1047 for (idx = 0; esym < esymend; esym++, idx++)
1049 Elf_Internal_Sym isym;
1051 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1052 hash = (struct elf32_mn10300_link_hash_entry *)
1053 elf_sym_hashes (input_bfd)[idx];
1054 if (isym.st_shndx == shndx
1055 && ELF_ST_TYPE (isym.st_info) == STT_FUNC
1056 && (hash)->root.root.u.def.section == section
1057 && ((hash)->root.root.type == bfd_link_hash_defined
1058 || (hash)->root.root.type == bfd_link_hash_defweak))
1059 compute_function_info (input_bfd, hash,
1060 (hash)->root.root.u.def.value,
1065 /* Cache or free any memory we allocated for the relocs. */
1066 if (free_relocs != NULL)
1072 /* Cache or free any memory we allocated for the contents. */
1073 if (free_contents != NULL)
1075 if (! link_info->keep_memory)
1076 free (free_contents);
1079 /* Cache the section contents for elf_link_input_bfd. */
1080 elf_section_data (section)->this_hdr.contents = contents;
1082 free_contents = NULL;
1086 /* Cache or free any memory we allocated for the symbols. */
1087 if (free_extsyms != NULL)
1089 if (! link_info->keep_memory)
1090 free (free_extsyms);
1093 /* Cache the symbols for elf_link_input_bfd. */
1094 symtab_hdr->contents = extsyms;
1096 free_extsyms = NULL;
1100 /* Now iterate on each symbol in the hash table and perform
1101 the final initialization steps on each. */
1102 elf32_mn10300_link_hash_traverse (hash_table,
1103 elf32_mn10300_finish_hash_table_entry,
1105 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
1106 elf32_mn10300_finish_hash_table_entry,
1109 /* All entries in the hash table are fully initialized. */
1110 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
1112 /* Now that everything has been initialized, go through each
1113 code section and delete any prologue insns which will be
1114 redundant because their operations will be performed by
1115 a "call" instruction. */
1116 for (input_bfd = link_info->input_bfds;
1118 input_bfd = input_bfd->link_next)
1122 /* We're going to need all the symbols for each bfd. */
1123 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1125 /* Get cached copy if it exists. */
1126 if (symtab_hdr->contents != NULL)
1127 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1130 /* Go get them off disk. */
1131 extsyms = ((Elf32_External_Sym *)
1132 bfd_malloc (symtab_hdr->sh_size));
1133 if (extsyms == NULL)
1135 free_extsyms = extsyms;
1136 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1137 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
1138 != symtab_hdr->sh_size))
1142 /* Walk over each section in this bfd. */
1143 for (section = input_bfd->sections;
1145 section = section->next)
1148 Elf32_External_Sym *esym, *esymend;
1151 /* Skip non-code sections and empty sections. */
1152 if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
1155 if (section->reloc_count != 0)
1157 /* Get a copy of the native relocations. */
1158 internal_relocs = (_bfd_elf32_link_read_relocs
1159 (input_bfd, section, (PTR) NULL,
1160 (Elf_Internal_Rela *) NULL,
1161 link_info->keep_memory));
1162 if (internal_relocs == NULL)
1164 if (! link_info->keep_memory)
1165 free_relocs = internal_relocs;
1168 /* Get cached copy of section contents if it exists. */
1169 if (elf_section_data (section)->this_hdr.contents != NULL)
1170 contents = elf_section_data (section)->this_hdr.contents;
1173 /* Go get them off disk. */
1174 contents = (bfd_byte *)bfd_malloc (section->_raw_size);
1175 if (contents == NULL)
1177 free_contents = contents;
1179 if (!bfd_get_section_contents (input_bfd, section,
1180 contents, (file_ptr) 0,
1181 section->_raw_size))
1186 shndx = _bfd_elf_section_from_bfd_section (input_bfd, section);
1188 /* Now look for any function in this section which needs
1189 insns deleted from its prologue. */
1191 esymend = esym + symtab_hdr->sh_info;
1192 for (; esym < esymend; esym++)
1194 Elf_Internal_Sym isym;
1195 struct elf32_mn10300_link_hash_entry *sym_hash;
1197 const char *sym_name;
1200 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1202 if (isym.st_shndx != shndx)
1205 if (isym.st_shndx == SHN_UNDEF)
1206 sym_sec = bfd_und_section_ptr;
1207 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1209 = bfd_section_from_elf_index (input_bfd, isym.st_shndx);
1210 else if (isym.st_shndx == SHN_ABS)
1211 sym_sec = bfd_abs_section_ptr;
1212 else if (isym.st_shndx == SHN_COMMON)
1213 sym_sec = bfd_com_section_ptr;
1215 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1216 symtab_hdr->sh_link,
1219 /* Tack on an ID so we can uniquely identify this
1220 local symbol in the global hash table. */
1221 new_name = bfd_malloc (strlen (sym_name) + 10);
1224 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1225 sym_name = new_name;
1227 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1228 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1233 if (sym_hash == NULL)
1236 if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1237 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1241 /* Note that we've changed things. */
1242 elf_section_data (section)->relocs = internal_relocs;
1245 elf_section_data (section)->this_hdr.contents = contents;
1246 free_contents = NULL;
1248 symtab_hdr->contents = (bfd_byte *)extsyms;
1249 free_extsyms = NULL;
1251 /* Count how many bytes we're going to delete. */
1252 if (sym_hash->movm_args)
1255 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1257 else if (sym_hash->stack_size
1258 && sym_hash->stack_size < 256)
1261 /* Note that we've deleted prologue bytes for this
1263 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1265 /* Actually delete the bytes. */
1266 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1272 /* Something changed. Not strictly necessary, but
1273 may lead to more relaxing opportunities. */
1278 /* Look for any global functions in this section which
1279 need insns deleted from their prologues. */
1280 esym = extsyms + symtab_hdr->sh_info;
1281 esymend = extsyms + (symtab_hdr->sh_size
1282 / sizeof (Elf32_External_Sym));
1283 for (idx = 0; esym < esymend; esym++, idx++)
1285 Elf_Internal_Sym isym;
1286 struct elf32_mn10300_link_hash_entry *sym_hash;
1288 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1289 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1290 (elf_sym_hashes (input_bfd)[idx]);
1291 if (isym.st_shndx == shndx
1292 && (sym_hash)->root.root.u.def.section == section
1293 && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1294 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1298 /* Note that we've changed things. */
1299 elf_section_data (section)->relocs = internal_relocs;
1302 elf_section_data (section)->this_hdr.contents = contents;
1303 free_contents = NULL;
1305 symtab_hdr->contents = (bfd_byte *)extsyms;
1306 free_extsyms = NULL;
1308 /* Count how many bytes we're going to delete. */
1309 if (sym_hash->movm_args)
1312 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1314 else if (sym_hash->stack_size
1315 && sym_hash->stack_size < 256)
1318 /* Note that we've deleted prologue bytes for this
1320 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1322 /* Actually delete the bytes. */
1323 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1325 (sym_hash)->root.root.u.def.value,
1329 /* Something changed. Not strictly necessary, but
1330 may lead to more relaxing opportunities. */
1335 /* Cache or free any memory we allocated for the relocs. */
1336 if (free_relocs != NULL)
1342 /* Cache or free any memory we allocated for the contents. */
1343 if (free_contents != NULL)
1345 if (! link_info->keep_memory)
1346 free (free_contents);
1349 /* Cache the section contents for elf_link_input_bfd. */
1350 elf_section_data (section)->this_hdr.contents = contents;
1352 free_contents = NULL;
1356 /* Cache or free any memory we allocated for the symbols. */
1357 if (free_extsyms != NULL)
1359 if (! link_info->keep_memory)
1360 free (free_extsyms);
1363 /* Cache the symbols for elf_link_input_bfd. */
1364 symtab_hdr->contents = extsyms;
1366 free_extsyms = NULL;
1372 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
1375 internal_relocs = NULL;
1377 free_contents = NULL;
1378 free_extsyms = NULL;
1380 /* We don't have to do anything for a relocateable link, if
1381 this section does not have relocs, or if this is not a
1383 if (link_info->relocateable
1384 || (sec->flags & SEC_RELOC) == 0
1385 || sec->reloc_count == 0
1386 || (sec->flags & SEC_CODE) == 0)
1389 /* If this is the first time we have been called for this section,
1390 initialize the cooked size. */
1391 if (sec->_cooked_size == 0)
1392 sec->_cooked_size = sec->_raw_size;
1394 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1396 /* Get a copy of the native relocations. */
1397 internal_relocs = (_bfd_elf32_link_read_relocs
1398 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1399 link_info->keep_memory));
1400 if (internal_relocs == NULL)
1402 if (! link_info->keep_memory)
1403 free_relocs = internal_relocs;
1405 /* Walk through them looking for relaxing opportunities. */
1406 irelend = internal_relocs + sec->reloc_count;
1407 for (irel = internal_relocs; irel < irelend; irel++)
1410 struct elf32_mn10300_link_hash_entry *h = NULL;
1412 /* If this isn't something that can be relaxed, then ignore
1414 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1415 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1416 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1419 /* Get the section contents if we haven't done so already. */
1420 if (contents == NULL)
1422 /* Get cached copy if it exists. */
1423 if (elf_section_data (sec)->this_hdr.contents != NULL)
1424 contents = elf_section_data (sec)->this_hdr.contents;
1427 /* Go get them off disk. */
1428 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1429 if (contents == NULL)
1431 free_contents = contents;
1433 if (! bfd_get_section_contents (abfd, sec, contents,
1434 (file_ptr) 0, sec->_raw_size))
1439 /* Read this BFD's symbols if we haven't done so already. */
1440 if (extsyms == NULL)
1442 /* Get cached copy if it exists. */
1443 if (symtab_hdr->contents != NULL)
1444 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1447 /* Go get them off disk. */
1448 extsyms = ((Elf32_External_Sym *)
1449 bfd_malloc (symtab_hdr->sh_size));
1450 if (extsyms == NULL)
1452 free_extsyms = extsyms;
1453 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1454 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1455 != symtab_hdr->sh_size))
1460 /* Get the value of the symbol referred to by the reloc. */
1461 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1463 Elf_Internal_Sym isym;
1465 const char *sym_name;
1468 /* A local symbol. */
1469 bfd_elf32_swap_symbol_in (abfd,
1470 extsyms + ELF32_R_SYM (irel->r_info),
1473 if (isym.st_shndx == SHN_UNDEF)
1474 sym_sec = bfd_und_section_ptr;
1475 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1476 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1477 else if (isym.st_shndx == SHN_ABS)
1478 sym_sec = bfd_abs_section_ptr;
1479 else if (isym.st_shndx == SHN_COMMON)
1480 sym_sec = bfd_com_section_ptr;
1482 symval = (isym.st_value
1483 + sym_sec->output_section->vma
1484 + sym_sec->output_offset);
1485 sym_name = bfd_elf_string_from_elf_section (abfd,
1486 symtab_hdr->sh_link,
1489 /* Tack on an ID so we can uniquely identify this
1490 local symbol in the global hash table. */
1491 new_name = bfd_malloc (strlen (sym_name) + 10);
1494 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1495 sym_name = new_name;
1497 h = (struct elf32_mn10300_link_hash_entry *)
1498 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1499 sym_name, false, false, false);
1506 /* An external symbol. */
1507 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1508 h = (struct elf32_mn10300_link_hash_entry *)
1509 (elf_sym_hashes (abfd)[indx]);
1510 BFD_ASSERT (h != NULL);
1511 if (h->root.root.type != bfd_link_hash_defined
1512 && h->root.root.type != bfd_link_hash_defweak)
1514 /* This appears to be a reference to an undefined
1515 symbol. Just ignore it--it will be caught by the
1516 regular reloc processing. */
1520 symval = (h->root.root.u.def.value
1521 + h->root.root.u.def.section->output_section->vma
1522 + h->root.root.u.def.section->output_offset);
1525 /* For simplicity of coding, we are going to modify the section
1526 contents, the section relocs, and the BFD symbol table. We
1527 must tell the rest of the code not to free up this
1528 information. It would be possible to instead create a table
1529 of changes which have to be made, as is done in coff-mips.c;
1530 that would be more work, but would require less memory when
1531 the linker is run. */
1533 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1534 branch/call, also deal with "call" -> "calls" conversions and
1535 insertion of prologue data into "call" instructions. */
1536 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
1538 bfd_vma value = symval;
1540 /* If we've got a "call" instruction that needs to be turned
1541 into a "calls" instruction, do so now. It saves a byte. */
1542 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1546 /* Get the opcode. */
1547 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1549 /* Make sure we're working with a "call" instruction! */
1552 /* Note that we've changed the relocs, section contents,
1554 elf_section_data (sec)->relocs = internal_relocs;
1557 elf_section_data (sec)->this_hdr.contents = contents;
1558 free_contents = NULL;
1560 symtab_hdr->contents = (bfd_byte *) extsyms;
1561 free_extsyms = NULL;
1563 /* Fix the opcode. */
1564 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
1565 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1567 /* Fix irel->r_offset and irel->r_addend. */
1568 irel->r_offset += 1;
1569 irel->r_addend += 1;
1571 /* Delete one byte of data. */
1572 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1573 irel->r_offset + 3, 1))
1576 /* That will change things, so, we should relax again.
1577 Note that this is not required, and it may be slow. */
1583 /* We've got a "call" instruction which needs some data
1584 from target function filled in. */
1587 /* Get the opcode. */
1588 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1590 /* Insert data from the target function into the "call"
1591 instruction if needed. */
1594 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
1595 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1596 contents + irel->r_offset + 5);
1600 /* Deal with pc-relative gunk. */
1601 value -= (sec->output_section->vma + sec->output_offset);
1602 value -= irel->r_offset;
1603 value += irel->r_addend;
1605 /* See if the value will fit in 16 bits, note the high value is
1606 0x7fff + 2 as the target will be two bytes closer if we are
1608 if ((long)value < 0x8001 && (long)value > -0x8000)
1612 /* Get the opcode. */
1613 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1615 if (code != 0xdc && code != 0xdd && code != 0xff)
1618 /* Note that we've changed the relocs, section contents, etc. */
1619 elf_section_data (sec)->relocs = internal_relocs;
1622 elf_section_data (sec)->this_hdr.contents = contents;
1623 free_contents = NULL;
1625 symtab_hdr->contents = (bfd_byte *) extsyms;
1626 free_extsyms = NULL;
1628 /* Fix the opcode. */
1630 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
1631 else if (code == 0xdd)
1632 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
1633 else if (code == 0xff)
1634 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1636 /* Fix the relocation's type. */
1637 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1640 /* Delete two bytes of data. */
1641 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1642 irel->r_offset + 1, 2))
1645 /* That will change things, so, we should relax again.
1646 Note that this is not required, and it may be slow. */
1651 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1653 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
1655 bfd_vma value = symval;
1657 /* If we've got a "call" instruction that needs to be turned
1658 into a "calls" instruction, do so now. It saves a byte. */
1659 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1663 /* Get the opcode. */
1664 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1666 /* Make sure we're working with a "call" instruction! */
1669 /* Note that we've changed the relocs, section contents,
1671 elf_section_data (sec)->relocs = internal_relocs;
1674 elf_section_data (sec)->this_hdr.contents = contents;
1675 free_contents = NULL;
1677 symtab_hdr->contents = (bfd_byte *) extsyms;
1678 free_extsyms = NULL;
1680 /* Fix the opcode. */
1681 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
1682 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1684 /* Fix irel->r_offset and irel->r_addend. */
1685 irel->r_offset += 1;
1686 irel->r_addend += 1;
1688 /* Delete one byte of data. */
1689 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1690 irel->r_offset + 1, 1))
1693 /* That will change things, so, we should relax again.
1694 Note that this is not required, and it may be slow. */
1702 /* Get the opcode. */
1703 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1705 /* Insert data from the target function into the "call"
1706 instruction if needed. */
1709 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
1710 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1711 contents + irel->r_offset + 3);
1715 /* Deal with pc-relative gunk. */
1716 value -= (sec->output_section->vma + sec->output_offset);
1717 value -= irel->r_offset;
1718 value += irel->r_addend;
1720 /* See if the value will fit in 8 bits, note the high value is
1721 0x7f + 1 as the target will be one bytes closer if we are
1723 if ((long)value < 0x80 && (long)value > -0x80)
1727 /* Get the opcode. */
1728 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1733 /* Note that we've changed the relocs, section contents, etc. */
1734 elf_section_data (sec)->relocs = internal_relocs;
1737 elf_section_data (sec)->this_hdr.contents = contents;
1738 free_contents = NULL;
1740 symtab_hdr->contents = (bfd_byte *) extsyms;
1741 free_extsyms = NULL;
1743 /* Fix the opcode. */
1744 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
1746 /* Fix the relocation's type. */
1747 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1750 /* Delete one byte of data. */
1751 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1752 irel->r_offset + 1, 1))
1755 /* That will change things, so, we should relax again.
1756 Note that this is not required, and it may be slow. */
1761 /* Try to eliminate an unconditional 8 bit pc-relative branch
1762 which immediately follows a conditional 8 bit pc-relative
1763 branch around the unconditional branch.
1771 This happens when the bCC can't reach lab2 at assembly time,
1772 but due to other relaxations it can reach at link time. */
1773 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
1775 Elf_Internal_Rela *nrel;
1776 bfd_vma value = symval;
1779 /* Deal with pc-relative gunk. */
1780 value -= (sec->output_section->vma + sec->output_offset);
1781 value -= irel->r_offset;
1782 value += irel->r_addend;
1784 /* Do nothing if this reloc is the last byte in the section. */
1785 if (irel->r_offset == sec->_cooked_size)
1788 /* See if the next instruction is an unconditional pc-relative
1789 branch, more often than not this test will fail, so we
1790 test it first to speed things up. */
1791 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1795 /* Also make sure the next relocation applies to the next
1796 instruction and that it's a pc-relative 8 bit branch. */
1799 || irel->r_offset + 2 != nrel->r_offset
1800 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
1803 /* Make sure our destination immediately follows the
1804 unconditional branch. */
1805 if (symval != (sec->output_section->vma + sec->output_offset
1806 + irel->r_offset + 3))
1809 /* Now make sure we are a conditional branch. This may not
1810 be necessary, but why take the chance.
1812 Note these checks assume that R_MN10300_PCREL8 relocs
1813 only occur on bCC and bCCx insns. If they occured
1814 elsewhere, we'd need to know the start of this insn
1815 for this check to be accurate. */
1816 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1817 if (code != 0xc0 && code != 0xc1 && code != 0xc2
1818 && code != 0xc3 && code != 0xc4 && code != 0xc5
1819 && code != 0xc6 && code != 0xc7 && code != 0xc8
1820 && code != 0xc9 && code != 0xe8 && code != 0xe9
1821 && code != 0xea && code != 0xeb)
1824 /* We also have to be sure there is no symbol/label
1825 at the unconditional branch. */
1826 if (mn10300_elf_symbol_address_p (abfd, sec, extsyms,
1827 irel->r_offset + 1))
1830 /* Note that we've changed the relocs, section contents, etc. */
1831 elf_section_data (sec)->relocs = internal_relocs;
1834 elf_section_data (sec)->this_hdr.contents = contents;
1835 free_contents = NULL;
1837 symtab_hdr->contents = (bfd_byte *) extsyms;
1838 free_extsyms = NULL;
1840 /* Reverse the condition of the first branch. */
1886 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1888 /* Set the reloc type and symbol for the first branch
1889 from the second branch. */
1890 irel->r_info = nrel->r_info;
1892 /* Make the reloc for the second branch a null reloc. */
1893 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1896 /* Delete two bytes of data. */
1897 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1898 irel->r_offset + 1, 2))
1901 /* That will change things, so, we should relax again.
1902 Note that this is not required, and it may be slow. */
1907 /* Try to turn a 32bit immediate, displacement or absolute address
1908 into a 16bit immediate, displacement or absolute address. */
1909 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1911 bfd_vma value = symval;
1912 value += irel->r_addend;
1915 /* See if the value will fit in 16 bits.
1916 We allow any 16bit match here. We prune those we can't
1918 if ((long)value < 0x7fff && (long)value > -0x8000)
1922 /* Most insns which have 32bit operands are 6 bytes long;
1923 exceptions are pcrel insns and bit insns.
1925 We handle pcrel insns above. We don't bother trying
1926 to handle the bit insns here.
1928 The first byte of the remaining insns will be 0xfc. */
1930 /* Get the first opcode. */
1931 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1936 /* Get the second opcode. */
1937 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1939 if ((code & 0xf0) < 0x80)
1940 switch (code & 0xf0)
1942 /* mov (d32,am),dn -> mov (d32,am),dn
1943 mov dm,(d32,am) -> mov dn,(d32,am)
1944 mov (d32,am),an -> mov (d32,am),an
1945 mov dm,(d32,am) -> mov dn,(d32,am)
1946 movbu (d32,am),dn -> movbu (d32,am),dn
1947 movbu dm,(d32,am) -> movbu dn,(d32,am)
1948 movhu (d32,am),dn -> movhu (d32,am),dn
1949 movhu dm,(d32,am) -> movhu dn,(d32,am) */
1958 /* Not safe if the high bit is on as relaxing may
1959 move the value out of high mem and thus not fit
1960 in a signed 16bit value. */
1962 && (value & 0x8000))
1965 /* Note that we've changed the relocation contents, etc. */
1966 elf_section_data (sec)->relocs = internal_relocs;
1969 elf_section_data (sec)->this_hdr.contents = contents;
1970 free_contents = NULL;
1972 symtab_hdr->contents = (bfd_byte *) extsyms;
1973 free_extsyms = NULL;
1975 /* Fix the opcode. */
1976 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1977 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1979 /* Fix the relocation's type. */
1980 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1983 /* Delete two bytes of data. */
1984 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1985 irel->r_offset + 2, 2))
1988 /* That will change things, so, we should relax again.
1989 Note that this is not required, and it may be slow. */
1993 else if ((code & 0xf0) == 0x80
1994 || (code & 0xf0) == 0x90)
1995 switch (code & 0xf3)
1997 /* mov dn,(abs32) -> mov dn,(abs16)
1998 movbu dn,(abs32) -> movbu dn,(abs16)
1999 movhu dn,(abs32) -> movhu dn,(abs16) */
2003 /* Note that we've changed the relocation contents, etc. */
2004 elf_section_data (sec)->relocs = internal_relocs;
2007 elf_section_data (sec)->this_hdr.contents = contents;
2008 free_contents = NULL;
2010 symtab_hdr->contents = (bfd_byte *) extsyms;
2011 free_extsyms = NULL;
2013 if ((code & 0xf3) == 0x81)
2014 code = 0x01 + (code & 0x0c);
2015 else if ((code & 0xf3) == 0x82)
2016 code = 0x02 + (code & 0x0c);
2017 else if ((code & 0xf3) == 0x83)
2018 code = 0x03 + (code & 0x0c);
2022 /* Fix the opcode. */
2023 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2025 /* Fix the relocation's type. */
2026 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2029 /* The opcode got shorter too, so we have to fix the
2030 addend and offset too! */
2031 irel->r_offset -= 1;
2033 /* Delete three bytes of data. */
2034 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2035 irel->r_offset + 1, 3))
2038 /* That will change things, so, we should relax again.
2039 Note that this is not required, and it may be slow. */
2043 /* mov am,(abs32) -> mov am,(abs16)
2044 mov am,(d32,sp) -> mov am,(d16,sp)
2045 mov dm,(d32,sp) -> mov dm,(d32,sp)
2046 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2047 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2053 /* Note that we've changed the relocation contents, etc. */
2054 elf_section_data (sec)->relocs = internal_relocs;
2057 elf_section_data (sec)->this_hdr.contents = contents;
2058 free_contents = NULL;
2060 symtab_hdr->contents = (bfd_byte *) extsyms;
2061 free_extsyms = NULL;
2063 /* Fix the opcode. */
2064 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2065 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2067 /* Fix the relocation's type. */
2068 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2071 /* Delete two bytes of data. */
2072 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2073 irel->r_offset + 2, 2))
2076 /* That will change things, so, we should relax again.
2077 Note that this is not required, and it may be slow. */
2081 else if ((code & 0xf0) < 0xf0)
2082 switch (code & 0xfc)
2084 /* mov imm32,dn -> mov imm16,dn
2085 mov imm32,an -> mov imm16,an
2086 mov (abs32),dn -> mov (abs16),dn
2087 movbu (abs32),dn -> movbu (abs16),dn
2088 movhu (abs32),dn -> movhu (abs16),dn */
2094 /* Not safe if the high bit is on as relaxing may
2095 move the value out of high mem and thus not fit
2096 in a signed 16bit value. */
2098 && (value & 0x8000))
2101 /* Note that we've changed the relocation contents, etc. */
2102 elf_section_data (sec)->relocs = internal_relocs;
2105 elf_section_data (sec)->this_hdr.contents = contents;
2106 free_contents = NULL;
2108 symtab_hdr->contents = (bfd_byte *) extsyms;
2109 free_extsyms = NULL;
2111 if ((code & 0xfc) == 0xcc)
2112 code = 0x2c + (code & 0x03);
2113 else if ((code & 0xfc) == 0xdc)
2114 code = 0x24 + (code & 0x03);
2115 else if ((code & 0xfc) == 0xa4)
2116 code = 0x30 + (code & 0x03);
2117 else if ((code & 0xfc) == 0xa8)
2118 code = 0x34 + (code & 0x03);
2119 else if ((code & 0xfc) == 0xac)
2120 code = 0x38 + (code & 0x03);
2124 /* Fix the opcode. */
2125 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2127 /* Fix the relocation's type. */
2128 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2131 /* The opcode got shorter too, so we have to fix the
2132 addend and offset too! */
2133 irel->r_offset -= 1;
2135 /* Delete three bytes of data. */
2136 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2137 irel->r_offset + 1, 3))
2140 /* That will change things, so, we should relax again.
2141 Note that this is not required, and it may be slow. */
2145 /* mov (abs32),an -> mov (abs16),an
2146 mov (d32,sp),an -> mov (d32,sp),an
2147 mov (d32,sp),dn -> mov (d32,sp),dn
2148 movbu (d32,sp),dn -> movbu (d32,sp),dn
2149 movhu (d32,sp),dn -> movhu (d32,sp),dn
2150 add imm32,dn -> add imm16,dn
2151 cmp imm32,dn -> cmp imm16,dn
2152 add imm32,an -> add imm16,an
2153 cmp imm32,an -> cmp imm16,an
2154 and imm32,dn -> and imm32,dn
2155 or imm32,dn -> or imm32,dn
2156 xor imm32,dn -> xor imm32,dn
2157 btst imm32,dn -> btst imm32,dn */
2173 /* Note that we've changed the relocation contents, etc. */
2174 elf_section_data (sec)->relocs = internal_relocs;
2177 elf_section_data (sec)->this_hdr.contents = contents;
2178 free_contents = NULL;
2180 symtab_hdr->contents = (bfd_byte *) extsyms;
2181 free_extsyms = NULL;
2183 /* Fix the opcode. */
2184 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2185 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2187 /* Fix the relocation's type. */
2188 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2191 /* Delete two bytes of data. */
2192 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2193 irel->r_offset + 2, 2))
2196 /* That will change things, so, we should relax again.
2197 Note that this is not required, and it may be slow. */
2201 else if (code == 0xfe)
2203 /* add imm32,sp -> add imm16,sp */
2205 /* Note that we've changed the relocation contents, etc. */
2206 elf_section_data (sec)->relocs = internal_relocs;
2209 elf_section_data (sec)->this_hdr.contents = contents;
2210 free_contents = NULL;
2212 symtab_hdr->contents = (bfd_byte *) extsyms;
2213 free_extsyms = NULL;
2215 /* Fix the opcode. */
2216 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2217 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2219 /* Fix the relocation's type. */
2220 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2223 /* Delete two bytes of data. */
2224 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2225 irel->r_offset + 2, 2))
2228 /* That will change things, so, we should relax again.
2229 Note that this is not required, and it may be slow. */
2237 if (free_relocs != NULL)
2243 if (free_contents != NULL)
2245 if (! link_info->keep_memory)
2246 free (free_contents);
2249 /* Cache the section contents for elf_link_input_bfd. */
2250 elf_section_data (sec)->this_hdr.contents = contents;
2252 free_contents = NULL;
2255 if (free_extsyms != NULL)
2257 if (! link_info->keep_memory)
2258 free (free_extsyms);
2261 /* Cache the symbols for elf_link_input_bfd. */
2262 symtab_hdr->contents = extsyms;
2264 free_extsyms = NULL;
2270 if (free_relocs != NULL)
2272 if (free_contents != NULL)
2273 free (free_contents);
2274 if (free_extsyms != NULL)
2275 free (free_extsyms);
2279 /* Compute the stack size and movm arguments for the function
2280 referred to by HASH at address ADDR in section with
2281 contents CONTENTS, store the information in the hash table. */
2283 compute_function_info (abfd, hash, addr, contents)
2285 struct elf32_mn10300_link_hash_entry *hash;
2287 unsigned char *contents;
2289 unsigned char byte1, byte2;
2290 /* We only care about a very small subset of the possible prologue
2291 sequences here. Basically we look for:
2293 movm [d2,d3,a2,a3],sp (optional)
2294 add <size>,sp (optional, and only for sizes which fit in an unsigned
2297 If we find anything else, we quit. */
2299 /* Look for movm [regs],sp */
2300 byte1 = bfd_get_8 (abfd, contents + addr);
2301 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2305 hash->movm_args = byte2;
2307 byte1 = bfd_get_8 (abfd, contents + addr);
2308 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2311 /* Now figure out how much stack space will be allocated by the movm
2312 instruction. We need this kept separate from the funtion's normal
2314 if (hash->movm_args)
2317 if (hash->movm_args & 0x80)
2318 hash->movm_stack_size += 4;
2321 if (hash->movm_args & 0x40)
2322 hash->movm_stack_size += 4;
2325 if (hash->movm_args & 0x20)
2326 hash->movm_stack_size += 4;
2329 if (hash->movm_args & 0x10)
2330 hash->movm_stack_size += 4;
2332 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
2333 if (hash->movm_args & 0x08)
2334 hash->movm_stack_size += 8 * 4;
2338 /* Now look for the two stack adjustment variants. */
2339 if (byte1 == 0xf8 && byte2 == 0xfe)
2341 int temp = bfd_get_8 (abfd, contents + addr + 2);
2342 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2344 hash->stack_size = -temp;
2346 else if (byte1 == 0xfa && byte2 == 0xfe)
2348 int temp = bfd_get_16 (abfd, contents + addr + 2);
2349 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2353 hash->stack_size = temp;
2356 /* If the total stack to be allocated by the call instruction is more
2357 than 255 bytes, then we can't remove the stack adjustment by using
2358 "call" (we might still be able to remove the "movm" instruction. */
2359 if (hash->stack_size + hash->movm_stack_size > 255)
2360 hash->stack_size = 0;
2365 /* Delete some bytes from a section while relaxing. */
2368 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2374 Elf_Internal_Shdr *symtab_hdr;
2375 Elf32_External_Sym *extsyms;
2378 Elf_Internal_Rela *irel, *irelend;
2379 Elf_Internal_Rela *irelalign;
2381 Elf32_External_Sym *esym, *esymend;
2382 struct elf32_mn10300_link_hash_entry *sym_hash;
2384 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2385 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2387 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2389 contents = elf_section_data (sec)->this_hdr.contents;
2391 /* The deletion must stop at the next ALIGN reloc for an aligment
2392 power larger than the number of bytes we are deleting. */
2395 toaddr = sec->_cooked_size;
2397 irel = elf_section_data (sec)->relocs;
2398 irelend = irel + sec->reloc_count;
2400 /* Actually delete the bytes. */
2401 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2402 sec->_cooked_size -= count;
2404 /* Adjust all the relocs. */
2405 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2407 /* Get the new reloc address. */
2408 if ((irel->r_offset > addr
2409 && irel->r_offset < toaddr))
2410 irel->r_offset -= count;
2413 /* Adjust the local symbols defined in this section. */
2415 esymend = esym + symtab_hdr->sh_info;
2416 for (; esym < esymend; esym++)
2418 Elf_Internal_Sym isym;
2420 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2422 if (isym.st_shndx == shndx
2423 && isym.st_value > addr
2424 && isym.st_value < toaddr)
2426 isym.st_value -= count;
2427 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2431 /* Now adjust the global symbols defined in this section. */
2432 esym = extsyms + symtab_hdr->sh_info;
2433 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2434 for (index = 0; esym < esymend; esym++, index++)
2436 Elf_Internal_Sym isym;
2438 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2439 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2440 (elf_sym_hashes (abfd)[index]);
2441 if (isym.st_shndx == shndx
2442 && ((sym_hash)->root.root.type == bfd_link_hash_defined
2443 || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2444 && (sym_hash)->root.root.u.def.section == sec
2445 && (sym_hash)->root.root.u.def.value > addr
2446 && (sym_hash)->root.root.u.def.value < toaddr)
2448 (sym_hash)->root.root.u.def.value -= count;
2455 /* Return true if a symbol exists at the given address, else return
2458 mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2461 Elf32_External_Sym *extsyms;
2464 Elf_Internal_Shdr *symtab_hdr;
2466 Elf32_External_Sym *esym, *esymend;
2467 struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2469 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2470 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2472 /* Examine all the symbols. */
2474 esymend = esym + symtab_hdr->sh_info;
2475 for (; esym < esymend; esym++)
2477 Elf_Internal_Sym isym;
2479 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2481 if (isym.st_shndx == shndx
2482 && isym.st_value == addr)
2486 sym_hash = (struct elf32_mn10300_link_hash_entry **)(elf_sym_hashes (abfd));
2487 sym_hash_end = (sym_hash
2488 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2489 - symtab_hdr->sh_info));
2490 for (; sym_hash < sym_hash_end; sym_hash++)
2492 if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2493 || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2494 && (*sym_hash)->root.root.u.def.section == sec
2495 && (*sym_hash)->root.root.u.def.value == addr)
2501 /* This is a version of bfd_generic_get_relocated_section_contents
2502 which uses mn10300_elf_relocate_section. */
2505 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2506 data, relocateable, symbols)
2508 struct bfd_link_info *link_info;
2509 struct bfd_link_order *link_order;
2511 boolean relocateable;
2514 Elf_Internal_Shdr *symtab_hdr;
2515 asection *input_section = link_order->u.indirect.section;
2516 bfd *input_bfd = input_section->owner;
2517 asection **sections = NULL;
2518 Elf_Internal_Rela *internal_relocs = NULL;
2519 Elf32_External_Sym *external_syms = NULL;
2520 Elf_Internal_Sym *internal_syms = NULL;
2522 /* We only need to handle the case of relaxing, or of having a
2523 particular set of section contents, specially. */
2525 || elf_section_data (input_section)->this_hdr.contents == NULL)
2526 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2531 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2533 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2534 input_section->_raw_size);
2536 if ((input_section->flags & SEC_RELOC) != 0
2537 && input_section->reloc_count > 0)
2539 Elf_Internal_Sym *isymp;
2541 Elf32_External_Sym *esym, *esymend;
2543 if (symtab_hdr->contents != NULL)
2544 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2547 external_syms = ((Elf32_External_Sym *)
2548 bfd_malloc (symtab_hdr->sh_info
2549 * sizeof (Elf32_External_Sym)));
2550 if (external_syms == NULL && symtab_hdr->sh_info > 0)
2552 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2553 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2554 symtab_hdr->sh_info, input_bfd)
2555 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2559 internal_relocs = (_bfd_elf32_link_read_relocs
2560 (input_bfd, input_section, (PTR) NULL,
2561 (Elf_Internal_Rela *) NULL, false));
2562 if (internal_relocs == NULL)
2565 internal_syms = ((Elf_Internal_Sym *)
2566 bfd_malloc (symtab_hdr->sh_info
2567 * sizeof (Elf_Internal_Sym)));
2568 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2571 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2572 * sizeof (asection *));
2573 if (sections == NULL && symtab_hdr->sh_info > 0)
2576 isymp = internal_syms;
2578 esym = external_syms;
2579 esymend = esym + symtab_hdr->sh_info;
2580 for (; esym < esymend; ++esym, ++isymp, ++secpp)
2584 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2586 if (isymp->st_shndx == SHN_UNDEF)
2587 isec = bfd_und_section_ptr;
2588 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2589 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2590 else if (isymp->st_shndx == SHN_ABS)
2591 isec = bfd_abs_section_ptr;
2592 else if (isymp->st_shndx == SHN_COMMON)
2593 isec = bfd_com_section_ptr;
2603 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2604 input_section, data, internal_relocs,
2605 internal_syms, sections))
2608 if (sections != NULL)
2611 if (internal_syms != NULL)
2612 free (internal_syms);
2613 internal_syms = NULL;
2614 if (external_syms != NULL && symtab_hdr->contents == NULL)
2615 free (external_syms);
2616 external_syms = NULL;
2617 if (internal_relocs != elf_section_data (input_section)->relocs)
2618 free (internal_relocs);
2619 internal_relocs = NULL;
2625 if (internal_relocs != NULL
2626 && internal_relocs != elf_section_data (input_section)->relocs)
2627 free (internal_relocs);
2628 if (external_syms != NULL && symtab_hdr->contents == NULL)
2629 free (external_syms);
2630 if (internal_syms != NULL)
2631 free (internal_syms);
2632 if (sections != NULL)
2637 /* Assorted hash table functions. */
2639 /* Initialize an entry in the link hash table. */
2641 /* Create an entry in an MN10300 ELF linker hash table. */
2643 static struct bfd_hash_entry *
2644 elf32_mn10300_link_hash_newfunc (entry, table, string)
2645 struct bfd_hash_entry *entry;
2646 struct bfd_hash_table *table;
2649 struct elf32_mn10300_link_hash_entry *ret =
2650 (struct elf32_mn10300_link_hash_entry *) entry;
2652 /* Allocate the structure if it has not already been allocated by a
2654 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2655 ret = ((struct elf32_mn10300_link_hash_entry *)
2656 bfd_hash_allocate (table,
2657 sizeof (struct elf32_mn10300_link_hash_entry)));
2658 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2659 return (struct bfd_hash_entry *) ret;
2661 /* Call the allocation method of the superclass. */
2662 ret = ((struct elf32_mn10300_link_hash_entry *)
2663 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2665 if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2667 ret->direct_calls = 0;
2668 ret->stack_size = 0;
2669 ret->movm_stack_size = 0;
2674 return (struct bfd_hash_entry *) ret;
2677 /* Create an mn10300 ELF linker hash table. */
2679 static struct bfd_link_hash_table *
2680 elf32_mn10300_link_hash_table_create (abfd)
2683 struct elf32_mn10300_link_hash_table *ret;
2685 ret = ((struct elf32_mn10300_link_hash_table *)
2686 bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2687 if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2690 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2691 elf32_mn10300_link_hash_newfunc))
2693 bfd_release (abfd, ret);
2698 ret->static_hash_table
2699 = ((struct elf32_mn10300_link_hash_table *)
2700 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2701 if (ret->static_hash_table == NULL)
2703 bfd_release (abfd, ret);
2707 if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2708 elf32_mn10300_link_hash_newfunc))
2710 bfd_release (abfd, ret->static_hash_table);
2711 bfd_release (abfd, ret);
2714 return &ret->root.root;
2718 elf_mn10300_mach (flags)
2721 switch (flags & EF_MN10300_MACH)
2723 case E_MN10300_MACH_MN10300:
2725 return bfd_mach_mn10300;
2730 /* The final processing done just before writing out a MN10300 ELF object
2731 file. This gets the MN10300 architecture right based on the machine
2736 _bfd_mn10300_elf_final_write_processing (abfd, linker)
2742 switch (bfd_get_mach (abfd))
2745 case bfd_mach_mn10300:
2746 val = E_MN10300_MACH_MN10300;
2751 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2752 elf_elfheader (abfd)->e_flags |= val;
2756 _bfd_mn10300_elf_object_p (abfd)
2759 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2760 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2764 /* Merge backend specific data from an object file to the output
2765 object file when linking. */
2768 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2772 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2773 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2776 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2777 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2779 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2780 bfd_get_mach (ibfd)))
2788 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
2789 #define TARGET_LITTLE_NAME "elf32-mn10300"
2790 #define ELF_ARCH bfd_arch_mn10300
2791 #define ELF_MACHINE_CODE EM_CYGNUS_MN10300
2792 #define ELF_MAXPAGESIZE 0x1000
2794 #define elf_info_to_howto mn10300_info_to_howto
2795 #define elf_info_to_howto_rel 0
2796 #define elf_backend_can_gc_sections 1
2797 #define elf_backend_check_relocs mn10300_elf_check_relocs
2798 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
2799 #define elf_backend_relocate_section mn10300_elf_relocate_section
2800 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
2801 #define bfd_elf32_bfd_get_relocated_section_contents \
2802 mn10300_elf_get_relocated_section_contents
2803 #define bfd_elf32_bfd_link_hash_table_create \
2804 elf32_mn10300_link_hash_table_create
2806 #define elf_symbol_leading_char '_'
2808 /* So we can set bits in e_flags. */
2809 #define elf_backend_final_write_processing \
2810 _bfd_mn10300_elf_final_write_processing
2811 #define elf_backend_object_p _bfd_mn10300_elf_object_p
2813 #define bfd_elf32_bfd_merge_private_bfd_data \
2814 _bfd_mn10300_elf_merge_private_bfd_data
2817 #include "elf32-target.h"