1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright (C) 1996-2016 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "elf/mn10300.h"
26 #include "libiberty.h"
28 /* The mn10300 linker needs to keep track of the number of relocs that
29 it decides to copy in check_relocs for each symbol. This is so
30 that it can discard PC relative relocs if it doesn't need them when
31 linking with -Bsymbolic. We store the information in a field
32 extending the regular ELF linker hash table. */
34 struct elf32_mn10300_link_hash_entry
36 /* The basic elf link hash table entry. */
37 struct elf_link_hash_entry root;
39 /* For function symbols, the number of times this function is
40 called directly (ie by name). */
41 unsigned int direct_calls;
43 /* For function symbols, the size of this function's stack
44 (if <= 255 bytes). We stuff this into "call" instructions
45 to this target when it's valid and profitable to do so.
47 This does not include stack allocated by movm! */
48 unsigned char stack_size;
50 /* For function symbols, arguments (if any) for movm instruction
51 in the prologue. We stuff this value into "call" instructions
52 to the target when it's valid and profitable to do so. */
53 unsigned char movm_args;
55 /* For function symbols, the amount of stack space that would be allocated
56 by the movm instruction. This is redundant with movm_args, but we
57 add it to the hash table to avoid computing it over and over. */
58 unsigned char movm_stack_size;
60 /* When set, convert all "call" instructions to this target into "calls"
62 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
64 /* Used to mark functions which have had redundant parts of their
66 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
69 /* Calculated value. */
77 /* Used to distinguish GOT entries for TLS types from normal GOT entries. */
78 unsigned char tls_type;
81 /* We derive a hash table from the main elf linker hash table so
82 we can store state variables and a secondary hash table without
83 resorting to global variables. */
84 struct elf32_mn10300_link_hash_table
86 /* The main hash table. */
87 struct elf_link_hash_table root;
89 /* A hash table for static functions. We could derive a new hash table
90 instead of using the full elf32_mn10300_link_hash_table if we wanted
91 to save some memory. */
92 struct elf32_mn10300_link_hash_table *static_hash_table;
94 /* Random linker state flags. */
95 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
99 bfd_signed_vma refcount;
106 #define elf_mn10300_hash_entry(ent) ((struct elf32_mn10300_link_hash_entry *)(ent))
108 struct elf_mn10300_obj_tdata
110 struct elf_obj_tdata root;
112 /* tls_type for each local got entry. */
113 char * local_got_tls_type;
116 #define elf_mn10300_tdata(abfd) \
117 ((struct elf_mn10300_obj_tdata *) (abfd)->tdata.any)
119 #define elf_mn10300_local_got_tls_type(abfd) \
120 (elf_mn10300_tdata (abfd)->local_got_tls_type)
123 #define streq(a, b) (strcmp ((a),(b)) == 0)
126 /* For MN10300 linker hash table. */
128 /* Get the MN10300 ELF linker hash table from a link_info structure. */
130 #define elf32_mn10300_hash_table(p) \
131 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
132 == MN10300_ELF_DATA ? ((struct elf32_mn10300_link_hash_table *) ((p)->hash)) : NULL)
134 #define elf32_mn10300_link_hash_traverse(table, func, info) \
135 (elf_link_hash_traverse \
137 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
140 static reloc_howto_type elf_mn10300_howto_table[] =
142 /* Dummy relocation. Does nothing. */
143 HOWTO (R_MN10300_NONE,
149 complain_overflow_dont,
150 bfd_elf_generic_reloc,
156 /* Standard 32 bit reloc. */
163 complain_overflow_bitfield,
164 bfd_elf_generic_reloc,
170 /* Standard 16 bit reloc. */
177 complain_overflow_bitfield,
178 bfd_elf_generic_reloc,
184 /* Standard 8 bit reloc. */
191 complain_overflow_bitfield,
192 bfd_elf_generic_reloc,
198 /* Standard 32bit pc-relative reloc. */
199 HOWTO (R_MN10300_PCREL32,
205 complain_overflow_bitfield,
206 bfd_elf_generic_reloc,
212 /* Standard 16bit pc-relative reloc. */
213 HOWTO (R_MN10300_PCREL16,
219 complain_overflow_bitfield,
220 bfd_elf_generic_reloc,
226 /* Standard 8 pc-relative reloc. */
227 HOWTO (R_MN10300_PCREL8,
233 complain_overflow_bitfield,
234 bfd_elf_generic_reloc,
241 /* GNU extension to record C++ vtable hierarchy. */
242 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
244 0, /* size (0 = byte, 1 = short, 2 = long) */
246 FALSE, /* pc_relative */
248 complain_overflow_dont, /* complain_on_overflow */
249 NULL, /* special_function */
250 "R_MN10300_GNU_VTINHERIT", /* name */
251 FALSE, /* partial_inplace */
254 FALSE), /* pcrel_offset */
256 /* GNU extension to record C++ vtable member usage */
257 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
259 0, /* size (0 = byte, 1 = short, 2 = long) */
261 FALSE, /* pc_relative */
263 complain_overflow_dont, /* complain_on_overflow */
264 NULL, /* special_function */
265 "R_MN10300_GNU_VTENTRY", /* name */
266 FALSE, /* partial_inplace */
269 FALSE), /* pcrel_offset */
271 /* Standard 24 bit reloc. */
278 complain_overflow_bitfield,
279 bfd_elf_generic_reloc,
285 HOWTO (R_MN10300_GOTPC32, /* type */
287 2, /* size (0 = byte, 1 = short, 2 = long) */
289 TRUE, /* pc_relative */
291 complain_overflow_bitfield, /* complain_on_overflow */
292 bfd_elf_generic_reloc, /* */
293 "R_MN10300_GOTPC32", /* name */
294 FALSE, /* partial_inplace */
295 0xffffffff, /* src_mask */
296 0xffffffff, /* dst_mask */
297 TRUE), /* pcrel_offset */
299 HOWTO (R_MN10300_GOTPC16, /* type */
301 1, /* size (0 = byte, 1 = short, 2 = long) */
303 TRUE, /* pc_relative */
305 complain_overflow_bitfield, /* complain_on_overflow */
306 bfd_elf_generic_reloc, /* */
307 "R_MN10300_GOTPC16", /* name */
308 FALSE, /* partial_inplace */
309 0xffff, /* src_mask */
310 0xffff, /* dst_mask */
311 TRUE), /* pcrel_offset */
313 HOWTO (R_MN10300_GOTOFF32, /* type */
315 2, /* size (0 = byte, 1 = short, 2 = long) */
317 FALSE, /* pc_relative */
319 complain_overflow_bitfield, /* complain_on_overflow */
320 bfd_elf_generic_reloc, /* */
321 "R_MN10300_GOTOFF32", /* name */
322 FALSE, /* partial_inplace */
323 0xffffffff, /* src_mask */
324 0xffffffff, /* dst_mask */
325 FALSE), /* pcrel_offset */
327 HOWTO (R_MN10300_GOTOFF24, /* type */
329 2, /* size (0 = byte, 1 = short, 2 = long) */
331 FALSE, /* pc_relative */
333 complain_overflow_bitfield, /* complain_on_overflow */
334 bfd_elf_generic_reloc, /* */
335 "R_MN10300_GOTOFF24", /* name */
336 FALSE, /* partial_inplace */
337 0xffffff, /* src_mask */
338 0xffffff, /* dst_mask */
339 FALSE), /* pcrel_offset */
341 HOWTO (R_MN10300_GOTOFF16, /* type */
343 1, /* size (0 = byte, 1 = short, 2 = long) */
345 FALSE, /* pc_relative */
347 complain_overflow_bitfield, /* complain_on_overflow */
348 bfd_elf_generic_reloc, /* */
349 "R_MN10300_GOTOFF16", /* name */
350 FALSE, /* partial_inplace */
351 0xffff, /* src_mask */
352 0xffff, /* dst_mask */
353 FALSE), /* pcrel_offset */
355 HOWTO (R_MN10300_PLT32, /* type */
357 2, /* size (0 = byte, 1 = short, 2 = long) */
359 TRUE, /* pc_relative */
361 complain_overflow_bitfield, /* complain_on_overflow */
362 bfd_elf_generic_reloc, /* */
363 "R_MN10300_PLT32", /* name */
364 FALSE, /* partial_inplace */
365 0xffffffff, /* src_mask */
366 0xffffffff, /* dst_mask */
367 TRUE), /* pcrel_offset */
369 HOWTO (R_MN10300_PLT16, /* type */
371 1, /* size (0 = byte, 1 = short, 2 = long) */
373 TRUE, /* pc_relative */
375 complain_overflow_bitfield, /* complain_on_overflow */
376 bfd_elf_generic_reloc, /* */
377 "R_MN10300_PLT16", /* name */
378 FALSE, /* partial_inplace */
379 0xffff, /* src_mask */
380 0xffff, /* dst_mask */
381 TRUE), /* pcrel_offset */
383 HOWTO (R_MN10300_GOT32, /* type */
385 2, /* size (0 = byte, 1 = short, 2 = long) */
387 FALSE, /* pc_relative */
389 complain_overflow_bitfield, /* complain_on_overflow */
390 bfd_elf_generic_reloc, /* */
391 "R_MN10300_GOT32", /* name */
392 FALSE, /* partial_inplace */
393 0xffffffff, /* src_mask */
394 0xffffffff, /* dst_mask */
395 FALSE), /* pcrel_offset */
397 HOWTO (R_MN10300_GOT24, /* type */
399 2, /* size (0 = byte, 1 = short, 2 = long) */
401 FALSE, /* pc_relative */
403 complain_overflow_bitfield, /* complain_on_overflow */
404 bfd_elf_generic_reloc, /* */
405 "R_MN10300_GOT24", /* name */
406 FALSE, /* partial_inplace */
407 0xffffffff, /* src_mask */
408 0xffffffff, /* dst_mask */
409 FALSE), /* pcrel_offset */
411 HOWTO (R_MN10300_GOT16, /* type */
413 1, /* size (0 = byte, 1 = short, 2 = long) */
415 FALSE, /* pc_relative */
417 complain_overflow_bitfield, /* complain_on_overflow */
418 bfd_elf_generic_reloc, /* */
419 "R_MN10300_GOT16", /* name */
420 FALSE, /* partial_inplace */
421 0xffffffff, /* src_mask */
422 0xffffffff, /* dst_mask */
423 FALSE), /* pcrel_offset */
425 HOWTO (R_MN10300_COPY, /* type */
427 2, /* size (0 = byte, 1 = short, 2 = long) */
429 FALSE, /* pc_relative */
431 complain_overflow_bitfield, /* complain_on_overflow */
432 bfd_elf_generic_reloc, /* */
433 "R_MN10300_COPY", /* name */
434 FALSE, /* partial_inplace */
435 0xffffffff, /* src_mask */
436 0xffffffff, /* dst_mask */
437 FALSE), /* pcrel_offset */
439 HOWTO (R_MN10300_GLOB_DAT, /* type */
441 2, /* size (0 = byte, 1 = short, 2 = long) */
443 FALSE, /* pc_relative */
445 complain_overflow_bitfield, /* complain_on_overflow */
446 bfd_elf_generic_reloc, /* */
447 "R_MN10300_GLOB_DAT", /* name */
448 FALSE, /* partial_inplace */
449 0xffffffff, /* src_mask */
450 0xffffffff, /* dst_mask */
451 FALSE), /* pcrel_offset */
453 HOWTO (R_MN10300_JMP_SLOT, /* type */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
457 FALSE, /* pc_relative */
459 complain_overflow_bitfield, /* complain_on_overflow */
460 bfd_elf_generic_reloc, /* */
461 "R_MN10300_JMP_SLOT", /* name */
462 FALSE, /* partial_inplace */
463 0xffffffff, /* src_mask */
464 0xffffffff, /* dst_mask */
465 FALSE), /* pcrel_offset */
467 HOWTO (R_MN10300_RELATIVE, /* type */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
471 FALSE, /* pc_relative */
473 complain_overflow_bitfield, /* complain_on_overflow */
474 bfd_elf_generic_reloc, /* */
475 "R_MN10300_RELATIVE", /* name */
476 FALSE, /* partial_inplace */
477 0xffffffff, /* src_mask */
478 0xffffffff, /* dst_mask */
479 FALSE), /* pcrel_offset */
481 HOWTO (R_MN10300_TLS_GD, /* type */
483 2, /* size (0 = byte, 1 = short, 2 = long) */
485 FALSE, /* pc_relative */
487 complain_overflow_bitfield, /* complain_on_overflow */
488 bfd_elf_generic_reloc, /* */
489 "R_MN10300_TLS_GD", /* name */
490 FALSE, /* partial_inplace */
491 0xffffffff, /* src_mask */
492 0xffffffff, /* dst_mask */
493 FALSE), /* pcrel_offset */
495 HOWTO (R_MN10300_TLS_LD, /* type */
497 2, /* size (0 = byte, 1 = short, 2 = long) */
499 FALSE, /* pc_relative */
501 complain_overflow_bitfield, /* complain_on_overflow */
502 bfd_elf_generic_reloc, /* */
503 "R_MN10300_TLS_LD", /* name */
504 FALSE, /* partial_inplace */
505 0xffffffff, /* src_mask */
506 0xffffffff, /* dst_mask */
507 FALSE), /* pcrel_offset */
509 HOWTO (R_MN10300_TLS_LDO, /* type */
511 2, /* size (0 = byte, 1 = short, 2 = long) */
513 FALSE, /* pc_relative */
515 complain_overflow_bitfield, /* complain_on_overflow */
516 bfd_elf_generic_reloc, /* */
517 "R_MN10300_TLS_LDO", /* name */
518 FALSE, /* partial_inplace */
519 0xffffffff, /* src_mask */
520 0xffffffff, /* dst_mask */
521 FALSE), /* pcrel_offset */
523 HOWTO (R_MN10300_TLS_GOTIE, /* type */
525 2, /* size (0 = byte, 1 = short, 2 = long) */
527 FALSE, /* pc_relative */
529 complain_overflow_bitfield, /* complain_on_overflow */
530 bfd_elf_generic_reloc, /* */
531 "R_MN10300_TLS_GOTIE", /* name */
532 FALSE, /* partial_inplace */
533 0xffffffff, /* src_mask */
534 0xffffffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
537 HOWTO (R_MN10300_TLS_IE, /* type */
539 2, /* size (0 = byte, 1 = short, 2 = long) */
541 FALSE, /* pc_relative */
543 complain_overflow_bitfield, /* complain_on_overflow */
544 bfd_elf_generic_reloc, /* */
545 "R_MN10300_TLS_IE", /* name */
546 FALSE, /* partial_inplace */
547 0xffffffff, /* src_mask */
548 0xffffffff, /* dst_mask */
549 FALSE), /* pcrel_offset */
551 HOWTO (R_MN10300_TLS_LE, /* type */
553 2, /* size (0 = byte, 1 = short, 2 = long) */
555 FALSE, /* pc_relative */
557 complain_overflow_bitfield, /* complain_on_overflow */
558 bfd_elf_generic_reloc, /* */
559 "R_MN10300_TLS_LE", /* name */
560 FALSE, /* partial_inplace */
561 0xffffffff, /* src_mask */
562 0xffffffff, /* dst_mask */
563 FALSE), /* pcrel_offset */
565 HOWTO (R_MN10300_TLS_DTPMOD, /* type */
567 2, /* size (0 = byte, 1 = short, 2 = long) */
569 FALSE, /* pc_relative */
571 complain_overflow_bitfield, /* complain_on_overflow */
572 bfd_elf_generic_reloc, /* */
573 "R_MN10300_TLS_DTPMOD", /* name */
574 FALSE, /* partial_inplace */
575 0xffffffff, /* src_mask */
576 0xffffffff, /* dst_mask */
577 FALSE), /* pcrel_offset */
579 HOWTO (R_MN10300_TLS_DTPOFF, /* type */
581 2, /* size (0 = byte, 1 = short, 2 = long) */
583 FALSE, /* pc_relative */
585 complain_overflow_bitfield, /* complain_on_overflow */
586 bfd_elf_generic_reloc, /* */
587 "R_MN10300_TLS_DTPOFF", /* name */
588 FALSE, /* partial_inplace */
589 0xffffffff, /* src_mask */
590 0xffffffff, /* dst_mask */
591 FALSE), /* pcrel_offset */
593 HOWTO (R_MN10300_TLS_TPOFF, /* type */
595 2, /* size (0 = byte, 1 = short, 2 = long) */
597 FALSE, /* pc_relative */
599 complain_overflow_bitfield, /* complain_on_overflow */
600 bfd_elf_generic_reloc, /* */
601 "R_MN10300_TLS_TPOFF", /* name */
602 FALSE, /* partial_inplace */
603 0xffffffff, /* src_mask */
604 0xffffffff, /* dst_mask */
605 FALSE), /* pcrel_offset */
607 HOWTO (R_MN10300_SYM_DIFF, /* type */
609 2, /* size (0 = byte, 1 = short, 2 = long) */
611 FALSE, /* pc_relative */
613 complain_overflow_dont,/* complain_on_overflow */
614 NULL, /* special handler. */
615 "R_MN10300_SYM_DIFF", /* name */
616 FALSE, /* partial_inplace */
617 0xffffffff, /* src_mask */
618 0xffffffff, /* dst_mask */
619 FALSE), /* pcrel_offset */
621 HOWTO (R_MN10300_ALIGN, /* type */
623 0, /* size (0 = byte, 1 = short, 2 = long) */
625 FALSE, /* pc_relative */
627 complain_overflow_dont,/* complain_on_overflow */
628 NULL, /* special handler. */
629 "R_MN10300_ALIGN", /* name */
630 FALSE, /* partial_inplace */
633 FALSE) /* pcrel_offset */
636 struct mn10300_reloc_map
638 bfd_reloc_code_real_type bfd_reloc_val;
639 unsigned char elf_reloc_val;
642 static const struct mn10300_reloc_map mn10300_reloc_map[] =
644 { BFD_RELOC_NONE, R_MN10300_NONE, },
645 { BFD_RELOC_32, R_MN10300_32, },
646 { BFD_RELOC_16, R_MN10300_16, },
647 { BFD_RELOC_8, R_MN10300_8, },
648 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
649 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
650 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
651 { BFD_RELOC_24, R_MN10300_24, },
652 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
653 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
654 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
655 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
656 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
657 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
658 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
659 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
660 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
661 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
662 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
663 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
664 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
665 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
666 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
667 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
668 { BFD_RELOC_MN10300_TLS_GD, R_MN10300_TLS_GD },
669 { BFD_RELOC_MN10300_TLS_LD, R_MN10300_TLS_LD },
670 { BFD_RELOC_MN10300_TLS_LDO, R_MN10300_TLS_LDO },
671 { BFD_RELOC_MN10300_TLS_GOTIE, R_MN10300_TLS_GOTIE },
672 { BFD_RELOC_MN10300_TLS_IE, R_MN10300_TLS_IE },
673 { BFD_RELOC_MN10300_TLS_LE, R_MN10300_TLS_LE },
674 { BFD_RELOC_MN10300_TLS_DTPMOD, R_MN10300_TLS_DTPMOD },
675 { BFD_RELOC_MN10300_TLS_DTPOFF, R_MN10300_TLS_DTPOFF },
676 { BFD_RELOC_MN10300_TLS_TPOFF, R_MN10300_TLS_TPOFF },
677 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
678 { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
681 /* Create the GOT section. */
684 _bfd_mn10300_elf_create_got_section (bfd * abfd,
685 struct bfd_link_info * info)
690 struct elf_link_hash_entry * h;
691 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
692 struct elf_link_hash_table *htab;
695 /* This function may be called more than once. */
696 htab = elf_hash_table (info);
697 if (htab->sgot != NULL)
700 switch (bed->s->arch_size)
711 bfd_set_error (bfd_error_bad_value);
715 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
716 | SEC_LINKER_CREATED);
719 pltflags |= SEC_CODE;
720 if (bed->plt_not_loaded)
721 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
722 if (bed->plt_readonly)
723 pltflags |= SEC_READONLY;
725 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
728 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
731 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
733 if (bed->want_plt_sym)
735 h = _bfd_elf_define_linkage_sym (abfd, info, s,
736 "_PROCEDURE_LINKAGE_TABLE_");
742 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
745 || ! bfd_set_section_alignment (abfd, s, ptralign))
748 if (bed->want_got_plt)
750 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
753 || ! bfd_set_section_alignment (abfd, s, ptralign))
757 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
758 (or .got.plt) section. We don't do this in the linker script
759 because we don't want to define the symbol if we are not creating
760 a global offset table. */
761 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
766 /* The first bit of the global offset table is the header. */
767 s->size += bed->got_header_size;
772 static reloc_howto_type *
773 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
774 bfd_reloc_code_real_type code)
778 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
779 if (mn10300_reloc_map[i].bfd_reloc_val == code)
780 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
785 static reloc_howto_type *
786 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
791 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
792 if (elf_mn10300_howto_table[i].name != NULL
793 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
794 return elf_mn10300_howto_table + i;
799 /* Set the howto pointer for an MN10300 ELF reloc. */
802 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
804 Elf_Internal_Rela *dst)
808 r_type = ELF32_R_TYPE (dst->r_info);
809 if (r_type >= R_MN10300_MAX)
811 _bfd_error_handler (_("%B: unrecognised MN10300 reloc number: %d"),
813 bfd_set_error (bfd_error_bad_value);
814 r_type = R_MN10300_NONE;
816 cache_ptr->howto = elf_mn10300_howto_table + r_type;
820 elf_mn10300_tls_transition (struct bfd_link_info * info,
822 struct elf_link_hash_entry * h,
824 bfd_boolean counting)
826 bfd_boolean is_local;
828 if (r_type == R_MN10300_TLS_GD
830 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
831 return R_MN10300_TLS_GOTIE;
833 if (bfd_link_pic (info))
836 if (! (sec->flags & SEC_CODE))
839 if (! counting && h != NULL && ! elf_hash_table (info)->dynamic_sections_created)
842 is_local = SYMBOL_CALLS_LOCAL (info, h);
844 /* For the main program, these are the transitions we do. */
847 case R_MN10300_TLS_GD: return is_local ? R_MN10300_TLS_LE : R_MN10300_TLS_GOTIE;
848 case R_MN10300_TLS_LD: return R_MN10300_NONE;
849 case R_MN10300_TLS_LDO: return R_MN10300_TLS_LE;
850 case R_MN10300_TLS_IE:
851 case R_MN10300_TLS_GOTIE: return is_local ? R_MN10300_TLS_LE : r_type;
857 /* Return the relocation value for @tpoff relocation
858 if STT_TLS virtual address is ADDRESS. */
861 dtpoff (struct bfd_link_info * info, bfd_vma address)
863 struct elf_link_hash_table *htab = elf_hash_table (info);
865 /* If tls_sec is NULL, we should have signalled an error already. */
866 if (htab->tls_sec == NULL)
868 return address - htab->tls_sec->vma;
871 /* Return the relocation value for @tpoff relocation
872 if STT_TLS virtual address is ADDRESS. */
875 tpoff (struct bfd_link_info * info, bfd_vma address)
877 struct elf_link_hash_table *htab = elf_hash_table (info);
879 /* If tls_sec is NULL, we should have signalled an error already. */
880 if (htab->tls_sec == NULL)
882 return address - (htab->tls_size + htab->tls_sec->vma);
885 /* Returns nonzero if there's a R_MN10300_PLT32 reloc that we now need
886 to skip, after this one. The actual value is the offset between
887 this reloc and the PLT reloc. */
890 mn10300_do_tls_transition (bfd * input_bfd,
892 unsigned int tls_r_type,
896 bfd_byte *op = contents + offset;
899 #define TLS_PAIR(r1,r2) ((r1) * R_MN10300_MAX + (r2))
901 /* This is common to all GD/LD transitions, so break it out. */
902 if (r_type == R_MN10300_TLS_GD
903 || r_type == R_MN10300_TLS_LD)
907 BFD_ASSERT (bfd_get_8 (input_bfd, op) == 0xFC);
908 BFD_ASSERT (bfd_get_8 (input_bfd, op + 1) == 0xCC);
910 BFD_ASSERT (bfd_get_8 (input_bfd, op + 6) == 0xF1);
911 gotreg = (bfd_get_8 (input_bfd, op + 7) & 0x0c) >> 2;
913 BFD_ASSERT (bfd_get_8 (input_bfd, op + 8) == 0xDD);
916 switch (TLS_PAIR (r_type, tls_r_type))
918 case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_GOTIE):
920 /* Keep track of which register we put GOTptr in. */
921 /* mov (_x@indntpoff,a2),a0. */
922 memcpy (op, "\xFC\x20\x00\x00\x00\x00", 6);
925 memcpy (op+6, "\xF9\x78\x28", 3);
926 /* or 0x00000000, d0 - six byte nop. */
927 memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6);
931 case TLS_PAIR (R_MN10300_TLS_GD, R_MN10300_TLS_LE):
933 /* Register is *always* a0. */
934 /* mov _x@tpoff,a0. */
935 memcpy (op, "\xFC\xDC\x00\x00\x00\x00", 6);
937 memcpy (op+6, "\xF9\x78\x28", 3);
938 /* or 0x00000000, d0 - six byte nop. */
939 memcpy (op+9, "\xFC\xE4\x00\x00\x00\x00", 6);
942 case TLS_PAIR (R_MN10300_TLS_LD, R_MN10300_NONE):
944 /* Register is *always* a0. */
946 memcpy (op, "\xF5\x88", 2);
947 /* or 0x00000000, d0 - six byte nop. */
948 memcpy (op+2, "\xFC\xE4\x00\x00\x00\x00", 6);
949 /* or 0x00000000, e2 - seven byte nop. */
950 memcpy (op+8, "\xFE\x19\x22\x00\x00\x00\x00", 7);
954 case TLS_PAIR (R_MN10300_TLS_LDO, R_MN10300_TLS_LE):
955 /* No changes needed, just the reloc change. */
958 /* These are a little tricky, because we have to detect which
959 opcode is being used (they're different sizes, with the reloc
960 at different offsets within the opcode) and convert each
961 accordingly, copying the operands as needed. The conversions
962 we do are as follows (IE,GOTIE,LE):
964 1111 1100 1010 01Dn [-- abs32 --] MOV (x@indntpoff),Dn
965 1111 1100 0000 DnAm [-- abs32 --] MOV (x@gotntpoff,Am),Dn
966 1111 1100 1100 11Dn [-- abs32 --] MOV x@tpoff,Dn
968 1111 1100 1010 00An [-- abs32 --] MOV (x@indntpoff),An
969 1111 1100 0010 AnAm [-- abs32 --] MOV (x@gotntpoff,Am),An
970 1111 1100 1101 11An [-- abs32 --] MOV x@tpoff,An
972 1111 1110 0000 1110 Rnnn Xxxx [-- abs32 --] MOV (x@indntpoff),Rn
973 1111 1110 0000 1010 Rnnn Rmmm [-- abs32 --] MOV (x@indntpoff,Rm),Rn
974 1111 1110 0000 1000 Rnnn Xxxx [-- abs32 --] MOV x@tpoff,Rn
976 Since the GOT pointer is always $a2, we assume the last
977 normally won't happen, but let's be paranoid and plan for the
978 day that GCC optimizes it somewhow. */
980 case TLS_PAIR (R_MN10300_TLS_IE, R_MN10300_TLS_LE):
984 if ((op[1] & 0xFC) == 0xA4) /* Dn */
986 op[1] &= 0x03; /* Leaves Dn. */
991 op[1] &= 0x03; /* Leaves An. */
995 else if (op[-3] == 0xFE)
1001 case TLS_PAIR (R_MN10300_TLS_GOTIE, R_MN10300_TLS_LE):
1005 if ((op[1] & 0xF0) == 0x00) /* Dn */
1007 op[1] &= 0x0C; /* Leaves Dn. */
1013 op[1] &= 0x0C; /* Leaves An. */
1018 else if (op[-3] == 0xFE)
1026 (_("%s: Unsupported transition from %s to %s"),
1027 bfd_get_filename (input_bfd),
1028 elf_mn10300_howto_table[r_type].name,
1029 elf_mn10300_howto_table[tls_r_type].name);
1036 /* Look through the relocs for a section during the first phase.
1037 Since we don't do .gots or .plts, we just need to consider the
1038 virtual table relocs for gc. */
1041 mn10300_elf_check_relocs (bfd *abfd,
1042 struct bfd_link_info *info,
1044 const Elf_Internal_Rela *relocs)
1046 struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
1047 bfd_boolean sym_diff_reloc_seen;
1048 Elf_Internal_Shdr *symtab_hdr;
1049 Elf_Internal_Sym * isymbuf = NULL;
1050 struct elf_link_hash_entry **sym_hashes;
1051 const Elf_Internal_Rela *rel;
1052 const Elf_Internal_Rela *rel_end;
1054 bfd_vma * local_got_offsets;
1058 bfd_boolean result = FALSE;
1064 if (bfd_link_relocatable (info))
1067 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1068 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1069 sym_hashes = elf_sym_hashes (abfd);
1071 dynobj = elf_hash_table (info)->dynobj;
1072 local_got_offsets = elf_local_got_offsets (abfd);
1073 rel_end = relocs + sec->reloc_count;
1074 sym_diff_reloc_seen = FALSE;
1076 for (rel = relocs; rel < rel_end; rel++)
1078 struct elf_link_hash_entry *h;
1079 unsigned long r_symndx;
1080 unsigned int r_type;
1081 int tls_type = GOT_NORMAL;
1083 r_symndx = ELF32_R_SYM (rel->r_info);
1084 if (r_symndx < symtab_hdr->sh_info)
1088 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1089 while (h->root.type == bfd_link_hash_indirect
1090 || h->root.type == bfd_link_hash_warning)
1091 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1093 /* PR15323, ref flags aren't set for references in the same
1095 h->root.non_ir_ref = 1;
1098 r_type = ELF32_R_TYPE (rel->r_info);
1099 r_type = elf_mn10300_tls_transition (info, r_type, h, sec, TRUE);
1101 /* Some relocs require a global offset table. */
1106 case R_MN10300_GOT32:
1107 case R_MN10300_GOT24:
1108 case R_MN10300_GOT16:
1109 case R_MN10300_GOTOFF32:
1110 case R_MN10300_GOTOFF24:
1111 case R_MN10300_GOTOFF16:
1112 case R_MN10300_GOTPC32:
1113 case R_MN10300_GOTPC16:
1114 case R_MN10300_TLS_GD:
1115 case R_MN10300_TLS_LD:
1116 case R_MN10300_TLS_GOTIE:
1117 case R_MN10300_TLS_IE:
1118 elf_hash_table (info)->dynobj = dynobj = abfd;
1119 if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
1130 /* This relocation describes the C++ object vtable hierarchy.
1131 Reconstruct it for later use during GC. */
1132 case R_MN10300_GNU_VTINHERIT:
1133 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1137 /* This relocation describes which C++ vtable entries are actually
1138 used. Record for later use during GC. */
1139 case R_MN10300_GNU_VTENTRY:
1140 BFD_ASSERT (h != NULL);
1142 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1146 case R_MN10300_TLS_LD:
1147 htab->tls_ldm_got.refcount ++;
1148 tls_type = GOT_TLS_LD;
1150 if (htab->tls_ldm_got.got_allocated)
1154 case R_MN10300_TLS_IE:
1155 case R_MN10300_TLS_GOTIE:
1156 if (bfd_link_pic (info))
1157 info->flags |= DF_STATIC_TLS;
1160 case R_MN10300_TLS_GD:
1161 case R_MN10300_GOT32:
1162 case R_MN10300_GOT24:
1163 case R_MN10300_GOT16:
1165 /* This symbol requires a global offset table entry. */
1169 case R_MN10300_TLS_IE:
1170 case R_MN10300_TLS_GOTIE: tls_type = GOT_TLS_IE; break;
1171 case R_MN10300_TLS_GD: tls_type = GOT_TLS_GD; break;
1172 default: tls_type = GOT_NORMAL; break;
1177 sgot = htab->root.sgot;
1178 BFD_ASSERT (sgot != NULL);
1182 && (h != NULL || bfd_link_pic (info)))
1184 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1185 if (srelgot == NULL)
1187 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1188 | SEC_IN_MEMORY | SEC_LINKER_CREATED
1190 srelgot = bfd_make_section_anyway_with_flags (dynobj,
1194 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
1199 if (r_type == R_MN10300_TLS_LD)
1201 htab->tls_ldm_got.offset = sgot->size;
1202 htab->tls_ldm_got.got_allocated ++;
1206 if (elf_mn10300_hash_entry (h)->tls_type != tls_type
1207 && elf_mn10300_hash_entry (h)->tls_type != GOT_UNKNOWN)
1209 if (tls_type == GOT_TLS_IE
1210 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_GD)
1211 /* No change - this is ok. */;
1212 else if (tls_type == GOT_TLS_GD
1213 && elf_mn10300_hash_entry (h)->tls_type == GOT_TLS_IE)
1214 /* Transition GD->IE. */
1215 tls_type = GOT_TLS_IE;
1218 (_("%B: %s' accessed both as normal and thread local symbol"),
1219 abfd, h ? h->root.root.string : "<local>");
1222 elf_mn10300_hash_entry (h)->tls_type = tls_type;
1224 if (h->got.offset != (bfd_vma) -1)
1225 /* We have already allocated space in the .got. */
1228 h->got.offset = sgot->size;
1230 if (ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1231 /* Make sure this symbol is output as a dynamic symbol. */
1232 && h->dynindx == -1)
1234 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1238 srelgot->size += sizeof (Elf32_External_Rela);
1239 if (r_type == R_MN10300_TLS_GD)
1240 srelgot->size += sizeof (Elf32_External_Rela);
1244 /* This is a global offset table entry for a local
1246 if (local_got_offsets == NULL)
1251 size = symtab_hdr->sh_info * (sizeof (bfd_vma) + sizeof (char));
1252 local_got_offsets = bfd_alloc (abfd, size);
1254 if (local_got_offsets == NULL)
1257 elf_local_got_offsets (abfd) = local_got_offsets;
1258 elf_mn10300_local_got_tls_type (abfd)
1259 = (char *) (local_got_offsets + symtab_hdr->sh_info);
1261 for (i = 0; i < symtab_hdr->sh_info; i++)
1262 local_got_offsets[i] = (bfd_vma) -1;
1265 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
1266 /* We have already allocated space in the .got. */
1269 local_got_offsets[r_symndx] = sgot->size;
1271 if (bfd_link_pic (info))
1273 /* If we are generating a shared object, we need to
1274 output a R_MN10300_RELATIVE reloc so that the dynamic
1275 linker can adjust this GOT entry. */
1276 srelgot->size += sizeof (Elf32_External_Rela);
1278 if (r_type == R_MN10300_TLS_GD)
1279 /* And a R_MN10300_TLS_DTPOFF reloc as well. */
1280 srelgot->size += sizeof (Elf32_External_Rela);
1283 elf_mn10300_local_got_tls_type (abfd) [r_symndx] = tls_type;
1287 if (r_type == R_MN10300_TLS_GD
1288 || r_type == R_MN10300_TLS_LD)
1291 goto need_shared_relocs;
1293 case R_MN10300_PLT32:
1294 case R_MN10300_PLT16:
1295 /* This symbol requires a procedure linkage table entry. We
1296 actually build the entry in adjust_dynamic_symbol,
1297 because this might be a case of linking PIC code which is
1298 never referenced by a dynamic object, in which case we
1299 don't need to generate a procedure linkage table entry
1302 /* If this is a local symbol, we resolve it directly without
1303 creating a procedure linkage table entry. */
1307 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
1308 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
1317 case R_MN10300_PCREL32:
1318 case R_MN10300_PCREL16:
1319 case R_MN10300_PCREL8:
1324 case R_MN10300_SYM_DIFF:
1325 sym_diff_reloc_seen = TRUE;
1333 /* If we are creating a shared library, then we
1334 need to copy the reloc into the shared library. */
1335 if (bfd_link_pic (info)
1336 && (sec->flags & SEC_ALLOC) != 0
1337 /* Do not generate a dynamic reloc for a
1338 reloc associated with a SYM_DIFF operation. */
1339 && ! sym_diff_reloc_seen)
1341 asection * sym_section = NULL;
1343 /* Find the section containing the
1344 symbol involved in the relocation. */
1347 Elf_Internal_Sym * isym;
1349 if (isymbuf == NULL)
1350 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1351 symtab_hdr->sh_info, 0,
1355 isym = isymbuf + r_symndx;
1356 /* All we care about is whether this local symbol is absolute. */
1357 if (isym->st_shndx == SHN_ABS)
1358 sym_section = bfd_abs_section_ptr;
1363 if (h->root.type == bfd_link_hash_defined
1364 || h->root.type == bfd_link_hash_defweak)
1365 sym_section = h->root.u.def.section;
1368 /* If the symbol is absolute then the relocation can
1369 be resolved during linking and there is no need for
1371 if (sym_section != bfd_abs_section_ptr)
1373 /* When creating a shared object, we must copy these
1374 reloc types into the output file. We create a reloc
1375 section in dynobj and make room for this reloc. */
1378 sreloc = _bfd_elf_make_dynamic_reloc_section
1379 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
1384 sreloc->size += sizeof (Elf32_External_Rela);
1391 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
1392 sym_diff_reloc_seen = FALSE;
1397 if (isymbuf != NULL)
1403 /* Return the section that should be marked against GC for a given
1407 mn10300_elf_gc_mark_hook (asection *sec,
1408 struct bfd_link_info *info,
1409 Elf_Internal_Rela *rel,
1410 struct elf_link_hash_entry *h,
1411 Elf_Internal_Sym *sym)
1414 switch (ELF32_R_TYPE (rel->r_info))
1416 case R_MN10300_GNU_VTINHERIT:
1417 case R_MN10300_GNU_VTENTRY:
1421 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1424 /* Perform a relocation as part of a final link. */
1426 static bfd_reloc_status_type
1427 mn10300_elf_final_link_relocate (reloc_howto_type *howto,
1429 bfd *output_bfd ATTRIBUTE_UNUSED,
1430 asection *input_section,
1435 struct elf_link_hash_entry * h,
1436 unsigned long symndx,
1437 struct bfd_link_info *info,
1438 asection *sym_sec ATTRIBUTE_UNUSED,
1439 int is_local ATTRIBUTE_UNUSED)
1441 struct elf32_mn10300_link_hash_table * htab = elf32_mn10300_hash_table (info);
1442 static asection * sym_diff_section;
1443 static bfd_vma sym_diff_value;
1444 bfd_boolean is_sym_diff_reloc;
1445 unsigned long r_type = howto->type;
1446 bfd_byte * hit_data = contents + offset;
1452 dynobj = elf_hash_table (info)->dynobj;
1462 case R_MN10300_PCREL8:
1463 case R_MN10300_PCREL16:
1464 case R_MN10300_PCREL32:
1465 case R_MN10300_GOTOFF32:
1466 case R_MN10300_GOTOFF24:
1467 case R_MN10300_GOTOFF16:
1468 if (bfd_link_pic (info)
1469 && (input_section->flags & SEC_ALLOC) != 0
1471 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1472 return bfd_reloc_dangerous;
1474 case R_MN10300_GOT32:
1476 Taking the address of a protected function in a shared library
1477 is illegal. Issue an error message here. */
1478 if (bfd_link_pic (info)
1479 && (input_section->flags & SEC_ALLOC) != 0
1481 && ELF_ST_VISIBILITY (h->other) == STV_PROTECTED
1482 && (h->type == STT_FUNC || h->type == STT_GNU_IFUNC)
1483 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1484 return bfd_reloc_dangerous;
1487 is_sym_diff_reloc = FALSE;
1488 if (sym_diff_section != NULL)
1490 BFD_ASSERT (sym_diff_section == input_section);
1498 value -= sym_diff_value;
1499 /* If we are computing a 32-bit value for the location lists
1500 and the result is 0 then we add one to the value. A zero
1501 value can result because of linker relaxation deleteing
1502 prologue instructions and using a value of 1 (for the begin
1503 and end offsets in the location list entry) results in a
1504 nul entry which does not prevent the following entries from
1506 if (r_type == R_MN10300_32
1508 && strcmp (input_section->name, ".debug_loc") == 0)
1510 sym_diff_section = NULL;
1511 is_sym_diff_reloc = TRUE;
1515 sym_diff_section = NULL;
1522 case R_MN10300_SYM_DIFF:
1523 BFD_ASSERT (addend == 0);
1524 /* Cache the input section and value.
1525 The offset is unreliable, since relaxation may
1526 have reduced the following reloc's offset. */
1527 sym_diff_section = input_section;
1528 sym_diff_value = value;
1529 return bfd_reloc_ok;
1531 case R_MN10300_ALIGN:
1532 case R_MN10300_NONE:
1533 return bfd_reloc_ok;
1536 if (bfd_link_pic (info)
1537 /* Do not generate relocs when an R_MN10300_32 has been used
1538 with an R_MN10300_SYM_DIFF to compute a difference of two
1540 && is_sym_diff_reloc == FALSE
1541 /* Also, do not generate a reloc when the symbol associated
1542 with the R_MN10300_32 reloc is absolute - there is no
1543 need for a run time computation in this case. */
1544 && sym_sec != bfd_abs_section_ptr
1545 /* If the section is not going to be allocated at load time
1546 then there is no need to generate relocs for it. */
1547 && (input_section->flags & SEC_ALLOC) != 0)
1549 Elf_Internal_Rela outrel;
1550 bfd_boolean skip, relocate;
1552 /* When generating a shared object, these relocations are
1553 copied into the output file to be resolved at run
1557 sreloc = _bfd_elf_get_dynamic_reloc_section
1558 (input_bfd, input_section, /*rela?*/ TRUE);
1565 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1566 input_section, offset);
1567 if (outrel.r_offset == (bfd_vma) -1)
1570 outrel.r_offset += (input_section->output_section->vma
1571 + input_section->output_offset);
1575 memset (&outrel, 0, sizeof outrel);
1580 /* h->dynindx may be -1 if this symbol was marked to
1583 || SYMBOL_REFERENCES_LOCAL (info, h))
1586 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1587 outrel.r_addend = value + addend;
1591 BFD_ASSERT (h->dynindx != -1);
1593 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1594 outrel.r_addend = value + addend;
1598 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1599 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1600 + sreloc->reloc_count));
1601 ++sreloc->reloc_count;
1603 /* If this reloc is against an external symbol, we do
1604 not want to fiddle with the addend. Otherwise, we
1605 need to include the symbol value so that it becomes
1606 an addend for the dynamic reloc. */
1608 return bfd_reloc_ok;
1611 bfd_put_32 (input_bfd, value, hit_data);
1612 return bfd_reloc_ok;
1617 if ((long) value > 0x7fffff || (long) value < -0x800000)
1618 return bfd_reloc_overflow;
1620 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1621 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1622 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1623 return bfd_reloc_ok;
1628 if ((long) value > 0x7fff || (long) value < -0x8000)
1629 return bfd_reloc_overflow;
1631 bfd_put_16 (input_bfd, value, hit_data);
1632 return bfd_reloc_ok;
1637 if ((long) value > 0x7f || (long) value < -0x80)
1638 return bfd_reloc_overflow;
1640 bfd_put_8 (input_bfd, value, hit_data);
1641 return bfd_reloc_ok;
1643 case R_MN10300_PCREL8:
1644 value -= (input_section->output_section->vma
1645 + input_section->output_offset);
1649 if ((long) value > 0x7f || (long) value < -0x80)
1650 return bfd_reloc_overflow;
1652 bfd_put_8 (input_bfd, value, hit_data);
1653 return bfd_reloc_ok;
1655 case R_MN10300_PCREL16:
1656 value -= (input_section->output_section->vma
1657 + input_section->output_offset);
1661 if ((long) value > 0x7fff || (long) value < -0x8000)
1662 return bfd_reloc_overflow;
1664 bfd_put_16 (input_bfd, value, hit_data);
1665 return bfd_reloc_ok;
1667 case R_MN10300_PCREL32:
1668 value -= (input_section->output_section->vma
1669 + input_section->output_offset);
1673 bfd_put_32 (input_bfd, value, hit_data);
1674 return bfd_reloc_ok;
1676 case R_MN10300_GNU_VTINHERIT:
1677 case R_MN10300_GNU_VTENTRY:
1678 return bfd_reloc_ok;
1680 case R_MN10300_GOTPC32:
1682 return bfd_reloc_dangerous;
1684 /* Use global offset table as symbol value. */
1685 value = htab->root.sgot->output_section->vma;
1686 value -= (input_section->output_section->vma
1687 + input_section->output_offset);
1691 bfd_put_32 (input_bfd, value, hit_data);
1692 return bfd_reloc_ok;
1694 case R_MN10300_GOTPC16:
1696 return bfd_reloc_dangerous;
1698 /* Use global offset table as symbol value. */
1699 value = htab->root.sgot->output_section->vma;
1700 value -= (input_section->output_section->vma
1701 + input_section->output_offset);
1705 if ((long) value > 0x7fff || (long) value < -0x8000)
1706 return bfd_reloc_overflow;
1708 bfd_put_16 (input_bfd, value, hit_data);
1709 return bfd_reloc_ok;
1711 case R_MN10300_GOTOFF32:
1713 return bfd_reloc_dangerous;
1715 value -= htab->root.sgot->output_section->vma;
1718 bfd_put_32 (input_bfd, value, hit_data);
1719 return bfd_reloc_ok;
1721 case R_MN10300_GOTOFF24:
1723 return bfd_reloc_dangerous;
1725 value -= htab->root.sgot->output_section->vma;
1728 if ((long) value > 0x7fffff || (long) value < -0x800000)
1729 return bfd_reloc_overflow;
1731 bfd_put_8 (input_bfd, value, hit_data);
1732 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1733 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1734 return bfd_reloc_ok;
1736 case R_MN10300_GOTOFF16:
1738 return bfd_reloc_dangerous;
1740 value -= htab->root.sgot->output_section->vma;
1743 if ((long) value > 0x7fff || (long) value < -0x8000)
1744 return bfd_reloc_overflow;
1746 bfd_put_16 (input_bfd, value, hit_data);
1747 return bfd_reloc_ok;
1749 case R_MN10300_PLT32:
1751 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1752 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1753 && h->plt.offset != (bfd_vma) -1)
1756 return bfd_reloc_dangerous;
1758 splt = htab->root.splt;
1759 value = (splt->output_section->vma
1760 + splt->output_offset
1761 + h->plt.offset) - value;
1764 value -= (input_section->output_section->vma
1765 + input_section->output_offset);
1769 bfd_put_32 (input_bfd, value, hit_data);
1770 return bfd_reloc_ok;
1772 case R_MN10300_PLT16:
1774 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1775 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1776 && h->plt.offset != (bfd_vma) -1)
1779 return bfd_reloc_dangerous;
1781 splt = htab->root.splt;
1782 value = (splt->output_section->vma
1783 + splt->output_offset
1784 + h->plt.offset) - value;
1787 value -= (input_section->output_section->vma
1788 + input_section->output_offset);
1792 if ((long) value > 0x7fff || (long) value < -0x8000)
1793 return bfd_reloc_overflow;
1795 bfd_put_16 (input_bfd, value, hit_data);
1796 return bfd_reloc_ok;
1798 case R_MN10300_TLS_LDO:
1799 value = dtpoff (info, value);
1800 bfd_put_32 (input_bfd, value + addend, hit_data);
1801 return bfd_reloc_ok;
1803 case R_MN10300_TLS_LE:
1804 value = tpoff (info, value);
1805 bfd_put_32 (input_bfd, value + addend, hit_data);
1806 return bfd_reloc_ok;
1808 case R_MN10300_TLS_LD:
1810 return bfd_reloc_dangerous;
1812 sgot = htab->root.sgot;
1813 BFD_ASSERT (sgot != NULL);
1814 value = htab->tls_ldm_got.offset + sgot->output_offset;
1815 bfd_put_32 (input_bfd, value, hit_data);
1817 if (!htab->tls_ldm_got.rel_emitted)
1819 asection * srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1820 Elf_Internal_Rela rel;
1822 BFD_ASSERT (srelgot != NULL);
1823 htab->tls_ldm_got.rel_emitted ++;
1824 rel.r_offset = (sgot->output_section->vma
1825 + sgot->output_offset
1826 + htab->tls_ldm_got.offset);
1827 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset);
1828 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + htab->tls_ldm_got.offset+4);
1829 rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD);
1831 bfd_elf32_swap_reloca_out (output_bfd, & rel,
1832 (bfd_byte *) ((Elf32_External_Rela *) srelgot->contents
1833 + srelgot->reloc_count));
1834 ++ srelgot->reloc_count;
1837 return bfd_reloc_ok;
1839 case R_MN10300_TLS_GOTIE:
1840 value = tpoff (info, value);
1843 case R_MN10300_TLS_GD:
1844 case R_MN10300_TLS_IE:
1845 case R_MN10300_GOT32:
1846 case R_MN10300_GOT24:
1847 case R_MN10300_GOT16:
1849 return bfd_reloc_dangerous;
1851 sgot = htab->root.sgot;
1852 if (r_type == R_MN10300_TLS_GD)
1853 value = dtpoff (info, value);
1859 off = h->got.offset;
1860 /* Offsets in the GOT are allocated in check_relocs
1861 which is not called for shared libraries... */
1862 if (off == (bfd_vma) -1)
1865 if (sgot->contents != NULL
1866 && (! elf_hash_table (info)->dynamic_sections_created
1867 || SYMBOL_REFERENCES_LOCAL (info, h)))
1868 /* This is actually a static link, or it is a
1869 -Bsymbolic link and the symbol is defined
1870 locally, or the symbol was forced to be local
1871 because of a version file. We must initialize
1872 this entry in the global offset table.
1874 When doing a dynamic link, we create a .rela.got
1875 relocation entry to initialize the value. This
1876 is done in the finish_dynamic_symbol routine. */
1877 bfd_put_32 (output_bfd, value,
1878 sgot->contents + off);
1880 value = sgot->output_offset + off;
1886 off = elf_local_got_offsets (input_bfd)[symndx];
1889 bfd_put_32 (output_bfd, value, sgot->contents + (off & ~ 1));
1892 bfd_put_32 (output_bfd, value, sgot->contents + off);
1894 if (bfd_link_pic (info))
1897 Elf_Internal_Rela outrel;
1899 srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1900 BFD_ASSERT (srelgot != NULL);
1902 outrel.r_offset = (sgot->output_section->vma
1903 + sgot->output_offset
1907 case R_MN10300_TLS_GD:
1908 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPOFF);
1909 outrel.r_offset = (sgot->output_section->vma
1910 + sgot->output_offset
1912 bfd_elf32_swap_reloca_out (output_bfd, & outrel,
1913 (bfd_byte *) (((Elf32_External_Rela *)
1915 + srelgot->reloc_count));
1916 ++ srelgot->reloc_count;
1917 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_DTPMOD);
1919 case R_MN10300_TLS_GOTIE:
1920 case R_MN10300_TLS_IE:
1921 outrel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF);
1924 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1928 outrel.r_addend = value;
1929 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1930 (bfd_byte *) (((Elf32_External_Rela *)
1932 + srelgot->reloc_count));
1933 ++ srelgot->reloc_count;
1934 elf_local_got_offsets (input_bfd)[symndx] |= 1;
1937 value = sgot->output_offset + (off & ~(bfd_vma) 1);
1943 if (r_type == R_MN10300_TLS_IE)
1945 value += sgot->output_section->vma;
1946 bfd_put_32 (input_bfd, value, hit_data);
1947 return bfd_reloc_ok;
1949 else if (r_type == R_MN10300_TLS_GOTIE
1950 || r_type == R_MN10300_TLS_GD
1951 || r_type == R_MN10300_TLS_LD)
1953 bfd_put_32 (input_bfd, value, hit_data);
1954 return bfd_reloc_ok;
1956 else if (r_type == R_MN10300_GOT32)
1958 bfd_put_32 (input_bfd, value, hit_data);
1959 return bfd_reloc_ok;
1961 else if (r_type == R_MN10300_GOT24)
1963 if ((long) value > 0x7fffff || (long) value < -0x800000)
1964 return bfd_reloc_overflow;
1966 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1967 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1968 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1969 return bfd_reloc_ok;
1971 else if (r_type == R_MN10300_GOT16)
1973 if ((long) value > 0x7fff || (long) value < -0x8000)
1974 return bfd_reloc_overflow;
1976 bfd_put_16 (input_bfd, value, hit_data);
1977 return bfd_reloc_ok;
1982 return bfd_reloc_notsupported;
1986 /* Relocate an MN10300 ELF section. */
1989 mn10300_elf_relocate_section (bfd *output_bfd,
1990 struct bfd_link_info *info,
1992 asection *input_section,
1994 Elf_Internal_Rela *relocs,
1995 Elf_Internal_Sym *local_syms,
1996 asection **local_sections)
1998 Elf_Internal_Shdr *symtab_hdr;
1999 struct elf_link_hash_entry **sym_hashes;
2000 Elf_Internal_Rela *rel, *relend;
2001 Elf_Internal_Rela * trel;
2003 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2004 sym_hashes = elf_sym_hashes (input_bfd);
2007 relend = relocs + input_section->reloc_count;
2008 for (; rel < relend; rel++)
2011 reloc_howto_type *howto;
2012 unsigned long r_symndx;
2013 Elf_Internal_Sym *sym;
2015 struct elf32_mn10300_link_hash_entry *h;
2017 bfd_reloc_status_type r;
2019 bfd_boolean unresolved_reloc = FALSE;
2020 bfd_boolean warned, ignored;
2021 struct elf_link_hash_entry * hh;
2024 r_symndx = ELF32_R_SYM (rel->r_info);
2025 r_type = ELF32_R_TYPE (rel->r_info);
2026 howto = elf_mn10300_howto_table + r_type;
2028 /* Just skip the vtable gc relocs. */
2029 if (r_type == R_MN10300_GNU_VTINHERIT
2030 || r_type == R_MN10300_GNU_VTENTRY)
2036 if (r_symndx < symtab_hdr->sh_info)
2040 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2041 r_symndx, symtab_hdr, sym_hashes,
2042 hh, sec, relocation,
2043 unresolved_reloc, warned, ignored);
2045 h = elf_mn10300_hash_entry (hh);
2047 tls_r_type = elf_mn10300_tls_transition (info, r_type, hh, input_section, 0);
2048 if (tls_r_type != r_type)
2050 bfd_boolean had_plt;
2052 had_plt = mn10300_do_tls_transition (input_bfd, r_type, tls_r_type,
2053 contents, rel->r_offset);
2054 r_type = tls_r_type;
2055 howto = elf_mn10300_howto_table + r_type;
2058 for (trel = rel+1; trel < relend; trel++)
2059 if ((ELF32_R_TYPE (trel->r_info) == R_MN10300_PLT32
2060 || ELF32_R_TYPE (trel->r_info) == R_MN10300_PCREL32)
2061 && rel->r_offset + had_plt == trel->r_offset)
2062 trel->r_info = ELF32_R_INFO (0, R_MN10300_NONE);
2065 if (r_symndx < symtab_hdr->sh_info)
2067 sym = local_syms + r_symndx;
2068 sec = local_sections[r_symndx];
2069 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2073 if ((h->root.root.type == bfd_link_hash_defined
2074 || h->root.root.type == bfd_link_hash_defweak)
2075 && ( r_type == R_MN10300_GOTPC32
2076 || r_type == R_MN10300_GOTPC16
2077 || (( r_type == R_MN10300_PLT32
2078 || r_type == R_MN10300_PLT16)
2079 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2080 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2081 && h->root.plt.offset != (bfd_vma) -1)
2082 || (( r_type == R_MN10300_GOT32
2083 || r_type == R_MN10300_GOT24
2084 || r_type == R_MN10300_TLS_GD
2085 || r_type == R_MN10300_TLS_LD
2086 || r_type == R_MN10300_TLS_GOTIE
2087 || r_type == R_MN10300_TLS_IE
2088 || r_type == R_MN10300_GOT16)
2089 && elf_hash_table (info)->dynamic_sections_created
2090 && !SYMBOL_REFERENCES_LOCAL (info, hh))
2091 || (r_type == R_MN10300_32
2092 /* _32 relocs in executables force _COPY relocs,
2093 such that the address of the symbol ends up
2095 && !bfd_link_executable (info)
2096 && !SYMBOL_REFERENCES_LOCAL (info, hh)
2097 && ((input_section->flags & SEC_ALLOC) != 0
2098 /* DWARF will emit R_MN10300_32 relocations
2099 in its sections against symbols defined
2100 externally in shared libraries. We can't
2101 do anything with them here. */
2102 || ((input_section->flags & SEC_DEBUGGING) != 0
2103 && h->root.def_dynamic)))))
2104 /* In these cases, we don't need the relocation
2105 value. We check specially because in some
2106 obscure cases sec->output_section will be NULL. */
2109 else if (!bfd_link_relocatable (info) && unresolved_reloc
2110 && _bfd_elf_section_offset (output_bfd, info, input_section,
2111 rel->r_offset) != (bfd_vma) -1)
2114 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2117 (long) rel->r_offset,
2119 h->root.root.root.string);
2122 if (sec != NULL && discarded_section (sec))
2123 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2124 rel, 1, relend, howto, 0, contents);
2126 if (bfd_link_relocatable (info))
2129 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
2131 contents, rel->r_offset,
2132 relocation, rel->r_addend,
2133 (struct elf_link_hash_entry *) h,
2135 info, sec, h == NULL);
2137 if (r != bfd_reloc_ok)
2140 const char *msg = NULL;
2143 name = h->root.root.root.string;
2146 name = (bfd_elf_string_from_elf_section
2147 (input_bfd, symtab_hdr->sh_link, sym->st_name));
2148 if (name == NULL || *name == '\0')
2149 name = bfd_section_name (input_bfd, sec);
2154 case bfd_reloc_overflow:
2155 (*info->callbacks->reloc_overflow)
2156 (info, (h ? &h->root.root : NULL), name, howto->name,
2157 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2160 case bfd_reloc_undefined:
2161 (*info->callbacks->undefined_symbol)
2162 (info, name, input_bfd, input_section, 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 (bfd_link_relocatable (link_info))
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 (bfd_link_relocatable (link_info)
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 = hash_table->root.splt;
3490 value = ((splt->output_section->vma
3491 + splt->output_offset
3492 + h->root.plt.offset)
3493 - (sec->output_section->vma
3494 + sec->output_offset
3498 /* If we've got a "call" instruction that needs to be turned
3499 into a "calls" instruction, do so now. It saves a byte. */
3500 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3504 /* Get the opcode. */
3505 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3507 /* Make sure we're working with a "call" instruction! */
3510 /* Note that we've changed the relocs, section contents,
3512 elf_section_data (sec)->relocs = internal_relocs;
3513 elf_section_data (sec)->this_hdr.contents = contents;
3514 symtab_hdr->contents = (unsigned char *) isymbuf;
3516 /* Fix the opcode. */
3517 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
3518 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3520 /* Fix irel->r_offset and irel->r_addend. */
3521 irel->r_offset += 1;
3522 irel->r_addend += 1;
3524 /* Delete one byte of data. */
3525 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3526 irel->r_offset + 3, 1))
3529 /* That will change things, so, we should relax again.
3530 Note that this is not required, and it may be slow. */
3536 /* We've got a "call" instruction which needs some data
3537 from target function filled in. */
3540 /* Get the opcode. */
3541 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3543 /* Insert data from the target function into the "call"
3544 instruction if needed. */
3547 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
3548 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3549 contents + irel->r_offset + 5);
3553 /* Deal with pc-relative gunk. */
3554 value -= (sec->output_section->vma + sec->output_offset);
3555 value -= irel->r_offset;
3556 value += irel->r_addend;
3558 /* See if the value will fit in 16 bits, note the high value is
3559 0x7fff + 2 as the target will be two bytes closer if we are
3560 able to relax, if it's in the same section. */
3561 if (sec->output_section == sym_sec->output_section)
3562 jump_offset = 0x8001;
3564 jump_offset = 0x7fff;
3566 /* Account for jumps across alignment boundaries using
3567 align_gap_adjustment. */
3568 if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
3569 && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
3573 /* Get the opcode. */
3574 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3576 if (code != 0xdc && code != 0xdd && code != 0xff)
3579 /* Note that we've changed the relocs, section contents, etc. */
3580 elf_section_data (sec)->relocs = internal_relocs;
3581 elf_section_data (sec)->this_hdr.contents = contents;
3582 symtab_hdr->contents = (unsigned char *) isymbuf;
3584 /* Fix the opcode. */
3586 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
3587 else if (code == 0xdd)
3588 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
3589 else if (code == 0xff)
3590 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3592 /* Fix the relocation's type. */
3593 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3594 (ELF32_R_TYPE (irel->r_info)
3595 == (int) R_MN10300_PLT32)
3599 /* Delete two bytes of data. */
3600 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3601 irel->r_offset + 1, 2))
3604 /* That will change things, so, we should relax again.
3605 Note that this is not required, and it may be slow. */
3610 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
3612 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
3614 bfd_vma value = symval;
3616 /* If we've got a "call" instruction that needs to be turned
3617 into a "calls" instruction, do so now. It saves a byte. */
3618 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3622 /* Get the opcode. */
3623 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3625 /* Make sure we're working with a "call" instruction! */
3628 /* Note that we've changed the relocs, section contents,
3630 elf_section_data (sec)->relocs = internal_relocs;
3631 elf_section_data (sec)->this_hdr.contents = contents;
3632 symtab_hdr->contents = (unsigned char *) isymbuf;
3634 /* Fix the opcode. */
3635 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3636 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3638 /* Fix irel->r_offset and irel->r_addend. */
3639 irel->r_offset += 1;
3640 irel->r_addend += 1;
3642 /* Delete one byte of data. */
3643 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3644 irel->r_offset + 1, 1))
3647 /* That will change things, so, we should relax again.
3648 Note that this is not required, and it may be slow. */
3656 /* Get the opcode. */
3657 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3659 /* Insert data from the target function into the "call"
3660 instruction if needed. */
3663 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3664 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3665 contents + irel->r_offset + 3);
3669 /* Deal with pc-relative gunk. */
3670 value -= (sec->output_section->vma + sec->output_offset);
3671 value -= irel->r_offset;
3672 value += irel->r_addend;
3674 /* See if the value will fit in 8 bits, note the high value is
3675 0x7f + 1 as the target will be one bytes closer if we are
3677 if ((long) value < 0x80 && (long) value > -0x80)
3681 /* Get the opcode. */
3682 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3687 /* Note that we've changed the relocs, section contents, etc. */
3688 elf_section_data (sec)->relocs = internal_relocs;
3689 elf_section_data (sec)->this_hdr.contents = contents;
3690 symtab_hdr->contents = (unsigned char *) isymbuf;
3692 /* Fix the opcode. */
3693 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3695 /* Fix the relocation's type. */
3696 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3699 /* Delete one byte of data. */
3700 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3701 irel->r_offset + 1, 1))
3704 /* That will change things, so, we should relax again.
3705 Note that this is not required, and it may be slow. */
3710 /* Try to eliminate an unconditional 8 bit pc-relative branch
3711 which immediately follows a conditional 8 bit pc-relative
3712 branch around the unconditional branch.
3719 This happens when the bCC can't reach lab2 at assembly time,
3720 but due to other relaxations it can reach at link time. */
3721 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3723 Elf_Internal_Rela *nrel;
3724 bfd_vma value = symval;
3727 /* Deal with pc-relative gunk. */
3728 value -= (sec->output_section->vma + sec->output_offset);
3729 value -= irel->r_offset;
3730 value += irel->r_addend;
3732 /* Do nothing if this reloc is the last byte in the section. */
3733 if (irel->r_offset == sec->size)
3736 /* See if the next instruction is an unconditional pc-relative
3737 branch, more often than not this test will fail, so we
3738 test it first to speed things up. */
3739 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3743 /* Also make sure the next relocation applies to the next
3744 instruction and that it's a pc-relative 8 bit branch. */
3747 || irel->r_offset + 2 != nrel->r_offset
3748 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3751 /* Make sure our destination immediately follows the
3752 unconditional branch. */
3753 if (symval != (sec->output_section->vma + sec->output_offset
3754 + irel->r_offset + 3))
3757 /* Now make sure we are a conditional branch. This may not
3758 be necessary, but why take the chance.
3760 Note these checks assume that R_MN10300_PCREL8 relocs
3761 only occur on bCC and bCCx insns. If they occured
3762 elsewhere, we'd need to know the start of this insn
3763 for this check to be accurate. */
3764 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3765 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3766 && code != 0xc3 && code != 0xc4 && code != 0xc5
3767 && code != 0xc6 && code != 0xc7 && code != 0xc8
3768 && code != 0xc9 && code != 0xe8 && code != 0xe9
3769 && code != 0xea && code != 0xeb)
3772 /* We also have to be sure there is no symbol/label
3773 at the unconditional branch. */
3774 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3775 irel->r_offset + 1))
3778 /* Note that we've changed the relocs, section contents, etc. */
3779 elf_section_data (sec)->relocs = internal_relocs;
3780 elf_section_data (sec)->this_hdr.contents = contents;
3781 symtab_hdr->contents = (unsigned char *) isymbuf;
3783 /* Reverse the condition of the first branch. */
3829 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3831 /* Set the reloc type and symbol for the first branch
3832 from the second branch. */
3833 irel->r_info = nrel->r_info;
3835 /* Make the reloc for the second branch a null reloc. */
3836 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3839 /* Delete two bytes of data. */
3840 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3841 irel->r_offset + 1, 2))
3844 /* That will change things, so, we should relax again.
3845 Note that this is not required, and it may be slow. */
3849 /* Try to turn a 24 immediate, displacement or absolute address
3850 into a 8 immediate, displacement or absolute address. */
3851 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3853 bfd_vma value = symval;
3854 value += irel->r_addend;
3856 /* See if the value will fit in 8 bits. */
3857 if ((long) value < 0x7f && (long) value > -0x80)
3861 /* AM33 insns which have 24 operands are 6 bytes long and
3862 will have 0xfd as the first byte. */
3864 /* Get the first opcode. */
3865 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3869 /* Get the second opcode. */
3870 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3872 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3873 equivalent instructions exists. */
3874 if (code != 0x6b && code != 0x7b
3875 && code != 0x8b && code != 0x9b
3876 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3877 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3878 || (code & 0x0f) == 0x0e))
3880 /* Not safe if the high bit is on as relaxing may
3881 move the value out of high mem and thus not fit
3882 in a signed 8bit value. This is currently over
3884 if ((value & 0x80) == 0)
3886 /* Note that we've changed the relocation contents,
3888 elf_section_data (sec)->relocs = internal_relocs;
3889 elf_section_data (sec)->this_hdr.contents = contents;
3890 symtab_hdr->contents = (unsigned char *) isymbuf;
3892 /* Fix the opcode. */
3893 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3894 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3896 /* Fix the relocation's type. */
3898 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3901 /* Delete two bytes of data. */
3902 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3903 irel->r_offset + 1, 2))
3906 /* That will change things, so, we should relax
3907 again. Note that this is not required, and it
3917 /* Try to turn a 32bit immediate, displacement or absolute address
3918 into a 16bit immediate, displacement or absolute address. */
3919 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3920 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3921 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3923 bfd_vma value = symval;
3925 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3929 sgot = hash_table->root.sgot;
3930 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3932 value = sgot->output_offset;
3935 value += h->root.got.offset;
3937 value += (elf_local_got_offsets
3938 (abfd)[ELF32_R_SYM (irel->r_info)]);
3940 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3941 value -= sgot->output_section->vma;
3942 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3943 value = (sgot->output_section->vma
3944 - (sec->output_section->vma
3945 + sec->output_offset
3951 value += irel->r_addend;
3953 /* See if the value will fit in 24 bits.
3954 We allow any 16bit match here. We prune those we can't
3956 if ((long) value < 0x7fffff && (long) value > -0x800000)
3960 /* AM33 insns which have 32bit operands are 7 bytes long and
3961 will have 0xfe as the first byte. */
3963 /* Get the first opcode. */
3964 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3968 /* Get the second opcode. */
3969 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3971 /* All the am33 32 -> 24 relaxing possibilities. */
3972 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3973 equivalent instructions exists. */
3974 if (code != 0x6b && code != 0x7b
3975 && code != 0x8b && code != 0x9b
3976 && (ELF32_R_TYPE (irel->r_info)
3977 != (int) R_MN10300_GOTPC32)
3978 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3979 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3980 || (code & 0x0f) == 0x0e))
3982 /* Not safe if the high bit is on as relaxing may
3983 move the value out of high mem and thus not fit
3984 in a signed 16bit value. This is currently over
3986 if ((value & 0x8000) == 0)
3988 /* Note that we've changed the relocation contents,
3990 elf_section_data (sec)->relocs = internal_relocs;
3991 elf_section_data (sec)->this_hdr.contents = contents;
3992 symtab_hdr->contents = (unsigned char *) isymbuf;
3994 /* Fix the opcode. */
3995 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3996 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3998 /* Fix the relocation's type. */
4000 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4001 (ELF32_R_TYPE (irel->r_info)
4002 == (int) R_MN10300_GOTOFF32)
4003 ? R_MN10300_GOTOFF24
4004 : (ELF32_R_TYPE (irel->r_info)
4005 == (int) R_MN10300_GOT32)
4009 /* Delete one byte of data. */
4010 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4011 irel->r_offset + 3, 1))
4014 /* That will change things, so, we should relax
4015 again. Note that this is not required, and it
4024 /* See if the value will fit in 16 bits.
4025 We allow any 16bit match here. We prune those we can't
4027 if ((long) value < 0x7fff && (long) value > -0x8000)
4031 /* Most insns which have 32bit operands are 6 bytes long;
4032 exceptions are pcrel insns and bit insns.
4034 We handle pcrel insns above. We don't bother trying
4035 to handle the bit insns here.
4037 The first byte of the remaining insns will be 0xfc. */
4039 /* Get the first opcode. */
4040 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
4045 /* Get the second opcode. */
4046 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
4048 if ((code & 0xf0) < 0x80)
4049 switch (code & 0xf0)
4051 /* mov (d32,am),dn -> mov (d32,am),dn
4052 mov dm,(d32,am) -> mov dn,(d32,am)
4053 mov (d32,am),an -> mov (d32,am),an
4054 mov dm,(d32,am) -> mov dn,(d32,am)
4055 movbu (d32,am),dn -> movbu (d32,am),dn
4056 movbu dm,(d32,am) -> movbu dn,(d32,am)
4057 movhu (d32,am),dn -> movhu (d32,am),dn
4058 movhu dm,(d32,am) -> movhu dn,(d32,am) */
4067 /* Not safe if the high bit is on as relaxing may
4068 move the value out of high mem and thus not fit
4069 in a signed 16bit value. */
4071 && (value & 0x8000))
4074 /* Note that we've changed the relocation contents, etc. */
4075 elf_section_data (sec)->relocs = internal_relocs;
4076 elf_section_data (sec)->this_hdr.contents = contents;
4077 symtab_hdr->contents = (unsigned char *) isymbuf;
4079 /* Fix the opcode. */
4080 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4081 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4083 /* Fix the relocation's type. */
4084 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4085 (ELF32_R_TYPE (irel->r_info)
4086 == (int) R_MN10300_GOTOFF32)
4087 ? R_MN10300_GOTOFF16
4088 : (ELF32_R_TYPE (irel->r_info)
4089 == (int) R_MN10300_GOT32)
4091 : (ELF32_R_TYPE (irel->r_info)
4092 == (int) R_MN10300_GOTPC32)
4093 ? R_MN10300_GOTPC16 :
4096 /* Delete two bytes of data. */
4097 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4098 irel->r_offset + 2, 2))
4101 /* That will change things, so, we should relax again.
4102 Note that this is not required, and it may be slow. */
4106 else if ((code & 0xf0) == 0x80
4107 || (code & 0xf0) == 0x90)
4108 switch (code & 0xf3)
4110 /* mov dn,(abs32) -> mov dn,(abs16)
4111 movbu dn,(abs32) -> movbu dn,(abs16)
4112 movhu dn,(abs32) -> movhu dn,(abs16) */
4116 /* Note that we've changed the relocation contents, etc. */
4117 elf_section_data (sec)->relocs = internal_relocs;
4118 elf_section_data (sec)->this_hdr.contents = contents;
4119 symtab_hdr->contents = (unsigned char *) isymbuf;
4121 if ((code & 0xf3) == 0x81)
4122 code = 0x01 + (code & 0x0c);
4123 else if ((code & 0xf3) == 0x82)
4124 code = 0x02 + (code & 0x0c);
4125 else if ((code & 0xf3) == 0x83)
4126 code = 0x03 + (code & 0x0c);
4130 /* Fix the opcode. */
4131 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4133 /* Fix the relocation's type. */
4134 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4135 (ELF32_R_TYPE (irel->r_info)
4136 == (int) R_MN10300_GOTOFF32)
4137 ? R_MN10300_GOTOFF16
4138 : (ELF32_R_TYPE (irel->r_info)
4139 == (int) R_MN10300_GOT32)
4141 : (ELF32_R_TYPE (irel->r_info)
4142 == (int) R_MN10300_GOTPC32)
4143 ? R_MN10300_GOTPC16 :
4146 /* The opcode got shorter too, so we have to fix the
4147 addend and offset too! */
4148 irel->r_offset -= 1;
4150 /* Delete three bytes of data. */
4151 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4152 irel->r_offset + 1, 3))
4155 /* That will change things, so, we should relax again.
4156 Note that this is not required, and it may be slow. */
4160 /* mov am,(abs32) -> mov am,(abs16)
4161 mov am,(d32,sp) -> mov am,(d16,sp)
4162 mov dm,(d32,sp) -> mov dm,(d32,sp)
4163 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
4164 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
4170 /* sp-based offsets are zero-extended. */
4171 if (code >= 0x90 && code <= 0x93
4172 && (long) value < 0)
4175 /* Note that we've changed the relocation contents, etc. */
4176 elf_section_data (sec)->relocs = internal_relocs;
4177 elf_section_data (sec)->this_hdr.contents = contents;
4178 symtab_hdr->contents = (unsigned char *) isymbuf;
4180 /* Fix the opcode. */
4181 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4182 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4184 /* Fix the relocation's type. */
4185 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4186 (ELF32_R_TYPE (irel->r_info)
4187 == (int) R_MN10300_GOTOFF32)
4188 ? R_MN10300_GOTOFF16
4189 : (ELF32_R_TYPE (irel->r_info)
4190 == (int) R_MN10300_GOT32)
4192 : (ELF32_R_TYPE (irel->r_info)
4193 == (int) R_MN10300_GOTPC32)
4194 ? R_MN10300_GOTPC16 :
4197 /* Delete two bytes of data. */
4198 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4199 irel->r_offset + 2, 2))
4202 /* That will change things, so, we should relax again.
4203 Note that this is not required, and it may be slow. */
4207 else if ((code & 0xf0) < 0xf0)
4208 switch (code & 0xfc)
4210 /* mov imm32,dn -> mov imm16,dn
4211 mov imm32,an -> mov imm16,an
4212 mov (abs32),dn -> mov (abs16),dn
4213 movbu (abs32),dn -> movbu (abs16),dn
4214 movhu (abs32),dn -> movhu (abs16),dn */
4220 /* Not safe if the high bit is on as relaxing may
4221 move the value out of high mem and thus not fit
4222 in a signed 16bit value. */
4224 && (value & 0x8000))
4227 /* "mov imm16, an" zero-extends the immediate. */
4228 if ((code & 0xfc) == 0xdc
4229 && (long) value < 0)
4232 /* Note that we've changed the relocation contents, etc. */
4233 elf_section_data (sec)->relocs = internal_relocs;
4234 elf_section_data (sec)->this_hdr.contents = contents;
4235 symtab_hdr->contents = (unsigned char *) isymbuf;
4237 if ((code & 0xfc) == 0xcc)
4238 code = 0x2c + (code & 0x03);
4239 else if ((code & 0xfc) == 0xdc)
4240 code = 0x24 + (code & 0x03);
4241 else if ((code & 0xfc) == 0xa4)
4242 code = 0x30 + (code & 0x03);
4243 else if ((code & 0xfc) == 0xa8)
4244 code = 0x34 + (code & 0x03);
4245 else if ((code & 0xfc) == 0xac)
4246 code = 0x38 + (code & 0x03);
4250 /* Fix the opcode. */
4251 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
4253 /* Fix the relocation's type. */
4254 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4255 (ELF32_R_TYPE (irel->r_info)
4256 == (int) R_MN10300_GOTOFF32)
4257 ? R_MN10300_GOTOFF16
4258 : (ELF32_R_TYPE (irel->r_info)
4259 == (int) R_MN10300_GOT32)
4261 : (ELF32_R_TYPE (irel->r_info)
4262 == (int) R_MN10300_GOTPC32)
4263 ? R_MN10300_GOTPC16 :
4266 /* The opcode got shorter too, so we have to fix the
4267 addend and offset too! */
4268 irel->r_offset -= 1;
4270 /* Delete three bytes of data. */
4271 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4272 irel->r_offset + 1, 3))
4275 /* That will change things, so, we should relax again.
4276 Note that this is not required, and it may be slow. */
4280 /* mov (abs32),an -> mov (abs16),an
4281 mov (d32,sp),an -> mov (d16,sp),an
4282 mov (d32,sp),dn -> mov (d16,sp),dn
4283 movbu (d32,sp),dn -> movbu (d16,sp),dn
4284 movhu (d32,sp),dn -> movhu (d16,sp),dn
4285 add imm32,dn -> add imm16,dn
4286 cmp imm32,dn -> cmp imm16,dn
4287 add imm32,an -> add imm16,an
4288 cmp imm32,an -> cmp imm16,an
4289 and imm32,dn -> and imm16,dn
4290 or imm32,dn -> or imm16,dn
4291 xor imm32,dn -> xor imm16,dn
4292 btst imm32,dn -> btst imm16,dn */
4308 /* cmp imm16, an zero-extends the immediate. */
4310 && (long) value < 0)
4313 /* So do sp-based offsets. */
4314 if (code >= 0xb0 && code <= 0xb3
4315 && (long) value < 0)
4318 /* Note that we've changed the relocation contents, etc. */
4319 elf_section_data (sec)->relocs = internal_relocs;
4320 elf_section_data (sec)->this_hdr.contents = contents;
4321 symtab_hdr->contents = (unsigned char *) isymbuf;
4323 /* Fix the opcode. */
4324 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4325 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
4327 /* Fix the relocation's type. */
4328 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4329 (ELF32_R_TYPE (irel->r_info)
4330 == (int) R_MN10300_GOTOFF32)
4331 ? R_MN10300_GOTOFF16
4332 : (ELF32_R_TYPE (irel->r_info)
4333 == (int) R_MN10300_GOT32)
4335 : (ELF32_R_TYPE (irel->r_info)
4336 == (int) R_MN10300_GOTPC32)
4337 ? R_MN10300_GOTPC16 :
4340 /* Delete two bytes of data. */
4341 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4342 irel->r_offset + 2, 2))
4345 /* That will change things, so, we should relax again.
4346 Note that this is not required, and it may be slow. */
4350 else if (code == 0xfe)
4352 /* add imm32,sp -> add imm16,sp */
4354 /* Note that we've changed the relocation contents, etc. */
4355 elf_section_data (sec)->relocs = internal_relocs;
4356 elf_section_data (sec)->this_hdr.contents = contents;
4357 symtab_hdr->contents = (unsigned char *) isymbuf;
4359 /* Fix the opcode. */
4360 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
4361 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
4363 /* Fix the relocation's type. */
4364 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
4365 (ELF32_R_TYPE (irel->r_info)
4366 == (int) R_MN10300_GOT32)
4368 : (ELF32_R_TYPE (irel->r_info)
4369 == (int) R_MN10300_GOTOFF32)
4370 ? R_MN10300_GOTOFF16
4371 : (ELF32_R_TYPE (irel->r_info)
4372 == (int) R_MN10300_GOTPC32)
4373 ? R_MN10300_GOTPC16 :
4376 /* Delete two bytes of data. */
4377 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
4378 irel->r_offset + 2, 2))
4381 /* That will change things, so, we should relax again.
4382 Note that this is not required, and it may be slow. */
4391 && symtab_hdr->contents != (unsigned char *) isymbuf)
4393 if (! link_info->keep_memory)
4397 /* Cache the symbols for elf_link_input_bfd. */
4398 symtab_hdr->contents = (unsigned char *) isymbuf;
4402 if (contents != NULL
4403 && elf_section_data (sec)->this_hdr.contents != contents)
4405 if (! link_info->keep_memory)
4409 /* Cache the section contents for elf_link_input_bfd. */
4410 elf_section_data (sec)->this_hdr.contents = contents;
4414 if (internal_relocs != NULL
4415 && elf_section_data (sec)->relocs != internal_relocs)
4416 free (internal_relocs);
4422 && symtab_hdr->contents != (unsigned char *) isymbuf)
4424 if (contents != NULL
4425 && elf_section_data (section)->this_hdr.contents != contents)
4427 if (internal_relocs != NULL
4428 && elf_section_data (section)->relocs != internal_relocs)
4429 free (internal_relocs);
4434 /* This is a version of bfd_generic_get_relocated_section_contents
4435 which uses mn10300_elf_relocate_section. */
4438 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
4439 struct bfd_link_info *link_info,
4440 struct bfd_link_order *link_order,
4442 bfd_boolean relocatable,
4445 Elf_Internal_Shdr *symtab_hdr;
4446 asection *input_section = link_order->u.indirect.section;
4447 bfd *input_bfd = input_section->owner;
4448 asection **sections = NULL;
4449 Elf_Internal_Rela *internal_relocs = NULL;
4450 Elf_Internal_Sym *isymbuf = NULL;
4452 /* We only need to handle the case of relaxing, or of having a
4453 particular set of section contents, specially. */
4455 || elf_section_data (input_section)->this_hdr.contents == NULL)
4456 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
4461 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4463 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
4464 (size_t) input_section->size);
4466 if ((input_section->flags & SEC_RELOC) != 0
4467 && input_section->reloc_count > 0)
4470 Elf_Internal_Sym *isym, *isymend;
4473 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
4475 if (internal_relocs == NULL)
4478 if (symtab_hdr->sh_info != 0)
4480 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
4481 if (isymbuf == NULL)
4482 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4483 symtab_hdr->sh_info, 0,
4485 if (isymbuf == NULL)
4489 amt = symtab_hdr->sh_info;
4490 amt *= sizeof (asection *);
4491 sections = bfd_malloc (amt);
4492 if (sections == NULL && amt != 0)
4495 isymend = isymbuf + symtab_hdr->sh_info;
4496 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
4500 if (isym->st_shndx == SHN_UNDEF)
4501 isec = bfd_und_section_ptr;
4502 else if (isym->st_shndx == SHN_ABS)
4503 isec = bfd_abs_section_ptr;
4504 else if (isym->st_shndx == SHN_COMMON)
4505 isec = bfd_com_section_ptr;
4507 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
4512 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
4513 input_section, data, internal_relocs,
4517 if (sections != NULL)
4519 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4521 if (internal_relocs != elf_section_data (input_section)->relocs)
4522 free (internal_relocs);
4528 if (sections != NULL)
4530 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
4532 if (internal_relocs != NULL
4533 && internal_relocs != elf_section_data (input_section)->relocs)
4534 free (internal_relocs);
4538 /* Assorted hash table functions. */
4540 /* Initialize an entry in the link hash table. */
4542 /* Create an entry in an MN10300 ELF linker hash table. */
4544 static struct bfd_hash_entry *
4545 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
4546 struct bfd_hash_table *table,
4549 struct elf32_mn10300_link_hash_entry *ret =
4550 (struct elf32_mn10300_link_hash_entry *) entry;
4552 /* Allocate the structure if it has not already been allocated by a
4555 ret = (struct elf32_mn10300_link_hash_entry *)
4556 bfd_hash_allocate (table, sizeof (* ret));
4558 return (struct bfd_hash_entry *) ret;
4560 /* Call the allocation method of the superclass. */
4561 ret = (struct elf32_mn10300_link_hash_entry *)
4562 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
4566 ret->direct_calls = 0;
4567 ret->stack_size = 0;
4569 ret->movm_stack_size = 0;
4572 ret->tls_type = GOT_UNKNOWN;
4575 return (struct bfd_hash_entry *) ret;
4579 _bfd_mn10300_copy_indirect_symbol (struct bfd_link_info * info,
4580 struct elf_link_hash_entry * dir,
4581 struct elf_link_hash_entry * ind)
4583 struct elf32_mn10300_link_hash_entry * edir;
4584 struct elf32_mn10300_link_hash_entry * eind;
4586 edir = elf_mn10300_hash_entry (dir);
4587 eind = elf_mn10300_hash_entry (ind);
4589 if (ind->root.type == bfd_link_hash_indirect
4590 && dir->got.refcount <= 0)
4592 edir->tls_type = eind->tls_type;
4593 eind->tls_type = GOT_UNKNOWN;
4595 edir->direct_calls = eind->direct_calls;
4596 edir->stack_size = eind->stack_size;
4597 edir->movm_args = eind->movm_args;
4598 edir->movm_stack_size = eind->movm_stack_size;
4599 edir->flags = eind->flags;
4601 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4604 /* Destroy an mn10300 ELF linker hash table. */
4607 elf32_mn10300_link_hash_table_free (bfd *obfd)
4609 struct elf32_mn10300_link_hash_table *ret
4610 = (struct elf32_mn10300_link_hash_table *) obfd->link.hash;
4612 obfd->link.hash = &ret->static_hash_table->root.root;
4613 _bfd_elf_link_hash_table_free (obfd);
4614 obfd->is_linker_output = TRUE;
4615 obfd->link.hash = &ret->root.root;
4616 _bfd_elf_link_hash_table_free (obfd);
4619 /* Create an mn10300 ELF linker hash table. */
4621 static struct bfd_link_hash_table *
4622 elf32_mn10300_link_hash_table_create (bfd *abfd)
4624 struct elf32_mn10300_link_hash_table *ret;
4625 bfd_size_type amt = sizeof (* ret);
4627 ret = bfd_zmalloc (amt);
4631 amt = sizeof (struct elf_link_hash_table);
4632 ret->static_hash_table = bfd_zmalloc (amt);
4633 if (ret->static_hash_table == NULL)
4639 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
4640 elf32_mn10300_link_hash_newfunc,
4641 sizeof (struct elf32_mn10300_link_hash_entry),
4644 free (ret->static_hash_table);
4649 abfd->is_linker_output = FALSE;
4650 abfd->link.hash = NULL;
4651 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4652 elf32_mn10300_link_hash_newfunc,
4653 sizeof (struct elf32_mn10300_link_hash_entry),
4656 abfd->is_linker_output = TRUE;
4657 abfd->link.hash = &ret->static_hash_table->root.root;
4658 _bfd_elf_link_hash_table_free (abfd);
4662 ret->root.root.hash_table_free = elf32_mn10300_link_hash_table_free;
4664 ret->tls_ldm_got.offset = -1;
4666 return & ret->root.root;
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, struct bfd_link_info *info)
4730 bfd *obfd = info->output_bfd;
4732 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4733 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4736 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4737 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4739 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4740 bfd_get_mach (ibfd)))
4747 #define PLT0_ENTRY_SIZE 15
4748 #define PLT_ENTRY_SIZE 20
4749 #define PIC_PLT_ENTRY_SIZE 24
4751 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4753 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4754 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4755 0xf0, 0xf4, /* jmp (a0) */
4758 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4760 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4761 0xf0, 0xf4, /* jmp (a0) */
4762 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4763 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4766 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4768 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4769 0xf0, 0xf4, /* jmp (a0) */
4770 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4771 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4772 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4773 0xf0, 0xf4, /* jmp (a0) */
4776 /* Return size of the first PLT entry. */
4777 #define elf_mn10300_sizeof_plt0(info) \
4778 (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4780 /* Return size of a PLT entry. */
4781 #define elf_mn10300_sizeof_plt(info) \
4782 (bfd_link_pic (info) ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4784 /* Return offset of the PLT0 address in an absolute PLT entry. */
4785 #define elf_mn10300_plt_plt0_offset(info) 16
4787 /* Return offset of the linker in PLT0 entry. */
4788 #define elf_mn10300_plt0_linker_offset(info) 2
4790 /* Return offset of the GOT id in PLT0 entry. */
4791 #define elf_mn10300_plt0_gotid_offset(info) 9
4793 /* Return offset of the temporary in PLT entry. */
4794 #define elf_mn10300_plt_temp_offset(info) 8
4796 /* Return offset of the symbol in PLT entry. */
4797 #define elf_mn10300_plt_symbol_offset(info) 2
4799 /* Return offset of the relocation in PLT entry. */
4800 #define elf_mn10300_plt_reloc_offset(info) 11
4802 /* The name of the dynamic interpreter. This is put in the .interp
4805 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4807 /* Create dynamic sections when linking against a dynamic object. */
4810 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4814 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4815 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
4818 switch (bed->s->arch_size)
4829 bfd_set_error (bfd_error_bad_value);
4833 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4834 .rel[a].bss sections. */
4835 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4836 | SEC_LINKER_CREATED);
4838 s = bfd_make_section_anyway_with_flags (abfd,
4839 (bed->default_use_rela_p
4840 ? ".rela.plt" : ".rel.plt"),
4841 flags | SEC_READONLY);
4842 htab->root.srelplt = s;
4844 || ! bfd_set_section_alignment (abfd, s, ptralign))
4847 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4850 if (bed->want_dynbss)
4852 /* The .dynbss section is a place to put symbols which are defined
4853 by dynamic objects, are referenced by regular objects, and are
4854 not functions. We must allocate space for them in the process
4855 image and use a R_*_COPY reloc to tell the dynamic linker to
4856 initialize them at run time. The linker script puts the .dynbss
4857 section into the .bss section of the final image. */
4858 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
4859 SEC_ALLOC | SEC_LINKER_CREATED);
4863 /* The .rel[a].bss section holds copy relocs. This section is not
4864 normally needed. We need to create it here, though, so that the
4865 linker will map it to an output section. We can't just create it
4866 only if we need it, because we will not know whether we need it
4867 until we have seen all the input files, and the first time the
4868 main linker code calls BFD after examining all the input files
4869 (size_dynamic_sections) the input sections have already been
4870 mapped to the output sections. If the section turns out not to
4871 be needed, we can discard it later. We will never need this
4872 section when generating a shared object, since they do not use
4874 if (! bfd_link_pic (info))
4876 s = bfd_make_section_anyway_with_flags (abfd,
4877 (bed->default_use_rela_p
4878 ? ".rela.bss" : ".rel.bss"),
4879 flags | SEC_READONLY);
4881 || ! bfd_set_section_alignment (abfd, s, ptralign))
4889 /* Adjust a symbol defined by a dynamic object and referenced by a
4890 regular object. The current definition is in some section of the
4891 dynamic object, but we're not including those sections. We have to
4892 change the definition to something the rest of the link can
4896 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4897 struct elf_link_hash_entry * h)
4899 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
4903 dynobj = htab->root.dynobj;
4905 /* Make sure we know what is going on here. */
4906 BFD_ASSERT (dynobj != NULL
4908 || h->u.weakdef != NULL
4911 && !h->def_regular)));
4913 /* If this is a function, put it in the procedure linkage table. We
4914 will fill in the contents of the procedure linkage table later,
4915 when we know the address of the .got section. */
4916 if (h->type == STT_FUNC
4919 if (! bfd_link_pic (info)
4923 /* This case can occur if we saw a PLT reloc in an input
4924 file, but the symbol was never referred to by a dynamic
4925 object. In such a case, we don't actually need to build
4926 a procedure linkage table, and we can just do a REL32
4928 BFD_ASSERT (h->needs_plt);
4932 /* Make sure this symbol is output as a dynamic symbol. */
4933 if (h->dynindx == -1)
4935 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4939 s = htab->root.splt;
4940 BFD_ASSERT (s != NULL);
4942 /* If this is the first .plt entry, make room for the special
4945 s->size += elf_mn10300_sizeof_plt0 (info);
4947 /* If this symbol is not defined in a regular file, and we are
4948 not generating a shared library, then set the symbol to this
4949 location in the .plt. This is required to make function
4950 pointers compare as equal between the normal executable and
4951 the shared library. */
4952 if (! bfd_link_pic (info)
4955 h->root.u.def.section = s;
4956 h->root.u.def.value = s->size;
4959 h->plt.offset = s->size;
4961 /* Make room for this entry. */
4962 s->size += elf_mn10300_sizeof_plt (info);
4964 /* We also need to make an entry in the .got.plt section, which
4965 will be placed in the .got section by the linker script. */
4966 s = htab->root.sgotplt;
4967 BFD_ASSERT (s != NULL);
4970 /* We also need to make an entry in the .rela.plt section. */
4971 s = bfd_get_linker_section (dynobj, ".rela.plt");
4972 BFD_ASSERT (s != NULL);
4973 s->size += sizeof (Elf32_External_Rela);
4978 /* If this is a weak symbol, and there is a real definition, the
4979 processor independent code will have arranged for us to see the
4980 real definition first, and we can just use the same value. */
4981 if (h->u.weakdef != NULL)
4983 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4984 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4985 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4986 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4990 /* This is a reference to a symbol defined by a dynamic object which
4991 is not a function. */
4993 /* If we are creating a shared library, we must presume that the
4994 only references to the symbol are via the global offset table.
4995 For such cases we need not do anything here; the relocations will
4996 be handled correctly by relocate_section. */
4997 if (bfd_link_pic (info))
5000 /* If there are no references to this symbol that do not use the
5001 GOT, we don't need to generate a copy reloc. */
5002 if (!h->non_got_ref)
5005 /* We must allocate the symbol in our .dynbss section, which will
5006 become part of the .bss section of the executable. There will be
5007 an entry for this symbol in the .dynsym section. The dynamic
5008 object will contain position independent code, so all references
5009 from the dynamic object to this symbol will go through the global
5010 offset table. The dynamic linker will use the .dynsym entry to
5011 determine the address it must put in the global offset table, so
5012 both the dynamic object and the regular object will refer to the
5013 same memory location for the variable. */
5015 s = bfd_get_linker_section (dynobj, ".dynbss");
5016 BFD_ASSERT (s != NULL);
5018 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
5019 copy the initial value out of the dynamic object and into the
5020 runtime process image. We need to remember the offset into the
5021 .rela.bss section we are going to use. */
5022 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
5026 srel = bfd_get_linker_section (dynobj, ".rela.bss");
5027 BFD_ASSERT (srel != NULL);
5028 srel->size += sizeof (Elf32_External_Rela);
5032 return _bfd_elf_adjust_dynamic_copy (info, h, s);
5035 /* Set the sizes of the dynamic sections. */
5038 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
5039 struct bfd_link_info * info)
5041 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5046 bfd_boolean reltext;
5048 dynobj = htab->root.dynobj;
5049 BFD_ASSERT (dynobj != NULL);
5051 if (elf_hash_table (info)->dynamic_sections_created)
5053 /* Set the contents of the .interp section to the interpreter. */
5054 if (bfd_link_executable (info))
5056 s = bfd_get_linker_section (dynobj, ".interp");
5057 BFD_ASSERT (s != NULL);
5058 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5059 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5064 /* We may have created entries in the .rela.got section.
5065 However, if we are not creating the dynamic sections, we will
5066 not actually use these entries. Reset the size of .rela.got,
5067 which will cause it to get stripped from the output file
5069 s = htab->root.sgot;
5074 if (htab->tls_ldm_got.refcount > 0)
5076 s = bfd_get_linker_section (dynobj, ".rela.got");
5077 BFD_ASSERT (s != NULL);
5078 s->size += sizeof (Elf32_External_Rela);
5081 /* The check_relocs and adjust_dynamic_symbol entry points have
5082 determined the sizes of the various dynamic sections. Allocate
5087 for (s = dynobj->sections; s != NULL; s = s->next)
5091 if ((s->flags & SEC_LINKER_CREATED) == 0)
5094 /* It's OK to base decisions on the section name, because none
5095 of the dynobj section names depend upon the input files. */
5096 name = bfd_get_section_name (dynobj, s);
5098 if (streq (name, ".plt"))
5100 /* Remember whether there is a PLT. */
5103 else if (CONST_STRNEQ (name, ".rela"))
5109 /* Remember whether there are any reloc sections other
5111 if (! streq (name, ".rela.plt"))
5113 const char * outname;
5117 /* If this relocation section applies to a read only
5118 section, then we probably need a DT_TEXTREL
5119 entry. The entries in the .rela.plt section
5120 really apply to the .got section, which we
5121 created ourselves and so know is not readonly. */
5122 outname = bfd_get_section_name (output_bfd,
5124 target = bfd_get_section_by_name (output_bfd, outname + 5);
5126 && (target->flags & SEC_READONLY) != 0
5127 && (target->flags & SEC_ALLOC) != 0)
5131 /* We use the reloc_count field as a counter if we need
5132 to copy relocs into the output file. */
5136 else if (! CONST_STRNEQ (name, ".got")
5137 && ! streq (name, ".dynbss"))
5138 /* It's not one of our sections, so don't allocate space. */
5143 /* If we don't need this section, strip it from the
5144 output file. This is mostly to handle .rela.bss and
5145 .rela.plt. We must create both sections in
5146 create_dynamic_sections, because they must be created
5147 before the linker maps input sections to output
5148 sections. The linker does that before
5149 adjust_dynamic_symbol is called, and it is that
5150 function which decides whether anything needs to go
5151 into these sections. */
5152 s->flags |= SEC_EXCLUDE;
5156 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5159 /* Allocate memory for the section contents. We use bfd_zalloc
5160 here in case unused entries are not reclaimed before the
5161 section's contents are written out. This should not happen,
5162 but this way if it does, we get a R_MN10300_NONE reloc
5163 instead of garbage. */
5164 s->contents = bfd_zalloc (dynobj, s->size);
5165 if (s->contents == NULL)
5169 if (elf_hash_table (info)->dynamic_sections_created)
5171 /* Add some entries to the .dynamic section. We fill in the
5172 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
5173 but we must add the entries now so that we get the correct
5174 size for the .dynamic section. The DT_DEBUG entry is filled
5175 in by the dynamic linker and used by the debugger. */
5176 if (! bfd_link_pic (info))
5178 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
5184 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
5185 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5186 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
5187 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5193 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
5194 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
5195 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
5196 sizeof (Elf32_External_Rela)))
5202 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
5210 /* Finish up dynamic symbol handling. We set the contents of various
5211 dynamic sections here. */
5214 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
5215 struct bfd_link_info * info,
5216 struct elf_link_hash_entry * h,
5217 Elf_Internal_Sym * sym)
5219 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5222 dynobj = htab->root.dynobj;
5224 if (h->plt.offset != (bfd_vma) -1)
5231 Elf_Internal_Rela rel;
5233 /* This symbol has an entry in the procedure linkage table. Set
5236 BFD_ASSERT (h->dynindx != -1);
5238 splt = htab->root.splt;
5239 sgot = htab->root.sgotplt;
5240 srel = bfd_get_linker_section (dynobj, ".rela.plt");
5241 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
5243 /* Get the index in the procedure linkage table which
5244 corresponds to this symbol. This is the index of this symbol
5245 in all the symbols for which we are making plt entries. The
5246 first entry in the procedure linkage table is reserved. */
5247 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
5248 / elf_mn10300_sizeof_plt (info));
5250 /* Get the offset into the .got table of the entry that
5251 corresponds to this function. Each .got entry is 4 bytes.
5252 The first three are reserved. */
5253 got_offset = (plt_index + 3) * 4;
5255 /* Fill in the entry in the procedure linkage table. */
5256 if (! bfd_link_pic (info))
5258 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
5259 elf_mn10300_sizeof_plt (info));
5260 bfd_put_32 (output_bfd,
5261 (sgot->output_section->vma
5262 + sgot->output_offset
5264 (splt->contents + h->plt.offset
5265 + elf_mn10300_plt_symbol_offset (info)));
5267 bfd_put_32 (output_bfd,
5268 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
5269 (splt->contents + h->plt.offset
5270 + elf_mn10300_plt_plt0_offset (info)));
5274 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
5275 elf_mn10300_sizeof_plt (info));
5277 bfd_put_32 (output_bfd, got_offset,
5278 (splt->contents + h->plt.offset
5279 + elf_mn10300_plt_symbol_offset (info)));
5282 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
5283 (splt->contents + h->plt.offset
5284 + elf_mn10300_plt_reloc_offset (info)));
5286 /* Fill in the entry in the global offset table. */
5287 bfd_put_32 (output_bfd,
5288 (splt->output_section->vma
5289 + splt->output_offset
5291 + elf_mn10300_plt_temp_offset (info)),
5292 sgot->contents + got_offset);
5294 /* Fill in the entry in the .rela.plt section. */
5295 rel.r_offset = (sgot->output_section->vma
5296 + sgot->output_offset
5298 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
5300 bfd_elf32_swap_reloca_out (output_bfd, &rel,
5301 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5304 if (!h->def_regular)
5305 /* Mark the symbol as undefined, rather than as defined in
5306 the .plt section. Leave the value alone. */
5307 sym->st_shndx = SHN_UNDEF;
5310 if (h->got.offset != (bfd_vma) -1)
5314 Elf_Internal_Rela rel;
5316 /* This symbol has an entry in the global offset table. Set it up. */
5317 sgot = htab->root.sgot;
5318 srel = bfd_get_linker_section (dynobj, ".rela.got");
5319 BFD_ASSERT (sgot != NULL && srel != NULL);
5321 rel.r_offset = (sgot->output_section->vma
5322 + sgot->output_offset
5323 + (h->got.offset & ~1));
5325 switch (elf_mn10300_hash_entry (h)->tls_type)
5328 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5329 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset + 4);
5330 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPMOD);
5332 bfd_elf32_swap_reloca_out (output_bfd, & rel,
5333 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5334 + srel->reloc_count));
5335 ++ srel->reloc_count;
5336 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_DTPOFF);
5342 /* We originally stored the addend in the GOT, but at this
5343 point, we want to move it to the reloc instead as that's
5344 where the dynamic linker wants it. */
5345 rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + h->got.offset);
5346 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5347 if (h->dynindx == -1)
5348 rel.r_info = ELF32_R_INFO (0, R_MN10300_TLS_TPOFF);
5350 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_TLS_TPOFF);
5354 /* If this is a -Bsymbolic link, and the symbol is defined
5355 locally, we just want to emit a RELATIVE reloc. Likewise if
5356 the symbol was forced to be local because of a version file.
5357 The entry in the global offset table will already have been
5358 initialized in the relocate_section function. */
5359 if (bfd_link_pic (info)
5360 && (info->symbolic || h->dynindx == -1)
5363 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
5364 rel.r_addend = (h->root.u.def.value
5365 + h->root.u.def.section->output_section->vma
5366 + h->root.u.def.section->output_offset);
5370 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5371 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
5376 if (ELF32_R_TYPE (rel.r_info) != R_MN10300_NONE)
5378 bfd_elf32_swap_reloca_out (output_bfd, &rel,
5379 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
5380 + srel->reloc_count));
5381 ++ srel->reloc_count;
5388 Elf_Internal_Rela rel;
5390 /* This symbol needs a copy reloc. Set it up. */
5391 BFD_ASSERT (h->dynindx != -1
5392 && (h->root.type == bfd_link_hash_defined
5393 || h->root.type == bfd_link_hash_defweak));
5395 s = bfd_get_linker_section (dynobj, ".rela.bss");
5396 BFD_ASSERT (s != NULL);
5398 rel.r_offset = (h->root.u.def.value
5399 + h->root.u.def.section->output_section->vma
5400 + h->root.u.def.section->output_offset);
5401 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
5403 bfd_elf32_swap_reloca_out (output_bfd, & rel,
5404 (bfd_byte *) ((Elf32_External_Rela *) s->contents
5409 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5410 if (h == elf_hash_table (info)->hdynamic
5411 || h == elf_hash_table (info)->hgot)
5412 sym->st_shndx = SHN_ABS;
5417 /* Finish up the dynamic sections. */
5420 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
5421 struct bfd_link_info * info)
5426 struct elf32_mn10300_link_hash_table *htab = elf32_mn10300_hash_table (info);
5428 dynobj = htab->root.dynobj;
5429 sgot = htab->root.sgotplt;
5430 BFD_ASSERT (sgot != NULL);
5431 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5433 if (elf_hash_table (info)->dynamic_sections_created)
5436 Elf32_External_Dyn * dyncon;
5437 Elf32_External_Dyn * dynconend;
5439 BFD_ASSERT (sdyn != NULL);
5441 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5442 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5444 for (; dyncon < dynconend; dyncon++)
5446 Elf_Internal_Dyn dyn;
5450 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5464 s = bfd_get_linker_section (dynobj, name);
5465 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5466 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5470 s = bfd_get_linker_section (dynobj, ".rela.plt");
5471 dyn.d_un.d_val = s->size;
5472 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5476 /* My reading of the SVR4 ABI indicates that the
5477 procedure linkage table relocs (DT_JMPREL) should be
5478 included in the overall relocs (DT_RELA). This is
5479 what Solaris does. However, UnixWare can not handle
5480 that case. Therefore, we override the DT_RELASZ entry
5481 here to make it not include the JMPREL relocs. Since
5482 the linker script arranges for .rela.plt to follow all
5483 other relocation sections, we don't have to worry
5484 about changing the DT_RELA entry. */
5485 s = bfd_get_linker_section (dynobj, ".rela.plt");
5487 dyn.d_un.d_val -= s->size;
5488 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5493 /* Fill in the first entry in the procedure linkage table. */
5494 splt = htab->root.splt;
5495 if (splt && splt->size > 0)
5497 if (bfd_link_pic (info))
5499 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
5500 elf_mn10300_sizeof_plt (info));
5504 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
5505 bfd_put_32 (output_bfd,
5506 sgot->output_section->vma + sgot->output_offset + 4,
5507 splt->contents + elf_mn10300_plt0_gotid_offset (info));
5508 bfd_put_32 (output_bfd,
5509 sgot->output_section->vma + sgot->output_offset + 8,
5510 splt->contents + elf_mn10300_plt0_linker_offset (info));
5513 /* UnixWare sets the entsize of .plt to 4, although that doesn't
5514 really seem like the right value. */
5515 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5517 /* UnixWare sets the entsize of .plt to 4, but this is incorrect
5518 as it means that the size of the PLT0 section (15 bytes) is not
5519 a multiple of the sh_entsize. Some ELF tools flag this as an
5520 error. We could pad PLT0 to 16 bytes, but that would introduce
5521 compatibilty issues with previous toolchains, so instead we
5522 just set the entry size to 1. */
5523 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 1;
5527 /* Fill in the first three entries in the global offset table. */
5531 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5533 bfd_put_32 (output_bfd,
5534 sdyn->output_section->vma + sdyn->output_offset,
5536 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5537 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5540 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5545 /* Classify relocation types, such that combreloc can sort them
5548 static enum elf_reloc_type_class
5549 _bfd_mn10300_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
5550 const asection *rel_sec ATTRIBUTE_UNUSED,
5551 const Elf_Internal_Rela *rela)
5553 switch ((int) ELF32_R_TYPE (rela->r_info))
5555 case R_MN10300_RELATIVE: return reloc_class_relative;
5556 case R_MN10300_JMP_SLOT: return reloc_class_plt;
5557 case R_MN10300_COPY: return reloc_class_copy;
5558 default: return reloc_class_normal;
5562 /* Allocate space for an MN10300 extension to the bfd elf data structure. */
5565 mn10300_elf_mkobject (bfd *abfd)
5567 return bfd_elf_allocate_object (abfd, sizeof (struct elf_mn10300_obj_tdata),
5571 #define bfd_elf32_mkobject mn10300_elf_mkobject
5574 #define TARGET_LITTLE_SYM mn10300_elf32_vec
5575 #define TARGET_LITTLE_NAME "elf32-mn10300"
5576 #define ELF_ARCH bfd_arch_mn10300
5577 #define ELF_TARGET_ID MN10300_ELF_DATA
5578 #define ELF_MACHINE_CODE EM_MN10300
5579 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
5580 #define ELF_MAXPAGESIZE 0x1000
5583 #define elf_info_to_howto mn10300_info_to_howto
5584 #define elf_info_to_howto_rel 0
5585 #define elf_backend_can_gc_sections 1
5586 #define elf_backend_rela_normal 1
5587 #define elf_backend_check_relocs mn10300_elf_check_relocs
5588 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
5589 #define elf_backend_relocate_section mn10300_elf_relocate_section
5590 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
5591 #define bfd_elf32_bfd_get_relocated_section_contents \
5592 mn10300_elf_get_relocated_section_contents
5593 #define bfd_elf32_bfd_link_hash_table_create \
5594 elf32_mn10300_link_hash_table_create
5596 #ifndef elf_symbol_leading_char
5597 #define elf_symbol_leading_char '_'
5600 /* So we can set bits in e_flags. */
5601 #define elf_backend_final_write_processing \
5602 _bfd_mn10300_elf_final_write_processing
5603 #define elf_backend_object_p _bfd_mn10300_elf_object_p
5605 #define bfd_elf32_bfd_merge_private_bfd_data \
5606 _bfd_mn10300_elf_merge_private_bfd_data
5608 #define elf_backend_can_gc_sections 1
5609 #define elf_backend_create_dynamic_sections \
5610 _bfd_mn10300_elf_create_dynamic_sections
5611 #define elf_backend_adjust_dynamic_symbol \
5612 _bfd_mn10300_elf_adjust_dynamic_symbol
5613 #define elf_backend_size_dynamic_sections \
5614 _bfd_mn10300_elf_size_dynamic_sections
5615 #define elf_backend_omit_section_dynsym \
5616 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
5617 #define elf_backend_finish_dynamic_symbol \
5618 _bfd_mn10300_elf_finish_dynamic_symbol
5619 #define elf_backend_finish_dynamic_sections \
5620 _bfd_mn10300_elf_finish_dynamic_sections
5621 #define elf_backend_copy_indirect_symbol \
5622 _bfd_mn10300_copy_indirect_symbol
5623 #define elf_backend_reloc_type_class \
5624 _bfd_mn10300_elf_reloc_type_class
5626 #define elf_backend_want_got_plt 1
5627 #define elf_backend_plt_readonly 1
5628 #define elf_backend_want_plt_sym 0
5629 #define elf_backend_got_header_size 12
5631 #include "elf32-target.h"