1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright (C) 1996, 1997, 1998, 1999, 2000 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. */
122 static reloc_howto_type elf_mn10300_howto_table[] =
124 /* Dummy relocation. Does nothing. */
125 HOWTO (R_MN10300_NONE,
131 complain_overflow_bitfield,
132 bfd_elf_generic_reloc,
138 /* Standard 32 bit reloc. */
145 complain_overflow_bitfield,
146 bfd_elf_generic_reloc,
152 /* Standard 16 bit reloc. */
159 complain_overflow_bitfield,
160 bfd_elf_generic_reloc,
166 /* Standard 8 bit reloc. */
173 complain_overflow_bitfield,
174 bfd_elf_generic_reloc,
180 /* Standard 32bit pc-relative reloc. */
181 HOWTO (R_MN10300_PCREL32,
187 complain_overflow_bitfield,
188 bfd_elf_generic_reloc,
194 /* Standard 16bit pc-relative reloc. */
195 HOWTO (R_MN10300_PCREL16,
201 complain_overflow_bitfield,
202 bfd_elf_generic_reloc,
208 /* Standard 8 pc-relative reloc. */
209 HOWTO (R_MN10300_PCREL8,
215 complain_overflow_bitfield,
216 bfd_elf_generic_reloc,
223 /* GNU extension to record C++ vtable hierarchy */
224 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
226 0, /* size (0 = byte, 1 = short, 2 = long) */
228 false, /* pc_relative */
230 complain_overflow_dont, /* complain_on_overflow */
231 NULL, /* special_function */
232 "R_MN10300_GNU_VTINHERIT", /* name */
233 false, /* partial_inplace */
236 false), /* pcrel_offset */
238 /* GNU extension to record C++ vtable member usage */
239 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
241 0, /* size (0 = byte, 1 = short, 2 = long) */
243 false, /* pc_relative */
245 complain_overflow_dont, /* complain_on_overflow */
246 NULL, /* special_function */
247 "R_MN10300_GNU_VTENTRY", /* name */
248 false, /* partial_inplace */
251 false), /* pcrel_offset */
253 /* Standard 24 bit reloc. */
260 complain_overflow_bitfield,
261 bfd_elf_generic_reloc,
270 struct mn10300_reloc_map
272 bfd_reloc_code_real_type bfd_reloc_val;
273 unsigned char elf_reloc_val;
276 static const struct mn10300_reloc_map mn10300_reloc_map[] =
278 { BFD_RELOC_NONE, R_MN10300_NONE, },
279 { BFD_RELOC_32, R_MN10300_32, },
280 { BFD_RELOC_16, R_MN10300_16, },
281 { BFD_RELOC_8, R_MN10300_8, },
282 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
283 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
284 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
285 { BFD_RELOC_24, R_MN10300_24, },
286 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
287 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
290 static reloc_howto_type *
291 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
292 bfd *abfd ATTRIBUTE_UNUSED;
293 bfd_reloc_code_real_type code;
298 i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map);
301 if (mn10300_reloc_map[i].bfd_reloc_val == code)
302 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
308 /* Set the howto pointer for an MN10300 ELF reloc. */
311 mn10300_info_to_howto (abfd, cache_ptr, dst)
312 bfd *abfd ATTRIBUTE_UNUSED;
314 Elf32_Internal_Rela *dst;
318 r_type = ELF32_R_TYPE (dst->r_info);
319 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
320 cache_ptr->howto = &elf_mn10300_howto_table[r_type];
323 /* Look through the relocs for a section during the first phase.
324 Since we don't do .gots or .plts, we just need to consider the
325 virtual table relocs for gc. */
328 mn10300_elf_check_relocs (abfd, info, sec, relocs)
330 struct bfd_link_info *info;
332 const Elf_Internal_Rela *relocs;
334 Elf_Internal_Shdr *symtab_hdr;
335 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
336 const Elf_Internal_Rela *rel;
337 const Elf_Internal_Rela *rel_end;
339 if (info->relocateable)
342 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
343 sym_hashes = elf_sym_hashes (abfd);
344 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
345 if (!elf_bad_symtab (abfd))
346 sym_hashes_end -= symtab_hdr->sh_info;
348 rel_end = relocs + sec->reloc_count;
349 for (rel = relocs; rel < rel_end; rel++)
351 struct elf_link_hash_entry *h;
352 unsigned long r_symndx;
354 r_symndx = ELF32_R_SYM (rel->r_info);
355 if (r_symndx < symtab_hdr->sh_info)
358 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
360 switch (ELF32_R_TYPE (rel->r_info))
362 /* This relocation describes the C++ object vtable hierarchy.
363 Reconstruct it for later use during GC. */
364 case R_MN10300_GNU_VTINHERIT:
365 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
369 /* This relocation describes which C++ vtable entries are actually
370 used. Record for later use during GC. */
371 case R_MN10300_GNU_VTENTRY:
372 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
381 /* Return the section that should be marked against GC for a given
385 mn10300_elf_gc_mark_hook (abfd, info, rel, h, sym)
387 struct bfd_link_info *info ATTRIBUTE_UNUSED;
388 Elf_Internal_Rela *rel;
389 struct elf_link_hash_entry *h;
390 Elf_Internal_Sym *sym;
394 switch (ELF32_R_TYPE (rel->r_info))
396 case R_MN10300_GNU_VTINHERIT:
397 case R_MN10300_GNU_VTENTRY:
401 switch (h->root.type)
403 case bfd_link_hash_defined:
404 case bfd_link_hash_defweak:
405 return h->root.u.def.section;
407 case bfd_link_hash_common:
408 return h->root.u.c.p->section;
417 if (!(elf_bad_symtab (abfd)
418 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
419 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
420 && sym->st_shndx != SHN_COMMON))
422 return bfd_section_from_elf_index (abfd, sym->st_shndx);
429 /* Perform a relocation as part of a final link. */
430 static bfd_reloc_status_type
431 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
432 input_section, contents, offset, value,
433 addend, info, sym_sec, is_local)
434 reloc_howto_type *howto;
436 bfd *output_bfd ATTRIBUTE_UNUSED;
437 asection *input_section;
442 struct bfd_link_info *info ATTRIBUTE_UNUSED;
443 asection *sym_sec ATTRIBUTE_UNUSED;
444 int is_local ATTRIBUTE_UNUSED;
446 unsigned long r_type = howto->type;
447 bfd_byte *hit_data = contents + offset;
456 bfd_put_32 (input_bfd, value, hit_data);
462 if ((long)value > 0x7fffff || (long)value < -0x800000)
463 return bfd_reloc_overflow;
465 bfd_put_8 (input_bfd, value & 0xff, hit_data);
466 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
467 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
473 if ((long)value > 0x7fff || (long)value < -0x8000)
474 return bfd_reloc_overflow;
476 bfd_put_16 (input_bfd, value, hit_data);
482 if ((long)value > 0x7f || (long)value < -0x80)
483 return bfd_reloc_overflow;
485 bfd_put_8 (input_bfd, value, hit_data);
488 case R_MN10300_PCREL8:
489 value -= (input_section->output_section->vma
490 + input_section->output_offset);
494 if ((long)value > 0xff || (long)value < -0x100)
495 return bfd_reloc_overflow;
497 bfd_put_8 (input_bfd, value, hit_data);
500 case R_MN10300_PCREL16:
501 value -= (input_section->output_section->vma
502 + input_section->output_offset);
506 if ((long)value > 0xffff || (long)value < -0x10000)
507 return bfd_reloc_overflow;
509 bfd_put_16 (input_bfd, value, hit_data);
512 case R_MN10300_PCREL32:
513 value -= (input_section->output_section->vma
514 + input_section->output_offset);
518 bfd_put_32 (input_bfd, value, hit_data);
521 case R_MN10300_GNU_VTINHERIT:
522 case R_MN10300_GNU_VTENTRY:
526 return bfd_reloc_notsupported;
530 /* Relocate an MN10300 ELF section. */
532 mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
533 contents, relocs, local_syms, local_sections)
535 struct bfd_link_info *info;
537 asection *input_section;
539 Elf_Internal_Rela *relocs;
540 Elf_Internal_Sym *local_syms;
541 asection **local_sections;
543 Elf_Internal_Shdr *symtab_hdr;
544 struct elf32_mn10300_link_hash_entry **sym_hashes;
545 Elf_Internal_Rela *rel, *relend;
547 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
548 sym_hashes = (struct elf32_mn10300_link_hash_entry **)
549 (elf_sym_hashes (input_bfd));
552 relend = relocs + input_section->reloc_count;
553 for (; rel < relend; rel++)
556 reloc_howto_type *howto;
557 unsigned long r_symndx;
558 Elf_Internal_Sym *sym;
560 struct elf32_mn10300_link_hash_entry *h;
562 bfd_reloc_status_type r;
564 r_symndx = ELF32_R_SYM (rel->r_info);
565 r_type = ELF32_R_TYPE (rel->r_info);
566 howto = elf_mn10300_howto_table + r_type;
568 /* Just skip the vtable gc relocs. */
569 if (r_type == R_MN10300_GNU_VTINHERIT
570 || r_type == R_MN10300_GNU_VTENTRY)
573 if (info->relocateable)
575 /* This is a relocateable link. We don't have to change
576 anything, unless the reloc is against a section symbol,
577 in which case we have to adjust according to where the
578 section symbol winds up in the output section. */
579 if (r_symndx < symtab_hdr->sh_info)
581 sym = local_syms + r_symndx;
582 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
584 sec = local_sections[r_symndx];
585 rel->r_addend += sec->output_offset + sym->st_value;
592 /* This is a final link. */
596 if (r_symndx < symtab_hdr->sh_info)
598 sym = local_syms + r_symndx;
599 sec = local_sections[r_symndx];
600 relocation = (sec->output_section->vma
606 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
607 while (h->root.type == bfd_link_hash_indirect
608 || h->root.type == bfd_link_hash_warning)
609 h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
610 if (h->root.root.type == bfd_link_hash_defined
611 || h->root.root.type == bfd_link_hash_defweak)
613 sec = h->root.root.u.def.section;
614 relocation = (h->root.root.u.def.value
615 + sec->output_section->vma
616 + sec->output_offset);
618 else if (h->root.root.type == bfd_link_hash_undefweak)
622 if (! ((*info->callbacks->undefined_symbol)
623 (info, h->root.root.root.string, input_bfd,
624 input_section, rel->r_offset, true)))
630 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
632 contents, rel->r_offset,
633 relocation, rel->r_addend,
634 info, sec, h == NULL);
636 if (r != bfd_reloc_ok)
639 const char *msg = (const char *)0;
642 name = h->root.root.root.string;
645 name = (bfd_elf_string_from_elf_section
646 (input_bfd, symtab_hdr->sh_link, sym->st_name));
647 if (name == NULL || *name == '\0')
648 name = bfd_section_name (input_bfd, sec);
653 case bfd_reloc_overflow:
654 if (! ((*info->callbacks->reloc_overflow)
655 (info, name, howto->name, (bfd_vma) 0,
656 input_bfd, input_section, rel->r_offset)))
660 case bfd_reloc_undefined:
661 if (! ((*info->callbacks->undefined_symbol)
662 (info, name, input_bfd, input_section,
663 rel->r_offset, true)))
667 case bfd_reloc_outofrange:
668 msg = _("internal error: out of range error");
671 case bfd_reloc_notsupported:
672 msg = _("internal error: unsupported relocation error");
675 case bfd_reloc_dangerous:
676 msg = _("internal error: dangerous error");
680 msg = _("internal error: unknown error");
684 if (!((*info->callbacks->warning)
685 (info, msg, name, input_bfd, input_section,
696 /* Finish initializing one hash table entry. */
698 elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
699 struct bfd_hash_entry *gen_entry;
700 PTR in_args ATTRIBUTE_UNUSED;
702 struct elf32_mn10300_link_hash_entry *entry;
703 unsigned int byte_count = 0;
705 entry = (struct elf32_mn10300_link_hash_entry *)gen_entry;
707 /* If we already know we want to convert "call" to "calls" for calls
708 to this symbol, then return now. */
709 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
712 /* If there are no named calls to this symbol, or there's nothing we
713 can move from the function itself into the "call" instruction, then
714 note that all "call" instructions should be converted into "calls"
715 instructions and return. */
716 if (entry->direct_calls == 0
717 || (entry->stack_size == 0 && entry->movm_args == 0))
719 /* Make a note that we should convert "call" instructions to "calls"
720 instructions for calls to this symbol. */
721 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
725 /* We may be able to move some instructions from the function itself into
726 the "call" instruction. Count how many bytes we might be able to
727 eliminate in the function itself. */
729 /* A movm instruction is two bytes. */
730 if (entry->movm_args)
733 /* Count the insn to allocate stack space too. */
734 if (entry->stack_size > 0 && entry->stack_size <= 128)
736 else if (entry->stack_size > 0 && entry->stack_size < 256)
739 /* If using "call" will result in larger code, then turn all
740 the associated "call" instructions into "calls" instrutions. */
741 if (byte_count < entry->direct_calls)
742 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
744 /* This routine never fails. */
748 /* This function handles relaxing for the mn10300.
750 There's quite a few relaxing opportunites available on the mn10300:
752 * calls:32 -> calls:16 2 bytes
753 * call:32 -> call:16 2 bytes
755 * call:32 -> calls:32 1 byte
756 * call:16 -> calls:16 1 byte
757 * These are done anytime using "calls" would result
758 in smaller code, or when necessary to preserve the
759 meaning of the program.
763 * In some circumstances we can move instructions
764 from a function prologue into a "call" instruction.
765 This is only done if the resulting code is no larger
766 than the original code.
768 * jmp:32 -> jmp:16 2 bytes
769 * jmp:16 -> bra:8 1 byte
771 * If the previous instruction is a conditional branch
772 around the jump/bra, we may be able to reverse its condition
773 and change its target to the jump's target. The jump/bra
774 can then be deleted. 2 bytes
776 * mov abs32 -> mov abs16 1 or 2 bytes
778 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
779 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
781 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
782 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
784 We don't handle imm16->imm8 or d16->d8 as they're very rare
785 and somewhat more difficult to support. */
788 mn10300_elf_relax_section (abfd, sec, link_info, again)
791 struct bfd_link_info *link_info;
794 Elf_Internal_Shdr *symtab_hdr;
795 Elf_Internal_Rela *internal_relocs = NULL;
796 Elf_Internal_Rela *free_relocs = NULL;
797 Elf_Internal_Rela *irel, *irelend;
798 bfd_byte *contents = NULL;
799 bfd_byte *free_contents = NULL;
800 Elf32_External_Sym *extsyms = NULL;
801 Elf32_External_Sym *free_extsyms = NULL;
802 struct elf32_mn10300_link_hash_table *hash_table;
804 /* Assume nothing changes. */
807 /* We need a pointer to the mn10300 specific hash table. */
808 hash_table = elf32_mn10300_hash_table (link_info);
810 /* Initialize fields in each hash table entry the first time through. */
811 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
815 /* Iterate over all the input bfds. */
816 for (input_bfd = link_info->input_bfds;
818 input_bfd = input_bfd->link_next)
822 /* We're going to need all the symbols for each bfd. */
823 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
825 /* Get cached copy if it exists. */
826 if (symtab_hdr->contents != NULL)
827 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
830 /* Go get them off disk. */
831 extsyms = ((Elf32_External_Sym *)
832 bfd_malloc (symtab_hdr->sh_size));
835 free_extsyms = extsyms;
836 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
837 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
838 != symtab_hdr->sh_size))
842 /* Iterate over each section in this bfd. */
843 for (section = input_bfd->sections;
845 section = section->next)
847 struct elf32_mn10300_link_hash_entry *hash;
848 Elf_Internal_Sym *sym;
849 asection *sym_sec = NULL;
850 const char *sym_name;
853 /* Get cached copy of section contents if it exists. */
854 if (elf_section_data (section)->this_hdr.contents != NULL)
855 contents = elf_section_data (section)->this_hdr.contents;
856 else if (section->_raw_size != 0)
858 /* Go get them off disk. */
859 contents = (bfd_byte *)bfd_malloc (section->_raw_size);
860 if (contents == NULL)
862 free_contents = contents;
864 if (!bfd_get_section_contents (input_bfd, section,
865 contents, (file_ptr) 0,
872 free_contents = NULL;
875 /* If there aren't any relocs, then there's nothing to do. */
876 if ((section->flags & SEC_RELOC) != 0
877 && section->reloc_count != 0)
880 /* Get a copy of the native relocations. */
881 internal_relocs = (_bfd_elf32_link_read_relocs
882 (input_bfd, section, (PTR) NULL,
883 (Elf_Internal_Rela *) NULL,
884 link_info->keep_memory));
885 if (internal_relocs == NULL)
887 if (! link_info->keep_memory)
888 free_relocs = internal_relocs;
890 /* Now examine each relocation. */
891 irel = internal_relocs;
892 irelend = irel + section->reloc_count;
893 for (; irel < irelend; irel++)
896 unsigned long r_index;
899 r_type = ELF32_R_TYPE (irel->r_info);
900 r_index = ELF32_R_SYM (irel->r_info);
902 if (r_type < 0 || r_type >= (int)R_MN10300_MAX)
905 /* We need the name and hash table entry of the target
911 if (r_index < symtab_hdr->sh_info)
913 /* A local symbol. */
914 Elf_Internal_Sym isym;
916 bfd_elf32_swap_symbol_in (input_bfd,
917 extsyms + r_index, &isym);
919 if (isym.st_shndx == SHN_UNDEF)
920 sym_sec = bfd_und_section_ptr;
921 else if (isym.st_shndx > 0
922 && isym.st_shndx < SHN_LORESERVE)
924 = bfd_section_from_elf_index (input_bfd,
926 else if (isym.st_shndx == SHN_ABS)
927 sym_sec = bfd_abs_section_ptr;
928 else if (isym.st_shndx == SHN_COMMON)
929 sym_sec = bfd_com_section_ptr;
931 sym_name = bfd_elf_string_from_elf_section (input_bfd,
935 /* If it isn't a function, then we don't care
937 if (r_index < symtab_hdr->sh_info
938 && ELF_ST_TYPE (isym.st_info) != STT_FUNC)
941 /* Tack on an ID so we can uniquely identify this
942 local symbol in the global hash table. */
943 new_name = bfd_malloc (strlen (sym_name) + 10);
947 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
950 hash = (struct elf32_mn10300_link_hash_entry *)
951 elf_link_hash_lookup (&hash_table->static_hash_table->root,
958 r_index -= symtab_hdr->sh_info;
959 hash = (struct elf32_mn10300_link_hash_entry *)
960 elf_sym_hashes (input_bfd)[r_index];
963 /* If this is not a "call" instruction, then we
964 should convert "call" instructions to "calls"
966 code = bfd_get_8 (input_bfd,
967 contents + irel->r_offset - 1);
968 if (code != 0xdd && code != 0xcd)
969 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
971 /* If this is a jump/call, then bump the direct_calls
972 counter. Else force "call" to "calls" conversions. */
973 if (r_type == R_MN10300_PCREL32
974 || r_type == R_MN10300_PCREL16)
975 hash->direct_calls++;
977 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
981 /* Now look at the actual contents to get the stack size,
982 and a list of what registers were saved in the prologue
984 if ((section->flags & SEC_CODE) != 0)
987 Elf32_External_Sym *esym, *esymend;
990 shndx = _bfd_elf_section_from_bfd_section (input_bfd,
993 /* Look at each function defined in this section and
994 update info for that function. */
996 esymend = esym + symtab_hdr->sh_info;
997 for (; esym < esymend; esym++)
999 Elf_Internal_Sym isym;
1001 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1002 if (isym.st_shndx == shndx
1003 && ELF_ST_TYPE (isym.st_info) == STT_FUNC)
1005 if (isym.st_shndx == SHN_UNDEF)
1006 sym_sec = bfd_und_section_ptr;
1007 else if (isym.st_shndx > 0
1008 && isym.st_shndx < SHN_LORESERVE)
1010 = bfd_section_from_elf_index (input_bfd,
1012 else if (isym.st_shndx == SHN_ABS)
1013 sym_sec = bfd_abs_section_ptr;
1014 else if (isym.st_shndx == SHN_COMMON)
1015 sym_sec = bfd_com_section_ptr;
1017 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1018 symtab_hdr->sh_link,
1021 /* Tack on an ID so we can uniquely identify this
1022 local symbol in the global hash table. */
1023 new_name = bfd_malloc (strlen (sym_name) + 10);
1027 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1028 sym_name = new_name;
1030 hash = (struct elf32_mn10300_link_hash_entry *)
1031 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1035 compute_function_info (input_bfd, hash,
1036 isym.st_value, contents);
1040 esym = extsyms + symtab_hdr->sh_info;
1041 esymend = extsyms + (symtab_hdr->sh_size
1042 / sizeof (Elf32_External_Sym));
1043 for (idx = 0; esym < esymend; esym++, idx++)
1045 Elf_Internal_Sym isym;
1047 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1048 hash = (struct elf32_mn10300_link_hash_entry *)
1049 elf_sym_hashes (input_bfd)[idx];
1050 if (isym.st_shndx == shndx
1051 && ELF_ST_TYPE (isym.st_info) == STT_FUNC
1052 && (hash)->root.root.u.def.section == section
1053 && ((hash)->root.root.type == bfd_link_hash_defined
1054 || (hash)->root.root.type == bfd_link_hash_defweak))
1055 compute_function_info (input_bfd, hash,
1056 (hash)->root.root.u.def.value,
1061 /* Cache or free any memory we allocated for the relocs. */
1062 if (free_relocs != NULL)
1068 /* Cache or free any memory we allocated for the contents. */
1069 if (free_contents != NULL)
1071 if (! link_info->keep_memory)
1072 free (free_contents);
1075 /* Cache the section contents for elf_link_input_bfd. */
1076 elf_section_data (section)->this_hdr.contents = contents;
1078 free_contents = NULL;
1082 /* Cache or free any memory we allocated for the symbols. */
1083 if (free_extsyms != NULL)
1085 if (! link_info->keep_memory)
1086 free (free_extsyms);
1089 /* Cache the symbols for elf_link_input_bfd. */
1090 symtab_hdr->contents = extsyms;
1092 free_extsyms = NULL;
1096 /* Now iterate on each symbol in the hash table and perform
1097 the final initialization steps on each. */
1098 elf32_mn10300_link_hash_traverse (hash_table,
1099 elf32_mn10300_finish_hash_table_entry,
1101 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
1102 elf32_mn10300_finish_hash_table_entry,
1105 /* All entries in the hash table are fully initialized. */
1106 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
1108 /* Now that everything has been initialized, go through each
1109 code section and delete any prologue insns which will be
1110 redundant because their operations will be performed by
1111 a "call" instruction. */
1112 for (input_bfd = link_info->input_bfds;
1114 input_bfd = input_bfd->link_next)
1118 /* We're going to need all the symbols for each bfd. */
1119 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1121 /* Get cached copy if it exists. */
1122 if (symtab_hdr->contents != NULL)
1123 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1126 /* Go get them off disk. */
1127 extsyms = ((Elf32_External_Sym *)
1128 bfd_malloc (symtab_hdr->sh_size));
1129 if (extsyms == NULL)
1131 free_extsyms = extsyms;
1132 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1133 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
1134 != symtab_hdr->sh_size))
1138 /* Walk over each section in this bfd. */
1139 for (section = input_bfd->sections;
1141 section = section->next)
1144 Elf32_External_Sym *esym, *esymend;
1147 /* Skip non-code sections and empty sections. */
1148 if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
1151 if (section->reloc_count != 0)
1153 /* Get a copy of the native relocations. */
1154 internal_relocs = (_bfd_elf32_link_read_relocs
1155 (input_bfd, section, (PTR) NULL,
1156 (Elf_Internal_Rela *) NULL,
1157 link_info->keep_memory));
1158 if (internal_relocs == NULL)
1160 if (! link_info->keep_memory)
1161 free_relocs = internal_relocs;
1164 /* Get cached copy of section contents if it exists. */
1165 if (elf_section_data (section)->this_hdr.contents != NULL)
1166 contents = elf_section_data (section)->this_hdr.contents;
1169 /* Go get them off disk. */
1170 contents = (bfd_byte *)bfd_malloc (section->_raw_size);
1171 if (contents == NULL)
1173 free_contents = contents;
1175 if (!bfd_get_section_contents (input_bfd, section,
1176 contents, (file_ptr) 0,
1177 section->_raw_size))
1181 shndx = _bfd_elf_section_from_bfd_section (input_bfd, section);
1183 /* Now look for any function in this section which needs
1184 insns deleted from its prologue. */
1186 esymend = esym + symtab_hdr->sh_info;
1187 for (; esym < esymend; esym++)
1189 Elf_Internal_Sym isym;
1190 struct elf32_mn10300_link_hash_entry *sym_hash;
1191 asection *sym_sec = NULL;
1192 const char *sym_name;
1195 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1197 if (isym.st_shndx != shndx)
1200 if (isym.st_shndx == SHN_UNDEF)
1201 sym_sec = bfd_und_section_ptr;
1202 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1204 = bfd_section_from_elf_index (input_bfd, isym.st_shndx);
1205 else if (isym.st_shndx == SHN_ABS)
1206 sym_sec = bfd_abs_section_ptr;
1207 else if (isym.st_shndx == SHN_COMMON)
1208 sym_sec = bfd_com_section_ptr;
1212 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1213 symtab_hdr->sh_link,
1216 /* Tack on an ID so we can uniquely identify this
1217 local symbol in the global hash table. */
1218 new_name = bfd_malloc (strlen (sym_name) + 10);
1221 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1222 sym_name = new_name;
1224 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1225 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1230 if (sym_hash == NULL)
1233 if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1234 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1238 /* Note that we've changed things. */
1239 elf_section_data (section)->relocs = internal_relocs;
1242 elf_section_data (section)->this_hdr.contents = contents;
1243 free_contents = NULL;
1245 symtab_hdr->contents = (bfd_byte *)extsyms;
1246 free_extsyms = NULL;
1248 /* Count how many bytes we're going to delete. */
1249 if (sym_hash->movm_args)
1252 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1254 else if (sym_hash->stack_size
1255 && sym_hash->stack_size < 256)
1258 /* Note that we've deleted prologue bytes for this
1260 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1262 /* Actually delete the bytes. */
1263 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1269 /* Something changed. Not strictly necessary, but
1270 may lead to more relaxing opportunities. */
1275 /* Look for any global functions in this section which
1276 need insns deleted from their prologues. */
1277 esym = extsyms + symtab_hdr->sh_info;
1278 esymend = extsyms + (symtab_hdr->sh_size
1279 / sizeof (Elf32_External_Sym));
1280 for (idx = 0; esym < esymend; esym++, idx++)
1282 Elf_Internal_Sym isym;
1283 struct elf32_mn10300_link_hash_entry *sym_hash;
1285 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1286 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1287 (elf_sym_hashes (input_bfd)[idx]);
1288 if (isym.st_shndx == shndx
1289 && (sym_hash)->root.root.u.def.section == section
1290 && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1291 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1295 /* Note that we've changed things. */
1296 elf_section_data (section)->relocs = internal_relocs;
1299 elf_section_data (section)->this_hdr.contents = contents;
1300 free_contents = NULL;
1302 symtab_hdr->contents = (bfd_byte *)extsyms;
1303 free_extsyms = NULL;
1305 /* Count how many bytes we're going to delete. */
1306 if (sym_hash->movm_args)
1309 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1311 else if (sym_hash->stack_size
1312 && sym_hash->stack_size < 256)
1315 /* Note that we've deleted prologue bytes for this
1317 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1319 /* Actually delete the bytes. */
1320 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1322 (sym_hash)->root.root.u.def.value,
1326 /* Something changed. Not strictly necessary, but
1327 may lead to more relaxing opportunities. */
1332 /* Cache or free any memory we allocated for the relocs. */
1333 if (free_relocs != NULL)
1339 /* Cache or free any memory we allocated for the contents. */
1340 if (free_contents != NULL)
1342 if (! link_info->keep_memory)
1343 free (free_contents);
1346 /* Cache the section contents for elf_link_input_bfd. */
1347 elf_section_data (section)->this_hdr.contents = contents;
1349 free_contents = NULL;
1353 /* Cache or free any memory we allocated for the symbols. */
1354 if (free_extsyms != NULL)
1356 if (! link_info->keep_memory)
1357 free (free_extsyms);
1360 /* Cache the symbols for elf_link_input_bfd. */
1361 symtab_hdr->contents = extsyms;
1363 free_extsyms = NULL;
1368 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
1371 internal_relocs = NULL;
1373 free_contents = NULL;
1374 free_extsyms = NULL;
1376 /* We don't have to do anything for a relocateable link, if
1377 this section does not have relocs, or if this is not a
1379 if (link_info->relocateable
1380 || (sec->flags & SEC_RELOC) == 0
1381 || sec->reloc_count == 0
1382 || (sec->flags & SEC_CODE) == 0)
1385 /* If this is the first time we have been called for this section,
1386 initialize the cooked size. */
1387 if (sec->_cooked_size == 0)
1388 sec->_cooked_size = sec->_raw_size;
1390 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1392 /* Get a copy of the native relocations. */
1393 internal_relocs = (_bfd_elf32_link_read_relocs
1394 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1395 link_info->keep_memory));
1396 if (internal_relocs == NULL)
1398 if (! link_info->keep_memory)
1399 free_relocs = internal_relocs;
1401 /* Walk through them looking for relaxing opportunities. */
1402 irelend = internal_relocs + sec->reloc_count;
1403 for (irel = internal_relocs; irel < irelend; irel++)
1406 struct elf32_mn10300_link_hash_entry *h = NULL;
1408 /* If this isn't something that can be relaxed, then ignore
1410 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1411 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1412 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1415 /* Get the section contents if we haven't done so already. */
1416 if (contents == NULL)
1418 /* Get cached copy if it exists. */
1419 if (elf_section_data (sec)->this_hdr.contents != NULL)
1420 contents = elf_section_data (sec)->this_hdr.contents;
1423 /* Go get them off disk. */
1424 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1425 if (contents == NULL)
1427 free_contents = contents;
1429 if (! bfd_get_section_contents (abfd, sec, contents,
1430 (file_ptr) 0, sec->_raw_size))
1435 /* Read this BFD's symbols if we haven't done so already. */
1436 if (extsyms == NULL)
1438 /* Get cached copy if it exists. */
1439 if (symtab_hdr->contents != NULL)
1440 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1443 /* Go get them off disk. */
1444 extsyms = ((Elf32_External_Sym *)
1445 bfd_malloc (symtab_hdr->sh_size));
1446 if (extsyms == NULL)
1448 free_extsyms = extsyms;
1449 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1450 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1451 != symtab_hdr->sh_size))
1456 /* Get the value of the symbol referred to by the reloc. */
1457 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1459 Elf_Internal_Sym isym;
1460 asection *sym_sec = NULL;
1461 const char *sym_name;
1464 /* A local symbol. */
1465 bfd_elf32_swap_symbol_in (abfd,
1466 extsyms + ELF32_R_SYM (irel->r_info),
1469 if (isym.st_shndx == SHN_UNDEF)
1470 sym_sec = bfd_und_section_ptr;
1471 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1472 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1473 else if (isym.st_shndx == SHN_ABS)
1474 sym_sec = bfd_abs_section_ptr;
1475 else if (isym.st_shndx == SHN_COMMON)
1476 sym_sec = bfd_com_section_ptr;
1480 symval = (isym.st_value
1481 + sym_sec->output_section->vma
1482 + sym_sec->output_offset);
1483 sym_name = bfd_elf_string_from_elf_section (abfd,
1484 symtab_hdr->sh_link,
1487 /* Tack on an ID so we can uniquely identify this
1488 local symbol in the global hash table. */
1489 new_name = bfd_malloc (strlen (sym_name) + 10);
1492 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1493 sym_name = new_name;
1495 h = (struct elf32_mn10300_link_hash_entry *)
1496 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1497 sym_name, false, false, false);
1504 /* An external symbol. */
1505 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1506 h = (struct elf32_mn10300_link_hash_entry *)
1507 (elf_sym_hashes (abfd)[indx]);
1508 BFD_ASSERT (h != NULL);
1509 if (h->root.root.type != bfd_link_hash_defined
1510 && h->root.root.type != bfd_link_hash_defweak)
1512 /* This appears to be a reference to an undefined
1513 symbol. Just ignore it--it will be caught by the
1514 regular reloc processing. */
1518 symval = (h->root.root.u.def.value
1519 + h->root.root.u.def.section->output_section->vma
1520 + h->root.root.u.def.section->output_offset);
1523 /* For simplicity of coding, we are going to modify the section
1524 contents, the section relocs, and the BFD symbol table. We
1525 must tell the rest of the code not to free up this
1526 information. It would be possible to instead create a table
1527 of changes which have to be made, as is done in coff-mips.c;
1528 that would be more work, but would require less memory when
1529 the linker is run. */
1531 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1532 branch/call, also deal with "call" -> "calls" conversions and
1533 insertion of prologue data into "call" instructions. */
1534 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
1536 bfd_vma value = symval;
1538 /* If we've got a "call" instruction that needs to be turned
1539 into a "calls" instruction, do so now. It saves a byte. */
1540 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1544 /* Get the opcode. */
1545 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1547 /* Make sure we're working with a "call" instruction! */
1550 /* Note that we've changed the relocs, section contents,
1552 elf_section_data (sec)->relocs = internal_relocs;
1555 elf_section_data (sec)->this_hdr.contents = contents;
1556 free_contents = NULL;
1558 symtab_hdr->contents = (bfd_byte *) extsyms;
1559 free_extsyms = NULL;
1561 /* Fix the opcode. */
1562 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
1563 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1565 /* Fix irel->r_offset and irel->r_addend. */
1566 irel->r_offset += 1;
1567 irel->r_addend += 1;
1569 /* Delete one byte of data. */
1570 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1571 irel->r_offset + 3, 1))
1574 /* That will change things, so, we should relax again.
1575 Note that this is not required, and it may be slow. */
1581 /* We've got a "call" instruction which needs some data
1582 from target function filled in. */
1585 /* Get the opcode. */
1586 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1588 /* Insert data from the target function into the "call"
1589 instruction if needed. */
1592 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
1593 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1594 contents + irel->r_offset + 5);
1598 /* Deal with pc-relative gunk. */
1599 value -= (sec->output_section->vma + sec->output_offset);
1600 value -= irel->r_offset;
1601 value += irel->r_addend;
1603 /* See if the value will fit in 16 bits, note the high value is
1604 0x7fff + 2 as the target will be two bytes closer if we are
1606 if ((long)value < 0x8001 && (long)value > -0x8000)
1610 /* Get the opcode. */
1611 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1613 if (code != 0xdc && code != 0xdd && code != 0xff)
1616 /* Note that we've changed the relocs, section contents, etc. */
1617 elf_section_data (sec)->relocs = internal_relocs;
1620 elf_section_data (sec)->this_hdr.contents = contents;
1621 free_contents = NULL;
1623 symtab_hdr->contents = (bfd_byte *) extsyms;
1624 free_extsyms = NULL;
1626 /* Fix the opcode. */
1628 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
1629 else if (code == 0xdd)
1630 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
1631 else if (code == 0xff)
1632 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1634 /* Fix the relocation's type. */
1635 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1638 /* Delete two bytes of data. */
1639 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1640 irel->r_offset + 1, 2))
1643 /* That will change things, so, we should relax again.
1644 Note that this is not required, and it may be slow. */
1649 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1651 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
1653 bfd_vma value = symval;
1655 /* If we've got a "call" instruction that needs to be turned
1656 into a "calls" instruction, do so now. It saves a byte. */
1657 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1661 /* Get the opcode. */
1662 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1664 /* Make sure we're working with a "call" instruction! */
1667 /* Note that we've changed the relocs, section contents,
1669 elf_section_data (sec)->relocs = internal_relocs;
1672 elf_section_data (sec)->this_hdr.contents = contents;
1673 free_contents = NULL;
1675 symtab_hdr->contents = (bfd_byte *) extsyms;
1676 free_extsyms = NULL;
1678 /* Fix the opcode. */
1679 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
1680 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1682 /* Fix irel->r_offset and irel->r_addend. */
1683 irel->r_offset += 1;
1684 irel->r_addend += 1;
1686 /* Delete one byte of data. */
1687 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1688 irel->r_offset + 1, 1))
1691 /* That will change things, so, we should relax again.
1692 Note that this is not required, and it may be slow. */
1700 /* Get the opcode. */
1701 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1703 /* Insert data from the target function into the "call"
1704 instruction if needed. */
1707 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
1708 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1709 contents + irel->r_offset + 3);
1713 /* Deal with pc-relative gunk. */
1714 value -= (sec->output_section->vma + sec->output_offset);
1715 value -= irel->r_offset;
1716 value += irel->r_addend;
1718 /* See if the value will fit in 8 bits, note the high value is
1719 0x7f + 1 as the target will be one bytes closer if we are
1721 if ((long)value < 0x80 && (long)value > -0x80)
1725 /* Get the opcode. */
1726 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1731 /* Note that we've changed the relocs, section contents, etc. */
1732 elf_section_data (sec)->relocs = internal_relocs;
1735 elf_section_data (sec)->this_hdr.contents = contents;
1736 free_contents = NULL;
1738 symtab_hdr->contents = (bfd_byte *) extsyms;
1739 free_extsyms = NULL;
1741 /* Fix the opcode. */
1742 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
1744 /* Fix the relocation's type. */
1745 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1748 /* Delete one byte of data. */
1749 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1750 irel->r_offset + 1, 1))
1753 /* That will change things, so, we should relax again.
1754 Note that this is not required, and it may be slow. */
1759 /* Try to eliminate an unconditional 8 bit pc-relative branch
1760 which immediately follows a conditional 8 bit pc-relative
1761 branch around the unconditional branch.
1768 This happens when the bCC can't reach lab2 at assembly time,
1769 but due to other relaxations it can reach at link time. */
1770 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
1772 Elf_Internal_Rela *nrel;
1773 bfd_vma value = symval;
1776 /* Deal with pc-relative gunk. */
1777 value -= (sec->output_section->vma + sec->output_offset);
1778 value -= irel->r_offset;
1779 value += irel->r_addend;
1781 /* Do nothing if this reloc is the last byte in the section. */
1782 if (irel->r_offset == sec->_cooked_size)
1785 /* See if the next instruction is an unconditional pc-relative
1786 branch, more often than not this test will fail, so we
1787 test it first to speed things up. */
1788 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1792 /* Also make sure the next relocation applies to the next
1793 instruction and that it's a pc-relative 8 bit branch. */
1796 || irel->r_offset + 2 != nrel->r_offset
1797 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
1800 /* Make sure our destination immediately follows the
1801 unconditional branch. */
1802 if (symval != (sec->output_section->vma + sec->output_offset
1803 + irel->r_offset + 3))
1806 /* Now make sure we are a conditional branch. This may not
1807 be necessary, but why take the chance.
1809 Note these checks assume that R_MN10300_PCREL8 relocs
1810 only occur on bCC and bCCx insns. If they occured
1811 elsewhere, we'd need to know the start of this insn
1812 for this check to be accurate. */
1813 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1814 if (code != 0xc0 && code != 0xc1 && code != 0xc2
1815 && code != 0xc3 && code != 0xc4 && code != 0xc5
1816 && code != 0xc6 && code != 0xc7 && code != 0xc8
1817 && code != 0xc9 && code != 0xe8 && code != 0xe9
1818 && code != 0xea && code != 0xeb)
1821 /* We also have to be sure there is no symbol/label
1822 at the unconditional branch. */
1823 if (mn10300_elf_symbol_address_p (abfd, sec, extsyms,
1824 irel->r_offset + 1))
1827 /* Note that we've changed the relocs, section contents, etc. */
1828 elf_section_data (sec)->relocs = internal_relocs;
1831 elf_section_data (sec)->this_hdr.contents = contents;
1832 free_contents = NULL;
1834 symtab_hdr->contents = (bfd_byte *) extsyms;
1835 free_extsyms = NULL;
1837 /* Reverse the condition of the first branch. */
1883 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1885 /* Set the reloc type and symbol for the first branch
1886 from the second branch. */
1887 irel->r_info = nrel->r_info;
1889 /* Make the reloc for the second branch a null reloc. */
1890 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1893 /* Delete two bytes of data. */
1894 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1895 irel->r_offset + 1, 2))
1898 /* That will change things, so, we should relax again.
1899 Note that this is not required, and it may be slow. */
1903 /* Try to turn a 24 immediate, displacement or absolute address
1904 into a 8 immediate, displacement or absolute address. */
1905 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
1907 bfd_vma value = symval;
1908 value += irel->r_addend;
1910 /* See if the value will fit in 8 bits. */
1911 if ((long)value < 0x7f && (long)value > -0x80)
1915 /* AM33 insns which have 24 operands are 6 bytes long and
1916 will have 0xfd as the first byte. */
1918 /* Get the first opcode. */
1919 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1923 /* Get the second opcode. */
1924 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1926 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
1927 equivalent instructions exists. */
1928 if (code != 0x6b && code != 0x7b
1929 && code != 0x8b && code != 0x9b
1930 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
1931 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
1932 || (code & 0x0f) == 0x0e))
1934 /* Not safe if the high bit is on as relaxing may
1935 move the value out of high mem and thus not fit
1936 in a signed 8bit value. This is currently over
1938 if ((value & 0x80) == 0)
1940 /* Note that we've changed the relocation contents,
1942 elf_section_data (sec)->relocs = internal_relocs;
1945 elf_section_data (sec)->this_hdr.contents = contents;
1946 free_contents = NULL;
1948 symtab_hdr->contents = (bfd_byte *) extsyms;
1949 free_extsyms = NULL;
1951 /* Fix the opcode. */
1952 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
1953 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1955 /* Fix the relocation's type. */
1957 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1960 /* Delete two bytes of data. */
1961 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1962 irel->r_offset + 1, 2))
1965 /* That will change things, so, we should relax
1966 again. Note that this is not required, and it
1977 /* Try to turn a 32bit immediate, displacement or absolute address
1978 into a 16bit immediate, displacement or absolute address. */
1979 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1981 bfd_vma value = symval;
1982 value += irel->r_addend;
1984 /* See if the value will fit in 24 bits.
1985 We allow any 16bit match here. We prune those we can't
1987 if ((long)value < 0x7fffff && (long)value > -0x800000)
1991 /* AM33 insns which have 32bit operands are 7 bytes long and
1992 will have 0xfe as the first byte. */
1994 /* Get the first opcode. */
1995 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1999 /* Get the second opcode. */
2000 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2002 /* All the am33 32 -> 24 relaxing possibilities. */
2003 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2004 equivalent instructions exists. */
2005 if (code != 0x6b && code != 0x7b
2006 && code != 0x8b && code != 0x9b
2007 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
2008 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
2009 || (code & 0x0f) == 0x0e))
2011 /* Not safe if the high bit is on as relaxing may
2012 move the value out of high mem and thus not fit
2013 in a signed 16bit value. This is currently over
2015 if ((value & 0x8000) == 0)
2017 /* Note that we've changed the relocation contents,
2019 elf_section_data (sec)->relocs = internal_relocs;
2022 elf_section_data (sec)->this_hdr.contents = contents;
2023 free_contents = NULL;
2025 symtab_hdr->contents = (bfd_byte *) extsyms;
2026 free_extsyms = NULL;
2028 /* Fix the opcode. */
2029 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
2030 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2032 /* Fix the relocation's type. */
2034 = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2037 /* Delete one byte of data. */
2038 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2039 irel->r_offset + 3, 1))
2042 /* That will change things, so, we should relax
2043 again. Note that this is not required, and it
2053 /* See if the value will fit in 16 bits.
2054 We allow any 16bit match here. We prune those we can't
2056 if ((long)value < 0x7fff && (long)value > -0x8000)
2060 /* Most insns which have 32bit operands are 6 bytes long;
2061 exceptions are pcrel insns and bit insns.
2063 We handle pcrel insns above. We don't bother trying
2064 to handle the bit insns here.
2066 The first byte of the remaining insns will be 0xfc. */
2068 /* Get the first opcode. */
2069 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2074 /* Get the second opcode. */
2075 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2077 if ((code & 0xf0) < 0x80)
2078 switch (code & 0xf0)
2080 /* mov (d32,am),dn -> mov (d32,am),dn
2081 mov dm,(d32,am) -> mov dn,(d32,am)
2082 mov (d32,am),an -> mov (d32,am),an
2083 mov dm,(d32,am) -> mov dn,(d32,am)
2084 movbu (d32,am),dn -> movbu (d32,am),dn
2085 movbu dm,(d32,am) -> movbu dn,(d32,am)
2086 movhu (d32,am),dn -> movhu (d32,am),dn
2087 movhu dm,(d32,am) -> movhu dn,(d32,am) */
2096 /* Not safe if the high bit is on as relaxing may
2097 move the value out of high mem and thus not fit
2098 in a signed 16bit value. */
2100 && (value & 0x8000))
2103 /* Note that we've changed the relocation contents, etc. */
2104 elf_section_data (sec)->relocs = internal_relocs;
2107 elf_section_data (sec)->this_hdr.contents = contents;
2108 free_contents = NULL;
2110 symtab_hdr->contents = (bfd_byte *) extsyms;
2111 free_extsyms = NULL;
2113 /* Fix the opcode. */
2114 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2115 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2117 /* Fix the relocation's type. */
2118 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2121 /* Delete two bytes of data. */
2122 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2123 irel->r_offset + 2, 2))
2126 /* That will change things, so, we should relax again.
2127 Note that this is not required, and it may be slow. */
2131 else if ((code & 0xf0) == 0x80
2132 || (code & 0xf0) == 0x90)
2133 switch (code & 0xf3)
2135 /* mov dn,(abs32) -> mov dn,(abs16)
2136 movbu dn,(abs32) -> movbu dn,(abs16)
2137 movhu dn,(abs32) -> movhu dn,(abs16) */
2141 /* Note that we've changed the relocation contents, etc. */
2142 elf_section_data (sec)->relocs = internal_relocs;
2145 elf_section_data (sec)->this_hdr.contents = contents;
2146 free_contents = NULL;
2148 symtab_hdr->contents = (bfd_byte *) extsyms;
2149 free_extsyms = NULL;
2151 if ((code & 0xf3) == 0x81)
2152 code = 0x01 + (code & 0x0c);
2153 else if ((code & 0xf3) == 0x82)
2154 code = 0x02 + (code & 0x0c);
2155 else if ((code & 0xf3) == 0x83)
2156 code = 0x03 + (code & 0x0c);
2160 /* Fix the opcode. */
2161 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2163 /* Fix the relocation's type. */
2164 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2167 /* The opcode got shorter too, so we have to fix the
2168 addend and offset too! */
2169 irel->r_offset -= 1;
2171 /* Delete three bytes of data. */
2172 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2173 irel->r_offset + 1, 3))
2176 /* That will change things, so, we should relax again.
2177 Note that this is not required, and it may be slow. */
2181 /* mov am,(abs32) -> mov am,(abs16)
2182 mov am,(d32,sp) -> mov am,(d16,sp)
2183 mov dm,(d32,sp) -> mov dm,(d32,sp)
2184 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2185 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2191 /* Note that we've changed the relocation contents, etc. */
2192 elf_section_data (sec)->relocs = internal_relocs;
2195 elf_section_data (sec)->this_hdr.contents = contents;
2196 free_contents = NULL;
2198 symtab_hdr->contents = (bfd_byte *) extsyms;
2199 free_extsyms = NULL;
2201 /* Fix the opcode. */
2202 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2203 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2205 /* Fix the relocation's type. */
2206 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2209 /* Delete two bytes of data. */
2210 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2211 irel->r_offset + 2, 2))
2214 /* That will change things, so, we should relax again.
2215 Note that this is not required, and it may be slow. */
2219 else if ((code & 0xf0) < 0xf0)
2220 switch (code & 0xfc)
2222 /* mov imm32,dn -> mov imm16,dn
2223 mov imm32,an -> mov imm16,an
2224 mov (abs32),dn -> mov (abs16),dn
2225 movbu (abs32),dn -> movbu (abs16),dn
2226 movhu (abs32),dn -> movhu (abs16),dn */
2232 /* Not safe if the high bit is on as relaxing may
2233 move the value out of high mem and thus not fit
2234 in a signed 16bit value. */
2236 && (value & 0x8000))
2239 /* Note that we've changed the relocation contents, etc. */
2240 elf_section_data (sec)->relocs = internal_relocs;
2243 elf_section_data (sec)->this_hdr.contents = contents;
2244 free_contents = NULL;
2246 symtab_hdr->contents = (bfd_byte *) extsyms;
2247 free_extsyms = NULL;
2249 if ((code & 0xfc) == 0xcc)
2250 code = 0x2c + (code & 0x03);
2251 else if ((code & 0xfc) == 0xdc)
2252 code = 0x24 + (code & 0x03);
2253 else if ((code & 0xfc) == 0xa4)
2254 code = 0x30 + (code & 0x03);
2255 else if ((code & 0xfc) == 0xa8)
2256 code = 0x34 + (code & 0x03);
2257 else if ((code & 0xfc) == 0xac)
2258 code = 0x38 + (code & 0x03);
2262 /* Fix the opcode. */
2263 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2265 /* Fix the relocation's type. */
2266 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2269 /* The opcode got shorter too, so we have to fix the
2270 addend and offset too! */
2271 irel->r_offset -= 1;
2273 /* Delete three bytes of data. */
2274 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2275 irel->r_offset + 1, 3))
2278 /* That will change things, so, we should relax again.
2279 Note that this is not required, and it may be slow. */
2283 /* mov (abs32),an -> mov (abs16),an
2284 mov (d32,sp),an -> mov (d32,sp),an
2285 mov (d32,sp),dn -> mov (d32,sp),dn
2286 movbu (d32,sp),dn -> movbu (d32,sp),dn
2287 movhu (d32,sp),dn -> movhu (d32,sp),dn
2288 add imm32,dn -> add imm16,dn
2289 cmp imm32,dn -> cmp imm16,dn
2290 add imm32,an -> add imm16,an
2291 cmp imm32,an -> cmp imm16,an
2292 and imm32,dn -> and imm32,dn
2293 or imm32,dn -> or imm32,dn
2294 xor imm32,dn -> xor imm32,dn
2295 btst imm32,dn -> btst imm32,dn */
2311 /* Note that we've changed the relocation contents, etc. */
2312 elf_section_data (sec)->relocs = internal_relocs;
2315 elf_section_data (sec)->this_hdr.contents = contents;
2316 free_contents = NULL;
2318 symtab_hdr->contents = (bfd_byte *) extsyms;
2319 free_extsyms = NULL;
2321 /* Fix the opcode. */
2322 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2323 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2325 /* Fix the relocation's type. */
2326 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2329 /* Delete two bytes of data. */
2330 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2331 irel->r_offset + 2, 2))
2334 /* That will change things, so, we should relax again.
2335 Note that this is not required, and it may be slow. */
2339 else if (code == 0xfe)
2341 /* add imm32,sp -> add imm16,sp */
2343 /* Note that we've changed the relocation contents, etc. */
2344 elf_section_data (sec)->relocs = internal_relocs;
2347 elf_section_data (sec)->this_hdr.contents = contents;
2348 free_contents = NULL;
2350 symtab_hdr->contents = (bfd_byte *) extsyms;
2351 free_extsyms = NULL;
2353 /* Fix the opcode. */
2354 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2355 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2357 /* Fix the relocation's type. */
2358 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2361 /* Delete two bytes of data. */
2362 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2363 irel->r_offset + 2, 2))
2366 /* That will change things, so, we should relax again.
2367 Note that this is not required, and it may be slow. */
2375 if (free_relocs != NULL)
2381 if (free_contents != NULL)
2383 if (! link_info->keep_memory)
2384 free (free_contents);
2387 /* Cache the section contents for elf_link_input_bfd. */
2388 elf_section_data (sec)->this_hdr.contents = contents;
2390 free_contents = NULL;
2393 if (free_extsyms != NULL)
2395 if (! link_info->keep_memory)
2396 free (free_extsyms);
2399 /* Cache the symbols for elf_link_input_bfd. */
2400 symtab_hdr->contents = extsyms;
2402 free_extsyms = NULL;
2408 if (free_relocs != NULL)
2410 if (free_contents != NULL)
2411 free (free_contents);
2412 if (free_extsyms != NULL)
2413 free (free_extsyms);
2417 /* Compute the stack size and movm arguments for the function
2418 referred to by HASH at address ADDR in section with
2419 contents CONTENTS, store the information in the hash table. */
2421 compute_function_info (abfd, hash, addr, contents)
2423 struct elf32_mn10300_link_hash_entry *hash;
2425 unsigned char *contents;
2427 unsigned char byte1, byte2;
2428 /* We only care about a very small subset of the possible prologue
2429 sequences here. Basically we look for:
2431 movm [d2,d3,a2,a3],sp (optional)
2432 add <size>,sp (optional, and only for sizes which fit in an unsigned
2435 If we find anything else, we quit. */
2437 /* Look for movm [regs],sp */
2438 byte1 = bfd_get_8 (abfd, contents + addr);
2439 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2443 hash->movm_args = byte2;
2445 byte1 = bfd_get_8 (abfd, contents + addr);
2446 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2449 /* Now figure out how much stack space will be allocated by the movm
2450 instruction. We need this kept separate from the funtion's normal
2452 if (hash->movm_args)
2455 if (hash->movm_args & 0x80)
2456 hash->movm_stack_size += 4;
2459 if (hash->movm_args & 0x40)
2460 hash->movm_stack_size += 4;
2463 if (hash->movm_args & 0x20)
2464 hash->movm_stack_size += 4;
2467 if (hash->movm_args & 0x10)
2468 hash->movm_stack_size += 4;
2470 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
2471 if (hash->movm_args & 0x08)
2472 hash->movm_stack_size += 8 * 4;
2474 if (bfd_get_mach (abfd) == bfd_mach_am33)
2476 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
2477 if (hash->movm_args & 0x1)
2478 hash->movm_stack_size += 6 * 4;
2480 /* exreg1 space. e4, e5, e6, e7 */
2481 if (hash->movm_args & 0x2)
2482 hash->movm_stack_size += 4 * 4;
2484 /* exreg0 space. e2, e3 */
2485 if (hash->movm_args & 0x4)
2486 hash->movm_stack_size += 2 * 4;
2490 /* Now look for the two stack adjustment variants. */
2491 if (byte1 == 0xf8 && byte2 == 0xfe)
2493 int temp = bfd_get_8 (abfd, contents + addr + 2);
2494 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2496 hash->stack_size = -temp;
2498 else if (byte1 == 0xfa && byte2 == 0xfe)
2500 int temp = bfd_get_16 (abfd, contents + addr + 2);
2501 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2505 hash->stack_size = temp;
2508 /* If the total stack to be allocated by the call instruction is more
2509 than 255 bytes, then we can't remove the stack adjustment by using
2510 "call" (we might still be able to remove the "movm" instruction. */
2511 if (hash->stack_size + hash->movm_stack_size > 255)
2512 hash->stack_size = 0;
2517 /* Delete some bytes from a section while relaxing. */
2520 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2526 Elf_Internal_Shdr *symtab_hdr;
2527 Elf32_External_Sym *extsyms;
2530 Elf_Internal_Rela *irel, *irelend;
2531 Elf_Internal_Rela *irelalign;
2533 Elf32_External_Sym *esym, *esymend;
2534 struct elf32_mn10300_link_hash_entry *sym_hash;
2536 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2537 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2539 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2541 contents = elf_section_data (sec)->this_hdr.contents;
2543 /* The deletion must stop at the next ALIGN reloc for an aligment
2544 power larger than the number of bytes we are deleting. */
2547 toaddr = sec->_cooked_size;
2549 irel = elf_section_data (sec)->relocs;
2550 irelend = irel + sec->reloc_count;
2552 /* Actually delete the bytes. */
2553 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2554 sec->_cooked_size -= count;
2556 /* Adjust all the relocs. */
2557 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2559 /* Get the new reloc address. */
2560 if ((irel->r_offset > addr
2561 && irel->r_offset < toaddr))
2562 irel->r_offset -= count;
2565 /* Adjust the local symbols defined in this section. */
2567 esymend = esym + symtab_hdr->sh_info;
2568 for (; esym < esymend; esym++)
2570 Elf_Internal_Sym isym;
2572 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2574 if (isym.st_shndx == shndx
2575 && isym.st_value > addr
2576 && isym.st_value < toaddr)
2578 isym.st_value -= count;
2579 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2583 /* Now adjust the global symbols defined in this section. */
2584 esym = extsyms + symtab_hdr->sh_info;
2585 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2586 for (index = 0; esym < esymend; esym++, index++)
2588 Elf_Internal_Sym isym;
2590 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2591 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2592 (elf_sym_hashes (abfd)[index]);
2593 if (isym.st_shndx == shndx
2594 && ((sym_hash)->root.root.type == bfd_link_hash_defined
2595 || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2596 && (sym_hash)->root.root.u.def.section == sec
2597 && (sym_hash)->root.root.u.def.value > addr
2598 && (sym_hash)->root.root.u.def.value < toaddr)
2600 (sym_hash)->root.root.u.def.value -= count;
2607 /* Return true if a symbol exists at the given address, else return
2610 mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2613 Elf32_External_Sym *extsyms;
2616 Elf_Internal_Shdr *symtab_hdr;
2618 Elf32_External_Sym *esym, *esymend;
2619 struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2621 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2622 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2624 /* Examine all the symbols. */
2626 esymend = esym + symtab_hdr->sh_info;
2627 for (; esym < esymend; esym++)
2629 Elf_Internal_Sym isym;
2631 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2633 if (isym.st_shndx == shndx
2634 && isym.st_value == addr)
2638 sym_hash = (struct elf32_mn10300_link_hash_entry **) (elf_sym_hashes (abfd));
2639 sym_hash_end = (sym_hash
2640 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2641 - symtab_hdr->sh_info));
2642 for (; sym_hash < sym_hash_end; sym_hash++)
2644 if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2645 || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2646 && (*sym_hash)->root.root.u.def.section == sec
2647 && (*sym_hash)->root.root.u.def.value == addr)
2653 /* This is a version of bfd_generic_get_relocated_section_contents
2654 which uses mn10300_elf_relocate_section. */
2657 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2658 data, relocateable, symbols)
2660 struct bfd_link_info *link_info;
2661 struct bfd_link_order *link_order;
2663 boolean relocateable;
2666 Elf_Internal_Shdr *symtab_hdr;
2667 asection *input_section = link_order->u.indirect.section;
2668 bfd *input_bfd = input_section->owner;
2669 asection **sections = NULL;
2670 Elf_Internal_Rela *internal_relocs = NULL;
2671 Elf32_External_Sym *external_syms = NULL;
2672 Elf_Internal_Sym *internal_syms = NULL;
2674 /* We only need to handle the case of relaxing, or of having a
2675 particular set of section contents, specially. */
2677 || elf_section_data (input_section)->this_hdr.contents == NULL)
2678 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2683 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2685 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2686 input_section->_raw_size);
2688 if ((input_section->flags & SEC_RELOC) != 0
2689 && input_section->reloc_count > 0)
2691 Elf_Internal_Sym *isymp;
2693 Elf32_External_Sym *esym, *esymend;
2695 if (symtab_hdr->contents != NULL)
2696 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2699 external_syms = ((Elf32_External_Sym *)
2700 bfd_malloc (symtab_hdr->sh_info
2701 * sizeof (Elf32_External_Sym)));
2702 if (external_syms == NULL && symtab_hdr->sh_info > 0)
2704 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2705 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2706 symtab_hdr->sh_info, input_bfd)
2707 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2711 internal_relocs = (_bfd_elf32_link_read_relocs
2712 (input_bfd, input_section, (PTR) NULL,
2713 (Elf_Internal_Rela *) NULL, false));
2714 if (internal_relocs == NULL)
2717 internal_syms = ((Elf_Internal_Sym *)
2718 bfd_malloc (symtab_hdr->sh_info
2719 * sizeof (Elf_Internal_Sym)));
2720 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2723 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2724 * sizeof (asection *));
2725 if (sections == NULL && symtab_hdr->sh_info > 0)
2728 isymp = internal_syms;
2730 esym = external_syms;
2731 esymend = esym + symtab_hdr->sh_info;
2732 for (; esym < esymend; ++esym, ++isymp, ++secpp)
2736 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2738 if (isymp->st_shndx == SHN_UNDEF)
2739 isec = bfd_und_section_ptr;
2740 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2741 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2742 else if (isymp->st_shndx == SHN_ABS)
2743 isec = bfd_abs_section_ptr;
2744 else if (isymp->st_shndx == SHN_COMMON)
2745 isec = bfd_com_section_ptr;
2755 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2756 input_section, data, internal_relocs,
2757 internal_syms, sections))
2760 if (sections != NULL)
2763 if (internal_syms != NULL)
2764 free (internal_syms);
2765 internal_syms = NULL;
2766 if (external_syms != NULL && symtab_hdr->contents == NULL)
2767 free (external_syms);
2768 external_syms = NULL;
2769 if (internal_relocs != elf_section_data (input_section)->relocs)
2770 free (internal_relocs);
2771 internal_relocs = NULL;
2777 if (internal_relocs != NULL
2778 && internal_relocs != elf_section_data (input_section)->relocs)
2779 free (internal_relocs);
2780 if (external_syms != NULL && symtab_hdr->contents == NULL)
2781 free (external_syms);
2782 if (internal_syms != NULL)
2783 free (internal_syms);
2784 if (sections != NULL)
2789 /* Assorted hash table functions. */
2791 /* Initialize an entry in the link hash table. */
2793 /* Create an entry in an MN10300 ELF linker hash table. */
2795 static struct bfd_hash_entry *
2796 elf32_mn10300_link_hash_newfunc (entry, table, string)
2797 struct bfd_hash_entry *entry;
2798 struct bfd_hash_table *table;
2801 struct elf32_mn10300_link_hash_entry *ret =
2802 (struct elf32_mn10300_link_hash_entry *) entry;
2804 /* Allocate the structure if it has not already been allocated by a
2806 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2807 ret = ((struct elf32_mn10300_link_hash_entry *)
2808 bfd_hash_allocate (table,
2809 sizeof (struct elf32_mn10300_link_hash_entry)));
2810 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2811 return (struct bfd_hash_entry *) ret;
2813 /* Call the allocation method of the superclass. */
2814 ret = ((struct elf32_mn10300_link_hash_entry *)
2815 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2817 if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2819 ret->direct_calls = 0;
2820 ret->stack_size = 0;
2821 ret->movm_stack_size = 0;
2826 return (struct bfd_hash_entry *) ret;
2829 /* Create an mn10300 ELF linker hash table. */
2831 static struct bfd_link_hash_table *
2832 elf32_mn10300_link_hash_table_create (abfd)
2835 struct elf32_mn10300_link_hash_table *ret;
2837 ret = ((struct elf32_mn10300_link_hash_table *)
2838 bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2839 if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2842 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2843 elf32_mn10300_link_hash_newfunc))
2845 bfd_release (abfd, ret);
2850 ret->static_hash_table
2851 = ((struct elf32_mn10300_link_hash_table *)
2852 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2853 if (ret->static_hash_table == NULL)
2855 bfd_release (abfd, ret);
2859 if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2860 elf32_mn10300_link_hash_newfunc))
2862 bfd_release (abfd, ret->static_hash_table);
2863 bfd_release (abfd, ret);
2866 return &ret->root.root;
2870 elf_mn10300_mach (flags)
2873 switch (flags & EF_MN10300_MACH)
2875 case E_MN10300_MACH_MN10300:
2877 return bfd_mach_mn10300;
2879 case E_MN10300_MACH_AM33:
2880 return bfd_mach_am33;
2884 /* The final processing done just before writing out a MN10300 ELF object
2885 file. This gets the MN10300 architecture right based on the machine
2889 _bfd_mn10300_elf_final_write_processing (abfd, linker)
2891 boolean linker ATTRIBUTE_UNUSED;
2895 switch (bfd_get_mach (abfd))
2898 case bfd_mach_mn10300:
2899 val = E_MN10300_MACH_MN10300;
2903 val = E_MN10300_MACH_AM33;
2907 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2908 elf_elfheader (abfd)->e_flags |= val;
2912 _bfd_mn10300_elf_object_p (abfd)
2915 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2916 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2920 /* Merge backend specific data from an object file to the output
2921 object file when linking. */
2924 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2928 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2929 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2932 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2933 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2935 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2936 bfd_get_mach (ibfd)))
2943 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
2944 #define TARGET_LITTLE_NAME "elf32-mn10300"
2945 #define ELF_ARCH bfd_arch_mn10300
2946 #define ELF_MACHINE_CODE EM_CYGNUS_MN10300
2947 #define ELF_MAXPAGESIZE 0x1000
2949 #define elf_info_to_howto mn10300_info_to_howto
2950 #define elf_info_to_howto_rel 0
2951 #define elf_backend_can_gc_sections 1
2952 #define elf_backend_check_relocs mn10300_elf_check_relocs
2953 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
2954 #define elf_backend_relocate_section mn10300_elf_relocate_section
2955 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
2956 #define bfd_elf32_bfd_get_relocated_section_contents \
2957 mn10300_elf_get_relocated_section_contents
2958 #define bfd_elf32_bfd_link_hash_table_create \
2959 elf32_mn10300_link_hash_table_create
2961 #define elf_symbol_leading_char '_'
2963 /* So we can set bits in e_flags. */
2964 #define elf_backend_final_write_processing \
2965 _bfd_mn10300_elf_final_write_processing
2966 #define elf_backend_object_p _bfd_mn10300_elf_object_p
2968 #define bfd_elf32_bfd_merge_private_bfd_data \
2969 _bfd_mn10300_elf_merge_private_bfd_data
2971 #include "elf32-target.h"