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 */
474 HOWTO (R_MN10300_ALIGN, /* type */
476 0, /* size (0 = byte, 1 = short, 2 = long) */
478 FALSE, /* pc_relative */
480 complain_overflow_dont,/* complain_on_overflow */
481 NULL, /* special handler. */
482 "R_MN10300_ALIGN", /* name */
483 FALSE, /* partial_inplace */
486 FALSE) /* pcrel_offset */
489 struct mn10300_reloc_map
491 bfd_reloc_code_real_type bfd_reloc_val;
492 unsigned char elf_reloc_val;
495 static const struct mn10300_reloc_map mn10300_reloc_map[] =
497 { BFD_RELOC_NONE, R_MN10300_NONE, },
498 { BFD_RELOC_32, R_MN10300_32, },
499 { BFD_RELOC_16, R_MN10300_16, },
500 { BFD_RELOC_8, R_MN10300_8, },
501 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
502 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
503 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
504 { BFD_RELOC_24, R_MN10300_24, },
505 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
506 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
507 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
508 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
509 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
510 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
511 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
512 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
513 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
514 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
515 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
516 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
517 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
518 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
519 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
520 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
521 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
522 { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
525 /* Create the GOT section. */
528 _bfd_mn10300_elf_create_got_section (bfd * abfd,
529 struct bfd_link_info * info)
534 struct elf_link_hash_entry * h;
535 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
538 /* This function may be called more than once. */
539 if (bfd_get_section_by_name (abfd, ".got") != NULL)
542 switch (bed->s->arch_size)
553 bfd_set_error (bfd_error_bad_value);
557 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
558 | SEC_LINKER_CREATED);
561 pltflags |= SEC_CODE;
562 if (bed->plt_not_loaded)
563 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
564 if (bed->plt_readonly)
565 pltflags |= SEC_READONLY;
567 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
569 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
572 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
574 if (bed->want_plt_sym)
576 h = _bfd_elf_define_linkage_sym (abfd, info, s,
577 "_PROCEDURE_LINKAGE_TABLE_");
578 elf_hash_table (info)->hplt = h;
583 s = bfd_make_section_with_flags (abfd, ".got", flags);
585 || ! bfd_set_section_alignment (abfd, s, ptralign))
588 if (bed->want_got_plt)
590 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
592 || ! bfd_set_section_alignment (abfd, s, ptralign))
596 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
597 (or .got.plt) section. We don't do this in the linker script
598 because we don't want to define the symbol if we are not creating
599 a global offset table. */
600 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
601 elf_hash_table (info)->hgot = h;
605 /* The first bit of the global offset table is the header. */
606 s->size += bed->got_header_size;
611 static reloc_howto_type *
612 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
613 bfd_reloc_code_real_type code)
617 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
618 if (mn10300_reloc_map[i].bfd_reloc_val == code)
619 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
624 static reloc_howto_type *
625 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
630 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
631 if (elf_mn10300_howto_table[i].name != NULL
632 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
633 return elf_mn10300_howto_table + i;
638 /* Set the howto pointer for an MN10300 ELF reloc. */
641 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
643 Elf_Internal_Rela *dst)
647 r_type = ELF32_R_TYPE (dst->r_info);
648 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
649 cache_ptr->howto = elf_mn10300_howto_table + r_type;
652 /* Look through the relocs for a section during the first phase.
653 Since we don't do .gots or .plts, we just need to consider the
654 virtual table relocs for gc. */
657 mn10300_elf_check_relocs (bfd *abfd,
658 struct bfd_link_info *info,
660 const Elf_Internal_Rela *relocs)
662 bfd_boolean sym_diff_reloc_seen;
663 Elf_Internal_Shdr *symtab_hdr;
664 Elf_Internal_Sym * isymbuf = NULL;
665 struct elf_link_hash_entry **sym_hashes;
666 const Elf_Internal_Rela *rel;
667 const Elf_Internal_Rela *rel_end;
669 bfd_vma * local_got_offsets;
673 bfd_boolean result = FALSE;
679 if (info->relocatable)
682 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
683 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
684 sym_hashes = elf_sym_hashes (abfd);
686 dynobj = elf_hash_table (info)->dynobj;
687 local_got_offsets = elf_local_got_offsets (abfd);
688 rel_end = relocs + sec->reloc_count;
689 sym_diff_reloc_seen = FALSE;
691 for (rel = relocs; rel < rel_end; rel++)
693 struct elf_link_hash_entry *h;
694 unsigned long r_symndx;
697 r_symndx = ELF32_R_SYM (rel->r_info);
698 if (r_symndx < symtab_hdr->sh_info)
702 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
703 while (h->root.type == bfd_link_hash_indirect
704 || h->root.type == bfd_link_hash_warning)
705 h = (struct elf_link_hash_entry *) h->root.u.i.link;
708 r_type = ELF32_R_TYPE (rel->r_info);
710 /* Some relocs require a global offset table. */
715 case R_MN10300_GOT32:
716 case R_MN10300_GOT24:
717 case R_MN10300_GOT16:
718 case R_MN10300_GOTOFF32:
719 case R_MN10300_GOTOFF24:
720 case R_MN10300_GOTOFF16:
721 case R_MN10300_GOTPC32:
722 case R_MN10300_GOTPC16:
723 elf_hash_table (info)->dynobj = dynobj = abfd;
724 if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
735 /* This relocation describes the C++ object vtable hierarchy.
736 Reconstruct it for later use during GC. */
737 case R_MN10300_GNU_VTINHERIT:
738 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
742 /* This relocation describes which C++ vtable entries are actually
743 used. Record for later use during GC. */
744 case R_MN10300_GNU_VTENTRY:
745 BFD_ASSERT (h != NULL);
747 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
751 case R_MN10300_GOT32:
752 case R_MN10300_GOT24:
753 case R_MN10300_GOT16:
754 /* This symbol requires a global offset table entry. */
758 sgot = bfd_get_section_by_name (dynobj, ".got");
759 BFD_ASSERT (sgot != NULL);
763 && (h != NULL || info->shared))
765 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
768 srelgot = bfd_make_section_with_flags (dynobj,
777 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
784 if (h->got.offset != (bfd_vma) -1)
785 /* We have already allocated space in the .got. */
788 h->got.offset = sgot->size;
790 /* Make sure this symbol is output as a dynamic symbol. */
791 if (h->dynindx == -1)
793 if (! bfd_elf_link_record_dynamic_symbol (info, h))
797 srelgot->size += sizeof (Elf32_External_Rela);
801 /* This is a global offset table entry for a local
803 if (local_got_offsets == NULL)
808 size = symtab_hdr->sh_info * sizeof (bfd_vma);
809 local_got_offsets = bfd_alloc (abfd, size);
811 if (local_got_offsets == NULL)
814 elf_local_got_offsets (abfd) = local_got_offsets;
816 for (i = 0; i < symtab_hdr->sh_info; i++)
817 local_got_offsets[i] = (bfd_vma) -1;
820 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
821 /* We have already allocated space in the .got. */
824 local_got_offsets[r_symndx] = sgot->size;
827 /* If we are generating a shared object, we need to
828 output a R_MN10300_RELATIVE reloc so that the dynamic
829 linker can adjust this GOT entry. */
830 srelgot->size += sizeof (Elf32_External_Rela);
836 case R_MN10300_PLT32:
837 case R_MN10300_PLT16:
838 /* This symbol requires a procedure linkage table entry. We
839 actually build the entry in adjust_dynamic_symbol,
840 because this might be a case of linking PIC code which is
841 never referenced by a dynamic object, in which case we
842 don't need to generate a procedure linkage table entry
845 /* If this is a local symbol, we resolve it directly without
846 creating a procedure linkage table entry. */
850 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
851 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
860 case R_MN10300_PCREL32:
861 case R_MN10300_PCREL16:
862 case R_MN10300_PCREL8:
867 case R_MN10300_SYM_DIFF:
868 sym_diff_reloc_seen = TRUE;
875 /* If we are creating a shared library, then we
876 need to copy the reloc into the shared library. */
878 && (sec->flags & SEC_ALLOC) != 0
879 /* Do not generate a dynamic reloc for a
880 reloc associated with a SYM_DIFF operation. */
881 && ! sym_diff_reloc_seen)
883 asection * sym_section = NULL;
885 /* Find the section containing the
886 symbol involved in the relocation. */
889 Elf_Internal_Sym * isym;
892 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
893 symtab_hdr->sh_info, 0,
897 isym = isymbuf + r_symndx;
898 /* All we care about is whether this local symbol is absolute. */
899 if (isym->st_shndx == SHN_ABS)
900 sym_section = bfd_abs_section_ptr;
905 if (h->root.type == bfd_link_hash_defined
906 || h->root.type == bfd_link_hash_defweak)
907 sym_section = h->root.u.def.section;
910 /* If the symbol is absolute then the relocation can
911 be resolved during linking and there is no need for
913 if (sym_section != bfd_abs_section_ptr)
915 /* When creating a shared object, we must copy these
916 reloc types into the output file. We create a reloc
917 section in dynobj and make room for this reloc. */
922 name = (bfd_elf_string_from_elf_section
924 elf_elfheader (abfd)->e_shstrndx,
925 elf_section_data (sec)->rel_hdr.sh_name));
929 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
930 && streq (bfd_get_section_name (abfd, sec), name + 5));
932 sreloc = bfd_get_section_by_name (dynobj, name);
937 flags = (SEC_HAS_CONTENTS | SEC_READONLY
938 | SEC_IN_MEMORY | SEC_LINKER_CREATED);
939 if ((sec->flags & SEC_ALLOC) != 0)
940 flags |= SEC_ALLOC | SEC_LOAD;
941 sreloc = bfd_make_section_with_flags (dynobj, name, flags);
943 || ! bfd_set_section_alignment (dynobj, sreloc, 2))
948 sreloc->size += sizeof (Elf32_External_Rela);
955 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
956 sym_diff_reloc_seen = FALSE;
967 /* Return the section that should be marked against GC for a given
971 mn10300_elf_gc_mark_hook (asection *sec,
972 struct bfd_link_info *info,
973 Elf_Internal_Rela *rel,
974 struct elf_link_hash_entry *h,
975 Elf_Internal_Sym *sym)
978 switch (ELF32_R_TYPE (rel->r_info))
980 case R_MN10300_GNU_VTINHERIT:
981 case R_MN10300_GNU_VTENTRY:
985 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
988 /* Perform a relocation as part of a final link. */
990 static bfd_reloc_status_type
991 mn10300_elf_final_link_relocate (reloc_howto_type *howto,
993 bfd *output_bfd ATTRIBUTE_UNUSED,
994 asection *input_section,
999 struct elf_link_hash_entry * h,
1000 unsigned long symndx,
1001 struct bfd_link_info *info,
1002 asection *sym_sec ATTRIBUTE_UNUSED,
1003 int is_local ATTRIBUTE_UNUSED)
1005 static asection * sym_diff_section;
1006 static bfd_vma sym_diff_value;
1007 bfd_boolean is_sym_diff_reloc;
1008 unsigned long r_type = howto->type;
1009 bfd_byte * hit_data = contents + offset;
1011 bfd_vma * local_got_offsets;
1016 dynobj = elf_hash_table (info)->dynobj;
1017 local_got_offsets = elf_local_got_offsets (input_bfd);
1028 case R_MN10300_PCREL8:
1029 case R_MN10300_PCREL16:
1030 case R_MN10300_PCREL32:
1031 case R_MN10300_GOTOFF32:
1032 case R_MN10300_GOTOFF24:
1033 case R_MN10300_GOTOFF16:
1035 && (input_section->flags & SEC_ALLOC) != 0
1037 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1038 return bfd_reloc_dangerous;
1041 is_sym_diff_reloc = FALSE;
1042 if (sym_diff_section != NULL)
1044 BFD_ASSERT (sym_diff_section == input_section);
1052 value -= sym_diff_value;
1053 /* If we are computing a 32-bit value for the location lists
1054 and the result is 0 then we add one to the value. A zero
1055 value can result because of linker relaxation deleteing
1056 prologue instructions and using a value of 1 (for the begin
1057 and end offsets in the location list entry) results in a
1058 nul entry which does not prevent the following entries from
1060 if (r_type == R_MN10300_32
1062 && strcmp (input_section->name, ".debug_loc") == 0)
1064 sym_diff_section = NULL;
1065 is_sym_diff_reloc = TRUE;
1069 sym_diff_section = NULL;
1076 case R_MN10300_SYM_DIFF:
1077 BFD_ASSERT (addend == 0);
1078 /* Cache the input section and value.
1079 The offset is unreliable, since relaxation may
1080 have reduced the following reloc's offset. */
1081 sym_diff_section = input_section;
1082 sym_diff_value = value;
1083 return bfd_reloc_ok;
1085 case R_MN10300_ALIGN:
1086 case R_MN10300_NONE:
1087 return bfd_reloc_ok;
1091 /* Do not generate relocs when an R_MN10300_32 has been used
1092 with an R_MN10300_SYM_DIFF to compute a difference of two
1094 && is_sym_diff_reloc == FALSE
1095 /* Also, do not generate a reloc when the symbol associated
1096 with the R_MN10300_32 reloc is absolute - there is no
1097 need for a run time computation in this case. */
1098 && sym_sec != bfd_abs_section_ptr
1099 /* If the section is not going to be allocated at load time
1100 then there is no need to generate relocs for it. */
1101 && (input_section->flags & SEC_ALLOC) != 0)
1103 Elf_Internal_Rela outrel;
1104 bfd_boolean skip, relocate;
1106 /* When generating a shared object, these relocations are
1107 copied into the output file to be resolved at run
1113 name = (bfd_elf_string_from_elf_section
1115 elf_elfheader (input_bfd)->e_shstrndx,
1116 elf_section_data (input_section)->rel_hdr.sh_name));
1120 BFD_ASSERT (CONST_STRNEQ (name, ".rela")
1121 && streq (bfd_get_section_name (input_bfd,
1125 sreloc = bfd_get_section_by_name (dynobj, name);
1126 BFD_ASSERT (sreloc != NULL);
1131 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1132 input_section, offset);
1133 if (outrel.r_offset == (bfd_vma) -1)
1136 outrel.r_offset += (input_section->output_section->vma
1137 + input_section->output_offset);
1141 memset (&outrel, 0, sizeof outrel);
1146 /* h->dynindx may be -1 if this symbol was marked to
1149 || SYMBOL_REFERENCES_LOCAL (info, h))
1152 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1153 outrel.r_addend = value + addend;
1157 BFD_ASSERT (h->dynindx != -1);
1159 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1160 outrel.r_addend = value + addend;
1164 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1165 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1166 + sreloc->reloc_count));
1167 ++sreloc->reloc_count;
1169 /* If this reloc is against an external symbol, we do
1170 not want to fiddle with the addend. Otherwise, we
1171 need to include the symbol value so that it becomes
1172 an addend for the dynamic reloc. */
1174 return bfd_reloc_ok;
1177 bfd_put_32 (input_bfd, value, hit_data);
1178 return bfd_reloc_ok;
1183 if ((long) value > 0x7fffff || (long) value < -0x800000)
1184 return bfd_reloc_overflow;
1186 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1187 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1188 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1189 return bfd_reloc_ok;
1194 if ((long) value > 0x7fff || (long) value < -0x8000)
1195 return bfd_reloc_overflow;
1197 bfd_put_16 (input_bfd, value, hit_data);
1198 return bfd_reloc_ok;
1203 if ((long) value > 0x7f || (long) value < -0x80)
1204 return bfd_reloc_overflow;
1206 bfd_put_8 (input_bfd, value, hit_data);
1207 return bfd_reloc_ok;
1209 case R_MN10300_PCREL8:
1210 value -= (input_section->output_section->vma
1211 + input_section->output_offset);
1215 if ((long) value > 0xff || (long) value < -0x100)
1216 return bfd_reloc_overflow;
1218 bfd_put_8 (input_bfd, value, hit_data);
1219 return bfd_reloc_ok;
1221 case R_MN10300_PCREL16:
1222 value -= (input_section->output_section->vma
1223 + input_section->output_offset);
1227 if ((long) value > 0xffff || (long) value < -0x10000)
1228 return bfd_reloc_overflow;
1230 bfd_put_16 (input_bfd, value, hit_data);
1231 return bfd_reloc_ok;
1233 case R_MN10300_PCREL32:
1234 value -= (input_section->output_section->vma
1235 + input_section->output_offset);
1239 bfd_put_32 (input_bfd, value, hit_data);
1240 return bfd_reloc_ok;
1242 case R_MN10300_GNU_VTINHERIT:
1243 case R_MN10300_GNU_VTENTRY:
1244 return bfd_reloc_ok;
1246 case R_MN10300_GOTPC32:
1247 /* Use global offset table as symbol value. */
1248 value = bfd_get_section_by_name (dynobj,
1249 ".got")->output_section->vma;
1250 value -= (input_section->output_section->vma
1251 + input_section->output_offset);
1255 bfd_put_32 (input_bfd, value, hit_data);
1256 return bfd_reloc_ok;
1258 case R_MN10300_GOTPC16:
1259 /* Use global offset table as symbol value. */
1260 value = bfd_get_section_by_name (dynobj,
1261 ".got")->output_section->vma;
1262 value -= (input_section->output_section->vma
1263 + input_section->output_offset);
1267 if ((long) value > 0xffff || (long) value < -0x10000)
1268 return bfd_reloc_overflow;
1270 bfd_put_16 (input_bfd, value, hit_data);
1271 return bfd_reloc_ok;
1273 case R_MN10300_GOTOFF32:
1274 value -= bfd_get_section_by_name (dynobj,
1275 ".got")->output_section->vma;
1278 bfd_put_32 (input_bfd, value, hit_data);
1279 return bfd_reloc_ok;
1281 case R_MN10300_GOTOFF24:
1282 value -= bfd_get_section_by_name (dynobj,
1283 ".got")->output_section->vma;
1286 if ((long) value > 0x7fffff || (long) value < -0x800000)
1287 return bfd_reloc_overflow;
1289 bfd_put_8 (input_bfd, value, hit_data);
1290 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1291 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1292 return bfd_reloc_ok;
1294 case R_MN10300_GOTOFF16:
1295 value -= bfd_get_section_by_name (dynobj,
1296 ".got")->output_section->vma;
1299 if ((long) value > 0xffff || (long) value < -0x10000)
1300 return bfd_reloc_overflow;
1302 bfd_put_16 (input_bfd, value, hit_data);
1303 return bfd_reloc_ok;
1305 case R_MN10300_PLT32:
1307 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1308 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1309 && h->plt.offset != (bfd_vma) -1)
1313 splt = bfd_get_section_by_name (dynobj, ".plt");
1315 value = (splt->output_section->vma
1316 + splt->output_offset
1317 + h->plt.offset) - value;
1320 value -= (input_section->output_section->vma
1321 + input_section->output_offset);
1325 bfd_put_32 (input_bfd, value, hit_data);
1326 return bfd_reloc_ok;
1328 case R_MN10300_PLT16:
1330 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1331 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1332 && h->plt.offset != (bfd_vma) -1)
1336 splt = bfd_get_section_by_name (dynobj, ".plt");
1338 value = (splt->output_section->vma
1339 + splt->output_offset
1340 + h->plt.offset) - value;
1343 value -= (input_section->output_section->vma
1344 + input_section->output_offset);
1348 if ((long) value > 0xffff || (long) value < -0x10000)
1349 return bfd_reloc_overflow;
1351 bfd_put_16 (input_bfd, value, hit_data);
1352 return bfd_reloc_ok;
1354 case R_MN10300_GOT32:
1355 case R_MN10300_GOT24:
1356 case R_MN10300_GOT16:
1360 sgot = bfd_get_section_by_name (dynobj, ".got");
1366 off = h->got.offset;
1367 BFD_ASSERT (off != (bfd_vma) -1);
1369 if (! elf_hash_table (info)->dynamic_sections_created
1370 || SYMBOL_REFERENCES_LOCAL (info, h))
1371 /* This is actually a static link, or it is a
1372 -Bsymbolic link and the symbol is defined
1373 locally, or the symbol was forced to be local
1374 because of a version file. We must initialize
1375 this entry in the global offset table.
1377 When doing a dynamic link, we create a .rela.got
1378 relocation entry to initialize the value. This
1379 is done in the finish_dynamic_symbol routine. */
1380 bfd_put_32 (output_bfd, value,
1381 sgot->contents + off);
1383 value = sgot->output_offset + off;
1389 off = elf_local_got_offsets (input_bfd)[symndx];
1391 bfd_put_32 (output_bfd, value, sgot->contents + off);
1396 Elf_Internal_Rela outrel;
1398 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1399 BFD_ASSERT (srelgot != NULL);
1401 outrel.r_offset = (sgot->output_section->vma
1402 + sgot->output_offset
1404 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1405 outrel.r_addend = value;
1406 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1407 (bfd_byte *) (((Elf32_External_Rela *)
1409 + srelgot->reloc_count));
1410 ++ srelgot->reloc_count;
1413 value = sgot->output_offset + off;
1419 if (r_type == R_MN10300_GOT32)
1421 bfd_put_32 (input_bfd, value, hit_data);
1422 return bfd_reloc_ok;
1424 else if (r_type == R_MN10300_GOT24)
1426 if ((long) value > 0x7fffff || (long) value < -0x800000)
1427 return bfd_reloc_overflow;
1429 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1430 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1431 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1432 return bfd_reloc_ok;
1434 else if (r_type == R_MN10300_GOT16)
1436 if ((long) value > 0xffff || (long) value < -0x10000)
1437 return bfd_reloc_overflow;
1439 bfd_put_16 (input_bfd, value, hit_data);
1440 return bfd_reloc_ok;
1445 return bfd_reloc_notsupported;
1449 /* Relocate an MN10300 ELF section. */
1452 mn10300_elf_relocate_section (bfd *output_bfd,
1453 struct bfd_link_info *info,
1455 asection *input_section,
1457 Elf_Internal_Rela *relocs,
1458 Elf_Internal_Sym *local_syms,
1459 asection **local_sections)
1461 Elf_Internal_Shdr *symtab_hdr;
1462 struct elf_link_hash_entry **sym_hashes;
1463 Elf_Internal_Rela *rel, *relend;
1465 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1466 sym_hashes = elf_sym_hashes (input_bfd);
1469 relend = relocs + input_section->reloc_count;
1470 for (; rel < relend; rel++)
1473 reloc_howto_type *howto;
1474 unsigned long r_symndx;
1475 Elf_Internal_Sym *sym;
1477 struct elf32_mn10300_link_hash_entry *h;
1479 bfd_reloc_status_type r;
1481 r_symndx = ELF32_R_SYM (rel->r_info);
1482 r_type = ELF32_R_TYPE (rel->r_info);
1483 howto = elf_mn10300_howto_table + r_type;
1485 /* Just skip the vtable gc relocs. */
1486 if (r_type == R_MN10300_GNU_VTINHERIT
1487 || r_type == R_MN10300_GNU_VTENTRY)
1493 if (r_symndx < symtab_hdr->sh_info)
1495 sym = local_syms + r_symndx;
1496 sec = local_sections[r_symndx];
1497 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1501 bfd_boolean unresolved_reloc;
1503 struct elf_link_hash_entry *hh;
1505 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1506 r_symndx, symtab_hdr, sym_hashes,
1507 hh, sec, relocation,
1508 unresolved_reloc, warned);
1510 h = (struct elf32_mn10300_link_hash_entry *) hh;
1512 if ((h->root.root.type == bfd_link_hash_defined
1513 || h->root.root.type == bfd_link_hash_defweak)
1514 && ( r_type == R_MN10300_GOTPC32
1515 || r_type == R_MN10300_GOTPC16
1516 || (( r_type == R_MN10300_PLT32
1517 || r_type == R_MN10300_PLT16)
1518 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1519 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1520 && h->root.plt.offset != (bfd_vma) -1)
1521 || (( r_type == R_MN10300_GOT32
1522 || r_type == R_MN10300_GOT24
1523 || r_type == R_MN10300_GOT16)
1524 && elf_hash_table (info)->dynamic_sections_created
1525 && !SYMBOL_REFERENCES_LOCAL (info, hh))
1526 || (r_type == R_MN10300_32
1527 /* _32 relocs in executables force _COPY relocs,
1528 such that the address of the symbol ends up
1530 && !info->executable
1531 && !SYMBOL_REFERENCES_LOCAL (info, hh)
1532 && ((input_section->flags & SEC_ALLOC) != 0
1533 /* DWARF will emit R_MN10300_32 relocations
1534 in its sections against symbols defined
1535 externally in shared libraries. We can't
1536 do anything with them here. */
1537 || ((input_section->flags & SEC_DEBUGGING) != 0
1538 && h->root.def_dynamic)))))
1539 /* In these cases, we don't need the relocation
1540 value. We check specially because in some
1541 obscure cases sec->output_section will be NULL. */
1544 else if (!info->relocatable && unresolved_reloc)
1545 (*_bfd_error_handler)
1546 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1549 (long) rel->r_offset,
1551 h->root.root.root.string);
1554 if (sec != NULL && elf_discarded_section (sec))
1556 /* For relocs against symbols from removed linkonce sections,
1557 or sections discarded by a linker script, we just want the
1558 section contents zeroed. Avoid any special processing. */
1559 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1565 if (info->relocatable)
1568 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1570 contents, rel->r_offset,
1571 relocation, rel->r_addend,
1572 (struct elf_link_hash_entry *) h,
1574 info, sec, h == NULL);
1576 if (r != bfd_reloc_ok)
1579 const char *msg = NULL;
1582 name = h->root.root.root.string;
1585 name = (bfd_elf_string_from_elf_section
1586 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1587 if (name == NULL || *name == '\0')
1588 name = bfd_section_name (input_bfd, sec);
1593 case bfd_reloc_overflow:
1594 if (! ((*info->callbacks->reloc_overflow)
1595 (info, (h ? &h->root.root : NULL), name,
1596 howto->name, (bfd_vma) 0, input_bfd,
1597 input_section, rel->r_offset)))
1601 case bfd_reloc_undefined:
1602 if (! ((*info->callbacks->undefined_symbol)
1603 (info, name, input_bfd, input_section,
1604 rel->r_offset, TRUE)))
1608 case bfd_reloc_outofrange:
1609 msg = _("internal error: out of range error");
1612 case bfd_reloc_notsupported:
1613 msg = _("internal error: unsupported relocation error");
1616 case bfd_reloc_dangerous:
1617 if (r_type == R_MN10300_PCREL32)
1618 msg = _("error: inappropriate relocation type for shared"
1619 " library (did you forget -fpic?)");
1621 msg = _("internal error: suspicious relocation type used"
1622 " in shared library");
1626 msg = _("internal error: unknown error");
1630 if (!((*info->callbacks->warning)
1631 (info, msg, name, input_bfd, input_section,
1642 /* Finish initializing one hash table entry. */
1645 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
1648 struct elf32_mn10300_link_hash_entry *entry;
1649 struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
1650 unsigned int byte_count = 0;
1652 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
1654 if (entry->root.root.type == bfd_link_hash_warning)
1655 entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1657 /* If we already know we want to convert "call" to "calls" for calls
1658 to this symbol, then return now. */
1659 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
1662 /* If there are no named calls to this symbol, or there's nothing we
1663 can move from the function itself into the "call" instruction,
1664 then note that all "call" instructions should be converted into
1665 "calls" instructions and return. If a symbol is available for
1666 dynamic symbol resolution (overridable or overriding), avoid
1667 custom calling conventions. */
1668 if (entry->direct_calls == 0
1669 || (entry->stack_size == 0 && entry->movm_args == 0)
1670 || (elf_hash_table (link_info)->dynamic_sections_created
1671 && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
1672 && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
1674 /* Make a note that we should convert "call" instructions to "calls"
1675 instructions for calls to this symbol. */
1676 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1680 /* We may be able to move some instructions from the function itself into
1681 the "call" instruction. Count how many bytes we might be able to
1682 eliminate in the function itself. */
1684 /* A movm instruction is two bytes. */
1685 if (entry->movm_args)
1688 /* Count the insn to allocate stack space too. */
1689 if (entry->stack_size > 0)
1691 if (entry->stack_size <= 128)
1697 /* If using "call" will result in larger code, then turn all
1698 the associated "call" instructions into "calls" instructions. */
1699 if (byte_count < entry->direct_calls)
1700 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1702 /* This routine never fails. */
1706 /* Used to count hash table entries. */
1709 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
1712 int *count = (int *) in_args;
1718 /* Used to enumerate hash table entries into a linear array. */
1721 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
1724 struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
1731 /* Used to sort the array created by the above. */
1734 sort_by_value (const void *va, const void *vb)
1736 struct elf32_mn10300_link_hash_entry *a
1737 = *(struct elf32_mn10300_link_hash_entry **) va;
1738 struct elf32_mn10300_link_hash_entry *b
1739 = *(struct elf32_mn10300_link_hash_entry **) vb;
1741 return a->value - b->value;
1744 /* Compute the stack size and movm arguments for the function
1745 referred to by HASH at address ADDR in section with
1746 contents CONTENTS, store the information in the hash table. */
1749 compute_function_info (bfd *abfd,
1750 struct elf32_mn10300_link_hash_entry *hash,
1752 unsigned char *contents)
1754 unsigned char byte1, byte2;
1755 /* We only care about a very small subset of the possible prologue
1756 sequences here. Basically we look for:
1758 movm [d2,d3,a2,a3],sp (optional)
1759 add <size>,sp (optional, and only for sizes which fit in an unsigned
1762 If we find anything else, we quit. */
1764 /* Look for movm [regs],sp. */
1765 byte1 = bfd_get_8 (abfd, contents + addr);
1766 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1770 hash->movm_args = byte2;
1772 byte1 = bfd_get_8 (abfd, contents + addr);
1773 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1776 /* Now figure out how much stack space will be allocated by the movm
1777 instruction. We need this kept separate from the function's normal
1779 if (hash->movm_args)
1782 if (hash->movm_args & 0x80)
1783 hash->movm_stack_size += 4;
1786 if (hash->movm_args & 0x40)
1787 hash->movm_stack_size += 4;
1790 if (hash->movm_args & 0x20)
1791 hash->movm_stack_size += 4;
1794 if (hash->movm_args & 0x10)
1795 hash->movm_stack_size += 4;
1797 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
1798 if (hash->movm_args & 0x08)
1799 hash->movm_stack_size += 8 * 4;
1801 if (bfd_get_mach (abfd) == bfd_mach_am33
1802 || bfd_get_mach (abfd) == bfd_mach_am33_2)
1804 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
1805 if (hash->movm_args & 0x1)
1806 hash->movm_stack_size += 6 * 4;
1808 /* exreg1 space. e4, e5, e6, e7 */
1809 if (hash->movm_args & 0x2)
1810 hash->movm_stack_size += 4 * 4;
1812 /* exreg0 space. e2, e3 */
1813 if (hash->movm_args & 0x4)
1814 hash->movm_stack_size += 2 * 4;
1818 /* Now look for the two stack adjustment variants. */
1819 if (byte1 == 0xf8 && byte2 == 0xfe)
1821 int temp = bfd_get_8 (abfd, contents + addr + 2);
1822 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
1824 hash->stack_size = -temp;
1826 else if (byte1 == 0xfa && byte2 == 0xfe)
1828 int temp = bfd_get_16 (abfd, contents + addr + 2);
1829 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
1833 hash->stack_size = temp;
1836 /* If the total stack to be allocated by the call instruction is more
1837 than 255 bytes, then we can't remove the stack adjustment by using
1838 "call" (we might still be able to remove the "movm" instruction. */
1839 if (hash->stack_size + hash->movm_stack_size > 255)
1840 hash->stack_size = 0;
1843 /* Delete some bytes from a section while relaxing. */
1846 mn10300_elf_relax_delete_bytes (bfd *abfd,
1851 Elf_Internal_Shdr *symtab_hdr;
1852 unsigned int sec_shndx;
1854 Elf_Internal_Rela *irel, *irelend;
1855 Elf_Internal_Rela *irelalign;
1857 Elf_Internal_Sym *isym, *isymend;
1858 struct elf_link_hash_entry **sym_hashes;
1859 struct elf_link_hash_entry **end_hashes;
1860 unsigned int symcount;
1862 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1864 contents = elf_section_data (sec)->this_hdr.contents;
1869 irel = elf_section_data (sec)->relocs;
1870 irelend = irel + sec->reloc_count;
1872 if (sec->reloc_count > 0)
1874 /* If there is an align reloc at the end of the section ignore it.
1875 GAS creates these relocs for reasons of its own, and they just
1876 serve to keep the section artifically inflated. */
1877 if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
1880 /* The deletion must stop at the next ALIGN reloc for an aligment
1881 power larger than, or not a multiple of, the number of bytes we
1883 for (; irel < irelend; irel++)
1885 int alignment = 1 << irel->r_addend;
1887 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1888 && irel->r_offset > addr
1889 && irel->r_offset < toaddr
1890 && (count < alignment
1891 || alignment % count != 0))
1894 toaddr = irel->r_offset;
1900 /* Actually delete the bytes. */
1901 memmove (contents + addr, contents + addr + count,
1902 (size_t) (toaddr - addr - count));
1904 /* Adjust the section's size if we are shrinking it, or else
1905 pad the bytes between the end of the shrunken region and
1906 the start of the next region with NOP codes. */
1907 if (irelalign == NULL)
1910 /* Include symbols at the end of the section, but
1911 not at the end of a sub-region of the section. */
1918 #define NOP_OPCODE 0xcb
1920 for (i = 0; i < count; i ++)
1921 bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
1924 /* Adjust all the relocs. */
1925 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1927 /* Get the new reloc address. */
1928 if ((irel->r_offset > addr
1929 && irel->r_offset < toaddr)
1930 || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1931 && irel->r_offset == toaddr))
1932 irel->r_offset -= count;
1935 /* Adjust the local symbols in the section, reducing their value
1936 by the number of bytes deleted. Note - symbols within the deleted
1937 region are moved to the address of the start of the region, which
1938 actually means that they will address the byte beyond the end of
1939 the region once the deletion has been completed. */
1940 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1941 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1942 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1944 if (isym->st_shndx == sec_shndx
1945 && isym->st_value > addr
1946 && isym->st_value < toaddr)
1948 if (isym->st_value < addr + count)
1949 isym->st_value = addr;
1951 isym->st_value -= count;
1953 /* Adjust the function symbol's size as well. */
1954 else if (isym->st_shndx == sec_shndx
1955 && ELF_ST_TYPE (isym->st_info) == STT_FUNC
1956 && isym->st_value + isym->st_size > addr
1957 && isym->st_value + isym->st_size < toaddr)
1958 isym->st_size -= count;
1961 /* Now adjust the global symbols defined in this section. */
1962 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1963 - symtab_hdr->sh_info);
1964 sym_hashes = elf_sym_hashes (abfd);
1965 end_hashes = sym_hashes + symcount;
1966 for (; sym_hashes < end_hashes; sym_hashes++)
1968 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1970 if ((sym_hash->root.type == bfd_link_hash_defined
1971 || sym_hash->root.type == bfd_link_hash_defweak)
1972 && sym_hash->root.u.def.section == sec
1973 && sym_hash->root.u.def.value > addr
1974 && sym_hash->root.u.def.value < toaddr)
1976 if (sym_hash->root.u.def.value < addr + count)
1977 sym_hash->root.u.def.value = addr;
1979 sym_hash->root.u.def.value -= count;
1981 /* Adjust the function symbol's size as well. */
1982 else if (sym_hash->root.type == bfd_link_hash_defined
1983 && sym_hash->root.u.def.section == sec
1984 && sym_hash->type == STT_FUNC
1985 && sym_hash->root.u.def.value + sym_hash->size > addr
1986 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1987 sym_hash->size -= count;
1990 /* See if we can move the ALIGN reloc forward.
1991 We have adjusted r_offset for it already. */
1992 if (irelalign != NULL)
1994 bfd_vma alignto, alignaddr;
1996 if ((int) irelalign->r_addend > 0)
1998 /* This is the old address. */
1999 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
2000 /* This is where the align points to now. */
2001 alignaddr = BFD_ALIGN (irelalign->r_offset,
2002 1 << irelalign->r_addend);
2003 if (alignaddr < alignto)
2004 /* Tail recursion. */
2005 return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr,
2006 (int) (alignto - alignaddr));
2013 /* Return TRUE if a symbol exists at the given address, else return
2017 mn10300_elf_symbol_address_p (bfd *abfd,
2019 Elf_Internal_Sym *isym,
2022 Elf_Internal_Shdr *symtab_hdr;
2023 unsigned int sec_shndx;
2024 Elf_Internal_Sym *isymend;
2025 struct elf_link_hash_entry **sym_hashes;
2026 struct elf_link_hash_entry **end_hashes;
2027 unsigned int symcount;
2029 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2031 /* Examine all the symbols. */
2032 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2033 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2034 if (isym->st_shndx == sec_shndx
2035 && isym->st_value == addr)
2038 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2039 - symtab_hdr->sh_info);
2040 sym_hashes = elf_sym_hashes (abfd);
2041 end_hashes = sym_hashes + symcount;
2042 for (; sym_hashes < end_hashes; sym_hashes++)
2044 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2046 if ((sym_hash->root.type == bfd_link_hash_defined
2047 || sym_hash->root.type == bfd_link_hash_defweak)
2048 && sym_hash->root.u.def.section == sec
2049 && sym_hash->root.u.def.value == addr)
2056 /* This function handles relaxing for the mn10300.
2058 There are quite a few relaxing opportunities available on the mn10300:
2060 * calls:32 -> calls:16 2 bytes
2061 * call:32 -> call:16 2 bytes
2063 * call:32 -> calls:32 1 byte
2064 * call:16 -> calls:16 1 byte
2065 * These are done anytime using "calls" would result
2066 in smaller code, or when necessary to preserve the
2067 meaning of the program.
2071 * In some circumstances we can move instructions
2072 from a function prologue into a "call" instruction.
2073 This is only done if the resulting code is no larger
2074 than the original code.
2076 * jmp:32 -> jmp:16 2 bytes
2077 * jmp:16 -> bra:8 1 byte
2079 * If the previous instruction is a conditional branch
2080 around the jump/bra, we may be able to reverse its condition
2081 and change its target to the jump's target. The jump/bra
2082 can then be deleted. 2 bytes
2084 * mov abs32 -> mov abs16 1 or 2 bytes
2086 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
2087 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
2089 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
2090 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
2092 We don't handle imm16->imm8 or d16->d8 as they're very rare
2093 and somewhat more difficult to support. */
2096 mn10300_elf_relax_section (bfd *abfd,
2098 struct bfd_link_info *link_info,
2101 Elf_Internal_Shdr *symtab_hdr;
2102 Elf_Internal_Rela *internal_relocs = NULL;
2103 Elf_Internal_Rela *irel, *irelend;
2104 bfd_byte *contents = NULL;
2105 Elf_Internal_Sym *isymbuf = NULL;
2106 struct elf32_mn10300_link_hash_table *hash_table;
2107 asection *section = sec;
2109 /* Assume nothing changes. */
2112 /* We need a pointer to the mn10300 specific hash table. */
2113 hash_table = elf32_mn10300_hash_table (link_info);
2115 /* Initialize fields in each hash table entry the first time through. */
2116 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2120 /* Iterate over all the input bfds. */
2121 for (input_bfd = link_info->input_bfds;
2123 input_bfd = input_bfd->link_next)
2125 /* We're going to need all the symbols for each bfd. */
2126 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2127 if (symtab_hdr->sh_info != 0)
2129 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2130 if (isymbuf == NULL)
2131 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2132 symtab_hdr->sh_info, 0,
2134 if (isymbuf == NULL)
2138 /* Iterate over each section in this bfd. */
2139 for (section = input_bfd->sections;
2141 section = section->next)
2143 struct elf32_mn10300_link_hash_entry *hash;
2144 Elf_Internal_Sym *sym;
2145 asection *sym_sec = NULL;
2146 const char *sym_name;
2149 /* If there's nothing to do in this section, skip it. */
2150 if (! ((section->flags & SEC_RELOC) != 0
2151 && section->reloc_count != 0))
2153 if ((section->flags & SEC_ALLOC) == 0)
2156 /* Get cached copy of section contents if it exists. */
2157 if (elf_section_data (section)->this_hdr.contents != NULL)
2158 contents = elf_section_data (section)->this_hdr.contents;
2159 else if (section->size != 0)
2161 /* Go get them off disk. */
2162 if (!bfd_malloc_and_get_section (input_bfd, section,
2169 /* If there aren't any relocs, then there's nothing to do. */
2170 if ((section->flags & SEC_RELOC) != 0
2171 && section->reloc_count != 0)
2173 /* Get a copy of the native relocations. */
2174 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2176 link_info->keep_memory);
2177 if (internal_relocs == NULL)
2180 /* Now examine each relocation. */
2181 irel = internal_relocs;
2182 irelend = irel + section->reloc_count;
2183 for (; irel < irelend; irel++)
2186 unsigned long r_index;
2189 r_type = ELF32_R_TYPE (irel->r_info);
2190 r_index = ELF32_R_SYM (irel->r_info);
2192 if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2195 /* We need the name and hash table entry of the target
2201 if (r_index < symtab_hdr->sh_info)
2203 /* A local symbol. */
2204 Elf_Internal_Sym *isym;
2205 struct elf_link_hash_table *elftab;
2208 isym = isymbuf + r_index;
2209 if (isym->st_shndx == SHN_UNDEF)
2210 sym_sec = bfd_und_section_ptr;
2211 else if (isym->st_shndx == SHN_ABS)
2212 sym_sec = bfd_abs_section_ptr;
2213 else if (isym->st_shndx == SHN_COMMON)
2214 sym_sec = bfd_com_section_ptr;
2217 = bfd_section_from_elf_index (input_bfd,
2221 = bfd_elf_string_from_elf_section (input_bfd,
2226 /* If it isn't a function, then we don't care
2228 if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2231 /* Tack on an ID so we can uniquely identify this
2232 local symbol in the global hash table. */
2233 amt = strlen (sym_name) + 10;
2234 new_name = bfd_malloc (amt);
2235 if (new_name == NULL)
2238 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2239 sym_name = new_name;
2241 elftab = &hash_table->static_hash_table->root;
2242 hash = ((struct elf32_mn10300_link_hash_entry *)
2243 elf_link_hash_lookup (elftab, sym_name,
2244 TRUE, TRUE, FALSE));
2249 r_index -= symtab_hdr->sh_info;
2250 hash = (struct elf32_mn10300_link_hash_entry *)
2251 elf_sym_hashes (input_bfd)[r_index];
2254 sym_name = hash->root.root.root.string;
2255 if ((section->flags & SEC_CODE) != 0)
2257 /* If this is not a "call" instruction, then we
2258 should convert "call" instructions to "calls"
2260 code = bfd_get_8 (input_bfd,
2261 contents + irel->r_offset - 1);
2262 if (code != 0xdd && code != 0xcd)
2263 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2266 /* If this is a jump/call, then bump the
2267 direct_calls counter. Else force "call" to
2268 "calls" conversions. */
2269 if (r_type == R_MN10300_PCREL32
2270 || r_type == R_MN10300_PLT32
2271 || r_type == R_MN10300_PLT16
2272 || r_type == R_MN10300_PCREL16)
2273 hash->direct_calls++;
2275 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2279 /* Now look at the actual contents to get the stack size,
2280 and a list of what registers were saved in the prologue
2282 if ((section->flags & SEC_CODE) != 0)
2284 Elf_Internal_Sym *isym, *isymend;
2285 unsigned int sec_shndx;
2286 struct elf_link_hash_entry **hashes;
2287 struct elf_link_hash_entry **end_hashes;
2288 unsigned int symcount;
2290 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2293 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2294 - symtab_hdr->sh_info);
2295 hashes = elf_sym_hashes (input_bfd);
2296 end_hashes = hashes + symcount;
2298 /* Look at each function defined in this section and
2299 update info for that function. */
2300 isymend = isymbuf + symtab_hdr->sh_info;
2301 for (isym = isymbuf; isym < isymend; isym++)
2303 if (isym->st_shndx == sec_shndx
2304 && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2306 struct elf_link_hash_table *elftab;
2308 struct elf_link_hash_entry **lhashes = hashes;
2310 /* Skip a local symbol if it aliases a
2312 for (; lhashes < end_hashes; lhashes++)
2314 hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2315 if ((hash->root.root.type == bfd_link_hash_defined
2316 || hash->root.root.type == bfd_link_hash_defweak)
2317 && hash->root.root.u.def.section == section
2318 && hash->root.type == STT_FUNC
2319 && hash->root.root.u.def.value == isym->st_value)
2322 if (lhashes != end_hashes)
2325 if (isym->st_shndx == SHN_UNDEF)
2326 sym_sec = bfd_und_section_ptr;
2327 else if (isym->st_shndx == SHN_ABS)
2328 sym_sec = bfd_abs_section_ptr;
2329 else if (isym->st_shndx == SHN_COMMON)
2330 sym_sec = bfd_com_section_ptr;
2333 = bfd_section_from_elf_index (input_bfd,
2336 sym_name = (bfd_elf_string_from_elf_section
2337 (input_bfd, symtab_hdr->sh_link,
2340 /* Tack on an ID so we can uniquely identify this
2341 local symbol in the global hash table. */
2342 amt = strlen (sym_name) + 10;
2343 new_name = bfd_malloc (amt);
2344 if (new_name == NULL)
2347 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2348 sym_name = new_name;
2350 elftab = &hash_table->static_hash_table->root;
2351 hash = ((struct elf32_mn10300_link_hash_entry *)
2352 elf_link_hash_lookup (elftab, sym_name,
2353 TRUE, TRUE, FALSE));
2355 compute_function_info (input_bfd, hash,
2356 isym->st_value, contents);
2357 hash->value = isym->st_value;
2361 for (; hashes < end_hashes; hashes++)
2363 hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2364 if ((hash->root.root.type == bfd_link_hash_defined
2365 || hash->root.root.type == bfd_link_hash_defweak)
2366 && hash->root.root.u.def.section == section
2367 && hash->root.type == STT_FUNC)
2368 compute_function_info (input_bfd, hash,
2369 (hash)->root.root.u.def.value,
2374 /* Cache or free any memory we allocated for the relocs. */
2375 if (internal_relocs != NULL
2376 && elf_section_data (section)->relocs != internal_relocs)
2377 free (internal_relocs);
2378 internal_relocs = NULL;
2380 /* Cache or free any memory we allocated for the contents. */
2381 if (contents != NULL
2382 && elf_section_data (section)->this_hdr.contents != contents)
2384 if (! link_info->keep_memory)
2388 /* Cache the section contents for elf_link_input_bfd. */
2389 elf_section_data (section)->this_hdr.contents = contents;
2395 /* Cache or free any memory we allocated for the symbols. */
2397 && symtab_hdr->contents != (unsigned char *) isymbuf)
2399 if (! link_info->keep_memory)
2403 /* Cache the symbols for elf_link_input_bfd. */
2404 symtab_hdr->contents = (unsigned char *) isymbuf;
2410 /* Now iterate on each symbol in the hash table and perform
2411 the final initialization steps on each. */
2412 elf32_mn10300_link_hash_traverse (hash_table,
2413 elf32_mn10300_finish_hash_table_entry,
2415 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2416 elf32_mn10300_finish_hash_table_entry,
2420 /* This section of code collects all our local symbols, sorts
2421 them by value, and looks for multiple symbols referring to
2422 the same address. For those symbols, the flags are merged.
2423 At this point, the only flag that can be set is
2424 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2426 int static_count = 0, i;
2427 struct elf32_mn10300_link_hash_entry **entries;
2428 struct elf32_mn10300_link_hash_entry **ptr;
2430 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2431 elf32_mn10300_count_hash_table_entries,
2434 entries = bfd_malloc (static_count * sizeof (* ptr));
2437 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2438 elf32_mn10300_list_hash_table_entries,
2441 qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
2443 for (i = 0; i < static_count - 1; i++)
2444 if (entries[i]->value && entries[i]->value == entries[i+1]->value)
2446 int v = entries[i]->flags;
2449 for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
2450 v |= entries[j]->flags;
2452 for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
2453 entries[j]->flags = v;
2459 /* All entries in the hash table are fully initialized. */
2460 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2462 /* Now that everything has been initialized, go through each
2463 code section and delete any prologue insns which will be
2464 redundant because their operations will be performed by
2465 a "call" instruction. */
2466 for (input_bfd = link_info->input_bfds;
2468 input_bfd = input_bfd->link_next)
2470 /* We're going to need all the local symbols for each bfd. */
2471 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2472 if (symtab_hdr->sh_info != 0)
2474 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2475 if (isymbuf == NULL)
2476 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2477 symtab_hdr->sh_info, 0,
2479 if (isymbuf == NULL)
2483 /* Walk over each section in this bfd. */
2484 for (section = input_bfd->sections;
2486 section = section->next)
2488 unsigned int sec_shndx;
2489 Elf_Internal_Sym *isym, *isymend;
2490 struct elf_link_hash_entry **hashes;
2491 struct elf_link_hash_entry **end_hashes;
2492 unsigned int symcount;
2494 /* Skip non-code sections and empty sections. */
2495 if ((section->flags & SEC_CODE) == 0 || section->size == 0)
2498 if (section->reloc_count != 0)
2500 /* Get a copy of the native relocations. */
2501 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2503 link_info->keep_memory);
2504 if (internal_relocs == NULL)
2508 /* Get cached copy of section contents if it exists. */
2509 if (elf_section_data (section)->this_hdr.contents != NULL)
2510 contents = elf_section_data (section)->this_hdr.contents;
2513 /* Go get them off disk. */
2514 if (!bfd_malloc_and_get_section (input_bfd, section,
2519 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2522 /* Now look for any function in this section which needs
2523 insns deleted from its prologue. */
2524 isymend = isymbuf + symtab_hdr->sh_info;
2525 for (isym = isymbuf; isym < isymend; isym++)
2527 struct elf32_mn10300_link_hash_entry *sym_hash;
2528 asection *sym_sec = NULL;
2529 const char *sym_name;
2531 struct elf_link_hash_table *elftab;
2534 if (isym->st_shndx != sec_shndx)
2537 if (isym->st_shndx == SHN_UNDEF)
2538 sym_sec = bfd_und_section_ptr;
2539 else if (isym->st_shndx == SHN_ABS)
2540 sym_sec = bfd_abs_section_ptr;
2541 else if (isym->st_shndx == SHN_COMMON)
2542 sym_sec = bfd_com_section_ptr;
2545 = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2548 = bfd_elf_string_from_elf_section (input_bfd,
2549 symtab_hdr->sh_link,
2552 /* Tack on an ID so we can uniquely identify this
2553 local symbol in the global hash table. */
2554 amt = strlen (sym_name) + 10;
2555 new_name = bfd_malloc (amt);
2556 if (new_name == NULL)
2558 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2559 sym_name = new_name;
2561 elftab = & hash_table->static_hash_table->root;
2562 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2563 elf_link_hash_lookup (elftab, sym_name,
2564 FALSE, FALSE, FALSE);
2567 if (sym_hash == NULL)
2570 if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2571 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2575 /* Note that we've changed things. */
2576 elf_section_data (section)->relocs = internal_relocs;
2577 elf_section_data (section)->this_hdr.contents = contents;
2578 symtab_hdr->contents = (unsigned char *) isymbuf;
2580 /* Count how many bytes we're going to delete. */
2581 if (sym_hash->movm_args)
2584 if (sym_hash->stack_size > 0)
2586 if (sym_hash->stack_size <= 128)
2592 /* Note that we've deleted prologue bytes for this
2594 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2596 /* Actually delete the bytes. */
2597 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2603 /* Something changed. Not strictly necessary, but
2604 may lead to more relaxing opportunities. */
2609 /* Look for any global functions in this section which
2610 need insns deleted from their prologues. */
2611 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2612 - symtab_hdr->sh_info);
2613 hashes = elf_sym_hashes (input_bfd);
2614 end_hashes = hashes + symcount;
2615 for (; hashes < end_hashes; hashes++)
2617 struct elf32_mn10300_link_hash_entry *sym_hash;
2619 sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2620 if ((sym_hash->root.root.type == bfd_link_hash_defined
2621 || sym_hash->root.root.type == bfd_link_hash_defweak)
2622 && sym_hash->root.root.u.def.section == section
2623 && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2624 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2629 /* Note that we've changed things. */
2630 elf_section_data (section)->relocs = internal_relocs;
2631 elf_section_data (section)->this_hdr.contents = contents;
2632 symtab_hdr->contents = (unsigned char *) isymbuf;
2634 /* Count how many bytes we're going to delete. */
2635 if (sym_hash->movm_args)
2638 if (sym_hash->stack_size > 0)
2640 if (sym_hash->stack_size <= 128)
2646 /* Note that we've deleted prologue bytes for this
2648 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2650 /* Actually delete the bytes. */
2651 symval = sym_hash->root.root.u.def.value;
2652 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2658 /* Something changed. Not strictly necessary, but
2659 may lead to more relaxing opportunities. */
2664 /* Cache or free any memory we allocated for the relocs. */
2665 if (internal_relocs != NULL
2666 && elf_section_data (section)->relocs != internal_relocs)
2667 free (internal_relocs);
2668 internal_relocs = NULL;
2670 /* Cache or free any memory we allocated for the contents. */
2671 if (contents != NULL
2672 && elf_section_data (section)->this_hdr.contents != contents)
2674 if (! link_info->keep_memory)
2677 /* Cache the section contents for elf_link_input_bfd. */
2678 elf_section_data (section)->this_hdr.contents = contents;
2683 /* Cache or free any memory we allocated for the symbols. */
2685 && symtab_hdr->contents != (unsigned char *) isymbuf)
2687 if (! link_info->keep_memory)
2690 /* Cache the symbols for elf_link_input_bfd. */
2691 symtab_hdr->contents = (unsigned char *) isymbuf;
2697 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
2699 internal_relocs = NULL;
2701 /* For error_return. */
2704 /* We don't have to do anything for a relocatable link, if
2705 this section does not have relocs, or if this is not a
2707 if (link_info->relocatable
2708 || (sec->flags & SEC_RELOC) == 0
2709 || sec->reloc_count == 0
2710 || (sec->flags & SEC_CODE) == 0)
2713 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2715 /* Get a copy of the native relocations. */
2716 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2717 link_info->keep_memory);
2718 if (internal_relocs == NULL)
2721 /* Walk through them looking for relaxing opportunities. */
2722 irelend = internal_relocs + sec->reloc_count;
2723 for (irel = internal_relocs; irel < irelend; irel++)
2726 struct elf32_mn10300_link_hash_entry *h = NULL;
2728 /* If this isn't something that can be relaxed, then ignore
2730 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2731 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2732 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2735 /* Get the section contents if we haven't done so already. */
2736 if (contents == NULL)
2738 /* Get cached copy if it exists. */
2739 if (elf_section_data (sec)->this_hdr.contents != NULL)
2740 contents = elf_section_data (sec)->this_hdr.contents;
2743 /* Go get them off disk. */
2744 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2749 /* Read this BFD's symbols if we haven't done so already. */
2750 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2752 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2753 if (isymbuf == NULL)
2754 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2755 symtab_hdr->sh_info, 0,
2757 if (isymbuf == NULL)
2761 /* Get the value of the symbol referred to by the reloc. */
2762 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2764 Elf_Internal_Sym *isym;
2765 asection *sym_sec = NULL;
2766 const char *sym_name;
2769 /* A local symbol. */
2770 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2771 if (isym->st_shndx == SHN_UNDEF)
2772 sym_sec = bfd_und_section_ptr;
2773 else if (isym->st_shndx == SHN_ABS)
2774 sym_sec = bfd_abs_section_ptr;
2775 else if (isym->st_shndx == SHN_COMMON)
2776 sym_sec = bfd_com_section_ptr;
2778 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2780 sym_name = bfd_elf_string_from_elf_section (abfd,
2781 symtab_hdr->sh_link,
2784 if ((sym_sec->flags & SEC_MERGE)
2785 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
2786 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2788 bfd_vma saved_addend;
2790 saved_addend = irel->r_addend;
2791 symval = _bfd_elf_rela_local_sym (abfd, isym, & sym_sec, irel);
2792 symval += irel->r_addend;
2793 irel->r_addend = saved_addend;
2796 symval = (isym->st_value
2797 + sym_sec->output_section->vma
2798 + sym_sec->output_offset);
2800 /* Tack on an ID so we can uniquely identify this
2801 local symbol in the global hash table. */
2802 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2803 if (new_name == NULL)
2805 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2806 sym_name = new_name;
2808 h = (struct elf32_mn10300_link_hash_entry *)
2809 elf_link_hash_lookup (&hash_table->static_hash_table->root,
2810 sym_name, FALSE, FALSE, FALSE);
2817 /* An external symbol. */
2818 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2819 h = (struct elf32_mn10300_link_hash_entry *)
2820 (elf_sym_hashes (abfd)[indx]);
2821 BFD_ASSERT (h != NULL);
2822 if (h->root.root.type != bfd_link_hash_defined
2823 && h->root.root.type != bfd_link_hash_defweak)
2824 /* This appears to be a reference to an undefined
2825 symbol. Just ignore it--it will be caught by the
2826 regular reloc processing. */
2829 /* Check for a reference to a discarded symbol and ignore it. */
2830 if (h->root.root.u.def.section->output_section == NULL)
2833 symval = (h->root.root.u.def.value
2834 + h->root.root.u.def.section->output_section->vma
2835 + h->root.root.u.def.section->output_offset);
2838 /* For simplicity of coding, we are going to modify the section
2839 contents, the section relocs, and the BFD symbol table. We
2840 must tell the rest of the code not to free up this
2841 information. It would be possible to instead create a table
2842 of changes which have to be made, as is done in coff-mips.c;
2843 that would be more work, but would require less memory when
2844 the linker is run. */
2846 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2847 branch/call, also deal with "call" -> "calls" conversions and
2848 insertion of prologue data into "call" instructions. */
2849 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2850 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2852 bfd_vma value = symval;
2854 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2856 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2857 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2858 && h->root.plt.offset != (bfd_vma) -1)
2862 splt = bfd_get_section_by_name (elf_hash_table (link_info)
2865 value = ((splt->output_section->vma
2866 + splt->output_offset
2867 + h->root.plt.offset)
2868 - (sec->output_section->vma
2869 + sec->output_offset
2873 /* If we've got a "call" instruction that needs to be turned
2874 into a "calls" instruction, do so now. It saves a byte. */
2875 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2879 /* Get the opcode. */
2880 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2882 /* Make sure we're working with a "call" instruction! */
2885 /* Note that we've changed the relocs, section contents,
2887 elf_section_data (sec)->relocs = internal_relocs;
2888 elf_section_data (sec)->this_hdr.contents = contents;
2889 symtab_hdr->contents = (unsigned char *) isymbuf;
2891 /* Fix the opcode. */
2892 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2893 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2895 /* Fix irel->r_offset and irel->r_addend. */
2896 irel->r_offset += 1;
2897 irel->r_addend += 1;
2899 /* Delete one byte of data. */
2900 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2901 irel->r_offset + 3, 1))
2904 /* That will change things, so, we should relax again.
2905 Note that this is not required, and it may be slow. */
2911 /* We've got a "call" instruction which needs some data
2912 from target function filled in. */
2915 /* Get the opcode. */
2916 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2918 /* Insert data from the target function into the "call"
2919 instruction if needed. */
2922 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2923 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2924 contents + irel->r_offset + 5);
2928 /* Deal with pc-relative gunk. */
2929 value -= (sec->output_section->vma + sec->output_offset);
2930 value -= irel->r_offset;
2931 value += irel->r_addend;
2933 /* See if the value will fit in 16 bits, note the high value is
2934 0x7fff + 2 as the target will be two bytes closer if we are
2936 if ((long) value < 0x8001 && (long) value > -0x8000)
2940 /* Get the opcode. */
2941 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2943 if (code != 0xdc && code != 0xdd && code != 0xff)
2946 /* Note that we've changed the relocs, section contents, etc. */
2947 elf_section_data (sec)->relocs = internal_relocs;
2948 elf_section_data (sec)->this_hdr.contents = contents;
2949 symtab_hdr->contents = (unsigned char *) isymbuf;
2951 /* Fix the opcode. */
2953 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2954 else if (code == 0xdd)
2955 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2956 else if (code == 0xff)
2957 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2959 /* Fix the relocation's type. */
2960 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2961 (ELF32_R_TYPE (irel->r_info)
2962 == (int) R_MN10300_PLT32)
2966 /* Delete two bytes of data. */
2967 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2968 irel->r_offset + 1, 2))
2971 /* That will change things, so, we should relax again.
2972 Note that this is not required, and it may be slow. */
2977 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
2979 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
2981 bfd_vma value = symval;
2983 /* If we've got a "call" instruction that needs to be turned
2984 into a "calls" instruction, do so now. It saves a byte. */
2985 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2989 /* Get the opcode. */
2990 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2992 /* Make sure we're working with a "call" instruction! */
2995 /* Note that we've changed the relocs, section contents,
2997 elf_section_data (sec)->relocs = internal_relocs;
2998 elf_section_data (sec)->this_hdr.contents = contents;
2999 symtab_hdr->contents = (unsigned char *) isymbuf;
3001 /* Fix the opcode. */
3002 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3003 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3005 /* Fix irel->r_offset and irel->r_addend. */
3006 irel->r_offset += 1;
3007 irel->r_addend += 1;
3009 /* Delete one byte of data. */
3010 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3011 irel->r_offset + 1, 1))
3014 /* That will change things, so, we should relax again.
3015 Note that this is not required, and it may be slow. */
3023 /* Get the opcode. */
3024 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3026 /* Insert data from the target function into the "call"
3027 instruction if needed. */
3030 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3031 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3032 contents + irel->r_offset + 3);
3036 /* Deal with pc-relative gunk. */
3037 value -= (sec->output_section->vma + sec->output_offset);
3038 value -= irel->r_offset;
3039 value += irel->r_addend;
3041 /* See if the value will fit in 8 bits, note the high value is
3042 0x7f + 1 as the target will be one bytes closer if we are
3044 if ((long) value < 0x80 && (long) value > -0x80)
3048 /* Get the opcode. */
3049 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3054 /* Note that we've changed the relocs, section contents, etc. */
3055 elf_section_data (sec)->relocs = internal_relocs;
3056 elf_section_data (sec)->this_hdr.contents = contents;
3057 symtab_hdr->contents = (unsigned char *) isymbuf;
3059 /* Fix the opcode. */
3060 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3062 /* Fix the relocation's type. */
3063 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3066 /* Delete one byte of data. */
3067 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3068 irel->r_offset + 1, 1))
3071 /* That will change things, so, we should relax again.
3072 Note that this is not required, and it may be slow. */
3077 /* Try to eliminate an unconditional 8 bit pc-relative branch
3078 which immediately follows a conditional 8 bit pc-relative
3079 branch around the unconditional branch.
3086 This happens when the bCC can't reach lab2 at assembly time,
3087 but due to other relaxations it can reach at link time. */
3088 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3090 Elf_Internal_Rela *nrel;
3091 bfd_vma value = symval;
3094 /* Deal with pc-relative gunk. */
3095 value -= (sec->output_section->vma + sec->output_offset);
3096 value -= irel->r_offset;
3097 value += irel->r_addend;
3099 /* Do nothing if this reloc is the last byte in the section. */
3100 if (irel->r_offset == sec->size)
3103 /* See if the next instruction is an unconditional pc-relative
3104 branch, more often than not this test will fail, so we
3105 test it first to speed things up. */
3106 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3110 /* Also make sure the next relocation applies to the next
3111 instruction and that it's a pc-relative 8 bit branch. */
3114 || irel->r_offset + 2 != nrel->r_offset
3115 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3118 /* Make sure our destination immediately follows the
3119 unconditional branch. */
3120 if (symval != (sec->output_section->vma + sec->output_offset
3121 + irel->r_offset + 3))
3124 /* Now make sure we are a conditional branch. This may not
3125 be necessary, but why take the chance.
3127 Note these checks assume that R_MN10300_PCREL8 relocs
3128 only occur on bCC and bCCx insns. If they occured
3129 elsewhere, we'd need to know the start of this insn
3130 for this check to be accurate. */
3131 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3132 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3133 && code != 0xc3 && code != 0xc4 && code != 0xc5
3134 && code != 0xc6 && code != 0xc7 && code != 0xc8
3135 && code != 0xc9 && code != 0xe8 && code != 0xe9
3136 && code != 0xea && code != 0xeb)
3139 /* We also have to be sure there is no symbol/label
3140 at the unconditional branch. */
3141 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3142 irel->r_offset + 1))
3145 /* Note that we've changed the relocs, section contents, etc. */
3146 elf_section_data (sec)->relocs = internal_relocs;
3147 elf_section_data (sec)->this_hdr.contents = contents;
3148 symtab_hdr->contents = (unsigned char *) isymbuf;
3150 /* Reverse the condition of the first branch. */
3196 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3198 /* Set the reloc type and symbol for the first branch
3199 from the second branch. */
3200 irel->r_info = nrel->r_info;
3202 /* Make the reloc for the second branch a null reloc. */
3203 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3206 /* Delete two bytes of data. */
3207 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3208 irel->r_offset + 1, 2))
3211 /* That will change things, so, we should relax again.
3212 Note that this is not required, and it may be slow. */
3216 /* Try to turn a 24 immediate, displacement or absolute address
3217 into a 8 immediate, displacement or absolute address. */
3218 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3220 bfd_vma value = symval;
3221 value += irel->r_addend;
3223 /* See if the value will fit in 8 bits. */
3224 if ((long) value < 0x7f && (long) value > -0x80)
3228 /* AM33 insns which have 24 operands are 6 bytes long and
3229 will have 0xfd as the first byte. */
3231 /* Get the first opcode. */
3232 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3236 /* Get the second opcode. */
3237 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3239 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3240 equivalent instructions exists. */
3241 if (code != 0x6b && code != 0x7b
3242 && code != 0x8b && code != 0x9b
3243 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3244 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3245 || (code & 0x0f) == 0x0e))
3247 /* Not safe if the high bit is on as relaxing may
3248 move the value out of high mem and thus not fit
3249 in a signed 8bit value. This is currently over
3251 if ((value & 0x80) == 0)
3253 /* Note that we've changed the relocation contents,
3255 elf_section_data (sec)->relocs = internal_relocs;
3256 elf_section_data (sec)->this_hdr.contents = contents;
3257 symtab_hdr->contents = (unsigned char *) isymbuf;
3259 /* Fix the opcode. */
3260 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3261 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3263 /* Fix the relocation's type. */
3265 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3268 /* Delete two bytes of data. */
3269 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3270 irel->r_offset + 1, 2))
3273 /* That will change things, so, we should relax
3274 again. Note that this is not required, and it
3284 /* Try to turn a 32bit immediate, displacement or absolute address
3285 into a 16bit immediate, displacement or absolute address. */
3286 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3287 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3288 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3290 bfd_vma value = symval;
3292 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3296 sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3299 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3301 value = sgot->output_offset;
3304 value += h->root.got.offset;
3306 value += (elf_local_got_offsets
3307 (abfd)[ELF32_R_SYM (irel->r_info)]);
3309 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3310 value -= sgot->output_section->vma;
3311 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3312 value = (sgot->output_section->vma
3313 - (sec->output_section->vma
3314 + sec->output_offset
3320 value += irel->r_addend;
3322 /* See if the value will fit in 24 bits.
3323 We allow any 16bit match here. We prune those we can't
3325 if ((long) value < 0x7fffff && (long) value > -0x800000)
3329 /* AM33 insns which have 32bit operands are 7 bytes long and
3330 will have 0xfe as the first byte. */
3332 /* Get the first opcode. */
3333 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3337 /* Get the second opcode. */
3338 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3340 /* All the am33 32 -> 24 relaxing possibilities. */
3341 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3342 equivalent instructions exists. */
3343 if (code != 0x6b && code != 0x7b
3344 && code != 0x8b && code != 0x9b
3345 && (ELF32_R_TYPE (irel->r_info)
3346 != (int) R_MN10300_GOTPC32)
3347 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3348 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3349 || (code & 0x0f) == 0x0e))
3351 /* Not safe if the high bit is on as relaxing may
3352 move the value out of high mem and thus not fit
3353 in a signed 16bit value. This is currently over
3355 if ((value & 0x8000) == 0)
3357 /* Note that we've changed the relocation contents,
3359 elf_section_data (sec)->relocs = internal_relocs;
3360 elf_section_data (sec)->this_hdr.contents = contents;
3361 symtab_hdr->contents = (unsigned char *) isymbuf;
3363 /* Fix the opcode. */
3364 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3365 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3367 /* Fix the relocation's type. */
3369 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3370 (ELF32_R_TYPE (irel->r_info)
3371 == (int) R_MN10300_GOTOFF32)
3372 ? R_MN10300_GOTOFF24
3373 : (ELF32_R_TYPE (irel->r_info)
3374 == (int) R_MN10300_GOT32)
3378 /* Delete one byte of data. */
3379 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3380 irel->r_offset + 3, 1))
3383 /* That will change things, so, we should relax
3384 again. Note that this is not required, and it
3393 /* See if the value will fit in 16 bits.
3394 We allow any 16bit match here. We prune those we can't
3396 if ((long) value < 0x7fff && (long) value > -0x8000)
3400 /* Most insns which have 32bit operands are 6 bytes long;
3401 exceptions are pcrel insns and bit insns.
3403 We handle pcrel insns above. We don't bother trying
3404 to handle the bit insns here.
3406 The first byte of the remaining insns will be 0xfc. */
3408 /* Get the first opcode. */
3409 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3414 /* Get the second opcode. */
3415 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3417 if ((code & 0xf0) < 0x80)
3418 switch (code & 0xf0)
3420 /* mov (d32,am),dn -> mov (d32,am),dn
3421 mov dm,(d32,am) -> mov dn,(d32,am)
3422 mov (d32,am),an -> mov (d32,am),an
3423 mov dm,(d32,am) -> mov dn,(d32,am)
3424 movbu (d32,am),dn -> movbu (d32,am),dn
3425 movbu dm,(d32,am) -> movbu dn,(d32,am)
3426 movhu (d32,am),dn -> movhu (d32,am),dn
3427 movhu dm,(d32,am) -> movhu dn,(d32,am) */
3436 /* Not safe if the high bit is on as relaxing may
3437 move the value out of high mem and thus not fit
3438 in a signed 16bit value. */
3440 && (value & 0x8000))
3443 /* Note that we've changed the relocation contents, etc. */
3444 elf_section_data (sec)->relocs = internal_relocs;
3445 elf_section_data (sec)->this_hdr.contents = contents;
3446 symtab_hdr->contents = (unsigned char *) isymbuf;
3448 /* Fix the opcode. */
3449 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3450 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3452 /* Fix the relocation's type. */
3453 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3454 (ELF32_R_TYPE (irel->r_info)
3455 == (int) R_MN10300_GOTOFF32)
3456 ? R_MN10300_GOTOFF16
3457 : (ELF32_R_TYPE (irel->r_info)
3458 == (int) R_MN10300_GOT32)
3460 : (ELF32_R_TYPE (irel->r_info)
3461 == (int) R_MN10300_GOTPC32)
3462 ? R_MN10300_GOTPC16 :
3465 /* Delete two bytes of data. */
3466 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3467 irel->r_offset + 2, 2))
3470 /* That will change things, so, we should relax again.
3471 Note that this is not required, and it may be slow. */
3475 else if ((code & 0xf0) == 0x80
3476 || (code & 0xf0) == 0x90)
3477 switch (code & 0xf3)
3479 /* mov dn,(abs32) -> mov dn,(abs16)
3480 movbu dn,(abs32) -> movbu dn,(abs16)
3481 movhu dn,(abs32) -> movhu dn,(abs16) */
3485 /* Note that we've changed the relocation contents, etc. */
3486 elf_section_data (sec)->relocs = internal_relocs;
3487 elf_section_data (sec)->this_hdr.contents = contents;
3488 symtab_hdr->contents = (unsigned char *) isymbuf;
3490 if ((code & 0xf3) == 0x81)
3491 code = 0x01 + (code & 0x0c);
3492 else if ((code & 0xf3) == 0x82)
3493 code = 0x02 + (code & 0x0c);
3494 else if ((code & 0xf3) == 0x83)
3495 code = 0x03 + (code & 0x0c);
3499 /* Fix the opcode. */
3500 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3502 /* Fix the relocation's type. */
3503 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3504 (ELF32_R_TYPE (irel->r_info)
3505 == (int) R_MN10300_GOTOFF32)
3506 ? R_MN10300_GOTOFF16
3507 : (ELF32_R_TYPE (irel->r_info)
3508 == (int) R_MN10300_GOT32)
3510 : (ELF32_R_TYPE (irel->r_info)
3511 == (int) R_MN10300_GOTPC32)
3512 ? R_MN10300_GOTPC16 :
3515 /* The opcode got shorter too, so we have to fix the
3516 addend and offset too! */
3517 irel->r_offset -= 1;
3519 /* Delete three bytes of data. */
3520 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3521 irel->r_offset + 1, 3))
3524 /* That will change things, so, we should relax again.
3525 Note that this is not required, and it may be slow. */
3529 /* mov am,(abs32) -> mov am,(abs16)
3530 mov am,(d32,sp) -> mov am,(d16,sp)
3531 mov dm,(d32,sp) -> mov dm,(d32,sp)
3532 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3533 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3539 /* sp-based offsets are zero-extended. */
3540 if (code >= 0x90 && code <= 0x93
3541 && (long) value < 0)
3544 /* Note that we've changed the relocation contents, etc. */
3545 elf_section_data (sec)->relocs = internal_relocs;
3546 elf_section_data (sec)->this_hdr.contents = contents;
3547 symtab_hdr->contents = (unsigned char *) isymbuf;
3549 /* Fix the opcode. */
3550 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3551 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3553 /* Fix the relocation's type. */
3554 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3555 (ELF32_R_TYPE (irel->r_info)
3556 == (int) R_MN10300_GOTOFF32)
3557 ? R_MN10300_GOTOFF16
3558 : (ELF32_R_TYPE (irel->r_info)
3559 == (int) R_MN10300_GOT32)
3561 : (ELF32_R_TYPE (irel->r_info)
3562 == (int) R_MN10300_GOTPC32)
3563 ? R_MN10300_GOTPC16 :
3566 /* Delete two bytes of data. */
3567 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3568 irel->r_offset + 2, 2))
3571 /* That will change things, so, we should relax again.
3572 Note that this is not required, and it may be slow. */
3576 else if ((code & 0xf0) < 0xf0)
3577 switch (code & 0xfc)
3579 /* mov imm32,dn -> mov imm16,dn
3580 mov imm32,an -> mov imm16,an
3581 mov (abs32),dn -> mov (abs16),dn
3582 movbu (abs32),dn -> movbu (abs16),dn
3583 movhu (abs32),dn -> movhu (abs16),dn */
3589 /* Not safe if the high bit is on as relaxing may
3590 move the value out of high mem and thus not fit
3591 in a signed 16bit value. */
3593 && (value & 0x8000))
3596 /* mov imm16, an zero-extends the immediate. */
3598 && (long) value < 0)
3601 /* Note that we've changed the relocation contents, etc. */
3602 elf_section_data (sec)->relocs = internal_relocs;
3603 elf_section_data (sec)->this_hdr.contents = contents;
3604 symtab_hdr->contents = (unsigned char *) isymbuf;
3606 if ((code & 0xfc) == 0xcc)
3607 code = 0x2c + (code & 0x03);
3608 else if ((code & 0xfc) == 0xdc)
3609 code = 0x24 + (code & 0x03);
3610 else if ((code & 0xfc) == 0xa4)
3611 code = 0x30 + (code & 0x03);
3612 else if ((code & 0xfc) == 0xa8)
3613 code = 0x34 + (code & 0x03);
3614 else if ((code & 0xfc) == 0xac)
3615 code = 0x38 + (code & 0x03);
3619 /* Fix the opcode. */
3620 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3622 /* Fix the relocation's type. */
3623 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3624 (ELF32_R_TYPE (irel->r_info)
3625 == (int) R_MN10300_GOTOFF32)
3626 ? R_MN10300_GOTOFF16
3627 : (ELF32_R_TYPE (irel->r_info)
3628 == (int) R_MN10300_GOT32)
3630 : (ELF32_R_TYPE (irel->r_info)
3631 == (int) R_MN10300_GOTPC32)
3632 ? R_MN10300_GOTPC16 :
3635 /* The opcode got shorter too, so we have to fix the
3636 addend and offset too! */
3637 irel->r_offset -= 1;
3639 /* Delete three bytes of data. */
3640 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3641 irel->r_offset + 1, 3))
3644 /* That will change things, so, we should relax again.
3645 Note that this is not required, and it may be slow. */
3649 /* mov (abs32),an -> mov (abs16),an
3650 mov (d32,sp),an -> mov (d16,sp),an
3651 mov (d32,sp),dn -> mov (d16,sp),dn
3652 movbu (d32,sp),dn -> movbu (d16,sp),dn
3653 movhu (d32,sp),dn -> movhu (d16,sp),dn
3654 add imm32,dn -> add imm16,dn
3655 cmp imm32,dn -> cmp imm16,dn
3656 add imm32,an -> add imm16,an
3657 cmp imm32,an -> cmp imm16,an
3658 and imm32,dn -> and imm16,dn
3659 or imm32,dn -> or imm16,dn
3660 xor imm32,dn -> xor imm16,dn
3661 btst imm32,dn -> btst imm16,dn */
3677 /* cmp imm16, an zero-extends the immediate. */
3679 && (long) value < 0)
3682 /* So do sp-based offsets. */
3683 if (code >= 0xb0 && code <= 0xb3
3684 && (long) value < 0)
3687 /* Note that we've changed the relocation contents, etc. */
3688 elf_section_data (sec)->relocs = internal_relocs;
3689 elf_section_data (sec)->this_hdr.contents = contents;
3690 symtab_hdr->contents = (unsigned char *) isymbuf;
3692 /* Fix the opcode. */
3693 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3694 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3696 /* Fix the relocation's type. */
3697 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3698 (ELF32_R_TYPE (irel->r_info)
3699 == (int) R_MN10300_GOTOFF32)
3700 ? R_MN10300_GOTOFF16
3701 : (ELF32_R_TYPE (irel->r_info)
3702 == (int) R_MN10300_GOT32)
3704 : (ELF32_R_TYPE (irel->r_info)
3705 == (int) R_MN10300_GOTPC32)
3706 ? R_MN10300_GOTPC16 :
3709 /* Delete two bytes of data. */
3710 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3711 irel->r_offset + 2, 2))
3714 /* That will change things, so, we should relax again.
3715 Note that this is not required, and it may be slow. */
3719 else if (code == 0xfe)
3721 /* add imm32,sp -> add imm16,sp */
3723 /* Note that we've changed the relocation contents, etc. */
3724 elf_section_data (sec)->relocs = internal_relocs;
3725 elf_section_data (sec)->this_hdr.contents = contents;
3726 symtab_hdr->contents = (unsigned char *) isymbuf;
3728 /* Fix the opcode. */
3729 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3730 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3732 /* Fix the relocation's type. */
3733 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3734 (ELF32_R_TYPE (irel->r_info)
3735 == (int) R_MN10300_GOT32)
3737 : (ELF32_R_TYPE (irel->r_info)
3738 == (int) R_MN10300_GOTOFF32)
3739 ? R_MN10300_GOTOFF16
3740 : (ELF32_R_TYPE (irel->r_info)
3741 == (int) R_MN10300_GOTPC32)
3742 ? R_MN10300_GOTPC16 :
3745 /* Delete two bytes of data. */
3746 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3747 irel->r_offset + 2, 2))
3750 /* That will change things, so, we should relax again.
3751 Note that this is not required, and it may be slow. */
3760 && symtab_hdr->contents != (unsigned char *) isymbuf)
3762 if (! link_info->keep_memory)
3766 /* Cache the symbols for elf_link_input_bfd. */
3767 symtab_hdr->contents = (unsigned char *) isymbuf;
3771 if (contents != NULL
3772 && elf_section_data (sec)->this_hdr.contents != contents)
3774 if (! link_info->keep_memory)
3778 /* Cache the section contents for elf_link_input_bfd. */
3779 elf_section_data (sec)->this_hdr.contents = contents;
3783 if (internal_relocs != NULL
3784 && elf_section_data (sec)->relocs != internal_relocs)
3785 free (internal_relocs);
3791 && symtab_hdr->contents != (unsigned char *) isymbuf)
3793 if (contents != NULL
3794 && elf_section_data (section)->this_hdr.contents != contents)
3796 if (internal_relocs != NULL
3797 && elf_section_data (section)->relocs != internal_relocs)
3798 free (internal_relocs);
3803 /* This is a version of bfd_generic_get_relocated_section_contents
3804 which uses mn10300_elf_relocate_section. */
3807 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3808 struct bfd_link_info *link_info,
3809 struct bfd_link_order *link_order,
3811 bfd_boolean relocatable,
3814 Elf_Internal_Shdr *symtab_hdr;
3815 asection *input_section = link_order->u.indirect.section;
3816 bfd *input_bfd = input_section->owner;
3817 asection **sections = NULL;
3818 Elf_Internal_Rela *internal_relocs = NULL;
3819 Elf_Internal_Sym *isymbuf = NULL;
3821 /* We only need to handle the case of relaxing, or of having a
3822 particular set of section contents, specially. */
3824 || elf_section_data (input_section)->this_hdr.contents == NULL)
3825 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3830 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3832 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3833 (size_t) input_section->size);
3835 if ((input_section->flags & SEC_RELOC) != 0
3836 && input_section->reloc_count > 0)
3839 Elf_Internal_Sym *isym, *isymend;
3842 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3844 if (internal_relocs == NULL)
3847 if (symtab_hdr->sh_info != 0)
3849 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3850 if (isymbuf == NULL)
3851 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3852 symtab_hdr->sh_info, 0,
3854 if (isymbuf == NULL)
3858 amt = symtab_hdr->sh_info;
3859 amt *= sizeof (asection *);
3860 sections = bfd_malloc (amt);
3861 if (sections == NULL && amt != 0)
3864 isymend = isymbuf + symtab_hdr->sh_info;
3865 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3869 if (isym->st_shndx == SHN_UNDEF)
3870 isec = bfd_und_section_ptr;
3871 else if (isym->st_shndx == SHN_ABS)
3872 isec = bfd_abs_section_ptr;
3873 else if (isym->st_shndx == SHN_COMMON)
3874 isec = bfd_com_section_ptr;
3876 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3881 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3882 input_section, data, internal_relocs,
3886 if (sections != NULL)
3888 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3890 if (internal_relocs != elf_section_data (input_section)->relocs)
3891 free (internal_relocs);
3897 if (sections != NULL)
3899 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3901 if (internal_relocs != NULL
3902 && internal_relocs != elf_section_data (input_section)->relocs)
3903 free (internal_relocs);
3907 /* Assorted hash table functions. */
3909 /* Initialize an entry in the link hash table. */
3911 /* Create an entry in an MN10300 ELF linker hash table. */
3913 static struct bfd_hash_entry *
3914 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3915 struct bfd_hash_table *table,
3918 struct elf32_mn10300_link_hash_entry *ret =
3919 (struct elf32_mn10300_link_hash_entry *) entry;
3921 /* Allocate the structure if it has not already been allocated by a
3924 ret = (struct elf32_mn10300_link_hash_entry *)
3925 bfd_hash_allocate (table, sizeof (* ret));
3927 return (struct bfd_hash_entry *) ret;
3929 /* Call the allocation method of the superclass. */
3930 ret = (struct elf32_mn10300_link_hash_entry *)
3931 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3935 ret->direct_calls = 0;
3936 ret->stack_size = 0;
3938 ret->movm_stack_size = 0;
3943 return (struct bfd_hash_entry *) ret;
3946 /* Create an mn10300 ELF linker hash table. */
3948 static struct bfd_link_hash_table *
3949 elf32_mn10300_link_hash_table_create (bfd *abfd)
3951 struct elf32_mn10300_link_hash_table *ret;
3952 bfd_size_type amt = sizeof (* ret);
3954 ret = bfd_malloc (amt);
3958 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3959 elf32_mn10300_link_hash_newfunc,
3960 sizeof (struct elf32_mn10300_link_hash_entry)))
3967 amt = sizeof (struct elf_link_hash_table);
3968 ret->static_hash_table = bfd_malloc (amt);
3969 if (ret->static_hash_table == NULL)
3975 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
3976 elf32_mn10300_link_hash_newfunc,
3977 sizeof (struct elf32_mn10300_link_hash_entry)))
3979 free (ret->static_hash_table);
3983 return & ret->root.root;
3986 /* Free an mn10300 ELF linker hash table. */
3989 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
3991 struct elf32_mn10300_link_hash_table *ret
3992 = (struct elf32_mn10300_link_hash_table *) hash;
3994 _bfd_generic_link_hash_table_free
3995 ((struct bfd_link_hash_table *) ret->static_hash_table);
3996 _bfd_generic_link_hash_table_free
3997 ((struct bfd_link_hash_table *) ret);
4000 static unsigned long
4001 elf_mn10300_mach (flagword flags)
4003 switch (flags & EF_MN10300_MACH)
4005 case E_MN10300_MACH_MN10300:
4007 return bfd_mach_mn10300;
4009 case E_MN10300_MACH_AM33:
4010 return bfd_mach_am33;
4012 case E_MN10300_MACH_AM33_2:
4013 return bfd_mach_am33_2;
4017 /* The final processing done just before writing out a MN10300 ELF object
4018 file. This gets the MN10300 architecture right based on the machine
4022 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
4023 bfd_boolean linker ATTRIBUTE_UNUSED)
4027 switch (bfd_get_mach (abfd))
4030 case bfd_mach_mn10300:
4031 val = E_MN10300_MACH_MN10300;
4035 val = E_MN10300_MACH_AM33;
4038 case bfd_mach_am33_2:
4039 val = E_MN10300_MACH_AM33_2;
4043 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4044 elf_elfheader (abfd)->e_flags |= val;
4048 _bfd_mn10300_elf_object_p (bfd *abfd)
4050 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
4051 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
4055 /* Merge backend specific data from an object file to the output
4056 object file when linking. */
4059 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4061 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4062 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4065 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4066 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4068 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4069 bfd_get_mach (ibfd)))
4076 #define PLT0_ENTRY_SIZE 15
4077 #define PLT_ENTRY_SIZE 20
4078 #define PIC_PLT_ENTRY_SIZE 24
4080 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4082 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4083 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4084 0xf0, 0xf4, /* jmp (a0) */
4087 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4089 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4090 0xf0, 0xf4, /* jmp (a0) */
4091 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4092 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4095 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4097 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4098 0xf0, 0xf4, /* jmp (a0) */
4099 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4100 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4101 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4102 0xf0, 0xf4, /* jmp (a0) */
4105 /* Return size of the first PLT entry. */
4106 #define elf_mn10300_sizeof_plt0(info) \
4107 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4109 /* Return size of a PLT entry. */
4110 #define elf_mn10300_sizeof_plt(info) \
4111 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4113 /* Return offset of the PLT0 address in an absolute PLT entry. */
4114 #define elf_mn10300_plt_plt0_offset(info) 16
4116 /* Return offset of the linker in PLT0 entry. */
4117 #define elf_mn10300_plt0_linker_offset(info) 2
4119 /* Return offset of the GOT id in PLT0 entry. */
4120 #define elf_mn10300_plt0_gotid_offset(info) 9
4122 /* Return offset of the temporary in PLT entry. */
4123 #define elf_mn10300_plt_temp_offset(info) 8
4125 /* Return offset of the symbol in PLT entry. */
4126 #define elf_mn10300_plt_symbol_offset(info) 2
4128 /* Return offset of the relocation in PLT entry. */
4129 #define elf_mn10300_plt_reloc_offset(info) 11
4131 /* The name of the dynamic interpreter. This is put in the .interp
4134 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4136 /* Create dynamic sections when linking against a dynamic object. */
4139 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4143 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4146 switch (bed->s->arch_size)
4157 bfd_set_error (bfd_error_bad_value);
4161 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4162 .rel[a].bss sections. */
4163 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4164 | SEC_LINKER_CREATED);
4166 s = bfd_make_section_with_flags (abfd,
4167 (bed->default_use_rela_p
4168 ? ".rela.plt" : ".rel.plt"),
4169 flags | SEC_READONLY);
4171 || ! bfd_set_section_alignment (abfd, s, ptralign))
4174 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4178 const char * secname;
4183 for (sec = abfd->sections; sec; sec = sec->next)
4185 secflags = bfd_get_section_flags (abfd, sec);
4186 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4187 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4190 secname = bfd_get_section_name (abfd, sec);
4191 relname = bfd_malloc (strlen (secname) + 6);
4192 strcpy (relname, ".rela");
4193 strcat (relname, secname);
4195 s = bfd_make_section_with_flags (abfd, relname,
4196 flags | SEC_READONLY);
4198 || ! bfd_set_section_alignment (abfd, s, ptralign))
4203 if (bed->want_dynbss)
4205 /* The .dynbss section is a place to put symbols which are defined
4206 by dynamic objects, are referenced by regular objects, and are
4207 not functions. We must allocate space for them in the process
4208 image and use a R_*_COPY reloc to tell the dynamic linker to
4209 initialize them at run time. The linker script puts the .dynbss
4210 section into the .bss section of the final image. */
4211 s = bfd_make_section_with_flags (abfd, ".dynbss",
4212 SEC_ALLOC | SEC_LINKER_CREATED);
4216 /* The .rel[a].bss section holds copy relocs. This section is not
4217 normally needed. We need to create it here, though, so that the
4218 linker will map it to an output section. We can't just create it
4219 only if we need it, because we will not know whether we need it
4220 until we have seen all the input files, and the first time the
4221 main linker code calls BFD after examining all the input files
4222 (size_dynamic_sections) the input sections have already been
4223 mapped to the output sections. If the section turns out not to
4224 be needed, we can discard it later. We will never need this
4225 section when generating a shared object, since they do not use
4229 s = bfd_make_section_with_flags (abfd,
4230 (bed->default_use_rela_p
4231 ? ".rela.bss" : ".rel.bss"),
4232 flags | SEC_READONLY);
4234 || ! bfd_set_section_alignment (abfd, s, ptralign))
4242 /* Adjust a symbol defined by a dynamic object and referenced by a
4243 regular object. The current definition is in some section of the
4244 dynamic object, but we're not including those sections. We have to
4245 change the definition to something the rest of the link can
4249 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4250 struct elf_link_hash_entry * h)
4255 dynobj = elf_hash_table (info)->dynobj;
4257 /* Make sure we know what is going on here. */
4258 BFD_ASSERT (dynobj != NULL
4260 || h->u.weakdef != NULL
4263 && !h->def_regular)));
4265 /* If this is a function, put it in the procedure linkage table. We
4266 will fill in the contents of the procedure linkage table later,
4267 when we know the address of the .got section. */
4268 if (h->type == STT_FUNC
4275 /* This case can occur if we saw a PLT reloc in an input
4276 file, but the symbol was never referred to by a dynamic
4277 object. In such a case, we don't actually need to build
4278 a procedure linkage table, and we can just do a REL32
4280 BFD_ASSERT (h->needs_plt);
4284 /* Make sure this symbol is output as a dynamic symbol. */
4285 if (h->dynindx == -1)
4287 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4291 s = bfd_get_section_by_name (dynobj, ".plt");
4292 BFD_ASSERT (s != NULL);
4294 /* If this is the first .plt entry, make room for the special
4297 s->size += elf_mn10300_sizeof_plt0 (info);
4299 /* If this symbol is not defined in a regular file, and we are
4300 not generating a shared library, then set the symbol to this
4301 location in the .plt. This is required to make function
4302 pointers compare as equal between the normal executable and
4303 the shared library. */
4307 h->root.u.def.section = s;
4308 h->root.u.def.value = s->size;
4311 h->plt.offset = s->size;
4313 /* Make room for this entry. */
4314 s->size += elf_mn10300_sizeof_plt (info);
4316 /* We also need to make an entry in the .got.plt section, which
4317 will be placed in the .got section by the linker script. */
4318 s = bfd_get_section_by_name (dynobj, ".got.plt");
4319 BFD_ASSERT (s != NULL);
4322 /* We also need to make an entry in the .rela.plt section. */
4323 s = bfd_get_section_by_name (dynobj, ".rela.plt");
4324 BFD_ASSERT (s != NULL);
4325 s->size += sizeof (Elf32_External_Rela);
4330 /* If this is a weak symbol, and there is a real definition, the
4331 processor independent code will have arranged for us to see the
4332 real definition first, and we can just use the same value. */
4333 if (h->u.weakdef != NULL)
4335 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4336 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4337 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4338 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4342 /* This is a reference to a symbol defined by a dynamic object which
4343 is not a function. */
4345 /* If we are creating a shared library, we must presume that the
4346 only references to the symbol are via the global offset table.
4347 For such cases we need not do anything here; the relocations will
4348 be handled correctly by relocate_section. */
4352 /* If there are no references to this symbol that do not use the
4353 GOT, we don't need to generate a copy reloc. */
4354 if (!h->non_got_ref)
4359 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4360 h->root.root.string);
4364 /* We must allocate the symbol in our .dynbss section, which will
4365 become part of the .bss section of the executable. There will be
4366 an entry for this symbol in the .dynsym section. The dynamic
4367 object will contain position independent code, so all references
4368 from the dynamic object to this symbol will go through the global
4369 offset table. The dynamic linker will use the .dynsym entry to
4370 determine the address it must put in the global offset table, so
4371 both the dynamic object and the regular object will refer to the
4372 same memory location for the variable. */
4374 s = bfd_get_section_by_name (dynobj, ".dynbss");
4375 BFD_ASSERT (s != NULL);
4377 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4378 copy the initial value out of the dynamic object and into the
4379 runtime process image. We need to remember the offset into the
4380 .rela.bss section we are going to use. */
4381 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4385 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4386 BFD_ASSERT (srel != NULL);
4387 srel->size += sizeof (Elf32_External_Rela);
4391 return _bfd_elf_adjust_dynamic_copy (h, s);
4394 /* Set the sizes of the dynamic sections. */
4397 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4398 struct bfd_link_info * info)
4404 bfd_boolean reltext;
4406 dynobj = elf_hash_table (info)->dynobj;
4407 BFD_ASSERT (dynobj != NULL);
4409 if (elf_hash_table (info)->dynamic_sections_created)
4411 /* Set the contents of the .interp section to the interpreter. */
4412 if (info->executable)
4414 s = bfd_get_section_by_name (dynobj, ".interp");
4415 BFD_ASSERT (s != NULL);
4416 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4417 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4422 /* We may have created entries in the .rela.got section.
4423 However, if we are not creating the dynamic sections, we will
4424 not actually use these entries. Reset the size of .rela.got,
4425 which will cause it to get stripped from the output file
4427 s = bfd_get_section_by_name (dynobj, ".rela.got");
4432 /* The check_relocs and adjust_dynamic_symbol entry points have
4433 determined the sizes of the various dynamic sections. Allocate
4438 for (s = dynobj->sections; s != NULL; s = s->next)
4442 if ((s->flags & SEC_LINKER_CREATED) == 0)
4445 /* It's OK to base decisions on the section name, because none
4446 of the dynobj section names depend upon the input files. */
4447 name = bfd_get_section_name (dynobj, s);
4449 if (streq (name, ".plt"))
4451 /* Remember whether there is a PLT. */
4454 else if (CONST_STRNEQ (name, ".rela"))
4460 /* Remember whether there are any reloc sections other
4462 if (! streq (name, ".rela.plt"))
4464 const char * outname;
4468 /* If this relocation section applies to a read only
4469 section, then we probably need a DT_TEXTREL
4470 entry. The entries in the .rela.plt section
4471 really apply to the .got section, which we
4472 created ourselves and so know is not readonly. */
4473 outname = bfd_get_section_name (output_bfd,
4475 target = bfd_get_section_by_name (output_bfd, outname + 5);
4477 && (target->flags & SEC_READONLY) != 0
4478 && (target->flags & SEC_ALLOC) != 0)
4482 /* We use the reloc_count field as a counter if we need
4483 to copy relocs into the output file. */
4487 else if (! CONST_STRNEQ (name, ".got")
4488 && ! streq (name, ".dynbss"))
4489 /* It's not one of our sections, so don't allocate space. */
4494 /* If we don't need this section, strip it from the
4495 output file. This is mostly to handle .rela.bss and
4496 .rela.plt. We must create both sections in
4497 create_dynamic_sections, because they must be created
4498 before the linker maps input sections to output
4499 sections. The linker does that before
4500 adjust_dynamic_symbol is called, and it is that
4501 function which decides whether anything needs to go
4502 into these sections. */
4503 s->flags |= SEC_EXCLUDE;
4507 if ((s->flags & SEC_HAS_CONTENTS) == 0)
4510 /* Allocate memory for the section contents. We use bfd_zalloc
4511 here in case unused entries are not reclaimed before the
4512 section's contents are written out. This should not happen,
4513 but this way if it does, we get a R_MN10300_NONE reloc
4514 instead of garbage. */
4515 s->contents = bfd_zalloc (dynobj, s->size);
4516 if (s->contents == NULL)
4520 if (elf_hash_table (info)->dynamic_sections_created)
4522 /* Add some entries to the .dynamic section. We fill in the
4523 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4524 but we must add the entries now so that we get the correct
4525 size for the .dynamic section. The DT_DEBUG entry is filled
4526 in by the dynamic linker and used by the debugger. */
4529 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
4535 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4536 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4537 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4538 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4544 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4545 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4546 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4547 sizeof (Elf32_External_Rela)))
4553 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
4561 /* Finish up dynamic symbol handling. We set the contents of various
4562 dynamic sections here. */
4565 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4566 struct bfd_link_info * info,
4567 struct elf_link_hash_entry * h,
4568 Elf_Internal_Sym * sym)
4572 dynobj = elf_hash_table (info)->dynobj;
4574 if (h->plt.offset != (bfd_vma) -1)
4581 Elf_Internal_Rela rel;
4583 /* This symbol has an entry in the procedure linkage table. Set
4586 BFD_ASSERT (h->dynindx != -1);
4588 splt = bfd_get_section_by_name (dynobj, ".plt");
4589 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4590 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4591 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4593 /* Get the index in the procedure linkage table which
4594 corresponds to this symbol. This is the index of this symbol
4595 in all the symbols for which we are making plt entries. The
4596 first entry in the procedure linkage table is reserved. */
4597 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4598 / elf_mn10300_sizeof_plt (info));
4600 /* Get the offset into the .got table of the entry that
4601 corresponds to this function. Each .got entry is 4 bytes.
4602 The first three are reserved. */
4603 got_offset = (plt_index + 3) * 4;
4605 /* Fill in the entry in the procedure linkage table. */
4608 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4609 elf_mn10300_sizeof_plt (info));
4610 bfd_put_32 (output_bfd,
4611 (sgot->output_section->vma
4612 + sgot->output_offset
4614 (splt->contents + h->plt.offset
4615 + elf_mn10300_plt_symbol_offset (info)));
4617 bfd_put_32 (output_bfd,
4618 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4619 (splt->contents + h->plt.offset
4620 + elf_mn10300_plt_plt0_offset (info)));
4624 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4625 elf_mn10300_sizeof_plt (info));
4627 bfd_put_32 (output_bfd, got_offset,
4628 (splt->contents + h->plt.offset
4629 + elf_mn10300_plt_symbol_offset (info)));
4632 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4633 (splt->contents + h->plt.offset
4634 + elf_mn10300_plt_reloc_offset (info)));
4636 /* Fill in the entry in the global offset table. */
4637 bfd_put_32 (output_bfd,
4638 (splt->output_section->vma
4639 + splt->output_offset
4641 + elf_mn10300_plt_temp_offset (info)),
4642 sgot->contents + got_offset);
4644 /* Fill in the entry in the .rela.plt section. */
4645 rel.r_offset = (sgot->output_section->vma
4646 + sgot->output_offset
4648 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4650 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4651 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4654 if (!h->def_regular)
4655 /* Mark the symbol as undefined, rather than as defined in
4656 the .plt section. Leave the value alone. */
4657 sym->st_shndx = SHN_UNDEF;
4660 if (h->got.offset != (bfd_vma) -1)
4664 Elf_Internal_Rela rel;
4666 /* This symbol has an entry in the global offset table. Set it up. */
4667 sgot = bfd_get_section_by_name (dynobj, ".got");
4668 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4669 BFD_ASSERT (sgot != NULL && srel != NULL);
4671 rel.r_offset = (sgot->output_section->vma
4672 + sgot->output_offset
4673 + (h->got.offset & ~1));
4675 /* If this is a -Bsymbolic link, and the symbol is defined
4676 locally, we just want to emit a RELATIVE reloc. Likewise if
4677 the symbol was forced to be local because of a version file.
4678 The entry in the global offset table will already have been
4679 initialized in the relocate_section function. */
4681 && (info->symbolic || h->dynindx == -1)
4684 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4685 rel.r_addend = (h->root.u.def.value
4686 + h->root.u.def.section->output_section->vma
4687 + h->root.u.def.section->output_offset);
4691 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4692 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4696 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4697 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4698 + srel->reloc_count));
4699 ++ srel->reloc_count;
4705 Elf_Internal_Rela rel;
4707 /* This symbol needs a copy reloc. Set it up. */
4708 BFD_ASSERT (h->dynindx != -1
4709 && (h->root.type == bfd_link_hash_defined
4710 || h->root.type == bfd_link_hash_defweak));
4712 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4714 BFD_ASSERT (s != NULL);
4716 rel.r_offset = (h->root.u.def.value
4717 + h->root.u.def.section->output_section->vma
4718 + h->root.u.def.section->output_offset);
4719 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4721 bfd_elf32_swap_reloca_out (output_bfd, & rel,
4722 (bfd_byte *) ((Elf32_External_Rela *) s->contents
4727 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4728 if (streq (h->root.root.string, "_DYNAMIC")
4729 || h == elf_hash_table (info)->hgot)
4730 sym->st_shndx = SHN_ABS;
4735 /* Finish up the dynamic sections. */
4738 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4739 struct bfd_link_info * info)
4745 dynobj = elf_hash_table (info)->dynobj;
4747 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4748 BFD_ASSERT (sgot != NULL);
4749 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4751 if (elf_hash_table (info)->dynamic_sections_created)
4754 Elf32_External_Dyn * dyncon;
4755 Elf32_External_Dyn * dynconend;
4757 BFD_ASSERT (sdyn != NULL);
4759 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4760 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4762 for (; dyncon < dynconend; dyncon++)
4764 Elf_Internal_Dyn dyn;
4768 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4782 s = bfd_get_section_by_name (output_bfd, name);
4783 BFD_ASSERT (s != NULL);
4784 dyn.d_un.d_ptr = s->vma;
4785 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4789 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4790 BFD_ASSERT (s != NULL);
4791 dyn.d_un.d_val = s->size;
4792 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4796 /* My reading of the SVR4 ABI indicates that the
4797 procedure linkage table relocs (DT_JMPREL) should be
4798 included in the overall relocs (DT_RELA). This is
4799 what Solaris does. However, UnixWare can not handle
4800 that case. Therefore, we override the DT_RELASZ entry
4801 here to make it not include the JMPREL relocs. Since
4802 the linker script arranges for .rela.plt to follow all
4803 other relocation sections, we don't have to worry
4804 about changing the DT_RELA entry. */
4805 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4807 dyn.d_un.d_val -= s->size;
4808 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4813 /* Fill in the first entry in the procedure linkage table. */
4814 splt = bfd_get_section_by_name (dynobj, ".plt");
4815 if (splt && splt->size > 0)
4819 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4820 elf_mn10300_sizeof_plt (info));
4824 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4825 bfd_put_32 (output_bfd,
4826 sgot->output_section->vma + sgot->output_offset + 4,
4827 splt->contents + elf_mn10300_plt0_gotid_offset (info));
4828 bfd_put_32 (output_bfd,
4829 sgot->output_section->vma + sgot->output_offset + 8,
4830 splt->contents + elf_mn10300_plt0_linker_offset (info));
4833 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4834 really seem like the right value. */
4835 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4839 /* Fill in the first three entries in the global offset table. */
4843 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4845 bfd_put_32 (output_bfd,
4846 sdyn->output_section->vma + sdyn->output_offset,
4848 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4849 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4852 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4857 /* Classify relocation types, such that combreloc can sort them
4860 static enum elf_reloc_type_class
4861 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4863 switch ((int) ELF32_R_TYPE (rela->r_info))
4865 case R_MN10300_RELATIVE: return reloc_class_relative;
4866 case R_MN10300_JMP_SLOT: return reloc_class_plt;
4867 case R_MN10300_COPY: return reloc_class_copy;
4868 default: return reloc_class_normal;
4873 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
4874 #define TARGET_LITTLE_NAME "elf32-mn10300"
4875 #define ELF_ARCH bfd_arch_mn10300
4876 #define ELF_MACHINE_CODE EM_MN10300
4877 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
4878 #define ELF_MAXPAGESIZE 0x1000
4881 #define elf_info_to_howto mn10300_info_to_howto
4882 #define elf_info_to_howto_rel 0
4883 #define elf_backend_can_gc_sections 1
4884 #define elf_backend_rela_normal 1
4885 #define elf_backend_check_relocs mn10300_elf_check_relocs
4886 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
4887 #define elf_backend_relocate_section mn10300_elf_relocate_section
4888 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
4889 #define bfd_elf32_bfd_get_relocated_section_contents \
4890 mn10300_elf_get_relocated_section_contents
4891 #define bfd_elf32_bfd_link_hash_table_create \
4892 elf32_mn10300_link_hash_table_create
4893 #define bfd_elf32_bfd_link_hash_table_free \
4894 elf32_mn10300_link_hash_table_free
4896 #ifndef elf_symbol_leading_char
4897 #define elf_symbol_leading_char '_'
4900 /* So we can set bits in e_flags. */
4901 #define elf_backend_final_write_processing \
4902 _bfd_mn10300_elf_final_write_processing
4903 #define elf_backend_object_p _bfd_mn10300_elf_object_p
4905 #define bfd_elf32_bfd_merge_private_bfd_data \
4906 _bfd_mn10300_elf_merge_private_bfd_data
4908 #define elf_backend_can_gc_sections 1
4909 #define elf_backend_create_dynamic_sections \
4910 _bfd_mn10300_elf_create_dynamic_sections
4911 #define elf_backend_adjust_dynamic_symbol \
4912 _bfd_mn10300_elf_adjust_dynamic_symbol
4913 #define elf_backend_size_dynamic_sections \
4914 _bfd_mn10300_elf_size_dynamic_sections
4915 #define elf_backend_omit_section_dynsym \
4916 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4917 #define elf_backend_finish_dynamic_symbol \
4918 _bfd_mn10300_elf_finish_dynamic_symbol
4919 #define elf_backend_finish_dynamic_sections \
4920 _bfd_mn10300_elf_finish_dynamic_sections
4922 #define elf_backend_reloc_type_class \
4923 _bfd_mn10300_elf_reloc_type_class
4925 #define elf_backend_want_got_plt 1
4926 #define elf_backend_plt_readonly 1
4927 #define elf_backend_want_plt_sym 0
4928 #define elf_backend_got_header_size 12
4930 #include "elf32-target.h"