1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
26 #include "elf/mn10300.h"
27 #include "libiberty.h"
29 /* The mn10300 linker needs to keep track of the number of relocs that
30 it decides to copy in check_relocs for each symbol. This is so
31 that it can discard PC relative relocs if it doesn't need them when
32 linking with -Bsymbolic. We store the information in a field
33 extending the regular ELF linker hash table. */
35 struct elf32_mn10300_link_hash_entry
37 /* The basic elf link hash table entry. */
38 struct elf_link_hash_entry root;
40 /* For function symbols, the number of times this function is
41 called directly (ie by name). */
42 unsigned int direct_calls;
44 /* For function symbols, the size of this function's stack
45 (if <= 255 bytes). We stuff this into "call" instructions
46 to this target when it's valid and profitable to do so.
48 This does not include stack allocated by movm! */
49 unsigned char stack_size;
51 /* For function symbols, arguments (if any) for movm instruction
52 in the prologue. We stuff this value into "call" instructions
53 to the target when it's valid and profitable to do so. */
54 unsigned char movm_args;
56 /* For function symbols, the amount of stack space that would be allocated
57 by the movm instruction. This is redundant with movm_args, but we
58 add it to the hash table to avoid computing it over and over. */
59 unsigned char movm_stack_size;
61 /* When set, convert all "call" instructions to this target into "calls"
63 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
65 /* Used to mark functions which have had redundant parts of their
67 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
70 /* Calculated value. */
74 /* We derive a hash table from the main elf linker hash table so
75 we can store state variables and a secondary hash table without
76 resorting to global variables. */
77 struct elf32_mn10300_link_hash_table
79 /* The main hash table. */
80 struct elf_link_hash_table root;
82 /* A hash table for static functions. We could derive a new hash table
83 instead of using the full elf32_mn10300_link_hash_table if we wanted
84 to save some memory. */
85 struct elf32_mn10300_link_hash_table *static_hash_table;
87 /* Random linker state flags. */
88 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
93 #define streq(a, b) (strcmp ((a),(b)) == 0)
96 /* For MN10300 linker hash table. */
98 /* Get the MN10300 ELF linker hash table from a link_info structure. */
100 #define elf32_mn10300_hash_table(p) \
101 ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
103 #define elf32_mn10300_link_hash_traverse(table, func, info) \
104 (elf_link_hash_traverse \
106 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
109 static reloc_howto_type elf_mn10300_howto_table[] =
111 /* Dummy relocation. Does nothing. */
112 HOWTO (R_MN10300_NONE,
118 complain_overflow_bitfield,
119 bfd_elf_generic_reloc,
125 /* Standard 32 bit reloc. */
132 complain_overflow_bitfield,
133 bfd_elf_generic_reloc,
139 /* Standard 16 bit reloc. */
146 complain_overflow_bitfield,
147 bfd_elf_generic_reloc,
153 /* Standard 8 bit reloc. */
160 complain_overflow_bitfield,
161 bfd_elf_generic_reloc,
167 /* Standard 32bit pc-relative reloc. */
168 HOWTO (R_MN10300_PCREL32,
174 complain_overflow_bitfield,
175 bfd_elf_generic_reloc,
181 /* Standard 16bit pc-relative reloc. */
182 HOWTO (R_MN10300_PCREL16,
188 complain_overflow_bitfield,
189 bfd_elf_generic_reloc,
195 /* Standard 8 pc-relative reloc. */
196 HOWTO (R_MN10300_PCREL8,
202 complain_overflow_bitfield,
203 bfd_elf_generic_reloc,
210 /* GNU extension to record C++ vtable hierarchy. */
211 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
213 0, /* size (0 = byte, 1 = short, 2 = long) */
215 FALSE, /* pc_relative */
217 complain_overflow_dont, /* complain_on_overflow */
218 NULL, /* special_function */
219 "R_MN10300_GNU_VTINHERIT", /* name */
220 FALSE, /* partial_inplace */
223 FALSE), /* pcrel_offset */
225 /* GNU extension to record C++ vtable member usage */
226 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
228 0, /* size (0 = byte, 1 = short, 2 = long) */
230 FALSE, /* pc_relative */
232 complain_overflow_dont, /* complain_on_overflow */
233 NULL, /* special_function */
234 "R_MN10300_GNU_VTENTRY", /* name */
235 FALSE, /* partial_inplace */
238 FALSE), /* pcrel_offset */
240 /* Standard 24 bit reloc. */
247 complain_overflow_bitfield,
248 bfd_elf_generic_reloc,
254 HOWTO (R_MN10300_GOTPC32, /* type */
256 2, /* size (0 = byte, 1 = short, 2 = long) */
258 TRUE, /* pc_relative */
260 complain_overflow_bitfield, /* complain_on_overflow */
261 bfd_elf_generic_reloc, /* */
262 "R_MN10300_GOTPC32", /* name */
263 FALSE, /* partial_inplace */
264 0xffffffff, /* src_mask */
265 0xffffffff, /* dst_mask */
266 TRUE), /* pcrel_offset */
268 HOWTO (R_MN10300_GOTPC16, /* type */
270 1, /* size (0 = byte, 1 = short, 2 = long) */
272 TRUE, /* pc_relative */
274 complain_overflow_bitfield, /* complain_on_overflow */
275 bfd_elf_generic_reloc, /* */
276 "R_MN10300_GOTPC16", /* name */
277 FALSE, /* partial_inplace */
278 0xffff, /* src_mask */
279 0xffff, /* dst_mask */
280 TRUE), /* pcrel_offset */
282 HOWTO (R_MN10300_GOTOFF32, /* type */
284 2, /* size (0 = byte, 1 = short, 2 = long) */
286 FALSE, /* pc_relative */
288 complain_overflow_bitfield, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* */
290 "R_MN10300_GOTOFF32", /* name */
291 FALSE, /* partial_inplace */
292 0xffffffff, /* src_mask */
293 0xffffffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
296 HOWTO (R_MN10300_GOTOFF24, /* type */
298 2, /* size (0 = byte, 1 = short, 2 = long) */
300 FALSE, /* pc_relative */
302 complain_overflow_bitfield, /* complain_on_overflow */
303 bfd_elf_generic_reloc, /* */
304 "R_MN10300_GOTOFF24", /* name */
305 FALSE, /* partial_inplace */
306 0xffffff, /* src_mask */
307 0xffffff, /* dst_mask */
308 FALSE), /* pcrel_offset */
310 HOWTO (R_MN10300_GOTOFF16, /* type */
312 1, /* size (0 = byte, 1 = short, 2 = long) */
314 FALSE, /* pc_relative */
316 complain_overflow_bitfield, /* complain_on_overflow */
317 bfd_elf_generic_reloc, /* */
318 "R_MN10300_GOTOFF16", /* name */
319 FALSE, /* partial_inplace */
320 0xffff, /* src_mask */
321 0xffff, /* dst_mask */
322 FALSE), /* pcrel_offset */
324 HOWTO (R_MN10300_PLT32, /* type */
326 2, /* size (0 = byte, 1 = short, 2 = long) */
328 TRUE, /* pc_relative */
330 complain_overflow_bitfield, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* */
332 "R_MN10300_PLT32", /* name */
333 FALSE, /* partial_inplace */
334 0xffffffff, /* src_mask */
335 0xffffffff, /* dst_mask */
336 TRUE), /* pcrel_offset */
338 HOWTO (R_MN10300_PLT16, /* type */
340 1, /* size (0 = byte, 1 = short, 2 = long) */
342 TRUE, /* pc_relative */
344 complain_overflow_bitfield, /* complain_on_overflow */
345 bfd_elf_generic_reloc, /* */
346 "R_MN10300_PLT16", /* name */
347 FALSE, /* partial_inplace */
348 0xffff, /* src_mask */
349 0xffff, /* dst_mask */
350 TRUE), /* pcrel_offset */
352 HOWTO (R_MN10300_GOT32, /* type */
354 2, /* size (0 = byte, 1 = short, 2 = long) */
356 FALSE, /* pc_relative */
358 complain_overflow_bitfield, /* complain_on_overflow */
359 bfd_elf_generic_reloc, /* */
360 "R_MN10300_GOT32", /* name */
361 FALSE, /* partial_inplace */
362 0xffffffff, /* src_mask */
363 0xffffffff, /* dst_mask */
364 FALSE), /* pcrel_offset */
366 HOWTO (R_MN10300_GOT24, /* type */
368 2, /* size (0 = byte, 1 = short, 2 = long) */
370 FALSE, /* pc_relative */
372 complain_overflow_bitfield, /* complain_on_overflow */
373 bfd_elf_generic_reloc, /* */
374 "R_MN10300_GOT24", /* name */
375 FALSE, /* partial_inplace */
376 0xffffffff, /* src_mask */
377 0xffffffff, /* dst_mask */
378 FALSE), /* pcrel_offset */
380 HOWTO (R_MN10300_GOT16, /* type */
382 1, /* size (0 = byte, 1 = short, 2 = long) */
384 FALSE, /* pc_relative */
386 complain_overflow_bitfield, /* complain_on_overflow */
387 bfd_elf_generic_reloc, /* */
388 "R_MN10300_GOT16", /* name */
389 FALSE, /* partial_inplace */
390 0xffffffff, /* src_mask */
391 0xffffffff, /* dst_mask */
392 FALSE), /* pcrel_offset */
394 HOWTO (R_MN10300_COPY, /* type */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
398 FALSE, /* pc_relative */
400 complain_overflow_bitfield, /* complain_on_overflow */
401 bfd_elf_generic_reloc, /* */
402 "R_MN10300_COPY", /* name */
403 FALSE, /* partial_inplace */
404 0xffffffff, /* src_mask */
405 0xffffffff, /* dst_mask */
406 FALSE), /* pcrel_offset */
408 HOWTO (R_MN10300_GLOB_DAT, /* type */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
412 FALSE, /* pc_relative */
414 complain_overflow_bitfield, /* complain_on_overflow */
415 bfd_elf_generic_reloc, /* */
416 "R_MN10300_GLOB_DAT", /* name */
417 FALSE, /* partial_inplace */
418 0xffffffff, /* src_mask */
419 0xffffffff, /* dst_mask */
420 FALSE), /* pcrel_offset */
422 HOWTO (R_MN10300_JMP_SLOT, /* type */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
426 FALSE, /* pc_relative */
428 complain_overflow_bitfield, /* complain_on_overflow */
429 bfd_elf_generic_reloc, /* */
430 "R_MN10300_JMP_SLOT", /* name */
431 FALSE, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
436 HOWTO (R_MN10300_RELATIVE, /* type */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
440 FALSE, /* pc_relative */
442 complain_overflow_bitfield, /* complain_on_overflow */
443 bfd_elf_generic_reloc, /* */
444 "R_MN10300_RELATIVE", /* name */
445 FALSE, /* partial_inplace */
446 0xffffffff, /* src_mask */
447 0xffffffff, /* dst_mask */
448 FALSE), /* pcrel_offset */
460 HOWTO (R_MN10300_SYM_DIFF, /* type */
462 2, /* size (0 = byte, 1 = short, 2 = long) */
464 FALSE, /* pc_relative */
466 complain_overflow_dont,/* complain_on_overflow */
467 NULL, /* special handler. */
468 "R_MN10300_SYM_DIFF", /* name */
469 FALSE, /* partial_inplace */
470 0xffffffff, /* src_mask */
471 0xffffffff, /* dst_mask */
472 FALSE) /* pcrel_offset */
475 struct mn10300_reloc_map
477 bfd_reloc_code_real_type bfd_reloc_val;
478 unsigned char elf_reloc_val;
481 static const struct mn10300_reloc_map mn10300_reloc_map[] =
483 { BFD_RELOC_NONE, R_MN10300_NONE, },
484 { BFD_RELOC_32, R_MN10300_32, },
485 { BFD_RELOC_16, R_MN10300_16, },
486 { BFD_RELOC_8, R_MN10300_8, },
487 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
488 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
489 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
490 { BFD_RELOC_24, R_MN10300_24, },
491 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
492 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
493 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
494 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
495 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
496 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
497 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
498 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
499 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
500 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
501 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
502 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
503 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
504 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
505 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
506 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
507 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF }
510 /* Create the GOT section. */
513 _bfd_mn10300_elf_create_got_section (bfd * abfd,
514 struct bfd_link_info * info)
519 struct elf_link_hash_entry * h;
520 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
523 /* This function may be called more than once. */
524 if (bfd_get_section_by_name (abfd, ".got") != NULL)
527 switch (bed->s->arch_size)
538 bfd_set_error (bfd_error_bad_value);
542 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
543 | SEC_LINKER_CREATED);
546 pltflags |= SEC_CODE;
547 if (bed->plt_not_loaded)
548 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
549 if (bed->plt_readonly)
550 pltflags |= SEC_READONLY;
552 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
554 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
557 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
559 if (bed->want_plt_sym)
561 h = _bfd_elf_define_linkage_sym (abfd, info, s,
562 "_PROCEDURE_LINKAGE_TABLE_");
563 elf_hash_table (info)->hplt = h;
568 s = bfd_make_section_with_flags (abfd, ".got", flags);
570 || ! bfd_set_section_alignment (abfd, s, ptralign))
573 if (bed->want_got_plt)
575 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
577 || ! bfd_set_section_alignment (abfd, s, ptralign))
581 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
582 (or .got.plt) section. We don't do this in the linker script
583 because we don't want to define the symbol if we are not creating
584 a global offset table. */
585 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
586 elf_hash_table (info)->hgot = h;
590 /* The first bit of the global offset table is the header. */
591 s->size += bed->got_header_size;
596 static reloc_howto_type *
597 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
598 bfd_reloc_code_real_type code)
602 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
603 if (mn10300_reloc_map[i].bfd_reloc_val == code)
604 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
609 static reloc_howto_type *
610 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
615 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
616 if (elf_mn10300_howto_table[i].name != NULL
617 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
618 return elf_mn10300_howto_table + i;
623 /* Set the howto pointer for an MN10300 ELF reloc. */
626 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
628 Elf_Internal_Rela *dst)
632 r_type = ELF32_R_TYPE (dst->r_info);
633 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
634 cache_ptr->howto = elf_mn10300_howto_table + r_type;
637 /* Look through the relocs for a section during the first phase.
638 Since we don't do .gots or .plts, we just need to consider the
639 virtual table relocs for gc. */
642 mn10300_elf_check_relocs (bfd *abfd,
643 struct bfd_link_info *info,
645 const Elf_Internal_Rela *relocs)
647 bfd_boolean sym_diff_reloc_seen;
648 Elf_Internal_Shdr *symtab_hdr;
649 struct elf_link_hash_entry **sym_hashes;
650 const Elf_Internal_Rela *rel;
651 const Elf_Internal_Rela *rel_end;
653 bfd_vma * local_got_offsets;
662 if (info->relocatable)
665 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
666 sym_hashes = elf_sym_hashes (abfd);
668 dynobj = elf_hash_table (info)->dynobj;
669 local_got_offsets = elf_local_got_offsets (abfd);
670 rel_end = relocs + sec->reloc_count;
671 sym_diff_reloc_seen = FALSE;
673 for (rel = relocs; rel < rel_end; rel++)
675 struct elf_link_hash_entry *h;
676 unsigned long r_symndx;
678 r_symndx = ELF32_R_SYM (rel->r_info);
679 if (r_symndx < symtab_hdr->sh_info)
683 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
684 while (h->root.type == bfd_link_hash_indirect
685 || h->root.type == bfd_link_hash_warning)
686 h = (struct elf_link_hash_entry *) h->root.u.i.link;
689 /* Some relocs require a global offset table. */
692 switch (ELF32_R_TYPE (rel->r_info))
694 case R_MN10300_GOT32:
695 case R_MN10300_GOT24:
696 case R_MN10300_GOT16:
697 case R_MN10300_GOTOFF32:
698 case R_MN10300_GOTOFF24:
699 case R_MN10300_GOTOFF16:
700 case R_MN10300_GOTPC32:
701 case R_MN10300_GOTPC16:
702 elf_hash_table (info)->dynobj = dynobj = abfd;
703 if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
712 switch (ELF32_R_TYPE (rel->r_info))
714 /* This relocation describes the C++ object vtable hierarchy.
715 Reconstruct it for later use during GC. */
716 case R_MN10300_GNU_VTINHERIT:
717 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
721 /* This relocation describes which C++ vtable entries are actually
722 used. Record for later use during GC. */
723 case R_MN10300_GNU_VTENTRY:
724 BFD_ASSERT (h != NULL);
726 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
729 case R_MN10300_GOT32:
730 case R_MN10300_GOT24:
731 case R_MN10300_GOT16:
732 /* This symbol requires a global offset table entry. */
736 sgot = bfd_get_section_by_name (dynobj, ".got");
737 BFD_ASSERT (sgot != NULL);
741 && (h != NULL || info->shared))
743 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
746 srelgot = bfd_make_section_with_flags (dynobj,
755 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
762 if (h->got.offset != (bfd_vma) -1)
763 /* We have already allocated space in the .got. */
766 h->got.offset = sgot->size;
768 /* Make sure this symbol is output as a dynamic symbol. */
769 if (h->dynindx == -1)
771 if (! bfd_elf_link_record_dynamic_symbol (info, h))
775 srelgot->size += sizeof (Elf32_External_Rela);
779 /* This is a global offset table entry for a local
781 if (local_got_offsets == NULL)
786 size = symtab_hdr->sh_info * sizeof (bfd_vma);
787 local_got_offsets = bfd_alloc (abfd, size);
789 if (local_got_offsets == NULL)
791 elf_local_got_offsets (abfd) = local_got_offsets;
793 for (i = 0; i < symtab_hdr->sh_info; i++)
794 local_got_offsets[i] = (bfd_vma) -1;
797 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
798 /* We have already allocated space in the .got. */
801 local_got_offsets[r_symndx] = sgot->size;
804 /* If we are generating a shared object, we need to
805 output a R_MN10300_RELATIVE reloc so that the dynamic
806 linker can adjust this GOT entry. */
807 srelgot->size += sizeof (Elf32_External_Rela);
813 case R_MN10300_PLT32:
814 case R_MN10300_PLT16:
815 /* This symbol requires a procedure linkage table entry. We
816 actually build the entry in adjust_dynamic_symbol,
817 because this might be a case of linking PIC code which is
818 never referenced by a dynamic object, in which case we
819 don't need to generate a procedure linkage table entry
822 /* If this is a local symbol, we resolve it directly without
823 creating a procedure linkage table entry. */
827 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
828 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
837 case R_MN10300_PCREL32:
838 case R_MN10300_PCREL16:
839 case R_MN10300_PCREL8:
844 case R_MN10300_SYM_DIFF:
845 sym_diff_reloc_seen = TRUE;
852 /* If we are creating a shared library, then we
853 need to copy the reloc into the shared library. */
855 && (sec->flags & SEC_ALLOC) != 0
856 /* Do not generate a dynamic reloc for a
857 reloc associated with a SYM_DIFF operation. */
858 && ! sym_diff_reloc_seen)
860 asection * sym_section = NULL;
862 /* Find the section containing the
863 symbol involved in the relocation. */
866 Elf_Internal_Sym * isymbuf;
867 Elf_Internal_Sym * isym;
869 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
871 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
872 symtab_hdr->sh_info, 0,
876 isym = isymbuf + r_symndx;
877 /* All we care about is whether this local symbol is absolute. */
878 if (isym->st_shndx == SHN_ABS)
879 sym_section = bfd_abs_section_ptr;
884 if (h->root.type == bfd_link_hash_defined
885 || h->root.type == bfd_link_hash_defweak)
886 sym_section = h->root.u.def.section;
889 /* If the symbol is absolute then the relocation can
890 be resolved during linking and there is no need for
892 if (sym_section != bfd_abs_section_ptr)
894 /* When creating a shared object, we must copy these
895 reloc types into the output file. We create a reloc
896 section in dynobj and make room for this reloc. */
901 name = (bfd_elf_string_from_elf_section
903 elf_elfheader (abfd)->e_shstrndx,
904 elf_section_data (sec)->rel_hdr.sh_name));
908 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
909 && streq (bfd_get_section_name (abfd, sec), name + 5));
911 sreloc = bfd_get_section_by_name (dynobj, name);
916 flags = (SEC_HAS_CONTENTS | SEC_READONLY
917 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
918 if ((sec->flags & SEC_ALLOC) != 0)
919 flags |= SEC_ALLOC | SEC_LOAD;
920 sreloc = bfd_make_section_with_flags (dynobj, name, flags);
922 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
927 sreloc->size += sizeof (Elf32_External_Rela);
934 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
935 sym_diff_reloc_seen = FALSE;
941 /* Return the section that should be marked against GC for a given
945 mn10300_elf_gc_mark_hook (asection *sec,
946 struct bfd_link_info *info,
947 Elf_Internal_Rela *rel,
948 struct elf_link_hash_entry *h,
949 Elf_Internal_Sym *sym)
952 switch (ELF32_R_TYPE (rel->r_info))
954 case R_MN10300_GNU_VTINHERIT:
955 case R_MN10300_GNU_VTENTRY:
959 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
962 /* Perform a relocation as part of a final link. */
964 static bfd_reloc_status_type
965 mn10300_elf_final_link_relocate (reloc_howto_type *howto,
967 bfd *output_bfd ATTRIBUTE_UNUSED,
968 asection *input_section,
973 struct elf_link_hash_entry * h,
974 unsigned long symndx,
975 struct bfd_link_info *info,
976 asection *sym_sec ATTRIBUTE_UNUSED,
977 int is_local ATTRIBUTE_UNUSED)
979 static asection * sym_diff_section;
980 static bfd_vma sym_diff_value;
981 bfd_boolean is_sym_diff_reloc;
982 unsigned long r_type = howto->type;
983 bfd_byte * hit_data = contents + offset;
985 bfd_vma * local_got_offsets;
990 dynobj = elf_hash_table (info)->dynobj;
991 local_got_offsets = elf_local_got_offsets (input_bfd);
1002 case R_MN10300_PCREL8:
1003 case R_MN10300_PCREL16:
1004 case R_MN10300_PCREL32:
1005 case R_MN10300_GOTOFF32:
1006 case R_MN10300_GOTOFF24:
1007 case R_MN10300_GOTOFF16:
1009 && (input_section->flags & SEC_ALLOC) != 0
1011 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1012 return bfd_reloc_dangerous;
1015 is_sym_diff_reloc = FALSE;
1016 if (sym_diff_section != NULL)
1018 BFD_ASSERT (sym_diff_section == input_section);
1026 value -= sym_diff_value;
1027 sym_diff_section = NULL;
1028 is_sym_diff_reloc = TRUE;
1032 sym_diff_section = NULL;
1039 case R_MN10300_SYM_DIFF:
1040 BFD_ASSERT (addend == 0);
1041 /* Cache the input section and value.
1042 The offset is unreliable, since relaxation may
1043 have reduced the following reloc's offset. */
1044 sym_diff_section = input_section;
1045 sym_diff_value = value;
1046 return bfd_reloc_ok;
1048 case R_MN10300_NONE:
1049 return bfd_reloc_ok;
1053 /* Do not generate relocs when an R_MN10300_32 has been used
1054 with an R_MN10300_SYM_DIFF to compute a difference of two
1056 && is_sym_diff_reloc == FALSE
1057 /* Also, do not generate a reloc when the symbol associated
1058 with the R_MN10300_32 reloc is absolute - there is no
1059 need for a run time computation in this case. */
1060 && sym_sec != bfd_abs_section_ptr
1061 /* If the section is not going to be allocated at load time
1062 then there is no need to generate relocs for it. */
1063 && (input_section->flags & SEC_ALLOC) != 0)
1065 Elf_Internal_Rela outrel;
1066 bfd_boolean skip, relocate;
1068 /* When generating a shared object, these relocations are
1069 copied into the output file to be resolved at run
1075 name = (bfd_elf_string_from_elf_section
1077 elf_elfheader (input_bfd)->e_shstrndx,
1078 elf_section_data (input_section)->rel_hdr.sh_name));
1082 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1083 && streq (bfd_get_section_name (input_bfd,
1087 sreloc = bfd_get_section_by_name (dynobj, name);
1088 BFD_ASSERT (sreloc != NULL);
1093 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1094 input_section, offset);
1095 if (outrel.r_offset == (bfd_vma) -1)
1098 outrel.r_offset += (input_section->output_section->vma
1099 + input_section->output_offset);
1103 memset (&outrel, 0, sizeof outrel);
1108 /* h->dynindx may be -1 if this symbol was marked to
1111 || SYMBOL_REFERENCES_LOCAL (info, h))
1114 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1115 outrel.r_addend = value + addend;
1119 BFD_ASSERT (h->dynindx != -1);
1121 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1122 outrel.r_addend = value + addend;
1126 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1127 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1128 + sreloc->reloc_count));
1129 ++sreloc->reloc_count;
1131 /* If this reloc is against an external symbol, we do
1132 not want to fiddle with the addend. Otherwise, we
1133 need to include the symbol value so that it becomes
1134 an addend for the dynamic reloc. */
1136 return bfd_reloc_ok;
1139 bfd_put_32 (input_bfd, value, hit_data);
1140 return bfd_reloc_ok;
1145 if ((long) value > 0x7fffff || (long) value < -0x800000)
1146 return bfd_reloc_overflow;
1148 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1149 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1150 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1151 return bfd_reloc_ok;
1156 if ((long) value > 0x7fff || (long) value < -0x8000)
1157 return bfd_reloc_overflow;
1159 bfd_put_16 (input_bfd, value, hit_data);
1160 return bfd_reloc_ok;
1165 if ((long) value > 0x7f || (long) value < -0x80)
1166 return bfd_reloc_overflow;
1168 bfd_put_8 (input_bfd, value, hit_data);
1169 return bfd_reloc_ok;
1171 case R_MN10300_PCREL8:
1172 value -= (input_section->output_section->vma
1173 + input_section->output_offset);
1177 if ((long) value > 0xff || (long) value < -0x100)
1178 return bfd_reloc_overflow;
1180 bfd_put_8 (input_bfd, value, hit_data);
1181 return bfd_reloc_ok;
1183 case R_MN10300_PCREL16:
1184 value -= (input_section->output_section->vma
1185 + input_section->output_offset);
1189 if ((long) value > 0xffff || (long) value < -0x10000)
1190 return bfd_reloc_overflow;
1192 bfd_put_16 (input_bfd, value, hit_data);
1193 return bfd_reloc_ok;
1195 case R_MN10300_PCREL32:
1196 value -= (input_section->output_section->vma
1197 + input_section->output_offset);
1201 bfd_put_32 (input_bfd, value, hit_data);
1202 return bfd_reloc_ok;
1204 case R_MN10300_GNU_VTINHERIT:
1205 case R_MN10300_GNU_VTENTRY:
1206 return bfd_reloc_ok;
1208 case R_MN10300_GOTPC32:
1209 /* Use global offset table as symbol value. */
1210 value = bfd_get_section_by_name (dynobj,
1211 ".got")->output_section->vma;
1212 value -= (input_section->output_section->vma
1213 + input_section->output_offset);
1217 bfd_put_32 (input_bfd, value, hit_data);
1218 return bfd_reloc_ok;
1220 case R_MN10300_GOTPC16:
1221 /* Use global offset table as symbol value. */
1222 value = bfd_get_section_by_name (dynobj,
1223 ".got")->output_section->vma;
1224 value -= (input_section->output_section->vma
1225 + input_section->output_offset);
1229 if ((long) value > 0xffff || (long) value < -0x10000)
1230 return bfd_reloc_overflow;
1232 bfd_put_16 (input_bfd, value, hit_data);
1233 return bfd_reloc_ok;
1235 case R_MN10300_GOTOFF32:
1236 value -= bfd_get_section_by_name (dynobj,
1237 ".got")->output_section->vma;
1240 bfd_put_32 (input_bfd, value, hit_data);
1241 return bfd_reloc_ok;
1243 case R_MN10300_GOTOFF24:
1244 value -= bfd_get_section_by_name (dynobj,
1245 ".got")->output_section->vma;
1248 if ((long) value > 0x7fffff || (long) value < -0x800000)
1249 return bfd_reloc_overflow;
1251 bfd_put_8 (input_bfd, value, hit_data);
1252 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1253 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1254 return bfd_reloc_ok;
1256 case R_MN10300_GOTOFF16:
1257 value -= bfd_get_section_by_name (dynobj,
1258 ".got")->output_section->vma;
1261 if ((long) value > 0xffff || (long) value < -0x10000)
1262 return bfd_reloc_overflow;
1264 bfd_put_16 (input_bfd, value, hit_data);
1265 return bfd_reloc_ok;
1267 case R_MN10300_PLT32:
1269 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1270 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1271 && h->plt.offset != (bfd_vma) -1)
1275 splt = bfd_get_section_by_name (dynobj, ".plt");
1277 value = (splt->output_section->vma
1278 + splt->output_offset
1279 + h->plt.offset) - value;
1282 value -= (input_section->output_section->vma
1283 + input_section->output_offset);
1287 bfd_put_32 (input_bfd, value, hit_data);
1288 return bfd_reloc_ok;
1290 case R_MN10300_PLT16:
1292 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1293 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1294 && h->plt.offset != (bfd_vma) -1)
1298 splt = bfd_get_section_by_name (dynobj, ".plt");
1300 value = (splt->output_section->vma
1301 + splt->output_offset
1302 + h->plt.offset) - value;
1305 value -= (input_section->output_section->vma
1306 + input_section->output_offset);
1310 if ((long) value > 0xffff || (long) value < -0x10000)
1311 return bfd_reloc_overflow;
1313 bfd_put_16 (input_bfd, value, hit_data);
1314 return bfd_reloc_ok;
1316 case R_MN10300_GOT32:
1317 case R_MN10300_GOT24:
1318 case R_MN10300_GOT16:
1322 sgot = bfd_get_section_by_name (dynobj, ".got");
1328 off = h->got.offset;
1329 BFD_ASSERT (off != (bfd_vma) -1);
1331 if (! elf_hash_table (info)->dynamic_sections_created
1332 || SYMBOL_REFERENCES_LOCAL (info, h))
1333 /* This is actually a static link, or it is a
1334 -Bsymbolic link and the symbol is defined
1335 locally, or the symbol was forced to be local
1336 because of a version file. We must initialize
1337 this entry in the global offset table.
1339 When doing a dynamic link, we create a .rela.got
1340 relocation entry to initialize the value. This
1341 is done in the finish_dynamic_symbol routine. */
1342 bfd_put_32 (output_bfd, value,
1343 sgot->contents + off);
1345 value = sgot->output_offset + off;
1351 off = elf_local_got_offsets (input_bfd)[symndx];
1353 bfd_put_32 (output_bfd, value, sgot->contents + off);
1358 Elf_Internal_Rela outrel;
1360 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1361 BFD_ASSERT (srelgot != NULL);
1363 outrel.r_offset = (sgot->output_section->vma
1364 + sgot->output_offset
1366 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1367 outrel.r_addend = value;
1368 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1369 (bfd_byte *) (((Elf32_External_Rela *)
1371 + srelgot->reloc_count));
1372 ++ srelgot->reloc_count;
1375 value = sgot->output_offset + off;
1381 if (r_type == R_MN10300_GOT32)
1383 bfd_put_32 (input_bfd, value, hit_data);
1384 return bfd_reloc_ok;
1386 else if (r_type == R_MN10300_GOT24)
1388 if ((long) value > 0x7fffff || (long) value < -0x800000)
1389 return bfd_reloc_overflow;
1391 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1392 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1393 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1394 return bfd_reloc_ok;
1396 else if (r_type == R_MN10300_GOT16)
1398 if ((long) value > 0xffff || (long) value < -0x10000)
1399 return bfd_reloc_overflow;
1401 bfd_put_16 (input_bfd, value, hit_data);
1402 return bfd_reloc_ok;
1407 return bfd_reloc_notsupported;
1411 /* Relocate an MN10300 ELF section. */
1414 mn10300_elf_relocate_section (bfd *output_bfd,
1415 struct bfd_link_info *info,
1417 asection *input_section,
1419 Elf_Internal_Rela *relocs,
1420 Elf_Internal_Sym *local_syms,
1421 asection **local_sections)
1423 Elf_Internal_Shdr *symtab_hdr;
1424 struct elf_link_hash_entry **sym_hashes;
1425 Elf_Internal_Rela *rel, *relend;
1427 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1428 sym_hashes = elf_sym_hashes (input_bfd);
1431 relend = relocs + input_section->reloc_count;
1432 for (; rel < relend; rel++)
1435 reloc_howto_type *howto;
1436 unsigned long r_symndx;
1437 Elf_Internal_Sym *sym;
1439 struct elf32_mn10300_link_hash_entry *h;
1441 bfd_reloc_status_type r;
1443 r_symndx = ELF32_R_SYM (rel->r_info);
1444 r_type = ELF32_R_TYPE (rel->r_info);
1445 howto = elf_mn10300_howto_table + r_type;
1447 /* Just skip the vtable gc relocs. */
1448 if (r_type == R_MN10300_GNU_VTINHERIT
1449 || r_type == R_MN10300_GNU_VTENTRY)
1455 if (r_symndx < symtab_hdr->sh_info)
1457 sym = local_syms + r_symndx;
1458 sec = local_sections[r_symndx];
1459 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1463 bfd_boolean unresolved_reloc;
1465 struct elf_link_hash_entry *hh;
1467 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1468 r_symndx, symtab_hdr, sym_hashes,
1469 hh, sec, relocation,
1470 unresolved_reloc, warned);
1472 h = (struct elf32_mn10300_link_hash_entry *) hh;
1474 if ((h->root.root.type == bfd_link_hash_defined
1475 || h->root.root.type == bfd_link_hash_defweak)
1476 && ( r_type == R_MN10300_GOTPC32
1477 || r_type == R_MN10300_GOTPC16
1478 || (( r_type == R_MN10300_PLT32
1479 || r_type == R_MN10300_PLT16)
1480 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1481 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1482 && h->root.plt.offset != (bfd_vma) -1)
1483 || (( r_type == R_MN10300_GOT32
1484 || r_type == R_MN10300_GOT24
1485 || r_type == R_MN10300_GOT16)
1486 && elf_hash_table (info)->dynamic_sections_created
1487 && !SYMBOL_REFERENCES_LOCAL (info, hh))
1488 || (r_type == R_MN10300_32
1489 /* _32 relocs in executables force _COPY relocs,
1490 such that the address of the symbol ends up
1492 && !info->executable
1493 && !SYMBOL_REFERENCES_LOCAL (info, hh)
1494 && ((input_section->flags & SEC_ALLOC) != 0
1495 /* DWARF will emit R_MN10300_32 relocations
1496 in its sections against symbols defined
1497 externally in shared libraries. We can't
1498 do anything with them here. */
1499 || ((input_section->flags & SEC_DEBUGGING) != 0
1500 && h->root.def_dynamic)))))
1501 /* In these cases, we don't need the relocation
1502 value. We check specially because in some
1503 obscure cases sec->output_section will be NULL. */
1506 else if (!info->relocatable && unresolved_reloc)
1507 (*_bfd_error_handler)
1508 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1511 (long) rel->r_offset,
1513 h->root.root.root.string);
1516 if (sec != NULL && elf_discarded_section (sec))
1518 /* For relocs against symbols from removed linkonce sections,
1519 or sections discarded by a linker script, we just want the
1520 section contents zeroed. Avoid any special processing. */
1521 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1527 if (info->relocatable)
1530 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1532 contents, rel->r_offset,
1533 relocation, rel->r_addend,
1534 (struct elf_link_hash_entry *) h,
1536 info, sec, h == NULL);
1538 if (r != bfd_reloc_ok)
1541 const char *msg = NULL;
1544 name = h->root.root.root.string;
1547 name = (bfd_elf_string_from_elf_section
1548 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1549 if (name == NULL || *name == '\0')
1550 name = bfd_section_name (input_bfd, sec);
1555 case bfd_reloc_overflow:
1556 if (! ((*info->callbacks->reloc_overflow)
1557 (info, (h ? &h->root.root : NULL), name,
1558 howto->name, (bfd_vma) 0, input_bfd,
1559 input_section, rel->r_offset)))
1563 case bfd_reloc_undefined:
1564 if (! ((*info->callbacks->undefined_symbol)
1565 (info, name, input_bfd, input_section,
1566 rel->r_offset, TRUE)))
1570 case bfd_reloc_outofrange:
1571 msg = _("internal error: out of range error");
1574 case bfd_reloc_notsupported:
1575 msg = _("internal error: unsupported relocation error");
1578 case bfd_reloc_dangerous:
1579 if (r_type == R_MN10300_PCREL32)
1580 msg = _("error: inappropriate relocation type for shared"
1581 " library (did you forget -fpic?)");
1583 msg = _("internal error: suspicious relocation type used"
1584 " in shared library");
1588 msg = _("internal error: unknown error");
1592 if (!((*info->callbacks->warning)
1593 (info, msg, name, input_bfd, input_section,
1604 /* Finish initializing one hash table entry. */
1607 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
1610 struct elf32_mn10300_link_hash_entry *entry;
1611 struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
1612 unsigned int byte_count = 0;
1614 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
1616 if (entry->root.root.type == bfd_link_hash_warning)
1617 entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1619 /* If we already know we want to convert "call" to "calls" for calls
1620 to this symbol, then return now. */
1621 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
1624 /* If there are no named calls to this symbol, or there's nothing we
1625 can move from the function itself into the "call" instruction,
1626 then note that all "call" instructions should be converted into
1627 "calls" instructions and return. If a symbol is available for
1628 dynamic symbol resolution (overridable or overriding), avoid
1629 custom calling conventions. */
1630 if (entry->direct_calls == 0
1631 || (entry->stack_size == 0 && entry->movm_args == 0)
1632 || (elf_hash_table (link_info)->dynamic_sections_created
1633 && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
1634 && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
1636 /* Make a note that we should convert "call" instructions to "calls"
1637 instructions for calls to this symbol. */
1638 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1642 /* We may be able to move some instructions from the function itself into
1643 the "call" instruction. Count how many bytes we might be able to
1644 eliminate in the function itself. */
1646 /* A movm instruction is two bytes. */
1647 if (entry->movm_args)
1650 /* Count the insn to allocate stack space too. */
1651 if (entry->stack_size > 0)
1653 if (entry->stack_size <= 128)
1659 /* If using "call" will result in larger code, then turn all
1660 the associated "call" instructions into "calls" instructions. */
1661 if (byte_count < entry->direct_calls)
1662 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1664 /* This routine never fails. */
1668 /* Used to count hash table entries. */
1671 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
1674 int *count = (int *) in_args;
1680 /* Used to enumerate hash table entries into a linear array. */
1683 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
1686 struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
1693 /* Used to sort the array created by the above. */
1696 sort_by_value (const void *va, const void *vb)
1698 struct elf32_mn10300_link_hash_entry *a
1699 = *(struct elf32_mn10300_link_hash_entry **) va;
1700 struct elf32_mn10300_link_hash_entry *b
1701 = *(struct elf32_mn10300_link_hash_entry **) vb;
1703 return a->value - b->value;
1706 /* Compute the stack size and movm arguments for the function
1707 referred to by HASH at address ADDR in section with
1708 contents CONTENTS, store the information in the hash table. */
1711 compute_function_info (bfd *abfd,
1712 struct elf32_mn10300_link_hash_entry *hash,
1714 unsigned char *contents)
1716 unsigned char byte1, byte2;
1717 /* We only care about a very small subset of the possible prologue
1718 sequences here. Basically we look for:
1720 movm [d2,d3,a2,a3],sp (optional)
1721 add <size>,sp (optional, and only for sizes which fit in an unsigned
1724 If we find anything else, we quit. */
1726 /* Look for movm [regs],sp. */
1727 byte1 = bfd_get_8 (abfd, contents + addr);
1728 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1732 hash->movm_args = byte2;
1734 byte1 = bfd_get_8 (abfd, contents + addr);
1735 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1738 /* Now figure out how much stack space will be allocated by the movm
1739 instruction. We need this kept separate from the function's normal
1741 if (hash->movm_args)
1744 if (hash->movm_args & 0x80)
1745 hash->movm_stack_size += 4;
1748 if (hash->movm_args & 0x40)
1749 hash->movm_stack_size += 4;
1752 if (hash->movm_args & 0x20)
1753 hash->movm_stack_size += 4;
1756 if (hash->movm_args & 0x10)
1757 hash->movm_stack_size += 4;
1759 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
1760 if (hash->movm_args & 0x08)
1761 hash->movm_stack_size += 8 * 4;
1763 if (bfd_get_mach (abfd) == bfd_mach_am33
1764 || bfd_get_mach (abfd) == bfd_mach_am33_2)
1766 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
1767 if (hash->movm_args & 0x1)
1768 hash->movm_stack_size += 6 * 4;
1770 /* exreg1 space. e4, e5, e6, e7 */
1771 if (hash->movm_args & 0x2)
1772 hash->movm_stack_size += 4 * 4;
1774 /* exreg0 space. e2, e3 */
1775 if (hash->movm_args & 0x4)
1776 hash->movm_stack_size += 2 * 4;
1780 /* Now look for the two stack adjustment variants. */
1781 if (byte1 == 0xf8 && byte2 == 0xfe)
1783 int temp = bfd_get_8 (abfd, contents + addr + 2);
1784 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
1786 hash->stack_size = -temp;
1788 else if (byte1 == 0xfa && byte2 == 0xfe)
1790 int temp = bfd_get_16 (abfd, contents + addr + 2);
1791 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
1795 hash->stack_size = temp;
1798 /* If the total stack to be allocated by the call instruction is more
1799 than 255 bytes, then we can't remove the stack adjustment by using
1800 "call" (we might still be able to remove the "movm" instruction. */
1801 if (hash->stack_size + hash->movm_stack_size > 255)
1802 hash->stack_size = 0;
1805 /* Delete some bytes from a section while relaxing. */
1808 mn10300_elf_relax_delete_bytes (bfd *abfd,
1813 Elf_Internal_Shdr *symtab_hdr;
1814 unsigned int sec_shndx;
1816 Elf_Internal_Rela *irel, *irelend;
1817 Elf_Internal_Rela *irelalign;
1819 Elf_Internal_Sym *isym, *isymend;
1820 struct elf_link_hash_entry **sym_hashes;
1821 struct elf_link_hash_entry **end_hashes;
1822 unsigned int symcount;
1824 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1826 contents = elf_section_data (sec)->this_hdr.contents;
1828 /* The deletion must stop at the next ALIGN reloc for an aligment
1829 power larger than the number of bytes we are deleting. */
1834 irel = elf_section_data (sec)->relocs;
1835 irelend = irel + sec->reloc_count;
1837 /* Actually delete the bytes. */
1838 memmove (contents + addr, contents + addr + count,
1839 (size_t) (toaddr - addr - count));
1842 /* Adjust all the relocs. */
1843 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1845 /* Get the new reloc address. */
1846 if ((irel->r_offset > addr
1847 && irel->r_offset < toaddr))
1848 irel->r_offset -= count;
1851 /* Adjust the local symbols defined in this section. */
1852 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1853 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1854 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1856 if (isym->st_shndx == sec_shndx
1857 && isym->st_value > addr
1858 && isym->st_value <= toaddr)
1859 isym->st_value -= count;
1860 /* Adjust the function symbol's size as well. */
1861 else if (isym->st_shndx == sec_shndx
1862 && ELF_ST_TYPE (isym->st_info) == STT_FUNC
1863 && isym->st_value + isym->st_size > addr
1864 && isym->st_value + isym->st_size <= toaddr)
1865 isym->st_size -= count;
1868 /* Now adjust the global symbols defined in this section. */
1869 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1870 - symtab_hdr->sh_info);
1871 sym_hashes = elf_sym_hashes (abfd);
1872 end_hashes = sym_hashes + symcount;
1873 for (; sym_hashes < end_hashes; sym_hashes++)
1875 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1877 if ((sym_hash->root.type == bfd_link_hash_defined
1878 || sym_hash->root.type == bfd_link_hash_defweak)
1879 && sym_hash->root.u.def.section == sec
1880 && sym_hash->root.u.def.value > addr
1881 && sym_hash->root.u.def.value <= toaddr)
1882 sym_hash->root.u.def.value -= count;
1883 /* Adjust the function symbol's size as well. */
1884 else if (sym_hash->root.type == bfd_link_hash_defined
1885 && sym_hash->root.u.def.section == sec
1886 && sym_hash->type == STT_FUNC
1887 && sym_hash->root.u.def.value + sym_hash->size > addr
1888 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
1889 sym_hash->size -= count;
1895 /* Return TRUE if a symbol exists at the given address, else return
1899 mn10300_elf_symbol_address_p (bfd *abfd,
1901 Elf_Internal_Sym *isym,
1904 Elf_Internal_Shdr *symtab_hdr;
1905 unsigned int sec_shndx;
1906 Elf_Internal_Sym *isymend;
1907 struct elf_link_hash_entry **sym_hashes;
1908 struct elf_link_hash_entry **end_hashes;
1909 unsigned int symcount;
1911 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1913 /* Examine all the symbols. */
1914 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1915 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1916 if (isym->st_shndx == sec_shndx
1917 && isym->st_value == addr)
1920 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1921 - symtab_hdr->sh_info);
1922 sym_hashes = elf_sym_hashes (abfd);
1923 end_hashes = sym_hashes + symcount;
1924 for (; sym_hashes < end_hashes; sym_hashes++)
1926 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1928 if ((sym_hash->root.type == bfd_link_hash_defined
1929 || sym_hash->root.type == bfd_link_hash_defweak)
1930 && sym_hash->root.u.def.section == sec
1931 && sym_hash->root.u.def.value == addr)
1938 /* This function handles relaxing for the mn10300.
1940 There are quite a few relaxing opportunities available on the mn10300:
1942 * calls:32 -> calls:16 2 bytes
1943 * call:32 -> call:16 2 bytes
1945 * call:32 -> calls:32 1 byte
1946 * call:16 -> calls:16 1 byte
1947 * These are done anytime using "calls" would result
1948 in smaller code, or when necessary to preserve the
1949 meaning of the program.
1953 * In some circumstances we can move instructions
1954 from a function prologue into a "call" instruction.
1955 This is only done if the resulting code is no larger
1956 than the original code.
1958 * jmp:32 -> jmp:16 2 bytes
1959 * jmp:16 -> bra:8 1 byte
1961 * If the previous instruction is a conditional branch
1962 around the jump/bra, we may be able to reverse its condition
1963 and change its target to the jump's target. The jump/bra
1964 can then be deleted. 2 bytes
1966 * mov abs32 -> mov abs16 1 or 2 bytes
1968 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
1969 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
1971 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
1972 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
1974 We don't handle imm16->imm8 or d16->d8 as they're very rare
1975 and somewhat more difficult to support. */
1978 mn10300_elf_relax_section (bfd *abfd,
1980 struct bfd_link_info *link_info,
1983 Elf_Internal_Shdr *symtab_hdr;
1984 Elf_Internal_Rela *internal_relocs = NULL;
1985 Elf_Internal_Rela *irel, *irelend;
1986 bfd_byte *contents = NULL;
1987 Elf_Internal_Sym *isymbuf = NULL;
1988 struct elf32_mn10300_link_hash_table *hash_table;
1989 asection *section = sec;
1991 /* Assume nothing changes. */
1994 /* We need a pointer to the mn10300 specific hash table. */
1995 hash_table = elf32_mn10300_hash_table (link_info);
1997 /* Initialize fields in each hash table entry the first time through. */
1998 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2002 /* Iterate over all the input bfds. */
2003 for (input_bfd = link_info->input_bfds;
2005 input_bfd = input_bfd->link_next)
2007 /* We're going to need all the symbols for each bfd. */
2008 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2009 if (symtab_hdr->sh_info != 0)
2011 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2012 if (isymbuf == NULL)
2013 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2014 symtab_hdr->sh_info, 0,
2016 if (isymbuf == NULL)
2020 /* Iterate over each section in this bfd. */
2021 for (section = input_bfd->sections;
2023 section = section->next)
2025 struct elf32_mn10300_link_hash_entry *hash;
2026 Elf_Internal_Sym *sym;
2027 asection *sym_sec = NULL;
2028 const char *sym_name;
2031 /* If there's nothing to do in this section, skip it. */
2032 if (! ((section->flags & SEC_RELOC) != 0
2033 && section->reloc_count != 0))
2035 if ((section->flags & SEC_ALLOC) == 0)
2038 /* Get cached copy of section contents if it exists. */
2039 if (elf_section_data (section)->this_hdr.contents != NULL)
2040 contents = elf_section_data (section)->this_hdr.contents;
2041 else if (section->size != 0)
2043 /* Go get them off disk. */
2044 if (!bfd_malloc_and_get_section (input_bfd, section,
2051 /* If there aren't any relocs, then there's nothing to do. */
2052 if ((section->flags & SEC_RELOC) != 0
2053 && section->reloc_count != 0)
2055 /* Get a copy of the native relocations. */
2056 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2058 link_info->keep_memory);
2059 if (internal_relocs == NULL)
2062 /* Now examine each relocation. */
2063 irel = internal_relocs;
2064 irelend = irel + section->reloc_count;
2065 for (; irel < irelend; irel++)
2068 unsigned long r_index;
2071 r_type = ELF32_R_TYPE (irel->r_info);
2072 r_index = ELF32_R_SYM (irel->r_info);
2074 if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2077 /* We need the name and hash table entry of the target
2083 if (r_index < symtab_hdr->sh_info)
2085 /* A local symbol. */
2086 Elf_Internal_Sym *isym;
2087 struct elf_link_hash_table *elftab;
2090 isym = isymbuf + r_index;
2091 if (isym->st_shndx == SHN_UNDEF)
2092 sym_sec = bfd_und_section_ptr;
2093 else if (isym->st_shndx == SHN_ABS)
2094 sym_sec = bfd_abs_section_ptr;
2095 else if (isym->st_shndx == SHN_COMMON)
2096 sym_sec = bfd_com_section_ptr;
2099 = bfd_section_from_elf_index (input_bfd,
2103 = bfd_elf_string_from_elf_section (input_bfd,
2108 /* If it isn't a function, then we don't care
2110 if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2113 /* Tack on an ID so we can uniquely identify this
2114 local symbol in the global hash table. */
2115 amt = strlen (sym_name) + 10;
2116 new_name = bfd_malloc (amt);
2117 if (new_name == NULL)
2120 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2121 sym_name = new_name;
2123 elftab = &hash_table->static_hash_table->root;
2124 hash = ((struct elf32_mn10300_link_hash_entry *)
2125 elf_link_hash_lookup (elftab, sym_name,
2126 TRUE, TRUE, FALSE));
2131 r_index -= symtab_hdr->sh_info;
2132 hash = (struct elf32_mn10300_link_hash_entry *)
2133 elf_sym_hashes (input_bfd)[r_index];
2136 sym_name = hash->root.root.root.string;
2137 if ((section->flags & SEC_CODE) != 0)
2139 /* If this is not a "call" instruction, then we
2140 should convert "call" instructions to "calls"
2142 code = bfd_get_8 (input_bfd,
2143 contents + irel->r_offset - 1);
2144 if (code != 0xdd && code != 0xcd)
2145 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2148 /* If this is a jump/call, then bump the
2149 direct_calls counter. Else force "call" to
2150 "calls" conversions. */
2151 if (r_type == R_MN10300_PCREL32
2152 || r_type == R_MN10300_PLT32
2153 || r_type == R_MN10300_PLT16
2154 || r_type == R_MN10300_PCREL16)
2155 hash->direct_calls++;
2157 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2161 /* Now look at the actual contents to get the stack size,
2162 and a list of what registers were saved in the prologue
2164 if ((section->flags & SEC_CODE) != 0)
2166 Elf_Internal_Sym *isym, *isymend;
2167 unsigned int sec_shndx;
2168 struct elf_link_hash_entry **hashes;
2169 struct elf_link_hash_entry **end_hashes;
2170 unsigned int symcount;
2172 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2175 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2176 - symtab_hdr->sh_info);
2177 hashes = elf_sym_hashes (input_bfd);
2178 end_hashes = hashes + symcount;
2180 /* Look at each function defined in this section and
2181 update info for that function. */
2182 isymend = isymbuf + symtab_hdr->sh_info;
2183 for (isym = isymbuf; isym < isymend; isym++)
2185 if (isym->st_shndx == sec_shndx
2186 && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2188 struct elf_link_hash_table *elftab;
2190 struct elf_link_hash_entry **lhashes = hashes;
2192 /* Skip a local symbol if it aliases a
2194 for (; lhashes < end_hashes; lhashes++)
2196 hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2197 if ((hash->root.root.type == bfd_link_hash_defined
2198 || hash->root.root.type == bfd_link_hash_defweak)
2199 && hash->root.root.u.def.section == section
2200 && hash->root.type == STT_FUNC
2201 && hash->root.root.u.def.value == isym->st_value)
2204 if (lhashes != end_hashes)
2207 if (isym->st_shndx == SHN_UNDEF)
2208 sym_sec = bfd_und_section_ptr;
2209 else if (isym->st_shndx == SHN_ABS)
2210 sym_sec = bfd_abs_section_ptr;
2211 else if (isym->st_shndx == SHN_COMMON)
2212 sym_sec = bfd_com_section_ptr;
2215 = bfd_section_from_elf_index (input_bfd,
2218 sym_name = (bfd_elf_string_from_elf_section
2219 (input_bfd, symtab_hdr->sh_link,
2222 /* Tack on an ID so we can uniquely identify this
2223 local symbol in the global hash table. */
2224 amt = strlen (sym_name) + 10;
2225 new_name = bfd_malloc (amt);
2226 if (new_name == NULL)
2229 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2230 sym_name = new_name;
2232 elftab = &hash_table->static_hash_table->root;
2233 hash = ((struct elf32_mn10300_link_hash_entry *)
2234 elf_link_hash_lookup (elftab, sym_name,
2235 TRUE, TRUE, FALSE));
2237 compute_function_info (input_bfd, hash,
2238 isym->st_value, contents);
2239 hash->value = isym->st_value;
2243 for (; hashes < end_hashes; hashes++)
2245 hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2246 if ((hash->root.root.type == bfd_link_hash_defined
2247 || hash->root.root.type == bfd_link_hash_defweak)
2248 && hash->root.root.u.def.section == section
2249 && hash->root.type == STT_FUNC)
2250 compute_function_info (input_bfd, hash,
2251 (hash)->root.root.u.def.value,
2256 /* Cache or free any memory we allocated for the relocs. */
2257 if (internal_relocs != NULL
2258 && elf_section_data (section)->relocs != internal_relocs)
2259 free (internal_relocs);
2260 internal_relocs = NULL;
2262 /* Cache or free any memory we allocated for the contents. */
2263 if (contents != NULL
2264 && elf_section_data (section)->this_hdr.contents != contents)
2266 if (! link_info->keep_memory)
2270 /* Cache the section contents for elf_link_input_bfd. */
2271 elf_section_data (section)->this_hdr.contents = contents;
2277 /* Cache or free any memory we allocated for the symbols. */
2279 && symtab_hdr->contents != (unsigned char *) isymbuf)
2281 if (! link_info->keep_memory)
2285 /* Cache the symbols for elf_link_input_bfd. */
2286 symtab_hdr->contents = (unsigned char *) isymbuf;
2292 /* Now iterate on each symbol in the hash table and perform
2293 the final initialization steps on each. */
2294 elf32_mn10300_link_hash_traverse (hash_table,
2295 elf32_mn10300_finish_hash_table_entry,
2297 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2298 elf32_mn10300_finish_hash_table_entry,
2302 /* This section of code collects all our local symbols, sorts
2303 them by value, and looks for multiple symbols referring to
2304 the same address. For those symbols, the flags are merged.
2305 At this point, the only flag that can be set is
2306 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2308 int static_count = 0, i;
2309 struct elf32_mn10300_link_hash_entry **entries;
2310 struct elf32_mn10300_link_hash_entry **ptr;
2312 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2313 elf32_mn10300_count_hash_table_entries,
2316 entries = bfd_malloc (static_count * sizeof (* ptr));
2319 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2320 elf32_mn10300_list_hash_table_entries,
2323 qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
2325 for (i = 0; i < static_count - 1; i++)
2326 if (entries[i]->value && entries[i]->value == entries[i+1]->value)
2328 int v = entries[i]->flags;
2331 for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
2332 v |= entries[j]->flags;
2334 for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
2335 entries[j]->flags = v;
2341 /* All entries in the hash table are fully initialized. */
2342 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2344 /* Now that everything has been initialized, go through each
2345 code section and delete any prologue insns which will be
2346 redundant because their operations will be performed by
2347 a "call" instruction. */
2348 for (input_bfd = link_info->input_bfds;
2350 input_bfd = input_bfd->link_next)
2352 /* We're going to need all the local symbols for each bfd. */
2353 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2354 if (symtab_hdr->sh_info != 0)
2356 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2357 if (isymbuf == NULL)
2358 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2359 symtab_hdr->sh_info, 0,
2361 if (isymbuf == NULL)
2365 /* Walk over each section in this bfd. */
2366 for (section = input_bfd->sections;
2368 section = section->next)
2370 unsigned int sec_shndx;
2371 Elf_Internal_Sym *isym, *isymend;
2372 struct elf_link_hash_entry **hashes;
2373 struct elf_link_hash_entry **end_hashes;
2374 unsigned int symcount;
2376 /* Skip non-code sections and empty sections. */
2377 if ((section->flags & SEC_CODE) == 0 || section->size == 0)
2380 if (section->reloc_count != 0)
2382 /* Get a copy of the native relocations. */
2383 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2385 link_info->keep_memory);
2386 if (internal_relocs == NULL)
2390 /* Get cached copy of section contents if it exists. */
2391 if (elf_section_data (section)->this_hdr.contents != NULL)
2392 contents = elf_section_data (section)->this_hdr.contents;
2395 /* Go get them off disk. */
2396 if (!bfd_malloc_and_get_section (input_bfd, section,
2401 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2404 /* Now look for any function in this section which needs
2405 insns deleted from its prologue. */
2406 isymend = isymbuf + symtab_hdr->sh_info;
2407 for (isym = isymbuf; isym < isymend; isym++)
2409 struct elf32_mn10300_link_hash_entry *sym_hash;
2410 asection *sym_sec = NULL;
2411 const char *sym_name;
2413 struct elf_link_hash_table *elftab;
2416 if (isym->st_shndx != sec_shndx)
2419 if (isym->st_shndx == SHN_UNDEF)
2420 sym_sec = bfd_und_section_ptr;
2421 else if (isym->st_shndx == SHN_ABS)
2422 sym_sec = bfd_abs_section_ptr;
2423 else if (isym->st_shndx == SHN_COMMON)
2424 sym_sec = bfd_com_section_ptr;
2427 = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2430 = bfd_elf_string_from_elf_section (input_bfd,
2431 symtab_hdr->sh_link,
2434 /* Tack on an ID so we can uniquely identify this
2435 local symbol in the global hash table. */
2436 amt = strlen (sym_name) + 10;
2437 new_name = bfd_malloc (amt);
2438 if (new_name == NULL)
2440 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2441 sym_name = new_name;
2443 elftab = & hash_table->static_hash_table->root;
2444 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2445 elf_link_hash_lookup (elftab, sym_name,
2446 FALSE, FALSE, FALSE);
2449 if (sym_hash == NULL)
2452 if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2453 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2457 /* Note that we've changed things. */
2458 elf_section_data (section)->relocs = internal_relocs;
2459 elf_section_data (section)->this_hdr.contents = contents;
2460 symtab_hdr->contents = (unsigned char *) isymbuf;
2462 /* Count how many bytes we're going to delete. */
2463 if (sym_hash->movm_args)
2466 if (sym_hash->stack_size > 0)
2468 if (sym_hash->stack_size <= 128)
2474 /* Note that we've deleted prologue bytes for this
2476 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2478 /* Actually delete the bytes. */
2479 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2485 /* Something changed. Not strictly necessary, but
2486 may lead to more relaxing opportunities. */
2491 /* Look for any global functions in this section which
2492 need insns deleted from their prologues. */
2493 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2494 - symtab_hdr->sh_info);
2495 hashes = elf_sym_hashes (input_bfd);
2496 end_hashes = hashes + symcount;
2497 for (; hashes < end_hashes; hashes++)
2499 struct elf32_mn10300_link_hash_entry *sym_hash;
2501 sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2502 if ((sym_hash->root.root.type == bfd_link_hash_defined
2503 || sym_hash->root.root.type == bfd_link_hash_defweak)
2504 && sym_hash->root.root.u.def.section == section
2505 && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2506 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2511 /* Note that we've changed things. */
2512 elf_section_data (section)->relocs = internal_relocs;
2513 elf_section_data (section)->this_hdr.contents = contents;
2514 symtab_hdr->contents = (unsigned char *) isymbuf;
2516 /* Count how many bytes we're going to delete. */
2517 if (sym_hash->movm_args)
2520 if (sym_hash->stack_size > 0)
2522 if (sym_hash->stack_size <= 128)
2528 /* Note that we've deleted prologue bytes for this
2530 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2532 /* Actually delete the bytes. */
2533 symval = sym_hash->root.root.u.def.value;
2534 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2540 /* Something changed. Not strictly necessary, but
2541 may lead to more relaxing opportunities. */
2546 /* Cache or free any memory we allocated for the relocs. */
2547 if (internal_relocs != NULL
2548 && elf_section_data (section)->relocs != internal_relocs)
2549 free (internal_relocs);
2550 internal_relocs = NULL;
2552 /* Cache or free any memory we allocated for the contents. */
2553 if (contents != NULL
2554 && elf_section_data (section)->this_hdr.contents != contents)
2556 if (! link_info->keep_memory)
2559 /* Cache the section contents for elf_link_input_bfd. */
2560 elf_section_data (section)->this_hdr.contents = contents;
2565 /* Cache or free any memory we allocated for the symbols. */
2567 && symtab_hdr->contents != (unsigned char *) isymbuf)
2569 if (! link_info->keep_memory)
2572 /* Cache the symbols for elf_link_input_bfd. */
2573 symtab_hdr->contents = (unsigned char *) isymbuf;
2579 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
2581 internal_relocs = NULL;
2583 /* For error_return. */
2586 /* We don't have to do anything for a relocatable link, if
2587 this section does not have relocs, or if this is not a
2589 if (link_info->relocatable
2590 || (sec->flags & SEC_RELOC) == 0
2591 || sec->reloc_count == 0
2592 || (sec->flags & SEC_CODE) == 0)
2595 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2597 /* Get a copy of the native relocations. */
2598 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2599 link_info->keep_memory);
2600 if (internal_relocs == NULL)
2603 /* Walk through them looking for relaxing opportunities. */
2604 irelend = internal_relocs + sec->reloc_count;
2605 for (irel = internal_relocs; irel < irelend; irel++)
2608 struct elf32_mn10300_link_hash_entry *h = NULL;
2610 /* If this isn't something that can be relaxed, then ignore
2612 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2613 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2614 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2617 /* Get the section contents if we haven't done so already. */
2618 if (contents == NULL)
2620 /* Get cached copy if it exists. */
2621 if (elf_section_data (sec)->this_hdr.contents != NULL)
2622 contents = elf_section_data (sec)->this_hdr.contents;
2625 /* Go get them off disk. */
2626 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2631 /* Read this BFD's symbols if we haven't done so already. */
2632 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2634 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2635 if (isymbuf == NULL)
2636 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2637 symtab_hdr->sh_info, 0,
2639 if (isymbuf == NULL)
2643 /* Get the value of the symbol referred to by the reloc. */
2644 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2646 Elf_Internal_Sym *isym;
2647 asection *sym_sec = NULL;
2648 const char *sym_name;
2651 /* A local symbol. */
2652 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2653 if (isym->st_shndx == SHN_UNDEF)
2654 sym_sec = bfd_und_section_ptr;
2655 else if (isym->st_shndx == SHN_ABS)
2656 sym_sec = bfd_abs_section_ptr;
2657 else if (isym->st_shndx == SHN_COMMON)
2658 sym_sec = bfd_com_section_ptr;
2660 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2662 sym_name = bfd_elf_string_from_elf_section (abfd,
2663 symtab_hdr->sh_link,
2666 if ((sym_sec->flags & SEC_MERGE)
2667 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
2668 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2670 bfd_vma saved_addend;
2672 saved_addend = irel->r_addend;
2673 symval = _bfd_elf_rela_local_sym (abfd, isym, & sym_sec, irel);
2674 symval += irel->r_addend;
2675 irel->r_addend = saved_addend;
2678 symval = (isym->st_value
2679 + sym_sec->output_section->vma
2680 + sym_sec->output_offset);
2682 /* Tack on an ID so we can uniquely identify this
2683 local symbol in the global hash table. */
2684 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2685 if (new_name == NULL)
2687 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2688 sym_name = new_name;
2690 h = (struct elf32_mn10300_link_hash_entry *)
2691 elf_link_hash_lookup (&hash_table->static_hash_table->root,
2692 sym_name, FALSE, FALSE, FALSE);
2699 /* An external symbol. */
2700 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2701 h = (struct elf32_mn10300_link_hash_entry *)
2702 (elf_sym_hashes (abfd)[indx]);
2703 BFD_ASSERT (h != NULL);
2704 if (h->root.root.type != bfd_link_hash_defined
2705 && h->root.root.type != bfd_link_hash_defweak)
2706 /* This appears to be a reference to an undefined
2707 symbol. Just ignore it--it will be caught by the
2708 regular reloc processing. */
2711 /* Check for a reference to a discarded symbol and ignore it. */
2712 if (h->root.root.u.def.section->output_section == NULL)
2715 symval = (h->root.root.u.def.value
2716 + h->root.root.u.def.section->output_section->vma
2717 + h->root.root.u.def.section->output_offset);
2720 /* For simplicity of coding, we are going to modify the section
2721 contents, the section relocs, and the BFD symbol table. We
2722 must tell the rest of the code not to free up this
2723 information. It would be possible to instead create a table
2724 of changes which have to be made, as is done in coff-mips.c;
2725 that would be more work, but would require less memory when
2726 the linker is run. */
2728 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2729 branch/call, also deal with "call" -> "calls" conversions and
2730 insertion of prologue data into "call" instructions. */
2731 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2732 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2734 bfd_vma value = symval;
2736 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2738 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2739 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2740 && h->root.plt.offset != (bfd_vma) -1)
2744 splt = bfd_get_section_by_name (elf_hash_table (link_info)
2747 value = ((splt->output_section->vma
2748 + splt->output_offset
2749 + h->root.plt.offset)
2750 - (sec->output_section->vma
2751 + sec->output_offset
2755 /* If we've got a "call" instruction that needs to be turned
2756 into a "calls" instruction, do so now. It saves a byte. */
2757 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2761 /* Get the opcode. */
2762 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2764 /* Make sure we're working with a "call" instruction! */
2767 /* Note that we've changed the relocs, section contents,
2769 elf_section_data (sec)->relocs = internal_relocs;
2770 elf_section_data (sec)->this_hdr.contents = contents;
2771 symtab_hdr->contents = (unsigned char *) isymbuf;
2773 /* Fix the opcode. */
2774 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2775 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2777 /* Fix irel->r_offset and irel->r_addend. */
2778 irel->r_offset += 1;
2779 irel->r_addend += 1;
2781 /* Delete one byte of data. */
2782 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2783 irel->r_offset + 3, 1))
2786 /* That will change things, so, we should relax again.
2787 Note that this is not required, and it may be slow. */
2793 /* We've got a "call" instruction which needs some data
2794 from target function filled in. */
2797 /* Get the opcode. */
2798 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2800 /* Insert data from the target function into the "call"
2801 instruction if needed. */
2804 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2805 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2806 contents + irel->r_offset + 5);
2810 /* Deal with pc-relative gunk. */
2811 value -= (sec->output_section->vma + sec->output_offset);
2812 value -= irel->r_offset;
2813 value += irel->r_addend;
2815 /* See if the value will fit in 16 bits, note the high value is
2816 0x7fff + 2 as the target will be two bytes closer if we are
2818 if ((long) value < 0x8001 && (long) value > -0x8000)
2822 /* Get the opcode. */
2823 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2825 if (code != 0xdc && code != 0xdd && code != 0xff)
2828 /* Note that we've changed the relocs, section contents, etc. */
2829 elf_section_data (sec)->relocs = internal_relocs;
2830 elf_section_data (sec)->this_hdr.contents = contents;
2831 symtab_hdr->contents = (unsigned char *) isymbuf;
2833 /* Fix the opcode. */
2835 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2836 else if (code == 0xdd)
2837 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2838 else if (code == 0xff)
2839 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2841 /* Fix the relocation's type. */
2842 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2843 (ELF32_R_TYPE (irel->r_info)
2844 == (int) R_MN10300_PLT32)
2848 /* Delete two bytes of data. */
2849 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2850 irel->r_offset + 1, 2))
2853 /* That will change things, so, we should relax again.
2854 Note that this is not required, and it may be slow. */
2859 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
2861 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
2863 bfd_vma value = symval;
2865 /* If we've got a "call" instruction that needs to be turned
2866 into a "calls" instruction, do so now. It saves a byte. */
2867 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2871 /* Get the opcode. */
2872 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2874 /* Make sure we're working with a "call" instruction! */
2877 /* Note that we've changed the relocs, section contents,
2879 elf_section_data (sec)->relocs = internal_relocs;
2880 elf_section_data (sec)->this_hdr.contents = contents;
2881 symtab_hdr->contents = (unsigned char *) isymbuf;
2883 /* Fix the opcode. */
2884 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
2885 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2887 /* Fix irel->r_offset and irel->r_addend. */
2888 irel->r_offset += 1;
2889 irel->r_addend += 1;
2891 /* Delete one byte of data. */
2892 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2893 irel->r_offset + 1, 1))
2896 /* That will change things, so, we should relax again.
2897 Note that this is not required, and it may be slow. */
2905 /* Get the opcode. */
2906 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2908 /* Insert data from the target function into the "call"
2909 instruction if needed. */
2912 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
2913 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2914 contents + irel->r_offset + 3);
2918 /* Deal with pc-relative gunk. */
2919 value -= (sec->output_section->vma + sec->output_offset);
2920 value -= irel->r_offset;
2921 value += irel->r_addend;
2923 /* See if the value will fit in 8 bits, note the high value is
2924 0x7f + 1 as the target will be one bytes closer if we are
2926 if ((long) value < 0x80 && (long) value > -0x80)
2930 /* Get the opcode. */
2931 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2936 /* Note that we've changed the relocs, section contents, etc. */
2937 elf_section_data (sec)->relocs = internal_relocs;
2938 elf_section_data (sec)->this_hdr.contents = contents;
2939 symtab_hdr->contents = (unsigned char *) isymbuf;
2941 /* Fix the opcode. */
2942 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
2944 /* Fix the relocation's type. */
2945 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2948 /* Delete one byte of data. */
2949 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2950 irel->r_offset + 1, 1))
2953 /* That will change things, so, we should relax again.
2954 Note that this is not required, and it may be slow. */
2959 /* Try to eliminate an unconditional 8 bit pc-relative branch
2960 which immediately follows a conditional 8 bit pc-relative
2961 branch around the unconditional branch.
2968 This happens when the bCC can't reach lab2 at assembly time,
2969 but due to other relaxations it can reach at link time. */
2970 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
2972 Elf_Internal_Rela *nrel;
2973 bfd_vma value = symval;
2976 /* Deal with pc-relative gunk. */
2977 value -= (sec->output_section->vma + sec->output_offset);
2978 value -= irel->r_offset;
2979 value += irel->r_addend;
2981 /* Do nothing if this reloc is the last byte in the section. */
2982 if (irel->r_offset == sec->size)
2985 /* See if the next instruction is an unconditional pc-relative
2986 branch, more often than not this test will fail, so we
2987 test it first to speed things up. */
2988 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2992 /* Also make sure the next relocation applies to the next
2993 instruction and that it's a pc-relative 8 bit branch. */
2996 || irel->r_offset + 2 != nrel->r_offset
2997 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3000 /* Make sure our destination immediately follows the
3001 unconditional branch. */
3002 if (symval != (sec->output_section->vma + sec->output_offset
3003 + irel->r_offset + 3))
3006 /* Now make sure we are a conditional branch. This may not
3007 be necessary, but why take the chance.
3009 Note these checks assume that R_MN10300_PCREL8 relocs
3010 only occur on bCC and bCCx insns. If they occured
3011 elsewhere, we'd need to know the start of this insn
3012 for this check to be accurate. */
3013 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3014 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3015 && code != 0xc3 && code != 0xc4 && code != 0xc5
3016 && code != 0xc6 && code != 0xc7 && code != 0xc8
3017 && code != 0xc9 && code != 0xe8 && code != 0xe9
3018 && code != 0xea && code != 0xeb)
3021 /* We also have to be sure there is no symbol/label
3022 at the unconditional branch. */
3023 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3024 irel->r_offset + 1))
3027 /* Note that we've changed the relocs, section contents, etc. */
3028 elf_section_data (sec)->relocs = internal_relocs;
3029 elf_section_data (sec)->this_hdr.contents = contents;
3030 symtab_hdr->contents = (unsigned char *) isymbuf;
3032 /* Reverse the condition of the first branch. */
3078 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3080 /* Set the reloc type and symbol for the first branch
3081 from the second branch. */
3082 irel->r_info = nrel->r_info;
3084 /* Make the reloc for the second branch a null reloc. */
3085 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3088 /* Delete two bytes of data. */
3089 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3090 irel->r_offset + 1, 2))
3093 /* That will change things, so, we should relax again.
3094 Note that this is not required, and it may be slow. */
3098 /* Try to turn a 24 immediate, displacement or absolute address
3099 into a 8 immediate, displacement or absolute address. */
3100 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3102 bfd_vma value = symval;
3103 value += irel->r_addend;
3105 /* See if the value will fit in 8 bits. */
3106 if ((long) value < 0x7f && (long) value > -0x80)
3110 /* AM33 insns which have 24 operands are 6 bytes long and
3111 will have 0xfd as the first byte. */
3113 /* Get the first opcode. */
3114 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3118 /* Get the second opcode. */
3119 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3121 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3122 equivalent instructions exists. */
3123 if (code != 0x6b && code != 0x7b
3124 && code != 0x8b && code != 0x9b
3125 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3126 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3127 || (code & 0x0f) == 0x0e))
3129 /* Not safe if the high bit is on as relaxing may
3130 move the value out of high mem and thus not fit
3131 in a signed 8bit value. This is currently over
3133 if ((value & 0x80) == 0)
3135 /* Note that we've changed the relocation contents,
3137 elf_section_data (sec)->relocs = internal_relocs;
3138 elf_section_data (sec)->this_hdr.contents = contents;
3139 symtab_hdr->contents = (unsigned char *) isymbuf;
3141 /* Fix the opcode. */
3142 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3143 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3145 /* Fix the relocation's type. */
3147 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3150 /* Delete two bytes of data. */
3151 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3152 irel->r_offset + 1, 2))
3155 /* That will change things, so, we should relax
3156 again. Note that this is not required, and it
3166 /* Try to turn a 32bit immediate, displacement or absolute address
3167 into a 16bit immediate, displacement or absolute address. */
3168 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3169 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3170 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3172 bfd_vma value = symval;
3174 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3178 sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3181 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3183 value = sgot->output_offset;
3186 value += h->root.got.offset;
3188 value += (elf_local_got_offsets
3189 (abfd)[ELF32_R_SYM (irel->r_info)]);
3191 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3192 value -= sgot->output_section->vma;
3193 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3194 value = (sgot->output_section->vma
3195 - (sec->output_section->vma
3196 + sec->output_offset
3202 value += irel->r_addend;
3204 /* See if the value will fit in 24 bits.
3205 We allow any 16bit match here. We prune those we can't
3207 if ((long) value < 0x7fffff && (long) value > -0x800000)
3211 /* AM33 insns which have 32bit operands are 7 bytes long and
3212 will have 0xfe as the first byte. */
3214 /* Get the first opcode. */
3215 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3219 /* Get the second opcode. */
3220 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3222 /* All the am33 32 -> 24 relaxing possibilities. */
3223 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3224 equivalent instructions exists. */
3225 if (code != 0x6b && code != 0x7b
3226 && code != 0x8b && code != 0x9b
3227 && (ELF32_R_TYPE (irel->r_info)
3228 != (int) R_MN10300_GOTPC32)
3229 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3230 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3231 || (code & 0x0f) == 0x0e))
3233 /* Not safe if the high bit is on as relaxing may
3234 move the value out of high mem and thus not fit
3235 in a signed 16bit value. This is currently over
3237 if ((value & 0x8000) == 0)
3239 /* Note that we've changed the relocation contents,
3241 elf_section_data (sec)->relocs = internal_relocs;
3242 elf_section_data (sec)->this_hdr.contents = contents;
3243 symtab_hdr->contents = (unsigned char *) isymbuf;
3245 /* Fix the opcode. */
3246 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3247 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3249 /* Fix the relocation's type. */
3251 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3252 (ELF32_R_TYPE (irel->r_info)
3253 == (int) R_MN10300_GOTOFF32)
3254 ? R_MN10300_GOTOFF24
3255 : (ELF32_R_TYPE (irel->r_info)
3256 == (int) R_MN10300_GOT32)
3260 /* Delete one byte of data. */
3261 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3262 irel->r_offset + 3, 1))
3265 /* That will change things, so, we should relax
3266 again. Note that this is not required, and it
3275 /* See if the value will fit in 16 bits.
3276 We allow any 16bit match here. We prune those we can't
3278 if ((long) value < 0x7fff && (long) value > -0x8000)
3282 /* Most insns which have 32bit operands are 6 bytes long;
3283 exceptions are pcrel insns and bit insns.
3285 We handle pcrel insns above. We don't bother trying
3286 to handle the bit insns here.
3288 The first byte of the remaining insns will be 0xfc. */
3290 /* Get the first opcode. */
3291 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3296 /* Get the second opcode. */
3297 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3299 if ((code & 0xf0) < 0x80)
3300 switch (code & 0xf0)
3302 /* mov (d32,am),dn -> mov (d32,am),dn
3303 mov dm,(d32,am) -> mov dn,(d32,am)
3304 mov (d32,am),an -> mov (d32,am),an
3305 mov dm,(d32,am) -> mov dn,(d32,am)
3306 movbu (d32,am),dn -> movbu (d32,am),dn
3307 movbu dm,(d32,am) -> movbu dn,(d32,am)
3308 movhu (d32,am),dn -> movhu (d32,am),dn
3309 movhu dm,(d32,am) -> movhu dn,(d32,am) */
3318 /* Not safe if the high bit is on as relaxing may
3319 move the value out of high mem and thus not fit
3320 in a signed 16bit value. */
3322 && (value & 0x8000))
3325 /* Note that we've changed the relocation contents, etc. */
3326 elf_section_data (sec)->relocs = internal_relocs;
3327 elf_section_data (sec)->this_hdr.contents = contents;
3328 symtab_hdr->contents = (unsigned char *) isymbuf;
3330 /* Fix the opcode. */
3331 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3332 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3334 /* Fix the relocation's type. */
3335 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3336 (ELF32_R_TYPE (irel->r_info)
3337 == (int) R_MN10300_GOTOFF32)
3338 ? R_MN10300_GOTOFF16
3339 : (ELF32_R_TYPE (irel->r_info)
3340 == (int) R_MN10300_GOT32)
3342 : (ELF32_R_TYPE (irel->r_info)
3343 == (int) R_MN10300_GOTPC32)
3344 ? R_MN10300_GOTPC16 :
3347 /* Delete two bytes of data. */
3348 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3349 irel->r_offset + 2, 2))
3352 /* That will change things, so, we should relax again.
3353 Note that this is not required, and it may be slow. */
3357 else if ((code & 0xf0) == 0x80
3358 || (code & 0xf0) == 0x90)
3359 switch (code & 0xf3)
3361 /* mov dn,(abs32) -> mov dn,(abs16)
3362 movbu dn,(abs32) -> movbu dn,(abs16)
3363 movhu dn,(abs32) -> movhu dn,(abs16) */
3367 /* Note that we've changed the relocation contents, etc. */
3368 elf_section_data (sec)->relocs = internal_relocs;
3369 elf_section_data (sec)->this_hdr.contents = contents;
3370 symtab_hdr->contents = (unsigned char *) isymbuf;
3372 if ((code & 0xf3) == 0x81)
3373 code = 0x01 + (code & 0x0c);
3374 else if ((code & 0xf3) == 0x82)
3375 code = 0x02 + (code & 0x0c);
3376 else if ((code & 0xf3) == 0x83)
3377 code = 0x03 + (code & 0x0c);
3381 /* Fix the opcode. */
3382 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3384 /* Fix the relocation's type. */
3385 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3386 (ELF32_R_TYPE (irel->r_info)
3387 == (int) R_MN10300_GOTOFF32)
3388 ? R_MN10300_GOTOFF16
3389 : (ELF32_R_TYPE (irel->r_info)
3390 == (int) R_MN10300_GOT32)
3392 : (ELF32_R_TYPE (irel->r_info)
3393 == (int) R_MN10300_GOTPC32)
3394 ? R_MN10300_GOTPC16 :
3397 /* The opcode got shorter too, so we have to fix the
3398 addend and offset too! */
3399 irel->r_offset -= 1;
3401 /* Delete three bytes of data. */
3402 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3403 irel->r_offset + 1, 3))
3406 /* That will change things, so, we should relax again.
3407 Note that this is not required, and it may be slow. */
3411 /* mov am,(abs32) -> mov am,(abs16)
3412 mov am,(d32,sp) -> mov am,(d16,sp)
3413 mov dm,(d32,sp) -> mov dm,(d32,sp)
3414 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3415 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3421 /* sp-based offsets are zero-extended. */
3422 if (code >= 0x90 && code <= 0x93
3423 && (long) value < 0)
3426 /* Note that we've changed the relocation contents, etc. */
3427 elf_section_data (sec)->relocs = internal_relocs;
3428 elf_section_data (sec)->this_hdr.contents = contents;
3429 symtab_hdr->contents = (unsigned char *) isymbuf;
3431 /* Fix the opcode. */
3432 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3433 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3435 /* Fix the relocation's type. */
3436 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3437 (ELF32_R_TYPE (irel->r_info)
3438 == (int) R_MN10300_GOTOFF32)
3439 ? R_MN10300_GOTOFF16
3440 : (ELF32_R_TYPE (irel->r_info)
3441 == (int) R_MN10300_GOT32)
3443 : (ELF32_R_TYPE (irel->r_info)
3444 == (int) R_MN10300_GOTPC32)
3445 ? R_MN10300_GOTPC16 :
3448 /* Delete two bytes of data. */
3449 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3450 irel->r_offset + 2, 2))
3453 /* That will change things, so, we should relax again.
3454 Note that this is not required, and it may be slow. */
3458 else if ((code & 0xf0) < 0xf0)
3459 switch (code & 0xfc)
3461 /* mov imm32,dn -> mov imm16,dn
3462 mov imm32,an -> mov imm16,an
3463 mov (abs32),dn -> mov (abs16),dn
3464 movbu (abs32),dn -> movbu (abs16),dn
3465 movhu (abs32),dn -> movhu (abs16),dn */
3471 /* Not safe if the high bit is on as relaxing may
3472 move the value out of high mem and thus not fit
3473 in a signed 16bit value. */
3475 && (value & 0x8000))
3478 /* mov imm16, an zero-extends the immediate. */
3480 && (long) value < 0)
3483 /* Note that we've changed the relocation contents, etc. */
3484 elf_section_data (sec)->relocs = internal_relocs;
3485 elf_section_data (sec)->this_hdr.contents = contents;
3486 symtab_hdr->contents = (unsigned char *) isymbuf;
3488 if ((code & 0xfc) == 0xcc)
3489 code = 0x2c + (code & 0x03);
3490 else if ((code & 0xfc) == 0xdc)
3491 code = 0x24 + (code & 0x03);
3492 else if ((code & 0xfc) == 0xa4)
3493 code = 0x30 + (code & 0x03);
3494 else if ((code & 0xfc) == 0xa8)
3495 code = 0x34 + (code & 0x03);
3496 else if ((code & 0xfc) == 0xac)
3497 code = 0x38 + (code & 0x03);
3501 /* Fix the opcode. */
3502 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3504 /* Fix the relocation's type. */
3505 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3506 (ELF32_R_TYPE (irel->r_info)
3507 == (int) R_MN10300_GOTOFF32)
3508 ? R_MN10300_GOTOFF16
3509 : (ELF32_R_TYPE (irel->r_info)
3510 == (int) R_MN10300_GOT32)
3512 : (ELF32_R_TYPE (irel->r_info)
3513 == (int) R_MN10300_GOTPC32)
3514 ? R_MN10300_GOTPC16 :
3517 /* The opcode got shorter too, so we have to fix the
3518 addend and offset too! */
3519 irel->r_offset -= 1;
3521 /* Delete three bytes of data. */
3522 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3523 irel->r_offset + 1, 3))
3526 /* That will change things, so, we should relax again.
3527 Note that this is not required, and it may be slow. */
3531 /* mov (abs32),an -> mov (abs16),an
3532 mov (d32,sp),an -> mov (d16,sp),an
3533 mov (d32,sp),dn -> mov (d16,sp),dn
3534 movbu (d32,sp),dn -> movbu (d16,sp),dn
3535 movhu (d32,sp),dn -> movhu (d16,sp),dn
3536 add imm32,dn -> add imm16,dn
3537 cmp imm32,dn -> cmp imm16,dn
3538 add imm32,an -> add imm16,an
3539 cmp imm32,an -> cmp imm16,an
3540 and imm32,dn -> and imm16,dn
3541 or imm32,dn -> or imm16,dn
3542 xor imm32,dn -> xor imm16,dn
3543 btst imm32,dn -> btst imm16,dn */
3559 /* cmp imm16, an zero-extends the immediate. */
3561 && (long) value < 0)
3564 /* So do sp-based offsets. */
3565 if (code >= 0xb0 && code <= 0xb3
3566 && (long) value < 0)
3569 /* Note that we've changed the relocation contents, etc. */
3570 elf_section_data (sec)->relocs = internal_relocs;
3571 elf_section_data (sec)->this_hdr.contents = contents;
3572 symtab_hdr->contents = (unsigned char *) isymbuf;
3574 /* Fix the opcode. */
3575 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3576 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3578 /* Fix the relocation's type. */
3579 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3580 (ELF32_R_TYPE (irel->r_info)
3581 == (int) R_MN10300_GOTOFF32)
3582 ? R_MN10300_GOTOFF16
3583 : (ELF32_R_TYPE (irel->r_info)
3584 == (int) R_MN10300_GOT32)
3586 : (ELF32_R_TYPE (irel->r_info)
3587 == (int) R_MN10300_GOTPC32)
3588 ? R_MN10300_GOTPC16 :
3591 /* Delete two bytes of data. */
3592 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3593 irel->r_offset + 2, 2))
3596 /* That will change things, so, we should relax again.
3597 Note that this is not required, and it may be slow. */
3601 else if (code == 0xfe)
3603 /* add imm32,sp -> add imm16,sp */
3605 /* Note that we've changed the relocation contents, etc. */
3606 elf_section_data (sec)->relocs = internal_relocs;
3607 elf_section_data (sec)->this_hdr.contents = contents;
3608 symtab_hdr->contents = (unsigned char *) isymbuf;
3610 /* Fix the opcode. */
3611 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3612 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3614 /* Fix the relocation's type. */
3615 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3616 (ELF32_R_TYPE (irel->r_info)
3617 == (int) R_MN10300_GOT32)
3619 : (ELF32_R_TYPE (irel->r_info)
3620 == (int) R_MN10300_GOTOFF32)
3621 ? R_MN10300_GOTOFF16
3622 : (ELF32_R_TYPE (irel->r_info)
3623 == (int) R_MN10300_GOTPC32)
3624 ? R_MN10300_GOTPC16 :
3627 /* Delete two bytes of data. */
3628 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3629 irel->r_offset + 2, 2))
3632 /* That will change things, so, we should relax again.
3633 Note that this is not required, and it may be slow. */
3642 && symtab_hdr->contents != (unsigned char *) isymbuf)
3644 if (! link_info->keep_memory)
3648 /* Cache the symbols for elf_link_input_bfd. */
3649 symtab_hdr->contents = (unsigned char *) isymbuf;
3653 if (contents != NULL
3654 && elf_section_data (sec)->this_hdr.contents != contents)
3656 if (! link_info->keep_memory)
3660 /* Cache the section contents for elf_link_input_bfd. */
3661 elf_section_data (sec)->this_hdr.contents = contents;
3665 if (internal_relocs != NULL
3666 && elf_section_data (sec)->relocs != internal_relocs)
3667 free (internal_relocs);
3673 && symtab_hdr->contents != (unsigned char *) isymbuf)
3675 if (contents != NULL
3676 && elf_section_data (section)->this_hdr.contents != contents)
3678 if (internal_relocs != NULL
3679 && elf_section_data (section)->relocs != internal_relocs)
3680 free (internal_relocs);
3685 /* This is a version of bfd_generic_get_relocated_section_contents
3686 which uses mn10300_elf_relocate_section. */
3689 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3690 struct bfd_link_info *link_info,
3691 struct bfd_link_order *link_order,
3693 bfd_boolean relocatable,
3696 Elf_Internal_Shdr *symtab_hdr;
3697 asection *input_section = link_order->u.indirect.section;
3698 bfd *input_bfd = input_section->owner;
3699 asection **sections = NULL;
3700 Elf_Internal_Rela *internal_relocs = NULL;
3701 Elf_Internal_Sym *isymbuf = NULL;
3703 /* We only need to handle the case of relaxing, or of having a
3704 particular set of section contents, specially. */
3706 || elf_section_data (input_section)->this_hdr.contents == NULL)
3707 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3712 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3714 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3715 (size_t) input_section->size);
3717 if ((input_section->flags & SEC_RELOC) != 0
3718 && input_section->reloc_count > 0)
3721 Elf_Internal_Sym *isym, *isymend;
3724 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3726 if (internal_relocs == NULL)
3729 if (symtab_hdr->sh_info != 0)
3731 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3732 if (isymbuf == NULL)
3733 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3734 symtab_hdr->sh_info, 0,
3736 if (isymbuf == NULL)
3740 amt = symtab_hdr->sh_info;
3741 amt *= sizeof (asection *);
3742 sections = bfd_malloc (amt);
3743 if (sections == NULL && amt != 0)
3746 isymend = isymbuf + symtab_hdr->sh_info;
3747 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3751 if (isym->st_shndx == SHN_UNDEF)
3752 isec = bfd_und_section_ptr;
3753 else if (isym->st_shndx == SHN_ABS)
3754 isec = bfd_abs_section_ptr;
3755 else if (isym->st_shndx == SHN_COMMON)
3756 isec = bfd_com_section_ptr;
3758 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3763 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3764 input_section, data, internal_relocs,
3768 if (sections != NULL)
3770 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3772 if (internal_relocs != elf_section_data (input_section)->relocs)
3773 free (internal_relocs);
3779 if (sections != NULL)
3781 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3783 if (internal_relocs != NULL
3784 && internal_relocs != elf_section_data (input_section)->relocs)
3785 free (internal_relocs);
3789 /* Assorted hash table functions. */
3791 /* Initialize an entry in the link hash table. */
3793 /* Create an entry in an MN10300 ELF linker hash table. */
3795 static struct bfd_hash_entry *
3796 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3797 struct bfd_hash_table *table,
3800 struct elf32_mn10300_link_hash_entry *ret =
3801 (struct elf32_mn10300_link_hash_entry *) entry;
3803 /* Allocate the structure if it has not already been allocated by a
3806 ret = (struct elf32_mn10300_link_hash_entry *)
3807 bfd_hash_allocate (table, sizeof (* ret));
3809 return (struct bfd_hash_entry *) ret;
3811 /* Call the allocation method of the superclass. */
3812 ret = (struct elf32_mn10300_link_hash_entry *)
3813 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3817 ret->direct_calls = 0;
3818 ret->stack_size = 0;
3820 ret->movm_stack_size = 0;
3825 return (struct bfd_hash_entry *) ret;
3828 /* Create an mn10300 ELF linker hash table. */
3830 static struct bfd_link_hash_table *
3831 elf32_mn10300_link_hash_table_create (bfd *abfd)
3833 struct elf32_mn10300_link_hash_table *ret;
3834 bfd_size_type amt = sizeof (* ret);
3836 ret = bfd_malloc (amt);
3840 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3841 elf32_mn10300_link_hash_newfunc,
3842 sizeof (struct elf32_mn10300_link_hash_entry)))
3849 amt = sizeof (struct elf_link_hash_table);
3850 ret->static_hash_table = bfd_malloc (amt);
3851 if (ret->static_hash_table == NULL)
3857 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
3858 elf32_mn10300_link_hash_newfunc,
3859 sizeof (struct elf32_mn10300_link_hash_entry)))
3861 free (ret->static_hash_table);
3865 return & ret->root.root;
3868 /* Free an mn10300 ELF linker hash table. */
3871 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
3873 struct elf32_mn10300_link_hash_table *ret
3874 = (struct elf32_mn10300_link_hash_table *) hash;
3876 _bfd_generic_link_hash_table_free
3877 ((struct bfd_link_hash_table *) ret->static_hash_table);
3878 _bfd_generic_link_hash_table_free
3879 ((struct bfd_link_hash_table *) ret);
3882 static unsigned long
3883 elf_mn10300_mach (flagword flags)
3885 switch (flags & EF_MN10300_MACH)
3887 case E_MN10300_MACH_MN10300:
3889 return bfd_mach_mn10300;
3891 case E_MN10300_MACH_AM33:
3892 return bfd_mach_am33;
3894 case E_MN10300_MACH_AM33_2:
3895 return bfd_mach_am33_2;
3899 /* The final processing done just before writing out a MN10300 ELF object
3900 file. This gets the MN10300 architecture right based on the machine
3904 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
3905 bfd_boolean linker ATTRIBUTE_UNUSED)
3909 switch (bfd_get_mach (abfd))
3912 case bfd_mach_mn10300:
3913 val = E_MN10300_MACH_MN10300;
3917 val = E_MN10300_MACH_AM33;
3920 case bfd_mach_am33_2:
3921 val = E_MN10300_MACH_AM33_2;
3925 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
3926 elf_elfheader (abfd)->e_flags |= val;
3930 _bfd_mn10300_elf_object_p (bfd *abfd)
3932 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
3933 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
3937 /* Merge backend specific data from an object file to the output
3938 object file when linking. */
3941 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3943 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3944 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3947 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3948 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
3950 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3951 bfd_get_mach (ibfd)))
3958 #define PLT0_ENTRY_SIZE 15
3959 #define PLT_ENTRY_SIZE 20
3960 #define PIC_PLT_ENTRY_SIZE 24
3962 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
3964 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
3965 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
3966 0xf0, 0xf4, /* jmp (a0) */
3969 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
3971 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
3972 0xf0, 0xf4, /* jmp (a0) */
3973 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
3974 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
3977 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
3979 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
3980 0xf0, 0xf4, /* jmp (a0) */
3981 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
3982 0xf8, 0x22, 8, /* mov (8,a2),a0 */
3983 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
3984 0xf0, 0xf4, /* jmp (a0) */
3987 /* Return size of the first PLT entry. */
3988 #define elf_mn10300_sizeof_plt0(info) \
3989 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
3991 /* Return size of a PLT entry. */
3992 #define elf_mn10300_sizeof_plt(info) \
3993 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
3995 /* Return offset of the PLT0 address in an absolute PLT entry. */
3996 #define elf_mn10300_plt_plt0_offset(info) 16
3998 /* Return offset of the linker in PLT0 entry. */
3999 #define elf_mn10300_plt0_linker_offset(info) 2
4001 /* Return offset of the GOT id in PLT0 entry. */
4002 #define elf_mn10300_plt0_gotid_offset(info) 9
4004 /* Return offset of the temporary in PLT entry. */
4005 #define elf_mn10300_plt_temp_offset(info) 8
4007 /* Return offset of the symbol in PLT entry. */
4008 #define elf_mn10300_plt_symbol_offset(info) 2
4010 /* Return offset of the relocation in PLT entry. */
4011 #define elf_mn10300_plt_reloc_offset(info) 11
4013 /* The name of the dynamic interpreter. This is put in the .interp
4016 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4018 /* Create dynamic sections when linking against a dynamic object. */
4021 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4025 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4028 switch (bed->s->arch_size)
4039 bfd_set_error (bfd_error_bad_value);
4043 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4044 .rel[a].bss sections. */
4045 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4046 | SEC_LINKER_CREATED);
4048 s = bfd_make_section_with_flags (abfd,
4049 (bed->default_use_rela_p
4050 ? ".rela.plt" : ".rel.plt"),
4051 flags | SEC_READONLY);
4053 || ! bfd_set_section_alignment (abfd, s, ptralign))
4056 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4060 const char * secname;
4065 for (sec = abfd->sections; sec; sec = sec->next)
4067 secflags = bfd_get_section_flags (abfd, sec);
4068 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4069 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4072 secname = bfd_get_section_name (abfd, sec);
4073 relname = bfd_malloc (strlen (secname) + 6);
4074 strcpy (relname, ".rela");
4075 strcat (relname, secname);
4077 s = bfd_make_section_with_flags (abfd, relname,
4078 flags | SEC_READONLY);
4080 || ! bfd_set_section_alignment (abfd, s, ptralign))
4085 if (bed->want_dynbss)
4087 /* The .dynbss section is a place to put symbols which are defined
4088 by dynamic objects, are referenced by regular objects, and are
4089 not functions. We must allocate space for them in the process
4090 image and use a R_*_COPY reloc to tell the dynamic linker to
4091 initialize them at run time. The linker script puts the .dynbss
4092 section into the .bss section of the final image. */
4093 s = bfd_make_section_with_flags (abfd, ".dynbss",
4094 SEC_ALLOC | SEC_LINKER_CREATED);
4098 /* The .rel[a].bss section holds copy relocs. This section is not
4099 normally needed. We need to create it here, though, so that the
4100 linker will map it to an output section. We can't just create it
4101 only if we need it, because we will not know whether we need it
4102 until we have seen all the input files, and the first time the
4103 main linker code calls BFD after examining all the input files
4104 (size_dynamic_sections) the input sections have already been
4105 mapped to the output sections. If the section turns out not to
4106 be needed, we can discard it later. We will never need this
4107 section when generating a shared object, since they do not use
4111 s = bfd_make_section_with_flags (abfd,
4112 (bed->default_use_rela_p
4113 ? ".rela.bss" : ".rel.bss"),
4114 flags | SEC_READONLY);
4116 || ! bfd_set_section_alignment (abfd, s, ptralign))
4124 /* Adjust a symbol defined by a dynamic object and referenced by a
4125 regular object. The current definition is in some section of the
4126 dynamic object, but we're not including those sections. We have to
4127 change the definition to something the rest of the link can
4131 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4132 struct elf_link_hash_entry * h)
4137 dynobj = elf_hash_table (info)->dynobj;
4139 /* Make sure we know what is going on here. */
4140 BFD_ASSERT (dynobj != NULL
4142 || h->u.weakdef != NULL
4145 && !h->def_regular)));
4147 /* If this is a function, put it in the procedure linkage table. We
4148 will fill in the contents of the procedure linkage table later,
4149 when we know the address of the .got section. */
4150 if (h->type == STT_FUNC
4157 /* This case can occur if we saw a PLT reloc in an input
4158 file, but the symbol was never referred to by a dynamic
4159 object. In such a case, we don't actually need to build
4160 a procedure linkage table, and we can just do a REL32
4162 BFD_ASSERT (h->needs_plt);
4166 /* Make sure this symbol is output as a dynamic symbol. */
4167 if (h->dynindx == -1)
4169 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4173 s = bfd_get_section_by_name (dynobj, ".plt");
4174 BFD_ASSERT (s != NULL);
4176 /* If this is the first .plt entry, make room for the special
4179 s->size += elf_mn10300_sizeof_plt0 (info);
4181 /* If this symbol is not defined in a regular file, and we are
4182 not generating a shared library, then set the symbol to this
4183 location in the .plt. This is required to make function
4184 pointers compare as equal between the normal executable and
4185 the shared library. */
4189 h->root.u.def.section = s;
4190 h->root.u.def.value = s->size;
4193 h->plt.offset = s->size;
4195 /* Make room for this entry. */
4196 s->size += elf_mn10300_sizeof_plt (info);
4198 /* We also need to make an entry in the .got.plt section, which
4199 will be placed in the .got section by the linker script. */
4200 s = bfd_get_section_by_name (dynobj, ".got.plt");
4201 BFD_ASSERT (s != NULL);
4204 /* We also need to make an entry in the .rela.plt section. */
4205 s = bfd_get_section_by_name (dynobj, ".rela.plt");
4206 BFD_ASSERT (s != NULL);
4207 s->size += sizeof (Elf32_External_Rela);
4212 /* If this is a weak symbol, and there is a real definition, the
4213 processor independent code will have arranged for us to see the
4214 real definition first, and we can just use the same value. */
4215 if (h->u.weakdef != NULL)
4217 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4218 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4219 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4220 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4224 /* This is a reference to a symbol defined by a dynamic object which
4225 is not a function. */
4227 /* If we are creating a shared library, we must presume that the
4228 only references to the symbol are via the global offset table.
4229 For such cases we need not do anything here; the relocations will
4230 be handled correctly by relocate_section. */
4234 /* If there are no references to this symbol that do not use the
4235 GOT, we don't need to generate a copy reloc. */
4236 if (!h->non_got_ref)
4241 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4242 h->root.root.string);
4246 /* We must allocate the symbol in our .dynbss section, which will
4247 become part of the .bss section of the executable. There will be
4248 an entry for this symbol in the .dynsym section. The dynamic
4249 object will contain position independent code, so all references
4250 from the dynamic object to this symbol will go through the global
4251 offset table. The dynamic linker will use the .dynsym entry to
4252 determine the address it must put in the global offset table, so
4253 both the dynamic object and the regular object will refer to the
4254 same memory location for the variable. */
4256 s = bfd_get_section_by_name (dynobj, ".dynbss");
4257 BFD_ASSERT (s != NULL);
4259 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4260 copy the initial value out of the dynamic object and into the
4261 runtime process image. We need to remember the offset into the
4262 .rela.bss section we are going to use. */
4263 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4267 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4268 BFD_ASSERT (srel != NULL);
4269 srel->size += sizeof (Elf32_External_Rela);
4273 return _bfd_elf_adjust_dynamic_copy (h, s);
4276 /* Set the sizes of the dynamic sections. */
4279 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4280 struct bfd_link_info * info)
4286 bfd_boolean reltext;
4288 dynobj = elf_hash_table (info)->dynobj;
4289 BFD_ASSERT (dynobj != NULL);
4291 if (elf_hash_table (info)->dynamic_sections_created)
4293 /* Set the contents of the .interp section to the interpreter. */
4294 if (info->executable)
4296 s = bfd_get_section_by_name (dynobj, ".interp");
4297 BFD_ASSERT (s != NULL);
4298 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4299 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4304 /* We may have created entries in the .rela.got section.
4305 However, if we are not creating the dynamic sections, we will
4306 not actually use these entries. Reset the size of .rela.got,
4307 which will cause it to get stripped from the output file
4309 s = bfd_get_section_by_name (dynobj, ".rela.got");
4314 /* The check_relocs and adjust_dynamic_symbol entry points have
4315 determined the sizes of the various dynamic sections. Allocate
4320 for (s = dynobj->sections; s != NULL; s = s->next)
4324 if ((s->flags & SEC_LINKER_CREATED) == 0)
4327 /* It's OK to base decisions on the section name, because none
4328 of the dynobj section names depend upon the input files. */
4329 name = bfd_get_section_name (dynobj, s);
4331 if (streq (name, ".plt"))
4333 /* Remember whether there is a PLT. */
4336 else if (CONST_STRNEQ (name, ".rela"))
4342 /* Remember whether there are any reloc sections other
4344 if (! streq (name, ".rela.plt"))
4346 const char * outname;
4350 /* If this relocation section applies to a read only
4351 section, then we probably need a DT_TEXTREL
4352 entry. The entries in the .rela.plt section
4353 really apply to the .got section, which we
4354 created ourselves and so know is not readonly. */
4355 outname = bfd_get_section_name (output_bfd,
4357 target = bfd_get_section_by_name (output_bfd, outname + 5);
4359 && (target->flags & SEC_READONLY) != 0
4360 && (target->flags & SEC_ALLOC) != 0)
4364 /* We use the reloc_count field as a counter if we need
4365 to copy relocs into the output file. */
4369 else if (! CONST_STRNEQ (name, ".got")
4370 && ! streq (name, ".dynbss"))
4371 /* It's not one of our sections, so don't allocate space. */
4376 /* If we don't need this section, strip it from the
4377 output file. This is mostly to handle .rela.bss and
4378 .rela.plt. We must create both sections in
4379 create_dynamic_sections, because they must be created
4380 before the linker maps input sections to output
4381 sections. The linker does that before
4382 adjust_dynamic_symbol is called, and it is that
4383 function which decides whether anything needs to go
4384 into these sections. */
4385 s->flags |= SEC_EXCLUDE;
4389 if ((s->flags & SEC_HAS_CONTENTS) == 0)
4392 /* Allocate memory for the section contents. We use bfd_zalloc
4393 here in case unused entries are not reclaimed before the
4394 section's contents are written out. This should not happen,
4395 but this way if it does, we get a R_MN10300_NONE reloc
4396 instead of garbage. */
4397 s->contents = bfd_zalloc (dynobj, s->size);
4398 if (s->contents == NULL)
4402 if (elf_hash_table (info)->dynamic_sections_created)
4404 /* Add some entries to the .dynamic section. We fill in the
4405 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4406 but we must add the entries now so that we get the correct
4407 size for the .dynamic section. The DT_DEBUG entry is filled
4408 in by the dynamic linker and used by the debugger. */
4411 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
4417 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4418 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4419 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4420 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4426 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4427 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4428 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4429 sizeof (Elf32_External_Rela)))
4435 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
4443 /* Finish up dynamic symbol handling. We set the contents of various
4444 dynamic sections here. */
4447 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4448 struct bfd_link_info * info,
4449 struct elf_link_hash_entry * h,
4450 Elf_Internal_Sym * sym)
4454 dynobj = elf_hash_table (info)->dynobj;
4456 if (h->plt.offset != (bfd_vma) -1)
4463 Elf_Internal_Rela rel;
4465 /* This symbol has an entry in the procedure linkage table. Set
4468 BFD_ASSERT (h->dynindx != -1);
4470 splt = bfd_get_section_by_name (dynobj, ".plt");
4471 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4472 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4473 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4475 /* Get the index in the procedure linkage table which
4476 corresponds to this symbol. This is the index of this symbol
4477 in all the symbols for which we are making plt entries. The
4478 first entry in the procedure linkage table is reserved. */
4479 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4480 / elf_mn10300_sizeof_plt (info));
4482 /* Get the offset into the .got table of the entry that
4483 corresponds to this function. Each .got entry is 4 bytes.
4484 The first three are reserved. */
4485 got_offset = (plt_index + 3) * 4;
4487 /* Fill in the entry in the procedure linkage table. */
4490 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4491 elf_mn10300_sizeof_plt (info));
4492 bfd_put_32 (output_bfd,
4493 (sgot->output_section->vma
4494 + sgot->output_offset
4496 (splt->contents + h->plt.offset
4497 + elf_mn10300_plt_symbol_offset (info)));
4499 bfd_put_32 (output_bfd,
4500 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4501 (splt->contents + h->plt.offset
4502 + elf_mn10300_plt_plt0_offset (info)));
4506 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4507 elf_mn10300_sizeof_plt (info));
4509 bfd_put_32 (output_bfd, got_offset,
4510 (splt->contents + h->plt.offset
4511 + elf_mn10300_plt_symbol_offset (info)));
4514 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4515 (splt->contents + h->plt.offset
4516 + elf_mn10300_plt_reloc_offset (info)));
4518 /* Fill in the entry in the global offset table. */
4519 bfd_put_32 (output_bfd,
4520 (splt->output_section->vma
4521 + splt->output_offset
4523 + elf_mn10300_plt_temp_offset (info)),
4524 sgot->contents + got_offset);
4526 /* Fill in the entry in the .rela.plt section. */
4527 rel.r_offset = (sgot->output_section->vma
4528 + sgot->output_offset
4530 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4532 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4533 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4536 if (!h->def_regular)
4537 /* Mark the symbol as undefined, rather than as defined in
4538 the .plt section. Leave the value alone. */
4539 sym->st_shndx = SHN_UNDEF;
4542 if (h->got.offset != (bfd_vma) -1)
4546 Elf_Internal_Rela rel;
4548 /* This symbol has an entry in the global offset table. Set it up. */
4549 sgot = bfd_get_section_by_name (dynobj, ".got");
4550 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4551 BFD_ASSERT (sgot != NULL && srel != NULL);
4553 rel.r_offset = (sgot->output_section->vma
4554 + sgot->output_offset
4555 + (h->got.offset & ~1));
4557 /* If this is a -Bsymbolic link, and the symbol is defined
4558 locally, we just want to emit a RELATIVE reloc. Likewise if
4559 the symbol was forced to be local because of a version file.
4560 The entry in the global offset table will already have been
4561 initialized in the relocate_section function. */
4563 && (info->symbolic || h->dynindx == -1)
4566 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4567 rel.r_addend = (h->root.u.def.value
4568 + h->root.u.def.section->output_section->vma
4569 + h->root.u.def.section->output_offset);
4573 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4574 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4578 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4579 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4580 + srel->reloc_count));
4581 ++ srel->reloc_count;
4587 Elf_Internal_Rela rel;
4589 /* This symbol needs a copy reloc. Set it up. */
4590 BFD_ASSERT (h->dynindx != -1
4591 && (h->root.type == bfd_link_hash_defined
4592 || h->root.type == bfd_link_hash_defweak));
4594 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4596 BFD_ASSERT (s != NULL);
4598 rel.r_offset = (h->root.u.def.value
4599 + h->root.u.def.section->output_section->vma
4600 + h->root.u.def.section->output_offset);
4601 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4603 bfd_elf32_swap_reloca_out (output_bfd, & rel,
4604 (bfd_byte *) ((Elf32_External_Rela *) s->contents
4609 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4610 if (streq (h->root.root.string, "_DYNAMIC")
4611 || h == elf_hash_table (info)->hgot)
4612 sym->st_shndx = SHN_ABS;
4617 /* Finish up the dynamic sections. */
4620 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4621 struct bfd_link_info * info)
4627 dynobj = elf_hash_table (info)->dynobj;
4629 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4630 BFD_ASSERT (sgot != NULL);
4631 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4633 if (elf_hash_table (info)->dynamic_sections_created)
4636 Elf32_External_Dyn * dyncon;
4637 Elf32_External_Dyn * dynconend;
4639 BFD_ASSERT (sdyn != NULL);
4641 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4642 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4644 for (; dyncon < dynconend; dyncon++)
4646 Elf_Internal_Dyn dyn;
4650 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4664 s = bfd_get_section_by_name (output_bfd, name);
4665 BFD_ASSERT (s != NULL);
4666 dyn.d_un.d_ptr = s->vma;
4667 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4671 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4672 BFD_ASSERT (s != NULL);
4673 dyn.d_un.d_val = s->size;
4674 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4678 /* My reading of the SVR4 ABI indicates that the
4679 procedure linkage table relocs (DT_JMPREL) should be
4680 included in the overall relocs (DT_RELA). This is
4681 what Solaris does. However, UnixWare can not handle
4682 that case. Therefore, we override the DT_RELASZ entry
4683 here to make it not include the JMPREL relocs. Since
4684 the linker script arranges for .rela.plt to follow all
4685 other relocation sections, we don't have to worry
4686 about changing the DT_RELA entry. */
4687 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4689 dyn.d_un.d_val -= s->size;
4690 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4695 /* Fill in the first entry in the procedure linkage table. */
4696 splt = bfd_get_section_by_name (dynobj, ".plt");
4697 if (splt && splt->size > 0)
4701 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4702 elf_mn10300_sizeof_plt (info));
4706 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4707 bfd_put_32 (output_bfd,
4708 sgot->output_section->vma + sgot->output_offset + 4,
4709 splt->contents + elf_mn10300_plt0_gotid_offset (info));
4710 bfd_put_32 (output_bfd,
4711 sgot->output_section->vma + sgot->output_offset + 8,
4712 splt->contents + elf_mn10300_plt0_linker_offset (info));
4715 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4716 really seem like the right value. */
4717 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4721 /* Fill in the first three entries in the global offset table. */
4725 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4727 bfd_put_32 (output_bfd,
4728 sdyn->output_section->vma + sdyn->output_offset,
4730 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4731 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4734 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4739 /* Classify relocation types, such that combreloc can sort them
4742 static enum elf_reloc_type_class
4743 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4745 switch ((int) ELF32_R_TYPE (rela->r_info))
4747 case R_MN10300_RELATIVE: return reloc_class_relative;
4748 case R_MN10300_JMP_SLOT: return reloc_class_plt;
4749 case R_MN10300_COPY: return reloc_class_copy;
4750 default: return reloc_class_normal;
4755 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
4756 #define TARGET_LITTLE_NAME "elf32-mn10300"
4757 #define ELF_ARCH bfd_arch_mn10300
4758 #define ELF_MACHINE_CODE EM_MN10300
4759 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
4760 #define ELF_MAXPAGESIZE 0x1000
4763 #define elf_info_to_howto mn10300_info_to_howto
4764 #define elf_info_to_howto_rel 0
4765 #define elf_backend_can_gc_sections 1
4766 #define elf_backend_rela_normal 1
4767 #define elf_backend_check_relocs mn10300_elf_check_relocs
4768 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
4769 #define elf_backend_relocate_section mn10300_elf_relocate_section
4770 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
4771 #define bfd_elf32_bfd_get_relocated_section_contents \
4772 mn10300_elf_get_relocated_section_contents
4773 #define bfd_elf32_bfd_link_hash_table_create \
4774 elf32_mn10300_link_hash_table_create
4775 #define bfd_elf32_bfd_link_hash_table_free \
4776 elf32_mn10300_link_hash_table_free
4778 #ifndef elf_symbol_leading_char
4779 #define elf_symbol_leading_char '_'
4782 /* So we can set bits in e_flags. */
4783 #define elf_backend_final_write_processing \
4784 _bfd_mn10300_elf_final_write_processing
4785 #define elf_backend_object_p _bfd_mn10300_elf_object_p
4787 #define bfd_elf32_bfd_merge_private_bfd_data \
4788 _bfd_mn10300_elf_merge_private_bfd_data
4790 #define elf_backend_can_gc_sections 1
4791 #define elf_backend_create_dynamic_sections \
4792 _bfd_mn10300_elf_create_dynamic_sections
4793 #define elf_backend_adjust_dynamic_symbol \
4794 _bfd_mn10300_elf_adjust_dynamic_symbol
4795 #define elf_backend_size_dynamic_sections \
4796 _bfd_mn10300_elf_size_dynamic_sections
4797 #define elf_backend_omit_section_dynsym \
4798 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4799 #define elf_backend_finish_dynamic_symbol \
4800 _bfd_mn10300_elf_finish_dynamic_symbol
4801 #define elf_backend_finish_dynamic_sections \
4802 _bfd_mn10300_elf_finish_dynamic_sections
4804 #define elf_backend_reloc_type_class \
4805 _bfd_mn10300_elf_reloc_type_class
4807 #define elf_backend_want_got_plt 1
4808 #define elf_backend_plt_readonly 1
4809 #define elf_backend_want_plt_sym 0
4810 #define elf_backend_got_header_size 12
4812 #include "elf32-target.h"