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 struct elf_link_hash_entry
**sym_hashes
;
665 const Elf_Internal_Rela
*rel
;
666 const Elf_Internal_Rela
*rel_end
;
668 bfd_vma
* local_got_offsets
;
677 if (info
->relocatable
)
680 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
681 sym_hashes
= elf_sym_hashes (abfd
);
683 dynobj
= elf_hash_table (info
)->dynobj
;
684 local_got_offsets
= elf_local_got_offsets (abfd
);
685 rel_end
= relocs
+ sec
->reloc_count
;
686 sym_diff_reloc_seen
= FALSE
;
688 for (rel
= relocs
; rel
< rel_end
; rel
++)
690 struct elf_link_hash_entry
*h
;
691 unsigned long r_symndx
;
693 r_symndx
= ELF32_R_SYM (rel
->r_info
);
694 if (r_symndx
< symtab_hdr
->sh_info
)
698 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
699 while (h
->root
.type
== bfd_link_hash_indirect
700 || h
->root
.type
== bfd_link_hash_warning
)
701 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
704 /* Some relocs require a global offset table. */
707 switch (ELF32_R_TYPE (rel
->r_info
))
709 case R_MN10300_GOT32
:
710 case R_MN10300_GOT24
:
711 case R_MN10300_GOT16
:
712 case R_MN10300_GOTOFF32
:
713 case R_MN10300_GOTOFF24
:
714 case R_MN10300_GOTOFF16
:
715 case R_MN10300_GOTPC32
:
716 case R_MN10300_GOTPC16
:
717 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
718 if (! _bfd_mn10300_elf_create_got_section (dynobj
, info
))
727 switch (ELF32_R_TYPE (rel
->r_info
))
729 /* This relocation describes the C++ object vtable hierarchy.
730 Reconstruct it for later use during GC. */
731 case R_MN10300_GNU_VTINHERIT
:
732 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
736 /* This relocation describes which C++ vtable entries are actually
737 used. Record for later use during GC. */
738 case R_MN10300_GNU_VTENTRY
:
739 BFD_ASSERT (h
!= NULL
);
741 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
744 case R_MN10300_GOT32
:
745 case R_MN10300_GOT24
:
746 case R_MN10300_GOT16
:
747 /* This symbol requires a global offset table entry. */
751 sgot
= bfd_get_section_by_name (dynobj
, ".got");
752 BFD_ASSERT (sgot
!= NULL
);
756 && (h
!= NULL
|| info
->shared
))
758 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
761 srelgot
= bfd_make_section_with_flags (dynobj
,
770 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
777 if (h
->got
.offset
!= (bfd_vma
) -1)
778 /* We have already allocated space in the .got. */
781 h
->got
.offset
= sgot
->size
;
783 /* Make sure this symbol is output as a dynamic symbol. */
784 if (h
->dynindx
== -1)
786 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
790 srelgot
->size
+= sizeof (Elf32_External_Rela
);
794 /* This is a global offset table entry for a local
796 if (local_got_offsets
== NULL
)
801 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
802 local_got_offsets
= bfd_alloc (abfd
, size
);
804 if (local_got_offsets
== NULL
)
806 elf_local_got_offsets (abfd
) = local_got_offsets
;
808 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
809 local_got_offsets
[i
] = (bfd_vma
) -1;
812 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
813 /* We have already allocated space in the .got. */
816 local_got_offsets
[r_symndx
] = sgot
->size
;
819 /* If we are generating a shared object, we need to
820 output a R_MN10300_RELATIVE reloc so that the dynamic
821 linker can adjust this GOT entry. */
822 srelgot
->size
+= sizeof (Elf32_External_Rela
);
828 case R_MN10300_PLT32
:
829 case R_MN10300_PLT16
:
830 /* This symbol requires a procedure linkage table entry. We
831 actually build the entry in adjust_dynamic_symbol,
832 because this might be a case of linking PIC code which is
833 never referenced by a dynamic object, in which case we
834 don't need to generate a procedure linkage table entry
837 /* If this is a local symbol, we resolve it directly without
838 creating a procedure linkage table entry. */
842 if (ELF_ST_VISIBILITY (h
->other
) == STV_INTERNAL
843 || ELF_ST_VISIBILITY (h
->other
) == STV_HIDDEN
)
852 case R_MN10300_PCREL32
:
853 case R_MN10300_PCREL16
:
854 case R_MN10300_PCREL8
:
859 case R_MN10300_SYM_DIFF
:
860 sym_diff_reloc_seen
= TRUE
;
867 /* If we are creating a shared library, then we
868 need to copy the reloc into the shared library. */
870 && (sec
->flags
& SEC_ALLOC
) != 0
871 /* Do not generate a dynamic reloc for a
872 reloc associated with a SYM_DIFF operation. */
873 && ! sym_diff_reloc_seen
)
875 asection
* sym_section
= NULL
;
877 /* Find the section containing the
878 symbol involved in the relocation. */
881 Elf_Internal_Sym
* isymbuf
;
882 Elf_Internal_Sym
* isym
;
884 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
886 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
887 symtab_hdr
->sh_info
, 0,
891 isym
= isymbuf
+ r_symndx
;
892 /* All we care about is whether this local symbol is absolute. */
893 if (isym
->st_shndx
== SHN_ABS
)
894 sym_section
= bfd_abs_section_ptr
;
899 if (h
->root
.type
== bfd_link_hash_defined
900 || h
->root
.type
== bfd_link_hash_defweak
)
901 sym_section
= h
->root
.u
.def
.section
;
904 /* If the symbol is absolute then the relocation can
905 be resolved during linking and there is no need for
907 if (sym_section
!= bfd_abs_section_ptr
)
909 /* When creating a shared object, we must copy these
910 reloc types into the output file. We create a reloc
911 section in dynobj and make room for this reloc. */
916 name
= (bfd_elf_string_from_elf_section
918 elf_elfheader (abfd
)->e_shstrndx
,
919 elf_section_data (sec
)->rel_hdr
.sh_name
));
923 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
924 && streq (bfd_get_section_name (abfd
, sec
), name
+ 5));
926 sreloc
= bfd_get_section_by_name (dynobj
, name
);
931 flags
= (SEC_HAS_CONTENTS
| SEC_READONLY
932 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
933 if ((sec
->flags
& SEC_ALLOC
) != 0)
934 flags
|= SEC_ALLOC
| SEC_LOAD
;
935 sreloc
= bfd_make_section_with_flags (dynobj
, name
, flags
);
937 || ! bfd_set_section_alignment (dynobj
, sreloc
, 2))
942 sreloc
->size
+= sizeof (Elf32_External_Rela
);
949 if (ELF32_R_TYPE (rel
->r_info
) != R_MN10300_SYM_DIFF
)
950 sym_diff_reloc_seen
= FALSE
;
956 /* Return the section that should be marked against GC for a given
960 mn10300_elf_gc_mark_hook (asection
*sec
,
961 struct bfd_link_info
*info
,
962 Elf_Internal_Rela
*rel
,
963 struct elf_link_hash_entry
*h
,
964 Elf_Internal_Sym
*sym
)
967 switch (ELF32_R_TYPE (rel
->r_info
))
969 case R_MN10300_GNU_VTINHERIT
:
970 case R_MN10300_GNU_VTENTRY
:
974 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
977 /* Perform a relocation as part of a final link. */
979 static bfd_reloc_status_type
980 mn10300_elf_final_link_relocate (reloc_howto_type
*howto
,
982 bfd
*output_bfd ATTRIBUTE_UNUSED
,
983 asection
*input_section
,
988 struct elf_link_hash_entry
* h
,
989 unsigned long symndx
,
990 struct bfd_link_info
*info
,
991 asection
*sym_sec ATTRIBUTE_UNUSED
,
992 int is_local ATTRIBUTE_UNUSED
)
994 static asection
* sym_diff_section
;
995 static bfd_vma sym_diff_value
;
996 bfd_boolean is_sym_diff_reloc
;
997 unsigned long r_type
= howto
->type
;
998 bfd_byte
* hit_data
= contents
+ offset
;
1000 bfd_vma
* local_got_offsets
;
1005 dynobj
= elf_hash_table (info
)->dynobj
;
1006 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1017 case R_MN10300_PCREL8
:
1018 case R_MN10300_PCREL16
:
1019 case R_MN10300_PCREL32
:
1020 case R_MN10300_GOTOFF32
:
1021 case R_MN10300_GOTOFF24
:
1022 case R_MN10300_GOTOFF16
:
1024 && (input_section
->flags
& SEC_ALLOC
) != 0
1026 && ! SYMBOL_REFERENCES_LOCAL (info
, h
))
1027 return bfd_reloc_dangerous
;
1030 is_sym_diff_reloc
= FALSE
;
1031 if (sym_diff_section
!= NULL
)
1033 BFD_ASSERT (sym_diff_section
== input_section
);
1041 value
-= sym_diff_value
;
1042 /* If we are computing a 32-bit value for the location lists
1043 and the result is 0 then we add one to the value. A zero
1044 value can result because of linker relaxation deleteing
1045 prologue instructions and using a value of 1 (for the begin
1046 and end offsets in the location list entry) results in a
1047 nul entry which does not prevent the following entries from
1049 if (r_type
== R_MN10300_32
1051 && strcmp (input_section
->name
, ".debug_loc") == 0)
1053 sym_diff_section
= NULL
;
1054 is_sym_diff_reloc
= TRUE
;
1058 sym_diff_section
= NULL
;
1065 case R_MN10300_SYM_DIFF
:
1066 BFD_ASSERT (addend
== 0);
1067 /* Cache the input section and value.
1068 The offset is unreliable, since relaxation may
1069 have reduced the following reloc's offset. */
1070 sym_diff_section
= input_section
;
1071 sym_diff_value
= value
;
1072 return bfd_reloc_ok
;
1074 case R_MN10300_ALIGN
:
1075 case R_MN10300_NONE
:
1076 return bfd_reloc_ok
;
1080 /* Do not generate relocs when an R_MN10300_32 has been used
1081 with an R_MN10300_SYM_DIFF to compute a difference of two
1083 && is_sym_diff_reloc
== FALSE
1084 /* Also, do not generate a reloc when the symbol associated
1085 with the R_MN10300_32 reloc is absolute - there is no
1086 need for a run time computation in this case. */
1087 && sym_sec
!= bfd_abs_section_ptr
1088 /* If the section is not going to be allocated at load time
1089 then there is no need to generate relocs for it. */
1090 && (input_section
->flags
& SEC_ALLOC
) != 0)
1092 Elf_Internal_Rela outrel
;
1093 bfd_boolean skip
, relocate
;
1095 /* When generating a shared object, these relocations are
1096 copied into the output file to be resolved at run
1102 name
= (bfd_elf_string_from_elf_section
1104 elf_elfheader (input_bfd
)->e_shstrndx
,
1105 elf_section_data (input_section
)->rel_hdr
.sh_name
));
1109 BFD_ASSERT (CONST_STRNEQ (name
, ".rela")
1110 && streq (bfd_get_section_name (input_bfd
,
1114 sreloc
= bfd_get_section_by_name (dynobj
, name
);
1115 BFD_ASSERT (sreloc
!= NULL
);
1120 outrel
.r_offset
= _bfd_elf_section_offset (input_bfd
, info
,
1121 input_section
, offset
);
1122 if (outrel
.r_offset
== (bfd_vma
) -1)
1125 outrel
.r_offset
+= (input_section
->output_section
->vma
1126 + input_section
->output_offset
);
1130 memset (&outrel
, 0, sizeof outrel
);
1135 /* h->dynindx may be -1 if this symbol was marked to
1138 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1141 outrel
.r_info
= ELF32_R_INFO (0, R_MN10300_RELATIVE
);
1142 outrel
.r_addend
= value
+ addend
;
1146 BFD_ASSERT (h
->dynindx
!= -1);
1148 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MN10300_32
);
1149 outrel
.r_addend
= value
+ addend
;
1153 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1154 (bfd_byte
*) (((Elf32_External_Rela
*) sreloc
->contents
)
1155 + sreloc
->reloc_count
));
1156 ++sreloc
->reloc_count
;
1158 /* If this reloc is against an external symbol, we do
1159 not want to fiddle with the addend. Otherwise, we
1160 need to include the symbol value so that it becomes
1161 an addend for the dynamic reloc. */
1163 return bfd_reloc_ok
;
1166 bfd_put_32 (input_bfd
, value
, hit_data
);
1167 return bfd_reloc_ok
;
1172 if ((long) value
> 0x7fffff || (long) value
< -0x800000)
1173 return bfd_reloc_overflow
;
1175 bfd_put_8 (input_bfd
, value
& 0xff, hit_data
);
1176 bfd_put_8 (input_bfd
, (value
>> 8) & 0xff, hit_data
+ 1);
1177 bfd_put_8 (input_bfd
, (value
>> 16) & 0xff, hit_data
+ 2);
1178 return bfd_reloc_ok
;
1183 if ((long) value
> 0x7fff || (long) value
< -0x8000)
1184 return bfd_reloc_overflow
;
1186 bfd_put_16 (input_bfd
, value
, hit_data
);
1187 return bfd_reloc_ok
;
1192 if ((long) value
> 0x7f || (long) value
< -0x80)
1193 return bfd_reloc_overflow
;
1195 bfd_put_8 (input_bfd
, value
, hit_data
);
1196 return bfd_reloc_ok
;
1198 case R_MN10300_PCREL8
:
1199 value
-= (input_section
->output_section
->vma
1200 + input_section
->output_offset
);
1204 if ((long) value
> 0xff || (long) value
< -0x100)
1205 return bfd_reloc_overflow
;
1207 bfd_put_8 (input_bfd
, value
, hit_data
);
1208 return bfd_reloc_ok
;
1210 case R_MN10300_PCREL16
:
1211 value
-= (input_section
->output_section
->vma
1212 + input_section
->output_offset
);
1216 if ((long) value
> 0xffff || (long) value
< -0x10000)
1217 return bfd_reloc_overflow
;
1219 bfd_put_16 (input_bfd
, value
, hit_data
);
1220 return bfd_reloc_ok
;
1222 case R_MN10300_PCREL32
:
1223 value
-= (input_section
->output_section
->vma
1224 + input_section
->output_offset
);
1228 bfd_put_32 (input_bfd
, value
, hit_data
);
1229 return bfd_reloc_ok
;
1231 case R_MN10300_GNU_VTINHERIT
:
1232 case R_MN10300_GNU_VTENTRY
:
1233 return bfd_reloc_ok
;
1235 case R_MN10300_GOTPC32
:
1236 /* Use global offset table as symbol value. */
1237 value
= bfd_get_section_by_name (dynobj
,
1238 ".got")->output_section
->vma
;
1239 value
-= (input_section
->output_section
->vma
1240 + input_section
->output_offset
);
1244 bfd_put_32 (input_bfd
, value
, hit_data
);
1245 return bfd_reloc_ok
;
1247 case R_MN10300_GOTPC16
:
1248 /* Use global offset table as symbol value. */
1249 value
= bfd_get_section_by_name (dynobj
,
1250 ".got")->output_section
->vma
;
1251 value
-= (input_section
->output_section
->vma
1252 + input_section
->output_offset
);
1256 if ((long) value
> 0xffff || (long) value
< -0x10000)
1257 return bfd_reloc_overflow
;
1259 bfd_put_16 (input_bfd
, value
, hit_data
);
1260 return bfd_reloc_ok
;
1262 case R_MN10300_GOTOFF32
:
1263 value
-= bfd_get_section_by_name (dynobj
,
1264 ".got")->output_section
->vma
;
1267 bfd_put_32 (input_bfd
, value
, hit_data
);
1268 return bfd_reloc_ok
;
1270 case R_MN10300_GOTOFF24
:
1271 value
-= bfd_get_section_by_name (dynobj
,
1272 ".got")->output_section
->vma
;
1275 if ((long) value
> 0x7fffff || (long) value
< -0x800000)
1276 return bfd_reloc_overflow
;
1278 bfd_put_8 (input_bfd
, value
, hit_data
);
1279 bfd_put_8 (input_bfd
, (value
>> 8) & 0xff, hit_data
+ 1);
1280 bfd_put_8 (input_bfd
, (value
>> 16) & 0xff, hit_data
+ 2);
1281 return bfd_reloc_ok
;
1283 case R_MN10300_GOTOFF16
:
1284 value
-= bfd_get_section_by_name (dynobj
,
1285 ".got")->output_section
->vma
;
1288 if ((long) value
> 0xffff || (long) value
< -0x10000)
1289 return bfd_reloc_overflow
;
1291 bfd_put_16 (input_bfd
, value
, hit_data
);
1292 return bfd_reloc_ok
;
1294 case R_MN10300_PLT32
:
1296 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
1297 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
1298 && h
->plt
.offset
!= (bfd_vma
) -1)
1302 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1304 value
= (splt
->output_section
->vma
1305 + splt
->output_offset
1306 + h
->plt
.offset
) - value
;
1309 value
-= (input_section
->output_section
->vma
1310 + input_section
->output_offset
);
1314 bfd_put_32 (input_bfd
, value
, hit_data
);
1315 return bfd_reloc_ok
;
1317 case R_MN10300_PLT16
:
1319 && ELF_ST_VISIBILITY (h
->other
) != STV_INTERNAL
1320 && ELF_ST_VISIBILITY (h
->other
) != STV_HIDDEN
1321 && h
->plt
.offset
!= (bfd_vma
) -1)
1325 splt
= bfd_get_section_by_name (dynobj
, ".plt");
1327 value
= (splt
->output_section
->vma
1328 + splt
->output_offset
1329 + h
->plt
.offset
) - value
;
1332 value
-= (input_section
->output_section
->vma
1333 + input_section
->output_offset
);
1337 if ((long) value
> 0xffff || (long) value
< -0x10000)
1338 return bfd_reloc_overflow
;
1340 bfd_put_16 (input_bfd
, value
, hit_data
);
1341 return bfd_reloc_ok
;
1343 case R_MN10300_GOT32
:
1344 case R_MN10300_GOT24
:
1345 case R_MN10300_GOT16
:
1349 sgot
= bfd_get_section_by_name (dynobj
, ".got");
1355 off
= h
->got
.offset
;
1356 BFD_ASSERT (off
!= (bfd_vma
) -1);
1358 if (! elf_hash_table (info
)->dynamic_sections_created
1359 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1360 /* This is actually a static link, or it is a
1361 -Bsymbolic link and the symbol is defined
1362 locally, or the symbol was forced to be local
1363 because of a version file. We must initialize
1364 this entry in the global offset table.
1366 When doing a dynamic link, we create a .rela.got
1367 relocation entry to initialize the value. This
1368 is done in the finish_dynamic_symbol routine. */
1369 bfd_put_32 (output_bfd
, value
,
1370 sgot
->contents
+ off
);
1372 value
= sgot
->output_offset
+ off
;
1378 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1380 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ off
);
1385 Elf_Internal_Rela outrel
;
1387 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
1388 BFD_ASSERT (srelgot
!= NULL
);
1390 outrel
.r_offset
= (sgot
->output_section
->vma
1391 + sgot
->output_offset
1393 outrel
.r_info
= ELF32_R_INFO (0, R_MN10300_RELATIVE
);
1394 outrel
.r_addend
= value
;
1395 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
,
1396 (bfd_byte
*) (((Elf32_External_Rela
*)
1398 + srelgot
->reloc_count
));
1399 ++ srelgot
->reloc_count
;
1402 value
= sgot
->output_offset
+ off
;
1408 if (r_type
== R_MN10300_GOT32
)
1410 bfd_put_32 (input_bfd
, value
, hit_data
);
1411 return bfd_reloc_ok
;
1413 else if (r_type
== R_MN10300_GOT24
)
1415 if ((long) value
> 0x7fffff || (long) value
< -0x800000)
1416 return bfd_reloc_overflow
;
1418 bfd_put_8 (input_bfd
, value
& 0xff, hit_data
);
1419 bfd_put_8 (input_bfd
, (value
>> 8) & 0xff, hit_data
+ 1);
1420 bfd_put_8 (input_bfd
, (value
>> 16) & 0xff, hit_data
+ 2);
1421 return bfd_reloc_ok
;
1423 else if (r_type
== R_MN10300_GOT16
)
1425 if ((long) value
> 0xffff || (long) value
< -0x10000)
1426 return bfd_reloc_overflow
;
1428 bfd_put_16 (input_bfd
, value
, hit_data
);
1429 return bfd_reloc_ok
;
1434 return bfd_reloc_notsupported
;
1438 /* Relocate an MN10300 ELF section. */
1441 mn10300_elf_relocate_section (bfd
*output_bfd
,
1442 struct bfd_link_info
*info
,
1444 asection
*input_section
,
1446 Elf_Internal_Rela
*relocs
,
1447 Elf_Internal_Sym
*local_syms
,
1448 asection
**local_sections
)
1450 Elf_Internal_Shdr
*symtab_hdr
;
1451 struct elf_link_hash_entry
**sym_hashes
;
1452 Elf_Internal_Rela
*rel
, *relend
;
1454 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1455 sym_hashes
= elf_sym_hashes (input_bfd
);
1458 relend
= relocs
+ input_section
->reloc_count
;
1459 for (; rel
< relend
; rel
++)
1462 reloc_howto_type
*howto
;
1463 unsigned long r_symndx
;
1464 Elf_Internal_Sym
*sym
;
1466 struct elf32_mn10300_link_hash_entry
*h
;
1468 bfd_reloc_status_type r
;
1470 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1471 r_type
= ELF32_R_TYPE (rel
->r_info
);
1472 howto
= elf_mn10300_howto_table
+ r_type
;
1474 /* Just skip the vtable gc relocs. */
1475 if (r_type
== R_MN10300_GNU_VTINHERIT
1476 || r_type
== R_MN10300_GNU_VTENTRY
)
1482 if (r_symndx
< symtab_hdr
->sh_info
)
1484 sym
= local_syms
+ r_symndx
;
1485 sec
= local_sections
[r_symndx
];
1486 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1490 bfd_boolean unresolved_reloc
;
1492 struct elf_link_hash_entry
*hh
;
1494 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1495 r_symndx
, symtab_hdr
, sym_hashes
,
1496 hh
, sec
, relocation
,
1497 unresolved_reloc
, warned
);
1499 h
= (struct elf32_mn10300_link_hash_entry
*) hh
;
1501 if ((h
->root
.root
.type
== bfd_link_hash_defined
1502 || h
->root
.root
.type
== bfd_link_hash_defweak
)
1503 && ( r_type
== R_MN10300_GOTPC32
1504 || r_type
== R_MN10300_GOTPC16
1505 || (( r_type
== R_MN10300_PLT32
1506 || r_type
== R_MN10300_PLT16
)
1507 && ELF_ST_VISIBILITY (h
->root
.other
) != STV_INTERNAL
1508 && ELF_ST_VISIBILITY (h
->root
.other
) != STV_HIDDEN
1509 && h
->root
.plt
.offset
!= (bfd_vma
) -1)
1510 || (( r_type
== R_MN10300_GOT32
1511 || r_type
== R_MN10300_GOT24
1512 || r_type
== R_MN10300_GOT16
)
1513 && elf_hash_table (info
)->dynamic_sections_created
1514 && !SYMBOL_REFERENCES_LOCAL (info
, hh
))
1515 || (r_type
== R_MN10300_32
1516 /* _32 relocs in executables force _COPY relocs,
1517 such that the address of the symbol ends up
1519 && !info
->executable
1520 && !SYMBOL_REFERENCES_LOCAL (info
, hh
)
1521 && ((input_section
->flags
& SEC_ALLOC
) != 0
1522 /* DWARF will emit R_MN10300_32 relocations
1523 in its sections against symbols defined
1524 externally in shared libraries. We can't
1525 do anything with them here. */
1526 || ((input_section
->flags
& SEC_DEBUGGING
) != 0
1527 && h
->root
.def_dynamic
)))))
1528 /* In these cases, we don't need the relocation
1529 value. We check specially because in some
1530 obscure cases sec->output_section will be NULL. */
1533 else if (!info
->relocatable
&& unresolved_reloc
)
1534 (*_bfd_error_handler
)
1535 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1538 (long) rel
->r_offset
,
1540 h
->root
.root
.root
.string
);
1543 if (sec
!= NULL
&& elf_discarded_section (sec
))
1545 /* For relocs against symbols from removed linkonce sections,
1546 or sections discarded by a linker script, we just want the
1547 section contents zeroed. Avoid any special processing. */
1548 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
1554 if (info
->relocatable
)
1557 r
= mn10300_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
1559 contents
, rel
->r_offset
,
1560 relocation
, rel
->r_addend
,
1561 (struct elf_link_hash_entry
*) h
,
1563 info
, sec
, h
== NULL
);
1565 if (r
!= bfd_reloc_ok
)
1568 const char *msg
= NULL
;
1571 name
= h
->root
.root
.root
.string
;
1574 name
= (bfd_elf_string_from_elf_section
1575 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1576 if (name
== NULL
|| *name
== '\0')
1577 name
= bfd_section_name (input_bfd
, sec
);
1582 case bfd_reloc_overflow
:
1583 if (! ((*info
->callbacks
->reloc_overflow
)
1584 (info
, (h
? &h
->root
.root
: NULL
), name
,
1585 howto
->name
, (bfd_vma
) 0, input_bfd
,
1586 input_section
, rel
->r_offset
)))
1590 case bfd_reloc_undefined
:
1591 if (! ((*info
->callbacks
->undefined_symbol
)
1592 (info
, name
, input_bfd
, input_section
,
1593 rel
->r_offset
, TRUE
)))
1597 case bfd_reloc_outofrange
:
1598 msg
= _("internal error: out of range error");
1601 case bfd_reloc_notsupported
:
1602 msg
= _("internal error: unsupported relocation error");
1605 case bfd_reloc_dangerous
:
1606 if (r_type
== R_MN10300_PCREL32
)
1607 msg
= _("error: inappropriate relocation type for shared"
1608 " library (did you forget -fpic?)");
1610 msg
= _("internal error: suspicious relocation type used"
1611 " in shared library");
1615 msg
= _("internal error: unknown error");
1619 if (!((*info
->callbacks
->warning
)
1620 (info
, msg
, name
, input_bfd
, input_section
,
1631 /* Finish initializing one hash table entry. */
1634 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry
*gen_entry
,
1637 struct elf32_mn10300_link_hash_entry
*entry
;
1638 struct bfd_link_info
*link_info
= (struct bfd_link_info
*) in_args
;
1639 unsigned int byte_count
= 0;
1641 entry
= (struct elf32_mn10300_link_hash_entry
*) gen_entry
;
1643 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
1644 entry
= (struct elf32_mn10300_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
1646 /* If we already know we want to convert "call" to "calls" for calls
1647 to this symbol, then return now. */
1648 if (entry
->flags
== MN10300_CONVERT_CALL_TO_CALLS
)
1651 /* If there are no named calls to this symbol, or there's nothing we
1652 can move from the function itself into the "call" instruction,
1653 then note that all "call" instructions should be converted into
1654 "calls" instructions and return. If a symbol is available for
1655 dynamic symbol resolution (overridable or overriding), avoid
1656 custom calling conventions. */
1657 if (entry
->direct_calls
== 0
1658 || (entry
->stack_size
== 0 && entry
->movm_args
== 0)
1659 || (elf_hash_table (link_info
)->dynamic_sections_created
1660 && ELF_ST_VISIBILITY (entry
->root
.other
) != STV_INTERNAL
1661 && ELF_ST_VISIBILITY (entry
->root
.other
) != STV_HIDDEN
))
1663 /* Make a note that we should convert "call" instructions to "calls"
1664 instructions for calls to this symbol. */
1665 entry
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
1669 /* We may be able to move some instructions from the function itself into
1670 the "call" instruction. Count how many bytes we might be able to
1671 eliminate in the function itself. */
1673 /* A movm instruction is two bytes. */
1674 if (entry
->movm_args
)
1677 /* Count the insn to allocate stack space too. */
1678 if (entry
->stack_size
> 0)
1680 if (entry
->stack_size
<= 128)
1686 /* If using "call" will result in larger code, then turn all
1687 the associated "call" instructions into "calls" instructions. */
1688 if (byte_count
< entry
->direct_calls
)
1689 entry
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
1691 /* This routine never fails. */
1695 /* Used to count hash table entries. */
1698 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry
*gen_entry ATTRIBUTE_UNUSED
,
1701 int *count
= (int *) in_args
;
1707 /* Used to enumerate hash table entries into a linear array. */
1710 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry
*gen_entry
,
1713 struct bfd_hash_entry
***ptr
= (struct bfd_hash_entry
***) in_args
;
1720 /* Used to sort the array created by the above. */
1723 sort_by_value (const void *va
, const void *vb
)
1725 struct elf32_mn10300_link_hash_entry
*a
1726 = *(struct elf32_mn10300_link_hash_entry
**) va
;
1727 struct elf32_mn10300_link_hash_entry
*b
1728 = *(struct elf32_mn10300_link_hash_entry
**) vb
;
1730 return a
->value
- b
->value
;
1733 /* Compute the stack size and movm arguments for the function
1734 referred to by HASH at address ADDR in section with
1735 contents CONTENTS, store the information in the hash table. */
1738 compute_function_info (bfd
*abfd
,
1739 struct elf32_mn10300_link_hash_entry
*hash
,
1741 unsigned char *contents
)
1743 unsigned char byte1
, byte2
;
1744 /* We only care about a very small subset of the possible prologue
1745 sequences here. Basically we look for:
1747 movm [d2,d3,a2,a3],sp (optional)
1748 add <size>,sp (optional, and only for sizes which fit in an unsigned
1751 If we find anything else, we quit. */
1753 /* Look for movm [regs],sp. */
1754 byte1
= bfd_get_8 (abfd
, contents
+ addr
);
1755 byte2
= bfd_get_8 (abfd
, contents
+ addr
+ 1);
1759 hash
->movm_args
= byte2
;
1761 byte1
= bfd_get_8 (abfd
, contents
+ addr
);
1762 byte2
= bfd_get_8 (abfd
, contents
+ addr
+ 1);
1765 /* Now figure out how much stack space will be allocated by the movm
1766 instruction. We need this kept separate from the function's normal
1768 if (hash
->movm_args
)
1771 if (hash
->movm_args
& 0x80)
1772 hash
->movm_stack_size
+= 4;
1775 if (hash
->movm_args
& 0x40)
1776 hash
->movm_stack_size
+= 4;
1779 if (hash
->movm_args
& 0x20)
1780 hash
->movm_stack_size
+= 4;
1783 if (hash
->movm_args
& 0x10)
1784 hash
->movm_stack_size
+= 4;
1786 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
1787 if (hash
->movm_args
& 0x08)
1788 hash
->movm_stack_size
+= 8 * 4;
1790 if (bfd_get_mach (abfd
) == bfd_mach_am33
1791 || bfd_get_mach (abfd
) == bfd_mach_am33_2
)
1793 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
1794 if (hash
->movm_args
& 0x1)
1795 hash
->movm_stack_size
+= 6 * 4;
1797 /* exreg1 space. e4, e5, e6, e7 */
1798 if (hash
->movm_args
& 0x2)
1799 hash
->movm_stack_size
+= 4 * 4;
1801 /* exreg0 space. e2, e3 */
1802 if (hash
->movm_args
& 0x4)
1803 hash
->movm_stack_size
+= 2 * 4;
1807 /* Now look for the two stack adjustment variants. */
1808 if (byte1
== 0xf8 && byte2
== 0xfe)
1810 int temp
= bfd_get_8 (abfd
, contents
+ addr
+ 2);
1811 temp
= ((temp
& 0xff) ^ (~0x7f)) + 0x80;
1813 hash
->stack_size
= -temp
;
1815 else if (byte1
== 0xfa && byte2
== 0xfe)
1817 int temp
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
1818 temp
= ((temp
& 0xffff) ^ (~0x7fff)) + 0x8000;
1822 hash
->stack_size
= temp
;
1825 /* If the total stack to be allocated by the call instruction is more
1826 than 255 bytes, then we can't remove the stack adjustment by using
1827 "call" (we might still be able to remove the "movm" instruction. */
1828 if (hash
->stack_size
+ hash
->movm_stack_size
> 255)
1829 hash
->stack_size
= 0;
1832 /* Delete some bytes from a section while relaxing. */
1835 mn10300_elf_relax_delete_bytes (bfd
*abfd
,
1840 Elf_Internal_Shdr
*symtab_hdr
;
1841 unsigned int sec_shndx
;
1843 Elf_Internal_Rela
*irel
, *irelend
;
1844 Elf_Internal_Rela
*irelalign
;
1846 Elf_Internal_Sym
*isym
, *isymend
;
1847 struct elf_link_hash_entry
**sym_hashes
;
1848 struct elf_link_hash_entry
**end_hashes
;
1849 unsigned int symcount
;
1851 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1853 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1858 irel
= elf_section_data (sec
)->relocs
;
1859 irelend
= irel
+ sec
->reloc_count
;
1861 if (sec
->reloc_count
> 0)
1863 /* If there is an align reloc at the end of the section ignore it.
1864 GAS creates these relocs for reasons of its own, and they just
1865 serve to keep the section artifically inflated. */
1866 if (ELF32_R_TYPE ((irelend
- 1)->r_info
) == (int) R_MN10300_ALIGN
)
1869 /* The deletion must stop at the next ALIGN reloc for an aligment
1870 power larger than, or not a multiple of, the number of bytes we
1872 for (; irel
< irelend
; irel
++)
1874 int alignment
= 1 << irel
->r_addend
;
1876 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_ALIGN
1877 && irel
->r_offset
> addr
1878 && irel
->r_offset
< toaddr
1879 && (count
< alignment
1880 || alignment
% count
!= 0))
1883 toaddr
= irel
->r_offset
;
1889 /* Actually delete the bytes. */
1890 memmove (contents
+ addr
, contents
+ addr
+ count
,
1891 (size_t) (toaddr
- addr
- count
));
1893 /* Adjust the section's size if we are shrinking it, or else
1894 pad the bytes between the end of the shrunken region and
1895 the start of the next region with NOP codes. */
1896 if (irelalign
== NULL
)
1899 /* Include symbols at the end of the section, but
1900 not at the end of a sub-region of the section. */
1907 #define NOP_OPCODE 0xcb
1909 for (i
= 0; i
< count
; i
++)
1910 bfd_put_8 (abfd
, (bfd_vma
) NOP_OPCODE
, contents
+ toaddr
- count
+ i
);
1913 /* Adjust all the relocs. */
1914 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1916 /* Get the new reloc address. */
1917 if ((irel
->r_offset
> addr
1918 && irel
->r_offset
< toaddr
)
1919 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_ALIGN
1920 && irel
->r_offset
== toaddr
))
1921 irel
->r_offset
-= count
;
1924 /* Adjust the local symbols in the section, reducing their value
1925 by the number of bytes deleted. Note - symbols within the deleted
1926 region are moved to the address of the start of the region, which
1927 actually means that they will address the byte beyond the end of
1928 the region once the deletion has been completed. */
1929 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1930 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1931 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1933 if (isym
->st_shndx
== sec_shndx
1934 && isym
->st_value
> addr
1935 && isym
->st_value
< toaddr
)
1937 if (isym
->st_value
< addr
+ count
)
1938 isym
->st_value
= addr
;
1940 isym
->st_value
-= count
;
1942 /* Adjust the function symbol's size as well. */
1943 else if (isym
->st_shndx
== sec_shndx
1944 && ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
1945 && isym
->st_value
+ isym
->st_size
> addr
1946 && isym
->st_value
+ isym
->st_size
< toaddr
)
1947 isym
->st_size
-= count
;
1950 /* Now adjust the global symbols defined in this section. */
1951 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1952 - symtab_hdr
->sh_info
);
1953 sym_hashes
= elf_sym_hashes (abfd
);
1954 end_hashes
= sym_hashes
+ symcount
;
1955 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1957 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1959 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1960 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1961 && sym_hash
->root
.u
.def
.section
== sec
1962 && sym_hash
->root
.u
.def
.value
> addr
1963 && sym_hash
->root
.u
.def
.value
< toaddr
)
1965 if (sym_hash
->root
.u
.def
.value
< addr
+ count
)
1966 sym_hash
->root
.u
.def
.value
= addr
;
1968 sym_hash
->root
.u
.def
.value
-= count
;
1970 /* Adjust the function symbol's size as well. */
1971 else if (sym_hash
->root
.type
== bfd_link_hash_defined
1972 && sym_hash
->root
.u
.def
.section
== sec
1973 && sym_hash
->type
== STT_FUNC
1974 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
1975 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
1976 sym_hash
->size
-= count
;
1979 /* See if we can move the ALIGN reloc forward.
1980 We have adjusted r_offset for it already. */
1981 if (irelalign
!= NULL
)
1983 bfd_vma alignto
, alignaddr
;
1985 if ((int) irelalign
->r_addend
> 0)
1987 /* This is the old address. */
1988 alignto
= BFD_ALIGN (toaddr
, 1 << irelalign
->r_addend
);
1989 /* This is where the align points to now. */
1990 alignaddr
= BFD_ALIGN (irelalign
->r_offset
,
1991 1 << irelalign
->r_addend
);
1992 if (alignaddr
< alignto
)
1993 /* Tail recursion. */
1994 return mn10300_elf_relax_delete_bytes (abfd
, sec
, alignaddr
,
1995 (int) (alignto
- alignaddr
));
2002 /* Return TRUE if a symbol exists at the given address, else return
2006 mn10300_elf_symbol_address_p (bfd
*abfd
,
2008 Elf_Internal_Sym
*isym
,
2011 Elf_Internal_Shdr
*symtab_hdr
;
2012 unsigned int sec_shndx
;
2013 Elf_Internal_Sym
*isymend
;
2014 struct elf_link_hash_entry
**sym_hashes
;
2015 struct elf_link_hash_entry
**end_hashes
;
2016 unsigned int symcount
;
2018 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2020 /* Examine all the symbols. */
2021 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2022 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
2023 if (isym
->st_shndx
== sec_shndx
2024 && isym
->st_value
== addr
)
2027 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2028 - symtab_hdr
->sh_info
);
2029 sym_hashes
= elf_sym_hashes (abfd
);
2030 end_hashes
= sym_hashes
+ symcount
;
2031 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2033 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
2035 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2036 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2037 && sym_hash
->root
.u
.def
.section
== sec
2038 && sym_hash
->root
.u
.def
.value
== addr
)
2045 /* This function handles relaxing for the mn10300.
2047 There are quite a few relaxing opportunities available on the mn10300:
2049 * calls:32 -> calls:16 2 bytes
2050 * call:32 -> call:16 2 bytes
2052 * call:32 -> calls:32 1 byte
2053 * call:16 -> calls:16 1 byte
2054 * These are done anytime using "calls" would result
2055 in smaller code, or when necessary to preserve the
2056 meaning of the program.
2060 * In some circumstances we can move instructions
2061 from a function prologue into a "call" instruction.
2062 This is only done if the resulting code is no larger
2063 than the original code.
2065 * jmp:32 -> jmp:16 2 bytes
2066 * jmp:16 -> bra:8 1 byte
2068 * If the previous instruction is a conditional branch
2069 around the jump/bra, we may be able to reverse its condition
2070 and change its target to the jump's target. The jump/bra
2071 can then be deleted. 2 bytes
2073 * mov abs32 -> mov abs16 1 or 2 bytes
2075 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
2076 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
2078 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
2079 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
2081 We don't handle imm16->imm8 or d16->d8 as they're very rare
2082 and somewhat more difficult to support. */
2085 mn10300_elf_relax_section (bfd
*abfd
,
2087 struct bfd_link_info
*link_info
,
2090 Elf_Internal_Shdr
*symtab_hdr
;
2091 Elf_Internal_Rela
*internal_relocs
= NULL
;
2092 Elf_Internal_Rela
*irel
, *irelend
;
2093 bfd_byte
*contents
= NULL
;
2094 Elf_Internal_Sym
*isymbuf
= NULL
;
2095 struct elf32_mn10300_link_hash_table
*hash_table
;
2096 asection
*section
= sec
;
2098 /* Assume nothing changes. */
2101 /* We need a pointer to the mn10300 specific hash table. */
2102 hash_table
= elf32_mn10300_hash_table (link_info
);
2104 /* Initialize fields in each hash table entry the first time through. */
2105 if ((hash_table
->flags
& MN10300_HASH_ENTRIES_INITIALIZED
) == 0)
2109 /* Iterate over all the input bfds. */
2110 for (input_bfd
= link_info
->input_bfds
;
2112 input_bfd
= input_bfd
->link_next
)
2114 /* We're going to need all the symbols for each bfd. */
2115 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2116 if (symtab_hdr
->sh_info
!= 0)
2118 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2119 if (isymbuf
== NULL
)
2120 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2121 symtab_hdr
->sh_info
, 0,
2123 if (isymbuf
== NULL
)
2127 /* Iterate over each section in this bfd. */
2128 for (section
= input_bfd
->sections
;
2130 section
= section
->next
)
2132 struct elf32_mn10300_link_hash_entry
*hash
;
2133 Elf_Internal_Sym
*sym
;
2134 asection
*sym_sec
= NULL
;
2135 const char *sym_name
;
2138 /* If there's nothing to do in this section, skip it. */
2139 if (! ((section
->flags
& SEC_RELOC
) != 0
2140 && section
->reloc_count
!= 0))
2142 if ((section
->flags
& SEC_ALLOC
) == 0)
2145 /* Get cached copy of section contents if it exists. */
2146 if (elf_section_data (section
)->this_hdr
.contents
!= NULL
)
2147 contents
= elf_section_data (section
)->this_hdr
.contents
;
2148 else if (section
->size
!= 0)
2150 /* Go get them off disk. */
2151 if (!bfd_malloc_and_get_section (input_bfd
, section
,
2158 /* If there aren't any relocs, then there's nothing to do. */
2159 if ((section
->flags
& SEC_RELOC
) != 0
2160 && section
->reloc_count
!= 0)
2162 /* Get a copy of the native relocations. */
2163 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, section
,
2165 link_info
->keep_memory
);
2166 if (internal_relocs
== NULL
)
2169 /* Now examine each relocation. */
2170 irel
= internal_relocs
;
2171 irelend
= irel
+ section
->reloc_count
;
2172 for (; irel
< irelend
; irel
++)
2175 unsigned long r_index
;
2178 r_type
= ELF32_R_TYPE (irel
->r_info
);
2179 r_index
= ELF32_R_SYM (irel
->r_info
);
2181 if (r_type
< 0 || r_type
>= (int) R_MN10300_MAX
)
2184 /* We need the name and hash table entry of the target
2190 if (r_index
< symtab_hdr
->sh_info
)
2192 /* A local symbol. */
2193 Elf_Internal_Sym
*isym
;
2194 struct elf_link_hash_table
*elftab
;
2197 isym
= isymbuf
+ r_index
;
2198 if (isym
->st_shndx
== SHN_UNDEF
)
2199 sym_sec
= bfd_und_section_ptr
;
2200 else if (isym
->st_shndx
== SHN_ABS
)
2201 sym_sec
= bfd_abs_section_ptr
;
2202 else if (isym
->st_shndx
== SHN_COMMON
)
2203 sym_sec
= bfd_com_section_ptr
;
2206 = bfd_section_from_elf_index (input_bfd
,
2210 = bfd_elf_string_from_elf_section (input_bfd
,
2215 /* If it isn't a function, then we don't care
2217 if (ELF_ST_TYPE (isym
->st_info
) != STT_FUNC
)
2220 /* Tack on an ID so we can uniquely identify this
2221 local symbol in the global hash table. */
2222 amt
= strlen (sym_name
) + 10;
2223 new_name
= bfd_malloc (amt
);
2224 if (new_name
== NULL
)
2227 sprintf (new_name
, "%s_%08x", sym_name
, sym_sec
->id
);
2228 sym_name
= new_name
;
2230 elftab
= &hash_table
->static_hash_table
->root
;
2231 hash
= ((struct elf32_mn10300_link_hash_entry
*)
2232 elf_link_hash_lookup (elftab
, sym_name
,
2233 TRUE
, TRUE
, FALSE
));
2238 r_index
-= symtab_hdr
->sh_info
;
2239 hash
= (struct elf32_mn10300_link_hash_entry
*)
2240 elf_sym_hashes (input_bfd
)[r_index
];
2243 sym_name
= hash
->root
.root
.root
.string
;
2244 if ((section
->flags
& SEC_CODE
) != 0)
2246 /* If this is not a "call" instruction, then we
2247 should convert "call" instructions to "calls"
2249 code
= bfd_get_8 (input_bfd
,
2250 contents
+ irel
->r_offset
- 1);
2251 if (code
!= 0xdd && code
!= 0xcd)
2252 hash
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
2255 /* If this is a jump/call, then bump the
2256 direct_calls counter. Else force "call" to
2257 "calls" conversions. */
2258 if (r_type
== R_MN10300_PCREL32
2259 || r_type
== R_MN10300_PLT32
2260 || r_type
== R_MN10300_PLT16
2261 || r_type
== R_MN10300_PCREL16
)
2262 hash
->direct_calls
++;
2264 hash
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
2268 /* Now look at the actual contents to get the stack size,
2269 and a list of what registers were saved in the prologue
2271 if ((section
->flags
& SEC_CODE
) != 0)
2273 Elf_Internal_Sym
*isym
, *isymend
;
2274 unsigned int sec_shndx
;
2275 struct elf_link_hash_entry
**hashes
;
2276 struct elf_link_hash_entry
**end_hashes
;
2277 unsigned int symcount
;
2279 sec_shndx
= _bfd_elf_section_from_bfd_section (input_bfd
,
2282 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2283 - symtab_hdr
->sh_info
);
2284 hashes
= elf_sym_hashes (input_bfd
);
2285 end_hashes
= hashes
+ symcount
;
2287 /* Look at each function defined in this section and
2288 update info for that function. */
2289 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
2290 for (isym
= isymbuf
; isym
< isymend
; isym
++)
2292 if (isym
->st_shndx
== sec_shndx
2293 && ELF_ST_TYPE (isym
->st_info
) == STT_FUNC
)
2295 struct elf_link_hash_table
*elftab
;
2297 struct elf_link_hash_entry
**lhashes
= hashes
;
2299 /* Skip a local symbol if it aliases a
2301 for (; lhashes
< end_hashes
; lhashes
++)
2303 hash
= (struct elf32_mn10300_link_hash_entry
*) *lhashes
;
2304 if ((hash
->root
.root
.type
== bfd_link_hash_defined
2305 || hash
->root
.root
.type
== bfd_link_hash_defweak
)
2306 && hash
->root
.root
.u
.def
.section
== section
2307 && hash
->root
.type
== STT_FUNC
2308 && hash
->root
.root
.u
.def
.value
== isym
->st_value
)
2311 if (lhashes
!= end_hashes
)
2314 if (isym
->st_shndx
== SHN_UNDEF
)
2315 sym_sec
= bfd_und_section_ptr
;
2316 else if (isym
->st_shndx
== SHN_ABS
)
2317 sym_sec
= bfd_abs_section_ptr
;
2318 else if (isym
->st_shndx
== SHN_COMMON
)
2319 sym_sec
= bfd_com_section_ptr
;
2322 = bfd_section_from_elf_index (input_bfd
,
2325 sym_name
= (bfd_elf_string_from_elf_section
2326 (input_bfd
, symtab_hdr
->sh_link
,
2329 /* Tack on an ID so we can uniquely identify this
2330 local symbol in the global hash table. */
2331 amt
= strlen (sym_name
) + 10;
2332 new_name
= bfd_malloc (amt
);
2333 if (new_name
== NULL
)
2336 sprintf (new_name
, "%s_%08x", sym_name
, sym_sec
->id
);
2337 sym_name
= new_name
;
2339 elftab
= &hash_table
->static_hash_table
->root
;
2340 hash
= ((struct elf32_mn10300_link_hash_entry
*)
2341 elf_link_hash_lookup (elftab
, sym_name
,
2342 TRUE
, TRUE
, FALSE
));
2344 compute_function_info (input_bfd
, hash
,
2345 isym
->st_value
, contents
);
2346 hash
->value
= isym
->st_value
;
2350 for (; hashes
< end_hashes
; hashes
++)
2352 hash
= (struct elf32_mn10300_link_hash_entry
*) *hashes
;
2353 if ((hash
->root
.root
.type
== bfd_link_hash_defined
2354 || hash
->root
.root
.type
== bfd_link_hash_defweak
)
2355 && hash
->root
.root
.u
.def
.section
== section
2356 && hash
->root
.type
== STT_FUNC
)
2357 compute_function_info (input_bfd
, hash
,
2358 (hash
)->root
.root
.u
.def
.value
,
2363 /* Cache or free any memory we allocated for the relocs. */
2364 if (internal_relocs
!= NULL
2365 && elf_section_data (section
)->relocs
!= internal_relocs
)
2366 free (internal_relocs
);
2367 internal_relocs
= NULL
;
2369 /* Cache or free any memory we allocated for the contents. */
2370 if (contents
!= NULL
2371 && elf_section_data (section
)->this_hdr
.contents
!= contents
)
2373 if (! link_info
->keep_memory
)
2377 /* Cache the section contents for elf_link_input_bfd. */
2378 elf_section_data (section
)->this_hdr
.contents
= contents
;
2384 /* Cache or free any memory we allocated for the symbols. */
2386 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2388 if (! link_info
->keep_memory
)
2392 /* Cache the symbols for elf_link_input_bfd. */
2393 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2399 /* Now iterate on each symbol in the hash table and perform
2400 the final initialization steps on each. */
2401 elf32_mn10300_link_hash_traverse (hash_table
,
2402 elf32_mn10300_finish_hash_table_entry
,
2404 elf32_mn10300_link_hash_traverse (hash_table
->static_hash_table
,
2405 elf32_mn10300_finish_hash_table_entry
,
2409 /* This section of code collects all our local symbols, sorts
2410 them by value, and looks for multiple symbols referring to
2411 the same address. For those symbols, the flags are merged.
2412 At this point, the only flag that can be set is
2413 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2415 int static_count
= 0, i
;
2416 struct elf32_mn10300_link_hash_entry
**entries
;
2417 struct elf32_mn10300_link_hash_entry
**ptr
;
2419 elf32_mn10300_link_hash_traverse (hash_table
->static_hash_table
,
2420 elf32_mn10300_count_hash_table_entries
,
2423 entries
= bfd_malloc (static_count
* sizeof (* ptr
));
2426 elf32_mn10300_link_hash_traverse (hash_table
->static_hash_table
,
2427 elf32_mn10300_list_hash_table_entries
,
2430 qsort (entries
, static_count
, sizeof (entries
[0]), sort_by_value
);
2432 for (i
= 0; i
< static_count
- 1; i
++)
2433 if (entries
[i
]->value
&& entries
[i
]->value
== entries
[i
+1]->value
)
2435 int v
= entries
[i
]->flags
;
2438 for (j
= i
+ 1; j
< static_count
&& entries
[j
]->value
== entries
[i
]->value
; j
++)
2439 v
|= entries
[j
]->flags
;
2441 for (j
= i
; j
< static_count
&& entries
[j
]->value
== entries
[i
]->value
; j
++)
2442 entries
[j
]->flags
= v
;
2448 /* All entries in the hash table are fully initialized. */
2449 hash_table
->flags
|= MN10300_HASH_ENTRIES_INITIALIZED
;
2451 /* Now that everything has been initialized, go through each
2452 code section and delete any prologue insns which will be
2453 redundant because their operations will be performed by
2454 a "call" instruction. */
2455 for (input_bfd
= link_info
->input_bfds
;
2457 input_bfd
= input_bfd
->link_next
)
2459 /* We're going to need all the local symbols for each bfd. */
2460 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2461 if (symtab_hdr
->sh_info
!= 0)
2463 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2464 if (isymbuf
== NULL
)
2465 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2466 symtab_hdr
->sh_info
, 0,
2468 if (isymbuf
== NULL
)
2472 /* Walk over each section in this bfd. */
2473 for (section
= input_bfd
->sections
;
2475 section
= section
->next
)
2477 unsigned int sec_shndx
;
2478 Elf_Internal_Sym
*isym
, *isymend
;
2479 struct elf_link_hash_entry
**hashes
;
2480 struct elf_link_hash_entry
**end_hashes
;
2481 unsigned int symcount
;
2483 /* Skip non-code sections and empty sections. */
2484 if ((section
->flags
& SEC_CODE
) == 0 || section
->size
== 0)
2487 if (section
->reloc_count
!= 0)
2489 /* Get a copy of the native relocations. */
2490 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, section
,
2492 link_info
->keep_memory
);
2493 if (internal_relocs
== NULL
)
2497 /* Get cached copy of section contents if it exists. */
2498 if (elf_section_data (section
)->this_hdr
.contents
!= NULL
)
2499 contents
= elf_section_data (section
)->this_hdr
.contents
;
2502 /* Go get them off disk. */
2503 if (!bfd_malloc_and_get_section (input_bfd
, section
,
2508 sec_shndx
= _bfd_elf_section_from_bfd_section (input_bfd
,
2511 /* Now look for any function in this section which needs
2512 insns deleted from its prologue. */
2513 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
2514 for (isym
= isymbuf
; isym
< isymend
; isym
++)
2516 struct elf32_mn10300_link_hash_entry
*sym_hash
;
2517 asection
*sym_sec
= NULL
;
2518 const char *sym_name
;
2520 struct elf_link_hash_table
*elftab
;
2523 if (isym
->st_shndx
!= sec_shndx
)
2526 if (isym
->st_shndx
== SHN_UNDEF
)
2527 sym_sec
= bfd_und_section_ptr
;
2528 else if (isym
->st_shndx
== SHN_ABS
)
2529 sym_sec
= bfd_abs_section_ptr
;
2530 else if (isym
->st_shndx
== SHN_COMMON
)
2531 sym_sec
= bfd_com_section_ptr
;
2534 = bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
2537 = bfd_elf_string_from_elf_section (input_bfd
,
2538 symtab_hdr
->sh_link
,
2541 /* Tack on an ID so we can uniquely identify this
2542 local symbol in the global hash table. */
2543 amt
= strlen (sym_name
) + 10;
2544 new_name
= bfd_malloc (amt
);
2545 if (new_name
== NULL
)
2547 sprintf (new_name
, "%s_%08x", sym_name
, sym_sec
->id
);
2548 sym_name
= new_name
;
2550 elftab
= & hash_table
->static_hash_table
->root
;
2551 sym_hash
= (struct elf32_mn10300_link_hash_entry
*)
2552 elf_link_hash_lookup (elftab
, sym_name
,
2553 FALSE
, FALSE
, FALSE
);
2556 if (sym_hash
== NULL
)
2559 if (! (sym_hash
->flags
& MN10300_CONVERT_CALL_TO_CALLS
)
2560 && ! (sym_hash
->flags
& MN10300_DELETED_PROLOGUE_BYTES
))
2564 /* Note that we've changed things. */
2565 elf_section_data (section
)->relocs
= internal_relocs
;
2566 elf_section_data (section
)->this_hdr
.contents
= contents
;
2567 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2569 /* Count how many bytes we're going to delete. */
2570 if (sym_hash
->movm_args
)
2573 if (sym_hash
->stack_size
> 0)
2575 if (sym_hash
->stack_size
<= 128)
2581 /* Note that we've deleted prologue bytes for this
2583 sym_hash
->flags
|= MN10300_DELETED_PROLOGUE_BYTES
;
2585 /* Actually delete the bytes. */
2586 if (!mn10300_elf_relax_delete_bytes (input_bfd
,
2592 /* Something changed. Not strictly necessary, but
2593 may lead to more relaxing opportunities. */
2598 /* Look for any global functions in this section which
2599 need insns deleted from their prologues. */
2600 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2601 - symtab_hdr
->sh_info
);
2602 hashes
= elf_sym_hashes (input_bfd
);
2603 end_hashes
= hashes
+ symcount
;
2604 for (; hashes
< end_hashes
; hashes
++)
2606 struct elf32_mn10300_link_hash_entry
*sym_hash
;
2608 sym_hash
= (struct elf32_mn10300_link_hash_entry
*) *hashes
;
2609 if ((sym_hash
->root
.root
.type
== bfd_link_hash_defined
2610 || sym_hash
->root
.root
.type
== bfd_link_hash_defweak
)
2611 && sym_hash
->root
.root
.u
.def
.section
== section
2612 && ! (sym_hash
->flags
& MN10300_CONVERT_CALL_TO_CALLS
)
2613 && ! (sym_hash
->flags
& MN10300_DELETED_PROLOGUE_BYTES
))
2618 /* Note that we've changed things. */
2619 elf_section_data (section
)->relocs
= internal_relocs
;
2620 elf_section_data (section
)->this_hdr
.contents
= contents
;
2621 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2623 /* Count how many bytes we're going to delete. */
2624 if (sym_hash
->movm_args
)
2627 if (sym_hash
->stack_size
> 0)
2629 if (sym_hash
->stack_size
<= 128)
2635 /* Note that we've deleted prologue bytes for this
2637 sym_hash
->flags
|= MN10300_DELETED_PROLOGUE_BYTES
;
2639 /* Actually delete the bytes. */
2640 symval
= sym_hash
->root
.root
.u
.def
.value
;
2641 if (!mn10300_elf_relax_delete_bytes (input_bfd
,
2647 /* Something changed. Not strictly necessary, but
2648 may lead to more relaxing opportunities. */
2653 /* Cache or free any memory we allocated for the relocs. */
2654 if (internal_relocs
!= NULL
2655 && elf_section_data (section
)->relocs
!= internal_relocs
)
2656 free (internal_relocs
);
2657 internal_relocs
= NULL
;
2659 /* Cache or free any memory we allocated for the contents. */
2660 if (contents
!= NULL
2661 && elf_section_data (section
)->this_hdr
.contents
!= contents
)
2663 if (! link_info
->keep_memory
)
2666 /* Cache the section contents for elf_link_input_bfd. */
2667 elf_section_data (section
)->this_hdr
.contents
= contents
;
2672 /* Cache or free any memory we allocated for the symbols. */
2674 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2676 if (! link_info
->keep_memory
)
2679 /* Cache the symbols for elf_link_input_bfd. */
2680 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2686 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
2688 internal_relocs
= NULL
;
2690 /* For error_return. */
2693 /* We don't have to do anything for a relocatable link, if
2694 this section does not have relocs, or if this is not a
2696 if (link_info
->relocatable
2697 || (sec
->flags
& SEC_RELOC
) == 0
2698 || sec
->reloc_count
== 0
2699 || (sec
->flags
& SEC_CODE
) == 0)
2702 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2704 /* Get a copy of the native relocations. */
2705 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
2706 link_info
->keep_memory
);
2707 if (internal_relocs
== NULL
)
2710 /* Walk through them looking for relaxing opportunities. */
2711 irelend
= internal_relocs
+ sec
->reloc_count
;
2712 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2715 struct elf32_mn10300_link_hash_entry
*h
= NULL
;
2717 /* If this isn't something that can be relaxed, then ignore
2719 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_NONE
2720 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_8
2721 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_MAX
)
2724 /* Get the section contents if we haven't done so already. */
2725 if (contents
== NULL
)
2727 /* Get cached copy if it exists. */
2728 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2729 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2732 /* Go get them off disk. */
2733 if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2738 /* Read this BFD's symbols if we haven't done so already. */
2739 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
2741 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2742 if (isymbuf
== NULL
)
2743 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2744 symtab_hdr
->sh_info
, 0,
2746 if (isymbuf
== NULL
)
2750 /* Get the value of the symbol referred to by the reloc. */
2751 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2753 Elf_Internal_Sym
*isym
;
2754 asection
*sym_sec
= NULL
;
2755 const char *sym_name
;
2758 /* A local symbol. */
2759 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2760 if (isym
->st_shndx
== SHN_UNDEF
)
2761 sym_sec
= bfd_und_section_ptr
;
2762 else if (isym
->st_shndx
== SHN_ABS
)
2763 sym_sec
= bfd_abs_section_ptr
;
2764 else if (isym
->st_shndx
== SHN_COMMON
)
2765 sym_sec
= bfd_com_section_ptr
;
2767 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2769 sym_name
= bfd_elf_string_from_elf_section (abfd
,
2770 symtab_hdr
->sh_link
,
2773 if ((sym_sec
->flags
& SEC_MERGE
)
2774 && ELF_ST_TYPE (isym
->st_info
) == STT_SECTION
2775 && sym_sec
->sec_info_type
== ELF_INFO_TYPE_MERGE
)
2777 bfd_vma saved_addend
;
2779 saved_addend
= irel
->r_addend
;
2780 symval
= _bfd_elf_rela_local_sym (abfd
, isym
, & sym_sec
, irel
);
2781 symval
+= irel
->r_addend
;
2782 irel
->r_addend
= saved_addend
;
2785 symval
= (isym
->st_value
2786 + sym_sec
->output_section
->vma
2787 + sym_sec
->output_offset
);
2789 /* Tack on an ID so we can uniquely identify this
2790 local symbol in the global hash table. */
2791 new_name
= bfd_malloc ((bfd_size_type
) strlen (sym_name
) + 10);
2792 if (new_name
== NULL
)
2794 sprintf (new_name
, "%s_%08x", sym_name
, sym_sec
->id
);
2795 sym_name
= new_name
;
2797 h
= (struct elf32_mn10300_link_hash_entry
*)
2798 elf_link_hash_lookup (&hash_table
->static_hash_table
->root
,
2799 sym_name
, FALSE
, FALSE
, FALSE
);
2806 /* An external symbol. */
2807 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2808 h
= (struct elf32_mn10300_link_hash_entry
*)
2809 (elf_sym_hashes (abfd
)[indx
]);
2810 BFD_ASSERT (h
!= NULL
);
2811 if (h
->root
.root
.type
!= bfd_link_hash_defined
2812 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
2813 /* This appears to be a reference to an undefined
2814 symbol. Just ignore it--it will be caught by the
2815 regular reloc processing. */
2818 /* Check for a reference to a discarded symbol and ignore it. */
2819 if (h
->root
.root
.u
.def
.section
->output_section
== NULL
)
2822 symval
= (h
->root
.root
.u
.def
.value
2823 + h
->root
.root
.u
.def
.section
->output_section
->vma
2824 + h
->root
.root
.u
.def
.section
->output_offset
);
2827 /* For simplicity of coding, we are going to modify the section
2828 contents, the section relocs, and the BFD symbol table. We
2829 must tell the rest of the code not to free up this
2830 information. It would be possible to instead create a table
2831 of changes which have to be made, as is done in coff-mips.c;
2832 that would be more work, but would require less memory when
2833 the linker is run. */
2835 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2836 branch/call, also deal with "call" -> "calls" conversions and
2837 insertion of prologue data into "call" instructions. */
2838 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PCREL32
2839 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PLT32
)
2841 bfd_vma value
= symval
;
2843 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PLT32
2845 && ELF_ST_VISIBILITY (h
->root
.other
) != STV_INTERNAL
2846 && ELF_ST_VISIBILITY (h
->root
.other
) != STV_HIDDEN
2847 && h
->root
.plt
.offset
!= (bfd_vma
) -1)
2851 splt
= bfd_get_section_by_name (elf_hash_table (link_info
)
2854 value
= ((splt
->output_section
->vma
2855 + splt
->output_offset
2856 + h
->root
.plt
.offset
)
2857 - (sec
->output_section
->vma
2858 + sec
->output_offset
2862 /* If we've got a "call" instruction that needs to be turned
2863 into a "calls" instruction, do so now. It saves a byte. */
2864 if (h
&& (h
->flags
& MN10300_CONVERT_CALL_TO_CALLS
))
2868 /* Get the opcode. */
2869 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
2871 /* Make sure we're working with a "call" instruction! */
2874 /* Note that we've changed the relocs, section contents,
2876 elf_section_data (sec
)->relocs
= internal_relocs
;
2877 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2878 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2880 /* Fix the opcode. */
2881 bfd_put_8 (abfd
, 0xfc, contents
+ irel
->r_offset
- 1);
2882 bfd_put_8 (abfd
, 0xff, contents
+ irel
->r_offset
);
2884 /* Fix irel->r_offset and irel->r_addend. */
2885 irel
->r_offset
+= 1;
2886 irel
->r_addend
+= 1;
2888 /* Delete one byte of data. */
2889 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2890 irel
->r_offset
+ 3, 1))
2893 /* That will change things, so, we should relax again.
2894 Note that this is not required, and it may be slow. */
2900 /* We've got a "call" instruction which needs some data
2901 from target function filled in. */
2904 /* Get the opcode. */
2905 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
2907 /* Insert data from the target function into the "call"
2908 instruction if needed. */
2911 bfd_put_8 (abfd
, h
->movm_args
, contents
+ irel
->r_offset
+ 4);
2912 bfd_put_8 (abfd
, h
->stack_size
+ h
->movm_stack_size
,
2913 contents
+ irel
->r_offset
+ 5);
2917 /* Deal with pc-relative gunk. */
2918 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
2919 value
-= irel
->r_offset
;
2920 value
+= irel
->r_addend
;
2922 /* See if the value will fit in 16 bits, note the high value is
2923 0x7fff + 2 as the target will be two bytes closer if we are
2925 if ((long) value
< 0x8001 && (long) value
> -0x8000)
2929 /* Get the opcode. */
2930 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
2932 if (code
!= 0xdc && code
!= 0xdd && code
!= 0xff)
2935 /* Note that we've changed the relocs, section contents, etc. */
2936 elf_section_data (sec
)->relocs
= internal_relocs
;
2937 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2938 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2940 /* Fix the opcode. */
2942 bfd_put_8 (abfd
, 0xcc, contents
+ irel
->r_offset
- 1);
2943 else if (code
== 0xdd)
2944 bfd_put_8 (abfd
, 0xcd, contents
+ irel
->r_offset
- 1);
2945 else if (code
== 0xff)
2946 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
2948 /* Fix the relocation's type. */
2949 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2950 (ELF32_R_TYPE (irel
->r_info
)
2951 == (int) R_MN10300_PLT32
)
2955 /* Delete two bytes of data. */
2956 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2957 irel
->r_offset
+ 1, 2))
2960 /* That will change things, so, we should relax again.
2961 Note that this is not required, and it may be slow. */
2966 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
2968 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PCREL16
)
2970 bfd_vma value
= symval
;
2972 /* If we've got a "call" instruction that needs to be turned
2973 into a "calls" instruction, do so now. It saves a byte. */
2974 if (h
&& (h
->flags
& MN10300_CONVERT_CALL_TO_CALLS
))
2978 /* Get the opcode. */
2979 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
2981 /* Make sure we're working with a "call" instruction! */
2984 /* Note that we've changed the relocs, section contents,
2986 elf_section_data (sec
)->relocs
= internal_relocs
;
2987 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2988 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2990 /* Fix the opcode. */
2991 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 1);
2992 bfd_put_8 (abfd
, 0xff, contents
+ irel
->r_offset
);
2994 /* Fix irel->r_offset and irel->r_addend. */
2995 irel
->r_offset
+= 1;
2996 irel
->r_addend
+= 1;
2998 /* Delete one byte of data. */
2999 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3000 irel
->r_offset
+ 1, 1))
3003 /* That will change things, so, we should relax again.
3004 Note that this is not required, and it may be slow. */
3012 /* Get the opcode. */
3013 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
3015 /* Insert data from the target function into the "call"
3016 instruction if needed. */
3019 bfd_put_8 (abfd
, h
->movm_args
, contents
+ irel
->r_offset
+ 2);
3020 bfd_put_8 (abfd
, h
->stack_size
+ h
->movm_stack_size
,
3021 contents
+ irel
->r_offset
+ 3);
3025 /* Deal with pc-relative gunk. */
3026 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
3027 value
-= irel
->r_offset
;
3028 value
+= irel
->r_addend
;
3030 /* See if the value will fit in 8 bits, note the high value is
3031 0x7f + 1 as the target will be one bytes closer if we are
3033 if ((long) value
< 0x80 && (long) value
> -0x80)
3037 /* Get the opcode. */
3038 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
3043 /* Note that we've changed the relocs, section contents, etc. */
3044 elf_section_data (sec
)->relocs
= internal_relocs
;
3045 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3046 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3048 /* Fix the opcode. */
3049 bfd_put_8 (abfd
, 0xca, contents
+ irel
->r_offset
- 1);
3051 /* Fix the relocation's type. */
3052 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3055 /* Delete one byte of data. */
3056 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3057 irel
->r_offset
+ 1, 1))
3060 /* That will change things, so, we should relax again.
3061 Note that this is not required, and it may be slow. */
3066 /* Try to eliminate an unconditional 8 bit pc-relative branch
3067 which immediately follows a conditional 8 bit pc-relative
3068 branch around the unconditional branch.
3075 This happens when the bCC can't reach lab2 at assembly time,
3076 but due to other relaxations it can reach at link time. */
3077 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PCREL8
)
3079 Elf_Internal_Rela
*nrel
;
3080 bfd_vma value
= symval
;
3083 /* Deal with pc-relative gunk. */
3084 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
3085 value
-= irel
->r_offset
;
3086 value
+= irel
->r_addend
;
3088 /* Do nothing if this reloc is the last byte in the section. */
3089 if (irel
->r_offset
== sec
->size
)
3092 /* See if the next instruction is an unconditional pc-relative
3093 branch, more often than not this test will fail, so we
3094 test it first to speed things up. */
3095 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 1);
3099 /* Also make sure the next relocation applies to the next
3100 instruction and that it's a pc-relative 8 bit branch. */
3103 || irel
->r_offset
+ 2 != nrel
->r_offset
3104 || ELF32_R_TYPE (nrel
->r_info
) != (int) R_MN10300_PCREL8
)
3107 /* Make sure our destination immediately follows the
3108 unconditional branch. */
3109 if (symval
!= (sec
->output_section
->vma
+ sec
->output_offset
3110 + irel
->r_offset
+ 3))
3113 /* Now make sure we are a conditional branch. This may not
3114 be necessary, but why take the chance.
3116 Note these checks assume that R_MN10300_PCREL8 relocs
3117 only occur on bCC and bCCx insns. If they occured
3118 elsewhere, we'd need to know the start of this insn
3119 for this check to be accurate. */
3120 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
3121 if (code
!= 0xc0 && code
!= 0xc1 && code
!= 0xc2
3122 && code
!= 0xc3 && code
!= 0xc4 && code
!= 0xc5
3123 && code
!= 0xc6 && code
!= 0xc7 && code
!= 0xc8
3124 && code
!= 0xc9 && code
!= 0xe8 && code
!= 0xe9
3125 && code
!= 0xea && code
!= 0xeb)
3128 /* We also have to be sure there is no symbol/label
3129 at the unconditional branch. */
3130 if (mn10300_elf_symbol_address_p (abfd
, sec
, isymbuf
,
3131 irel
->r_offset
+ 1))
3134 /* Note that we've changed the relocs, section contents, etc. */
3135 elf_section_data (sec
)->relocs
= internal_relocs
;
3136 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3137 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3139 /* Reverse the condition of the first branch. */
3185 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
3187 /* Set the reloc type and symbol for the first branch
3188 from the second branch. */
3189 irel
->r_info
= nrel
->r_info
;
3191 /* Make the reloc for the second branch a null reloc. */
3192 nrel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (nrel
->r_info
),
3195 /* Delete two bytes of data. */
3196 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3197 irel
->r_offset
+ 1, 2))
3200 /* That will change things, so, we should relax again.
3201 Note that this is not required, and it may be slow. */
3205 /* Try to turn a 24 immediate, displacement or absolute address
3206 into a 8 immediate, displacement or absolute address. */
3207 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_24
)
3209 bfd_vma value
= symval
;
3210 value
+= irel
->r_addend
;
3212 /* See if the value will fit in 8 bits. */
3213 if ((long) value
< 0x7f && (long) value
> -0x80)
3217 /* AM33 insns which have 24 operands are 6 bytes long and
3218 will have 0xfd as the first byte. */
3220 /* Get the first opcode. */
3221 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 3);
3225 /* Get the second opcode. */
3226 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
3228 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3229 equivalent instructions exists. */
3230 if (code
!= 0x6b && code
!= 0x7b
3231 && code
!= 0x8b && code
!= 0x9b
3232 && ((code
& 0x0f) == 0x09 || (code
& 0x0f) == 0x08
3233 || (code
& 0x0f) == 0x0a || (code
& 0x0f) == 0x0b
3234 || (code
& 0x0f) == 0x0e))
3236 /* Not safe if the high bit is on as relaxing may
3237 move the value out of high mem and thus not fit
3238 in a signed 8bit value. This is currently over
3240 if ((value
& 0x80) == 0)
3242 /* Note that we've changed the relocation contents,
3244 elf_section_data (sec
)->relocs
= internal_relocs
;
3245 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3246 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3248 /* Fix the opcode. */
3249 bfd_put_8 (abfd
, 0xfb, contents
+ irel
->r_offset
- 3);
3250 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
3252 /* Fix the relocation's type. */
3254 ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3257 /* Delete two bytes of data. */
3258 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3259 irel
->r_offset
+ 1, 2))
3262 /* That will change things, so, we should relax
3263 again. Note that this is not required, and it
3273 /* Try to turn a 32bit immediate, displacement or absolute address
3274 into a 16bit immediate, displacement or absolute address. */
3275 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_32
3276 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_GOT32
3277 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_GOTOFF32
)
3279 bfd_vma value
= symval
;
3281 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_MN10300_32
)
3285 sgot
= bfd_get_section_by_name (elf_hash_table (link_info
)
3288 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_GOT32
)
3290 value
= sgot
->output_offset
;
3293 value
+= h
->root
.got
.offset
;
3295 value
+= (elf_local_got_offsets
3296 (abfd
)[ELF32_R_SYM (irel
->r_info
)]);
3298 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_GOTOFF32
)
3299 value
-= sgot
->output_section
->vma
;
3300 else if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_GOTPC32
)
3301 value
= (sgot
->output_section
->vma
3302 - (sec
->output_section
->vma
3303 + sec
->output_offset
3309 value
+= irel
->r_addend
;
3311 /* See if the value will fit in 24 bits.
3312 We allow any 16bit match here. We prune those we can't
3314 if ((long) value
< 0x7fffff && (long) value
> -0x800000)
3318 /* AM33 insns which have 32bit operands are 7 bytes long and
3319 will have 0xfe as the first byte. */
3321 /* Get the first opcode. */
3322 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 3);
3326 /* Get the second opcode. */
3327 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
3329 /* All the am33 32 -> 24 relaxing possibilities. */
3330 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3331 equivalent instructions exists. */
3332 if (code
!= 0x6b && code
!= 0x7b
3333 && code
!= 0x8b && code
!= 0x9b
3334 && (ELF32_R_TYPE (irel
->r_info
)
3335 != (int) R_MN10300_GOTPC32
)
3336 && ((code
& 0x0f) == 0x09 || (code
& 0x0f) == 0x08
3337 || (code
& 0x0f) == 0x0a || (code
& 0x0f) == 0x0b
3338 || (code
& 0x0f) == 0x0e))
3340 /* Not safe if the high bit is on as relaxing may
3341 move the value out of high mem and thus not fit
3342 in a signed 16bit value. This is currently over
3344 if ((value
& 0x8000) == 0)
3346 /* Note that we've changed the relocation contents,
3348 elf_section_data (sec
)->relocs
= internal_relocs
;
3349 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3350 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3352 /* Fix the opcode. */
3353 bfd_put_8 (abfd
, 0xfd, contents
+ irel
->r_offset
- 3);
3354 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
3356 /* Fix the relocation's type. */
3358 ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3359 (ELF32_R_TYPE (irel
->r_info
)
3360 == (int) R_MN10300_GOTOFF32
)
3361 ? R_MN10300_GOTOFF24
3362 : (ELF32_R_TYPE (irel
->r_info
)
3363 == (int) R_MN10300_GOT32
)
3367 /* Delete one byte of data. */
3368 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3369 irel
->r_offset
+ 3, 1))
3372 /* That will change things, so, we should relax
3373 again. Note that this is not required, and it
3382 /* See if the value will fit in 16 bits.
3383 We allow any 16bit match here. We prune those we can't
3385 if ((long) value
< 0x7fff && (long) value
> -0x8000)
3389 /* Most insns which have 32bit operands are 6 bytes long;
3390 exceptions are pcrel insns and bit insns.
3392 We handle pcrel insns above. We don't bother trying
3393 to handle the bit insns here.
3395 The first byte of the remaining insns will be 0xfc. */
3397 /* Get the first opcode. */
3398 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
3403 /* Get the second opcode. */
3404 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
3406 if ((code
& 0xf0) < 0x80)
3407 switch (code
& 0xf0)
3409 /* mov (d32,am),dn -> mov (d32,am),dn
3410 mov dm,(d32,am) -> mov dn,(d32,am)
3411 mov (d32,am),an -> mov (d32,am),an
3412 mov dm,(d32,am) -> mov dn,(d32,am)
3413 movbu (d32,am),dn -> movbu (d32,am),dn
3414 movbu dm,(d32,am) -> movbu dn,(d32,am)
3415 movhu (d32,am),dn -> movhu (d32,am),dn
3416 movhu dm,(d32,am) -> movhu dn,(d32,am) */
3425 /* Not safe if the high bit is on as relaxing may
3426 move the value out of high mem and thus not fit
3427 in a signed 16bit value. */
3429 && (value
& 0x8000))
3432 /* Note that we've changed the relocation contents, etc. */
3433 elf_section_data (sec
)->relocs
= internal_relocs
;
3434 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3435 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3437 /* Fix the opcode. */
3438 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
3439 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
3441 /* Fix the relocation's type. */
3442 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3443 (ELF32_R_TYPE (irel
->r_info
)
3444 == (int) R_MN10300_GOTOFF32
)
3445 ? R_MN10300_GOTOFF16
3446 : (ELF32_R_TYPE (irel
->r_info
)
3447 == (int) R_MN10300_GOT32
)
3449 : (ELF32_R_TYPE (irel
->r_info
)
3450 == (int) R_MN10300_GOTPC32
)
3451 ? R_MN10300_GOTPC16
:
3454 /* Delete two bytes of data. */
3455 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3456 irel
->r_offset
+ 2, 2))
3459 /* That will change things, so, we should relax again.
3460 Note that this is not required, and it may be slow. */
3464 else if ((code
& 0xf0) == 0x80
3465 || (code
& 0xf0) == 0x90)
3466 switch (code
& 0xf3)
3468 /* mov dn,(abs32) -> mov dn,(abs16)
3469 movbu dn,(abs32) -> movbu dn,(abs16)
3470 movhu dn,(abs32) -> movhu dn,(abs16) */
3474 /* Note that we've changed the relocation contents, etc. */
3475 elf_section_data (sec
)->relocs
= internal_relocs
;
3476 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3477 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3479 if ((code
& 0xf3) == 0x81)
3480 code
= 0x01 + (code
& 0x0c);
3481 else if ((code
& 0xf3) == 0x82)
3482 code
= 0x02 + (code
& 0x0c);
3483 else if ((code
& 0xf3) == 0x83)
3484 code
= 0x03 + (code
& 0x0c);
3488 /* Fix the opcode. */
3489 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
3491 /* Fix the relocation's type. */
3492 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3493 (ELF32_R_TYPE (irel
->r_info
)
3494 == (int) R_MN10300_GOTOFF32
)
3495 ? R_MN10300_GOTOFF16
3496 : (ELF32_R_TYPE (irel
->r_info
)
3497 == (int) R_MN10300_GOT32
)
3499 : (ELF32_R_TYPE (irel
->r_info
)
3500 == (int) R_MN10300_GOTPC32
)
3501 ? R_MN10300_GOTPC16
:
3504 /* The opcode got shorter too, so we have to fix the
3505 addend and offset too! */
3506 irel
->r_offset
-= 1;
3508 /* Delete three bytes of data. */
3509 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3510 irel
->r_offset
+ 1, 3))
3513 /* That will change things, so, we should relax again.
3514 Note that this is not required, and it may be slow. */
3518 /* mov am,(abs32) -> mov am,(abs16)
3519 mov am,(d32,sp) -> mov am,(d16,sp)
3520 mov dm,(d32,sp) -> mov dm,(d32,sp)
3521 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3522 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3528 /* sp-based offsets are zero-extended. */
3529 if (code
>= 0x90 && code
<= 0x93
3530 && (long) value
< 0)
3533 /* Note that we've changed the relocation contents, etc. */
3534 elf_section_data (sec
)->relocs
= internal_relocs
;
3535 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3536 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3538 /* Fix the opcode. */
3539 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
3540 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
3542 /* Fix the relocation's type. */
3543 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3544 (ELF32_R_TYPE (irel
->r_info
)
3545 == (int) R_MN10300_GOTOFF32
)
3546 ? R_MN10300_GOTOFF16
3547 : (ELF32_R_TYPE (irel
->r_info
)
3548 == (int) R_MN10300_GOT32
)
3550 : (ELF32_R_TYPE (irel
->r_info
)
3551 == (int) R_MN10300_GOTPC32
)
3552 ? R_MN10300_GOTPC16
:
3555 /* Delete two bytes of data. */
3556 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3557 irel
->r_offset
+ 2, 2))
3560 /* That will change things, so, we should relax again.
3561 Note that this is not required, and it may be slow. */
3565 else if ((code
& 0xf0) < 0xf0)
3566 switch (code
& 0xfc)
3568 /* mov imm32,dn -> mov imm16,dn
3569 mov imm32,an -> mov imm16,an
3570 mov (abs32),dn -> mov (abs16),dn
3571 movbu (abs32),dn -> movbu (abs16),dn
3572 movhu (abs32),dn -> movhu (abs16),dn */
3578 /* Not safe if the high bit is on as relaxing may
3579 move the value out of high mem and thus not fit
3580 in a signed 16bit value. */
3582 && (value
& 0x8000))
3585 /* mov imm16, an zero-extends the immediate. */
3587 && (long) value
< 0)
3590 /* Note that we've changed the relocation contents, etc. */
3591 elf_section_data (sec
)->relocs
= internal_relocs
;
3592 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3593 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3595 if ((code
& 0xfc) == 0xcc)
3596 code
= 0x2c + (code
& 0x03);
3597 else if ((code
& 0xfc) == 0xdc)
3598 code
= 0x24 + (code
& 0x03);
3599 else if ((code
& 0xfc) == 0xa4)
3600 code
= 0x30 + (code
& 0x03);
3601 else if ((code
& 0xfc) == 0xa8)
3602 code
= 0x34 + (code
& 0x03);
3603 else if ((code
& 0xfc) == 0xac)
3604 code
= 0x38 + (code
& 0x03);
3608 /* Fix the opcode. */
3609 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
3611 /* Fix the relocation's type. */
3612 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3613 (ELF32_R_TYPE (irel
->r_info
)
3614 == (int) R_MN10300_GOTOFF32
)
3615 ? R_MN10300_GOTOFF16
3616 : (ELF32_R_TYPE (irel
->r_info
)
3617 == (int) R_MN10300_GOT32
)
3619 : (ELF32_R_TYPE (irel
->r_info
)
3620 == (int) R_MN10300_GOTPC32
)
3621 ? R_MN10300_GOTPC16
:
3624 /* The opcode got shorter too, so we have to fix the
3625 addend and offset too! */
3626 irel
->r_offset
-= 1;
3628 /* Delete three bytes of data. */
3629 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3630 irel
->r_offset
+ 1, 3))
3633 /* That will change things, so, we should relax again.
3634 Note that this is not required, and it may be slow. */
3638 /* mov (abs32),an -> mov (abs16),an
3639 mov (d32,sp),an -> mov (d16,sp),an
3640 mov (d32,sp),dn -> mov (d16,sp),dn
3641 movbu (d32,sp),dn -> movbu (d16,sp),dn
3642 movhu (d32,sp),dn -> movhu (d16,sp),dn
3643 add imm32,dn -> add imm16,dn
3644 cmp imm32,dn -> cmp imm16,dn
3645 add imm32,an -> add imm16,an
3646 cmp imm32,an -> cmp imm16,an
3647 and imm32,dn -> and imm16,dn
3648 or imm32,dn -> or imm16,dn
3649 xor imm32,dn -> xor imm16,dn
3650 btst imm32,dn -> btst imm16,dn */
3666 /* cmp imm16, an zero-extends the immediate. */
3668 && (long) value
< 0)
3671 /* So do sp-based offsets. */
3672 if (code
>= 0xb0 && code
<= 0xb3
3673 && (long) value
< 0)
3676 /* Note that we've changed the relocation contents, etc. */
3677 elf_section_data (sec
)->relocs
= internal_relocs
;
3678 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3679 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3681 /* Fix the opcode. */
3682 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
3683 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
3685 /* Fix the relocation's type. */
3686 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3687 (ELF32_R_TYPE (irel
->r_info
)
3688 == (int) R_MN10300_GOTOFF32
)
3689 ? R_MN10300_GOTOFF16
3690 : (ELF32_R_TYPE (irel
->r_info
)
3691 == (int) R_MN10300_GOT32
)
3693 : (ELF32_R_TYPE (irel
->r_info
)
3694 == (int) R_MN10300_GOTPC32
)
3695 ? R_MN10300_GOTPC16
:
3698 /* Delete two bytes of data. */
3699 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3700 irel
->r_offset
+ 2, 2))
3703 /* That will change things, so, we should relax again.
3704 Note that this is not required, and it may be slow. */
3708 else if (code
== 0xfe)
3710 /* add imm32,sp -> add imm16,sp */
3712 /* Note that we've changed the relocation contents, etc. */
3713 elf_section_data (sec
)->relocs
= internal_relocs
;
3714 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3715 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3717 /* Fix the opcode. */
3718 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
3719 bfd_put_8 (abfd
, 0xfe, contents
+ irel
->r_offset
- 1);
3721 /* Fix the relocation's type. */
3722 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
3723 (ELF32_R_TYPE (irel
->r_info
)
3724 == (int) R_MN10300_GOT32
)
3726 : (ELF32_R_TYPE (irel
->r_info
)
3727 == (int) R_MN10300_GOTOFF32
)
3728 ? R_MN10300_GOTOFF16
3729 : (ELF32_R_TYPE (irel
->r_info
)
3730 == (int) R_MN10300_GOTPC32
)
3731 ? R_MN10300_GOTPC16
:
3734 /* Delete two bytes of data. */
3735 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
3736 irel
->r_offset
+ 2, 2))
3739 /* That will change things, so, we should relax again.
3740 Note that this is not required, and it may be slow. */
3749 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3751 if (! link_info
->keep_memory
)
3755 /* Cache the symbols for elf_link_input_bfd. */
3756 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
3760 if (contents
!= NULL
3761 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
3763 if (! link_info
->keep_memory
)
3767 /* Cache the section contents for elf_link_input_bfd. */
3768 elf_section_data (sec
)->this_hdr
.contents
= contents
;
3772 if (internal_relocs
!= NULL
3773 && elf_section_data (sec
)->relocs
!= internal_relocs
)
3774 free (internal_relocs
);
3780 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3782 if (contents
!= NULL
3783 && elf_section_data (section
)->this_hdr
.contents
!= contents
)
3785 if (internal_relocs
!= NULL
3786 && elf_section_data (section
)->relocs
!= internal_relocs
)
3787 free (internal_relocs
);
3792 /* This is a version of bfd_generic_get_relocated_section_contents
3793 which uses mn10300_elf_relocate_section. */
3796 mn10300_elf_get_relocated_section_contents (bfd
*output_bfd
,
3797 struct bfd_link_info
*link_info
,
3798 struct bfd_link_order
*link_order
,
3800 bfd_boolean relocatable
,
3803 Elf_Internal_Shdr
*symtab_hdr
;
3804 asection
*input_section
= link_order
->u
.indirect
.section
;
3805 bfd
*input_bfd
= input_section
->owner
;
3806 asection
**sections
= NULL
;
3807 Elf_Internal_Rela
*internal_relocs
= NULL
;
3808 Elf_Internal_Sym
*isymbuf
= NULL
;
3810 /* We only need to handle the case of relaxing, or of having a
3811 particular set of section contents, specially. */
3813 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
3814 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
3819 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3821 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
3822 (size_t) input_section
->size
);
3824 if ((input_section
->flags
& SEC_RELOC
) != 0
3825 && input_section
->reloc_count
> 0)
3828 Elf_Internal_Sym
*isym
, *isymend
;
3831 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, input_section
,
3833 if (internal_relocs
== NULL
)
3836 if (symtab_hdr
->sh_info
!= 0)
3838 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3839 if (isymbuf
== NULL
)
3840 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
3841 symtab_hdr
->sh_info
, 0,
3843 if (isymbuf
== NULL
)
3847 amt
= symtab_hdr
->sh_info
;
3848 amt
*= sizeof (asection
*);
3849 sections
= bfd_malloc (amt
);
3850 if (sections
== NULL
&& amt
!= 0)
3853 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
3854 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
3858 if (isym
->st_shndx
== SHN_UNDEF
)
3859 isec
= bfd_und_section_ptr
;
3860 else if (isym
->st_shndx
== SHN_ABS
)
3861 isec
= bfd_abs_section_ptr
;
3862 else if (isym
->st_shndx
== SHN_COMMON
)
3863 isec
= bfd_com_section_ptr
;
3865 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
3870 if (! mn10300_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
3871 input_section
, data
, internal_relocs
,
3875 if (sections
!= NULL
)
3877 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3879 if (internal_relocs
!= elf_section_data (input_section
)->relocs
)
3880 free (internal_relocs
);
3886 if (sections
!= NULL
)
3888 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
3890 if (internal_relocs
!= NULL
3891 && internal_relocs
!= elf_section_data (input_section
)->relocs
)
3892 free (internal_relocs
);
3896 /* Assorted hash table functions. */
3898 /* Initialize an entry in the link hash table. */
3900 /* Create an entry in an MN10300 ELF linker hash table. */
3902 static struct bfd_hash_entry
*
3903 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry
*entry
,
3904 struct bfd_hash_table
*table
,
3907 struct elf32_mn10300_link_hash_entry
*ret
=
3908 (struct elf32_mn10300_link_hash_entry
*) entry
;
3910 /* Allocate the structure if it has not already been allocated by a
3913 ret
= (struct elf32_mn10300_link_hash_entry
*)
3914 bfd_hash_allocate (table
, sizeof (* ret
));
3916 return (struct bfd_hash_entry
*) ret
;
3918 /* Call the allocation method of the superclass. */
3919 ret
= (struct elf32_mn10300_link_hash_entry
*)
3920 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
3924 ret
->direct_calls
= 0;
3925 ret
->stack_size
= 0;
3927 ret
->movm_stack_size
= 0;
3932 return (struct bfd_hash_entry
*) ret
;
3935 /* Create an mn10300 ELF linker hash table. */
3937 static struct bfd_link_hash_table
*
3938 elf32_mn10300_link_hash_table_create (bfd
*abfd
)
3940 struct elf32_mn10300_link_hash_table
*ret
;
3941 bfd_size_type amt
= sizeof (* ret
);
3943 ret
= bfd_malloc (amt
);
3947 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
3948 elf32_mn10300_link_hash_newfunc
,
3949 sizeof (struct elf32_mn10300_link_hash_entry
)))
3956 amt
= sizeof (struct elf_link_hash_table
);
3957 ret
->static_hash_table
= bfd_malloc (amt
);
3958 if (ret
->static_hash_table
== NULL
)
3964 if (!_bfd_elf_link_hash_table_init (&ret
->static_hash_table
->root
, abfd
,
3965 elf32_mn10300_link_hash_newfunc
,
3966 sizeof (struct elf32_mn10300_link_hash_entry
)))
3968 free (ret
->static_hash_table
);
3972 return & ret
->root
.root
;
3975 /* Free an mn10300 ELF linker hash table. */
3978 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table
*hash
)
3980 struct elf32_mn10300_link_hash_table
*ret
3981 = (struct elf32_mn10300_link_hash_table
*) hash
;
3983 _bfd_generic_link_hash_table_free
3984 ((struct bfd_link_hash_table
*) ret
->static_hash_table
);
3985 _bfd_generic_link_hash_table_free
3986 ((struct bfd_link_hash_table
*) ret
);
3989 static unsigned long
3990 elf_mn10300_mach (flagword flags
)
3992 switch (flags
& EF_MN10300_MACH
)
3994 case E_MN10300_MACH_MN10300
:
3996 return bfd_mach_mn10300
;
3998 case E_MN10300_MACH_AM33
:
3999 return bfd_mach_am33
;
4001 case E_MN10300_MACH_AM33_2
:
4002 return bfd_mach_am33_2
;
4006 /* The final processing done just before writing out a MN10300 ELF object
4007 file. This gets the MN10300 architecture right based on the machine
4011 _bfd_mn10300_elf_final_write_processing (bfd
*abfd
,
4012 bfd_boolean linker ATTRIBUTE_UNUSED
)
4016 switch (bfd_get_mach (abfd
))
4019 case bfd_mach_mn10300
:
4020 val
= E_MN10300_MACH_MN10300
;
4024 val
= E_MN10300_MACH_AM33
;
4027 case bfd_mach_am33_2
:
4028 val
= E_MN10300_MACH_AM33_2
;
4032 elf_elfheader (abfd
)->e_flags
&= ~ (EF_MN10300_MACH
);
4033 elf_elfheader (abfd
)->e_flags
|= val
;
4037 _bfd_mn10300_elf_object_p (bfd
*abfd
)
4039 bfd_default_set_arch_mach (abfd
, bfd_arch_mn10300
,
4040 elf_mn10300_mach (elf_elfheader (abfd
)->e_flags
));
4044 /* Merge backend specific data from an object file to the output
4045 object file when linking. */
4048 _bfd_mn10300_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4050 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4051 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4054 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4055 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
4057 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
4058 bfd_get_mach (ibfd
)))
4065 #define PLT0_ENTRY_SIZE 15
4066 #define PLT_ENTRY_SIZE 20
4067 #define PIC_PLT_ENTRY_SIZE 24
4069 static const bfd_byte elf_mn10300_plt0_entry
[PLT0_ENTRY_SIZE
] =
4071 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4072 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4073 0xf0, 0xf4, /* jmp (a0) */
4076 static const bfd_byte elf_mn10300_plt_entry
[PLT_ENTRY_SIZE
] =
4078 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4079 0xf0, 0xf4, /* jmp (a0) */
4080 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4081 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4084 static const bfd_byte elf_mn10300_pic_plt_entry
[PIC_PLT_ENTRY_SIZE
] =
4086 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4087 0xf0, 0xf4, /* jmp (a0) */
4088 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4089 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4090 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4091 0xf0, 0xf4, /* jmp (a0) */
4094 /* Return size of the first PLT entry. */
4095 #define elf_mn10300_sizeof_plt0(info) \
4096 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4098 /* Return size of a PLT entry. */
4099 #define elf_mn10300_sizeof_plt(info) \
4100 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4102 /* Return offset of the PLT0 address in an absolute PLT entry. */
4103 #define elf_mn10300_plt_plt0_offset(info) 16
4105 /* Return offset of the linker in PLT0 entry. */
4106 #define elf_mn10300_plt0_linker_offset(info) 2
4108 /* Return offset of the GOT id in PLT0 entry. */
4109 #define elf_mn10300_plt0_gotid_offset(info) 9
4111 /* Return offset of the temporary in PLT entry. */
4112 #define elf_mn10300_plt_temp_offset(info) 8
4114 /* Return offset of the symbol in PLT entry. */
4115 #define elf_mn10300_plt_symbol_offset(info) 2
4117 /* Return offset of the relocation in PLT entry. */
4118 #define elf_mn10300_plt_reloc_offset(info) 11
4120 /* The name of the dynamic interpreter. This is put in the .interp
4123 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4125 /* Create dynamic sections when linking against a dynamic object. */
4128 _bfd_mn10300_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4132 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
4135 switch (bed
->s
->arch_size
)
4146 bfd_set_error (bfd_error_bad_value
);
4150 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4151 .rel[a].bss sections. */
4152 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4153 | SEC_LINKER_CREATED
);
4155 s
= bfd_make_section_with_flags (abfd
,
4156 (bed
->default_use_rela_p
4157 ? ".rela.plt" : ".rel.plt"),
4158 flags
| SEC_READONLY
);
4160 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
4163 if (! _bfd_mn10300_elf_create_got_section (abfd
, info
))
4167 const char * secname
;
4172 for (sec
= abfd
->sections
; sec
; sec
= sec
->next
)
4174 secflags
= bfd_get_section_flags (abfd
, sec
);
4175 if ((secflags
& (SEC_DATA
| SEC_LINKER_CREATED
))
4176 || ((secflags
& SEC_HAS_CONTENTS
) != SEC_HAS_CONTENTS
))
4179 secname
= bfd_get_section_name (abfd
, sec
);
4180 relname
= bfd_malloc (strlen (secname
) + 6);
4181 strcpy (relname
, ".rela");
4182 strcat (relname
, secname
);
4184 s
= bfd_make_section_with_flags (abfd
, relname
,
4185 flags
| SEC_READONLY
);
4187 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
4192 if (bed
->want_dynbss
)
4194 /* The .dynbss section is a place to put symbols which are defined
4195 by dynamic objects, are referenced by regular objects, and are
4196 not functions. We must allocate space for them in the process
4197 image and use a R_*_COPY reloc to tell the dynamic linker to
4198 initialize them at run time. The linker script puts the .dynbss
4199 section into the .bss section of the final image. */
4200 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
4201 SEC_ALLOC
| SEC_LINKER_CREATED
);
4205 /* The .rel[a].bss section holds copy relocs. This section is not
4206 normally needed. We need to create it here, though, so that the
4207 linker will map it to an output section. We can't just create it
4208 only if we need it, because we will not know whether we need it
4209 until we have seen all the input files, and the first time the
4210 main linker code calls BFD after examining all the input files
4211 (size_dynamic_sections) the input sections have already been
4212 mapped to the output sections. If the section turns out not to
4213 be needed, we can discard it later. We will never need this
4214 section when generating a shared object, since they do not use
4218 s
= bfd_make_section_with_flags (abfd
,
4219 (bed
->default_use_rela_p
4220 ? ".rela.bss" : ".rel.bss"),
4221 flags
| SEC_READONLY
);
4223 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
4231 /* Adjust a symbol defined by a dynamic object and referenced by a
4232 regular object. The current definition is in some section of the
4233 dynamic object, but we're not including those sections. We have to
4234 change the definition to something the rest of the link can
4238 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info
* info
,
4239 struct elf_link_hash_entry
* h
)
4244 dynobj
= elf_hash_table (info
)->dynobj
;
4246 /* Make sure we know what is going on here. */
4247 BFD_ASSERT (dynobj
!= NULL
4249 || h
->u
.weakdef
!= NULL
4252 && !h
->def_regular
)));
4254 /* If this is a function, put it in the procedure linkage table. We
4255 will fill in the contents of the procedure linkage table later,
4256 when we know the address of the .got section. */
4257 if (h
->type
== STT_FUNC
4264 /* This case can occur if we saw a PLT reloc in an input
4265 file, but the symbol was never referred to by a dynamic
4266 object. In such a case, we don't actually need to build
4267 a procedure linkage table, and we can just do a REL32
4269 BFD_ASSERT (h
->needs_plt
);
4273 /* Make sure this symbol is output as a dynamic symbol. */
4274 if (h
->dynindx
== -1)
4276 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4280 s
= bfd_get_section_by_name (dynobj
, ".plt");
4281 BFD_ASSERT (s
!= NULL
);
4283 /* If this is the first .plt entry, make room for the special
4286 s
->size
+= elf_mn10300_sizeof_plt0 (info
);
4288 /* If this symbol is not defined in a regular file, and we are
4289 not generating a shared library, then set the symbol to this
4290 location in the .plt. This is required to make function
4291 pointers compare as equal between the normal executable and
4292 the shared library. */
4296 h
->root
.u
.def
.section
= s
;
4297 h
->root
.u
.def
.value
= s
->size
;
4300 h
->plt
.offset
= s
->size
;
4302 /* Make room for this entry. */
4303 s
->size
+= elf_mn10300_sizeof_plt (info
);
4305 /* We also need to make an entry in the .got.plt section, which
4306 will be placed in the .got section by the linker script. */
4307 s
= bfd_get_section_by_name (dynobj
, ".got.plt");
4308 BFD_ASSERT (s
!= NULL
);
4311 /* We also need to make an entry in the .rela.plt section. */
4312 s
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4313 BFD_ASSERT (s
!= NULL
);
4314 s
->size
+= sizeof (Elf32_External_Rela
);
4319 /* If this is a weak symbol, and there is a real definition, the
4320 processor independent code will have arranged for us to see the
4321 real definition first, and we can just use the same value. */
4322 if (h
->u
.weakdef
!= NULL
)
4324 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
4325 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
4326 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
4327 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
4331 /* This is a reference to a symbol defined by a dynamic object which
4332 is not a function. */
4334 /* If we are creating a shared library, we must presume that the
4335 only references to the symbol are via the global offset table.
4336 For such cases we need not do anything here; the relocations will
4337 be handled correctly by relocate_section. */
4341 /* If there are no references to this symbol that do not use the
4342 GOT, we don't need to generate a copy reloc. */
4343 if (!h
->non_got_ref
)
4348 (*_bfd_error_handler
) (_("dynamic variable `%s' is zero size"),
4349 h
->root
.root
.string
);
4353 /* We must allocate the symbol in our .dynbss section, which will
4354 become part of the .bss section of the executable. There will be
4355 an entry for this symbol in the .dynsym section. The dynamic
4356 object will contain position independent code, so all references
4357 from the dynamic object to this symbol will go through the global
4358 offset table. The dynamic linker will use the .dynsym entry to
4359 determine the address it must put in the global offset table, so
4360 both the dynamic object and the regular object will refer to the
4361 same memory location for the variable. */
4363 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
4364 BFD_ASSERT (s
!= NULL
);
4366 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4367 copy the initial value out of the dynamic object and into the
4368 runtime process image. We need to remember the offset into the
4369 .rela.bss section we are going to use. */
4370 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
4374 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
4375 BFD_ASSERT (srel
!= NULL
);
4376 srel
->size
+= sizeof (Elf32_External_Rela
);
4380 return _bfd_elf_adjust_dynamic_copy (h
, s
);
4383 /* Set the sizes of the dynamic sections. */
4386 _bfd_mn10300_elf_size_dynamic_sections (bfd
* output_bfd
,
4387 struct bfd_link_info
* info
)
4393 bfd_boolean reltext
;
4395 dynobj
= elf_hash_table (info
)->dynobj
;
4396 BFD_ASSERT (dynobj
!= NULL
);
4398 if (elf_hash_table (info
)->dynamic_sections_created
)
4400 /* Set the contents of the .interp section to the interpreter. */
4401 if (info
->executable
)
4403 s
= bfd_get_section_by_name (dynobj
, ".interp");
4404 BFD_ASSERT (s
!= NULL
);
4405 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4406 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
4411 /* We may have created entries in the .rela.got section.
4412 However, if we are not creating the dynamic sections, we will
4413 not actually use these entries. Reset the size of .rela.got,
4414 which will cause it to get stripped from the output file
4416 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
4421 /* The check_relocs and adjust_dynamic_symbol entry points have
4422 determined the sizes of the various dynamic sections. Allocate
4427 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
4431 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
4434 /* It's OK to base decisions on the section name, because none
4435 of the dynobj section names depend upon the input files. */
4436 name
= bfd_get_section_name (dynobj
, s
);
4438 if (streq (name
, ".plt"))
4440 /* Remember whether there is a PLT. */
4443 else if (CONST_STRNEQ (name
, ".rela"))
4449 /* Remember whether there are any reloc sections other
4451 if (! streq (name
, ".rela.plt"))
4453 const char * outname
;
4457 /* If this relocation section applies to a read only
4458 section, then we probably need a DT_TEXTREL
4459 entry. The entries in the .rela.plt section
4460 really apply to the .got section, which we
4461 created ourselves and so know is not readonly. */
4462 outname
= bfd_get_section_name (output_bfd
,
4464 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
4466 && (target
->flags
& SEC_READONLY
) != 0
4467 && (target
->flags
& SEC_ALLOC
) != 0)
4471 /* We use the reloc_count field as a counter if we need
4472 to copy relocs into the output file. */
4476 else if (! CONST_STRNEQ (name
, ".got")
4477 && ! streq (name
, ".dynbss"))
4478 /* It's not one of our sections, so don't allocate space. */
4483 /* If we don't need this section, strip it from the
4484 output file. This is mostly to handle .rela.bss and
4485 .rela.plt. We must create both sections in
4486 create_dynamic_sections, because they must be created
4487 before the linker maps input sections to output
4488 sections. The linker does that before
4489 adjust_dynamic_symbol is called, and it is that
4490 function which decides whether anything needs to go
4491 into these sections. */
4492 s
->flags
|= SEC_EXCLUDE
;
4496 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
4499 /* Allocate memory for the section contents. We use bfd_zalloc
4500 here in case unused entries are not reclaimed before the
4501 section's contents are written out. This should not happen,
4502 but this way if it does, we get a R_MN10300_NONE reloc
4503 instead of garbage. */
4504 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
4505 if (s
->contents
== NULL
)
4509 if (elf_hash_table (info
)->dynamic_sections_created
)
4511 /* Add some entries to the .dynamic section. We fill in the
4512 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4513 but we must add the entries now so that we get the correct
4514 size for the .dynamic section. The DT_DEBUG entry is filled
4515 in by the dynamic linker and used by the debugger. */
4518 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
4524 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
4525 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
4526 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
4527 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
4533 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
4534 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
4535 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
4536 sizeof (Elf32_External_Rela
)))
4542 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
4550 /* Finish up dynamic symbol handling. We set the contents of various
4551 dynamic sections here. */
4554 _bfd_mn10300_elf_finish_dynamic_symbol (bfd
* output_bfd
,
4555 struct bfd_link_info
* info
,
4556 struct elf_link_hash_entry
* h
,
4557 Elf_Internal_Sym
* sym
)
4561 dynobj
= elf_hash_table (info
)->dynobj
;
4563 if (h
->plt
.offset
!= (bfd_vma
) -1)
4570 Elf_Internal_Rela rel
;
4572 /* This symbol has an entry in the procedure linkage table. Set
4575 BFD_ASSERT (h
->dynindx
!= -1);
4577 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4578 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
4579 srel
= bfd_get_section_by_name (dynobj
, ".rela.plt");
4580 BFD_ASSERT (splt
!= NULL
&& sgot
!= NULL
&& srel
!= NULL
);
4582 /* Get the index in the procedure linkage table which
4583 corresponds to this symbol. This is the index of this symbol
4584 in all the symbols for which we are making plt entries. The
4585 first entry in the procedure linkage table is reserved. */
4586 plt_index
= ((h
->plt
.offset
- elf_mn10300_sizeof_plt0 (info
))
4587 / elf_mn10300_sizeof_plt (info
));
4589 /* Get the offset into the .got table of the entry that
4590 corresponds to this function. Each .got entry is 4 bytes.
4591 The first three are reserved. */
4592 got_offset
= (plt_index
+ 3) * 4;
4594 /* Fill in the entry in the procedure linkage table. */
4597 memcpy (splt
->contents
+ h
->plt
.offset
, elf_mn10300_plt_entry
,
4598 elf_mn10300_sizeof_plt (info
));
4599 bfd_put_32 (output_bfd
,
4600 (sgot
->output_section
->vma
4601 + sgot
->output_offset
4603 (splt
->contents
+ h
->plt
.offset
4604 + elf_mn10300_plt_symbol_offset (info
)));
4606 bfd_put_32 (output_bfd
,
4607 (1 - h
->plt
.offset
- elf_mn10300_plt_plt0_offset (info
)),
4608 (splt
->contents
+ h
->plt
.offset
4609 + elf_mn10300_plt_plt0_offset (info
)));
4613 memcpy (splt
->contents
+ h
->plt
.offset
, elf_mn10300_pic_plt_entry
,
4614 elf_mn10300_sizeof_plt (info
));
4616 bfd_put_32 (output_bfd
, got_offset
,
4617 (splt
->contents
+ h
->plt
.offset
4618 + elf_mn10300_plt_symbol_offset (info
)));
4621 bfd_put_32 (output_bfd
, plt_index
* sizeof (Elf32_External_Rela
),
4622 (splt
->contents
+ h
->plt
.offset
4623 + elf_mn10300_plt_reloc_offset (info
)));
4625 /* Fill in the entry in the global offset table. */
4626 bfd_put_32 (output_bfd
,
4627 (splt
->output_section
->vma
4628 + splt
->output_offset
4630 + elf_mn10300_plt_temp_offset (info
)),
4631 sgot
->contents
+ got_offset
);
4633 /* Fill in the entry in the .rela.plt section. */
4634 rel
.r_offset
= (sgot
->output_section
->vma
4635 + sgot
->output_offset
4637 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MN10300_JMP_SLOT
);
4639 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
4640 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
4643 if (!h
->def_regular
)
4644 /* Mark the symbol as undefined, rather than as defined in
4645 the .plt section. Leave the value alone. */
4646 sym
->st_shndx
= SHN_UNDEF
;
4649 if (h
->got
.offset
!= (bfd_vma
) -1)
4653 Elf_Internal_Rela rel
;
4655 /* This symbol has an entry in the global offset table. Set it up. */
4656 sgot
= bfd_get_section_by_name (dynobj
, ".got");
4657 srel
= bfd_get_section_by_name (dynobj
, ".rela.got");
4658 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
4660 rel
.r_offset
= (sgot
->output_section
->vma
4661 + sgot
->output_offset
4662 + (h
->got
.offset
& ~1));
4664 /* If this is a -Bsymbolic link, and the symbol is defined
4665 locally, we just want to emit a RELATIVE reloc. Likewise if
4666 the symbol was forced to be local because of a version file.
4667 The entry in the global offset table will already have been
4668 initialized in the relocate_section function. */
4670 && (info
->symbolic
|| h
->dynindx
== -1)
4673 rel
.r_info
= ELF32_R_INFO (0, R_MN10300_RELATIVE
);
4674 rel
.r_addend
= (h
->root
.u
.def
.value
4675 + h
->root
.u
.def
.section
->output_section
->vma
4676 + h
->root
.u
.def
.section
->output_offset
);
4680 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
4681 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MN10300_GLOB_DAT
);
4685 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
4686 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
4687 + srel
->reloc_count
));
4688 ++ srel
->reloc_count
;
4694 Elf_Internal_Rela rel
;
4696 /* This symbol needs a copy reloc. Set it up. */
4697 BFD_ASSERT (h
->dynindx
!= -1
4698 && (h
->root
.type
== bfd_link_hash_defined
4699 || h
->root
.type
== bfd_link_hash_defweak
));
4701 s
= bfd_get_section_by_name (h
->root
.u
.def
.section
->owner
,
4703 BFD_ASSERT (s
!= NULL
);
4705 rel
.r_offset
= (h
->root
.u
.def
.value
4706 + h
->root
.u
.def
.section
->output_section
->vma
4707 + h
->root
.u
.def
.section
->output_offset
);
4708 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_MN10300_COPY
);
4710 bfd_elf32_swap_reloca_out (output_bfd
, & rel
,
4711 (bfd_byte
*) ((Elf32_External_Rela
*) s
->contents
4716 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4717 if (streq (h
->root
.root
.string
, "_DYNAMIC")
4718 || h
== elf_hash_table (info
)->hgot
)
4719 sym
->st_shndx
= SHN_ABS
;
4724 /* Finish up the dynamic sections. */
4727 _bfd_mn10300_elf_finish_dynamic_sections (bfd
* output_bfd
,
4728 struct bfd_link_info
* info
)
4734 dynobj
= elf_hash_table (info
)->dynobj
;
4736 sgot
= bfd_get_section_by_name (dynobj
, ".got.plt");
4737 BFD_ASSERT (sgot
!= NULL
);
4738 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4740 if (elf_hash_table (info
)->dynamic_sections_created
)
4743 Elf32_External_Dyn
* dyncon
;
4744 Elf32_External_Dyn
* dynconend
;
4746 BFD_ASSERT (sdyn
!= NULL
);
4748 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4749 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4751 for (; dyncon
< dynconend
; dyncon
++)
4753 Elf_Internal_Dyn dyn
;
4757 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4771 s
= bfd_get_section_by_name (output_bfd
, name
);
4772 BFD_ASSERT (s
!= NULL
);
4773 dyn
.d_un
.d_ptr
= s
->vma
;
4774 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4778 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
4779 BFD_ASSERT (s
!= NULL
);
4780 dyn
.d_un
.d_val
= s
->size
;
4781 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4785 /* My reading of the SVR4 ABI indicates that the
4786 procedure linkage table relocs (DT_JMPREL) should be
4787 included in the overall relocs (DT_RELA). This is
4788 what Solaris does. However, UnixWare can not handle
4789 that case. Therefore, we override the DT_RELASZ entry
4790 here to make it not include the JMPREL relocs. Since
4791 the linker script arranges for .rela.plt to follow all
4792 other relocation sections, we don't have to worry
4793 about changing the DT_RELA entry. */
4794 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
4796 dyn
.d_un
.d_val
-= s
->size
;
4797 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4802 /* Fill in the first entry in the procedure linkage table. */
4803 splt
= bfd_get_section_by_name (dynobj
, ".plt");
4804 if (splt
&& splt
->size
> 0)
4808 memcpy (splt
->contents
, elf_mn10300_pic_plt_entry
,
4809 elf_mn10300_sizeof_plt (info
));
4813 memcpy (splt
->contents
, elf_mn10300_plt0_entry
, PLT0_ENTRY_SIZE
);
4814 bfd_put_32 (output_bfd
,
4815 sgot
->output_section
->vma
+ sgot
->output_offset
+ 4,
4816 splt
->contents
+ elf_mn10300_plt0_gotid_offset (info
));
4817 bfd_put_32 (output_bfd
,
4818 sgot
->output_section
->vma
+ sgot
->output_offset
+ 8,
4819 splt
->contents
+ elf_mn10300_plt0_linker_offset (info
));
4822 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4823 really seem like the right value. */
4824 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
= 4;
4828 /* Fill in the first three entries in the global offset table. */
4832 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
4834 bfd_put_32 (output_bfd
,
4835 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
4837 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 4);
4838 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ 8);
4841 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
4846 /* Classify relocation types, such that combreloc can sort them
4849 static enum elf_reloc_type_class
4850 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela
*rela
)
4852 switch ((int) ELF32_R_TYPE (rela
->r_info
))
4854 case R_MN10300_RELATIVE
: return reloc_class_relative
;
4855 case R_MN10300_JMP_SLOT
: return reloc_class_plt
;
4856 case R_MN10300_COPY
: return reloc_class_copy
;
4857 default: return reloc_class_normal
;
4862 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
4863 #define TARGET_LITTLE_NAME "elf32-mn10300"
4864 #define ELF_ARCH bfd_arch_mn10300
4865 #define ELF_MACHINE_CODE EM_MN10300
4866 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
4867 #define ELF_MAXPAGESIZE 0x1000
4870 #define elf_info_to_howto mn10300_info_to_howto
4871 #define elf_info_to_howto_rel 0
4872 #define elf_backend_can_gc_sections 1
4873 #define elf_backend_rela_normal 1
4874 #define elf_backend_check_relocs mn10300_elf_check_relocs
4875 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
4876 #define elf_backend_relocate_section mn10300_elf_relocate_section
4877 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
4878 #define bfd_elf32_bfd_get_relocated_section_contents \
4879 mn10300_elf_get_relocated_section_contents
4880 #define bfd_elf32_bfd_link_hash_table_create \
4881 elf32_mn10300_link_hash_table_create
4882 #define bfd_elf32_bfd_link_hash_table_free \
4883 elf32_mn10300_link_hash_table_free
4885 #ifndef elf_symbol_leading_char
4886 #define elf_symbol_leading_char '_'
4889 /* So we can set bits in e_flags. */
4890 #define elf_backend_final_write_processing \
4891 _bfd_mn10300_elf_final_write_processing
4892 #define elf_backend_object_p _bfd_mn10300_elf_object_p
4894 #define bfd_elf32_bfd_merge_private_bfd_data \
4895 _bfd_mn10300_elf_merge_private_bfd_data
4897 #define elf_backend_can_gc_sections 1
4898 #define elf_backend_create_dynamic_sections \
4899 _bfd_mn10300_elf_create_dynamic_sections
4900 #define elf_backend_adjust_dynamic_symbol \
4901 _bfd_mn10300_elf_adjust_dynamic_symbol
4902 #define elf_backend_size_dynamic_sections \
4903 _bfd_mn10300_elf_size_dynamic_sections
4904 #define elf_backend_omit_section_dynsym \
4905 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4906 #define elf_backend_finish_dynamic_symbol \
4907 _bfd_mn10300_elf_finish_dynamic_symbol
4908 #define elf_backend_finish_dynamic_sections \
4909 _bfd_mn10300_elf_finish_dynamic_sections
4911 #define elf_backend_reloc_type_class \
4912 _bfd_mn10300_elf_reloc_type_class
4914 #define elf_backend_want_got_plt 1
4915 #define elf_backend_plt_readonly 1
4916 #define elf_backend_want_plt_sym 0
4917 #define elf_backend_got_header_size 12
4919 #include "elf32-target.h"