1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
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 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "libiberty.h"
28 /* Forward declarations. */
29 static reloc_howto_type
* m32c_reloc_type_lookup
30 (bfd
*, bfd_reloc_code_real_type
);
31 static void m32c_info_to_howto_rela
32 (bfd
*, arelent
*, Elf_Internal_Rela
*);
33 static bfd_boolean m32c_elf_relocate_section
34 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
35 static bfd_boolean m32c_elf_check_relocs
36 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
37 static bfd_boolean
m32c_elf_relax_delete_bytes (bfd
*, asection
*, bfd_vma
, int);
39 char * m32c_get_reloc (long reloc
);
40 void dump_symtab (bfd
*, void *, void *);
42 static bfd_boolean m32c_elf_relax_section
43 (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
, bfd_boolean
*again
);
46 static reloc_howto_type m32c_elf_howto_table
[] =
48 /* This reloc does nothing. */
49 HOWTO (R_M32C_NONE
, /* type */
51 0, /* size (0 = byte, 1 = short, 2 = long) */
53 FALSE
, /* pc_relative */
55 complain_overflow_bitfield
, /* complain_on_overflow */
56 bfd_elf_generic_reloc
, /* special_function */
57 "R_M32C_NONE", /* name */
58 FALSE
, /* partial_inplace */
61 FALSE
), /* pcrel_offset */
63 /* GCC intentionally overflows these next two in order to work
64 around limitations in the addressing modes, so don't complain
66 HOWTO (R_M32C_16
, /* type */
68 1, /* size (0 = byte, 1 = short, 2 = long) */
70 FALSE
, /* pc_relative */
72 complain_overflow_dont
, /* complain_on_overflow */
73 bfd_elf_generic_reloc
, /* special_function */
74 "R_M32C_16", /* name */
75 FALSE
, /* partial_inplace */
77 0xffff, /* dst_mask */
78 FALSE
), /* pcrel_offset */
80 HOWTO (R_M32C_24
, /* type */
82 2, /* size (0 = byte, 1 = short, 2 = long) */
84 FALSE
, /* pc_relative */
86 complain_overflow_dont
, /* complain_on_overflow */
87 bfd_elf_generic_reloc
, /* special_function */
88 "R_M32C_24", /* name */
89 FALSE
, /* partial_inplace */
91 0xffffff, /* dst_mask */
92 FALSE
), /* pcrel_offset */
94 HOWTO (R_M32C_32
, /* type */
96 2, /* size (0 = byte, 1 = short, 2 = long) */
98 FALSE
, /* pc_relative */
100 complain_overflow_bitfield
, /* complain_on_overflow */
101 bfd_elf_generic_reloc
, /* special_function */
102 "R_M32C_32", /* name */
103 FALSE
, /* partial_inplace */
105 0xffffffff, /* dst_mask */
106 FALSE
), /* pcrel_offset */
108 HOWTO (R_M32C_8_PCREL
, /* type */
110 0, /* size (0 = byte, 1 = short, 2 = long) */
112 TRUE
, /* pc_relative */
114 complain_overflow_signed
, /* complain_on_overflow */
115 bfd_elf_generic_reloc
, /* special_function */
116 "R_M32C_8_PCREL", /* name */
117 FALSE
, /* partial_inplace */
120 TRUE
), /* pcrel_offset */
122 HOWTO (R_M32C_16_PCREL
, /* type */
124 1, /* size (0 = byte, 1 = short, 2 = long) */
126 TRUE
, /* pc_relative */
128 complain_overflow_signed
, /* complain_on_overflow */
129 bfd_elf_generic_reloc
, /* special_function */
130 "R_M32C_16_PCREL", /* name */
131 FALSE
, /* partial_inplace */
133 0xffff, /* dst_mask */
134 TRUE
), /* pcrel_offset */
136 HOWTO (R_M32C_8
, /* type */
138 0, /* size (0 = byte, 1 = short, 2 = long) */
140 FALSE
, /* pc_relative */
142 complain_overflow_unsigned
, /* complain_on_overflow */
143 bfd_elf_generic_reloc
, /* special_function */
144 "R_M32C_8", /* name */
145 FALSE
, /* partial_inplace */
148 FALSE
), /* pcrel_offset */
150 HOWTO (R_M32C_LO16
, /* type */
152 1, /* size (0 = byte, 1 = short, 2 = long) */
154 FALSE
, /* pc_relative */
156 complain_overflow_dont
, /* complain_on_overflow */
157 bfd_elf_generic_reloc
, /* special_function */
158 "R_M32C_LO16", /* name */
159 FALSE
, /* partial_inplace */
161 0xffff, /* dst_mask */
162 FALSE
), /* pcrel_offset */
164 HOWTO (R_M32C_HI8
, /* type */
166 0, /* size (0 = byte, 1 = short, 2 = long) */
168 FALSE
, /* pc_relative */
170 complain_overflow_dont
, /* complain_on_overflow */
171 bfd_elf_generic_reloc
, /* special_function */
172 "R_M32C_HI8", /* name */
173 FALSE
, /* partial_inplace */
176 FALSE
), /* pcrel_offset */
178 HOWTO (R_M32C_HI16
, /* type */
180 1, /* size (0 = byte, 1 = short, 2 = long) */
182 FALSE
, /* pc_relative */
184 complain_overflow_dont
, /* complain_on_overflow */
185 bfd_elf_generic_reloc
, /* special_function */
186 "R_M32C_HI16", /* name */
187 FALSE
, /* partial_inplace */
189 0xffff, /* dst_mask */
190 FALSE
), /* pcrel_offset */
192 HOWTO (R_M32C_RL_JUMP
, /* type */
194 0, /* size (0 = byte, 1 = short, 2 = long) */
196 FALSE
, /* pc_relative */
198 complain_overflow_signed
, /* complain_on_overflow */
199 bfd_elf_generic_reloc
, /* special_function */
200 "R_M32C_RL_JUMP", /* name */
201 FALSE
, /* partial_inplace */
204 FALSE
), /* pcrel_offset */
206 HOWTO (R_M32C_RL_1ADDR
, /* type */
208 0, /* size (0 = byte, 1 = short, 2 = long) */
210 FALSE
, /* pc_relative */
212 complain_overflow_signed
, /* complain_on_overflow */
213 bfd_elf_generic_reloc
, /* special_function */
214 "R_M32C_RL_1ADDR", /* name */
215 FALSE
, /* partial_inplace */
218 FALSE
), /* pcrel_offset */
220 HOWTO (R_M32C_RL_2ADDR
, /* type */
222 0, /* size (0 = byte, 1 = short, 2 = long) */
224 FALSE
, /* pc_relative */
226 complain_overflow_signed
, /* complain_on_overflow */
227 bfd_elf_generic_reloc
, /* special_function */
228 "R_M32C_RL_2ADDR", /* name */
229 FALSE
, /* partial_inplace */
232 FALSE
), /* pcrel_offset */
236 /* Map BFD reloc types to M32C ELF reloc types. */
238 struct m32c_reloc_map
240 bfd_reloc_code_real_type bfd_reloc_val
;
241 unsigned int m32c_reloc_val
;
244 static const struct m32c_reloc_map m32c_reloc_map
[] =
246 { BFD_RELOC_NONE
, R_M32C_NONE
},
247 { BFD_RELOC_16
, R_M32C_16
},
248 { BFD_RELOC_24
, R_M32C_24
},
249 { BFD_RELOC_32
, R_M32C_32
},
250 { BFD_RELOC_8_PCREL
, R_M32C_8_PCREL
},
251 { BFD_RELOC_16_PCREL
, R_M32C_16_PCREL
},
252 { BFD_RELOC_8
, R_M32C_8
},
253 { BFD_RELOC_LO16
, R_M32C_LO16
},
254 { BFD_RELOC_HI16
, R_M32C_HI16
},
255 { BFD_RELOC_M32C_HI8
, R_M32C_HI8
},
256 { BFD_RELOC_M32C_RL_JUMP
, R_M32C_RL_JUMP
},
257 { BFD_RELOC_M32C_RL_1ADDR
, R_M32C_RL_1ADDR
},
258 { BFD_RELOC_M32C_RL_2ADDR
, R_M32C_RL_2ADDR
}
261 static reloc_howto_type
*
262 m32c_reloc_type_lookup
263 (bfd
* abfd ATTRIBUTE_UNUSED
,
264 bfd_reloc_code_real_type code
)
268 for (i
= ARRAY_SIZE (m32c_reloc_map
); --i
;)
269 if (m32c_reloc_map
[i
].bfd_reloc_val
== code
)
270 return & m32c_elf_howto_table
[m32c_reloc_map
[i
].m32c_reloc_val
];
275 static reloc_howto_type
*
276 m32c_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, const char *r_name
)
281 i
< sizeof (m32c_elf_howto_table
) / sizeof (m32c_elf_howto_table
[0]);
283 if (m32c_elf_howto_table
[i
].name
!= NULL
284 && strcasecmp (m32c_elf_howto_table
[i
].name
, r_name
) == 0)
285 return &m32c_elf_howto_table
[i
];
290 /* Set the howto pointer for an M32C ELF reloc. */
293 m32c_info_to_howto_rela
294 (bfd
* abfd ATTRIBUTE_UNUSED
,
296 Elf_Internal_Rela
* dst
)
300 r_type
= ELF32_R_TYPE (dst
->r_info
);
301 BFD_ASSERT (r_type
< (unsigned int) R_M32C_max
);
302 cache_ptr
->howto
= & m32c_elf_howto_table
[r_type
];
307 /* Relocate an M32C ELF section.
308 There is some attempt to make this function usable for many architectures,
309 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
310 if only to serve as a learning tool.
312 The RELOCATE_SECTION function is called by the new ELF backend linker
313 to handle the relocations for a section.
315 The relocs are always passed as Rela structures; if the section
316 actually uses Rel structures, the r_addend field will always be
319 This function is responsible for adjusting the section contents as
320 necessary, and (if using Rela relocs and generating a relocatable
321 output file) adjusting the reloc addend as necessary.
323 This function does not have to worry about setting the reloc
324 address or the reloc symbol index.
326 LOCAL_SYMS is a pointer to the swapped in local symbols.
328 LOCAL_SECTIONS is an array giving the section in the input file
329 corresponding to the st_shndx field of each local symbol.
331 The global hash table entry for the global symbols can be found
332 via elf_sym_hashes (input_bfd).
334 When generating relocatable output, this function must handle
335 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
336 going to be the section symbol corresponding to the output
337 section, which means that the addend must be adjusted
341 m32c_elf_relocate_section
342 (bfd
* output_bfd ATTRIBUTE_UNUSED
,
343 struct bfd_link_info
* info
,
345 asection
* input_section
,
347 Elf_Internal_Rela
* relocs
,
348 Elf_Internal_Sym
* local_syms
,
349 asection
** local_sections
)
351 Elf_Internal_Shdr
* symtab_hdr
;
352 struct elf_link_hash_entry
** sym_hashes
;
353 Elf_Internal_Rela
* rel
;
354 Elf_Internal_Rela
* relend
;
358 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
359 sym_hashes
= elf_sym_hashes (input_bfd
);
360 relend
= relocs
+ input_section
->reloc_count
;
362 dynobj
= elf_hash_table (info
)->dynobj
;
365 splt
= bfd_get_linker_section (dynobj
, ".plt");
367 for (rel
= relocs
; rel
< relend
; rel
++)
369 reloc_howto_type
* howto
;
370 unsigned long r_symndx
;
371 Elf_Internal_Sym
* sym
;
373 struct elf_link_hash_entry
* h
;
375 bfd_reloc_status_type r
;
376 const char * name
= NULL
;
379 r_type
= ELF32_R_TYPE (rel
->r_info
);
381 /* These are only used for relaxing; we don't actually relocate
382 anything with them, so skip them. */
383 if (r_type
== R_M32C_RL_JUMP
384 || r_type
== R_M32C_RL_1ADDR
385 || r_type
== R_M32C_RL_2ADDR
)
388 r_symndx
= ELF32_R_SYM (rel
->r_info
);
390 howto
= m32c_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
396 if (r_symndx
< symtab_hdr
->sh_info
)
398 sym
= local_syms
+ r_symndx
;
399 sec
= local_sections
[r_symndx
];
400 relocation
= (sec
->output_section
->vma
404 name
= bfd_elf_string_from_elf_section
405 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
406 name
= (sym
->st_name
== 0) ? bfd_section_name (input_bfd
, sec
) : name
;
410 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
412 while (h
->root
.type
== bfd_link_hash_indirect
413 || h
->root
.type
== bfd_link_hash_warning
)
414 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
416 name
= h
->root
.root
.string
;
418 if (h
->root
.type
== bfd_link_hash_defined
419 || h
->root
.type
== bfd_link_hash_defweak
)
421 sec
= h
->root
.u
.def
.section
;
422 relocation
= (h
->root
.u
.def
.value
423 + sec
->output_section
->vma
424 + sec
->output_offset
);
426 else if (h
->root
.type
== bfd_link_hash_undefweak
)
428 else if (!info
->relocatable
)
430 if (! ((*info
->callbacks
->undefined_symbol
)
431 (info
, h
->root
.root
.string
, input_bfd
,
432 input_section
, rel
->r_offset
, TRUE
)))
437 if (sec
!= NULL
&& discarded_section (sec
))
438 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
439 rel
, 1, relend
, howto
, 0, contents
);
441 if (info
->relocatable
)
443 /* This is a relocatable link. We don't have to change
444 anything, unless the reloc is against a section symbol,
445 in which case we have to adjust according to where the
446 section symbol winds up in the output section. */
447 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
448 rel
->r_addend
+= sec
->output_offset
;
452 switch (ELF32_R_TYPE (rel
->r_info
))
459 plt_offset
= &h
->plt
.offset
;
461 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
463 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
464 relocation, *plt_offset);*/
465 if (relocation
<= 0xffff)
467 /* If the symbol is in range for a 16-bit address, we should
468 have deallocated the plt entry in relax_section. */
469 BFD_ASSERT (*plt_offset
== (bfd_vma
) -1);
473 /* If the symbol is out of range for a 16-bit address,
474 we must have allocated a plt entry. */
475 BFD_ASSERT (*plt_offset
!= (bfd_vma
) -1);
477 /* If this is the first time we've processed this symbol,
478 fill in the plt entry with the correct symbol address. */
479 if ((*plt_offset
& 1) == 0)
483 x
= 0x000000fc; /* jmpf */
484 x
|= (relocation
<< 8) & 0xffffff00;
485 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
489 relocation
= (splt
->output_section
->vma
490 + splt
->output_offset
491 + (*plt_offset
& -2));
494 char *newname
= bfd_malloc (strlen(name
)+5);
495 strcpy (newname
, name
);
496 strcat(newname
, ".plt");
497 _bfd_generic_link_add_one_symbol (info
,
500 BSF_FUNCTION
| BSF_WEAK
,
519 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
520 m32c_elf_howto_table
[ELF32_R_TYPE(rel
->r_info
)].name
,
521 rel
->r_offset
+ input_section
->output_section
->vma
+ input_section
->output_offset
,
522 relocation
, rel
->r_addend
);
526 printf (" %02x", contents
[rel
->r_offset
+i
]);
530 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
531 contents
, rel
->r_offset
, relocation
,
534 if (r
!= bfd_reloc_ok
)
536 const char * msg
= (const char *) NULL
;
540 case bfd_reloc_overflow
:
541 r
= info
->callbacks
->reloc_overflow
542 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
543 input_bfd
, input_section
, rel
->r_offset
);
546 case bfd_reloc_undefined
:
547 r
= info
->callbacks
->undefined_symbol
548 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
552 case bfd_reloc_outofrange
:
553 msg
= _("internal error: out of range error");
556 case bfd_reloc_notsupported
:
557 msg
= _("internal error: unsupported relocation error");
560 case bfd_reloc_dangerous
:
561 msg
= _("internal error: dangerous relocation");
565 msg
= _("internal error: unknown error");
570 r
= info
->callbacks
->warning
571 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
581 /* We support 16-bit pointers to code above 64k by generating a thunk
582 below 64k containing a JMP instruction to the final address. */
585 m32c_elf_check_relocs
587 struct bfd_link_info
* info
,
589 const Elf_Internal_Rela
* relocs
)
591 Elf_Internal_Shdr
* symtab_hdr
;
592 struct elf_link_hash_entry
** sym_hashes
;
593 const Elf_Internal_Rela
* rel
;
594 const Elf_Internal_Rela
* rel_end
;
595 bfd_vma
*local_plt_offsets
;
599 if (info
->relocatable
)
602 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
603 sym_hashes
= elf_sym_hashes (abfd
);
604 local_plt_offsets
= elf_local_got_offsets (abfd
);
606 dynobj
= elf_hash_table(info
)->dynobj
;
608 rel_end
= relocs
+ sec
->reloc_count
;
609 for (rel
= relocs
; rel
< rel_end
; rel
++)
611 struct elf_link_hash_entry
*h
;
612 unsigned long r_symndx
;
615 r_symndx
= ELF32_R_SYM (rel
->r_info
);
616 if (r_symndx
< symtab_hdr
->sh_info
)
620 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
621 while (h
->root
.type
== bfd_link_hash_indirect
622 || h
->root
.type
== bfd_link_hash_warning
)
623 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
626 switch (ELF32_R_TYPE (rel
->r_info
))
628 /* This relocation describes a 16-bit pointer to a function.
629 We may need to allocate a thunk in low memory; reserve memory
633 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
636 splt
= bfd_get_linker_section (dynobj
, ".plt");
639 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
640 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
641 | SEC_READONLY
| SEC_CODE
);
642 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
645 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
651 offset
= &h
->plt
.offset
;
654 if (local_plt_offsets
== NULL
)
659 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
660 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
661 if (local_plt_offsets
== NULL
)
663 elf_local_got_offsets (abfd
) = local_plt_offsets
;
665 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
666 local_plt_offsets
[i
] = (bfd_vma
) -1;
668 offset
= &local_plt_offsets
[r_symndx
];
671 if (*offset
== (bfd_vma
) -1)
673 *offset
= splt
->size
;
683 /* This must exist if dynobj is ever set. */
686 m32c_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
687 struct bfd_link_info
*info
)
692 /* As an extra sanity check, verify that all plt entries have
695 if ((dynobj
= elf_hash_table (info
)->dynobj
) != NULL
696 && (splt
= bfd_get_linker_section (dynobj
, ".plt")) != NULL
)
698 bfd_byte
*contents
= splt
->contents
;
699 unsigned int i
, size
= splt
->size
;
700 for (i
= 0; i
< size
; i
+= 4)
702 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
711 m32c_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
712 struct bfd_link_info
*info
)
717 if (info
->relocatable
)
720 dynobj
= elf_hash_table (info
)->dynobj
;
724 splt
= bfd_get_linker_section (dynobj
, ".plt");
725 BFD_ASSERT (splt
!= NULL
);
727 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
728 if (splt
->contents
== NULL
)
734 /* Function to set the ELF flag bits. */
737 m32c_elf_set_private_flags (bfd
*abfd
, flagword flags
)
739 elf_elfheader (abfd
)->e_flags
= flags
;
740 elf_flags_init (abfd
) = TRUE
;
744 /* Merge backend specific data from an object file to the output
745 object file when linking. */
748 m32c_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
750 flagword old_flags
, old_partial
;
751 flagword new_flags
, new_partial
;
752 bfd_boolean error
= FALSE
;
756 new_opt
[0] = old_opt
[0] = '\0';
757 new_flags
= elf_elfheader (ibfd
)->e_flags
;
758 old_flags
= elf_elfheader (obfd
)->e_flags
;
761 (*_bfd_error_handler
) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
762 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
763 bfd_get_filename (ibfd
));
766 if (!elf_flags_init (obfd
))
768 /* First call, no flags set. */
769 elf_flags_init (obfd
) = TRUE
;
770 elf_elfheader (obfd
)->e_flags
= new_flags
;
773 else if (new_flags
== old_flags
)
774 /* Compatible flags are ok. */
777 else /* Possibly incompatible flags. */
779 /* Warn if different cpu is used (allow a specific cpu to override
781 new_partial
= (new_flags
& EF_M32C_CPU_MASK
);
782 old_partial
= (old_flags
& EF_M32C_CPU_MASK
);
783 if (new_partial
== old_partial
)
790 default: strcat (new_opt
, " -m16c"); break;
791 case EF_M32C_CPU_M16C
: strcat (new_opt
, " -m16c"); break;
792 case EF_M32C_CPU_M32C
: strcat (new_opt
, " -m32c"); break;
797 default: strcat (old_opt
, " -m16c"); break;
798 case EF_M32C_CPU_M16C
: strcat (old_opt
, " -m16c"); break;
799 case EF_M32C_CPU_M32C
: strcat (old_opt
, " -m32c"); break;
803 /* Print out any mismatches from above. */
807 (*_bfd_error_handler
)
808 (_("%s: compiled with %s and linked with modules compiled with %s"),
809 bfd_get_filename (ibfd
), new_opt
, old_opt
);
812 new_flags
&= ~ EF_M32C_ALL_FLAGS
;
813 old_flags
&= ~ EF_M32C_ALL_FLAGS
;
815 /* Warn about any other mismatches. */
816 if (new_flags
!= old_flags
)
819 (*_bfd_error_handler
)
820 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
821 bfd_get_filename (ibfd
), (long)new_flags
, (long)old_flags
);
826 bfd_set_error (bfd_error_bad_value
);
833 m32c_elf_print_private_bfd_data (bfd
*abfd
, PTR ptr
)
835 FILE *file
= (FILE *) ptr
;
838 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
840 /* Print normal ELF private data. */
841 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
843 flags
= elf_elfheader (abfd
)->e_flags
;
844 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
846 switch (flags
& EF_M32C_CPU_MASK
)
849 case EF_M32C_CPU_M16C
: fprintf (file
, " -m16c"); break;
850 case EF_M32C_CPU_M32C
: fprintf (file
, " -m32c"); break;
857 /* Return the MACH for an e_flags value. */
860 elf32_m32c_machine (bfd
*abfd
)
862 switch (elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
)
864 case EF_M32C_CPU_M16C
: return bfd_mach_m16c
;
865 case EF_M32C_CPU_M32C
: return bfd_mach_m32c
;
868 return bfd_mach_m16c
;
872 m32c_elf_object_p (bfd
*abfd
)
874 bfd_default_set_arch_mach (abfd
, bfd_arch_m32c
,
875 elf32_m32c_machine (abfd
));
882 dump_symtab (bfd
* abfd
, void *internal_syms
, void *external_syms
)
885 Elf_Internal_Sym
*isymbuf
;
886 Elf_Internal_Sym
*isymend
;
887 Elf_Internal_Sym
*isym
;
888 Elf_Internal_Shdr
*symtab_hdr
;
889 bfd_boolean free_internal
= 0, free_external
= 0;
891 char * st_info_stb_str
;
897 internal_syms
= bfd_malloc (1000);
902 external_syms
= bfd_malloc (1000);
906 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
907 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data(abfd
)->s
->sizeof_sym
;
909 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
910 symtab_hdr
->sh_info
, 0,
911 internal_syms
, external_syms
, NULL
);
913 isymbuf
= internal_syms
;
914 isymend
= isymbuf
+ locsymcount
;
916 for (isym
= isymbuf
; isym
< isymend
; isym
++)
918 switch (ELF_ST_TYPE (isym
->st_info
))
920 case STT_FUNC
: st_info_str
= "STT_FUNC";
921 case STT_SECTION
: st_info_str
= "STT_SECTION";
922 case STT_FILE
: st_info_str
= "STT_FILE";
923 case STT_OBJECT
: st_info_str
= "STT_OBJECT";
924 case STT_TLS
: st_info_str
= "STT_TLS";
925 default: st_info_str
= "";
927 switch (ELF_ST_BIND (isym
->st_info
))
929 case STB_LOCAL
: st_info_stb_str
= "STB_LOCAL";
930 case STB_GLOBAL
: st_info_stb_str
= "STB_GLOBAL";
931 default: st_info_stb_str
= "";
933 switch (ELF_ST_VISIBILITY (isym
->st_other
))
935 case STV_DEFAULT
: st_other_str
= "STV_DEFAULT";
936 case STV_INTERNAL
: st_other_str
= "STV_INTERNAL";
937 case STV_PROTECTED
: st_other_str
= "STV_PROTECTED";
938 default: st_other_str
= "";
940 switch (isym
->st_shndx
)
942 case SHN_ABS
: st_shndx_str
= "SHN_ABS";
943 case SHN_COMMON
: st_shndx_str
= "SHN_COMMON";
944 case SHN_UNDEF
: st_shndx_str
= "SHN_UNDEF";
945 default: st_shndx_str
= "";
948 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
949 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
951 (unsigned long) isym
->st_value
,
952 (unsigned long) isym
->st_size
,
954 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
956 isym
->st_info
, st_info_str
, st_info_stb_str
,
957 isym
->st_other
, st_other_str
,
958 isym
->st_shndx
, st_shndx_str
);
961 free (internal_syms
);
963 free (external_syms
);
967 m32c_get_reloc (long reloc
)
969 if (0 <= reloc
&& reloc
< R_M32C_max
)
970 return m32c_elf_howto_table
[reloc
].name
;
976 /* Handle relaxing. */
978 /* A subroutine of m32c_elf_relax_section. If the global symbol H
979 is within the low 64k, remove any entry for it in the plt. */
981 struct relax_plt_data
988 m32c_relax_plt_check (struct elf_link_hash_entry
*h
,
991 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
993 if (h
->plt
.offset
!= (bfd_vma
) -1)
997 if (h
->root
.type
== bfd_link_hash_undefined
998 || h
->root
.type
== bfd_link_hash_undefweak
)
1001 address
= (h
->root
.u
.def
.section
->output_section
->vma
1002 + h
->root
.u
.def
.section
->output_offset
1003 + h
->root
.u
.def
.value
);
1005 if (address
<= 0xffff)
1008 data
->splt
->size
-= 4;
1009 *data
->again
= TRUE
;
1016 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1017 previously had a plt entry, give it a new entry offset. */
1020 m32c_relax_plt_realloc (struct elf_link_hash_entry
*h
,
1023 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1025 if (h
->plt
.offset
!= (bfd_vma
) -1)
1027 h
->plt
.offset
= *entry
;
1035 m32c_elf_relax_plt_section (asection
*splt
,
1036 struct bfd_link_info
*info
,
1039 struct relax_plt_data relax_plt_data
;
1042 /* Assume nothing changes. */
1045 if (info
->relocatable
)
1048 /* Quick check for an empty plt. */
1049 if (splt
->size
== 0)
1052 /* Map across all global symbols; see which ones happen to
1053 fall in the low 64k. */
1054 relax_plt_data
.splt
= splt
;
1055 relax_plt_data
.again
= again
;
1056 elf_link_hash_traverse (elf_hash_table (info
), m32c_relax_plt_check
,
1059 /* Likewise for local symbols, though that's somewhat less convenient
1060 as we have to walk the list of input bfds and swap in symbol data. */
1061 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1063 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1064 Elf_Internal_Shdr
*symtab_hdr
;
1065 Elf_Internal_Sym
*isymbuf
= NULL
;
1068 if (! local_plt_offsets
)
1071 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1072 if (symtab_hdr
->sh_info
!= 0)
1074 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1075 if (isymbuf
== NULL
)
1076 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1077 symtab_hdr
->sh_info
, 0,
1079 if (isymbuf
== NULL
)
1083 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1085 Elf_Internal_Sym
*isym
;
1089 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1092 isym
= &isymbuf
[idx
];
1093 if (isym
->st_shndx
== SHN_UNDEF
)
1095 else if (isym
->st_shndx
== SHN_ABS
)
1096 tsec
= bfd_abs_section_ptr
;
1097 else if (isym
->st_shndx
== SHN_COMMON
)
1098 tsec
= bfd_com_section_ptr
;
1100 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1102 address
= (tsec
->output_section
->vma
1103 + tsec
->output_offset
1105 if (address
<= 0xffff)
1107 local_plt_offsets
[idx
] = -1;
1114 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1116 if (! info
->keep_memory
)
1120 /* Cache the symbols for elf_link_input_bfd. */
1121 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1126 /* If we changed anything, walk the symbols again to reallocate
1127 .plt entry addresses. */
1128 if (*again
&& splt
->size
> 0)
1132 elf_link_hash_traverse (elf_hash_table (info
),
1133 m32c_relax_plt_realloc
, &entry
);
1135 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1137 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1138 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1141 if (! local_plt_offsets
)
1144 for (idx
= 0; idx
< nlocals
; ++idx
)
1145 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1147 local_plt_offsets
[idx
] = entry
;
1157 compare_reloc (const void *e1
, const void *e2
)
1159 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
1160 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
1162 if (i1
->r_offset
== i2
->r_offset
)
1165 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
1168 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1170 m32c_offset_for_reloc (bfd
*abfd
,
1171 Elf_Internal_Rela
*rel
,
1172 Elf_Internal_Shdr
*symtab_hdr
,
1173 Elf_External_Sym_Shndx
*shndx_buf ATTRIBUTE_UNUSED
,
1174 Elf_Internal_Sym
*intsyms
)
1178 /* Get the value of the symbol referred to by the reloc. */
1179 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1181 /* A local symbol. */
1182 Elf_Internal_Sym
*isym
;
1185 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1186 ssec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1187 symval
= isym
->st_value
;
1189 symval
+= ssec
->output_section
->vma
1190 + ssec
->output_offset
;
1195 struct elf_link_hash_entry
*h
;
1197 /* An external symbol. */
1198 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1199 h
= elf_sym_hashes (abfd
)[indx
];
1200 BFD_ASSERT (h
!= NULL
);
1202 if (h
->root
.type
!= bfd_link_hash_defined
1203 && h
->root
.type
!= bfd_link_hash_defweak
)
1204 /* This appears to be a reference to an undefined
1205 symbol. Just ignore it--it will be caught by the
1206 regular reloc processing. */
1209 symval
= (h
->root
.u
.def
.value
1210 + h
->root
.u
.def
.section
->output_section
->vma
1211 + h
->root
.u
.def
.section
->output_offset
);
1216 static int bytes_saved
= 0;
1218 static int bytes_to_reloc
[] = {
1226 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1228 /* Mask for the number of relocs associated with this insn. */
1229 #define RLA_RELOCS 0x0000000f
1230 /* Number of bytes gas emitted (before gas's relaxing) */
1231 #define RLA_NBYTES 0x00000ff0
1233 /* If the displacement is within the given range and the new encoding
1234 differs from the old encoding (the index), then the insn can be
1235 relaxed to the new encoding. */
1238 unsigned int max_disp
;
1239 unsigned char new_encoding
;
1242 static EncodingTable m16c_addr_encodings
[] = {
1243 { 0, 0, 0 }, /* R0 */
1244 { 0, 0, 1 }, /* R1 */
1245 { 0, 0, 2 }, /* R2 */
1246 { 0, 0, 3 }, /* R3 */
1247 { 0, 0, 4 }, /* A0 */
1248 { 0, 0, 5 }, /* A1 */
1249 { 0, 0, 6 }, /* [A0] */
1250 { 0, 0, 7 }, /* [A1] */
1251 { 1, 0, 6 }, /* udsp:8[A0] */
1252 { 1, 0, 7 }, /* udsp:8[A1] */
1253 { 1, 0, 10 }, /* udsp:8[SB] */
1254 { 1, 0, 11 }, /* sdsp:8[FB] */
1255 { 2, 255, 8 }, /* udsp:16[A0] */
1256 { 2, 255, 9 }, /* udsp:16[A1] */
1257 { 2, 255, 10 }, /* udsp:16[SB] */
1258 { 2, 0, 15 }, /* abs:16 */
1261 static EncodingTable m16c_jmpaddr_encodings
[] = {
1262 { 0, 0, 0 }, /* R0 */
1263 { 0, 0, 1 }, /* R1 */
1264 { 0, 0, 2 }, /* R2 */
1265 { 0, 0, 3 }, /* R3 */
1266 { 0, 0, 4 }, /* A0 */
1267 { 0, 0, 5 }, /* A1 */
1268 { 0, 0, 6 }, /* [A0] */
1269 { 0, 0, 7 }, /* [A1] */
1270 { 1, 0, 6 }, /* udsp:8[A0] */
1271 { 1, 0, 7 }, /* udsp:8[A1] */
1272 { 1, 0, 10 }, /* udsp:8[SB] */
1273 { 1, 0, 11 }, /* sdsp:8[FB] */
1274 { 3, 255, 8 }, /* udsp:20[A0] */
1275 { 3, 255, 9 }, /* udsp:20[A1] */
1276 { 2, 255, 10 }, /* udsp:16[SB] */
1277 { 2, 0, 15 }, /* abs:16 */
1280 static EncodingTable m32c_addr_encodings
[] = {
1281 { 0, 0, 0 }, /* [A0] */
1282 { 0, 0, 1 }, /* [A1] */
1283 { 0, 0, 2 }, /* A0 */
1284 { 0, 0, 3 }, /* A1 */
1285 { 1, 0, 0 }, /* udsp:8[A0] */
1286 { 1, 0, 1 }, /* udsp:8[A1] */
1287 { 1, 0, 6 }, /* udsp:8[SB] */
1288 { 1, 0, 7 }, /* sdsp:8[FB] */
1289 { 2, 255, 4 }, /* udsp:16[A0] */
1290 { 2, 255, 5 }, /* udsp:16[A1] */
1291 { 2, 255, 6 }, /* udsp:16[SB] */
1292 { 2, 127, 7 }, /* sdsp:16[FB] */
1293 { 3, 65535, 8 }, /* udsp:24[A0] */
1294 { 3, 65535, 9 }, /* udsp:24[A1] */
1295 { 3, 65535, 15 }, /* abs24 */
1296 { 2, 0, 15 }, /* abs16 */
1297 { 0, 0, 16 }, /* R2 */
1298 { 0, 0, 17 }, /* R3 */
1299 { 0, 0, 18 }, /* R0 */
1300 { 0, 0, 19 }, /* R1 */
1316 m32c_elf_relax_section
1319 struct bfd_link_info
* link_info
,
1320 bfd_boolean
* again
)
1322 Elf_Internal_Shdr
*symtab_hdr
;
1323 Elf_Internal_Shdr
*shndx_hdr
;
1324 Elf_Internal_Rela
*internal_relocs
;
1325 Elf_Internal_Rela
*free_relocs
= NULL
;
1326 Elf_Internal_Rela
*irel
, *irelend
, *srel
;
1327 bfd_byte
* contents
= NULL
;
1328 bfd_byte
* free_contents
= NULL
;
1329 Elf_Internal_Sym
*intsyms
= NULL
;
1330 Elf_Internal_Sym
*free_intsyms
= NULL
;
1331 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1334 if (abfd
== elf_hash_table (link_info
)->dynobj
1335 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1336 && strcmp (sec
->name
, ".plt") == 0)
1337 return m32c_elf_relax_plt_section (sec
, link_info
, again
);
1339 /* Assume nothing changes. */
1342 machine
= elf32_m32c_machine (abfd
);
1344 /* We don't have to do anything for a relocatable link, if
1345 this section does not have relocs, or if this is not a
1347 if (link_info
->relocatable
1348 || (sec
->flags
& SEC_RELOC
) == 0
1349 || sec
->reloc_count
== 0
1350 || (sec
->flags
& SEC_CODE
) == 0)
1353 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1354 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1356 /* Get the section contents. */
1357 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1358 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1359 /* Go get them off disk. */
1360 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1363 /* Read this BFD's symbols. */
1364 /* Get cached copy if it exists. */
1365 if (symtab_hdr
->contents
!= NULL
)
1367 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1371 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
1372 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1375 if (shndx_hdr
->sh_size
!= 0)
1379 amt
= symtab_hdr
->sh_info
;
1380 amt
*= sizeof (Elf_External_Sym_Shndx
);
1381 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1382 if (shndx_buf
== NULL
)
1384 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1385 || bfd_bread ((PTR
) shndx_buf
, amt
, abfd
) != amt
)
1387 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1390 /* Get a copy of the native relocations. */
1391 internal_relocs
= (_bfd_elf_link_read_relocs
1392 (abfd
, sec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
1393 link_info
->keep_memory
));
1394 if (internal_relocs
== NULL
)
1396 if (! link_info
->keep_memory
)
1397 free_relocs
= internal_relocs
;
1399 /* The RL_ relocs must be just before the operand relocs they go
1400 with, so we must sort them to guarantee this. */
1401 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
1404 /* Walk through them looking for relaxing opportunities. */
1405 irelend
= internal_relocs
+ sec
->reloc_count
;
1407 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1410 unsigned char *insn
, *gap
, *einsn
;
1412 bfd_signed_vma pcrel
;
1418 EncodingTable
*enctbl
;
1421 if (ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_JUMP
1422 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_1ADDR
1423 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_2ADDR
)
1428 /* There will always be room for the relaxed insn, since it is smaller
1429 than the one it would replace. */
1430 BFD_ASSERT (irel
->r_offset
< sec
->size
);
1432 insn
= contents
+ irel
->r_offset
;
1433 relax_relocs
= irel
->r_addend
% 16;
1435 /* Ok, we only have three relocs we care about, and they're all
1436 fake. The lower four bits of the addend is always the number
1437 of following relocs (hence the qsort above) that are assigned
1438 to this opcode. The next 8 bits of the addend indicates the
1439 number of bytes in the insn. We use the rest of them
1440 ourselves as flags for the more expensive operations (defines
1441 above). The three relocs are:
1443 RL_JUMP: This marks all direct jump insns. We check the
1444 displacement and replace them with shorter jumps if
1445 they're in range. We also use this to find JMP.S
1446 insns and manually shorten them when we delete bytes.
1447 We have to decode these insns to figure out what to
1450 RL_1ADDR: This is a :G or :Q insn, which has a single
1451 "standard" operand. We have to extract the type
1452 field, see if it's a wide displacement, then figure
1453 out if we can replace it with a narrow displacement.
1454 We don't have to decode these insns.
1456 RL_2ADDR: Similarly, but two "standard" operands. Note that
1457 r_addend may still be 1, as standard operands don't
1458 always have displacements. Gas shouldn't give us one
1459 with zero operands, but since we don't know which one
1460 has the displacement, we check them both anyway.
1462 These all point to the beginning of the insn itself, not the
1465 Note that we only relax one step at a time, relying on the
1466 linker to call us repeatedly. Thus, there is no code for
1467 JMP.A->JMP.B although that will happen in two steps.
1468 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1471 /* Get the value of the symbol referred to by the reloc. Just
1472 in case this is the last reloc in the list, use the RL's
1473 addend to choose between this reloc (no addend) or the next
1474 (yes addend, which means at least one following reloc). */
1475 srel
= irel
+ (relax_relocs
? 1 : 0);
1476 symval
= OFFSET_FOR_RELOC (srel
);
1478 /* Setting gap_size nonzero is the flag which means "something
1482 new_type
= ELF32_R_TYPE(srel
->r_info
);
1484 pc
= sec
->output_section
->vma
+ sec
->output_offset
1486 pcrel
= symval
- pc
+ srel
->r_addend
;
1488 if (machine
== bfd_mach_m16c
)
1492 switch (ELF32_R_TYPE(irel
->r_info
))
1495 case R_M32C_RL_JUMP
:
1498 case 0xfe: /* jmp.b */
1499 if (pcrel
>= 2 && pcrel
<= 9)
1501 /* Relax JMP.B -> JMP.S. We need to get rid of
1502 the following reloc though. */
1503 insn
[0] = 0x60 | (pcrel
- 2);
1504 new_type
= R_M32C_NONE
;
1505 irel
->r_addend
= 0x10;
1511 case 0xf4: /* jmp.w */
1512 /* 128 is allowed because it will be one byte closer
1513 after relaxing. Likewise for all other pc-rel
1515 if (pcrel
<= 128 && pcrel
>= -128)
1517 /* Relax JMP.W -> JMP.B */
1520 new_type
= R_M32C_8_PCREL
;
1526 case 0xfc: /* jmp.a */
1527 if (pcrel
<= 32768 && pcrel
>= -32768)
1529 /* Relax JMP.A -> JMP.W */
1533 new_type
= R_M32C_16_PCREL
;
1539 case 0xfd: /* jsr.a */
1540 if (pcrel
<= 32768 && pcrel
>= -32768)
1542 /* Relax JSR.A -> JSR.W */
1546 new_type
= R_M32C_16_PCREL
;
1554 case R_M32C_RL_2ADDR
:
1555 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1557 enctbl
= m16c_addr_encodings
;
1559 enc
= (insn
[1] >> 4) & 0x0f;
1562 if (srel
->r_offset
== irel
->r_offset
+ posn
1563 && e
->new_encoding
!= enc
1564 && symval
<= e
->max_disp
)
1567 insn
[1] |= e
->new_encoding
<< 4;
1568 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1569 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1570 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1573 if (relax_relocs
== 2)
1579 case R_M32C_RL_1ADDR
:
1580 /* xxxx xxxx xxxx dest [disp] */
1582 enctbl
= m16c_addr_encodings
;
1585 /* Check the opcode for jumps. We know it's safe to
1586 do this because all 2ADDR insns are at least two
1588 enc
= insn
[0] * 256 + insn
[1];
1595 enctbl
= m16c_jmpaddr_encodings
;
1599 /* srel, posn, and enc must be set here. */
1601 symval
= OFFSET_FOR_RELOC (srel
);
1602 enc
= insn
[1] & 0x0f;
1605 if (srel
->r_offset
== irel
->r_offset
+ posn
1606 && e
->new_encoding
!= enc
1607 && symval
<= e
->max_disp
)
1610 insn
[1] |= e
->new_encoding
;
1611 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1612 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1613 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1619 } /* Ends switch (reloc type) for m16c. */
1621 else /* machine == bfd_mach_m32c */
1625 switch (ELF32_R_TYPE(irel
->r_info
))
1628 case R_M32C_RL_JUMP
:
1631 case 0xbb: /* jmp.b */
1632 if (pcrel
>= 2 && pcrel
<= 9)
1635 /* Relax JMP.B -> JMP.S. We need to get rid of
1636 the following reloc though. */
1637 insn
[0] = 0x4a | ((p
<< 3) & 0x30) | (p
& 1);
1638 new_type
= R_M32C_NONE
;
1639 irel
->r_addend
= 0x10;
1645 case 0xce: /* jmp.w */
1646 if (pcrel
<= 128 && pcrel
>= -128)
1648 /* Relax JMP.W -> JMP.B */
1651 new_type
= R_M32C_8_PCREL
;
1657 case 0xcc: /* jmp.a */
1658 if (pcrel
<= 32768 && pcrel
>= -32768)
1660 /* Relax JMP.A -> JMP.W */
1664 new_type
= R_M32C_16_PCREL
;
1670 case 0xcd: /* jsr.a */
1671 if (pcrel
<= 32768 && pcrel
>= -32768)
1673 /* Relax JSR.A -> JSR.W */
1677 new_type
= R_M32C_16_PCREL
;
1685 case R_M32C_RL_2ADDR
:
1686 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1692 /* prefix; remove it as far as the RL reloc is concerned. */
1697 enctbl
= m32c_addr_encodings
;
1698 enc
= ((einsn
[0] & 0x70) >> 2) | ((einsn
[1] & 0x30) >> 4);
1701 if (srel
->r_offset
== irel
->r_offset
+ posn
1702 && e
->new_encoding
!= enc
1703 && symval
<= e
->max_disp
)
1706 einsn
[0] |= (e
->new_encoding
& 0x1c) << 2;
1708 einsn
[1] |= (e
->new_encoding
& 0x03) << 4;
1709 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1710 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1711 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1714 if (relax_relocs
== 2)
1720 case R_M32C_RL_1ADDR
:
1721 /* xxxx DDDx DDxx xxxx [disp] */
1727 /* prefix; remove it as far as the RL reloc is concerned. */
1732 enctbl
= m32c_addr_encodings
;
1735 /* srel, posn, and enc must be set here. */
1737 symval
= OFFSET_FOR_RELOC (srel
);
1738 enc
= ((einsn
[0] & 0x0e) << 1) | ((einsn
[1] & 0xc0) >> 6);
1741 if (srel
->r_offset
== irel
->r_offset
+ posn
1742 && e
->new_encoding
!= enc
1743 && symval
<= e
->max_disp
)
1746 einsn
[0] |= (e
->new_encoding
& 0x1c) >> 1;
1748 einsn
[1] |= (e
->new_encoding
& 0x03) << 6;
1749 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1750 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1751 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1757 } /* Ends switch (reloc type) for m32c. */
1765 srel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (srel
->r_info
), new_type
);
1767 /* Note that we've changed the relocs, section contents, etc. */
1768 elf_section_data (sec
)->relocs
= internal_relocs
;
1771 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1772 free_contents
= NULL
;
1774 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1775 free_intsyms
= NULL
;
1777 bytes_saved
+= gap_size
;
1779 if (! m32c_elf_relax_delete_bytes(abfd
, sec
, gap
- contents
, gap_size
))
1782 } /* next relocation */
1784 if (free_relocs
!= NULL
)
1790 if (free_contents
!= NULL
)
1792 if (! link_info
->keep_memory
)
1793 free (free_contents
);
1794 /* Cache the section contents for elf_link_input_bfd. */
1796 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1798 free_contents
= NULL
;
1801 if (shndx_buf
!= NULL
)
1803 shndx_hdr
->contents
= NULL
;
1807 if (free_intsyms
!= NULL
)
1809 if (! link_info
->keep_memory
)
1810 free (free_intsyms
);
1811 /* Cache the symbols for elf_link_input_bfd. */
1814 symtab_hdr
->contents
= NULL
/* (unsigned char *) intsyms*/;
1817 free_intsyms
= NULL
;
1823 if (free_relocs
!= NULL
)
1825 if (free_contents
!= NULL
)
1826 free (free_contents
);
1827 if (shndx_buf
!= NULL
)
1829 shndx_hdr
->contents
= NULL
;
1832 if (free_intsyms
!= NULL
)
1833 free (free_intsyms
);
1837 /* Delete some bytes from a section while relaxing. */
1840 m32c_elf_relax_delete_bytes
1846 Elf_Internal_Shdr
*symtab_hdr
;
1847 Elf_Internal_Shdr
*shndx_hdr
;
1850 Elf_Internal_Rela
*irel
;
1851 Elf_Internal_Rela
*irelend
;
1853 Elf_Internal_Sym
*isym
;
1854 Elf_Internal_Sym
*isymend
;
1855 Elf_Internal_Sym
*intsyms
;
1856 Elf_External_Sym_Shndx
*shndx_buf
;
1857 Elf_External_Sym_Shndx
*shndx
;
1858 struct elf_link_hash_entry
** sym_hashes
;
1859 struct elf_link_hash_entry
** end_hashes
;
1860 unsigned int symcount
;
1862 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1866 irel
= elf_section_data (sec
)->relocs
;
1867 irelend
= irel
+ sec
->reloc_count
;
1869 /* Actually delete the bytes. */
1870 memmove (contents
+ addr
, contents
+ addr
+ count
, (size_t) (toaddr
- addr
- count
));
1873 /* Adjust all the relocs. */
1874 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1876 /* Get the new reloc address. */
1877 if (irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
)
1878 irel
->r_offset
-= count
;
1880 if (ELF32_R_TYPE(irel
->r_info
) == R_M32C_RL_JUMP
1881 && irel
->r_addend
== 0x10 /* one byte insn, no relocs */
1882 && irel
->r_offset
+ 1 < addr
1883 && irel
->r_offset
+ 7 > addr
)
1886 unsigned char *insn
= &contents
[irel
->r_offset
];
1888 /* This is a JMP.S, which we have to manually update. */
1889 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
1891 if ((*insn
& 0xf8) != 0x60)
1897 if ((*insn
& 0xce) != 0x4a)
1899 disp
= ((disp
& 0x30) >> 3) | (disp
& 1);
1901 if (irel
->r_offset
+ disp
+ 2 >= addr
+count
)
1904 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
1906 *insn
= (*insn
& 0xf8) | disp
;
1910 *insn
= (*insn
& 0xce) | ((disp
& 6) << 3) | (disp
& 1);
1916 /* Adjust the local symbols defined in this section. */
1917 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
1918 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1920 isymend
= isym
+ symtab_hdr
->sh_info
;
1922 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1923 shndx_hdr
= & elf_tdata (abfd
)->symtab_shndx_hdr
;
1924 shndx_buf
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
1927 for (; isym
< isymend
; isym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
1929 /* If the symbol is in the range of memory we just moved, we
1930 have to adjust its value. */
1931 if ((int) isym
->st_shndx
== sec_shndx
1932 && isym
->st_value
> addr
1933 && isym
->st_value
< toaddr
)
1935 isym
->st_value
-= count
;
1937 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1938 *end* is in the moved bytes but it's *start* isn't), then we
1939 must adjust its size. */
1940 if ((int) isym
->st_shndx
== sec_shndx
1941 && isym
->st_value
< addr
1942 && isym
->st_value
+ isym
->st_size
> addr
1943 && isym
->st_value
+ isym
->st_size
< toaddr
)
1945 isym
->st_size
-= count
;
1949 /* Now adjust the global symbols defined in this section. */
1950 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1951 - symtab_hdr
->sh_info
);
1952 sym_hashes
= elf_sym_hashes (abfd
);
1953 // sym_hashes += symtab_hdr->sh_info;
1954 end_hashes
= sym_hashes
+ symcount
;
1956 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1958 struct elf_link_hash_entry
* sym_hash
= * sym_hashes
;
1961 (sym_hash
->root
.type
== bfd_link_hash_defined
1962 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1963 && sym_hash
->root
.u
.def
.section
== sec
)
1965 if (sym_hash
->root
.u
.def
.value
> addr
1966 && sym_hash
->root
.u
.def
.value
< toaddr
)
1968 sym_hash
->root
.u
.def
.value
-= count
;
1970 if (sym_hash
->root
.u
.def
.value
< addr
1971 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
1972 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
1974 sym_hash
->size
-= count
;
1982 /* This is for versions of gcc prior to 4.3. */
1984 _bfd_m32c_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1986 if ((elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
) == EF_M32C_CPU_M16C
)
1993 #define ELF_ARCH bfd_arch_m32c
1994 #define ELF_MACHINE_CODE EM_M32C
1995 #define ELF_MACHINE_ALT1 EM_M32C_OLD
1996 #define ELF_MAXPAGESIZE 0x100
1999 #define TARGET_BIG_SYM bfd_elf32_m32c_vec
2000 #define TARGET_BIG_NAME "elf32-m32c"
2002 #define TARGET_LITTLE_SYM bfd_elf32_m32c_vec
2003 #define TARGET_LITTLE_NAME "elf32-m32c"
2006 #define elf_info_to_howto_rel NULL
2007 #define elf_info_to_howto m32c_info_to_howto_rela
2008 #define elf_backend_object_p m32c_elf_object_p
2009 #define elf_backend_relocate_section m32c_elf_relocate_section
2010 #define elf_backend_check_relocs m32c_elf_check_relocs
2011 #define elf_backend_object_p m32c_elf_object_p
2012 #define elf_symbol_leading_char ('_')
2013 #define elf_backend_always_size_sections \
2014 m32c_elf_always_size_sections
2015 #define elf_backend_finish_dynamic_sections \
2016 m32c_elf_finish_dynamic_sections
2018 #define elf_backend_can_gc_sections 1
2019 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2021 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2022 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2023 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2024 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2025 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2026 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2028 #include "elf32-target.h"