1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007, 2008, 2009, 2010, 2011, 2012 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. */
78 /* Used to distinguish GOT entries for TLS types from normal GOT entries. */
79 unsigned char tls_type;
82 /* We derive a hash table from the main elf linker hash table so
83 we can store state variables and a secondary hash table without
84 resorting to global variables. */
85 struct elf32_mn10300_link_hash_table
87 /* The main hash table. */
88 struct elf_link_hash_table root;
90 /* A hash table for static functions. We could derive a new hash table
91 instead of using the full elf32_mn10300_link_hash_table if we wanted
92 to save some memory. */
93 struct elf32_mn10300_link_hash_table *static_hash_table;
95 /* Random linker state flags. */
96 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
100 bfd_signed_vma refcount;
107 #define elf_mn10300_hash_entry(ent) ((struct elf32_mn10300_link_hash_entry *)(ent))
109 struct elf_mn10300_obj_tdata
111 struct elf_obj_tdata root;
113 /* tls_type for each local got entry. */
114 char * local_got_tls_type;
117 #define elf_mn10300_tdata(abfd) \
118 ((struct elf_mn10300_obj_tdata *) (abfd)->tdata.any)
120 #define elf_mn10300_local_got_tls_type(abfd) \
121 (elf_mn10300_tdata (abfd)->local_got_tls_type)
124 #define streq(a, b) (strcmp ((a),(b)) == 0)
127 /* For MN10300 linker hash table. */
129 /* Get the MN10300 ELF linker hash table from a link_info structure. */
131 #define elf32_mn10300_hash_table(p) \
132 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
133 == MN10300_ELF_DATA ? ((struct elf32_mn10300_link_hash_table *) ((p)->hash)) : NULL)
135 #define elf32_mn10300_link_hash_traverse(table, func, info) \
136 (elf_link_hash_traverse \
138 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
141 static reloc_howto_type elf_mn10300_howto_table[] =
143 /* Dummy relocation. Does nothing. */
144 HOWTO (R_MN10300_NONE,
150 complain_overflow_bitfield,
151 bfd_elf_generic_reloc,
157 /* Standard 32 bit reloc. */
164 complain_overflow_bitfield,
165 bfd_elf_generic_reloc,
171 /* Standard 16 bit reloc. */
178 complain_overflow_bitfield,
179 bfd_elf_generic_reloc,
185 /* Standard 8 bit reloc. */
192 complain_overflow_bitfield,
193 bfd_elf_generic_reloc,
199 /* Standard 32bit pc-relative reloc. */
200 HOWTO (R_MN10300_PCREL32,
206 complain_overflow_bitfield,
207 bfd_elf_generic_reloc,
213 /* Standard 16bit pc-relative reloc. */
214 HOWTO (R_MN10300_PCREL16,
220 complain_overflow_bitfield,
221 bfd_elf_generic_reloc,
227 /* Standard 8 pc-relative reloc. */
228 HOWTO (R_MN10300_PCREL8,
234 complain_overflow_bitfield,
235 bfd_elf_generic_reloc,
242 /* GNU extension to record C++ vtable hierarchy. */
243 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
245 0, /* size (0 = byte, 1 = short, 2 = long) */
247 FALSE, /* pc_relative */
249 complain_overflow_dont, /* complain_on_overflow */
250 NULL, /* special_function */
251 "R_MN10300_GNU_VTINHERIT", /* name */
252 FALSE, /* partial_inplace */
255 FALSE), /* pcrel_offset */
257 /* GNU extension to record C++ vtable member usage */
258 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
260 0, /* size (0 = byte, 1 = short, 2 = long) */
262 FALSE, /* pc_relative */
264 complain_overflow_dont, /* complain_on_overflow */
265 NULL, /* special_function */
266 "R_MN10300_GNU_VTENTRY", /* name */
267 FALSE, /* partial_inplace */
270 FALSE), /* pcrel_offset */
272 /* Standard 24 bit reloc. */
279 complain_overflow_bitfield,
280 bfd_elf_generic_reloc,
286 HOWTO (R_MN10300_GOTPC32, /* type */
288 2, /* size (0 = byte, 1 = short, 2 = long) */
290 TRUE, /* pc_relative */
292 complain_overflow_bitfield, /* complain_on_overflow */
293 bfd_elf_generic_reloc, /* */
294 "R_MN10300_GOTPC32", /* name */
295 FALSE, /* partial_inplace */
296 0xffffffff, /* src_mask */
297 0xffffffff, /* dst_mask */
298 TRUE), /* pcrel_offset */
300 HOWTO (R_MN10300_GOTPC16, /* type */
302 1, /* size (0 = byte, 1 = short, 2 = long) */
304 TRUE, /* pc_relative */
306 complain_overflow_bitfield, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* */
308 "R_MN10300_GOTPC16", /* name */
309 FALSE, /* partial_inplace */
310 0xffff, /* src_mask */
311 0xffff, /* dst_mask */
312 TRUE), /* pcrel_offset */
314 HOWTO (R_MN10300_GOTOFF32, /* type */
316 2, /* size (0 = byte, 1 = short, 2 = long) */
318 FALSE, /* pc_relative */
320 complain_overflow_bitfield, /* complain_on_overflow */
321 bfd_elf_generic_reloc, /* */
322 "R_MN10300_GOTOFF32", /* name */
323 FALSE, /* partial_inplace */
324 0xffffffff, /* src_mask */
325 0xffffffff, /* dst_mask */
326 FALSE), /* pcrel_offset */
328 HOWTO (R_MN10300_GOTOFF24, /* type */
330 2, /* size (0 = byte, 1 = short, 2 = long) */
332 FALSE, /* pc_relative */
334 complain_overflow_bitfield, /* complain_on_overflow */
335 bfd_elf_generic_reloc, /* */
336 "R_MN10300_GOTOFF24", /* name */
337 FALSE, /* partial_inplace */
338 0xffffff, /* src_mask */
339 0xffffff, /* dst_mask */
340 FALSE), /* pcrel_offset */
342 HOWTO (R_MN10300_GOTOFF16, /* type */
344 1, /* size (0 = byte, 1 = short, 2 = long) */
346 FALSE, /* pc_relative */
348 complain_overflow_bitfield, /* complain_on_overflow */
349 bfd_elf_generic_reloc, /* */
350 "R_MN10300_GOTOFF16", /* name */
351 FALSE, /* partial_inplace */
352 0xffff, /* src_mask */
353 0xffff, /* dst_mask */
354 FALSE), /* pcrel_offset */
356 HOWTO (R_MN10300_PLT32, /* type */
358 2, /* size (0 = byte, 1 = short, 2 = long) */
360 TRUE, /* pc_relative */
362 complain_overflow_bitfield, /* complain_on_overflow */
363 bfd_elf_generic_reloc, /* */
364 "R_MN10300_PLT32", /* name */
365 FALSE, /* partial_inplace */
366 0xffffffff, /* src_mask */
367 0xffffffff, /* dst_mask */
368 TRUE), /* pcrel_offset */
370 HOWTO (R_MN10300_PLT16, /* type */
372 1, /* size (0 = byte, 1 = short, 2 = long) */
374 TRUE, /* pc_relative */
376 complain_overflow_bitfield, /* complain_on_overflow */
377 bfd_elf_generic_reloc, /* */
378 "R_MN10300_PLT16", /* name */
379 FALSE, /* partial_inplace */
380 0xffff, /* src_mask */
381 0xffff, /* dst_mask */
382 TRUE), /* pcrel_offset */
384 HOWTO (R_MN10300_GOT32, /* type */
386 2, /* size (0 = byte, 1 = short, 2 = long) */
388 FALSE, /* pc_relative */
390 complain_overflow_bitfield, /* complain_on_overflow */
391 bfd_elf_generic_reloc, /* */
392 "R_MN10300_GOT32", /* name */
393 FALSE, /* partial_inplace */
394 0xffffffff, /* src_mask */
395 0xffffffff, /* dst_mask */
396 FALSE), /* pcrel_offset */
398 HOWTO (R_MN10300_GOT24, /* type */
400 2, /* size (0 = byte, 1 = short, 2 = long) */
402 FALSE, /* pc_relative */
404 complain_overflow_bitfield, /* complain_on_overflow */
405 bfd_elf_generic_reloc, /* */
406 "R_MN10300_GOT24", /* name */
407 FALSE, /* partial_inplace */
408 0xffffffff, /* src_mask */
409 0xffffffff, /* dst_mask */
410 FALSE), /* pcrel_offset */
412 HOWTO (R_MN10300_GOT16, /* type */
414 1, /* size (0 = byte, 1 = short, 2 = long) */
416 FALSE, /* pc_relative */
418 complain_overflow_bitfield, /* complain_on_overflow */
419 bfd_elf_generic_reloc, /* */
420 "R_MN10300_GOT16", /* name */
421 FALSE, /* partial_inplace */
422 0xffffffff, /* src_mask */
423 0xffffffff, /* dst_mask */
424 FALSE), /* pcrel_offset */
426 HOWTO (R_MN10300_COPY, /* type */
428 2, /* size (0 = byte, 1 = short, 2 = long) */
430 FALSE, /* pc_relative */
432 complain_overflow_bitfield, /* complain_on_overflow */
433 bfd_elf_generic_reloc, /* */
434 "R_MN10300_COPY", /* name */
435 FALSE, /* partial_inplace */
436 0xffffffff, /* src_mask */
437 0xffffffff, /* dst_mask */
438 FALSE), /* pcrel_offset */
440 HOWTO (R_MN10300_GLOB_DAT, /* type */
442 2, /* size (0 = byte, 1 = short, 2 = long) */
444 FALSE, /* pc_relative */
446 complain_overflow_bitfield, /* complain_on_overflow */
447 bfd_elf_generic_reloc, /* */
448 "R_MN10300_GLOB_DAT", /* name */
449 FALSE, /* partial_inplace */
450 0xffffffff, /* src_mask */
451 0xffffffff, /* dst_mask */
452 FALSE), /* pcrel_offset */
454 HOWTO (R_MN10300_JMP_SLOT, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 FALSE, /* pc_relative */
460 complain_overflow_bitfield, /* complain_on_overflow */
461 bfd_elf_generic_reloc, /* */
462 "R_MN10300_JMP_SLOT", /* name */
463 FALSE, /* partial_inplace */
464 0xffffffff, /* src_mask */
465 0xffffffff, /* dst_mask */
466 FALSE), /* pcrel_offset */
468 HOWTO (R_MN10300_RELATIVE, /* type */
470 2, /* size (0 = byte, 1 = short, 2 = long) */
472 FALSE, /* pc_relative */
474 complain_overflow_bitfield, /* complain_on_overflow */
475 bfd_elf_generic_reloc, /* */
476 "R_MN10300_RELATIVE", /* name */
477 FALSE, /* partial_inplace */
478 0xffffffff, /* src_mask */
479 0xffffffff, /* dst_mask */
480 FALSE), /* pcrel_offset */
482 HOWTO (R_MN10300_TLS_GD, /* type */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
486 FALSE, /* pc_relative */
488 complain_overflow_bitfield, /* complain_on_overflow */
489 bfd_elf_generic_reloc, /* */
490 "R_MN10300_TLS_GD", /* name */
491 FALSE, /* partial_inplace */
492 0xffffffff, /* src_mask */
493 0xffffffff, /* dst_mask */
494 FALSE), /* pcrel_offset */
496 HOWTO (R_MN10300_TLS_LD, /* type */
498 2, /* size (0 = byte, 1 = short, 2 = long) */
500 FALSE, /* pc_relative */
502 complain_overflow_bitfield, /* complain_on_overflow */
503 bfd_elf_generic_reloc, /* */
504 "R_MN10300_TLS_LD", /* name */
505 FALSE, /* partial_inplace */
506 0xffffffff, /* src_mask */
507 0xffffffff, /* dst_mask */
508 FALSE), /* pcrel_offset */
510 HOWTO (R_MN10300_TLS_LDO, /* type */
512 2, /* size (0 = byte, 1 = short, 2 = long) */
514 FALSE, /* pc_relative */
516 complain_overflow_bitfield, /* complain_on_overflow */
517 bfd_elf_generic_reloc, /* */
518 "R_MN10300_TLS_LDO", /* name */
519 FALSE, /* partial_inplace */
520 0xffffffff, /* src_mask */
521 0xffffffff, /* dst_mask */
522 FALSE), /* pcrel_offset */
524 HOWTO (R_MN10300_TLS_GOTIE, /* type */
526 2, /* size (0 = byte, 1 = short, 2 = long) */
528 FALSE, /* pc_relative */
530 complain_overflow_bitfield, /* complain_on_overflow */
531 bfd_elf_generic_reloc, /* */
532 "R_MN10300_TLS_GOTIE", /* name */
533 FALSE, /* partial_inplace */
534 0xffffffff, /* src_mask */
535 0xffffffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
538 HOWTO (R_MN10300_TLS_IE, /* type */
540 2, /* size (0 = byte, 1 = short, 2 = long) */
542 FALSE, /* pc_relative */
544 complain_overflow_bitfield, /* complain_on_overflow */
545 bfd_elf_generic_reloc, /* */
546 "R_MN10300_TLS_IE", /* name */
547 FALSE, /* partial_inplace */
548 0xffffffff, /* src_mask */
549 0xffffffff, /* dst_mask */
550 FALSE), /* pcrel_offset */
552 HOWTO (R_MN10300_TLS_LE, /* type */
554 2, /* size (0 = byte, 1 = short, 2 = long) */
556 FALSE, /* pc_relative */
558 complain_overflow_bitfield, /* complain_on_overflow */
559 bfd_elf_generic_reloc, /* */
560 "R_MN10300_TLS_LE", /* name */
561 FALSE, /* partial_inplace */
562 0xffffffff, /* src_mask */
563 0xffffffff, /* dst_mask */
564 FALSE), /* pcrel_offset */
566 HOWTO (R_MN10300_TLS_DTPMOD, /* type */
568 2, /* size (0 = byte, 1 = short, 2 = long) */
570 FALSE, /* pc_relative */
572 complain_overflow_bitfield, /* complain_on_overflow */
573 bfd_elf_generic_reloc, /* */
574 "R_MN10300_TLS_DTPMOD", /* name */
575 FALSE, /* partial_inplace */
576 0xffffffff, /* src_mask */
577 0xffffffff, /* dst_mask */
578 FALSE), /* pcrel_offset */
580 HOWTO (R_MN10300_TLS_DTPOFF, /* type */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
584 FALSE, /* pc_relative */
586 complain_overflow_bitfield, /* complain_on_overflow */
587 bfd_elf_generic_reloc, /* */
588 "R_MN10300_TLS_DTPOFF", /* name */
589 FALSE, /* partial_inplace */
590 0xffffffff, /* src_mask */
591 0xffffffff, /* dst_mask */
592 FALSE), /* pcrel_offset */
594 HOWTO (R_MN10300_TLS_TPOFF, /* type */
596 2, /* size (0 = byte, 1 = short, 2 = long) */
598 FALSE, /* pc_relative */
600 complain_overflow_bitfield, /* complain_on_overflow */
601 bfd_elf_generic_reloc, /* */
602 "R_MN10300_TLS_TPOFF", /* name */
603 FALSE, /* partial_inplace */
604 0xffffffff, /* src_mask */
605 0xffffffff, /* dst_mask */
606 FALSE), /* pcrel_offset */
608 HOWTO (R_MN10300_SYM_DIFF, /* type */
610 2, /* size (0 = byte, 1 = short, 2 = long) */
612 FALSE, /* pc_relative */
614 complain_overflow_dont,/* complain_on_overflow */
615 NULL, /* special handler. */
616 "R_MN10300_SYM_DIFF", /* name */
617 FALSE, /* partial_inplace */
618 0xffffffff, /* src_mask */
619 0xffffffff, /* dst_mask */
620 FALSE), /* pcrel_offset */
622 HOWTO (R_MN10300_ALIGN, /* type */
624 0, /* size (0 = byte, 1 = short, 2 = long) */
626 FALSE, /* pc_relative */
628 complain_overflow_dont,/* complain_on_overflow */
629 NULL, /* special handler. */
630 "R_MN10300_ALIGN", /* name */
631 FALSE, /* partial_inplace */
634 FALSE) /* pcrel_offset */
637 struct mn10300_reloc_map
639 bfd_reloc_code_real_type bfd_reloc_val;
640 unsigned char elf_reloc_val;
643 static const struct mn10300_reloc_map mn10300_reloc_map[] =
645 { BFD_RELOC_NONE, R_MN10300_NONE, },
646 { BFD_RELOC_32, R_MN10300_32, },
647 { BFD_RELOC_16, R_MN10300_16, },
648 { BFD_RELOC_8, R_MN10300_8, },
649 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
650 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
651 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
652 { BFD_RELOC_24, R_MN10300_24, },
653 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
654 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
655 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
656 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
657 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
658 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
659 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
660 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
661 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
662 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
663 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
664 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
665 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
666 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
667 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
668 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
669 { BFD_RELOC_MN10300_TLS_GD, R_MN10300_TLS_GD },
670 { BFD_RELOC_MN10300_TLS_LD, R_MN10300_TLS_LD },
671 { BFD_RELOC_MN10300_TLS_LDO, R_MN10300_TLS_LDO },
672 { BFD_RELOC_MN10300_TLS_GOTIE, R_MN10300_TLS_GOTIE },
673 { BFD_RELOC_MN10300_TLS_IE, R_MN10300_TLS_IE },
674 { BFD_RELOC_MN10300_TLS_LE, R_MN10300_TLS_LE },
675 { BFD_RELOC_MN10300_TLS_DTPMOD, R_MN10300_TLS_DTPMOD },
676 { BFD_RELOC_MN10300_TLS_DTPOFF, R_MN10300_TLS_DTPOFF },
677 { BFD_RELOC_MN10300_TLS_TPOFF, R_MN10300_TLS_TPOFF },
678 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
679 { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
682 /* Create the GOT section. */
685 _bfd_mn10300_elf_create_got_section (bfd * abfd,
686 struct bfd_link_info * info)
691 struct elf_link_hash_entry * h;
692 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
695 /* This function may be called more than once. */
696 if (bfd_get_section_by_name (abfd, ".got") != NULL)
699 switch (bed->s->arch_size)
710 bfd_set_error (bfd_error_bad_value);
714 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
715 | SEC_LINKER_CREATED);
718 pltflags |= SEC_CODE;
719 if (bed->plt_not_loaded)
720 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
721 if (bed->plt_readonly)
722 pltflags |= SEC_READONLY;
724 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
726 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
729 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
731 if (bed->want_plt_sym)
733 h = _bfd_elf_define_linkage_sym (abfd, info, s,
734 "_PROCEDURE_LINKAGE_TABLE_");
735 elf_hash_table (info)->hplt = h;
740 s = bfd_make_section_with_flags (abfd, ".got", flags);
742 || ! bfd_set_section_alignment (abfd, s, ptralign))
745 if (bed->want_got_plt)
747 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
749 || ! bfd_set_section_alignment (abfd, s, ptralign))
753 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
754 (or .got.plt) section. We don't do this in the linker script
755 because we don't want to define the symbol if we are not creating
756 a global offset table. */
757 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
758 elf_hash_table (info)->hgot = h;
762 /* The first bit of the global offset table is the header. */
763 s->size += bed->got_header_size;
768 static reloc_howto_type *
769 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
770 bfd_reloc_code_real_type code)
774 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
775 if (mn10300_reloc_map[i].bfd_reloc_val == code)
776 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
781 static reloc_howto_type *
782 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
787 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
788 if (elf_mn10300_howto_table[i].name != NULL
789 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
790 return elf_mn10300_howto_table + i;
795 /* Set the howto pointer for an MN10300 ELF reloc. */
798 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
800 Elf_Internal_Rela *dst)
804 r_type = ELF32_R_TYPE (dst->r_info);
805 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
806 cache_ptr->howto = elf_mn10300_howto_table + r_type;
810 elf_mn10300_tls_transition (struct bfd_link_info * info,
812 struct elf_link_hash_entry * h,
814 bfd_boolean counting)
816 bfd_boolean is_local;
818 if (r_type == R_MN10300_TLS_GD
820 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
821 return R_MN10300_TLS_GOTIE;
826 if (! (sec->flags & SEC_CODE))
829 if (! counting && h != NULL && ! elf_hash_table (info)->dynamic_sections_created)
832 is_local = SYMBOL_CALLS_LOCAL (info, h);
834 /* For the main program, these are the transitions we do. */
837 case R_MN10300_TLS_GD: return is_local ? R_MN10300_TLS_LE : R_MN10300_TLS_GOTIE;
838 case R_MN10300_TLS_LD: return R_MN10300_NONE;
839 case R_MN10300_TLS_LDO: return R_MN10300_TLS_LE;
840 case R_MN10300_TLS_IE:
841 case R_MN10300_TLS_GOTIE: return is_local ? R_MN10300_TLS_LE : r_type;
847 /* Return the relocation value for @tpoff relocation
848 if STT_TLS virtual address is ADDRESS. */
851 dtpoff (struct bfd_link_info * info, bfd_vma address)
853 struct elf_link_hash_table *htab = elf_hash_table (info);
855 /* If tls_sec is NULL, we should have signalled an error already. */
856 if (htab->tls_sec == NULL)
858 return address - htab->tls_sec->vma;
861 /* Return the relocation value for @tpoff relocation
862 if STT_TLS virtual address is ADDRESS. */
865 tpoff (struct bfd_link_info * info, bfd_vma address)
867 struct elf_link_hash_table *htab = elf_hash_table (info);
869 /* If tls_sec is NULL, we should have signalled an error already. */
870 if (htab->tls_sec == NULL)
872 return address - (htab->tls_size + htab->tls_sec->vma);
875 /* Returns nonzero if there's a R_MN10300_PLT32 reloc that we now need
876 to skip, after this one. The actual value is the offset between
877 this reloc and the PLT reloc. */
880 mn10300_do_tls_transition (bfd * input_bfd,
882 unsigned int tls_r_type,
886 bfd_byte *op = contents + offset;
889 #define TLS_PAIR(r1,r2) ((r1) * R_MN10300_MAX + (r2))
891 /* This is common to all GD/LD transitions, so break it out. */
892 if (r_type == R_MN10300_TLS_GD
893 || r_type == R_MN10300_TLS_LD)
897 BFD_ASSERT (bfd_get_8 (input_bfd, op) == 0xFC);
898 BFD_ASSERT (bfd_get_8 (input_bfd, op + 1) == 0xCC);
900 BFD_ASSERT (bfd_get_8 (input_bfd, op + 6) == 0xF1);
901 gotreg = (bfd_get_8 (input_bfd, op + 7) & 0x0c) >> 2;
903 BFD_ASSERT (bfd_get_8 (input_bfd, op + 8) == 0xDD);
906 switch (TLS_PAIR (r_type, tls_r_type))
908 case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_GOTIE):
910 /* Keep track of which register we put GOTptr in. */
911 /* mov (_x@indntpoff,a2),a0. */
912 memcpy (op, "\xFC\x20\x00\x00\x00\x00", 6);
915 memcpy (op+6, "\xF9\x78\x28", 3);
916 /* or 0x00000000, d0 - six byte nop. */
917 memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6);
921 case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_LE):
923 /* Register is *always* a0. */
924 /* mov _x@tpoff,a0. */
925 memcpy (op, "\xFC\xDC\x00\x00\x00\x00", 6);
927 memcpy (op+6, "\xF9\x78\x28", 3);
928 /* or 0x00000000, d0 - six byte nop. */
929 memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6);
932 case TLS_PAIR (R_MN10300_TLS_LD, R_MN10300_NONE):
934 /* Register is *always* a0. */
936 memcpy (op, "\xF5\x88", 2);
937 /* or 0x00000000, d0 - six byte nop. */
938 memcpy (op+2, "\xFC\xE4\x00\x00\x00\x00", 6);
939 /* or 0x00000000, e2 - seven byte nop. */
940 memcpy (op+8, "\xFE\x19\x22\x00\x00\x00\x00", 7);
944 case TLS_PAIR (R_MN10300_TLS_LDO, R_MN10300_TLS_LE):
945 /* No changes needed, just the reloc change. */
948 /* These are a little tricky, because we have to detect which
949 opcode is being used (they're different sizes, with the reloc
950 at different offsets within the opcode) and convert each
951 accordingly, copying the operands as needed. The conversions
952 we do are as follows (IE,GOTIE,LE):
954 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn
955 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn
956 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn
958 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An
959 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An
960 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An
962 1111 1110 0000 1110 Rnnn Xxxx [-- abs32 --] MOV (x@indntpoff),Rn
963 1111 1110 0000 1010 Rnnn Rmmm [-- abs32 --] MOV (x@indntpoff,Rm),Rn
964 1111 1110 0000 1000 Rnnn Xxxx [-- abs32 --] MOV x@tpoff,Rn
966 Since the GOT pointer is always $a2, we assume the last
967 normally won't happen, but let's be paranoid and plan for the
968 day that GCC optimizes it somewhow. */
970 case TLS_PAIR (R_MN10300_TLS_IE, R_MN10300_TLS_LE):
974 if ((op[1] & 0xFC) == 0xA4) /* Dn */
976 op[1] &= 0x03; /* Leaves Dn. */
981 op[1] &= 0x03; /* Leaves An. */
985 else if (op[-3] == 0xFE)
991 case TLS_PAIR (R_MN10300_TLS_GOTIE, R_MN10300_TLS_LE):
995 if ((op[1] & 0xF0) == 0x00) /* Dn */
997 op[1] &= 0x0C; /* Leaves Dn. */
1003 op[1] &= 0x0C; /* Leaves An. */
1008 else if (op[-3] == 0xFE)
1015 (*_bfd_error_handler)
1016 (_("%s: Unsupported transition from %s to %s"),
1017 bfd_get_filename (input_bfd),
1018 elf_mn10300_howto_table[r_type].name,
1019 elf_mn10300_howto_table[tls_r_type].name);
1026 /* Look through the relocs for a section during the first phase.
1027 Since we don't do .gots or .plts, we just need to consider the
1028 virtual table relocs for gc. */
1031 mn10300_elf_check_relocs (bfd *abfd,
1032 struct bfd_link_info *info,
1034 const Elf_Internal_Rela *relocs)
1036 struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
1037 bfd_boolean sym_diff_reloc_seen;
1038 Elf_Internal_Shdr *symtab_hdr;
1039 Elf_Internal_Sym * isymbuf = NULL;
1040 struct elf_link_hash_entry **sym_hashes;
1041 const Elf_Internal_Rela *rel;
1042 const Elf_Internal_Rela *rel_end;
1044 bfd_vma * local_got_offsets;
1048 bfd_boolean result = FALSE;
1054 if (info->relocatable)
1057 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1058 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1059 sym_hashes = elf_sym_hashes (abfd);
1061 dynobj = elf_hash_table (info)->dynobj;
1062 local_got_offsets = elf_local_got_offsets (abfd);
1063 rel_end = relocs + sec->reloc_count;
1064 sym_diff_reloc_seen = FALSE;
1066 for (rel = relocs; rel < rel_end; rel++)
1068 struct elf_link_hash_entry *h;
1069 unsigned long r_symndx;
1070 unsigned int r_type;
1071 int tls_type = GOT_NORMAL;
1073 r_symndx = ELF32_R_SYM (rel->r_info);
1074 if (r_symndx < symtab_hdr->sh_info)
1078 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1079 while (h->root.type == bfd_link_hash_indirect
1080 || h->root.type == bfd_link_hash_warning)
1081 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1084 r_type = ELF32_R_TYPE (rel->r_info);
1085 r_type = elf_mn10300_tls_transition (info, r_type, h, sec, TRUE);
1087 /* Some relocs require a global offset table. */
1092 case R_MN10300_GOT32:
1093 case R_MN10300_GOT24:
1094 case R_MN10300_GOT16:
1095 case R_MN10300_GOTOFF32:
1096 case R_MN10300_GOTOFF24:
1097 case R_MN10300_GOTOFF16:
1098 case R_MN10300_GOTPC32:
1099 case R_MN10300_GOTPC16:
1100 case R_MN10300_TLS_GD:
1101 case R_MN10300_TLS_LD:
1102 case R_MN10300_TLS_GOTIE:
1103 case R_MN10300_TLS_IE:
1104 elf_hash_table (info)->dynobj = dynobj = abfd;
1105 if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
1116 /* This relocation describes the C++ object vtable hierarchy.
1117 Reconstruct it for later use during GC. */
1118 case R_MN10300_GNU_VTINHERIT:
1119 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1123 /* This relocation describes which C++ vtable entries are actually
1124 used. Record for later use during GC. */
1125 case R_MN10300_GNU_VTENTRY:
1126 BFD_ASSERT (h != NULL);
1128 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1132 case R_MN10300_TLS_LD:
1133 htab->tls_ldm_got.refcount ++;
1134 tls_type = GOT_TLS_LD;
1136 if (htab->tls_ldm_got.got_allocated)
1140 case R_MN10300_TLS_IE:
1141 case R_MN10300_TLS_GOTIE:
1143 info->flags |= DF_STATIC_TLS;
1146 case R_MN10300_TLS_GD:
1147 case R_MN10300_GOT32:
1148 case R_MN10300_GOT24:
1149 case R_MN10300_GOT16:
1151 /* This symbol requires a global offset table entry. */
1155 case R_MN10300_TLS_IE:
1156 case R_MN10300_TLS_GOTIE: tls_type = GOT_TLS_IE; break;
1157 case R_MN10300_TLS_GD: tls_type = GOT_TLS_GD; break;
1158 default: tls_type = GOT_NORMAL; break;
1163 sgot = bfd_get_section_by_name (dynobj, ".got");
1164 BFD_ASSERT (sgot != NULL);
1168 && (h != NULL || info->shared))
1170 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1171 if (srelgot == NULL)
1173 srelgot = bfd_make_section_with_flags (dynobj,
1179 | SEC_LINKER_CREATED
1182 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
1187 if (r_type == R_MN10300_TLS_LD)
1189 htab->tls_ldm_got.offset = sgot->size;
1190 htab->tls_ldm_got.got_allocated ++;
1194 if (elf_mn10300_hash_entry (h)->tls_type != tls_type
1195 && elf_mn10300_hash_entry (h)->tls_type != GOT_UNKNOWN)
1197 if (tls_type == GOT_TLS_IE
1198 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_GD)
1199 /* No change - this is ok. */;
1200 else if (tls_type == GOT_TLS_GD
1201 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
1202 /* Transition GD->IE. */
1203 tls_type = GOT_TLS_IE;
1205 (*_bfd_error_handler)
1206 (_("%B: %s' accessed both as normal and thread local symbol"),
1207 abfd, h ? h->root.root.string : "<local>");
1210 elf_mn10300_hash_entry (h)->tls_type = tls_type;
1212 if (h->got.offset != (bfd_vma) -1)
1213 /* We have already allocated space in the .got. */
1216 h->got.offset = sgot->size;
1218 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1219 /* Make sure this symbol is output as a dynamic symbol. */
1220 && h->dynindx == -1)
1222 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1226 srelgot->size += sizeof (Elf32_External_Rela);
1227 if (r_type == R_MN10300_TLS_GD)
1228 srelgot->size += sizeof (Elf32_External_Rela);
1232 /* This is a global offset table entry for a local
1234 if (local_got_offsets == NULL)
1239 size = symtab_hdr->sh_info * (sizeof (bfd_vma) + sizeof (char));
1240 local_got_offsets = bfd_alloc (abfd, size);
1242 if (local_got_offsets == NULL)
1245 elf_local_got_offsets (abfd) = local_got_offsets;
1246 elf_mn10300_local_got_tls_type (abfd)
1247 = (char *) (local_got_offsets + symtab_hdr->sh_info);
1249 for (i = 0; i < symtab_hdr->sh_info; i++)
1250 local_got_offsets[i] = (bfd_vma) -1;
1253 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
1254 /* We have already allocated space in the .got. */
1257 local_got_offsets[r_symndx] = sgot->size;
1261 /* If we are generating a shared object, we need to
1262 output a R_MN10300_RELATIVE reloc so that the dynamic
1263 linker can adjust this GOT entry. */
1264 srelgot->size += sizeof (Elf32_External_Rela);
1266 if (r_type == R_MN10300_TLS_GD)
1267 /* And a R_MN10300_TLS_DTPOFF reloc as well. */
1268 srelgot->size += sizeof (Elf32_External_Rela);
1271 elf_mn10300_local_got_tls_type (abfd) [r_symndx] = tls_type;
1275 if (r_type == R_MN10300_TLS_GD
1276 || r_type == R_MN10300_TLS_LD)
1279 goto need_shared_relocs;
1281 case R_MN10300_PLT32:
1282 case R_MN10300_PLT16:
1283 /* This symbol requires a procedure linkage table entry. We
1284 actually build the entry in adjust_dynamic_symbol,
1285 because this might be a case of linking PIC code which is
1286 never referenced by a dynamic object, in which case we
1287 don't need to generate a procedure linkage table entry
1290 /* If this is a local symbol, we resolve it directly without
1291 creating a procedure linkage table entry. */
1295 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1296 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1305 case R_MN10300_PCREL32:
1306 case R_MN10300_PCREL16:
1307 case R_MN10300_PCREL8:
1312 case R_MN10300_SYM_DIFF:
1313 sym_diff_reloc_seen = TRUE;
1321 /* If we are creating a shared library, then we
1322 need to copy the reloc into the shared library. */
1324 && (sec->flags & SEC_ALLOC) != 0
1325 /* Do not generate a dynamic reloc for a
1326 reloc associated with a SYM_DIFF operation. */
1327 && ! sym_diff_reloc_seen)
1329 asection * sym_section = NULL;
1331 /* Find the section containing the
1332 symbol involved in the relocation. */
1335 Elf_Internal_Sym * isym;
1337 if (isymbuf == NULL)
1338 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1339 symtab_hdr->sh_info, 0,
1343 isym = isymbuf + r_symndx;
1344 /* All we care about is whether this local symbol is absolute. */
1345 if (isym->st_shndx == SHN_ABS)
1346 sym_section = bfd_abs_section_ptr;
1351 if (h->root.type == bfd_link_hash_defined
1352 || h->root.type == bfd_link_hash_defweak)
1353 sym_section = h->root.u.def.section;
1356 /* If the symbol is absolute then the relocation can
1357 be resolved during linking and there is no need for
1359 if (sym_section != bfd_abs_section_ptr)
1361 /* When creating a shared object, we must copy these
1362 reloc types into the output file. We create a reloc
1363 section in dynobj and make room for this reloc. */
1366 sreloc = _bfd_elf_make_dynamic_reloc_section
1367 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
1372 sreloc->size += sizeof (Elf32_External_Rela);
1379 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
1380 sym_diff_reloc_seen = FALSE;
1385 if (isymbuf != NULL)
1391 /* Return the section that should be marked against GC for a given
1395 mn10300_elf_gc_mark_hook (asection *sec,
1396 struct bfd_link_info *info,
1397 Elf_Internal_Rela *rel,
1398 struct elf_link_hash_entry *h,
1399 Elf_Internal_Sym *sym)
1402 switch (ELF32_R_TYPE (rel->r_info))
1404 case R_MN10300_GNU_VTINHERIT:
1405 case R_MN10300_GNU_VTENTRY:
1409 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1412 /* Perform a relocation as part of a final link. */
1414 static bfd_reloc_status_type
1415 mn10300_elf_final_link_relocate (reloc_howto_type *howto,
1417 bfd *output_bfd ATTRIBUTE_UNUSED,
1418 asection *input_section,
1423 struct elf_link_hash_entry * h,
1424 unsigned long symndx,
1425 struct bfd_link_info *info,
1426 asection *sym_sec ATTRIBUTE_UNUSED,
1427 int is_local ATTRIBUTE_UNUSED)
1429 struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
1430 static asection * sym_diff_section;
1431 static bfd_vma sym_diff_value;
1432 bfd_boolean is_sym_diff_reloc;
1433 unsigned long r_type = howto->type;
1434 bfd_byte * hit_data = contents + offset;
1440 dynobj = elf_hash_table (info)->dynobj;
1450 case R_MN10300_PCREL8:
1451 case R_MN10300_PCREL16:
1452 case R_MN10300_PCREL32:
1453 case R_MN10300_GOTOFF32:
1454 case R_MN10300_GOTOFF24:
1455 case R_MN10300_GOTOFF16:
1457 && (input_section->flags & SEC_ALLOC) != 0
1459 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1460 return bfd_reloc_dangerous;
1461 case R_MN10300_GOT32:
1463 Taking the address of a protected function in a shared library
1464 is illegal. Issue an error message here. */
1466 && (input_section->flags & SEC_ALLOC) != 0
1468 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED
1469 && (h->type == STT_FUNC || h->type == STT_GNU_IFUNC)
1470 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1471 return bfd_reloc_dangerous;
1474 is_sym_diff_reloc = FALSE;
1475 if (sym_diff_section != NULL)
1477 BFD_ASSERT (sym_diff_section == input_section);
1485 value -= sym_diff_value;
1486 /* If we are computing a 32-bit value for the location lists
1487 and the result is 0 then we add one to the value. A zero
1488 value can result because of linker relaxation deleteing
1489 prologue instructions and using a value of 1 (for the begin
1490 and end offsets in the location list entry) results in a
1491 nul entry which does not prevent the following entries from
1493 if (r_type == R_MN10300_32
1495 && strcmp (input_section->name, ".debug_loc") == 0)
1497 sym_diff_section = NULL;
1498 is_sym_diff_reloc = TRUE;
1502 sym_diff_section = NULL;
1509 case R_MN10300_SYM_DIFF:
1510 BFD_ASSERT (addend == 0);
1511 /* Cache the input section and value.
1512 The offset is unreliable, since relaxation may
1513 have reduced the following reloc's offset. */
1514 sym_diff_section = input_section;
1515 sym_diff_value = value;
1516 return bfd_reloc_ok;
1518 case R_MN10300_ALIGN:
1519 case R_MN10300_NONE:
1520 return bfd_reloc_ok;
1524 /* Do not generate relocs when an R_MN10300_32 has been used
1525 with an R_MN10300_SYM_DIFF to compute a difference of two
1527 && is_sym_diff_reloc == FALSE
1528 /* Also, do not generate a reloc when the symbol associated
1529 with the R_MN10300_32 reloc is absolute - there is no
1530 need for a run time computation in this case. */
1531 && sym_sec != bfd_abs_section_ptr
1532 /* If the section is not going to be allocated at load time
1533 then there is no need to generate relocs for it. */
1534 && (input_section->flags & SEC_ALLOC) != 0)
1536 Elf_Internal_Rela outrel;
1537 bfd_boolean skip, relocate;
1539 /* When generating a shared object, these relocations are
1540 copied into the output file to be resolved at run
1544 sreloc = _bfd_elf_get_dynamic_reloc_section
1545 (input_bfd, input_section, /*rela?*/ TRUE);
1552 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1553 input_section, offset);
1554 if (outrel.r_offset == (bfd_vma) -1)
1557 outrel.r_offset += (input_section->output_section->vma
1558 + input_section->output_offset);
1562 memset (&outrel, 0, sizeof outrel);
1567 /* h->dynindx may be -1 if this symbol was marked to
1570 || SYMBOL_REFERENCES_LOCAL (info, h))
1573 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1574 outrel.r_addend = value + addend;
1578 BFD_ASSERT (h->dynindx != -1);
1580 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1581 outrel.r_addend = value + addend;
1585 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1586 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1587 + sreloc->reloc_count));
1588 ++sreloc->reloc_count;
1590 /* If this reloc is against an external symbol, we do
1591 not want to fiddle with the addend. Otherwise, we
1592 need to include the symbol value so that it becomes
1593 an addend for the dynamic reloc. */
1595 return bfd_reloc_ok;
1598 bfd_put_32 (input_bfd, value, hit_data);
1599 return bfd_reloc_ok;
1604 if ((long) value > 0x7fffff || (long) value < -0x800000)
1605 return bfd_reloc_overflow;
1607 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1608 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1609 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1610 return bfd_reloc_ok;
1615 if ((long) value > 0x7fff || (long) value < -0x8000)
1616 return bfd_reloc_overflow;
1618 bfd_put_16 (input_bfd, value, hit_data);
1619 return bfd_reloc_ok;
1624 if ((long) value > 0x7f || (long) value < -0x80)
1625 return bfd_reloc_overflow;
1627 bfd_put_8 (input_bfd, value, hit_data);
1628 return bfd_reloc_ok;
1630 case R_MN10300_PCREL8:
1631 value -= (input_section->output_section->vma
1632 + input_section->output_offset);
1636 if ((long) value > 0x7f || (long) value < -0x80)
1637 return bfd_reloc_overflow;
1639 bfd_put_8 (input_bfd, value, hit_data);
1640 return bfd_reloc_ok;
1642 case R_MN10300_PCREL16:
1643 value -= (input_section->output_section->vma
1644 + input_section->output_offset);
1648 if ((long) value > 0x7fff || (long) value < -0x8000)
1649 return bfd_reloc_overflow;
1651 bfd_put_16 (input_bfd, value, hit_data);
1652 return bfd_reloc_ok;
1654 case R_MN10300_PCREL32:
1655 value -= (input_section->output_section->vma
1656 + input_section->output_offset);
1660 bfd_put_32 (input_bfd, value, hit_data);
1661 return bfd_reloc_ok;
1663 case R_MN10300_GNU_VTINHERIT:
1664 case R_MN10300_GNU_VTENTRY:
1665 return bfd_reloc_ok;
1667 case R_MN10300_GOTPC32:
1669 return bfd_reloc_dangerous;
1671 /* Use global offset table as symbol value. */
1672 value = bfd_get_section_by_name (dynobj,
1673 ".got")->output_section->vma;
1674 value -= (input_section->output_section->vma
1675 + input_section->output_offset);
1679 bfd_put_32 (input_bfd, value, hit_data);
1680 return bfd_reloc_ok;
1682 case R_MN10300_GOTPC16:
1684 return bfd_reloc_dangerous;
1686 /* Use global offset table as symbol value. */
1687 value = bfd_get_section_by_name (dynobj,
1688 ".got")->output_section->vma;
1689 value -= (input_section->output_section->vma
1690 + input_section->output_offset);
1694 if ((long) value > 0x7fff || (long) value < -0x8000)
1695 return bfd_reloc_overflow;
1697 bfd_put_16 (input_bfd, value, hit_data);
1698 return bfd_reloc_ok;
1700 case R_MN10300_GOTOFF32:
1702 return bfd_reloc_dangerous;
1704 value -= bfd_get_section_by_name (dynobj,
1705 ".got")->output_section->vma;
1708 bfd_put_32 (input_bfd, value, hit_data);
1709 return bfd_reloc_ok;
1711 case R_MN10300_GOTOFF24:
1713 return bfd_reloc_dangerous;
1715 value -= bfd_get_section_by_name (dynobj,
1716 ".got")->output_section->vma;
1719 if ((long) value > 0x7fffff || (long) value < -0x800000)
1720 return bfd_reloc_overflow;
1722 bfd_put_8 (input_bfd, value, hit_data);
1723 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1724 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1725 return bfd_reloc_ok;
1727 case R_MN10300_GOTOFF16:
1729 return bfd_reloc_dangerous;
1731 value -= bfd_get_section_by_name (dynobj,
1732 ".got")->output_section->vma;
1735 if ((long) value > 0x7fff || (long) value < -0x8000)
1736 return bfd_reloc_overflow;
1738 bfd_put_16 (input_bfd, value, hit_data);
1739 return bfd_reloc_ok;
1741 case R_MN10300_PLT32:
1743 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1744 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1745 && h->plt.offset != (bfd_vma) -1)
1748 return bfd_reloc_dangerous;
1750 splt = bfd_get_section_by_name (dynobj, ".plt");
1752 value = (splt->output_section->vma
1753 + splt->output_offset
1754 + h->plt.offset) - value;
1757 value -= (input_section->output_section->vma
1758 + input_section->output_offset);
1762 bfd_put_32 (input_bfd, value, hit_data);
1763 return bfd_reloc_ok;
1765 case R_MN10300_PLT16:
1767 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1768 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1769 && h->plt.offset != (bfd_vma) -1)
1772 return bfd_reloc_dangerous;
1774 splt = bfd_get_section_by_name (dynobj, ".plt");
1776 value = (splt->output_section->vma
1777 + splt->output_offset
1778 + h->plt.offset) - value;
1781 value -= (input_section->output_section->vma
1782 + input_section->output_offset);
1786 if ((long) value > 0x7fff || (long) value < -0x8000)
1787 return bfd_reloc_overflow;
1789 bfd_put_16 (input_bfd, value, hit_data);
1790 return bfd_reloc_ok;
1792 case R_MN10300_TLS_LDO:
1793 value = dtpoff (info, value);
1794 bfd_put_32 (input_bfd, value + addend, hit_data);
1795 return bfd_reloc_ok;
1797 case R_MN10300_TLS_LE:
1798 value = tpoff (info, value);
1799 bfd_put_32 (input_bfd, value + addend, hit_data);
1800 return bfd_reloc_ok;
1802 case R_MN10300_TLS_LD:
1804 return bfd_reloc_dangerous;
1806 sgot = bfd_get_section_by_name (dynobj, ".got");
1808 BFD_ASSERT (sgot != NULL);
1809 value = htab->tls_ldm_got.offset + sgot->output_offset;
1810 bfd_put_32 (input_bfd, value, hit_data);
1812 if (!htab->tls_ldm_got.rel_emitted)
1814 asection * srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1815 Elf_Internal_Rela rel;
1817 BFD_ASSERT (srelgot != NULL);
1818 htab->tls_ldm_got.rel_emitted ++;
1819 rel.r_offset = (sgot->output_section->vma
1820 + sgot->output_offset
1821 + htab->tls_ldm_got.offset);
1822 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset);
1823 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset+4);
1824 rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD);
1826 bfd_elf32_swap_reloca_out (output_bfd, & rel,
1827 (bfd_byte *) ((Elf32_External_Rela *) srelgot->contents
1828 + srelgot->reloc_count));
1829 ++ srelgot->reloc_count;
1832 return bfd_reloc_ok;
1834 case R_MN10300_TLS_GOTIE:
1835 value = tpoff (info, value);
1838 case R_MN10300_TLS_GD:
1839 case R_MN10300_TLS_IE:
1840 case R_MN10300_GOT32:
1841 case R_MN10300_GOT24:
1842 case R_MN10300_GOT16:
1844 return bfd_reloc_dangerous;
1846 sgot = bfd_get_section_by_name (dynobj, ".got");
1848 if (r_type == R_MN10300_TLS_GD)
1849 value = dtpoff (info, value);
1855 off = h->got.offset;
1856 /* Offsets in the GOT are allocated in check_relocs
1857 which is not called for shared libraries... */
1858 if (off == (bfd_vma) -1)
1861 if (sgot->contents != NULL
1862 && (! elf_hash_table (info)->dynamic_sections_created
1863 || SYMBOL_REFERENCES_LOCAL (info, h)))
1864 /* This is actually a static link, or it is a
1865 -Bsymbolic link and the symbol is defined
1866 locally, or the symbol was forced to be local
1867 because of a version file. We must initialize
1868 this entry in the global offset table.
1870 When doing a dynamic link, we create a .rela.got
1871 relocation entry to initialize the value. This
1872 is done in the finish_dynamic_symbol routine. */
1873 bfd_put_32 (output_bfd, value,
1874 sgot->contents + off);
1876 value = sgot->output_offset + off;
1882 off = elf_local_got_offsets (input_bfd)[symndx];
1885 bfd_put_32 (output_bfd, value, sgot->contents + (off & ~ 1));
1888 bfd_put_32 (output_bfd, value, sgot->contents + off);
1893 Elf_Internal_Rela outrel;
1895 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1896 BFD_ASSERT (srelgot != NULL);
1898 outrel.r_offset = (sgot->output_section->vma
1899 + sgot->output_offset
1903 case R_MN10300_TLS_GD:
1904 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPOFF);
1905 outrel.r_offset = (sgot->output_section->vma
1906 + sgot->output_offset
1908 bfd_elf32_swap_reloca_out (output_bfd, & outrel,
1909 (bfd_byte *) (((Elf32_External_Rela *)
1911 + srelgot->reloc_count));
1912 ++ srelgot->reloc_count;
1913 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD);
1915 case R_MN10300_TLS_GOTIE:
1916 case R_MN10300_TLS_IE:
1917 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF);
1920 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1924 outrel.r_addend = value;
1925 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1926 (bfd_byte *) (((Elf32_External_Rela *)
1928 + srelgot->reloc_count));
1929 ++ srelgot->reloc_count;
1930 elf_local_got_offsets (input_bfd)[symndx] |= 1;
1933 value = sgot->output_offset + (off & ~(bfd_vma) 1);
1939 if (r_type == R_MN10300_TLS_IE)
1941 value += sgot->output_section->vma;
1942 bfd_put_32 (input_bfd, value, hit_data);
1943 return bfd_reloc_ok;
1945 else if (r_type == R_MN10300_TLS_GOTIE
1946 || r_type == R_MN10300_TLS_GD
1947 || r_type == R_MN10300_TLS_LD)
1949 bfd_put_32 (input_bfd, value, hit_data);
1950 return bfd_reloc_ok;
1952 else if (r_type == R_MN10300_GOT32)
1954 bfd_put_32 (input_bfd, value, hit_data);
1955 return bfd_reloc_ok;
1957 else if (r_type == R_MN10300_GOT24)
1959 if ((long) value > 0x7fffff || (long) value < -0x800000)
1960 return bfd_reloc_overflow;
1962 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1963 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1964 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1965 return bfd_reloc_ok;
1967 else if (r_type == R_MN10300_GOT16)
1969 if ((long) value > 0x7fff || (long) value < -0x8000)
1970 return bfd_reloc_overflow;
1972 bfd_put_16 (input_bfd, value, hit_data);
1973 return bfd_reloc_ok;
1978 return bfd_reloc_notsupported;
1982 /* Relocate an MN10300 ELF section. */
1985 mn10300_elf_relocate_section (bfd *output_bfd,
1986 struct bfd_link_info *info,
1988 asection *input_section,
1990 Elf_Internal_Rela *relocs,
1991 Elf_Internal_Sym *local_syms,
1992 asection **local_sections)
1994 Elf_Internal_Shdr *symtab_hdr;
1995 struct elf_link_hash_entry **sym_hashes;
1996 Elf_Internal_Rela *rel, *relend;
1997 Elf_Internal_Rela * trel;
1999 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2000 sym_hashes = elf_sym_hashes (input_bfd);
2003 relend = relocs + input_section->reloc_count;
2004 for (; rel < relend; rel++)
2007 reloc_howto_type *howto;
2008 unsigned long r_symndx;
2009 Elf_Internal_Sym *sym;
2011 struct elf32_mn10300_link_hash_entry *h;
2013 bfd_reloc_status_type r;
2015 bfd_boolean unresolved_reloc = FALSE;
2017 struct elf_link_hash_entry * hh;
2020 r_symndx = ELF32_R_SYM (rel->r_info);
2021 r_type = ELF32_R_TYPE (rel->r_info);
2022 howto = elf_mn10300_howto_table + r_type;
2024 /* Just skip the vtable gc relocs. */
2025 if (r_type == R_MN10300_GNU_VTINHERIT
2026 || r_type == R_MN10300_GNU_VTENTRY)
2032 if (r_symndx < symtab_hdr->sh_info)
2036 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2037 r_symndx, symtab_hdr, sym_hashes,
2038 hh, sec, relocation,
2039 unresolved_reloc, warned);
2041 h = elf_mn10300_hash_entry (hh);
2043 tls_r_type = elf_mn10300_tls_transition (info, r_type, hh, input_section, 0);
2044 if (tls_r_type != r_type)
2046 bfd_boolean had_plt;
2048 had_plt = mn10300_do_tls_transition (input_bfd, r_type, tls_r_type,
2049 contents, rel->r_offset);
2050 r_type = tls_r_type;
2051 howto = elf_mn10300_howto_table + r_type;
2054 for (trel = rel+1; trel < relend; trel++)
2055 if ((ELF32_R_TYPE (trel->r_info) == R_MN10300_PLT32
2056 || ELF32_R_TYPE (trel->r_info) == R_MN10300_PCREL32)
2057 && rel->r_offset + had_plt == trel->r_offset)
2058 trel->r_info = ELF32_R_INFO (0, R_MN10300_NONE);
2061 if (r_symndx < symtab_hdr->sh_info)
2063 sym = local_syms + r_symndx;
2064 sec = local_sections[r_symndx];
2065 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2069 if ((h->root.root.type == bfd_link_hash_defined
2070 || h->root.root.type == bfd_link_hash_defweak)
2071 && ( r_type == R_MN10300_GOTPC32
2072 || r_type == R_MN10300_GOTPC16
2073 || (( r_type == R_MN10300_PLT32
2074 || r_type == R_MN10300_PLT16)
2075 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2076 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2077 && h->root.plt.offset != (bfd_vma) -1)
2078 || (( r_type == R_MN10300_GOT32
2079 || r_type == R_MN10300_GOT24
2080 || r_type == R_MN10300_TLS_GD
2081 || r_type == R_MN10300_TLS_LD
2082 || r_type == R_MN10300_TLS_GOTIE
2083 || r_type == R_MN10300_TLS_IE
2084 || r_type == R_MN10300_GOT16)
2085 && elf_hash_table (info)->dynamic_sections_created
2086 && !SYMBOL_REFERENCES_LOCAL (info, hh))
2087 || (r_type == R_MN10300_32
2088 /* _32 relocs in executables force _COPY relocs,
2089 such that the address of the symbol ends up
2091 && !info->executable
2092 && !SYMBOL_REFERENCES_LOCAL (info, hh)
2093 && ((input_section->flags & SEC_ALLOC) != 0
2094 /* DWARF will emit R_MN10300_32 relocations
2095 in its sections against symbols defined
2096 externally in shared libraries. We can't
2097 do anything with them here. */
2098 || ((input_section->flags & SEC_DEBUGGING) != 0
2099 && h->root.def_dynamic)))))
2100 /* In these cases, we don't need the relocation
2101 value. We check specially because in some
2102 obscure cases sec->output_section will be NULL. */
2105 else if (!info->relocatable && unresolved_reloc
2106 && _bfd_elf_section_offset (output_bfd, info, input_section,
2107 rel->r_offset) != (bfd_vma) -1)
2109 (*_bfd_error_handler)
2110 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2113 (long) rel->r_offset,
2115 h->root.root.root.string);
2118 if (sec != NULL && discarded_section (sec))
2119 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2120 rel, 1, relend, howto, 0, contents);
2122 if (info->relocatable)
2125 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
2127 contents, rel->r_offset,
2128 relocation, rel->r_addend,
2129 (struct elf_link_hash_entry *) h,
2131 info, sec, h == NULL);
2133 if (r != bfd_reloc_ok)
2136 const char *msg = NULL;
2139 name = h->root.root.root.string;
2142 name = (bfd_elf_string_from_elf_section
2143 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2144 if (name == NULL || *name == '\0')
2145 name = bfd_section_name (input_bfd, sec);
2150 case bfd_reloc_overflow:
2151 if (! ((*info->callbacks->reloc_overflow)
2152 (info, (h ? &h->root.root : NULL), name,
2153 howto->name, (bfd_vma) 0, input_bfd,
2154 input_section, rel->r_offset)))
2158 case bfd_reloc_undefined:
2159 if (! ((*info->callbacks->undefined_symbol)
2160 (info, name, input_bfd, input_section,
2161 rel->r_offset, TRUE)))
2165 case bfd_reloc_outofrange:
2166 msg = _("internal error: out of range error");
2169 case bfd_reloc_notsupported:
2170 msg = _("internal error: unsupported relocation error");
2173 case bfd_reloc_dangerous:
2174 if (r_type == R_MN10300_PCREL32)
2175 msg = _("error: inappropriate relocation type for shared"
2176 " library (did you forget -fpic?)");
2177 else if (r_type == R_MN10300_GOT32)
2178 msg = _("%B: taking the address of protected function"
2179 " '%s' cannot be done when making a shared library");
2181 msg = _("internal error: suspicious relocation type used"
2182 " in shared library");
2186 msg = _("internal error: unknown error");
2190 _bfd_error_handler (msg, input_bfd, name);
2191 bfd_set_error (bfd_error_bad_value);
2200 /* Finish initializing one hash table entry. */
2203 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
2206 struct elf32_mn10300_link_hash_entry *entry;
2207 struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
2208 unsigned int byte_count = 0;
2210 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
2212 /* If we already know we want to convert "call" to "calls" for calls
2213 to this symbol, then return now. */
2214 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
2217 /* If there are no named calls to this symbol, or there's nothing we
2218 can move from the function itself into the "call" instruction,
2219 then note that all "call" instructions should be converted into
2220 "calls" instructions and return. If a symbol is available for
2221 dynamic symbol resolution (overridable or overriding), avoid
2222 custom calling conventions. */
2223 if (entry->direct_calls == 0
2224 || (entry->stack_size == 0 && entry->movm_args == 0)
2225 || (elf_hash_table (link_info)->dynamic_sections_created
2226 && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
2227 && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
2229 /* Make a note that we should convert "call" instructions to "calls"
2230 instructions for calls to this symbol. */
2231 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2235 /* We may be able to move some instructions from the function itself into
2236 the "call" instruction. Count how many bytes we might be able to
2237 eliminate in the function itself. */
2239 /* A movm instruction is two bytes. */
2240 if (entry->movm_args)
2243 /* Count the insn to allocate stack space too. */
2244 if (entry->stack_size > 0)
2246 if (entry->stack_size <= 128)
2252 /* If using "call" will result in larger code, then turn all
2253 the associated "call" instructions into "calls" instructions. */
2254 if (byte_count < entry->direct_calls)
2255 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2257 /* This routine never fails. */
2261 /* Used to count hash table entries. */
2264 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
2267 int *count = (int *) in_args;
2273 /* Used to enumerate hash table entries into a linear array. */
2276 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
2279 struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
2286 /* Used to sort the array created by the above. */
2289 sort_by_value (const void *va, const void *vb)
2291 struct elf32_mn10300_link_hash_entry *a
2292 = *(struct elf32_mn10300_link_hash_entry **) va;
2293 struct elf32_mn10300_link_hash_entry *b
2294 = *(struct elf32_mn10300_link_hash_entry **) vb;
2296 return a->value - b->value;
2299 /* Compute the stack size and movm arguments for the function
2300 referred to by HASH at address ADDR in section with
2301 contents CONTENTS, store the information in the hash table. */
2304 compute_function_info (bfd *abfd,
2305 struct elf32_mn10300_link_hash_entry *hash,
2307 unsigned char *contents)
2309 unsigned char byte1, byte2;
2310 /* We only care about a very small subset of the possible prologue
2311 sequences here. Basically we look for:
2313 movm [d2,d3,a2,a3],sp (optional)
2314 add <size>,sp (optional, and only for sizes which fit in an unsigned
2317 If we find anything else, we quit. */
2319 /* Look for movm [regs],sp. */
2320 byte1 = bfd_get_8 (abfd, contents + addr);
2321 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2325 hash->movm_args = byte2;
2327 byte1 = bfd_get_8 (abfd, contents + addr);
2328 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2331 /* Now figure out how much stack space will be allocated by the movm
2332 instruction. We need this kept separate from the function's normal
2334 if (hash->movm_args)
2337 if (hash->movm_args & 0x80)
2338 hash->movm_stack_size += 4;
2341 if (hash->movm_args & 0x40)
2342 hash->movm_stack_size += 4;
2345 if (hash->movm_args & 0x20)
2346 hash->movm_stack_size += 4;
2349 if (hash->movm_args & 0x10)
2350 hash->movm_stack_size += 4;
2352 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
2353 if (hash->movm_args & 0x08)
2354 hash->movm_stack_size += 8 * 4;
2356 if (bfd_get_mach (abfd) == bfd_mach_am33
2357 || bfd_get_mach (abfd) == bfd_mach_am33_2)
2359 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
2360 if (hash->movm_args & 0x1)
2361 hash->movm_stack_size += 6 * 4;
2363 /* exreg1 space. e4, e5, e6, e7 */
2364 if (hash->movm_args & 0x2)
2365 hash->movm_stack_size += 4 * 4;
2367 /* exreg0 space. e2, e3 */
2368 if (hash->movm_args & 0x4)
2369 hash->movm_stack_size += 2 * 4;
2373 /* Now look for the two stack adjustment variants. */
2374 if (byte1 == 0xf8 && byte2 == 0xfe)
2376 int temp = bfd_get_8 (abfd, contents + addr + 2);
2377 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2379 hash->stack_size = -temp;
2381 else if (byte1 == 0xfa && byte2 == 0xfe)
2383 int temp = bfd_get_16 (abfd, contents + addr + 2);
2384 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2388 hash->stack_size = temp;
2391 /* If the total stack to be allocated by the call instruction is more
2392 than 255 bytes, then we can't remove the stack adjustment by using
2393 "call" (we might still be able to remove the "movm" instruction. */
2394 if (hash->stack_size + hash->movm_stack_size > 255)
2395 hash->stack_size = 0;
2398 /* Delete some bytes from a section while relaxing. */
2401 mn10300_elf_relax_delete_bytes (bfd *abfd,
2406 Elf_Internal_Shdr *symtab_hdr;
2407 unsigned int sec_shndx;
2409 Elf_Internal_Rela *irel, *irelend;
2410 Elf_Internal_Rela *irelalign;
2412 Elf_Internal_Sym *isym, *isymend;
2413 struct elf_link_hash_entry **sym_hashes;
2414 struct elf_link_hash_entry **end_hashes;
2415 unsigned int symcount;
2417 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2419 contents = elf_section_data (sec)->this_hdr.contents;
2424 irel = elf_section_data (sec)->relocs;
2425 irelend = irel + sec->reloc_count;
2427 if (sec->reloc_count > 0)
2429 /* If there is an align reloc at the end of the section ignore it.
2430 GAS creates these relocs for reasons of its own, and they just
2431 serve to keep the section artifically inflated. */
2432 if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
2435 /* The deletion must stop at the next ALIGN reloc for an aligment
2436 power larger than, or not a multiple of, the number of bytes we
2438 for (; irel < irelend; irel++)
2440 int alignment = 1 << irel->r_addend;
2442 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
2443 && irel->r_offset > addr
2444 && irel->r_offset < toaddr
2445 && (count < alignment
2446 || alignment % count != 0))
2449 toaddr = irel->r_offset;
2455 /* Actually delete the bytes. */
2456 memmove (contents + addr, contents + addr + count,
2457 (size_t) (toaddr - addr - count));
2459 /* Adjust the section's size if we are shrinking it, or else
2460 pad the bytes between the end of the shrunken region and
2461 the start of the next region with NOP codes. */
2462 if (irelalign == NULL)
2465 /* Include symbols at the end of the section, but
2466 not at the end of a sub-region of the section. */
2473 #define NOP_OPCODE 0xcb
2475 for (i = 0; i < count; i ++)
2476 bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
2479 /* Adjust all the relocs. */
2480 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2482 /* Get the new reloc address. */
2483 if ((irel->r_offset > addr
2484 && irel->r_offset < toaddr)
2485 || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
2486 && irel->r_offset == toaddr))
2487 irel->r_offset -= count;
2490 /* Adjust the local symbols in the section, reducing their value
2491 by the number of bytes deleted. Note - symbols within the deleted
2492 region are moved to the address of the start of the region, which
2493 actually means that they will address the byte beyond the end of
2494 the region once the deletion has been completed. */
2495 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2496 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2497 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2499 if (isym->st_shndx == sec_shndx
2500 && isym->st_value > addr
2501 && isym->st_value < toaddr)
2503 if (isym->st_value < addr + count)
2504 isym->st_value = addr;
2506 isym->st_value -= count;
2508 /* Adjust the function symbol's size as well. */
2509 else if (isym->st_shndx == sec_shndx
2510 && ELF_ST_TYPE (isym->st_info) == STT_FUNC
2511 && isym->st_value + isym->st_size > addr
2512 && isym->st_value + isym->st_size < toaddr)
2513 isym->st_size -= count;
2516 /* Now adjust the global symbols defined in this section. */
2517 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2518 - symtab_hdr->sh_info);
2519 sym_hashes = elf_sym_hashes (abfd);
2520 end_hashes = sym_hashes + symcount;
2521 for (; sym_hashes < end_hashes; sym_hashes++)
2523 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2525 if ((sym_hash->root.type == bfd_link_hash_defined
2526 || sym_hash->root.type == bfd_link_hash_defweak)
2527 && sym_hash->root.u.def.section == sec
2528 && sym_hash->root.u.def.value > addr
2529 && sym_hash->root.u.def.value < toaddr)
2531 if (sym_hash->root.u.def.value < addr + count)
2532 sym_hash->root.u.def.value = addr;
2534 sym_hash->root.u.def.value -= count;
2536 /* Adjust the function symbol's size as well. */
2537 else if (sym_hash->root.type == bfd_link_hash_defined
2538 && sym_hash->root.u.def.section == sec
2539 && sym_hash->type == STT_FUNC
2540 && sym_hash->root.u.def.value + sym_hash->size > addr
2541 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
2542 sym_hash->size -= count;
2545 /* See if we can move the ALIGN reloc forward.
2546 We have adjusted r_offset for it already. */
2547 if (irelalign != NULL)
2549 bfd_vma alignto, alignaddr;
2551 if ((int) irelalign->r_addend > 0)
2553 /* This is the old address. */
2554 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
2555 /* This is where the align points to now. */
2556 alignaddr = BFD_ALIGN (irelalign->r_offset,
2557 1 << irelalign->r_addend);
2558 if (alignaddr < alignto)
2559 /* Tail recursion. */
2560 return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr,
2561 (int) (alignto - alignaddr));
2568 /* Return TRUE if a symbol exists at the given address, else return
2572 mn10300_elf_symbol_address_p (bfd *abfd,
2574 Elf_Internal_Sym *isym,
2577 Elf_Internal_Shdr *symtab_hdr;
2578 unsigned int sec_shndx;
2579 Elf_Internal_Sym *isymend;
2580 struct elf_link_hash_entry **sym_hashes;
2581 struct elf_link_hash_entry **end_hashes;
2582 unsigned int symcount;
2584 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2586 /* Examine all the symbols. */
2587 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2588 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2589 if (isym->st_shndx == sec_shndx
2590 && isym->st_value == addr)
2593 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2594 - symtab_hdr->sh_info);
2595 sym_hashes = elf_sym_hashes (abfd);
2596 end_hashes = sym_hashes + symcount;
2597 for (; sym_hashes < end_hashes; sym_hashes++)
2599 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2601 if ((sym_hash->root.type == bfd_link_hash_defined
2602 || sym_hash->root.type == bfd_link_hash_defweak)
2603 && sym_hash->root.u.def.section == sec
2604 && sym_hash->root.u.def.value == addr)
2611 /* This function handles relaxing for the mn10300.
2613 There are quite a few relaxing opportunities available on the mn10300:
2615 * calls:32 -> calls:16 2 bytes
2616 * call:32 -> call:16 2 bytes
2618 * call:32 -> calls:32 1 byte
2619 * call:16 -> calls:16 1 byte
2620 * These are done anytime using "calls" would result
2621 in smaller code, or when necessary to preserve the
2622 meaning of the program.
2626 * In some circumstances we can move instructions
2627 from a function prologue into a "call" instruction.
2628 This is only done if the resulting code is no larger
2629 than the original code.
2631 * jmp:32 -> jmp:16 2 bytes
2632 * jmp:16 -> bra:8 1 byte
2634 * If the previous instruction is a conditional branch
2635 around the jump/bra, we may be able to reverse its condition
2636 and change its target to the jump's target. The jump/bra
2637 can then be deleted. 2 bytes
2639 * mov abs32 -> mov abs16 1 or 2 bytes
2641 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
2642 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
2644 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
2645 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
2647 We don't handle imm16->imm8 or d16->d8 as they're very rare
2648 and somewhat more difficult to support. */
2651 mn10300_elf_relax_section (bfd *abfd,
2653 struct bfd_link_info *link_info,
2656 Elf_Internal_Shdr *symtab_hdr;
2657 Elf_Internal_Rela *internal_relocs = NULL;
2658 Elf_Internal_Rela *irel, *irelend;
2659 bfd_byte *contents = NULL;
2660 Elf_Internal_Sym *isymbuf = NULL;
2661 struct elf32_mn10300_link_hash_table *hash_table;
2662 asection *section = sec;
2663 bfd_vma align_gap_adjustment;
2665 if (link_info->relocatable)
2666 (*link_info->callbacks->einfo)
2667 (_("%P%F: --relax and -r may not be used together\n"));
2669 /* Assume nothing changes. */
2672 /* We need a pointer to the mn10300 specific hash table. */
2673 hash_table = elf32_mn10300_hash_table (link_info);
2674 if (hash_table == NULL)
2677 /* Initialize fields in each hash table entry the first time through. */
2678 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2682 /* Iterate over all the input bfds. */
2683 for (input_bfd = link_info->input_bfds;
2685 input_bfd = input_bfd->link_next)
2687 /* We're going to need all the symbols for each bfd. */
2688 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2689 if (symtab_hdr->sh_info != 0)
2691 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2692 if (isymbuf == NULL)
2693 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2694 symtab_hdr->sh_info, 0,
2696 if (isymbuf == NULL)
2700 /* Iterate over each section in this bfd. */
2701 for (section = input_bfd->sections;
2703 section = section->next)
2705 struct elf32_mn10300_link_hash_entry *hash;
2706 asection *sym_sec = NULL;
2707 const char *sym_name;
2710 /* If there's nothing to do in this section, skip it. */
2711 if (! ((section->flags & SEC_RELOC) != 0
2712 && section->reloc_count != 0))
2714 if ((section->flags & SEC_ALLOC) == 0)
2717 /* Get cached copy of section contents if it exists. */
2718 if (elf_section_data (section)->this_hdr.contents != NULL)
2719 contents = elf_section_data (section)->this_hdr.contents;
2720 else if (section->size != 0)
2722 /* Go get them off disk. */
2723 if (!bfd_malloc_and_get_section (input_bfd, section,
2730 /* If there aren't any relocs, then there's nothing to do. */
2731 if ((section->flags & SEC_RELOC) != 0
2732 && section->reloc_count != 0)
2734 /* Get a copy of the native relocations. */
2735 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2737 link_info->keep_memory);
2738 if (internal_relocs == NULL)
2741 /* Now examine each relocation. */
2742 irel = internal_relocs;
2743 irelend = irel + section->reloc_count;
2744 for (; irel < irelend; irel++)
2747 unsigned long r_index;
2750 r_type = ELF32_R_TYPE (irel->r_info);
2751 r_index = ELF32_R_SYM (irel->r_info);
2753 if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2756 /* We need the name and hash table entry of the target
2761 if (r_index < symtab_hdr->sh_info)
2763 /* A local symbol. */
2764 Elf_Internal_Sym *isym;
2765 struct elf_link_hash_table *elftab;
2768 isym = isymbuf + r_index;
2769 if (isym->st_shndx == SHN_UNDEF)
2770 sym_sec = bfd_und_section_ptr;
2771 else if (isym->st_shndx == SHN_ABS)
2772 sym_sec = bfd_abs_section_ptr;
2773 else if (isym->st_shndx == SHN_COMMON)
2774 sym_sec = bfd_com_section_ptr;
2777 = bfd_section_from_elf_index (input_bfd,
2781 = bfd_elf_string_from_elf_section (input_bfd,
2786 /* If it isn't a function, then we don't care
2788 if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2791 /* Tack on an ID so we can uniquely identify this
2792 local symbol in the global hash table. */
2793 amt = strlen (sym_name) + 10;
2794 new_name = bfd_malloc (amt);
2795 if (new_name == NULL)
2798 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2799 sym_name = new_name;
2801 elftab = &hash_table->static_hash_table->root;
2802 hash = ((struct elf32_mn10300_link_hash_entry *)
2803 elf_link_hash_lookup (elftab, sym_name,
2804 TRUE, TRUE, FALSE));
2809 r_index -= symtab_hdr->sh_info;
2810 hash = (struct elf32_mn10300_link_hash_entry *)
2811 elf_sym_hashes (input_bfd)[r_index];
2814 sym_name = hash->root.root.root.string;
2815 if ((section->flags & SEC_CODE) != 0)
2817 /* If this is not a "call" instruction, then we
2818 should convert "call" instructions to "calls"
2820 code = bfd_get_8 (input_bfd,
2821 contents + irel->r_offset - 1);
2822 if (code != 0xdd && code != 0xcd)
2823 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2826 /* If this is a jump/call, then bump the
2827 direct_calls counter. Else force "call" to
2828 "calls" conversions. */
2829 if (r_type == R_MN10300_PCREL32
2830 || r_type == R_MN10300_PLT32
2831 || r_type == R_MN10300_PLT16
2832 || r_type == R_MN10300_PCREL16)
2833 hash->direct_calls++;
2835 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2839 /* Now look at the actual contents to get the stack size,
2840 and a list of what registers were saved in the prologue
2842 if ((section->flags & SEC_CODE) != 0)
2844 Elf_Internal_Sym *isym, *isymend;
2845 unsigned int sec_shndx;
2846 struct elf_link_hash_entry **hashes;
2847 struct elf_link_hash_entry **end_hashes;
2848 unsigned int symcount;
2850 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2853 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2854 - symtab_hdr->sh_info);
2855 hashes = elf_sym_hashes (input_bfd);
2856 end_hashes = hashes + symcount;
2858 /* Look at each function defined in this section and
2859 update info for that function. */
2860 isymend = isymbuf + symtab_hdr->sh_info;
2861 for (isym = isymbuf; isym < isymend; isym++)
2863 if (isym->st_shndx == sec_shndx
2864 && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2866 struct elf_link_hash_table *elftab;
2868 struct elf_link_hash_entry **lhashes = hashes;
2870 /* Skip a local symbol if it aliases a
2872 for (; lhashes < end_hashes; lhashes++)
2874 hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2875 if ((hash->root.root.type == bfd_link_hash_defined
2876 || hash->root.root.type == bfd_link_hash_defweak)
2877 && hash->root.root.u.def.section == section
2878 && hash->root.type == STT_FUNC
2879 && hash->root.root.u.def.value == isym->st_value)
2882 if (lhashes != end_hashes)
2885 if (isym->st_shndx == SHN_UNDEF)
2886 sym_sec = bfd_und_section_ptr;
2887 else if (isym->st_shndx == SHN_ABS)
2888 sym_sec = bfd_abs_section_ptr;
2889 else if (isym->st_shndx == SHN_COMMON)
2890 sym_sec = bfd_com_section_ptr;
2893 = bfd_section_from_elf_index (input_bfd,
2896 sym_name = (bfd_elf_string_from_elf_section
2897 (input_bfd, symtab_hdr->sh_link,
2900 /* Tack on an ID so we can uniquely identify this
2901 local symbol in the global hash table. */
2902 amt = strlen (sym_name) + 10;
2903 new_name = bfd_malloc (amt);
2904 if (new_name == NULL)
2907 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2908 sym_name = new_name;
2910 elftab = &hash_table->static_hash_table->root;
2911 hash = ((struct elf32_mn10300_link_hash_entry *)
2912 elf_link_hash_lookup (elftab, sym_name,
2913 TRUE, TRUE, FALSE));
2915 compute_function_info (input_bfd, hash,
2916 isym->st_value, contents);
2917 hash->value = isym->st_value;
2921 for (; hashes < end_hashes; hashes++)
2923 hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2924 if ((hash->root.root.type == bfd_link_hash_defined
2925 || hash->root.root.type == bfd_link_hash_defweak)
2926 && hash->root.root.u.def.section == section
2927 && hash->root.type == STT_FUNC)
2928 compute_function_info (input_bfd, hash,
2929 (hash)->root.root.u.def.value,
2934 /* Cache or free any memory we allocated for the relocs. */
2935 if (internal_relocs != NULL
2936 && elf_section_data (section)->relocs != internal_relocs)
2937 free (internal_relocs);
2938 internal_relocs = NULL;
2940 /* Cache or free any memory we allocated for the contents. */
2941 if (contents != NULL
2942 && elf_section_data (section)->this_hdr.contents != contents)
2944 if (! link_info->keep_memory)
2948 /* Cache the section contents for elf_link_input_bfd. */
2949 elf_section_data (section)->this_hdr.contents = contents;
2955 /* Cache or free any memory we allocated for the symbols. */
2957 && symtab_hdr->contents != (unsigned char *) isymbuf)
2959 if (! link_info->keep_memory)
2963 /* Cache the symbols for elf_link_input_bfd. */
2964 symtab_hdr->contents = (unsigned char *) isymbuf;
2970 /* Now iterate on each symbol in the hash table and perform
2971 the final initialization steps on each. */
2972 elf32_mn10300_link_hash_traverse (hash_table,
2973 elf32_mn10300_finish_hash_table_entry,
2975 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2976 elf32_mn10300_finish_hash_table_entry,
2980 /* This section of code collects all our local symbols, sorts
2981 them by value, and looks for multiple symbols referring to
2982 the same address. For those symbols, the flags are merged.
2983 At this point, the only flag that can be set is
2984 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2986 int static_count = 0, i;
2987 struct elf32_mn10300_link_hash_entry **entries;
2988 struct elf32_mn10300_link_hash_entry **ptr;
2990 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2991 elf32_mn10300_count_hash_table_entries,
2994 entries = bfd_malloc (static_count * sizeof (* ptr));
2997 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2998 elf32_mn10300_list_hash_table_entries,
3001 qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
3003 for (i = 0; i < static_count - 1; i++)
3004 if (entries[i]->value && entries[i]->value == entries[i+1]->value)
3006 int v = entries[i]->flags;
3009 for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
3010 v |= entries[j]->flags;
3012 for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
3013 entries[j]->flags = v;
3019 /* All entries in the hash table are fully initialized. */
3020 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
3022 /* Now that everything has been initialized, go through each
3023 code section and delete any prologue insns which will be
3024 redundant because their operations will be performed by
3025 a "call" instruction. */
3026 for (input_bfd = link_info->input_bfds;
3028 input_bfd = input_bfd->link_next)
3030 /* We're going to need all the local symbols for each bfd. */
3031 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3032 if (symtab_hdr->sh_info != 0)
3034 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3035 if (isymbuf == NULL)
3036 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3037 symtab_hdr->sh_info, 0,
3039 if (isymbuf == NULL)
3043 /* Walk over each section in this bfd. */
3044 for (section = input_bfd->sections;
3046 section = section->next)
3048 unsigned int sec_shndx;
3049 Elf_Internal_Sym *isym, *isymend;
3050 struct elf_link_hash_entry **hashes;
3051 struct elf_link_hash_entry **end_hashes;
3052 unsigned int symcount;
3054 /* Skip non-code sections and empty sections. */
3055 if ((section->flags & SEC_CODE) == 0 || section->size == 0)
3058 if (section->reloc_count != 0)
3060 /* Get a copy of the native relocations. */
3061 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
3063 link_info->keep_memory);
3064 if (internal_relocs == NULL)
3068 /* Get cached copy of section contents if it exists. */
3069 if (elf_section_data (section)->this_hdr.contents != NULL)
3070 contents = elf_section_data (section)->this_hdr.contents;
3073 /* Go get them off disk. */
3074 if (!bfd_malloc_and_get_section (input_bfd, section,
3079 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
3082 /* Now look for any function in this section which needs
3083 insns deleted from its prologue. */
3084 isymend = isymbuf + symtab_hdr->sh_info;
3085 for (isym = isymbuf; isym < isymend; isym++)
3087 struct elf32_mn10300_link_hash_entry *sym_hash;
3088 asection *sym_sec = NULL;
3089 const char *sym_name;
3091 struct elf_link_hash_table *elftab;
3094 if (isym->st_shndx != sec_shndx)
3097 if (isym->st_shndx == SHN_UNDEF)
3098 sym_sec = bfd_und_section_ptr;
3099 else if (isym->st_shndx == SHN_ABS)
3100 sym_sec = bfd_abs_section_ptr;
3101 else if (isym->st_shndx == SHN_COMMON)
3102 sym_sec = bfd_com_section_ptr;
3105 = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3108 = bfd_elf_string_from_elf_section (input_bfd,
3109 symtab_hdr->sh_link,
3112 /* Tack on an ID so we can uniquely identify this
3113 local symbol in the global hash table. */
3114 amt = strlen (sym_name) + 10;
3115 new_name = bfd_malloc (amt);
3116 if (new_name == NULL)
3118 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
3119 sym_name = new_name;
3121 elftab = & hash_table->static_hash_table->root;
3122 sym_hash = (struct elf32_mn10300_link_hash_entry *)
3123 elf_link_hash_lookup (elftab, sym_name,
3124 FALSE, FALSE, FALSE);
3127 if (sym_hash == NULL)
3130 if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
3131 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
3135 /* Note that we've changed things. */
3136 elf_section_data (section)->relocs = internal_relocs;
3137 elf_section_data (section)->this_hdr.contents = contents;
3138 symtab_hdr->contents = (unsigned char *) isymbuf;
3140 /* Count how many bytes we're going to delete. */
3141 if (sym_hash->movm_args)
3144 if (sym_hash->stack_size > 0)
3146 if (sym_hash->stack_size <= 128)
3152 /* Note that we've deleted prologue bytes for this
3154 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
3156 /* Actually delete the bytes. */
3157 if (!mn10300_elf_relax_delete_bytes (input_bfd,
3163 /* Something changed. Not strictly necessary, but
3164 may lead to more relaxing opportunities. */
3169 /* Look for any global functions in this section which
3170 need insns deleted from their prologues. */
3171 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
3172 - symtab_hdr->sh_info);
3173 hashes = elf_sym_hashes (input_bfd);
3174 end_hashes = hashes + symcount;
3175 for (; hashes < end_hashes; hashes++)
3177 struct elf32_mn10300_link_hash_entry *sym_hash;
3179 sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
3180 if ((sym_hash->root.root.type == bfd_link_hash_defined
3181 || sym_hash->root.root.type == bfd_link_hash_defweak)
3182 && sym_hash->root.root.u.def.section == section
3183 && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
3184 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
3188 struct elf_link_hash_entry **hh;
3190 /* Note that we've changed things. */
3191 elf_section_data (section)->relocs = internal_relocs;
3192 elf_section_data (section)->this_hdr.contents = contents;
3193 symtab_hdr->contents = (unsigned char *) isymbuf;
3195 /* Count how many bytes we're going to delete. */
3196 if (sym_hash->movm_args)
3199 if (sym_hash->stack_size > 0)
3201 if (sym_hash->stack_size <= 128)
3207 /* Note that we've deleted prologue bytes for this
3209 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
3211 /* Actually delete the bytes. */
3212 symval = sym_hash->root.root.u.def.value;
3213 if (!mn10300_elf_relax_delete_bytes (input_bfd,
3219 /* There may be other C++ functions symbols with the same
3220 address. If so then mark these as having had their
3221 prologue bytes deleted as well. */
3222 for (hh = elf_sym_hashes (input_bfd); hh < end_hashes; hh++)
3224 struct elf32_mn10300_link_hash_entry *h;
3226 h = (struct elf32_mn10300_link_hash_entry *) * hh;
3229 && (h->root.root.type == bfd_link_hash_defined
3230 || h->root.root.type == bfd_link_hash_defweak)
3231 && h->root.root.u.def.section == section
3232 && ! (h->flags & MN10300_CONVERT_CALL_TO_CALLS)
3233 && h->root.root.u.def.value == symval
3234 && h->root.type == STT_FUNC)
3235 h->flags |= MN10300_DELETED_PROLOGUE_BYTES;
3238 /* Something changed. Not strictly necessary, but
3239 may lead to more relaxing opportunities. */
3244 /* Cache or free any memory we allocated for the relocs. */
3245 if (internal_relocs != NULL
3246 && elf_section_data (section)->relocs != internal_relocs)
3247 free (internal_relocs);
3248 internal_relocs = NULL;
3250 /* Cache or free any memory we allocated for the contents. */
3251 if (contents != NULL
3252 && elf_section_data (section)->this_hdr.contents != contents)
3254 if (! link_info->keep_memory)
3257 /* Cache the section contents for elf_link_input_bfd. */
3258 elf_section_data (section)->this_hdr.contents = contents;
3263 /* Cache or free any memory we allocated for the symbols. */
3265 && symtab_hdr->contents != (unsigned char *) isymbuf)
3267 if (! link_info->keep_memory)
3270 /* Cache the symbols for elf_link_input_bfd. */
3271 symtab_hdr->contents = (unsigned char *) isymbuf;
3277 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
3279 internal_relocs = NULL;
3281 /* For error_return. */
3284 /* We don't have to do anything for a relocatable link, if
3285 this section does not have relocs, or if this is not a
3287 if (link_info->relocatable
3288 || (sec->flags & SEC_RELOC) == 0
3289 || sec->reloc_count == 0
3290 || (sec->flags & SEC_CODE) == 0)
3293 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3295 /* Get a copy of the native relocations. */
3296 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3297 link_info->keep_memory);
3298 if (internal_relocs == NULL)
3301 /* Scan for worst case alignment gap changes. Note that this logic
3302 is not ideal; what we should do is run this scan for every
3303 opcode/address range and adjust accordingly, but that's
3304 expensive. Worst case is that for an alignment of N bytes, we
3305 move by 2*N-N-1 bytes, assuming we have aligns of 1, 2, 4, 8, etc
3306 all before it. Plus, this still doesn't cover cross-section
3307 jumps with section alignment. */
3308 irelend = internal_relocs + sec->reloc_count;
3309 align_gap_adjustment = 0;
3310 for (irel = internal_relocs; irel < irelend; irel++)
3312 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN)
3314 bfd_vma adj = 1 << irel->r_addend;
3315 bfd_vma aend = irel->r_offset;
3317 aend = BFD_ALIGN (aend, 1 << irel->r_addend);
3318 adj = 2 * adj - adj - 1;
3320 /* Record the biggest adjustmnet. Skip any alignment at the
3321 end of our section. */
3322 if (align_gap_adjustment < adj
3323 && aend < sec->output_section->vma + sec->output_offset + sec->size)
3324 align_gap_adjustment = adj;
3328 /* Walk through them looking for relaxing opportunities. */
3329 irelend = internal_relocs + sec->reloc_count;
3330 for (irel = internal_relocs; irel < irelend; irel++)
3333 bfd_signed_vma jump_offset;
3334 asection *sym_sec = NULL;
3335 struct elf32_mn10300_link_hash_entry *h = NULL;
3337 /* If this isn't something that can be relaxed, then ignore
3339 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
3340 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
3341 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
3344 /* Get the section contents if we haven't done so already. */
3345 if (contents == NULL)
3347 /* Get cached copy if it exists. */
3348 if (elf_section_data (sec)->this_hdr.contents != NULL)
3349 contents = elf_section_data (sec)->this_hdr.contents;
3352 /* Go get them off disk. */
3353 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
3358 /* Read this BFD's symbols if we haven't done so already. */
3359 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
3361 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3362 if (isymbuf == NULL)
3363 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3364 symtab_hdr->sh_info, 0,
3366 if (isymbuf == NULL)
3370 /* Get the value of the symbol referred to by the reloc. */
3371 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
3373 Elf_Internal_Sym *isym;
3374 const char *sym_name;
3377 /* A local symbol. */
3378 isym = isymbuf + ELF32_R_SYM (irel->r_info);
3379 if (isym->st_shndx == SHN_UNDEF)
3380 sym_sec = bfd_und_section_ptr;
3381 else if (isym->st_shndx == SHN_ABS)
3382 sym_sec = bfd_abs_section_ptr;
3383 else if (isym->st_shndx == SHN_COMMON)
3384 sym_sec = bfd_com_section_ptr;
3386 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3388 sym_name = bfd_elf_string_from_elf_section (abfd,
3389 symtab_hdr->sh_link,
3392 if ((sym_sec->flags & SEC_MERGE)
3393 && sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE)
3395 symval = isym->st_value;
3397 /* GAS may reduce relocations against symbols in SEC_MERGE
3398 sections to a relocation against the section symbol when
3399 the original addend was zero. When the reloc is against
3400 a section symbol we should include the addend in the
3401 offset passed to _bfd_merged_section_offset, since the
3402 location of interest is the original symbol. On the
3403 other hand, an access to "sym+addend" where "sym" is not
3404 a section symbol should not include the addend; Such an
3405 access is presumed to be an offset from "sym"; The
3406 location of interest is just "sym". */
3407 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
3408 symval += irel->r_addend;
3410 symval = _bfd_merged_section_offset (abfd, & sym_sec,
3411 elf_section_data (sym_sec)->sec_info,
3414 if (ELF_ST_TYPE (isym->st_info) != STT_SECTION)
3415 symval += irel->r_addend;
3417 symval += sym_sec->output_section->vma
3418 + sym_sec->output_offset - irel->r_addend;
3421 symval = (isym->st_value
3422 + sym_sec->output_section->vma
3423 + sym_sec->output_offset);
3425 /* Tack on an ID so we can uniquely identify this
3426 local symbol in the global hash table. */
3427 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
3428 if (new_name == NULL)
3430 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
3431 sym_name = new_name;
3433 h = (struct elf32_mn10300_link_hash_entry *)
3434 elf_link_hash_lookup (&hash_table->static_hash_table->root,
3435 sym_name, FALSE, FALSE, FALSE);
3442 /* An external symbol. */
3443 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
3444 h = (struct elf32_mn10300_link_hash_entry *)
3445 (elf_sym_hashes (abfd)[indx]);
3446 BFD_ASSERT (h != NULL);
3447 if (h->root.root.type != bfd_link_hash_defined
3448 && h->root.root.type != bfd_link_hash_defweak)
3449 /* This appears to be a reference to an undefined
3450 symbol. Just ignore it--it will be caught by the
3451 regular reloc processing. */
3454 /* Check for a reference to a discarded symbol and ignore it. */
3455 if (h->root.root.u.def.section->output_section == NULL)
3458 sym_sec = h->root.root.u.def.section->output_section;
3460 symval = (h->root.root.u.def.value
3461 + h->root.root.u.def.section->output_section->vma
3462 + h->root.root.u.def.section->output_offset);
3465 /* For simplicity of coding, we are going to modify the section
3466 contents, the section relocs, and the BFD symbol table. We
3467 must tell the rest of the code not to free up this
3468 information. It would be possible to instead create a table
3469 of changes which have to be made, as is done in coff-mips.c;
3470 that would be more work, but would require less memory when
3471 the linker is run. */
3473 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
3474 branch/call, also deal with "call" -> "calls" conversions and
3475 insertion of prologue data into "call" instructions. */
3476 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
3477 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
3479 bfd_vma value = symval;
3481 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
3483 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
3484 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
3485 && h->root.plt.offset != (bfd_vma) -1)
3489 splt = bfd_get_section_by_name (elf_hash_table (link_info)
3492 value = ((splt->output_section->vma
3493 + splt->output_offset
3494 + h->root.plt.offset)
3495 - (sec->output_section->vma
3496 + sec->output_offset
3500 /* If we've got a "call" instruction that needs to be turned
3501 into a "calls" instruction, do so now. It saves a byte. */
3502 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3506 /* Get the opcode. */
3507 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3509 /* Make sure we're working with a "call" instruction! */
3512 /* Note that we've changed the relocs, section contents,
3514 elf_section_data (sec)->relocs = internal_relocs;
3515 elf_section_data (sec)->this_hdr.contents = contents;
3516 symtab_hdr->contents = (unsigned char *) isymbuf;
3518 /* Fix the opcode. */
3519 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
3520 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3522 /* Fix irel->r_offset and irel->r_addend. */
3523 irel->r_offset += 1;
3524 irel->r_addend += 1;
3526 /* Delete one byte of data. */
3527 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3528 irel->r_offset + 3, 1))
3531 /* That will change things, so, we should relax again.
3532 Note that this is not required, and it may be slow. */
3538 /* We've got a "call" instruction which needs some data
3539 from target function filled in. */
3542 /* Get the opcode. */
3543 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3545 /* Insert data from the target function into the "call"
3546 instruction if needed. */
3549 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
3550 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3551 contents + irel->r_offset + 5);
3555 /* Deal with pc-relative gunk. */
3556 value -= (sec->output_section->vma + sec->output_offset);
3557 value -= irel->r_offset;
3558 value += irel->r_addend;
3560 /* See if the value will fit in 16 bits, note the high value is
3561 0x7fff + 2 as the target will be two bytes closer if we are
3562 able to relax, if it's in the same section. */
3563 if (sec->output_section == sym_sec->output_section)
3564 jump_offset = 0x8001;
3566 jump_offset = 0x7fff;
3568 /* Account for jumps across alignment boundaries using
3569 align_gap_adjustment. */
3570 if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
3571 && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
3575 /* Get the opcode. */
3576 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3578 if (code != 0xdc && code != 0xdd && code != 0xff)
3581 /* Note that we've changed the relocs, section contents, etc. */
3582 elf_section_data (sec)->relocs = internal_relocs;
3583 elf_section_data (sec)->this_hdr.contents = contents;
3584 symtab_hdr->contents = (unsigned char *) isymbuf;
3586 /* Fix the opcode. */
3588 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
3589 else if (code == 0xdd)
3590 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
3591 else if (code == 0xff)
3592 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3594 /* Fix the relocation's type. */
3595 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3596 (ELF32_R_TYPE (irel->r_info)
3597 == (int) R_MN10300_PLT32)
3601 /* Delete two bytes of data. */
3602 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3603 irel->r_offset + 1, 2))
3606 /* That will change things, so, we should relax again.
3607 Note that this is not required, and it may be slow. */
3612 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
3614 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
3616 bfd_vma value = symval;
3618 /* If we've got a "call" instruction that needs to be turned
3619 into a "calls" instruction, do so now. It saves a byte. */
3620 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3624 /* Get the opcode. */
3625 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3627 /* Make sure we're working with a "call" instruction! */
3630 /* Note that we've changed the relocs, section contents,
3632 elf_section_data (sec)->relocs = internal_relocs;
3633 elf_section_data (sec)->this_hdr.contents = contents;
3634 symtab_hdr->contents = (unsigned char *) isymbuf;
3636 /* Fix the opcode. */
3637 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3638 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3640 /* Fix irel->r_offset and irel->r_addend. */
3641 irel->r_offset += 1;
3642 irel->r_addend += 1;
3644 /* Delete one byte of data. */
3645 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3646 irel->r_offset + 1, 1))
3649 /* That will change things, so, we should relax again.
3650 Note that this is not required, and it may be slow. */
3658 /* Get the opcode. */
3659 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3661 /* Insert data from the target function into the "call"
3662 instruction if needed. */
3665 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3666 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3667 contents + irel->r_offset + 3);
3671 /* Deal with pc-relative gunk. */
3672 value -= (sec->output_section->vma + sec->output_offset);
3673 value -= irel->r_offset;
3674 value += irel->r_addend;
3676 /* See if the value will fit in 8 bits, note the high value is
3677 0x7f + 1 as the target will be one bytes closer if we are
3679 if ((long) value < 0x80 && (long) value > -0x80)
3683 /* Get the opcode. */
3684 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3689 /* Note that we've changed the relocs, section contents, etc. */
3690 elf_section_data (sec)->relocs = internal_relocs;
3691 elf_section_data (sec)->this_hdr.contents = contents;
3692 symtab_hdr->contents = (unsigned char *) isymbuf;
3694 /* Fix the opcode. */
3695 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3697 /* Fix the relocation's type. */
3698 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3701 /* Delete one byte of data. */
3702 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3703 irel->r_offset + 1, 1))
3706 /* That will change things, so, we should relax again.
3707 Note that this is not required, and it may be slow. */
3712 /* Try to eliminate an unconditional 8 bit pc-relative branch
3713 which immediately follows a conditional 8 bit pc-relative
3714 branch around the unconditional branch.
3721 This happens when the bCC can't reach lab2 at assembly time,
3722 but due to other relaxations it can reach at link time. */
3723 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3725 Elf_Internal_Rela *nrel;
3726 bfd_vma value = symval;
3729 /* Deal with pc-relative gunk. */
3730 value -= (sec->output_section->vma + sec->output_offset);
3731 value -= irel->r_offset;
3732 value += irel->r_addend;
3734 /* Do nothing if this reloc is the last byte in the section. */
3735 if (irel->r_offset == sec->size)
3738 /* See if the next instruction is an unconditional pc-relative
3739 branch, more often than not this test will fail, so we
3740 test it first to speed things up. */
3741 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3745 /* Also make sure the next relocation applies to the next
3746 instruction and that it's a pc-relative 8 bit branch. */
3749 || irel->r_offset + 2 != nrel->r_offset
3750 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3753 /* Make sure our destination immediately follows the
3754 unconditional branch. */
3755 if (symval != (sec->output_section->vma + sec->output_offset
3756 + irel->r_offset + 3))
3759 /* Now make sure we are a conditional branch. This may not
3760 be necessary, but why take the chance.
3762 Note these checks assume that R_MN10300_PCREL8 relocs
3763 only occur on bCC and bCCx insns. If they occured
3764 elsewhere, we'd need to know the start of this insn
3765 for this check to be accurate. */
3766 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3767 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3768 && code != 0xc3 && code != 0xc4 && code != 0xc5
3769 && code != 0xc6 && code != 0xc7 && code != 0xc8
3770 && code != 0xc9 && code != 0xe8 && code != 0xe9
3771 && code != 0xea && code != 0xeb)
3774 /* We also have to be sure there is no symbol/label
3775 at the unconditional branch. */
3776 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3777 irel->r_offset + 1))
3780 /* Note that we've changed the relocs, section contents, etc. */
3781 elf_section_data (sec)->relocs = internal_relocs;
3782 elf_section_data (sec)->this_hdr.contents = contents;
3783 symtab_hdr->contents = (unsigned char *) isymbuf;
3785 /* Reverse the condition of the first branch. */
3831 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3833 /* Set the reloc type and symbol for the first branch
3834 from the second branch. */
3835 irel->r_info = nrel->r_info;
3837 /* Make the reloc for the second branch a null reloc. */
3838 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3841 /* Delete two bytes of data. */
3842 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3843 irel->r_offset + 1, 2))
3846 /* That will change things, so, we should relax again.
3847 Note that this is not required, and it may be slow. */
3851 /* Try to turn a 24 immediate, displacement or absolute address
3852 into a 8 immediate, displacement or absolute address. */
3853 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3855 bfd_vma value = symval;
3856 value += irel->r_addend;
3858 /* See if the value will fit in 8 bits. */
3859 if ((long) value < 0x7f && (long) value > -0x80)
3863 /* AM33 insns which have 24 operands are 6 bytes long and
3864 will have 0xfd as the first byte. */
3866 /* Get the first opcode. */
3867 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3871 /* Get the second opcode. */
3872 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3874 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3875 equivalent instructions exists. */
3876 if (code != 0x6b && code != 0x7b
3877 && code != 0x8b && code != 0x9b
3878 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3879 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3880 || (code & 0x0f) == 0x0e))
3882 /* Not safe if the high bit is on as relaxing may
3883 move the value out of high mem and thus not fit
3884 in a signed 8bit value. This is currently over
3886 if ((value & 0x80) == 0)
3888 /* Note that we've changed the relocation contents,
3890 elf_section_data (sec)->relocs = internal_relocs;
3891 elf_section_data (sec)->this_hdr.contents = contents;
3892 symtab_hdr->contents = (unsigned char *) isymbuf;
3894 /* Fix the opcode. */
3895 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3896 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3898 /* Fix the relocation's type. */
3900 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3903 /* Delete two bytes of data. */
3904 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3905 irel->r_offset + 1, 2))
3908 /* That will change things, so, we should relax
3909 again. Note that this is not required, and it
3919 /* Try to turn a 32bit immediate, displacement or absolute address
3920 into a 16bit immediate, displacement or absolute address. */
3921 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3922 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3923 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3925 bfd_vma value = symval;
3927 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3931 sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3934 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3936 value = sgot->output_offset;
3939 value += h->root.got.offset;
3941 value += (elf_local_got_offsets
3942 (abfd)[ELF32_R_SYM (irel->r_info)]);
3944 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3945 value -= sgot->output_section->vma;
3946 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3947 value = (sgot->output_section->vma
3948 - (sec->output_section->vma
3949 + sec->output_offset
3955 value += irel->r_addend;
3957 /* See if the value will fit in 24 bits.
3958 We allow any 16bit match here. We prune those we can't
3960 if ((long) value < 0x7fffff && (long) value > -0x800000)
3964 /* AM33 insns which have 32bit operands are 7 bytes long and
3965 will have 0xfe as the first byte. */
3967 /* Get the first opcode. */
3968 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3972 /* Get the second opcode. */
3973 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3975 /* All the am33 32 -> 24 relaxing possibilities. */
3976 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3977 equivalent instructions exists. */
3978 if (code != 0x6b && code != 0x7b
3979 && code != 0x8b && code != 0x9b
3980 && (ELF32_R_TYPE (irel->r_info)
3981 != (int) R_MN10300_GOTPC32)
3982 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3983 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3984 || (code & 0x0f) == 0x0e))
3986 /* Not safe if the high bit is on as relaxing may
3987 move the value out of high mem and thus not fit
3988 in a signed 16bit value. This is currently over
3990 if ((value & 0x8000) == 0)
3992 /* Note that we've changed the relocation contents,
3994 elf_section_data (sec)->relocs = internal_relocs;
3995 elf_section_data (sec)->this_hdr.contents = contents;
3996 symtab_hdr->contents = (unsigned char *) isymbuf;
3998 /* Fix the opcode. */
3999 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
4000 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4002 /* Fix the relocation's type. */
4004 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4005 (ELF32_R_TYPE (irel->r_info)
4006 == (int) R_MN10300_GOTOFF32)
4007 ? R_MN10300_GOTOFF24
4008 : (ELF32_R_TYPE (irel->r_info)
4009 == (int) R_MN10300_GOT32)
4013 /* Delete one byte of data. */
4014 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4015 irel->r_offset + 3, 1))
4018 /* That will change things, so, we should relax
4019 again. Note that this is not required, and it
4028 /* See if the value will fit in 16 bits.
4029 We allow any 16bit match here. We prune those we can't
4031 if ((long) value < 0x7fff && (long) value > -0x8000)
4035 /* Most insns which have 32bit operands are 6 bytes long;
4036 exceptions are pcrel insns and bit insns.
4038 We handle pcrel insns above. We don't bother trying
4039 to handle the bit insns here.
4041 The first byte of the remaining insns will be 0xfc. */
4043 /* Get the first opcode. */
4044 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
4049 /* Get the second opcode. */
4050 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
4052 if ((code & 0xf0) < 0x80)
4053 switch (code & 0xf0)
4055 /* mov (d32,am),dn -> mov (d32,am),dn
4056 mov dm,(d32,am) -> mov dn,(d32,am)
4057 mov (d32,am),an -> mov (d32,am),an
4058 mov dm,(d32,am) -> mov dn,(d32,am)
4059 movbu (d32,am),dn -> movbu (d32,am),dn
4060 movbu dm,(d32,am) -> movbu dn,(d32,am)
4061 movhu (d32,am),dn -> movhu (d32,am),dn
4062 movhu dm,(d32,am) -> movhu dn,(d32,am) */
4071 /* Not safe if the high bit is on as relaxing may
4072 move the value out of high mem and thus not fit
4073 in a signed 16bit value. */
4075 && (value & 0x8000))
4078 /* Note that we've changed the relocation contents, etc. */
4079 elf_section_data (sec)->relocs = internal_relocs;
4080 elf_section_data (sec)->this_hdr.contents = contents;
4081 symtab_hdr->contents = (unsigned char *) isymbuf;
4083 /* Fix the opcode. */
4084 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4085 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4087 /* Fix the relocation's type. */
4088 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4089 (ELF32_R_TYPE (irel->r_info)
4090 == (int) R_MN10300_GOTOFF32)
4091 ? R_MN10300_GOTOFF16
4092 : (ELF32_R_TYPE (irel->r_info)
4093 == (int) R_MN10300_GOT32)
4095 : (ELF32_R_TYPE (irel->r_info)
4096 == (int) R_MN10300_GOTPC32)
4097 ? R_MN10300_GOTPC16 :
4100 /* Delete two bytes of data. */
4101 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4102 irel->r_offset + 2, 2))
4105 /* That will change things, so, we should relax again.
4106 Note that this is not required, and it may be slow. */
4110 else if ((code & 0xf0) == 0x80
4111 || (code & 0xf0) == 0x90)
4112 switch (code & 0xf3)
4114 /* mov dn,(abs32) -> mov dn,(abs16)
4115 movbu dn,(abs32) -> movbu dn,(abs16)
4116 movhu dn,(abs32) -> movhu dn,(abs16) */
4120 /* Note that we've changed the relocation contents, etc. */
4121 elf_section_data (sec)->relocs = internal_relocs;
4122 elf_section_data (sec)->this_hdr.contents = contents;
4123 symtab_hdr->contents = (unsigned char *) isymbuf;
4125 if ((code & 0xf3) == 0x81)
4126 code = 0x01 + (code & 0x0c);
4127 else if ((code & 0xf3) == 0x82)
4128 code = 0x02 + (code & 0x0c);
4129 else if ((code & 0xf3) == 0x83)
4130 code = 0x03 + (code & 0x0c);
4134 /* Fix the opcode. */
4135 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4137 /* Fix the relocation's type. */
4138 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4139 (ELF32_R_TYPE (irel->r_info)
4140 == (int) R_MN10300_GOTOFF32)
4141 ? R_MN10300_GOTOFF16
4142 : (ELF32_R_TYPE (irel->r_info)
4143 == (int) R_MN10300_GOT32)
4145 : (ELF32_R_TYPE (irel->r_info)
4146 == (int) R_MN10300_GOTPC32)
4147 ? R_MN10300_GOTPC16 :
4150 /* The opcode got shorter too, so we have to fix the
4151 addend and offset too! */
4152 irel->r_offset -= 1;
4154 /* Delete three bytes of data. */
4155 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4156 irel->r_offset + 1, 3))
4159 /* That will change things, so, we should relax again.
4160 Note that this is not required, and it may be slow. */
4164 /* mov am,(abs32) -> mov am,(abs16)
4165 mov am,(d32,sp) -> mov am,(d16,sp)
4166 mov dm,(d32,sp) -> mov dm,(d32,sp)
4167 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
4168 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
4174 /* sp-based offsets are zero-extended. */
4175 if (code >= 0x90 && code <= 0x93
4176 && (long) value < 0)
4179 /* Note that we've changed the relocation contents, etc. */
4180 elf_section_data (sec)->relocs = internal_relocs;
4181 elf_section_data (sec)->this_hdr.contents = contents;
4182 symtab_hdr->contents = (unsigned char *) isymbuf;
4184 /* Fix the opcode. */
4185 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4186 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4188 /* Fix the relocation's type. */
4189 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4190 (ELF32_R_TYPE (irel->r_info)
4191 == (int) R_MN10300_GOTOFF32)
4192 ? R_MN10300_GOTOFF16
4193 : (ELF32_R_TYPE (irel->r_info)
4194 == (int) R_MN10300_GOT32)
4196 : (ELF32_R_TYPE (irel->r_info)
4197 == (int) R_MN10300_GOTPC32)
4198 ? R_MN10300_GOTPC16 :
4201 /* Delete two bytes of data. */
4202 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4203 irel->r_offset + 2, 2))
4206 /* That will change things, so, we should relax again.
4207 Note that this is not required, and it may be slow. */
4211 else if ((code & 0xf0) < 0xf0)
4212 switch (code & 0xfc)
4214 /* mov imm32,dn -> mov imm16,dn
4215 mov imm32,an -> mov imm16,an
4216 mov (abs32),dn -> mov (abs16),dn
4217 movbu (abs32),dn -> movbu (abs16),dn
4218 movhu (abs32),dn -> movhu (abs16),dn */
4224 /* Not safe if the high bit is on as relaxing may
4225 move the value out of high mem and thus not fit
4226 in a signed 16bit value. */
4228 && (value & 0x8000))
4231 /* "mov imm16, an" zero-extends the immediate. */
4232 if ((code & 0xfc) == 0xdc
4233 && (long) value < 0)
4236 /* Note that we've changed the relocation contents, etc. */
4237 elf_section_data (sec)->relocs = internal_relocs;
4238 elf_section_data (sec)->this_hdr.contents = contents;
4239 symtab_hdr->contents = (unsigned char *) isymbuf;
4241 if ((code & 0xfc) == 0xcc)
4242 code = 0x2c + (code & 0x03);
4243 else if ((code & 0xfc) == 0xdc)
4244 code = 0x24 + (code & 0x03);
4245 else if ((code & 0xfc) == 0xa4)
4246 code = 0x30 + (code & 0x03);
4247 else if ((code & 0xfc) == 0xa8)
4248 code = 0x34 + (code & 0x03);
4249 else if ((code & 0xfc) == 0xac)
4250 code = 0x38 + (code & 0x03);
4254 /* Fix the opcode. */
4255 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4257 /* Fix the relocation's type. */
4258 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4259 (ELF32_R_TYPE (irel->r_info)
4260 == (int) R_MN10300_GOTOFF32)
4261 ? R_MN10300_GOTOFF16
4262 : (ELF32_R_TYPE (irel->r_info)
4263 == (int) R_MN10300_GOT32)
4265 : (ELF32_R_TYPE (irel->r_info)
4266 == (int) R_MN10300_GOTPC32)
4267 ? R_MN10300_GOTPC16 :
4270 /* The opcode got shorter too, so we have to fix the
4271 addend and offset too! */
4272 irel->r_offset -= 1;
4274 /* Delete three bytes of data. */
4275 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4276 irel->r_offset + 1, 3))
4279 /* That will change things, so, we should relax again.
4280 Note that this is not required, and it may be slow. */
4284 /* mov (abs32),an -> mov (abs16),an
4285 mov (d32,sp),an -> mov (d16,sp),an
4286 mov (d32,sp),dn -> mov (d16,sp),dn
4287 movbu (d32,sp),dn -> movbu (d16,sp),dn
4288 movhu (d32,sp),dn -> movhu (d16,sp),dn
4289 add imm32,dn -> add imm16,dn
4290 cmp imm32,dn -> cmp imm16,dn
4291 add imm32,an -> add imm16,an
4292 cmp imm32,an -> cmp imm16,an
4293 and imm32,dn -> and imm16,dn
4294 or imm32,dn -> or imm16,dn
4295 xor imm32,dn -> xor imm16,dn
4296 btst imm32,dn -> btst imm16,dn */
4312 /* cmp imm16, an zero-extends the immediate. */
4314 && (long) value < 0)
4317 /* So do sp-based offsets. */
4318 if (code >= 0xb0 && code <= 0xb3
4319 && (long) value < 0)
4322 /* Note that we've changed the relocation contents, etc. */
4323 elf_section_data (sec)->relocs = internal_relocs;
4324 elf_section_data (sec)->this_hdr.contents = contents;
4325 symtab_hdr->contents = (unsigned char *) isymbuf;
4327 /* Fix the opcode. */
4328 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4329 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4331 /* Fix the relocation's type. */
4332 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4333 (ELF32_R_TYPE (irel->r_info)
4334 == (int) R_MN10300_GOTOFF32)
4335 ? R_MN10300_GOTOFF16
4336 : (ELF32_R_TYPE (irel->r_info)
4337 == (int) R_MN10300_GOT32)
4339 : (ELF32_R_TYPE (irel->r_info)
4340 == (int) R_MN10300_GOTPC32)
4341 ? R_MN10300_GOTPC16 :
4344 /* Delete two bytes of data. */
4345 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4346 irel->r_offset + 2, 2))
4349 /* That will change things, so, we should relax again.
4350 Note that this is not required, and it may be slow. */
4354 else if (code == 0xfe)
4356 /* add imm32,sp -> add imm16,sp */
4358 /* Note that we've changed the relocation contents, etc. */
4359 elf_section_data (sec)->relocs = internal_relocs;
4360 elf_section_data (sec)->this_hdr.contents = contents;
4361 symtab_hdr->contents = (unsigned char *) isymbuf;
4363 /* Fix the opcode. */
4364 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4365 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
4367 /* Fix the relocation's type. */
4368 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4369 (ELF32_R_TYPE (irel->r_info)
4370 == (int) R_MN10300_GOT32)
4372 : (ELF32_R_TYPE (irel->r_info)
4373 == (int) R_MN10300_GOTOFF32)
4374 ? R_MN10300_GOTOFF16
4375 : (ELF32_R_TYPE (irel->r_info)
4376 == (int) R_MN10300_GOTPC32)
4377 ? R_MN10300_GOTPC16 :
4380 /* Delete two bytes of data. */
4381 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4382 irel->r_offset + 2, 2))
4385 /* That will change things, so, we should relax again.
4386 Note that this is not required, and it may be slow. */
4395 && symtab_hdr->contents != (unsigned char *) isymbuf)
4397 if (! link_info->keep_memory)
4401 /* Cache the symbols for elf_link_input_bfd. */
4402 symtab_hdr->contents = (unsigned char *) isymbuf;
4406 if (contents != NULL
4407 && elf_section_data (sec)->this_hdr.contents != contents)
4409 if (! link_info->keep_memory)
4413 /* Cache the section contents for elf_link_input_bfd. */
4414 elf_section_data (sec)->this_hdr.contents = contents;
4418 if (internal_relocs != NULL
4419 && elf_section_data (sec)->relocs != internal_relocs)
4420 free (internal_relocs);
4426 && symtab_hdr->contents != (unsigned char *) isymbuf)
4428 if (contents != NULL
4429 && elf_section_data (section)->this_hdr.contents != contents)
4431 if (internal_relocs != NULL
4432 && elf_section_data (section)->relocs != internal_relocs)
4433 free (internal_relocs);
4438 /* This is a version of bfd_generic_get_relocated_section_contents
4439 which uses mn10300_elf_relocate_section. */
4442 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
4443 struct bfd_link_info *link_info,
4444 struct bfd_link_order *link_order,
4446 bfd_boolean relocatable,
4449 Elf_Internal_Shdr *symtab_hdr;
4450 asection *input_section = link_order->u.indirect.section;
4451 bfd *input_bfd = input_section->owner;
4452 asection **sections = NULL;
4453 Elf_Internal_Rela *internal_relocs = NULL;
4454 Elf_Internal_Sym *isymbuf = NULL;
4456 /* We only need to handle the case of relaxing, or of having a
4457 particular set of section contents, specially. */
4459 || elf_section_data (input_section)->this_hdr.contents == NULL)
4460 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
4465 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4467 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
4468 (size_t) input_section->size);
4470 if ((input_section->flags & SEC_RELOC) != 0
4471 && input_section->reloc_count > 0)
4474 Elf_Internal_Sym *isym, *isymend;
4477 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
4479 if (internal_relocs == NULL)
4482 if (symtab_hdr->sh_info != 0)
4484 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4485 if (isymbuf == NULL)
4486 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4487 symtab_hdr->sh_info, 0,
4489 if (isymbuf == NULL)
4493 amt = symtab_hdr->sh_info;
4494 amt *= sizeof (asection *);
4495 sections = bfd_malloc (amt);
4496 if (sections == NULL && amt != 0)
4499 isymend = isymbuf + symtab_hdr->sh_info;
4500 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
4504 if (isym->st_shndx == SHN_UNDEF)
4505 isec = bfd_und_section_ptr;
4506 else if (isym->st_shndx == SHN_ABS)
4507 isec = bfd_abs_section_ptr;
4508 else if (isym->st_shndx == SHN_COMMON)
4509 isec = bfd_com_section_ptr;
4511 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
4516 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
4517 input_section, data, internal_relocs,
4521 if (sections != NULL)
4523 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4525 if (internal_relocs != elf_section_data (input_section)->relocs)
4526 free (internal_relocs);
4532 if (sections != NULL)
4534 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4536 if (internal_relocs != NULL
4537 && internal_relocs != elf_section_data (input_section)->relocs)
4538 free (internal_relocs);
4542 /* Assorted hash table functions. */
4544 /* Initialize an entry in the link hash table. */
4546 /* Create an entry in an MN10300 ELF linker hash table. */
4548 static struct bfd_hash_entry *
4549 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
4550 struct bfd_hash_table *table,
4553 struct elf32_mn10300_link_hash_entry *ret =
4554 (struct elf32_mn10300_link_hash_entry *) entry;
4556 /* Allocate the structure if it has not already been allocated by a
4559 ret = (struct elf32_mn10300_link_hash_entry *)
4560 bfd_hash_allocate (table, sizeof (* ret));
4562 return (struct bfd_hash_entry *) ret;
4564 /* Call the allocation method of the superclass. */
4565 ret = (struct elf32_mn10300_link_hash_entry *)
4566 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
4570 ret->direct_calls = 0;
4571 ret->stack_size = 0;
4573 ret->movm_stack_size = 0;
4576 ret->tls_type = GOT_UNKNOWN;
4579 return (struct bfd_hash_entry *) ret;
4583 _bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info,
4584 struct elf_link_hash_entry * dir,
4585 struct elf_link_hash_entry * ind)
4587 struct elf32_mn10300_link_hash_entry * edir;
4588 struct elf32_mn10300_link_hash_entry * eind;
4590 edir = elf_mn10300_hash_entry (dir);
4591 eind = elf_mn10300_hash_entry (ind);
4593 if (ind->root.type == bfd_link_hash_indirect
4594 && dir->got.refcount <= 0)
4596 edir->tls_type = eind->tls_type;
4597 eind->tls_type = GOT_UNKNOWN;
4599 edir->direct_calls = eind->direct_calls;
4600 edir->stack_size = eind->stack_size;
4601 edir->movm_args = eind->movm_args;
4602 edir->movm_stack_size = eind->movm_stack_size;
4603 edir->flags = eind->flags;
4605 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4608 /* Create an mn10300 ELF linker hash table. */
4610 static struct bfd_link_hash_table *
4611 elf32_mn10300_link_hash_table_create (bfd *abfd)
4613 struct elf32_mn10300_link_hash_table *ret;
4614 bfd_size_type amt = sizeof (* ret);
4616 ret = bfd_malloc (amt);
4620 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4621 elf32_mn10300_link_hash_newfunc,
4622 sizeof (struct elf32_mn10300_link_hash_entry),
4630 ret->tls_ldm_got.refcount = 0;
4631 ret->tls_ldm_got.offset = -1;
4632 ret->tls_ldm_got.got_allocated = 0;
4633 ret->tls_ldm_got.rel_emitted = 0;
4635 amt = sizeof (struct elf_link_hash_table);
4636 ret->static_hash_table = bfd_malloc (amt);
4637 if (ret->static_hash_table == NULL)
4643 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
4644 elf32_mn10300_link_hash_newfunc,
4645 sizeof (struct elf32_mn10300_link_hash_entry),
4648 free (ret->static_hash_table);
4652 return & ret->root.root;
4655 /* Free an mn10300 ELF linker hash table. */
4658 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
4660 struct elf32_mn10300_link_hash_table *ret
4661 = (struct elf32_mn10300_link_hash_table *) hash;
4663 _bfd_generic_link_hash_table_free
4664 ((struct bfd_link_hash_table *) ret->static_hash_table);
4665 _bfd_generic_link_hash_table_free
4666 ((struct bfd_link_hash_table *) ret);
4669 static unsigned long
4670 elf_mn10300_mach (flagword flags)
4672 switch (flags & EF_MN10300_MACH)
4674 case E_MN10300_MACH_MN10300:
4676 return bfd_mach_mn10300;
4678 case E_MN10300_MACH_AM33:
4679 return bfd_mach_am33;
4681 case E_MN10300_MACH_AM33_2:
4682 return bfd_mach_am33_2;
4686 /* The final processing done just before writing out a MN10300 ELF object
4687 file. This gets the MN10300 architecture right based on the machine
4691 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
4692 bfd_boolean linker ATTRIBUTE_UNUSED)
4696 switch (bfd_get_mach (abfd))
4699 case bfd_mach_mn10300:
4700 val = E_MN10300_MACH_MN10300;
4704 val = E_MN10300_MACH_AM33;
4707 case bfd_mach_am33_2:
4708 val = E_MN10300_MACH_AM33_2;
4712 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4713 elf_elfheader (abfd)->e_flags |= val;
4717 _bfd_mn10300_elf_object_p (bfd *abfd)
4719 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
4720 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
4724 /* Merge backend specific data from an object file to the output
4725 object file when linking. */
4728 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4730 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4731 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4734 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4735 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4737 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4738 bfd_get_mach (ibfd)))
4745 #define PLT0_ENTRY_SIZE 15
4746 #define PLT_ENTRY_SIZE 20
4747 #define PIC_PLT_ENTRY_SIZE 24
4749 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4751 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4752 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4753 0xf0, 0xf4, /* jmp (a0) */
4756 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4758 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4759 0xf0, 0xf4, /* jmp (a0) */
4760 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4761 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4764 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4766 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4767 0xf0, 0xf4, /* jmp (a0) */
4768 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4769 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4770 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4771 0xf0, 0xf4, /* jmp (a0) */
4774 /* Return size of the first PLT entry. */
4775 #define elf_mn10300_sizeof_plt0(info) \
4776 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4778 /* Return size of a PLT entry. */
4779 #define elf_mn10300_sizeof_plt(info) \
4780 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4782 /* Return offset of the PLT0 address in an absolute PLT entry. */
4783 #define elf_mn10300_plt_plt0_offset(info) 16
4785 /* Return offset of the linker in PLT0 entry. */
4786 #define elf_mn10300_plt0_linker_offset(info) 2
4788 /* Return offset of the GOT id in PLT0 entry. */
4789 #define elf_mn10300_plt0_gotid_offset(info) 9
4791 /* Return offset of the temporary in PLT entry. */
4792 #define elf_mn10300_plt_temp_offset(info) 8
4794 /* Return offset of the symbol in PLT entry. */
4795 #define elf_mn10300_plt_symbol_offset(info) 2
4797 /* Return offset of the relocation in PLT entry. */
4798 #define elf_mn10300_plt_reloc_offset(info) 11
4800 /* The name of the dynamic interpreter. This is put in the .interp
4803 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4805 /* Create dynamic sections when linking against a dynamic object. */
4808 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4812 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4815 switch (bed->s->arch_size)
4826 bfd_set_error (bfd_error_bad_value);
4830 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4831 .rel[a].bss sections. */
4832 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4833 | SEC_LINKER_CREATED);
4835 s = bfd_make_section_with_flags (abfd,
4836 (bed->default_use_rela_p
4837 ? ".rela.plt" : ".rel.plt"),
4838 flags | SEC_READONLY);
4840 || ! bfd_set_section_alignment (abfd, s, ptralign))
4843 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4846 if (bed->want_dynbss)
4848 /* The .dynbss section is a place to put symbols which are defined
4849 by dynamic objects, are referenced by regular objects, and are
4850 not functions. We must allocate space for them in the process
4851 image and use a R_*_COPY reloc to tell the dynamic linker to
4852 initialize them at run time. The linker script puts the .dynbss
4853 section into the .bss section of the final image. */
4854 s = bfd_make_section_with_flags (abfd, ".dynbss",
4855 SEC_ALLOC | SEC_LINKER_CREATED);
4859 /* The .rel[a].bss section holds copy relocs. This section is not
4860 normally needed. We need to create it here, though, so that the
4861 linker will map it to an output section. We can't just create it
4862 only if we need it, because we will not know whether we need it
4863 until we have seen all the input files, and the first time the
4864 main linker code calls BFD after examining all the input files
4865 (size_dynamic_sections) the input sections have already been
4866 mapped to the output sections. If the section turns out not to
4867 be needed, we can discard it later. We will never need this
4868 section when generating a shared object, since they do not use
4872 s = bfd_make_section_with_flags (abfd,
4873 (bed->default_use_rela_p
4874 ? ".rela.bss" : ".rel.bss"),
4875 flags | SEC_READONLY);
4877 || ! bfd_set_section_alignment (abfd, s, ptralign))
4885 /* Adjust a symbol defined by a dynamic object and referenced by a
4886 regular object. The current definition is in some section of the
4887 dynamic object, but we're not including those sections. We have to
4888 change the definition to something the rest of the link can
4892 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4893 struct elf_link_hash_entry * h)
4898 dynobj = elf_hash_table (info)->dynobj;
4900 /* Make sure we know what is going on here. */
4901 BFD_ASSERT (dynobj != NULL
4903 || h->u.weakdef != NULL
4906 && !h->def_regular)));
4908 /* If this is a function, put it in the procedure linkage table. We
4909 will fill in the contents of the procedure linkage table later,
4910 when we know the address of the .got section. */
4911 if (h->type == STT_FUNC
4918 /* This case can occur if we saw a PLT reloc in an input
4919 file, but the symbol was never referred to by a dynamic
4920 object. In such a case, we don't actually need to build
4921 a procedure linkage table, and we can just do a REL32
4923 BFD_ASSERT (h->needs_plt);
4927 /* Make sure this symbol is output as a dynamic symbol. */
4928 if (h->dynindx == -1)
4930 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4934 s = bfd_get_section_by_name (dynobj, ".plt");
4935 BFD_ASSERT (s != NULL);
4937 /* If this is the first .plt entry, make room for the special
4940 s->size += elf_mn10300_sizeof_plt0 (info);
4942 /* If this symbol is not defined in a regular file, and we are
4943 not generating a shared library, then set the symbol to this
4944 location in the .plt. This is required to make function
4945 pointers compare as equal between the normal executable and
4946 the shared library. */
4950 h->root.u.def.section = s;
4951 h->root.u.def.value = s->size;
4954 h->plt.offset = s->size;
4956 /* Make room for this entry. */
4957 s->size += elf_mn10300_sizeof_plt (info);
4959 /* We also need to make an entry in the .got.plt section, which
4960 will be placed in the .got section by the linker script. */
4961 s = bfd_get_section_by_name (dynobj, ".got.plt");
4962 BFD_ASSERT (s != NULL);
4965 /* We also need to make an entry in the .rela.plt section. */
4966 s = bfd_get_section_by_name (dynobj, ".rela.plt");
4967 BFD_ASSERT (s != NULL);
4968 s->size += sizeof (Elf32_External_Rela);
4973 /* If this is a weak symbol, and there is a real definition, the
4974 processor independent code will have arranged for us to see the
4975 real definition first, and we can just use the same value. */
4976 if (h->u.weakdef != NULL)
4978 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4979 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4980 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4981 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4985 /* This is a reference to a symbol defined by a dynamic object which
4986 is not a function. */
4988 /* If we are creating a shared library, we must presume that the
4989 only references to the symbol are via the global offset table.
4990 For such cases we need not do anything here; the relocations will
4991 be handled correctly by relocate_section. */
4995 /* If there are no references to this symbol that do not use the
4996 GOT, we don't need to generate a copy reloc. */
4997 if (!h->non_got_ref)
5000 /* We must allocate the symbol in our .dynbss section, which will
5001 become part of the .bss section of the executable. There will be
5002 an entry for this symbol in the .dynsym section. The dynamic
5003 object will contain position independent code, so all references
5004 from the dynamic object to this symbol will go through the global
5005 offset table. The dynamic linker will use the .dynsym entry to
5006 determine the address it must put in the global offset table, so
5007 both the dynamic object and the regular object will refer to the
5008 same memory location for the variable. */
5010 s = bfd_get_section_by_name (dynobj, ".dynbss");
5011 BFD_ASSERT (s != NULL);
5013 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
5014 copy the initial value out of the dynamic object and into the
5015 runtime process image. We need to remember the offset into the
5016 .rela.bss section we are going to use. */
5017 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5021 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
5022 BFD_ASSERT (srel != NULL);
5023 srel->size += sizeof (Elf32_External_Rela);
5027 return _bfd_elf_adjust_dynamic_copy (h, s);
5030 /* Set the sizes of the dynamic sections. */
5033 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
5034 struct bfd_link_info * info)
5036 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5041 bfd_boolean reltext;
5043 dynobj = elf_hash_table (info)->dynobj;
5044 BFD_ASSERT (dynobj != NULL);
5046 if (elf_hash_table (info)->dynamic_sections_created)
5048 /* Set the contents of the .interp section to the interpreter. */
5049 if (info->executable)
5051 s = bfd_get_section_by_name (dynobj, ".interp");
5052 BFD_ASSERT (s != NULL);
5053 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5054 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5059 /* We may have created entries in the .rela.got section.
5060 However, if we are not creating the dynamic sections, we will
5061 not actually use these entries. Reset the size of .rela.got,
5062 which will cause it to get stripped from the output file
5064 s = bfd_get_section_by_name (dynobj, ".rela.got");
5069 if (htab->tls_ldm_got.refcount > 0)
5071 s = bfd_get_section_by_name (dynobj, ".rela.got");
5072 BFD_ASSERT (s != NULL);
5073 s->size += sizeof (Elf32_External_Rela);
5076 /* The check_relocs and adjust_dynamic_symbol entry points have
5077 determined the sizes of the various dynamic sections. Allocate
5082 for (s = dynobj->sections; s != NULL; s = s->next)
5086 if ((s->flags & SEC_LINKER_CREATED) == 0)
5089 /* It's OK to base decisions on the section name, because none
5090 of the dynobj section names depend upon the input files. */
5091 name = bfd_get_section_name (dynobj, s);
5093 if (streq (name, ".plt"))
5095 /* Remember whether there is a PLT. */
5098 else if (CONST_STRNEQ (name, ".rela"))
5104 /* Remember whether there are any reloc sections other
5106 if (! streq (name, ".rela.plt"))
5108 const char * outname;
5112 /* If this relocation section applies to a read only
5113 section, then we probably need a DT_TEXTREL
5114 entry. The entries in the .rela.plt section
5115 really apply to the .got section, which we
5116 created ourselves and so know is not readonly. */
5117 outname = bfd_get_section_name (output_bfd,
5119 target = bfd_get_section_by_name (output_bfd, outname + 5);
5121 && (target->flags & SEC_READONLY) != 0
5122 && (target->flags & SEC_ALLOC) != 0)
5126 /* We use the reloc_count field as a counter if we need
5127 to copy relocs into the output file. */
5131 else if (! CONST_STRNEQ (name, ".got")
5132 && ! streq (name, ".dynbss"))
5133 /* It's not one of our sections, so don't allocate space. */
5138 /* If we don't need this section, strip it from the
5139 output file. This is mostly to handle .rela.bss and
5140 .rela.plt. We must create both sections in
5141 create_dynamic_sections, because they must be created
5142 before the linker maps input sections to output
5143 sections. The linker does that before
5144 adjust_dynamic_symbol is called, and it is that
5145 function which decides whether anything needs to go
5146 into these sections. */
5147 s->flags |= SEC_EXCLUDE;
5151 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5154 /* Allocate memory for the section contents. We use bfd_zalloc
5155 here in case unused entries are not reclaimed before the
5156 section's contents are written out. This should not happen,
5157 but this way if it does, we get a R_MN10300_NONE reloc
5158 instead of garbage. */
5159 s->contents = bfd_zalloc (dynobj, s->size);
5160 if (s->contents == NULL)
5164 if (elf_hash_table (info)->dynamic_sections_created)
5166 /* Add some entries to the .dynamic section. We fill in the
5167 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
5168 but we must add the entries now so that we get the correct
5169 size for the .dynamic section. The DT_DEBUG entry is filled
5170 in by the dynamic linker and used by the debugger. */
5173 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
5179 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
5180 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5181 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
5182 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5188 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
5189 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
5190 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
5191 sizeof (Elf32_External_Rela)))
5197 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
5205 /* Finish up dynamic symbol handling. We set the contents of various
5206 dynamic sections here. */
5209 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
5210 struct bfd_link_info * info,
5211 struct elf_link_hash_entry * h,
5212 Elf_Internal_Sym * sym)
5216 dynobj = elf_hash_table (info)->dynobj;
5218 if (h->plt.offset != (bfd_vma) -1)
5225 Elf_Internal_Rela rel;
5227 /* This symbol has an entry in the procedure linkage table. Set
5230 BFD_ASSERT (h->dynindx != -1);
5232 splt = bfd_get_section_by_name (dynobj, ".plt");
5233 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5234 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
5235 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
5237 /* Get the index in the procedure linkage table which
5238 corresponds to this symbol. This is the index of this symbol
5239 in all the symbols for which we are making plt entries. The
5240 first entry in the procedure linkage table is reserved. */
5241 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
5242 / elf_mn10300_sizeof_plt (info));
5244 /* Get the offset into the .got table of the entry that
5245 corresponds to this function. Each .got entry is 4 bytes.
5246 The first three are reserved. */
5247 got_offset = (plt_index + 3) * 4;
5249 /* Fill in the entry in the procedure linkage table. */
5252 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
5253 elf_mn10300_sizeof_plt (info));
5254 bfd_put_32 (output_bfd,
5255 (sgot->output_section->vma
5256 + sgot->output_offset
5258 (splt->contents + h->plt.offset
5259 + elf_mn10300_plt_symbol_offset (info)));
5261 bfd_put_32 (output_bfd,
5262 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
5263 (splt->contents + h->plt.offset
5264 + elf_mn10300_plt_plt0_offset (info)));
5268 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
5269 elf_mn10300_sizeof_plt (info));
5271 bfd_put_32 (output_bfd, got_offset,
5272 (splt->contents + h->plt.offset
5273 + elf_mn10300_plt_symbol_offset (info)));
5276 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
5277 (splt->contents + h->plt.offset
5278 + elf_mn10300_plt_reloc_offset (info)));
5280 /* Fill in the entry in the global offset table. */
5281 bfd_put_32 (output_bfd,
5282 (splt->output_section->vma
5283 + splt->output_offset
5285 + elf_mn10300_plt_temp_offset (info)),
5286 sgot->contents + got_offset);
5288 /* Fill in the entry in the .rela.plt section. */
5289 rel.r_offset = (sgot->output_section->vma
5290 + sgot->output_offset
5292 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
5294 bfd_elf32_swap_reloca_out (output_bfd, &rel,
5295 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5298 if (!h->def_regular)
5299 /* Mark the symbol as undefined, rather than as defined in
5300 the .plt section. Leave the value alone. */
5301 sym->st_shndx = SHN_UNDEF;
5304 if (h->got.offset != (bfd_vma) -1)
5308 Elf_Internal_Rela rel;
5310 /* This symbol has an entry in the global offset table. Set it up. */
5311 sgot = bfd_get_section_by_name (dynobj, ".got");
5312 srel = bfd_get_section_by_name (dynobj, ".rela.got");
5313 BFD_ASSERT (sgot != NULL && srel != NULL);
5315 rel.r_offset = (sgot->output_section->vma
5316 + sgot->output_offset
5317 + (h->got.offset & ~1));
5319 switch (elf_mn10300_hash_entry (h)->tls_type)
5322 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5323 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset + 4);
5324 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPMOD);
5326 bfd_elf32_swap_reloca_out (output_bfd, & rel,
5327 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5328 + srel->reloc_count));
5329 ++ srel->reloc_count;
5330 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPOFF);
5336 /* We originally stored the addend in the GOT, but at this
5337 point, we want to move it to the reloc instead as that's
5338 where the dynamic linker wants it. */
5339 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + h->got.offset);
5340 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5341 if (h->dynindx == -1)
5342 rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF);
5344 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_TPOFF);
5348 /* If this is a -Bsymbolic link, and the symbol is defined
5349 locally, we just want to emit a RELATIVE reloc. Likewise if
5350 the symbol was forced to be local because of a version file.
5351 The entry in the global offset table will already have been
5352 initialized in the relocate_section function. */
5354 && (info->symbolic || h->dynindx == -1)
5357 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
5358 rel.r_addend = (h->root.u.def.value
5359 + h->root.u.def.section->output_section->vma
5360 + h->root.u.def.section->output_offset);
5364 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5365 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
5370 if (ELF32_R_TYPE (rel.r_info) != R_MN10300_NONE)
5372 bfd_elf32_swap_reloca_out (output_bfd, &rel,
5373 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5374 + srel->reloc_count));
5375 ++ srel->reloc_count;
5382 Elf_Internal_Rela rel;
5384 /* This symbol needs a copy reloc. Set it up. */
5385 BFD_ASSERT (h->dynindx != -1
5386 && (h->root.type == bfd_link_hash_defined
5387 || h->root.type == bfd_link_hash_defweak));
5389 s = bfd_get_section_by_name (h->root.u.def.section->owner,
5391 BFD_ASSERT (s != NULL);
5393 rel.r_offset = (h->root.u.def.value
5394 + h->root.u.def.section->output_section->vma
5395 + h->root.u.def.section->output_offset);
5396 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
5398 bfd_elf32_swap_reloca_out (output_bfd, & rel,
5399 (bfd_byte *) ((Elf32_External_Rela *) s->contents
5404 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5405 if (streq (h->root.root.string, "_DYNAMIC")
5406 || h == elf_hash_table (info)->hgot)
5407 sym->st_shndx = SHN_ABS;
5412 /* Finish up the dynamic sections. */
5415 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
5416 struct bfd_link_info * info)
5422 dynobj = elf_hash_table (info)->dynobj;
5424 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5425 BFD_ASSERT (sgot != NULL);
5426 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5428 if (elf_hash_table (info)->dynamic_sections_created)
5431 Elf32_External_Dyn * dyncon;
5432 Elf32_External_Dyn * dynconend;
5434 BFD_ASSERT (sdyn != NULL);
5436 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5437 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5439 for (; dyncon < dynconend; dyncon++)
5441 Elf_Internal_Dyn dyn;
5445 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5459 s = bfd_get_section_by_name (output_bfd, name);
5460 BFD_ASSERT (s != NULL);
5461 dyn.d_un.d_ptr = s->vma;
5462 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5466 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
5467 BFD_ASSERT (s != NULL);
5468 dyn.d_un.d_val = s->size;
5469 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5473 /* My reading of the SVR4 ABI indicates that the
5474 procedure linkage table relocs (DT_JMPREL) should be
5475 included in the overall relocs (DT_RELA). This is
5476 what Solaris does. However, UnixWare can not handle
5477 that case. Therefore, we override the DT_RELASZ entry
5478 here to make it not include the JMPREL relocs. Since
5479 the linker script arranges for .rela.plt to follow all
5480 other relocation sections, we don't have to worry
5481 about changing the DT_RELA entry. */
5482 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
5484 dyn.d_un.d_val -= s->size;
5485 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5490 /* Fill in the first entry in the procedure linkage table. */
5491 splt = bfd_get_section_by_name (dynobj, ".plt");
5492 if (splt && splt->size > 0)
5496 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
5497 elf_mn10300_sizeof_plt (info));
5501 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
5502 bfd_put_32 (output_bfd,
5503 sgot->output_section->vma + sgot->output_offset + 4,
5504 splt->contents + elf_mn10300_plt0_gotid_offset (info));
5505 bfd_put_32 (output_bfd,
5506 sgot->output_section->vma + sgot->output_offset + 8,
5507 splt->contents + elf_mn10300_plt0_linker_offset (info));
5510 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5511 really seem like the right value. */
5512 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5514 /* UnixWare sets the entsize of .plt to 4, but this is incorrect
5515 as it means that the size of the PLT0 section (15 bytes) is not
5516 a multiple of the sh_entsize. Some ELF tools flag this as an
5517 error. We could pad PLT0 to 16 bytes, but that would introduce
5518 compatibilty issues with previous toolchains, so instead we
5519 just set the entry size to 1. */
5520 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1;
5524 /* Fill in the first three entries in the global offset table. */
5528 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5530 bfd_put_32 (output_bfd,
5531 sdyn->output_section->vma + sdyn->output_offset,
5533 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5534 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5537 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5542 /* Classify relocation types, such that combreloc can sort them
5545 static enum elf_reloc_type_class
5546 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
5548 switch ((int) ELF32_R_TYPE (rela->r_info))
5550 case R_MN10300_RELATIVE: return reloc_class_relative;
5551 case R_MN10300_JMP_SLOT: return reloc_class_plt;
5552 case R_MN10300_COPY: return reloc_class_copy;
5553 default: return reloc_class_normal;
5557 /* Allocate space for an MN10300 extension to the bfd elf data structure. */
5560 mn10300_elf_mkobject (bfd *abfd)
5562 return bfd_elf_allocate_object (abfd, sizeof (struct elf_mn10300_obj_tdata),
5566 #define bfd_elf32_mkobject mn10300_elf_mkobject
5569 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
5570 #define TARGET_LITTLE_NAME "elf32-mn10300"
5571 #define ELF_ARCH bfd_arch_mn10300
5572 #define ELF_TARGET_ID MN10300_ELF_DATA
5573 #define ELF_MACHINE_CODE EM_MN10300
5574 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
5575 #define ELF_MAXPAGESIZE 0x1000
5578 #define elf_info_to_howto mn10300_info_to_howto
5579 #define elf_info_to_howto_rel 0
5580 #define elf_backend_can_gc_sections 1
5581 #define elf_backend_rela_normal 1
5582 #define elf_backend_check_relocs mn10300_elf_check_relocs
5583 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
5584 #define elf_backend_relocate_section mn10300_elf_relocate_section
5585 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
5586 #define bfd_elf32_bfd_get_relocated_section_contents \
5587 mn10300_elf_get_relocated_section_contents
5588 #define bfd_elf32_bfd_link_hash_table_create \
5589 elf32_mn10300_link_hash_table_create
5590 #define bfd_elf32_bfd_link_hash_table_free \
5591 elf32_mn10300_link_hash_table_free
5593 #ifndef elf_symbol_leading_char
5594 #define elf_symbol_leading_char '_'
5597 /* So we can set bits in e_flags. */
5598 #define elf_backend_final_write_processing \
5599 _bfd_mn10300_elf_final_write_processing
5600 #define elf_backend_object_p _bfd_mn10300_elf_object_p
5602 #define bfd_elf32_bfd_merge_private_bfd_data \
5603 _bfd_mn10300_elf_merge_private_bfd_data
5605 #define elf_backend_can_gc_sections 1
5606 #define elf_backend_create_dynamic_sections \
5607 _bfd_mn10300_elf_create_dynamic_sections
5608 #define elf_backend_adjust_dynamic_symbol \
5609 _bfd_mn10300_elf_adjust_dynamic_symbol
5610 #define elf_backend_size_dynamic_sections \
5611 _bfd_mn10300_elf_size_dynamic_sections
5612 #define elf_backend_omit_section_dynsym \
5613 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5614 #define elf_backend_finish_dynamic_symbol \
5615 _bfd_mn10300_elf_finish_dynamic_symbol
5616 #define elf_backend_finish_dynamic_sections \
5617 _bfd_mn10300_elf_finish_dynamic_sections
5618 #define elf_backend_copy_indirect_symbol \
5619 _bfd_mn10300_copy_indirect_symbol
5620 #define elf_backend_reloc_type_class \
5621 _bfd_mn10300_elf_reloc_type_class
5623 #define elf_backend_want_got_plt 1
5624 #define elf_backend_plt_readonly 1
5625 #define elf_backend_want_plt_sym 0
5626 #define elf_backend_got_header_size 12
5628 #include "elf32-target.h"