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
;
625 /* PR15323, ref flags aren't set for references in the same
627 h
->root
.non_ir_ref
= 1;
630 switch (ELF32_R_TYPE (rel
->r_info
))
632 /* This relocation describes a 16-bit pointer to a function.
633 We may need to allocate a thunk in low memory; reserve memory
637 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
640 splt
= bfd_get_linker_section (dynobj
, ".plt");
643 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
644 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
645 | SEC_READONLY
| SEC_CODE
);
646 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
649 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
655 offset
= &h
->plt
.offset
;
658 if (local_plt_offsets
== NULL
)
663 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
664 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
665 if (local_plt_offsets
== NULL
)
667 elf_local_got_offsets (abfd
) = local_plt_offsets
;
669 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
670 local_plt_offsets
[i
] = (bfd_vma
) -1;
672 offset
= &local_plt_offsets
[r_symndx
];
675 if (*offset
== (bfd_vma
) -1)
677 *offset
= splt
->size
;
687 /* This must exist if dynobj is ever set. */
690 m32c_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
691 struct bfd_link_info
*info
)
696 /* As an extra sanity check, verify that all plt entries have
699 if ((dynobj
= elf_hash_table (info
)->dynobj
) != NULL
700 && (splt
= bfd_get_linker_section (dynobj
, ".plt")) != NULL
)
702 bfd_byte
*contents
= splt
->contents
;
703 unsigned int i
, size
= splt
->size
;
704 for (i
= 0; i
< size
; i
+= 4)
706 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
715 m32c_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
716 struct bfd_link_info
*info
)
721 if (info
->relocatable
)
724 dynobj
= elf_hash_table (info
)->dynobj
;
728 splt
= bfd_get_linker_section (dynobj
, ".plt");
729 BFD_ASSERT (splt
!= NULL
);
731 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
732 if (splt
->contents
== NULL
)
738 /* Function to set the ELF flag bits. */
741 m32c_elf_set_private_flags (bfd
*abfd
, flagword flags
)
743 elf_elfheader (abfd
)->e_flags
= flags
;
744 elf_flags_init (abfd
) = TRUE
;
748 /* Merge backend specific data from an object file to the output
749 object file when linking. */
752 m32c_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
754 flagword old_flags
, old_partial
;
755 flagword new_flags
, new_partial
;
756 bfd_boolean error
= FALSE
;
760 new_opt
[0] = old_opt
[0] = '\0';
761 new_flags
= elf_elfheader (ibfd
)->e_flags
;
762 old_flags
= elf_elfheader (obfd
)->e_flags
;
765 (*_bfd_error_handler
) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
766 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
767 bfd_get_filename (ibfd
));
770 if (!elf_flags_init (obfd
))
772 /* First call, no flags set. */
773 elf_flags_init (obfd
) = TRUE
;
774 elf_elfheader (obfd
)->e_flags
= new_flags
;
777 else if (new_flags
== old_flags
)
778 /* Compatible flags are ok. */
781 else /* Possibly incompatible flags. */
783 /* Warn if different cpu is used (allow a specific cpu to override
785 new_partial
= (new_flags
& EF_M32C_CPU_MASK
);
786 old_partial
= (old_flags
& EF_M32C_CPU_MASK
);
787 if (new_partial
== old_partial
)
794 default: strcat (new_opt
, " -m16c"); break;
795 case EF_M32C_CPU_M16C
: strcat (new_opt
, " -m16c"); break;
796 case EF_M32C_CPU_M32C
: strcat (new_opt
, " -m32c"); break;
801 default: strcat (old_opt
, " -m16c"); break;
802 case EF_M32C_CPU_M16C
: strcat (old_opt
, " -m16c"); break;
803 case EF_M32C_CPU_M32C
: strcat (old_opt
, " -m32c"); break;
807 /* Print out any mismatches from above. */
811 (*_bfd_error_handler
)
812 (_("%s: compiled with %s and linked with modules compiled with %s"),
813 bfd_get_filename (ibfd
), new_opt
, old_opt
);
816 new_flags
&= ~ EF_M32C_ALL_FLAGS
;
817 old_flags
&= ~ EF_M32C_ALL_FLAGS
;
819 /* Warn about any other mismatches. */
820 if (new_flags
!= old_flags
)
823 (*_bfd_error_handler
)
824 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
825 bfd_get_filename (ibfd
), (long)new_flags
, (long)old_flags
);
830 bfd_set_error (bfd_error_bad_value
);
837 m32c_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
839 FILE *file
= (FILE *) ptr
;
842 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
844 /* Print normal ELF private data. */
845 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
847 flags
= elf_elfheader (abfd
)->e_flags
;
848 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
850 switch (flags
& EF_M32C_CPU_MASK
)
853 case EF_M32C_CPU_M16C
: fprintf (file
, " -m16c"); break;
854 case EF_M32C_CPU_M32C
: fprintf (file
, " -m32c"); break;
861 /* Return the MACH for an e_flags value. */
864 elf32_m32c_machine (bfd
*abfd
)
866 switch (elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
)
868 case EF_M32C_CPU_M16C
: return bfd_mach_m16c
;
869 case EF_M32C_CPU_M32C
: return bfd_mach_m32c
;
872 return bfd_mach_m16c
;
876 m32c_elf_object_p (bfd
*abfd
)
878 bfd_default_set_arch_mach (abfd
, bfd_arch_m32c
,
879 elf32_m32c_machine (abfd
));
886 dump_symtab (bfd
* abfd
, void *internal_syms
, void *external_syms
)
889 Elf_Internal_Sym
*isymbuf
;
890 Elf_Internal_Sym
*isymend
;
891 Elf_Internal_Sym
*isym
;
892 Elf_Internal_Shdr
*symtab_hdr
;
893 bfd_boolean free_internal
= 0, free_external
= 0;
895 char * st_info_stb_str
;
901 internal_syms
= bfd_malloc (1000);
906 external_syms
= bfd_malloc (1000);
910 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
911 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data(abfd
)->s
->sizeof_sym
;
913 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
914 symtab_hdr
->sh_info
, 0,
915 internal_syms
, external_syms
, NULL
);
917 isymbuf
= internal_syms
;
918 isymend
= isymbuf
+ locsymcount
;
920 for (isym
= isymbuf
; isym
< isymend
; isym
++)
922 switch (ELF_ST_TYPE (isym
->st_info
))
925 st_info_str
= "STT_FUNC";
929 st_info_str
= "STT_SECTION";
933 st_info_str
= "STT_FILE";
937 st_info_str
= "STT_OBJECT";
941 st_info_str
= "STT_TLS";
948 switch (ELF_ST_BIND (isym
->st_info
))
951 st_info_stb_str
= "STB_LOCAL";
955 st_info_stb_str
= "STB_GLOBAL";
959 st_info_stb_str
= "";
962 switch (ELF_ST_VISIBILITY (isym
->st_other
))
965 st_other_str
= "STV_DEFAULT";
969 st_other_str
= "STV_INTERNAL";
973 st_other_str
= "STV_PROTECTED";
980 switch (isym
->st_shndx
)
983 st_shndx_str
= "SHN_ABS";
987 st_shndx_str
= "SHN_COMMON";
991 st_shndx_str
= "SHN_UNDEF";
998 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
999 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1001 (unsigned long) isym
->st_value
,
1002 (unsigned long) isym
->st_size
,
1004 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
1006 isym
->st_info
, st_info_str
, st_info_stb_str
,
1007 isym
->st_other
, st_other_str
,
1008 isym
->st_shndx
, st_shndx_str
);
1011 free (internal_syms
);
1013 free (external_syms
);
1017 m32c_get_reloc (long reloc
)
1019 if (0 <= reloc
&& reloc
< R_M32C_max
)
1020 return m32c_elf_howto_table
[reloc
].name
;
1026 /* Handle relaxing. */
1028 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1029 is within the low 64k, remove any entry for it in the plt. */
1031 struct relax_plt_data
1038 m32c_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1040 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1042 if (h
->plt
.offset
!= (bfd_vma
) -1)
1046 if (h
->root
.type
== bfd_link_hash_undefined
1047 || h
->root
.type
== bfd_link_hash_undefweak
)
1050 address
= (h
->root
.u
.def
.section
->output_section
->vma
1051 + h
->root
.u
.def
.section
->output_offset
1052 + h
->root
.u
.def
.value
);
1054 if (address
<= 0xffff)
1057 data
->splt
->size
-= 4;
1058 *data
->again
= TRUE
;
1065 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1066 previously had a plt entry, give it a new entry offset. */
1069 m32c_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1071 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1073 if (h
->plt
.offset
!= (bfd_vma
) -1)
1075 h
->plt
.offset
= *entry
;
1083 m32c_elf_relax_plt_section (asection
*splt
,
1084 struct bfd_link_info
*info
,
1087 struct relax_plt_data relax_plt_data
;
1090 /* Assume nothing changes. */
1093 if (info
->relocatable
)
1096 /* Quick check for an empty plt. */
1097 if (splt
->size
== 0)
1100 /* Map across all global symbols; see which ones happen to
1101 fall in the low 64k. */
1102 relax_plt_data
.splt
= splt
;
1103 relax_plt_data
.again
= again
;
1104 elf_link_hash_traverse (elf_hash_table (info
), m32c_relax_plt_check
,
1107 /* Likewise for local symbols, though that's somewhat less convenient
1108 as we have to walk the list of input bfds and swap in symbol data. */
1109 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1111 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1112 Elf_Internal_Shdr
*symtab_hdr
;
1113 Elf_Internal_Sym
*isymbuf
= NULL
;
1116 if (! local_plt_offsets
)
1119 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1120 if (symtab_hdr
->sh_info
!= 0)
1122 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1123 if (isymbuf
== NULL
)
1124 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1125 symtab_hdr
->sh_info
, 0,
1127 if (isymbuf
== NULL
)
1131 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1133 Elf_Internal_Sym
*isym
;
1137 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1140 isym
= &isymbuf
[idx
];
1141 if (isym
->st_shndx
== SHN_UNDEF
)
1143 else if (isym
->st_shndx
== SHN_ABS
)
1144 tsec
= bfd_abs_section_ptr
;
1145 else if (isym
->st_shndx
== SHN_COMMON
)
1146 tsec
= bfd_com_section_ptr
;
1148 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1150 address
= (tsec
->output_section
->vma
1151 + tsec
->output_offset
1153 if (address
<= 0xffff)
1155 local_plt_offsets
[idx
] = -1;
1162 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1164 if (! info
->keep_memory
)
1168 /* Cache the symbols for elf_link_input_bfd. */
1169 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1174 /* If we changed anything, walk the symbols again to reallocate
1175 .plt entry addresses. */
1176 if (*again
&& splt
->size
> 0)
1180 elf_link_hash_traverse (elf_hash_table (info
),
1181 m32c_relax_plt_realloc
, &entry
);
1183 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link_next
)
1185 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1186 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1189 if (! local_plt_offsets
)
1192 for (idx
= 0; idx
< nlocals
; ++idx
)
1193 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1195 local_plt_offsets
[idx
] = entry
;
1205 compare_reloc (const void *e1
, const void *e2
)
1207 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
1208 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
1210 if (i1
->r_offset
== i2
->r_offset
)
1213 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
1216 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1218 m32c_offset_for_reloc (bfd
*abfd
,
1219 Elf_Internal_Rela
*rel
,
1220 Elf_Internal_Shdr
*symtab_hdr
,
1221 Elf_External_Sym_Shndx
*shndx_buf ATTRIBUTE_UNUSED
,
1222 Elf_Internal_Sym
*intsyms
)
1226 /* Get the value of the symbol referred to by the reloc. */
1227 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1229 /* A local symbol. */
1230 Elf_Internal_Sym
*isym
;
1233 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1234 ssec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1235 symval
= isym
->st_value
;
1237 symval
+= ssec
->output_section
->vma
1238 + ssec
->output_offset
;
1243 struct elf_link_hash_entry
*h
;
1245 /* An external symbol. */
1246 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1247 h
= elf_sym_hashes (abfd
)[indx
];
1248 BFD_ASSERT (h
!= NULL
);
1250 if (h
->root
.type
!= bfd_link_hash_defined
1251 && h
->root
.type
!= bfd_link_hash_defweak
)
1252 /* This appears to be a reference to an undefined
1253 symbol. Just ignore it--it will be caught by the
1254 regular reloc processing. */
1257 symval
= (h
->root
.u
.def
.value
1258 + h
->root
.u
.def
.section
->output_section
->vma
1259 + h
->root
.u
.def
.section
->output_offset
);
1264 static int bytes_saved
= 0;
1266 static int bytes_to_reloc
[] = {
1274 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1276 /* Mask for the number of relocs associated with this insn. */
1277 #define RLA_RELOCS 0x0000000f
1278 /* Number of bytes gas emitted (before gas's relaxing) */
1279 #define RLA_NBYTES 0x00000ff0
1281 /* If the displacement is within the given range and the new encoding
1282 differs from the old encoding (the index), then the insn can be
1283 relaxed to the new encoding. */
1286 unsigned int max_disp
;
1287 unsigned char new_encoding
;
1290 static EncodingTable m16c_addr_encodings
[] = {
1291 { 0, 0, 0 }, /* R0 */
1292 { 0, 0, 1 }, /* R1 */
1293 { 0, 0, 2 }, /* R2 */
1294 { 0, 0, 3 }, /* R3 */
1295 { 0, 0, 4 }, /* A0 */
1296 { 0, 0, 5 }, /* A1 */
1297 { 0, 0, 6 }, /* [A0] */
1298 { 0, 0, 7 }, /* [A1] */
1299 { 1, 0, 6 }, /* udsp:8[A0] */
1300 { 1, 0, 7 }, /* udsp:8[A1] */
1301 { 1, 0, 10 }, /* udsp:8[SB] */
1302 { 1, 0, 11 }, /* sdsp:8[FB] */
1303 { 2, 255, 8 }, /* udsp:16[A0] */
1304 { 2, 255, 9 }, /* udsp:16[A1] */
1305 { 2, 255, 10 }, /* udsp:16[SB] */
1306 { 2, 0, 15 }, /* abs:16 */
1309 static EncodingTable m16c_jmpaddr_encodings
[] = {
1310 { 0, 0, 0 }, /* R0 */
1311 { 0, 0, 1 }, /* R1 */
1312 { 0, 0, 2 }, /* R2 */
1313 { 0, 0, 3 }, /* R3 */
1314 { 0, 0, 4 }, /* A0 */
1315 { 0, 0, 5 }, /* A1 */
1316 { 0, 0, 6 }, /* [A0] */
1317 { 0, 0, 7 }, /* [A1] */
1318 { 1, 0, 6 }, /* udsp:8[A0] */
1319 { 1, 0, 7 }, /* udsp:8[A1] */
1320 { 1, 0, 10 }, /* udsp:8[SB] */
1321 { 1, 0, 11 }, /* sdsp:8[FB] */
1322 { 3, 255, 8 }, /* udsp:20[A0] */
1323 { 3, 255, 9 }, /* udsp:20[A1] */
1324 { 2, 255, 10 }, /* udsp:16[SB] */
1325 { 2, 0, 15 }, /* abs:16 */
1328 static EncodingTable m32c_addr_encodings
[] = {
1329 { 0, 0, 0 }, /* [A0] */
1330 { 0, 0, 1 }, /* [A1] */
1331 { 0, 0, 2 }, /* A0 */
1332 { 0, 0, 3 }, /* A1 */
1333 { 1, 0, 0 }, /* udsp:8[A0] */
1334 { 1, 0, 1 }, /* udsp:8[A1] */
1335 { 1, 0, 6 }, /* udsp:8[SB] */
1336 { 1, 0, 7 }, /* sdsp:8[FB] */
1337 { 2, 255, 4 }, /* udsp:16[A0] */
1338 { 2, 255, 5 }, /* udsp:16[A1] */
1339 { 2, 255, 6 }, /* udsp:16[SB] */
1340 { 2, 127, 7 }, /* sdsp:16[FB] */
1341 { 3, 65535, 8 }, /* udsp:24[A0] */
1342 { 3, 65535, 9 }, /* udsp:24[A1] */
1343 { 3, 65535, 15 }, /* abs24 */
1344 { 2, 0, 15 }, /* abs16 */
1345 { 0, 0, 16 }, /* R2 */
1346 { 0, 0, 17 }, /* R3 */
1347 { 0, 0, 18 }, /* R0 */
1348 { 0, 0, 19 }, /* R1 */
1364 m32c_elf_relax_section
1367 struct bfd_link_info
* link_info
,
1368 bfd_boolean
* again
)
1370 Elf_Internal_Shdr
*symtab_hdr
;
1371 Elf_Internal_Shdr
*shndx_hdr
;
1372 Elf_Internal_Rela
*internal_relocs
;
1373 Elf_Internal_Rela
*free_relocs
= NULL
;
1374 Elf_Internal_Rela
*irel
, *irelend
, *srel
;
1375 bfd_byte
* contents
= NULL
;
1376 bfd_byte
* free_contents
= NULL
;
1377 Elf_Internal_Sym
*intsyms
= NULL
;
1378 Elf_Internal_Sym
*free_intsyms
= NULL
;
1379 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1382 if (abfd
== elf_hash_table (link_info
)->dynobj
1383 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1384 && strcmp (sec
->name
, ".plt") == 0)
1385 return m32c_elf_relax_plt_section (sec
, link_info
, again
);
1387 /* Assume nothing changes. */
1390 machine
= elf32_m32c_machine (abfd
);
1392 /* We don't have to do anything for a relocatable link, if
1393 this section does not have relocs, or if this is not a
1395 if (link_info
->relocatable
1396 || (sec
->flags
& SEC_RELOC
) == 0
1397 || sec
->reloc_count
== 0
1398 || (sec
->flags
& SEC_CODE
) == 0)
1401 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1402 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1404 /* Get the section contents. */
1405 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1406 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1407 /* Go get them off disk. */
1408 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1411 /* Read this BFD's symbols. */
1412 /* Get cached copy if it exists. */
1413 if (symtab_hdr
->contents
!= NULL
)
1415 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1419 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
1420 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1423 if (shndx_hdr
->sh_size
!= 0)
1427 amt
= symtab_hdr
->sh_info
;
1428 amt
*= sizeof (Elf_External_Sym_Shndx
);
1429 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1430 if (shndx_buf
== NULL
)
1432 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1433 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
1435 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1438 /* Get a copy of the native relocations. */
1439 internal_relocs
= (_bfd_elf_link_read_relocs
1440 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
1441 link_info
->keep_memory
));
1442 if (internal_relocs
== NULL
)
1444 if (! link_info
->keep_memory
)
1445 free_relocs
= internal_relocs
;
1447 /* The RL_ relocs must be just before the operand relocs they go
1448 with, so we must sort them to guarantee this. */
1449 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
1452 /* Walk through them looking for relaxing opportunities. */
1453 irelend
= internal_relocs
+ sec
->reloc_count
;
1455 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1458 unsigned char *insn
, *gap
, *einsn
;
1460 bfd_signed_vma pcrel
;
1466 EncodingTable
*enctbl
;
1469 if (ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_JUMP
1470 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_1ADDR
1471 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_2ADDR
)
1476 /* There will always be room for the relaxed insn, since it is smaller
1477 than the one it would replace. */
1478 BFD_ASSERT (irel
->r_offset
< sec
->size
);
1480 insn
= contents
+ irel
->r_offset
;
1481 relax_relocs
= irel
->r_addend
% 16;
1483 /* Ok, we only have three relocs we care about, and they're all
1484 fake. The lower four bits of the addend is always the number
1485 of following relocs (hence the qsort above) that are assigned
1486 to this opcode. The next 8 bits of the addend indicates the
1487 number of bytes in the insn. We use the rest of them
1488 ourselves as flags for the more expensive operations (defines
1489 above). The three relocs are:
1491 RL_JUMP: This marks all direct jump insns. We check the
1492 displacement and replace them with shorter jumps if
1493 they're in range. We also use this to find JMP.S
1494 insns and manually shorten them when we delete bytes.
1495 We have to decode these insns to figure out what to
1498 RL_1ADDR: This is a :G or :Q insn, which has a single
1499 "standard" operand. We have to extract the type
1500 field, see if it's a wide displacement, then figure
1501 out if we can replace it with a narrow displacement.
1502 We don't have to decode these insns.
1504 RL_2ADDR: Similarly, but two "standard" operands. Note that
1505 r_addend may still be 1, as standard operands don't
1506 always have displacements. Gas shouldn't give us one
1507 with zero operands, but since we don't know which one
1508 has the displacement, we check them both anyway.
1510 These all point to the beginning of the insn itself, not the
1513 Note that we only relax one step at a time, relying on the
1514 linker to call us repeatedly. Thus, there is no code for
1515 JMP.A->JMP.B although that will happen in two steps.
1516 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1519 /* Get the value of the symbol referred to by the reloc. Just
1520 in case this is the last reloc in the list, use the RL's
1521 addend to choose between this reloc (no addend) or the next
1522 (yes addend, which means at least one following reloc). */
1523 srel
= irel
+ (relax_relocs
? 1 : 0);
1524 symval
= OFFSET_FOR_RELOC (srel
);
1526 /* Setting gap_size nonzero is the flag which means "something
1530 new_type
= ELF32_R_TYPE(srel
->r_info
);
1532 pc
= sec
->output_section
->vma
+ sec
->output_offset
1534 pcrel
= symval
- pc
+ srel
->r_addend
;
1536 if (machine
== bfd_mach_m16c
)
1540 switch (ELF32_R_TYPE(irel
->r_info
))
1543 case R_M32C_RL_JUMP
:
1546 case 0xfe: /* jmp.b */
1547 if (pcrel
>= 2 && pcrel
<= 9)
1549 /* Relax JMP.B -> JMP.S. We need to get rid of
1550 the following reloc though. */
1551 insn
[0] = 0x60 | (pcrel
- 2);
1552 new_type
= R_M32C_NONE
;
1553 irel
->r_addend
= 0x10;
1559 case 0xf4: /* jmp.w */
1560 /* 128 is allowed because it will be one byte closer
1561 after relaxing. Likewise for all other pc-rel
1563 if (pcrel
<= 128 && pcrel
>= -128)
1565 /* Relax JMP.W -> JMP.B */
1568 new_type
= R_M32C_8_PCREL
;
1574 case 0xfc: /* jmp.a */
1575 if (pcrel
<= 32768 && pcrel
>= -32768)
1577 /* Relax JMP.A -> JMP.W */
1581 new_type
= R_M32C_16_PCREL
;
1587 case 0xfd: /* jsr.a */
1588 if (pcrel
<= 32768 && pcrel
>= -32768)
1590 /* Relax JSR.A -> JSR.W */
1594 new_type
= R_M32C_16_PCREL
;
1602 case R_M32C_RL_2ADDR
:
1603 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1605 enctbl
= m16c_addr_encodings
;
1607 enc
= (insn
[1] >> 4) & 0x0f;
1610 if (srel
->r_offset
== irel
->r_offset
+ posn
1611 && e
->new_encoding
!= enc
1612 && symval
<= e
->max_disp
)
1615 insn
[1] |= e
->new_encoding
<< 4;
1616 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1617 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1618 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1621 if (relax_relocs
== 2)
1627 case R_M32C_RL_1ADDR
:
1628 /* xxxx xxxx xxxx dest [disp] */
1630 enctbl
= m16c_addr_encodings
;
1633 /* Check the opcode for jumps. We know it's safe to
1634 do this because all 2ADDR insns are at least two
1636 enc
= insn
[0] * 256 + insn
[1];
1643 enctbl
= m16c_jmpaddr_encodings
;
1647 /* srel, posn, and enc must be set here. */
1649 symval
= OFFSET_FOR_RELOC (srel
);
1650 enc
= insn
[1] & 0x0f;
1653 if (srel
->r_offset
== irel
->r_offset
+ posn
1654 && e
->new_encoding
!= enc
1655 && symval
<= e
->max_disp
)
1658 insn
[1] |= e
->new_encoding
;
1659 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1660 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1661 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1667 } /* Ends switch (reloc type) for m16c. */
1669 else /* machine == bfd_mach_m32c */
1673 switch (ELF32_R_TYPE(irel
->r_info
))
1676 case R_M32C_RL_JUMP
:
1679 case 0xbb: /* jmp.b */
1680 if (pcrel
>= 2 && pcrel
<= 9)
1683 /* Relax JMP.B -> JMP.S. We need to get rid of
1684 the following reloc though. */
1685 insn
[0] = 0x4a | ((p
<< 3) & 0x30) | (p
& 1);
1686 new_type
= R_M32C_NONE
;
1687 irel
->r_addend
= 0x10;
1693 case 0xce: /* jmp.w */
1694 if (pcrel
<= 128 && pcrel
>= -128)
1696 /* Relax JMP.W -> JMP.B */
1699 new_type
= R_M32C_8_PCREL
;
1705 case 0xcc: /* jmp.a */
1706 if (pcrel
<= 32768 && pcrel
>= -32768)
1708 /* Relax JMP.A -> JMP.W */
1712 new_type
= R_M32C_16_PCREL
;
1718 case 0xcd: /* jsr.a */
1719 if (pcrel
<= 32768 && pcrel
>= -32768)
1721 /* Relax JSR.A -> JSR.W */
1725 new_type
= R_M32C_16_PCREL
;
1733 case R_M32C_RL_2ADDR
:
1734 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1740 /* prefix; remove it as far as the RL reloc is concerned. */
1745 enctbl
= m32c_addr_encodings
;
1746 enc
= ((einsn
[0] & 0x70) >> 2) | ((einsn
[1] & 0x30) >> 4);
1749 if (srel
->r_offset
== irel
->r_offset
+ posn
1750 && e
->new_encoding
!= enc
1751 && symval
<= e
->max_disp
)
1754 einsn
[0] |= (e
->new_encoding
& 0x1c) << 2;
1756 einsn
[1] |= (e
->new_encoding
& 0x03) << 4;
1757 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1758 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1759 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1762 if (relax_relocs
== 2)
1768 case R_M32C_RL_1ADDR
:
1769 /* xxxx DDDx DDxx xxxx [disp] */
1775 /* prefix; remove it as far as the RL reloc is concerned. */
1780 enctbl
= m32c_addr_encodings
;
1783 /* srel, posn, and enc must be set here. */
1785 symval
= OFFSET_FOR_RELOC (srel
);
1786 enc
= ((einsn
[0] & 0x0e) << 1) | ((einsn
[1] & 0xc0) >> 6);
1789 if (srel
->r_offset
== irel
->r_offset
+ posn
1790 && e
->new_encoding
!= enc
1791 && symval
<= e
->max_disp
)
1794 einsn
[0] |= (e
->new_encoding
& 0x1c) >> 1;
1796 einsn
[1] |= (e
->new_encoding
& 0x03) << 6;
1797 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1798 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1799 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1805 } /* Ends switch (reloc type) for m32c. */
1813 srel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (srel
->r_info
), new_type
);
1815 /* Note that we've changed the relocs, section contents, etc. */
1816 elf_section_data (sec
)->relocs
= internal_relocs
;
1819 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1820 free_contents
= NULL
;
1822 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1823 free_intsyms
= NULL
;
1825 bytes_saved
+= gap_size
;
1827 if (! m32c_elf_relax_delete_bytes(abfd
, sec
, gap
- contents
, gap_size
))
1830 } /* next relocation */
1832 if (free_relocs
!= NULL
)
1838 if (free_contents
!= NULL
)
1840 if (! link_info
->keep_memory
)
1841 free (free_contents
);
1842 /* Cache the section contents for elf_link_input_bfd. */
1844 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1846 free_contents
= NULL
;
1849 if (shndx_buf
!= NULL
)
1851 shndx_hdr
->contents
= NULL
;
1855 if (free_intsyms
!= NULL
)
1857 if (! link_info
->keep_memory
)
1858 free (free_intsyms
);
1859 /* Cache the symbols for elf_link_input_bfd. */
1862 symtab_hdr
->contents
= NULL
/* (unsigned char *) intsyms*/;
1865 free_intsyms
= NULL
;
1871 if (free_relocs
!= NULL
)
1873 if (free_contents
!= NULL
)
1874 free (free_contents
);
1875 if (shndx_buf
!= NULL
)
1877 shndx_hdr
->contents
= NULL
;
1880 if (free_intsyms
!= NULL
)
1881 free (free_intsyms
);
1885 /* Delete some bytes from a section while relaxing. */
1888 m32c_elf_relax_delete_bytes
1894 Elf_Internal_Shdr
*symtab_hdr
;
1895 Elf_Internal_Shdr
*shndx_hdr
;
1898 Elf_Internal_Rela
*irel
;
1899 Elf_Internal_Rela
*irelend
;
1901 Elf_Internal_Sym
*isym
;
1902 Elf_Internal_Sym
*isymend
;
1903 Elf_Internal_Sym
*intsyms
;
1904 Elf_External_Sym_Shndx
*shndx_buf
;
1905 Elf_External_Sym_Shndx
*shndx
;
1906 struct elf_link_hash_entry
** sym_hashes
;
1907 struct elf_link_hash_entry
** end_hashes
;
1908 unsigned int symcount
;
1910 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1914 irel
= elf_section_data (sec
)->relocs
;
1915 irelend
= irel
+ sec
->reloc_count
;
1917 /* Actually delete the bytes. */
1918 memmove (contents
+ addr
, contents
+ addr
+ count
, (size_t) (toaddr
- addr
- count
));
1921 /* Adjust all the relocs. */
1922 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1924 /* Get the new reloc address. */
1925 if (irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
)
1926 irel
->r_offset
-= count
;
1928 if (ELF32_R_TYPE(irel
->r_info
) == R_M32C_RL_JUMP
1929 && irel
->r_addend
== 0x10 /* one byte insn, no relocs */
1930 && irel
->r_offset
+ 1 < addr
1931 && irel
->r_offset
+ 7 > addr
)
1934 unsigned char *insn
= &contents
[irel
->r_offset
];
1936 /* This is a JMP.S, which we have to manually update. */
1937 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
1939 if ((*insn
& 0xf8) != 0x60)
1945 if ((*insn
& 0xce) != 0x4a)
1947 disp
= ((disp
& 0x30) >> 3) | (disp
& 1);
1949 if (irel
->r_offset
+ disp
+ 2 >= addr
+count
)
1952 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
1954 *insn
= (*insn
& 0xf8) | disp
;
1958 *insn
= (*insn
& 0xce) | ((disp
& 6) << 3) | (disp
& 1);
1964 /* Adjust the local symbols defined in this section. */
1965 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
1966 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1968 isymend
= isym
+ symtab_hdr
->sh_info
;
1970 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1971 shndx_hdr
= & elf_tdata (abfd
)->symtab_shndx_hdr
;
1972 shndx_buf
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
1975 for (; isym
< isymend
; isym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
1977 /* If the symbol is in the range of memory we just moved, we
1978 have to adjust its value. */
1979 if ((int) isym
->st_shndx
== sec_shndx
1980 && isym
->st_value
> addr
1981 && isym
->st_value
< toaddr
)
1983 isym
->st_value
-= count
;
1985 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1986 *end* is in the moved bytes but it's *start* isn't), then we
1987 must adjust its size. */
1988 if ((int) isym
->st_shndx
== sec_shndx
1989 && isym
->st_value
< addr
1990 && isym
->st_value
+ isym
->st_size
> addr
1991 && isym
->st_value
+ isym
->st_size
< toaddr
)
1993 isym
->st_size
-= count
;
1997 /* Now adjust the global symbols defined in this section. */
1998 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1999 - symtab_hdr
->sh_info
);
2000 sym_hashes
= elf_sym_hashes (abfd
);
2001 // sym_hashes += symtab_hdr->sh_info;
2002 end_hashes
= sym_hashes
+ symcount
;
2004 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2006 struct elf_link_hash_entry
* sym_hash
= * sym_hashes
;
2009 (sym_hash
->root
.type
== bfd_link_hash_defined
2010 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2011 && sym_hash
->root
.u
.def
.section
== sec
)
2013 if (sym_hash
->root
.u
.def
.value
> addr
2014 && sym_hash
->root
.u
.def
.value
< toaddr
)
2016 sym_hash
->root
.u
.def
.value
-= count
;
2018 if (sym_hash
->root
.u
.def
.value
< addr
2019 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2020 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
2022 sym_hash
->size
-= count
;
2030 /* This is for versions of gcc prior to 4.3. */
2032 _bfd_m32c_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
2034 if ((elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
) == EF_M32C_CPU_M16C
)
2041 #define ELF_ARCH bfd_arch_m32c
2042 #define ELF_MACHINE_CODE EM_M32C
2043 #define ELF_MACHINE_ALT1 EM_M32C_OLD
2044 #define ELF_MAXPAGESIZE 0x100
2047 #define TARGET_BIG_SYM bfd_elf32_m32c_vec
2048 #define TARGET_BIG_NAME "elf32-m32c"
2050 #define TARGET_LITTLE_SYM bfd_elf32_m32c_vec
2051 #define TARGET_LITTLE_NAME "elf32-m32c"
2054 #define elf_info_to_howto_rel NULL
2055 #define elf_info_to_howto m32c_info_to_howto_rela
2056 #define elf_backend_object_p m32c_elf_object_p
2057 #define elf_backend_relocate_section m32c_elf_relocate_section
2058 #define elf_backend_check_relocs m32c_elf_check_relocs
2059 #define elf_backend_object_p m32c_elf_object_p
2060 #define elf_symbol_leading_char ('_')
2061 #define elf_backend_always_size_sections \
2062 m32c_elf_always_size_sections
2063 #define elf_backend_finish_dynamic_sections \
2064 m32c_elf_finish_dynamic_sections
2066 #define elf_backend_can_gc_sections 1
2067 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2069 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2070 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2071 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2072 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2073 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2074 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2076 #include "elf32-target.h"