1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "elf/mn10300.h"
27 static bfd_reloc_status_type mn10300_elf_final_link_relocate
28 PARAMS ((reloc_howto_type
*, bfd
*, bfd
*, asection
*, bfd_byte
*,
29 bfd_vma
, bfd_vma
, bfd_vma
, struct bfd_link_info
*,
31 static boolean mn10300_elf_relocate_section
32 PARAMS ((bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
33 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**));
34 static boolean mn10300_elf_relax_section
35 PARAMS ((bfd
*, asection
*, struct bfd_link_info
*, boolean
*));
36 static bfd_byte
* mn10300_elf_get_relocated_section_contents
37 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
38 bfd_byte
*, boolean
, asymbol
**));
39 static unsigned long elf_mn10300_mach
PARAMS ((flagword
));
41 void _bfd_mn10300_elf_final_write_processing
PARAMS ((bfd
*, boolean
));
42 boolean _bfd_mn10300_elf_object_p
PARAMS ((bfd
*));
43 boolean _bfd_mn10300_elf_merge_private_bfd_data
PARAMS ((bfd
*,bfd
*));
45 struct elf32_mn10300_link_hash_entry
{
46 /* The basic elf link hash table entry. */
47 struct elf_link_hash_entry root
;
49 /* For function symbols, the number of times this function is
50 called directly (ie by name). */
51 unsigned int direct_calls
;
53 /* For function symbols, the size of this function's stack
54 (if <= 255 bytes). We stuff this into "call" instructions
55 to this target when it's valid and profitable to do so.
57 This does not include stack allocated by movm! */
58 unsigned char stack_size
;
60 /* For function symbols, arguments (if any) for movm instruction
61 in the prologue. We stuff this value into "call" instructions
62 to the target when it's valid and profitable to do so. */
63 unsigned char movm_args
;
65 /* For funtion symbols, the amount of stack space that would be allocated
66 by the movm instruction. This is redundant with movm_args, but we
67 add it to the hash table to avoid computing it over and over. */
68 unsigned char movm_stack_size
;
70 /* When set, convert all "call" instructions to this target into "calls"
72 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
74 /* Used to mark functions which have had redundant parts of their
76 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
80 /* We derive a hash table from the main elf linker hash table so
81 we can store state variables and a secondary hash table without
82 resorting to global variables. */
83 struct elf32_mn10300_link_hash_table
{
84 /* The main hash table. */
85 struct elf_link_hash_table root
;
87 /* A hash table for static functions. We could derive a new hash table
88 instead of using the full elf32_mn10300_link_hash_table if we wanted
89 to save some memory. */
90 struct elf32_mn10300_link_hash_table
*static_hash_table
;
92 /* Random linker state flags. */
93 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
97 /* For MN10300 linker hash table. */
99 /* Get the MN10300 ELF linker hash table from a link_info structure. */
101 #define elf32_mn10300_hash_table(p) \
102 ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
104 #define elf32_mn10300_link_hash_traverse(table, func, info) \
105 (elf_link_hash_traverse \
107 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
110 static struct bfd_hash_entry
*elf32_mn10300_link_hash_newfunc
111 PARAMS ((struct bfd_hash_entry
*, struct bfd_hash_table
*, const char *));
112 static struct bfd_link_hash_table
*elf32_mn10300_link_hash_table_create
114 static void elf32_mn10300_link_hash_table_free
115 PARAMS ((struct bfd_link_hash_table
*));
117 static reloc_howto_type
*bfd_elf32_bfd_reloc_type_lookup
118 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type code
));
119 static void mn10300_info_to_howto
120 PARAMS ((bfd
*, arelent
*, Elf32_Internal_Rela
*));
121 static boolean mn10300_elf_check_relocs
122 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*,
123 const Elf_Internal_Rela
*));
124 static asection
*mn10300_elf_gc_mark_hook
125 PARAMS ((asection
*, struct bfd_link_info
*info
, Elf_Internal_Rela
*,
126 struct elf_link_hash_entry
*, Elf_Internal_Sym
*));
127 static boolean mn10300_elf_relax_delete_bytes
128 PARAMS ((bfd
*, asection
*, bfd_vma
, int));
129 static boolean mn10300_elf_symbol_address_p
130 PARAMS ((bfd
*, asection
*, bfd_vma
));
131 static boolean elf32_mn10300_finish_hash_table_entry
132 PARAMS ((struct bfd_hash_entry
*, PTR
));
133 static void compute_function_info
134 PARAMS ((bfd
*, struct elf32_mn10300_link_hash_entry
*,
135 bfd_vma
, unsigned char *));
137 /* We have to use RELA instructions since md_apply_fix3 in the assembler
138 does absolutely nothing. */
141 static reloc_howto_type elf_mn10300_howto_table
[] = {
142 /* Dummy relocation. Does nothing. */
143 HOWTO (R_MN10300_NONE
,
149 complain_overflow_bitfield
,
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
,
287 struct mn10300_reloc_map
{
288 bfd_reloc_code_real_type bfd_reloc_val
;
289 unsigned char elf_reloc_val
;
292 static const struct mn10300_reloc_map mn10300_reloc_map
[] = {
293 { BFD_RELOC_NONE
, R_MN10300_NONE
, },
294 { BFD_RELOC_32
, R_MN10300_32
, },
295 { BFD_RELOC_16
, R_MN10300_16
, },
296 { BFD_RELOC_8
, R_MN10300_8
, },
297 { BFD_RELOC_32_PCREL
, R_MN10300_PCREL32
, },
298 { BFD_RELOC_16_PCREL
, R_MN10300_PCREL16
, },
299 { BFD_RELOC_8_PCREL
, R_MN10300_PCREL8
, },
300 { BFD_RELOC_24
, R_MN10300_24
, },
301 { BFD_RELOC_VTABLE_INHERIT
, R_MN10300_GNU_VTINHERIT
},
302 { BFD_RELOC_VTABLE_ENTRY
, R_MN10300_GNU_VTENTRY
},
305 static reloc_howto_type
*
306 bfd_elf32_bfd_reloc_type_lookup (abfd
, code
)
307 bfd
*abfd ATTRIBUTE_UNUSED
;
308 bfd_reloc_code_real_type code
;
313 i
< sizeof (mn10300_reloc_map
) / sizeof (struct mn10300_reloc_map
);
316 if (mn10300_reloc_map
[i
].bfd_reloc_val
== code
)
317 return &elf_mn10300_howto_table
[mn10300_reloc_map
[i
].elf_reloc_val
];
323 /* Set the howto pointer for an MN10300 ELF reloc. */
326 mn10300_info_to_howto (abfd
, cache_ptr
, dst
)
327 bfd
*abfd ATTRIBUTE_UNUSED
;
329 Elf32_Internal_Rela
*dst
;
333 r_type
= ELF32_R_TYPE (dst
->r_info
);
334 BFD_ASSERT (r_type
< (unsigned int) R_MN10300_MAX
);
335 cache_ptr
->howto
= &elf_mn10300_howto_table
[r_type
];
338 /* Look through the relocs for a section during the first phase.
339 Since we don't do .gots or .plts, we just need to consider the
340 virtual table relocs for gc. */
343 mn10300_elf_check_relocs (abfd
, info
, sec
, relocs
)
345 struct bfd_link_info
*info
;
347 const Elf_Internal_Rela
*relocs
;
349 Elf_Internal_Shdr
*symtab_hdr
;
350 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
351 const Elf_Internal_Rela
*rel
;
352 const Elf_Internal_Rela
*rel_end
;
354 if (info
->relocateable
)
357 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
358 sym_hashes
= elf_sym_hashes (abfd
);
359 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
360 if (!elf_bad_symtab (abfd
))
361 sym_hashes_end
-= symtab_hdr
->sh_info
;
363 rel_end
= relocs
+ sec
->reloc_count
;
364 for (rel
= relocs
; rel
< rel_end
; rel
++)
366 struct elf_link_hash_entry
*h
;
367 unsigned long r_symndx
;
369 r_symndx
= ELF32_R_SYM (rel
->r_info
);
370 if (r_symndx
< symtab_hdr
->sh_info
)
373 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
375 switch (ELF32_R_TYPE (rel
->r_info
))
377 /* This relocation describes the C++ object vtable hierarchy.
378 Reconstruct it for later use during GC. */
379 case R_MN10300_GNU_VTINHERIT
:
380 if (!_bfd_elf32_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
384 /* This relocation describes which C++ vtable entries are actually
385 used. Record for later use during GC. */
386 case R_MN10300_GNU_VTENTRY
:
387 if (!_bfd_elf32_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
396 /* Return the section that should be marked against GC for a given
400 mn10300_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
)
402 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
403 Elf_Internal_Rela
*rel
;
404 struct elf_link_hash_entry
*h
;
405 Elf_Internal_Sym
*sym
;
409 switch (ELF32_R_TYPE (rel
->r_info
))
411 case R_MN10300_GNU_VTINHERIT
:
412 case R_MN10300_GNU_VTENTRY
:
416 switch (h
->root
.type
)
418 case bfd_link_hash_defined
:
419 case bfd_link_hash_defweak
:
420 return h
->root
.u
.def
.section
;
422 case bfd_link_hash_common
:
423 return h
->root
.u
.c
.p
->section
;
431 return bfd_section_from_elf_index (sec
->owner
, sym
->st_shndx
);
436 /* Perform a relocation as part of a final link. */
437 static bfd_reloc_status_type
438 mn10300_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
439 input_section
, contents
, offset
, value
,
440 addend
, info
, sym_sec
, is_local
)
441 reloc_howto_type
*howto
;
443 bfd
*output_bfd ATTRIBUTE_UNUSED
;
444 asection
*input_section
;
449 struct bfd_link_info
*info ATTRIBUTE_UNUSED
;
450 asection
*sym_sec ATTRIBUTE_UNUSED
;
451 int is_local ATTRIBUTE_UNUSED
;
453 unsigned long r_type
= howto
->type
;
454 bfd_byte
*hit_data
= contents
+ offset
;
463 bfd_put_32 (input_bfd
, value
, hit_data
);
469 if ((long) value
> 0x7fffff || (long) value
< -0x800000)
470 return bfd_reloc_overflow
;
472 bfd_put_8 (input_bfd
, value
& 0xff, hit_data
);
473 bfd_put_8 (input_bfd
, (value
>> 8) & 0xff, hit_data
+ 1);
474 bfd_put_8 (input_bfd
, (value
>> 16) & 0xff, hit_data
+ 2);
480 if ((long) value
> 0x7fff || (long) value
< -0x8000)
481 return bfd_reloc_overflow
;
483 bfd_put_16 (input_bfd
, value
, hit_data
);
489 if ((long) value
> 0x7f || (long) value
< -0x80)
490 return bfd_reloc_overflow
;
492 bfd_put_8 (input_bfd
, value
, hit_data
);
495 case R_MN10300_PCREL8
:
496 value
-= (input_section
->output_section
->vma
497 + input_section
->output_offset
);
501 if ((long) value
> 0xff || (long) value
< -0x100)
502 return bfd_reloc_overflow
;
504 bfd_put_8 (input_bfd
, value
, hit_data
);
507 case R_MN10300_PCREL16
:
508 value
-= (input_section
->output_section
->vma
509 + input_section
->output_offset
);
513 if ((long) value
> 0xffff || (long) value
< -0x10000)
514 return bfd_reloc_overflow
;
516 bfd_put_16 (input_bfd
, value
, hit_data
);
519 case R_MN10300_PCREL32
:
520 value
-= (input_section
->output_section
->vma
521 + input_section
->output_offset
);
525 bfd_put_32 (input_bfd
, value
, hit_data
);
528 case R_MN10300_GNU_VTINHERIT
:
529 case R_MN10300_GNU_VTENTRY
:
533 return bfd_reloc_notsupported
;
537 /* Relocate an MN10300 ELF section. */
539 mn10300_elf_relocate_section (output_bfd
, info
, input_bfd
, input_section
,
540 contents
, relocs
, local_syms
, local_sections
)
542 struct bfd_link_info
*info
;
544 asection
*input_section
;
546 Elf_Internal_Rela
*relocs
;
547 Elf_Internal_Sym
*local_syms
;
548 asection
**local_sections
;
550 Elf_Internal_Shdr
*symtab_hdr
;
551 struct elf32_mn10300_link_hash_entry
**sym_hashes
;
552 Elf_Internal_Rela
*rel
, *relend
;
554 if (info
->relocateable
)
557 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
558 sym_hashes
= (struct elf32_mn10300_link_hash_entry
**)
559 (elf_sym_hashes (input_bfd
));
562 relend
= relocs
+ input_section
->reloc_count
;
563 for (; rel
< relend
; rel
++)
566 reloc_howto_type
*howto
;
567 unsigned long r_symndx
;
568 Elf_Internal_Sym
*sym
;
570 struct elf32_mn10300_link_hash_entry
*h
;
572 bfd_reloc_status_type r
;
574 r_symndx
= ELF32_R_SYM (rel
->r_info
);
575 r_type
= ELF32_R_TYPE (rel
->r_info
);
576 howto
= elf_mn10300_howto_table
+ r_type
;
578 /* Just skip the vtable gc relocs. */
579 if (r_type
== R_MN10300_GNU_VTINHERIT
580 || r_type
== R_MN10300_GNU_VTENTRY
)
586 if (r_symndx
< symtab_hdr
->sh_info
)
588 sym
= local_syms
+ r_symndx
;
589 sec
= local_sections
[r_symndx
];
590 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, sec
, rel
);
594 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
595 while (h
->root
.root
.type
== bfd_link_hash_indirect
596 || h
->root
.root
.type
== bfd_link_hash_warning
)
597 h
= (struct elf32_mn10300_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
598 if (h
->root
.root
.type
== bfd_link_hash_defined
599 || h
->root
.root
.type
== bfd_link_hash_defweak
)
601 sec
= h
->root
.root
.u
.def
.section
;
602 relocation
= (h
->root
.root
.u
.def
.value
603 + sec
->output_section
->vma
604 + sec
->output_offset
);
606 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
610 if (! ((*info
->callbacks
->undefined_symbol
)
611 (info
, h
->root
.root
.root
.string
, input_bfd
,
612 input_section
, rel
->r_offset
, true)))
618 r
= mn10300_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
620 contents
, rel
->r_offset
,
621 relocation
, rel
->r_addend
,
622 info
, sec
, h
== NULL
);
624 if (r
!= bfd_reloc_ok
)
627 const char *msg
= (const char *) 0;
630 name
= h
->root
.root
.root
.string
;
633 name
= (bfd_elf_string_from_elf_section
634 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
635 if (name
== NULL
|| *name
== '\0')
636 name
= bfd_section_name (input_bfd
, sec
);
641 case bfd_reloc_overflow
:
642 if (! ((*info
->callbacks
->reloc_overflow
)
643 (info
, name
, howto
->name
, (bfd_vma
) 0,
644 input_bfd
, input_section
, rel
->r_offset
)))
648 case bfd_reloc_undefined
:
649 if (! ((*info
->callbacks
->undefined_symbol
)
650 (info
, name
, input_bfd
, input_section
,
651 rel
->r_offset
, true)))
655 case bfd_reloc_outofrange
:
656 msg
= _("internal error: out of range error");
659 case bfd_reloc_notsupported
:
660 msg
= _("internal error: unsupported relocation error");
663 case bfd_reloc_dangerous
:
664 msg
= _("internal error: dangerous error");
668 msg
= _("internal error: unknown error");
672 if (!((*info
->callbacks
->warning
)
673 (info
, msg
, name
, input_bfd
, input_section
,
684 /* Finish initializing one hash table entry. */
686 elf32_mn10300_finish_hash_table_entry (gen_entry
, in_args
)
687 struct bfd_hash_entry
*gen_entry
;
688 PTR in_args ATTRIBUTE_UNUSED
;
690 struct elf32_mn10300_link_hash_entry
*entry
;
691 unsigned int byte_count
= 0;
693 entry
= (struct elf32_mn10300_link_hash_entry
*) gen_entry
;
695 if (entry
->root
.root
.type
== bfd_link_hash_warning
)
696 entry
= (struct elf32_mn10300_link_hash_entry
*) entry
->root
.root
.u
.i
.link
;
698 /* If we already know we want to convert "call" to "calls" for calls
699 to this symbol, then return now. */
700 if (entry
->flags
== MN10300_CONVERT_CALL_TO_CALLS
)
703 /* If there are no named calls to this symbol, or there's nothing we
704 can move from the function itself into the "call" instruction, then
705 note that all "call" instructions should be converted into "calls"
706 instructions and return. */
707 if (entry
->direct_calls
== 0
708 || (entry
->stack_size
== 0 && entry
->movm_args
== 0))
710 /* Make a note that we should convert "call" instructions to "calls"
711 instructions for calls to this symbol. */
712 entry
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
716 /* We may be able to move some instructions from the function itself into
717 the "call" instruction. Count how many bytes we might be able to
718 eliminate in the function itself. */
720 /* A movm instruction is two bytes. */
721 if (entry
->movm_args
)
724 /* Count the insn to allocate stack space too. */
725 if (entry
->stack_size
> 0 && entry
->stack_size
<= 128)
727 else if (entry
->stack_size
> 0 && entry
->stack_size
< 256)
730 /* If using "call" will result in larger code, then turn all
731 the associated "call" instructions into "calls" instrutions. */
732 if (byte_count
< entry
->direct_calls
)
733 entry
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
735 /* This routine never fails. */
739 /* This function handles relaxing for the mn10300.
741 There's quite a few relaxing opportunites available on the mn10300:
743 * calls:32 -> calls:16 2 bytes
744 * call:32 -> call:16 2 bytes
746 * call:32 -> calls:32 1 byte
747 * call:16 -> calls:16 1 byte
748 * These are done anytime using "calls" would result
749 in smaller code, or when necessary to preserve the
750 meaning of the program.
754 * In some circumstances we can move instructions
755 from a function prologue into a "call" instruction.
756 This is only done if the resulting code is no larger
757 than the original code.
759 * jmp:32 -> jmp:16 2 bytes
760 * jmp:16 -> bra:8 1 byte
762 * If the previous instruction is a conditional branch
763 around the jump/bra, we may be able to reverse its condition
764 and change its target to the jump's target. The jump/bra
765 can then be deleted. 2 bytes
767 * mov abs32 -> mov abs16 1 or 2 bytes
769 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
770 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
772 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
773 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
775 We don't handle imm16->imm8 or d16->d8 as they're very rare
776 and somewhat more difficult to support. */
779 mn10300_elf_relax_section (abfd
, sec
, link_info
, again
)
782 struct bfd_link_info
*link_info
;
785 Elf_Internal_Shdr
*symtab_hdr
;
786 Elf_Internal_Shdr
*shndx_hdr
;
787 Elf_Internal_Rela
*internal_relocs
= NULL
;
788 Elf_Internal_Rela
*free_relocs
= NULL
;
789 Elf_Internal_Rela
*irel
, *irelend
;
790 bfd_byte
*contents
= NULL
;
791 bfd_byte
*free_contents
= NULL
;
792 Elf32_External_Sym
*extsyms
= NULL
;
793 Elf32_External_Sym
*free_extsyms
= NULL
;
794 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
795 struct elf32_mn10300_link_hash_table
*hash_table
;
797 /* Assume nothing changes. */
800 /* We need a pointer to the mn10300 specific hash table. */
801 hash_table
= elf32_mn10300_hash_table (link_info
);
803 /* Initialize fields in each hash table entry the first time through. */
804 if ((hash_table
->flags
& MN10300_HASH_ENTRIES_INITIALIZED
) == 0)
808 /* Iterate over all the input bfds. */
809 for (input_bfd
= link_info
->input_bfds
;
811 input_bfd
= input_bfd
->link_next
)
815 /* We're going to need all the symbols for each bfd. */
816 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
817 shndx_hdr
= &elf_tdata (input_bfd
)->symtab_shndx_hdr
;
819 /* Get cached copy if it exists. */
820 if (symtab_hdr
->contents
!= NULL
)
821 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
824 /* Go get them off disk. */
827 amt
= symtab_hdr
->sh_info
;
828 amt
*= sizeof (Elf32_External_Sym
);
829 extsyms
= (Elf32_External_Sym
*) bfd_malloc (amt
);
832 free_extsyms
= extsyms
;
833 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
834 || bfd_bread ((PTR
) extsyms
, amt
, input_bfd
) != amt
)
838 if (shndx_hdr
->sh_size
!= 0)
842 amt
= symtab_hdr
->sh_info
;
843 amt
*= sizeof (Elf_External_Sym_Shndx
);
844 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
845 if (shndx_buf
== NULL
)
847 if (bfd_seek (input_bfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
848 || bfd_bread ((PTR
) shndx_buf
, amt
, input_bfd
) != amt
)
852 /* Iterate over each section in this bfd. */
853 for (section
= input_bfd
->sections
;
855 section
= section
->next
)
857 struct elf32_mn10300_link_hash_entry
*hash
;
858 Elf_Internal_Sym
*sym
;
859 asection
*sym_sec
= NULL
;
860 const char *sym_name
;
863 /* If there's nothing to do in this section, skip it. */
864 if (! (((section
->flags
& SEC_RELOC
) != 0
865 && section
->reloc_count
!= 0)
866 || (section
->flags
& SEC_CODE
) != 0))
869 /* Get cached copy of section contents if it exists. */
870 if (elf_section_data (section
)->this_hdr
.contents
!= NULL
)
871 contents
= elf_section_data (section
)->this_hdr
.contents
;
872 else if (section
->_raw_size
!= 0)
874 /* Go get them off disk. */
875 contents
= (bfd_byte
*) bfd_malloc (section
->_raw_size
);
876 if (contents
== NULL
)
878 free_contents
= contents
;
880 if (!bfd_get_section_contents (input_bfd
, section
,
881 contents
, (file_ptr
) 0,
888 free_contents
= NULL
;
891 /* If there aren't any relocs, then there's nothing to do. */
892 if ((section
->flags
& SEC_RELOC
) != 0
893 && section
->reloc_count
!= 0)
896 /* Get a copy of the native relocations. */
897 internal_relocs
= (_bfd_elf32_link_read_relocs
898 (input_bfd
, section
, (PTR
) NULL
,
899 (Elf_Internal_Rela
*) NULL
,
900 link_info
->keep_memory
));
901 if (internal_relocs
== NULL
)
903 if (! link_info
->keep_memory
)
904 free_relocs
= internal_relocs
;
906 /* Now examine each relocation. */
907 irel
= internal_relocs
;
908 irelend
= irel
+ section
->reloc_count
;
909 for (; irel
< irelend
; irel
++)
912 unsigned long r_index
;
915 r_type
= ELF32_R_TYPE (irel
->r_info
);
916 r_index
= ELF32_R_SYM (irel
->r_info
);
918 if (r_type
< 0 || r_type
>= (int) R_MN10300_MAX
)
921 /* We need the name and hash table entry of the target
927 if (r_index
< symtab_hdr
->sh_info
)
929 /* A local symbol. */
930 Elf32_External_Sym
*esym
;
931 Elf_External_Sym_Shndx
*shndx
;
932 Elf_Internal_Sym isym
;
933 struct elf_link_hash_table
*elftab
;
936 esym
= extsyms
+ r_index
;
937 shndx
= shndx_buf
+ (shndx_buf
? r_index
: 0);
938 bfd_elf32_swap_symbol_in (input_bfd
,
943 if (isym
.st_shndx
== SHN_UNDEF
)
944 sym_sec
= bfd_und_section_ptr
;
945 else if (isym
.st_shndx
== SHN_ABS
)
946 sym_sec
= bfd_abs_section_ptr
;
947 else if (isym
.st_shndx
== SHN_COMMON
)
948 sym_sec
= bfd_com_section_ptr
;
951 = bfd_section_from_elf_index (input_bfd
,
955 = bfd_elf_string_from_elf_section (input_bfd
,
960 /* If it isn't a function, then we don't care
962 if (r_index
< symtab_hdr
->sh_info
963 && ELF_ST_TYPE (isym
.st_info
) != STT_FUNC
)
966 /* Tack on an ID so we can uniquely identify this
967 local symbol in the global hash table. */
968 amt
= strlen (sym_name
) + 10;
969 new_name
= bfd_malloc (amt
);
973 sprintf (new_name
, "%s_%08x",
974 sym_name
, (int) sym_sec
);
977 elftab
= &hash_table
->static_hash_table
->root
;
978 hash
= ((struct elf32_mn10300_link_hash_entry
*)
979 elf_link_hash_lookup (elftab
, sym_name
,
985 r_index
-= symtab_hdr
->sh_info
;
986 hash
= (struct elf32_mn10300_link_hash_entry
*)
987 elf_sym_hashes (input_bfd
)[r_index
];
990 /* If this is not a "call" instruction, then we
991 should convert "call" instructions to "calls"
993 code
= bfd_get_8 (input_bfd
,
994 contents
+ irel
->r_offset
- 1);
995 if (code
!= 0xdd && code
!= 0xcd)
996 hash
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
998 /* If this is a jump/call, then bump the direct_calls
999 counter. Else force "call" to "calls" conversions. */
1000 if (r_type
== R_MN10300_PCREL32
1001 || r_type
== R_MN10300_PCREL16
)
1002 hash
->direct_calls
++;
1004 hash
->flags
|= MN10300_CONVERT_CALL_TO_CALLS
;
1008 /* Now look at the actual contents to get the stack size,
1009 and a list of what registers were saved in the prologue
1011 if ((section
->flags
& SEC_CODE
) != 0)
1014 Elf32_External_Sym
*esym
, *esymend
;
1015 Elf_External_Sym_Shndx
*shndx
;
1017 unsigned int sec_shndx
;
1019 sec_shndx
= _bfd_elf_section_from_bfd_section (input_bfd
,
1022 /* Look at each function defined in this section and
1023 update info for that function. */
1024 for (esym
= extsyms
, esymend
= esym
+ symtab_hdr
->sh_info
,
1027 esym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
1029 Elf_Internal_Sym isym
;
1031 bfd_elf32_swap_symbol_in (input_bfd
, (const PTR
) esym
,
1032 (const PTR
) shndx
, &isym
);
1033 if (isym
.st_shndx
== sec_shndx
1034 && ELF_ST_TYPE (isym
.st_info
) == STT_FUNC
)
1036 struct elf_link_hash_table
*elftab
;
1039 if (isym
.st_shndx
== SHN_UNDEF
)
1040 sym_sec
= bfd_und_section_ptr
;
1041 else if (isym
.st_shndx
== SHN_ABS
)
1042 sym_sec
= bfd_abs_section_ptr
;
1043 else if (isym
.st_shndx
== SHN_COMMON
)
1044 sym_sec
= bfd_com_section_ptr
;
1047 = bfd_section_from_elf_index (input_bfd
,
1050 sym_name
= (bfd_elf_string_from_elf_section
1051 (input_bfd
, symtab_hdr
->sh_link
,
1054 /* Tack on an ID so we can uniquely identify this
1055 local symbol in the global hash table. */
1056 amt
= strlen (sym_name
) + 10;
1057 new_name
= bfd_malloc (amt
);
1061 sprintf (new_name
, "%s_%08x",
1062 sym_name
, (int) sym_sec
);
1063 sym_name
= new_name
;
1065 elftab
= &hash_table
->static_hash_table
->root
;
1066 hash
= ((struct elf32_mn10300_link_hash_entry
*)
1067 elf_link_hash_lookup (elftab
, sym_name
,
1068 true, true, false));
1070 compute_function_info (input_bfd
, hash
,
1071 isym
.st_value
, contents
);
1075 esym
= extsyms
+ symtab_hdr
->sh_info
;
1076 esymend
= extsyms
+ (symtab_hdr
->sh_size
1077 / sizeof (Elf32_External_Sym
));
1078 for (idx
= 0; esym
< esymend
; esym
++, idx
++)
1080 Elf_Internal_Sym isym
;
1082 hash
= (struct elf32_mn10300_link_hash_entry
*)
1083 elf_sym_hashes (input_bfd
)[idx
];
1084 if ((hash
->root
.root
.type
== bfd_link_hash_defined
1085 || hash
->root
.root
.type
== bfd_link_hash_defweak
)
1086 && hash
->root
.root
.u
.def
.section
== section
1087 && ELF_ST_TYPE (isym
.st_info
) == STT_FUNC
)
1088 compute_function_info (input_bfd
, hash
,
1089 (hash
)->root
.root
.u
.def
.value
,
1094 /* Cache or free any memory we allocated for the relocs. */
1095 if (free_relocs
!= NULL
)
1101 /* Cache or free any memory we allocated for the contents. */
1102 if (free_contents
!= NULL
)
1104 if (! link_info
->keep_memory
)
1105 free (free_contents
);
1108 /* Cache the section contents for elf_link_input_bfd. */
1109 elf_section_data (section
)->this_hdr
.contents
= contents
;
1111 free_contents
= NULL
;
1115 if (shndx_buf
!= NULL
)
1121 /* Cache or free any memory we allocated for the symbols. */
1122 if (free_extsyms
!= NULL
)
1124 if (! link_info
->keep_memory
)
1125 free (free_extsyms
);
1128 /* Cache the symbols for elf_link_input_bfd. */
1129 symtab_hdr
->contents
= (unsigned char *) extsyms
;
1131 free_extsyms
= NULL
;
1135 /* Now iterate on each symbol in the hash table and perform
1136 the final initialization steps on each. */
1137 elf32_mn10300_link_hash_traverse (hash_table
,
1138 elf32_mn10300_finish_hash_table_entry
,
1140 elf32_mn10300_link_hash_traverse (hash_table
->static_hash_table
,
1141 elf32_mn10300_finish_hash_table_entry
,
1144 /* All entries in the hash table are fully initialized. */
1145 hash_table
->flags
|= MN10300_HASH_ENTRIES_INITIALIZED
;
1147 /* Now that everything has been initialized, go through each
1148 code section and delete any prologue insns which will be
1149 redundant because their operations will be performed by
1150 a "call" instruction. */
1151 for (input_bfd
= link_info
->input_bfds
;
1153 input_bfd
= input_bfd
->link_next
)
1157 /* We're going to need all the local symbols for each bfd. */
1158 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1159 shndx_hdr
= &elf_tdata (input_bfd
)->symtab_shndx_hdr
;
1161 /* Get cached copy if it exists. */
1162 if (symtab_hdr
->contents
!= NULL
)
1163 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1166 /* Go get them off disk. */
1169 amt
= symtab_hdr
->sh_info
;
1170 amt
*= sizeof (Elf32_External_Sym
);
1171 extsyms
= (Elf32_External_Sym
*) bfd_malloc (amt
);
1172 if (extsyms
== NULL
)
1174 free_extsyms
= extsyms
;
1175 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1176 || bfd_bread ((PTR
) extsyms
, amt
, input_bfd
) != amt
)
1178 symtab_hdr
->contents
= (bfd_byte
*) extsyms
;
1181 if (shndx_hdr
->sh_size
!= 0)
1185 amt
= symtab_hdr
->sh_info
;
1186 amt
*= sizeof (Elf_External_Sym_Shndx
);
1187 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1188 if (shndx_buf
== NULL
)
1190 if (bfd_seek (input_bfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1191 || bfd_bread ((PTR
) shndx_buf
, amt
, input_bfd
) != amt
)
1193 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1196 /* Walk over each section in this bfd. */
1197 for (section
= input_bfd
->sections
;
1199 section
= section
->next
)
1201 unsigned int sec_shndx
;
1202 Elf32_External_Sym
*esym
, *esymend
;
1203 Elf_External_Sym_Shndx
*shndx
;
1206 /* Skip non-code sections and empty sections. */
1207 if ((section
->flags
& SEC_CODE
) == 0 || section
->_raw_size
== 0)
1210 if (section
->reloc_count
!= 0)
1212 /* Get a copy of the native relocations. */
1213 internal_relocs
= (_bfd_elf32_link_read_relocs
1214 (input_bfd
, section
, (PTR
) NULL
,
1215 (Elf_Internal_Rela
*) NULL
,
1216 link_info
->keep_memory
));
1217 if (internal_relocs
== NULL
)
1219 if (! link_info
->keep_memory
)
1220 free_relocs
= internal_relocs
;
1223 /* Get cached copy of section contents if it exists. */
1224 if (elf_section_data (section
)->this_hdr
.contents
!= NULL
)
1225 contents
= elf_section_data (section
)->this_hdr
.contents
;
1228 /* Go get them off disk. */
1229 contents
= (bfd_byte
*) bfd_malloc (section
->_raw_size
);
1230 if (contents
== NULL
)
1232 free_contents
= contents
;
1234 if (!bfd_get_section_contents (input_bfd
, section
,
1235 contents
, (file_ptr
) 0,
1236 section
->_raw_size
))
1240 sec_shndx
= _bfd_elf_section_from_bfd_section (input_bfd
,
1243 /* Now look for any function in this section which needs
1244 insns deleted from its prologue. */
1245 for (esym
= extsyms
, esymend
= esym
+ symtab_hdr
->sh_info
,
1248 esym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
1250 Elf_Internal_Sym isym
;
1251 struct elf32_mn10300_link_hash_entry
*sym_hash
;
1252 asection
*sym_sec
= NULL
;
1253 const char *sym_name
;
1255 struct elf_link_hash_table
*elftab
;
1258 bfd_elf32_swap_symbol_in (input_bfd
, (const PTR
) esym
,
1259 (const PTR
) shndx
, &isym
);
1261 if (isym
.st_shndx
!= sec_shndx
)
1264 if (isym
.st_shndx
== SHN_UNDEF
)
1265 sym_sec
= bfd_und_section_ptr
;
1266 else if (isym
.st_shndx
== SHN_ABS
)
1267 sym_sec
= bfd_abs_section_ptr
;
1268 else if (isym
.st_shndx
== SHN_COMMON
)
1269 sym_sec
= bfd_com_section_ptr
;
1272 = bfd_section_from_elf_index (input_bfd
, isym
.st_shndx
);
1275 = bfd_elf_string_from_elf_section (input_bfd
,
1276 symtab_hdr
->sh_link
,
1279 /* Tack on an ID so we can uniquely identify this
1280 local symbol in the global hash table. */
1281 amt
= strlen (sym_name
) + 10;
1282 new_name
= bfd_malloc (amt
);
1285 sprintf (new_name
, "%s_%08x", sym_name
, (int) sym_sec
);
1286 sym_name
= new_name
;
1288 elftab
= &hash_table
->static_hash_table
->root
;
1289 sym_hash
= ((struct elf32_mn10300_link_hash_entry
*)
1290 elf_link_hash_lookup (elftab
, sym_name
,
1291 false, false, false));
1294 if (sym_hash
== NULL
)
1297 if (! (sym_hash
->flags
& MN10300_CONVERT_CALL_TO_CALLS
)
1298 && ! (sym_hash
->flags
& MN10300_DELETED_PROLOGUE_BYTES
))
1302 /* Note that we've changed things. */
1303 elf_section_data (section
)->relocs
= internal_relocs
;
1306 elf_section_data (section
)->this_hdr
.contents
= contents
;
1307 free_contents
= NULL
;
1309 free_extsyms
= NULL
;
1311 /* Count how many bytes we're going to delete. */
1312 if (sym_hash
->movm_args
)
1315 if (sym_hash
->stack_size
&& sym_hash
->stack_size
<= 128)
1317 else if (sym_hash
->stack_size
1318 && sym_hash
->stack_size
< 256)
1321 /* Note that we've deleted prologue bytes for this
1323 sym_hash
->flags
|= MN10300_DELETED_PROLOGUE_BYTES
;
1325 /* Actually delete the bytes. */
1326 if (!mn10300_elf_relax_delete_bytes (input_bfd
,
1332 /* Something changed. Not strictly necessary, but
1333 may lead to more relaxing opportunities. */
1338 /* Look for any global functions in this section which
1339 need insns deleted from their prologues. */
1341 idx
< (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1342 - symtab_hdr
->sh_info
);
1345 struct elf32_mn10300_link_hash_entry
*sym_hash
;
1347 sym_hash
= (struct elf32_mn10300_link_hash_entry
*)
1348 (elf_sym_hashes (input_bfd
)[idx
]);
1349 if ((sym_hash
->root
.root
.type
== bfd_link_hash_defined
1350 || sym_hash
->root
.root
.type
== bfd_link_hash_defweak
)
1351 && sym_hash
->root
.root
.u
.def
.section
== section
1352 && ! (sym_hash
->flags
& MN10300_CONVERT_CALL_TO_CALLS
)
1353 && ! (sym_hash
->flags
& MN10300_DELETED_PROLOGUE_BYTES
))
1358 /* Note that we've changed things. */
1359 elf_section_data (section
)->relocs
= internal_relocs
;
1362 elf_section_data (section
)->this_hdr
.contents
= contents
;
1363 free_contents
= NULL
;
1365 free_extsyms
= NULL
;
1367 /* Count how many bytes we're going to delete. */
1368 if (sym_hash
->movm_args
)
1371 if (sym_hash
->stack_size
&& sym_hash
->stack_size
<= 128)
1373 else if (sym_hash
->stack_size
1374 && sym_hash
->stack_size
< 256)
1377 /* Note that we've deleted prologue bytes for this
1379 sym_hash
->flags
|= MN10300_DELETED_PROLOGUE_BYTES
;
1381 /* Actually delete the bytes. */
1382 symval
= sym_hash
->root
.root
.u
.def
.value
;
1383 if (!mn10300_elf_relax_delete_bytes (input_bfd
,
1389 /* Something changed. Not strictly necessary, but
1390 may lead to more relaxing opportunities. */
1395 /* Cache or free any memory we allocated for the relocs. */
1396 if (free_relocs
!= NULL
)
1402 /* Cache or free any memory we allocated for the contents. */
1403 if (free_contents
!= NULL
)
1405 if (! link_info
->keep_memory
)
1406 free (free_contents
);
1409 /* Cache the section contents for elf_link_input_bfd. */
1410 elf_section_data (section
)->this_hdr
.contents
= contents
;
1412 free_contents
= NULL
;
1416 if (shndx_buf
!= NULL
)
1418 shndx_hdr
->contents
= NULL
;
1423 /* Cache or free any memory we allocated for the symbols. */
1424 if (free_extsyms
!= NULL
)
1426 if (! link_info
->keep_memory
)
1428 symtab_hdr
->contents
= NULL
;
1429 free (free_extsyms
);
1431 free_extsyms
= NULL
;
1436 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
1439 internal_relocs
= NULL
;
1441 free_contents
= NULL
;
1442 free_extsyms
= NULL
;
1444 /* We don't have to do anything for a relocateable link, if
1445 this section does not have relocs, or if this is not a
1447 if (link_info
->relocateable
1448 || (sec
->flags
& SEC_RELOC
) == 0
1449 || sec
->reloc_count
== 0
1450 || (sec
->flags
& SEC_CODE
) == 0)
1453 /* If this is the first time we have been called for this section,
1454 initialize the cooked size. */
1455 if (sec
->_cooked_size
== 0)
1456 sec
->_cooked_size
= sec
->_raw_size
;
1458 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1459 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1461 /* Get a copy of the native relocations. */
1462 internal_relocs
= (_bfd_elf32_link_read_relocs
1463 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1464 link_info
->keep_memory
));
1465 if (internal_relocs
== NULL
)
1467 if (! link_info
->keep_memory
)
1468 free_relocs
= internal_relocs
;
1470 /* Walk through them looking for relaxing opportunities. */
1471 irelend
= internal_relocs
+ sec
->reloc_count
;
1472 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1475 struct elf32_mn10300_link_hash_entry
*h
= NULL
;
1477 /* If this isn't something that can be relaxed, then ignore
1479 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_NONE
1480 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_8
1481 || ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_MAX
)
1484 /* Get the section contents if we haven't done so already. */
1485 if (contents
== NULL
)
1487 /* Get cached copy if it exists. */
1488 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1489 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1492 /* Go get them off disk. */
1493 contents
= (bfd_byte
*) bfd_malloc (sec
->_raw_size
);
1494 if (contents
== NULL
)
1496 free_contents
= contents
;
1498 if (! bfd_get_section_contents (abfd
, sec
, contents
,
1499 (file_ptr
) 0, sec
->_raw_size
))
1504 /* Read this BFD's symbols if we haven't done so already. */
1505 if (extsyms
== NULL
)
1507 /* Get cached copy if it exists. */
1508 if (symtab_hdr
->contents
!= NULL
)
1509 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
1512 /* Go get them off disk. */
1515 amt
= symtab_hdr
->sh_info
;
1516 amt
*= sizeof (Elf32_External_Sym
);
1517 extsyms
= (Elf32_External_Sym
*) bfd_malloc (amt
);
1518 if (extsyms
== NULL
)
1520 free_extsyms
= extsyms
;
1521 if (bfd_seek (abfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
1522 || bfd_bread ((PTR
) extsyms
, amt
, abfd
) != amt
)
1524 symtab_hdr
->contents
= (bfd_byte
*) extsyms
;
1527 if (shndx_hdr
->sh_size
!= 0)
1531 amt
= symtab_hdr
->sh_info
;
1532 amt
*= sizeof (Elf_External_Sym_Shndx
);
1533 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1534 if (shndx_buf
== NULL
)
1536 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1537 || bfd_bread ((PTR
) shndx_buf
, amt
, abfd
) != amt
)
1539 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1543 /* Get the value of the symbol referred to by the reloc. */
1544 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1546 Elf32_External_Sym
*esym
;
1547 Elf_External_Sym_Shndx
*shndx
;
1548 Elf_Internal_Sym isym
;
1549 asection
*sym_sec
= NULL
;
1550 const char *sym_name
;
1553 /* A local symbol. */
1554 esym
= extsyms
+ ELF32_R_SYM (irel
->r_info
);
1555 shndx
= shndx_buf
+ (shndx_buf
? ELF32_R_SYM (irel
->r_info
) : 0);
1556 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
,
1557 (const PTR
) shndx
, &isym
);
1559 if (isym
.st_shndx
== SHN_UNDEF
)
1560 sym_sec
= bfd_und_section_ptr
;
1561 else if (isym
.st_shndx
== SHN_ABS
)
1562 sym_sec
= bfd_abs_section_ptr
;
1563 else if (isym
.st_shndx
== SHN_COMMON
)
1564 sym_sec
= bfd_com_section_ptr
;
1566 sym_sec
= bfd_section_from_elf_index (abfd
, isym
.st_shndx
);
1568 symval
= (isym
.st_value
1569 + sym_sec
->output_section
->vma
1570 + sym_sec
->output_offset
);
1571 sym_name
= bfd_elf_string_from_elf_section (abfd
,
1572 symtab_hdr
->sh_link
,
1575 /* Tack on an ID so we can uniquely identify this
1576 local symbol in the global hash table. */
1577 new_name
= bfd_malloc ((bfd_size_type
) strlen (sym_name
) + 10);
1580 sprintf (new_name
, "%s_%08x", sym_name
, (int) sym_sec
);
1581 sym_name
= new_name
;
1583 h
= (struct elf32_mn10300_link_hash_entry
*)
1584 elf_link_hash_lookup (&hash_table
->static_hash_table
->root
,
1585 sym_name
, false, false, false);
1592 /* An external symbol. */
1593 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1594 h
= (struct elf32_mn10300_link_hash_entry
*)
1595 (elf_sym_hashes (abfd
)[indx
]);
1596 BFD_ASSERT (h
!= NULL
);
1597 if (h
->root
.root
.type
!= bfd_link_hash_defined
1598 && h
->root
.root
.type
!= bfd_link_hash_defweak
)
1600 /* This appears to be a reference to an undefined
1601 symbol. Just ignore it--it will be caught by the
1602 regular reloc processing. */
1606 symval
= (h
->root
.root
.u
.def
.value
1607 + h
->root
.root
.u
.def
.section
->output_section
->vma
1608 + h
->root
.root
.u
.def
.section
->output_offset
);
1611 /* For simplicity of coding, we are going to modify the section
1612 contents, the section relocs, and the BFD symbol table. We
1613 must tell the rest of the code not to free up this
1614 information. It would be possible to instead create a table
1615 of changes which have to be made, as is done in coff-mips.c;
1616 that would be more work, but would require less memory when
1617 the linker is run. */
1619 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1620 branch/call, also deal with "call" -> "calls" conversions and
1621 insertion of prologue data into "call" instructions. */
1622 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PCREL32
)
1624 bfd_vma value
= symval
;
1626 /* If we've got a "call" instruction that needs to be turned
1627 into a "calls" instruction, do so now. It saves a byte. */
1628 if (h
&& (h
->flags
& MN10300_CONVERT_CALL_TO_CALLS
))
1632 /* Get the opcode. */
1633 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1635 /* Make sure we're working with a "call" instruction! */
1638 /* Note that we've changed the relocs, section contents,
1640 elf_section_data (sec
)->relocs
= internal_relocs
;
1643 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1644 free_contents
= NULL
;
1646 free_extsyms
= NULL
;
1648 /* Fix the opcode. */
1649 bfd_put_8 (abfd
, 0xfc, contents
+ irel
->r_offset
- 1);
1650 bfd_put_8 (abfd
, 0xff, contents
+ irel
->r_offset
);
1652 /* Fix irel->r_offset and irel->r_addend. */
1653 irel
->r_offset
+= 1;
1654 irel
->r_addend
+= 1;
1656 /* Delete one byte of data. */
1657 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
1658 irel
->r_offset
+ 3, 1))
1661 /* That will change things, so, we should relax again.
1662 Note that this is not required, and it may be slow. */
1668 /* We've got a "call" instruction which needs some data
1669 from target function filled in. */
1672 /* Get the opcode. */
1673 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1675 /* Insert data from the target function into the "call"
1676 instruction if needed. */
1679 bfd_put_8 (abfd
, h
->movm_args
, contents
+ irel
->r_offset
+ 4);
1680 bfd_put_8 (abfd
, h
->stack_size
+ h
->movm_stack_size
,
1681 contents
+ irel
->r_offset
+ 5);
1685 /* Deal with pc-relative gunk. */
1686 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1687 value
-= irel
->r_offset
;
1688 value
+= irel
->r_addend
;
1690 /* See if the value will fit in 16 bits, note the high value is
1691 0x7fff + 2 as the target will be two bytes closer if we are
1693 if ((long) value
< 0x8001 && (long) value
> -0x8000)
1697 /* Get the opcode. */
1698 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1700 if (code
!= 0xdc && code
!= 0xdd && code
!= 0xff)
1703 /* Note that we've changed the relocs, section contents, etc. */
1704 elf_section_data (sec
)->relocs
= internal_relocs
;
1707 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1708 free_contents
= NULL
;
1710 free_extsyms
= NULL
;
1712 /* Fix the opcode. */
1714 bfd_put_8 (abfd
, 0xcc, contents
+ irel
->r_offset
- 1);
1715 else if (code
== 0xdd)
1716 bfd_put_8 (abfd
, 0xcd, contents
+ irel
->r_offset
- 1);
1717 else if (code
== 0xff)
1718 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
1720 /* Fix the relocation's type. */
1721 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1724 /* Delete two bytes of data. */
1725 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
1726 irel
->r_offset
+ 1, 2))
1729 /* That will change things, so, we should relax again.
1730 Note that this is not required, and it may be slow. */
1735 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1737 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PCREL16
)
1739 bfd_vma value
= symval
;
1741 /* If we've got a "call" instruction that needs to be turned
1742 into a "calls" instruction, do so now. It saves a byte. */
1743 if (h
&& (h
->flags
& MN10300_CONVERT_CALL_TO_CALLS
))
1747 /* Get the opcode. */
1748 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1750 /* Make sure we're working with a "call" instruction! */
1753 /* Note that we've changed the relocs, section contents,
1755 elf_section_data (sec
)->relocs
= internal_relocs
;
1758 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1759 free_contents
= NULL
;
1761 free_extsyms
= NULL
;
1763 /* Fix the opcode. */
1764 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 1);
1765 bfd_put_8 (abfd
, 0xff, contents
+ irel
->r_offset
);
1767 /* Fix irel->r_offset and irel->r_addend. */
1768 irel
->r_offset
+= 1;
1769 irel
->r_addend
+= 1;
1771 /* Delete one byte of data. */
1772 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
1773 irel
->r_offset
+ 1, 1))
1776 /* That will change things, so, we should relax again.
1777 Note that this is not required, and it may be slow. */
1785 /* Get the opcode. */
1786 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1788 /* Insert data from the target function into the "call"
1789 instruction if needed. */
1792 bfd_put_8 (abfd
, h
->movm_args
, contents
+ irel
->r_offset
+ 2);
1793 bfd_put_8 (abfd
, h
->stack_size
+ h
->movm_stack_size
,
1794 contents
+ irel
->r_offset
+ 3);
1798 /* Deal with pc-relative gunk. */
1799 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1800 value
-= irel
->r_offset
;
1801 value
+= irel
->r_addend
;
1803 /* See if the value will fit in 8 bits, note the high value is
1804 0x7f + 1 as the target will be one bytes closer if we are
1806 if ((long) value
< 0x80 && (long) value
> -0x80)
1810 /* Get the opcode. */
1811 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1816 /* Note that we've changed the relocs, section contents, etc. */
1817 elf_section_data (sec
)->relocs
= internal_relocs
;
1820 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1821 free_contents
= NULL
;
1823 free_extsyms
= NULL
;
1825 /* Fix the opcode. */
1826 bfd_put_8 (abfd
, 0xca, contents
+ irel
->r_offset
- 1);
1828 /* Fix the relocation's type. */
1829 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1832 /* Delete one byte of data. */
1833 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
1834 irel
->r_offset
+ 1, 1))
1837 /* That will change things, so, we should relax again.
1838 Note that this is not required, and it may be slow. */
1843 /* Try to eliminate an unconditional 8 bit pc-relative branch
1844 which immediately follows a conditional 8 bit pc-relative
1845 branch around the unconditional branch.
1852 This happens when the bCC can't reach lab2 at assembly time,
1853 but due to other relaxations it can reach at link time. */
1854 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_PCREL8
)
1856 Elf_Internal_Rela
*nrel
;
1857 bfd_vma value
= symval
;
1860 /* Deal with pc-relative gunk. */
1861 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1862 value
-= irel
->r_offset
;
1863 value
+= irel
->r_addend
;
1865 /* Do nothing if this reloc is the last byte in the section. */
1866 if (irel
->r_offset
== sec
->_cooked_size
)
1869 /* See if the next instruction is an unconditional pc-relative
1870 branch, more often than not this test will fail, so we
1871 test it first to speed things up. */
1872 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 1);
1876 /* Also make sure the next relocation applies to the next
1877 instruction and that it's a pc-relative 8 bit branch. */
1880 || irel
->r_offset
+ 2 != nrel
->r_offset
1881 || ELF32_R_TYPE (nrel
->r_info
) != (int) R_MN10300_PCREL8
)
1884 /* Make sure our destination immediately follows the
1885 unconditional branch. */
1886 if (symval
!= (sec
->output_section
->vma
+ sec
->output_offset
1887 + irel
->r_offset
+ 3))
1890 /* Now make sure we are a conditional branch. This may not
1891 be necessary, but why take the chance.
1893 Note these checks assume that R_MN10300_PCREL8 relocs
1894 only occur on bCC and bCCx insns. If they occured
1895 elsewhere, we'd need to know the start of this insn
1896 for this check to be accurate. */
1897 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
1898 if (code
!= 0xc0 && code
!= 0xc1 && code
!= 0xc2
1899 && code
!= 0xc3 && code
!= 0xc4 && code
!= 0xc5
1900 && code
!= 0xc6 && code
!= 0xc7 && code
!= 0xc8
1901 && code
!= 0xc9 && code
!= 0xe8 && code
!= 0xe9
1902 && code
!= 0xea && code
!= 0xeb)
1905 /* We also have to be sure there is no symbol/label
1906 at the unconditional branch. */
1907 if (mn10300_elf_symbol_address_p (abfd
, sec
, irel
->r_offset
+ 1))
1910 /* Note that we've changed the relocs, section contents, etc. */
1911 elf_section_data (sec
)->relocs
= internal_relocs
;
1914 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1915 free_contents
= NULL
;
1917 free_extsyms
= NULL
;
1919 /* Reverse the condition of the first branch. */
1965 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
1967 /* Set the reloc type and symbol for the first branch
1968 from the second branch. */
1969 irel
->r_info
= nrel
->r_info
;
1971 /* Make the reloc for the second branch a null reloc. */
1972 nrel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (nrel
->r_info
),
1975 /* Delete two bytes of data. */
1976 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
1977 irel
->r_offset
+ 1, 2))
1980 /* That will change things, so, we should relax again.
1981 Note that this is not required, and it may be slow. */
1985 /* Try to turn a 24 immediate, displacement or absolute address
1986 into a 8 immediate, displacement or absolute address. */
1987 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_24
)
1989 bfd_vma value
= symval
;
1990 value
+= irel
->r_addend
;
1992 /* See if the value will fit in 8 bits. */
1993 if ((long) value
< 0x7f && (long) value
> -0x80)
1997 /* AM33 insns which have 24 operands are 6 bytes long and
1998 will have 0xfd as the first byte. */
2000 /* Get the first opcode. */
2001 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 3);
2005 /* Get the second opcode. */
2006 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
2008 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2009 equivalent instructions exists. */
2010 if (code
!= 0x6b && code
!= 0x7b
2011 && code
!= 0x8b && code
!= 0x9b
2012 && ((code
& 0x0f) == 0x09 || (code
& 0x0f) == 0x08
2013 || (code
& 0x0f) == 0x0a || (code
& 0x0f) == 0x0b
2014 || (code
& 0x0f) == 0x0e))
2016 /* Not safe if the high bit is on as relaxing may
2017 move the value out of high mem and thus not fit
2018 in a signed 8bit value. This is currently over
2020 if ((value
& 0x80) == 0)
2022 /* Note that we've changed the relocation contents,
2024 elf_section_data (sec
)->relocs
= internal_relocs
;
2027 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2028 free_contents
= NULL
;
2030 free_extsyms
= NULL
;
2032 /* Fix the opcode. */
2033 bfd_put_8 (abfd
, 0xfb, contents
+ irel
->r_offset
- 3);
2034 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
2036 /* Fix the relocation's type. */
2038 ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2041 /* Delete two bytes of data. */
2042 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2043 irel
->r_offset
+ 1, 2))
2046 /* That will change things, so, we should relax
2047 again. Note that this is not required, and it
2057 /* Try to turn a 32bit immediate, displacement or absolute address
2058 into a 16bit immediate, displacement or absolute address. */
2059 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_MN10300_32
)
2061 bfd_vma value
= symval
;
2062 value
+= irel
->r_addend
;
2064 /* See if the value will fit in 24 bits.
2065 We allow any 16bit match here. We prune those we can't
2067 if ((long) value
< 0x7fffff && (long) value
> -0x800000)
2071 /* AM33 insns which have 32bit operands are 7 bytes long and
2072 will have 0xfe as the first byte. */
2074 /* Get the first opcode. */
2075 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 3);
2079 /* Get the second opcode. */
2080 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
2082 /* All the am33 32 -> 24 relaxing possibilities. */
2083 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2084 equivalent instructions exists. */
2085 if (code
!= 0x6b && code
!= 0x7b
2086 && code
!= 0x8b && code
!= 0x9b
2087 && ((code
& 0x0f) == 0x09 || (code
& 0x0f) == 0x08
2088 || (code
& 0x0f) == 0x0a || (code
& 0x0f) == 0x0b
2089 || (code
& 0x0f) == 0x0e))
2091 /* Not safe if the high bit is on as relaxing may
2092 move the value out of high mem and thus not fit
2093 in a signed 16bit value. This is currently over
2095 if ((value
& 0x8000) == 0)
2097 /* Note that we've changed the relocation contents,
2099 elf_section_data (sec
)->relocs
= internal_relocs
;
2102 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2103 free_contents
= NULL
;
2105 free_extsyms
= NULL
;
2107 /* Fix the opcode. */
2108 bfd_put_8 (abfd
, 0xfd, contents
+ irel
->r_offset
- 3);
2109 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
2111 /* Fix the relocation's type. */
2113 ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2116 /* Delete one byte of data. */
2117 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2118 irel
->r_offset
+ 3, 1))
2121 /* That will change things, so, we should relax
2122 again. Note that this is not required, and it
2131 /* See if the value will fit in 16 bits.
2132 We allow any 16bit match here. We prune those we can't
2134 if ((long) value
< 0x7fff && (long) value
> -0x8000)
2138 /* Most insns which have 32bit operands are 6 bytes long;
2139 exceptions are pcrel insns and bit insns.
2141 We handle pcrel insns above. We don't bother trying
2142 to handle the bit insns here.
2144 The first byte of the remaining insns will be 0xfc. */
2146 /* Get the first opcode. */
2147 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
2152 /* Get the second opcode. */
2153 code
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
2155 if ((code
& 0xf0) < 0x80)
2156 switch (code
& 0xf0)
2158 /* mov (d32,am),dn -> mov (d32,am),dn
2159 mov dm,(d32,am) -> mov dn,(d32,am)
2160 mov (d32,am),an -> mov (d32,am),an
2161 mov dm,(d32,am) -> mov dn,(d32,am)
2162 movbu (d32,am),dn -> movbu (d32,am),dn
2163 movbu dm,(d32,am) -> movbu dn,(d32,am)
2164 movhu (d32,am),dn -> movhu (d32,am),dn
2165 movhu dm,(d32,am) -> movhu dn,(d32,am) */
2174 /* Not safe if the high bit is on as relaxing may
2175 move the value out of high mem and thus not fit
2176 in a signed 16bit value. */
2178 && (value
& 0x8000))
2181 /* Note that we've changed the relocation contents, etc. */
2182 elf_section_data (sec
)->relocs
= internal_relocs
;
2185 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2186 free_contents
= NULL
;
2188 free_extsyms
= NULL
;
2190 /* Fix the opcode. */
2191 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
2192 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
2194 /* Fix the relocation's type. */
2195 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2198 /* Delete two bytes of data. */
2199 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2200 irel
->r_offset
+ 2, 2))
2203 /* That will change things, so, we should relax again.
2204 Note that this is not required, and it may be slow. */
2208 else if ((code
& 0xf0) == 0x80
2209 || (code
& 0xf0) == 0x90)
2210 switch (code
& 0xf3)
2212 /* mov dn,(abs32) -> mov dn,(abs16)
2213 movbu dn,(abs32) -> movbu dn,(abs16)
2214 movhu dn,(abs32) -> movhu dn,(abs16) */
2218 /* Note that we've changed the relocation contents, etc. */
2219 elf_section_data (sec
)->relocs
= internal_relocs
;
2222 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2223 free_contents
= NULL
;
2225 free_extsyms
= NULL
;
2227 if ((code
& 0xf3) == 0x81)
2228 code
= 0x01 + (code
& 0x0c);
2229 else if ((code
& 0xf3) == 0x82)
2230 code
= 0x02 + (code
& 0x0c);
2231 else if ((code
& 0xf3) == 0x83)
2232 code
= 0x03 + (code
& 0x0c);
2236 /* Fix the opcode. */
2237 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
2239 /* Fix the relocation's type. */
2240 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2243 /* The opcode got shorter too, so we have to fix the
2244 addend and offset too! */
2245 irel
->r_offset
-= 1;
2247 /* Delete three bytes of data. */
2248 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2249 irel
->r_offset
+ 1, 3))
2252 /* That will change things, so, we should relax again.
2253 Note that this is not required, and it may be slow. */
2257 /* mov am,(abs32) -> mov am,(abs16)
2258 mov am,(d32,sp) -> mov am,(d16,sp)
2259 mov dm,(d32,sp) -> mov dm,(d32,sp)
2260 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2261 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2267 /* sp-based offsets are zero-extended. */
2268 if (code
>= 0x90 && code
<= 0x93
2272 /* Note that we've changed the relocation contents, etc. */
2273 elf_section_data (sec
)->relocs
= internal_relocs
;
2276 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2277 free_contents
= NULL
;
2279 free_extsyms
= NULL
;
2281 /* Fix the opcode. */
2282 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
2283 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
2285 /* Fix the relocation's type. */
2286 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2289 /* Delete two bytes of data. */
2290 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2291 irel
->r_offset
+ 2, 2))
2294 /* That will change things, so, we should relax again.
2295 Note that this is not required, and it may be slow. */
2299 else if ((code
& 0xf0) < 0xf0)
2300 switch (code
& 0xfc)
2302 /* mov imm32,dn -> mov imm16,dn
2303 mov imm32,an -> mov imm16,an
2304 mov (abs32),dn -> mov (abs16),dn
2305 movbu (abs32),dn -> movbu (abs16),dn
2306 movhu (abs32),dn -> movhu (abs16),dn */
2312 /* Not safe if the high bit is on as relaxing may
2313 move the value out of high mem and thus not fit
2314 in a signed 16bit value. */
2316 && (value
& 0x8000))
2319 /* mov imm16, an zero-extends the immediate. */
2324 /* Note that we've changed the relocation contents, etc. */
2325 elf_section_data (sec
)->relocs
= internal_relocs
;
2328 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2329 free_contents
= NULL
;
2331 free_extsyms
= NULL
;
2333 if ((code
& 0xfc) == 0xcc)
2334 code
= 0x2c + (code
& 0x03);
2335 else if ((code
& 0xfc) == 0xdc)
2336 code
= 0x24 + (code
& 0x03);
2337 else if ((code
& 0xfc) == 0xa4)
2338 code
= 0x30 + (code
& 0x03);
2339 else if ((code
& 0xfc) == 0xa8)
2340 code
= 0x34 + (code
& 0x03);
2341 else if ((code
& 0xfc) == 0xac)
2342 code
= 0x38 + (code
& 0x03);
2346 /* Fix the opcode. */
2347 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 2);
2349 /* Fix the relocation's type. */
2350 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2353 /* The opcode got shorter too, so we have to fix the
2354 addend and offset too! */
2355 irel
->r_offset
-= 1;
2357 /* Delete three bytes of data. */
2358 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2359 irel
->r_offset
+ 1, 3))
2362 /* That will change things, so, we should relax again.
2363 Note that this is not required, and it may be slow. */
2367 /* mov (abs32),an -> mov (abs16),an
2368 mov (d32,sp),an -> mov (d16,sp),an
2369 mov (d32,sp),dn -> mov (d16,sp),dn
2370 movbu (d32,sp),dn -> movbu (d16,sp),dn
2371 movhu (d32,sp),dn -> movhu (d16,sp),dn
2372 add imm32,dn -> add imm16,dn
2373 cmp imm32,dn -> cmp imm16,dn
2374 add imm32,an -> add imm16,an
2375 cmp imm32,an -> cmp imm16,an
2376 and imm32,dn -> and imm16,dn
2377 or imm32,dn -> or imm16,dn
2378 xor imm32,dn -> xor imm16,dn
2379 btst imm32,dn -> btst imm16,dn */
2395 /* cmp imm16, an zero-extends the immediate. */
2400 /* So do sp-based offsets. */
2401 if (code
>= 0xb0 && code
<= 0xb3
2405 /* Note that we've changed the relocation contents, etc. */
2406 elf_section_data (sec
)->relocs
= internal_relocs
;
2409 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2410 free_contents
= NULL
;
2412 free_extsyms
= NULL
;
2414 /* Fix the opcode. */
2415 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
2416 bfd_put_8 (abfd
, code
, contents
+ irel
->r_offset
- 1);
2418 /* Fix the relocation's type. */
2419 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2422 /* Delete two bytes of data. */
2423 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2424 irel
->r_offset
+ 2, 2))
2427 /* That will change things, so, we should relax again.
2428 Note that this is not required, and it may be slow. */
2432 else if (code
== 0xfe)
2434 /* add imm32,sp -> add imm16,sp */
2436 /* Note that we've changed the relocation contents, etc. */
2437 elf_section_data (sec
)->relocs
= internal_relocs
;
2440 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2441 free_contents
= NULL
;
2443 free_extsyms
= NULL
;
2445 /* Fix the opcode. */
2446 bfd_put_8 (abfd
, 0xfa, contents
+ irel
->r_offset
- 2);
2447 bfd_put_8 (abfd
, 0xfe, contents
+ irel
->r_offset
- 1);
2449 /* Fix the relocation's type. */
2450 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2453 /* Delete two bytes of data. */
2454 if (!mn10300_elf_relax_delete_bytes (abfd
, sec
,
2455 irel
->r_offset
+ 2, 2))
2458 /* That will change things, so, we should relax again.
2459 Note that this is not required, and it may be slow. */
2467 if (free_relocs
!= NULL
)
2470 if (free_contents
!= NULL
)
2472 if (! link_info
->keep_memory
)
2473 free (free_contents
);
2476 /* Cache the section contents for elf_link_input_bfd. */
2477 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2481 if (shndx_buf
!= NULL
)
2483 shndx_hdr
->contents
= NULL
;
2487 if (free_extsyms
!= NULL
)
2489 if (! link_info
->keep_memory
)
2491 symtab_hdr
->contents
= NULL
;
2492 free (free_extsyms
);
2499 if (free_relocs
!= NULL
)
2501 if (free_contents
!= NULL
)
2502 free (free_contents
);
2503 if (shndx_buf
!= NULL
)
2505 shndx_hdr
->contents
= NULL
;
2508 if (free_extsyms
!= NULL
)
2510 symtab_hdr
->contents
= NULL
;
2511 free (free_extsyms
);
2517 /* Compute the stack size and movm arguments for the function
2518 referred to by HASH at address ADDR in section with
2519 contents CONTENTS, store the information in the hash table. */
2521 compute_function_info (abfd
, hash
, addr
, contents
)
2523 struct elf32_mn10300_link_hash_entry
*hash
;
2525 unsigned char *contents
;
2527 unsigned char byte1
, byte2
;
2528 /* We only care about a very small subset of the possible prologue
2529 sequences here. Basically we look for:
2531 movm [d2,d3,a2,a3],sp (optional)
2532 add <size>,sp (optional, and only for sizes which fit in an unsigned
2535 If we find anything else, we quit. */
2537 /* Look for movm [regs],sp */
2538 byte1
= bfd_get_8 (abfd
, contents
+ addr
);
2539 byte2
= bfd_get_8 (abfd
, contents
+ addr
+ 1);
2543 hash
->movm_args
= byte2
;
2545 byte1
= bfd_get_8 (abfd
, contents
+ addr
);
2546 byte2
= bfd_get_8 (abfd
, contents
+ addr
+ 1);
2549 /* Now figure out how much stack space will be allocated by the movm
2550 instruction. We need this kept separate from the funtion's normal
2552 if (hash
->movm_args
)
2555 if (hash
->movm_args
& 0x80)
2556 hash
->movm_stack_size
+= 4;
2559 if (hash
->movm_args
& 0x40)
2560 hash
->movm_stack_size
+= 4;
2563 if (hash
->movm_args
& 0x20)
2564 hash
->movm_stack_size
+= 4;
2567 if (hash
->movm_args
& 0x10)
2568 hash
->movm_stack_size
+= 4;
2570 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
2571 if (hash
->movm_args
& 0x08)
2572 hash
->movm_stack_size
+= 8 * 4;
2574 if (bfd_get_mach (abfd
) == bfd_mach_am33
)
2576 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
2577 if (hash
->movm_args
& 0x1)
2578 hash
->movm_stack_size
+= 6 * 4;
2580 /* exreg1 space. e4, e5, e6, e7 */
2581 if (hash
->movm_args
& 0x2)
2582 hash
->movm_stack_size
+= 4 * 4;
2584 /* exreg0 space. e2, e3 */
2585 if (hash
->movm_args
& 0x4)
2586 hash
->movm_stack_size
+= 2 * 4;
2590 /* Now look for the two stack adjustment variants. */
2591 if (byte1
== 0xf8 && byte2
== 0xfe)
2593 int temp
= bfd_get_8 (abfd
, contents
+ addr
+ 2);
2594 temp
= ((temp
& 0xff) ^ (~0x7f)) + 0x80;
2596 hash
->stack_size
= -temp
;
2598 else if (byte1
== 0xfa && byte2
== 0xfe)
2600 int temp
= bfd_get_16 (abfd
, contents
+ addr
+ 2);
2601 temp
= ((temp
& 0xffff) ^ (~0x7fff)) + 0x8000;
2605 hash
->stack_size
= temp
;
2608 /* If the total stack to be allocated by the call instruction is more
2609 than 255 bytes, then we can't remove the stack adjustment by using
2610 "call" (we might still be able to remove the "movm" instruction. */
2611 if (hash
->stack_size
+ hash
->movm_stack_size
> 255)
2612 hash
->stack_size
= 0;
2617 /* Delete some bytes from a section while relaxing. */
2620 mn10300_elf_relax_delete_bytes (abfd
, sec
, addr
, count
)
2626 Elf_Internal_Shdr
*symtab_hdr
;
2627 Elf_Internal_Shdr
*shndx_hdr
;
2628 Elf32_External_Sym
*extsyms
;
2629 unsigned int sec_shndx
;
2631 Elf_Internal_Rela
*irel
, *irelend
;
2632 Elf_Internal_Rela
*irelalign
;
2634 Elf32_External_Sym
*esym
, *esymend
;
2635 Elf_External_Sym_Shndx
*shndx
;
2636 struct elf_link_hash_entry
**sym_hashes
;
2637 struct elf_link_hash_entry
**end_hashes
;
2638 unsigned int symcount
;
2640 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2641 extsyms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
2643 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2645 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2647 /* The deletion must stop at the next ALIGN reloc for an aligment
2648 power larger than the number of bytes we are deleting. */
2651 toaddr
= sec
->_cooked_size
;
2653 irel
= elf_section_data (sec
)->relocs
;
2654 irelend
= irel
+ sec
->reloc_count
;
2656 /* Actually delete the bytes. */
2657 memmove (contents
+ addr
, contents
+ addr
+ count
,
2658 (size_t) (toaddr
- addr
- count
));
2659 sec
->_cooked_size
-= count
;
2661 /* Adjust all the relocs. */
2662 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
2664 /* Get the new reloc address. */
2665 if ((irel
->r_offset
> addr
2666 && irel
->r_offset
< toaddr
))
2667 irel
->r_offset
-= count
;
2670 /* Adjust the local symbols defined in this section. */
2671 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2672 shndx
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
2674 esymend
= esym
+ symtab_hdr
->sh_info
;
2675 for (; esym
< esymend
; esym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
2677 Elf_Internal_Sym isym
;
2678 Elf_External_Sym_Shndx dummy
;
2680 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
, (const PTR
) shndx
,
2683 if (isym
.st_shndx
== sec_shndx
2684 && isym
.st_value
> addr
2685 && isym
.st_value
< toaddr
)
2687 isym
.st_value
-= count
;
2688 bfd_elf32_swap_symbol_out (abfd
, &isym
, (PTR
) esym
, (PTR
) &dummy
);
2692 /* Now adjust the global symbols defined in this section. */
2693 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2694 - symtab_hdr
->sh_info
);
2695 sym_hashes
= elf_sym_hashes (abfd
);
2696 end_hashes
= sym_hashes
+ symcount
;
2697 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2699 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
2700 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2701 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2702 && sym_hash
->root
.u
.def
.section
== sec
2703 && sym_hash
->root
.u
.def
.value
> addr
2704 && sym_hash
->root
.u
.def
.value
< toaddr
)
2706 sym_hash
->root
.u
.def
.value
-= count
;
2713 /* Return true if a symbol exists at the given address, else return
2716 mn10300_elf_symbol_address_p (abfd
, sec
, addr
)
2721 Elf_Internal_Shdr
*symtab_hdr
;
2722 Elf_Internal_Shdr
*shndx_hdr
;
2723 unsigned int sec_shndx
;
2724 Elf32_External_Sym
*esym
, *esymend
;
2725 Elf_External_Sym_Shndx
*shndx
;
2726 struct elf_link_hash_entry
**sym_hashes
;
2727 struct elf_link_hash_entry
**end_hashes
;
2728 unsigned int symcount
;
2730 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2732 /* Examine all the symbols. */
2733 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2734 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
2735 shndx
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
2736 esym
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
2737 esymend
= esym
+ symtab_hdr
->sh_info
;
2738 for (; esym
< esymend
; esym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
2740 Elf_Internal_Sym isym
;
2742 bfd_elf32_swap_symbol_in (abfd
, (const PTR
) esym
, (const PTR
) shndx
,
2745 if (isym
.st_shndx
== sec_shndx
2746 && isym
.st_value
== addr
)
2750 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2751 - symtab_hdr
->sh_info
);
2752 sym_hashes
= elf_sym_hashes (abfd
);
2753 end_hashes
= sym_hashes
+ symcount
;
2754 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2756 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
2757 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2758 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2759 && sym_hash
->root
.u
.def
.section
== sec
2760 && sym_hash
->root
.u
.def
.value
== addr
)
2767 /* This is a version of bfd_generic_get_relocated_section_contents
2768 which uses mn10300_elf_relocate_section. */
2771 mn10300_elf_get_relocated_section_contents (output_bfd
, link_info
, link_order
,
2772 data
, relocateable
, symbols
)
2774 struct bfd_link_info
*link_info
;
2775 struct bfd_link_order
*link_order
;
2777 boolean relocateable
;
2780 Elf_Internal_Shdr
*symtab_hdr
;
2781 Elf_Internal_Shdr
*shndx_hdr
;
2782 asection
*input_section
= link_order
->u
.indirect
.section
;
2783 bfd
*input_bfd
= input_section
->owner
;
2784 asection
**sections
= NULL
;
2785 Elf_Internal_Rela
*internal_relocs
= NULL
;
2786 Elf32_External_Sym
*external_syms
= NULL
;
2787 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
2788 Elf_External_Sym_Shndx
*shndx
;
2789 Elf_Internal_Sym
*internal_syms
= NULL
;
2791 /* We only need to handle the case of relaxing, or of having a
2792 particular set of section contents, specially. */
2794 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
2795 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
2800 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2801 shndx_hdr
= &elf_tdata (input_bfd
)->symtab_shndx_hdr
;
2803 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
2804 (size_t) input_section
->_raw_size
);
2806 if ((input_section
->flags
& SEC_RELOC
) != 0
2807 && input_section
->reloc_count
> 0)
2809 Elf_Internal_Sym
*isymp
;
2811 Elf32_External_Sym
*esym
, *esymend
;
2814 if (symtab_hdr
->contents
!= NULL
)
2815 external_syms
= (Elf32_External_Sym
*) symtab_hdr
->contents
;
2816 else if (symtab_hdr
->sh_info
!= 0)
2818 amt
= symtab_hdr
->sh_info
;
2819 amt
*= sizeof (Elf32_External_Sym
);
2820 external_syms
= (Elf32_External_Sym
*) bfd_malloc (amt
);
2821 if (external_syms
== NULL
)
2823 if (bfd_seek (input_bfd
, symtab_hdr
->sh_offset
, SEEK_SET
) != 0
2824 || bfd_bread ((PTR
) external_syms
, amt
, input_bfd
) != amt
)
2828 if (symtab_hdr
->sh_info
!= 0 && shndx_hdr
->sh_size
!= 0)
2830 amt
= symtab_hdr
->sh_info
;
2831 amt
*= sizeof (Elf_External_Sym_Shndx
);
2832 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
2833 if (shndx_buf
== NULL
)
2835 if (bfd_seek (input_bfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
2836 || bfd_bread ((PTR
) shndx_buf
, amt
, input_bfd
) != amt
)
2840 internal_relocs
= (_bfd_elf32_link_read_relocs
2841 (input_bfd
, input_section
, (PTR
) NULL
,
2842 (Elf_Internal_Rela
*) NULL
, false));
2843 if (internal_relocs
== NULL
)
2846 amt
= symtab_hdr
->sh_info
;
2847 amt
*= sizeof (Elf_Internal_Sym
);
2848 internal_syms
= (Elf_Internal_Sym
*) bfd_malloc (amt
);
2849 if (internal_syms
== NULL
&& amt
!= 0)
2852 amt
= symtab_hdr
->sh_info
;
2853 amt
*= sizeof (asection
*);
2854 sections
= (asection
**) bfd_malloc (amt
);
2855 if (sections
== NULL
&& amt
!= 0)
2858 for (isymp
= internal_syms
, secpp
= sections
, shndx
= shndx_buf
,
2859 esym
= external_syms
, esymend
= esym
+ symtab_hdr
->sh_info
;
2861 ++esym
, ++isymp
, ++secpp
, shndx
= (shndx
? shndx
+ 1 : NULL
))
2865 bfd_elf32_swap_symbol_in (input_bfd
, (const PTR
) esym
,
2866 (const PTR
) shndx
, isymp
);
2868 if (isymp
->st_shndx
== SHN_UNDEF
)
2869 isec
= bfd_und_section_ptr
;
2870 else if (isymp
->st_shndx
== SHN_ABS
)
2871 isec
= bfd_abs_section_ptr
;
2872 else if (isymp
->st_shndx
== SHN_COMMON
)
2873 isec
= bfd_com_section_ptr
;
2875 isec
= bfd_section_from_elf_index (input_bfd
, isymp
->st_shndx
);
2880 if (! mn10300_elf_relocate_section (output_bfd
, link_info
, input_bfd
,
2881 input_section
, data
, internal_relocs
,
2882 internal_syms
, sections
))
2885 if (sections
!= NULL
)
2887 if (internal_syms
!= NULL
)
2888 free (internal_syms
);
2889 if (shndx_buf
!= NULL
)
2891 if (external_syms
!= NULL
&& symtab_hdr
->contents
== NULL
)
2892 free (external_syms
);
2893 if (internal_relocs
!= elf_section_data (input_section
)->relocs
)
2894 free (internal_relocs
);
2900 if (internal_relocs
!= NULL
2901 && internal_relocs
!= elf_section_data (input_section
)->relocs
)
2902 free (internal_relocs
);
2903 if (shndx_buf
!= NULL
)
2905 if (external_syms
!= NULL
&& symtab_hdr
->contents
== NULL
)
2906 free (external_syms
);
2907 if (internal_syms
!= NULL
)
2908 free (internal_syms
);
2909 if (sections
!= NULL
)
2914 /* Assorted hash table functions. */
2916 /* Initialize an entry in the link hash table. */
2918 /* Create an entry in an MN10300 ELF linker hash table. */
2920 static struct bfd_hash_entry
*
2921 elf32_mn10300_link_hash_newfunc (entry
, table
, string
)
2922 struct bfd_hash_entry
*entry
;
2923 struct bfd_hash_table
*table
;
2926 struct elf32_mn10300_link_hash_entry
*ret
=
2927 (struct elf32_mn10300_link_hash_entry
*) entry
;
2929 /* Allocate the structure if it has not already been allocated by a
2931 if (ret
== (struct elf32_mn10300_link_hash_entry
*) NULL
)
2932 ret
= ((struct elf32_mn10300_link_hash_entry
*)
2933 bfd_hash_allocate (table
,
2934 sizeof (struct elf32_mn10300_link_hash_entry
)));
2935 if (ret
== (struct elf32_mn10300_link_hash_entry
*) NULL
)
2936 return (struct bfd_hash_entry
*) ret
;
2938 /* Call the allocation method of the superclass. */
2939 ret
= ((struct elf32_mn10300_link_hash_entry
*)
2940 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
2942 if (ret
!= (struct elf32_mn10300_link_hash_entry
*) NULL
)
2944 ret
->direct_calls
= 0;
2945 ret
->stack_size
= 0;
2946 ret
->movm_stack_size
= 0;
2951 return (struct bfd_hash_entry
*) ret
;
2954 /* Create an mn10300 ELF linker hash table. */
2956 static struct bfd_link_hash_table
*
2957 elf32_mn10300_link_hash_table_create (abfd
)
2960 struct elf32_mn10300_link_hash_table
*ret
;
2961 bfd_size_type amt
= sizeof (struct elf32_mn10300_link_hash_table
);
2963 ret
= (struct elf32_mn10300_link_hash_table
*) bfd_malloc (amt
);
2964 if (ret
== (struct elf32_mn10300_link_hash_table
*) NULL
)
2967 if (! _bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
2968 elf32_mn10300_link_hash_newfunc
))
2975 amt
= sizeof (struct elf_link_hash_table
);
2976 ret
->static_hash_table
2977 = (struct elf32_mn10300_link_hash_table
*) bfd_malloc (amt
);
2978 if (ret
->static_hash_table
== NULL
)
2984 if (! _bfd_elf_link_hash_table_init (&ret
->static_hash_table
->root
, abfd
,
2985 elf32_mn10300_link_hash_newfunc
))
2987 free (ret
->static_hash_table
);
2991 return &ret
->root
.root
;
2994 /* Free an mn10300 ELF linker hash table. */
2997 elf32_mn10300_link_hash_table_free (hash
)
2998 struct bfd_link_hash_table
*hash
;
3000 struct elf32_mn10300_link_hash_table
*ret
3001 = (struct elf32_mn10300_link_hash_table
*) hash
;
3003 _bfd_generic_link_hash_table_free
3004 ((struct bfd_link_hash_table
*) ret
->static_hash_table
);
3005 _bfd_generic_link_hash_table_free
3006 ((struct bfd_link_hash_table
*) ret
);
3009 static unsigned long
3010 elf_mn10300_mach (flags
)
3013 switch (flags
& EF_MN10300_MACH
)
3015 case E_MN10300_MACH_MN10300
:
3017 return bfd_mach_mn10300
;
3019 case E_MN10300_MACH_AM33
:
3020 return bfd_mach_am33
;
3024 /* The final processing done just before writing out a MN10300 ELF object
3025 file. This gets the MN10300 architecture right based on the machine
3029 _bfd_mn10300_elf_final_write_processing (abfd
, linker
)
3031 boolean linker ATTRIBUTE_UNUSED
;
3035 switch (bfd_get_mach (abfd
))
3038 case bfd_mach_mn10300
:
3039 val
= E_MN10300_MACH_MN10300
;
3043 val
= E_MN10300_MACH_AM33
;
3047 elf_elfheader (abfd
)->e_flags
&= ~ (EF_MN10300_MACH
);
3048 elf_elfheader (abfd
)->e_flags
|= val
;
3052 _bfd_mn10300_elf_object_p (abfd
)
3055 bfd_default_set_arch_mach (abfd
, bfd_arch_mn10300
,
3056 elf_mn10300_mach (elf_elfheader (abfd
)->e_flags
));
3060 /* Merge backend specific data from an object file to the output
3061 object file when linking. */
3064 _bfd_mn10300_elf_merge_private_bfd_data (ibfd
, obfd
)
3068 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3069 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3072 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3073 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
3075 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
3076 bfd_get_mach (ibfd
)))
3083 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
3084 #define TARGET_LITTLE_NAME "elf32-mn10300"
3085 #define ELF_ARCH bfd_arch_mn10300
3086 #define ELF_MACHINE_CODE EM_MN10300
3087 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
3088 #define ELF_MAXPAGESIZE 0x1000
3090 #define elf_info_to_howto mn10300_info_to_howto
3091 #define elf_info_to_howto_rel 0
3092 #define elf_backend_can_gc_sections 1
3093 #define elf_backend_rela_normal 1
3094 #define elf_backend_check_relocs mn10300_elf_check_relocs
3095 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
3096 #define elf_backend_relocate_section mn10300_elf_relocate_section
3097 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
3098 #define bfd_elf32_bfd_get_relocated_section_contents \
3099 mn10300_elf_get_relocated_section_contents
3100 #define bfd_elf32_bfd_link_hash_table_create \
3101 elf32_mn10300_link_hash_table_create
3102 #define bfd_elf32_bfd_link_hash_table_free \
3103 elf32_mn10300_link_hash_table_free
3105 #define elf_symbol_leading_char '_'
3107 /* So we can set bits in e_flags. */
3108 #define elf_backend_final_write_processing \
3109 _bfd_mn10300_elf_final_write_processing
3110 #define elf_backend_object_p _bfd_mn10300_elf_object_p
3112 #define bfd_elf32_bfd_merge_private_bfd_data \
3113 _bfd_mn10300_elf_merge_private_bfd_data
3115 #include "elf32-target.h"