1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005-2015 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #include "libiberty.h"
27 /* Forward declarations. */
28 static reloc_howto_type
* m32c_reloc_type_lookup
29 (bfd
*, bfd_reloc_code_real_type
);
30 static void m32c_info_to_howto_rela
31 (bfd
*, arelent
*, Elf_Internal_Rela
*);
32 static bfd_boolean m32c_elf_relocate_section
33 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*, Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
34 static bfd_boolean m32c_elf_check_relocs
35 (bfd
*, struct bfd_link_info
*, asection
*, const Elf_Internal_Rela
*);
36 static bfd_boolean
m32c_elf_relax_delete_bytes (bfd
*, asection
*, bfd_vma
, int);
38 char * m32c_get_reloc (long reloc
);
39 void dump_symtab (bfd
*, void *, void *);
41 static bfd_boolean m32c_elf_relax_section
42 (bfd
*abfd
, asection
*sec
, struct bfd_link_info
*link_info
, bfd_boolean
*again
);
43 static bfd_reloc_status_type m32c_apply_reloc_24
44 (bfd
*, arelent
*, asymbol
*, void *, asection
*, bfd
*, char **);
47 static reloc_howto_type m32c_elf_howto_table
[] =
49 /* This reloc does nothing. */
50 HOWTO (R_M32C_NONE
, /* type */
52 3, /* size (0 = byte, 1 = short, 2 = long) */
54 FALSE
, /* pc_relative */
56 complain_overflow_dont
, /* complain_on_overflow */
57 bfd_elf_generic_reloc
, /* special_function */
58 "R_M32C_NONE", /* name */
59 FALSE
, /* partial_inplace */
62 FALSE
), /* pcrel_offset */
64 /* GCC intentionally overflows these next two in order to work
65 around limitations in the addressing modes, so don't complain
67 HOWTO (R_M32C_16
, /* type */
69 1, /* size (0 = byte, 1 = short, 2 = long) */
71 FALSE
, /* pc_relative */
73 complain_overflow_dont
, /* complain_on_overflow */
74 bfd_elf_generic_reloc
, /* special_function */
75 "R_M32C_16", /* name */
76 FALSE
, /* partial_inplace */
78 0xffff, /* dst_mask */
79 FALSE
), /* pcrel_offset */
81 HOWTO (R_M32C_24
, /* type */
83 2, /* size (0 = byte, 1 = short, 2 = long) */
85 FALSE
, /* pc_relative */
87 complain_overflow_dont
, /* complain_on_overflow */
88 m32c_apply_reloc_24
, /* special_function */
89 "R_M32C_24", /* name */
90 FALSE
, /* partial_inplace */
92 0xffffff, /* dst_mask */
93 FALSE
), /* pcrel_offset */
95 HOWTO (R_M32C_32
, /* type */
97 2, /* size (0 = byte, 1 = short, 2 = long) */
99 FALSE
, /* pc_relative */
101 complain_overflow_bitfield
, /* complain_on_overflow */
102 bfd_elf_generic_reloc
, /* special_function */
103 "R_M32C_32", /* name */
104 FALSE
, /* partial_inplace */
106 0xffffffff, /* dst_mask */
107 FALSE
), /* pcrel_offset */
109 HOWTO (R_M32C_8_PCREL
, /* type */
111 0, /* size (0 = byte, 1 = short, 2 = long) */
113 TRUE
, /* pc_relative */
115 complain_overflow_signed
, /* complain_on_overflow */
116 bfd_elf_generic_reloc
, /* special_function */
117 "R_M32C_8_PCREL", /* name */
118 FALSE
, /* partial_inplace */
121 TRUE
), /* pcrel_offset */
123 HOWTO (R_M32C_16_PCREL
, /* type */
125 1, /* size (0 = byte, 1 = short, 2 = long) */
127 TRUE
, /* pc_relative */
129 complain_overflow_signed
, /* complain_on_overflow */
130 bfd_elf_generic_reloc
, /* special_function */
131 "R_M32C_16_PCREL", /* name */
132 FALSE
, /* partial_inplace */
134 0xffff, /* dst_mask */
135 TRUE
), /* pcrel_offset */
137 HOWTO (R_M32C_8
, /* type */
139 0, /* size (0 = byte, 1 = short, 2 = long) */
141 FALSE
, /* pc_relative */
143 complain_overflow_unsigned
, /* complain_on_overflow */
144 bfd_elf_generic_reloc
, /* special_function */
145 "R_M32C_8", /* name */
146 FALSE
, /* partial_inplace */
149 FALSE
), /* pcrel_offset */
151 HOWTO (R_M32C_LO16
, /* type */
153 1, /* size (0 = byte, 1 = short, 2 = long) */
155 FALSE
, /* pc_relative */
157 complain_overflow_dont
, /* complain_on_overflow */
158 bfd_elf_generic_reloc
, /* special_function */
159 "R_M32C_LO16", /* name */
160 FALSE
, /* partial_inplace */
162 0xffff, /* dst_mask */
163 FALSE
), /* pcrel_offset */
165 HOWTO (R_M32C_HI8
, /* type */
167 0, /* size (0 = byte, 1 = short, 2 = long) */
169 FALSE
, /* pc_relative */
171 complain_overflow_dont
, /* complain_on_overflow */
172 bfd_elf_generic_reloc
, /* special_function */
173 "R_M32C_HI8", /* name */
174 FALSE
, /* partial_inplace */
177 FALSE
), /* pcrel_offset */
179 HOWTO (R_M32C_HI16
, /* type */
181 1, /* size (0 = byte, 1 = short, 2 = long) */
183 FALSE
, /* pc_relative */
185 complain_overflow_dont
, /* complain_on_overflow */
186 bfd_elf_generic_reloc
, /* special_function */
187 "R_M32C_HI16", /* name */
188 FALSE
, /* partial_inplace */
190 0xffff, /* dst_mask */
191 FALSE
), /* pcrel_offset */
193 HOWTO (R_M32C_RL_JUMP
, /* type */
195 0, /* size (0 = byte, 1 = short, 2 = long) */
197 FALSE
, /* pc_relative */
199 complain_overflow_signed
, /* complain_on_overflow */
200 bfd_elf_generic_reloc
, /* special_function */
201 "R_M32C_RL_JUMP", /* name */
202 FALSE
, /* partial_inplace */
205 FALSE
), /* pcrel_offset */
207 HOWTO (R_M32C_RL_1ADDR
, /* type */
209 0, /* size (0 = byte, 1 = short, 2 = long) */
211 FALSE
, /* pc_relative */
213 complain_overflow_signed
, /* complain_on_overflow */
214 bfd_elf_generic_reloc
, /* special_function */
215 "R_M32C_RL_1ADDR", /* name */
216 FALSE
, /* partial_inplace */
219 FALSE
), /* pcrel_offset */
221 HOWTO (R_M32C_RL_2ADDR
, /* type */
223 0, /* size (0 = byte, 1 = short, 2 = long) */
225 FALSE
, /* pc_relative */
227 complain_overflow_signed
, /* complain_on_overflow */
228 bfd_elf_generic_reloc
, /* special_function */
229 "R_M32C_RL_2ADDR", /* name */
230 FALSE
, /* partial_inplace */
233 FALSE
), /* pcrel_offset */
237 /* Map BFD reloc types to M32C ELF reloc types. */
239 struct m32c_reloc_map
241 bfd_reloc_code_real_type bfd_reloc_val
;
242 unsigned int m32c_reloc_val
;
245 static const struct m32c_reloc_map m32c_reloc_map
[] =
247 { BFD_RELOC_NONE
, R_M32C_NONE
},
248 { BFD_RELOC_16
, R_M32C_16
},
249 { BFD_RELOC_24
, R_M32C_24
},
250 { BFD_RELOC_32
, R_M32C_32
},
251 { BFD_RELOC_8_PCREL
, R_M32C_8_PCREL
},
252 { BFD_RELOC_16_PCREL
, R_M32C_16_PCREL
},
253 { BFD_RELOC_8
, R_M32C_8
},
254 { BFD_RELOC_LO16
, R_M32C_LO16
},
255 { BFD_RELOC_HI16
, R_M32C_HI16
},
256 { BFD_RELOC_M32C_HI8
, R_M32C_HI8
},
257 { BFD_RELOC_M32C_RL_JUMP
, R_M32C_RL_JUMP
},
258 { BFD_RELOC_M32C_RL_1ADDR
, R_M32C_RL_1ADDR
},
259 { BFD_RELOC_M32C_RL_2ADDR
, R_M32C_RL_2ADDR
}
262 static reloc_howto_type
*
263 m32c_reloc_type_lookup
264 (bfd
* abfd ATTRIBUTE_UNUSED
,
265 bfd_reloc_code_real_type code
)
269 for (i
= ARRAY_SIZE (m32c_reloc_map
); i
--;)
270 if (m32c_reloc_map
[i
].bfd_reloc_val
== code
)
271 return & m32c_elf_howto_table
[m32c_reloc_map
[i
].m32c_reloc_val
];
276 static reloc_howto_type
*
277 m32c_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, const char *r_name
)
282 i
< sizeof (m32c_elf_howto_table
) / sizeof (m32c_elf_howto_table
[0]);
284 if (m32c_elf_howto_table
[i
].name
!= NULL
285 && strcasecmp (m32c_elf_howto_table
[i
].name
, r_name
) == 0)
286 return &m32c_elf_howto_table
[i
];
291 /* Set the howto pointer for an M32C ELF reloc. */
294 m32c_info_to_howto_rela
295 (bfd
* abfd ATTRIBUTE_UNUSED
,
297 Elf_Internal_Rela
* dst
)
301 r_type
= ELF32_R_TYPE (dst
->r_info
);
302 if (r_type
>= (unsigned int) R_M32C_max
)
304 _bfd_error_handler (_("%B: invalid M32C reloc number: %d"), abfd
, r_type
);
307 cache_ptr
->howto
= & m32c_elf_howto_table
[r_type
];
312 /* Apply R_M32C_24 relocations. We have to do this because it's not a
313 power-of-two size, and the generic code may think it overruns the
314 section if it's right at the end.
316 Must return something other than bfd_reloc_continue to avoid the
317 above problem. Typical return values include bfd_reloc_ok or
321 static bfd_reloc_status_type
m32c_apply_reloc_24 (bfd
*abfd ATTRIBUTE_UNUSED
,
322 arelent
*reloc_entry
,
324 void *vdata_start ATTRIBUTE_UNUSED
,
325 asection
*input_section
,
326 bfd
*ibfd ATTRIBUTE_UNUSED
,
327 char **error_msg ATTRIBUTE_UNUSED
)
330 bfd_reloc_status_type s
;
332 s
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
,
334 input_section
, ibfd
, error_msg
);
335 if (s
!= bfd_reloc_continue
)
338 /* Get symbol value. (Common symbols are special.) */
339 if (bfd_is_com_section (symbol
->section
))
342 relocation
= symbol
->value
;
344 relocation
+= symbol
->section
->output_offset
;
346 /* Add in supplied addend. */
347 relocation
+= reloc_entry
->addend
;
349 reloc_entry
->addend
= relocation
;
350 reloc_entry
->address
+= input_section
->output_offset
;
354 /* Relocate an M32C ELF section.
355 There is some attempt to make this function usable for many architectures,
356 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
357 if only to serve as a learning tool.
359 The RELOCATE_SECTION function is called by the new ELF backend linker
360 to handle the relocations for a section.
362 The relocs are always passed as Rela structures; if the section
363 actually uses Rel structures, the r_addend field will always be
366 This function is responsible for adjusting the section contents as
367 necessary, and (if using Rela relocs and generating a relocatable
368 output file) adjusting the reloc addend as necessary.
370 This function does not have to worry about setting the reloc
371 address or the reloc symbol index.
373 LOCAL_SYMS is a pointer to the swapped in local symbols.
375 LOCAL_SECTIONS is an array giving the section in the input file
376 corresponding to the st_shndx field of each local symbol.
378 The global hash table entry for the global symbols can be found
379 via elf_sym_hashes (input_bfd).
381 When generating relocatable output, this function must handle
382 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
383 going to be the section symbol corresponding to the output
384 section, which means that the addend must be adjusted
388 m32c_elf_relocate_section
389 (bfd
* output_bfd ATTRIBUTE_UNUSED
,
390 struct bfd_link_info
* info
,
392 asection
* input_section
,
394 Elf_Internal_Rela
* relocs
,
395 Elf_Internal_Sym
* local_syms
,
396 asection
** local_sections
)
398 Elf_Internal_Shdr
* symtab_hdr
;
399 struct elf_link_hash_entry
** sym_hashes
;
400 Elf_Internal_Rela
* rel
;
401 Elf_Internal_Rela
* relend
;
405 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
406 sym_hashes
= elf_sym_hashes (input_bfd
);
407 relend
= relocs
+ input_section
->reloc_count
;
409 dynobj
= elf_hash_table (info
)->dynobj
;
412 splt
= bfd_get_linker_section (dynobj
, ".plt");
414 for (rel
= relocs
; rel
< relend
; rel
++)
416 reloc_howto_type
* howto
;
417 unsigned long r_symndx
;
418 Elf_Internal_Sym
* sym
;
420 struct elf_link_hash_entry
* h
;
422 bfd_reloc_status_type r
;
423 const char * name
= NULL
;
426 r_type
= ELF32_R_TYPE (rel
->r_info
);
428 /* These are only used for relaxing; we don't actually relocate
429 anything with them, so skip them. */
430 if (r_type
== R_M32C_RL_JUMP
431 || r_type
== R_M32C_RL_1ADDR
432 || r_type
== R_M32C_RL_2ADDR
)
435 r_symndx
= ELF32_R_SYM (rel
->r_info
);
437 howto
= m32c_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
443 if (r_symndx
< symtab_hdr
->sh_info
)
445 sym
= local_syms
+ r_symndx
;
446 sec
= local_sections
[r_symndx
];
447 relocation
= (sec
->output_section
->vma
451 name
= bfd_elf_string_from_elf_section
452 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
453 name
= (sym
->st_name
== 0) ? bfd_section_name (input_bfd
, sec
) : name
;
457 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
459 if (info
->wrap_hash
!= NULL
460 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
461 h
= ((struct elf_link_hash_entry
*)
462 unwrap_hash_lookup (info
, input_bfd
, &h
->root
));
464 while (h
->root
.type
== bfd_link_hash_indirect
465 || h
->root
.type
== bfd_link_hash_warning
)
466 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
468 name
= h
->root
.root
.string
;
470 if (h
->root
.type
== bfd_link_hash_defined
471 || h
->root
.type
== bfd_link_hash_defweak
)
473 sec
= h
->root
.u
.def
.section
;
474 relocation
= (h
->root
.u
.def
.value
475 + sec
->output_section
->vma
476 + sec
->output_offset
);
478 else if (h
->root
.type
== bfd_link_hash_undefweak
)
480 else if (!info
->relocatable
)
482 if (! ((*info
->callbacks
->undefined_symbol
)
483 (info
, h
->root
.root
.string
, input_bfd
,
484 input_section
, rel
->r_offset
, TRUE
)))
489 if (sec
!= NULL
&& discarded_section (sec
))
490 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
491 rel
, 1, relend
, howto
, 0, contents
);
493 if (info
->relocatable
)
495 /* This is a relocatable link. We don't have to change
496 anything, unless the reloc is against a section symbol,
497 in which case we have to adjust according to where the
498 section symbol winds up in the output section. */
499 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
500 rel
->r_addend
+= sec
->output_offset
;
504 switch (ELF32_R_TYPE (rel
->r_info
))
511 plt_offset
= &h
->plt
.offset
;
513 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
515 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
516 relocation, *plt_offset);*/
517 if (relocation
<= 0xffff)
519 /* If the symbol is in range for a 16-bit address, we should
520 have deallocated the plt entry in relax_section. */
521 BFD_ASSERT (*plt_offset
== (bfd_vma
) -1);
525 /* If the symbol is out of range for a 16-bit address,
526 we must have allocated a plt entry. */
527 BFD_ASSERT (*plt_offset
!= (bfd_vma
) -1);
529 /* If this is the first time we've processed this symbol,
530 fill in the plt entry with the correct symbol address. */
531 if ((*plt_offset
& 1) == 0)
535 x
= 0x000000fc; /* jmpf */
536 x
|= (relocation
<< 8) & 0xffffff00;
537 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
541 relocation
= (splt
->output_section
->vma
542 + splt
->output_offset
543 + (*plt_offset
& -2));
546 char *newname
= bfd_malloc (strlen(name
)+5);
547 strcpy (newname
, name
);
548 strcat(newname
, ".plt");
549 _bfd_generic_link_add_one_symbol (info
,
552 BSF_FUNCTION
| BSF_WEAK
,
571 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
572 m32c_elf_howto_table
[ELF32_R_TYPE(rel
->r_info
)].name
,
573 rel
->r_offset
+ input_section
->output_section
->vma
+ input_section
->output_offset
,
574 relocation
, rel
->r_addend
);
578 printf (" %02x", contents
[rel
->r_offset
+i
]);
582 switch (ELF32_R_TYPE(rel
->r_info
))
585 /* Like m32c_apply_reloc_24, we must handle this one separately. */
586 relocation
+= rel
->r_addend
;
588 /* Sanity check the address. */
589 if (rel
->r_offset
+ 3
590 > bfd_get_section_limit_octets (input_bfd
, input_section
))
591 r
= bfd_reloc_outofrange
;
594 bfd_put_8 (input_bfd
, relocation
& 0xff, contents
+ rel
->r_offset
);
595 bfd_put_8 (input_bfd
, (relocation
>> 8) & 0xff, contents
+ rel
->r_offset
+ 1);
596 bfd_put_8 (input_bfd
, (relocation
>> 16) & 0xff, contents
+ rel
->r_offset
+ 2);
603 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
604 contents
, rel
->r_offset
, relocation
,
609 if (r
!= bfd_reloc_ok
)
611 const char * msg
= (const char *) NULL
;
615 case bfd_reloc_overflow
:
616 r
= info
->callbacks
->reloc_overflow
617 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
618 input_bfd
, input_section
, rel
->r_offset
);
621 case bfd_reloc_undefined
:
622 r
= info
->callbacks
->undefined_symbol
623 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
627 case bfd_reloc_outofrange
:
628 msg
= _("internal error: out of range error");
631 case bfd_reloc_notsupported
:
632 msg
= _("internal error: unsupported relocation error");
635 case bfd_reloc_dangerous
:
636 msg
= _("internal error: dangerous relocation");
640 msg
= _("internal error: unknown error");
645 r
= info
->callbacks
->warning
646 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
656 /* We support 16-bit pointers to code above 64k by generating a thunk
657 below 64k containing a JMP instruction to the final address. */
660 m32c_elf_check_relocs
662 struct bfd_link_info
* info
,
664 const Elf_Internal_Rela
* relocs
)
666 Elf_Internal_Shdr
* symtab_hdr
;
667 struct elf_link_hash_entry
** sym_hashes
;
668 const Elf_Internal_Rela
* rel
;
669 const Elf_Internal_Rela
* rel_end
;
670 bfd_vma
*local_plt_offsets
;
674 if (info
->relocatable
)
677 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
678 sym_hashes
= elf_sym_hashes (abfd
);
679 local_plt_offsets
= elf_local_got_offsets (abfd
);
681 dynobj
= elf_hash_table(info
)->dynobj
;
683 rel_end
= relocs
+ sec
->reloc_count
;
684 for (rel
= relocs
; rel
< rel_end
; rel
++)
686 struct elf_link_hash_entry
*h
;
687 unsigned long r_symndx
;
690 r_symndx
= ELF32_R_SYM (rel
->r_info
);
691 if (r_symndx
< symtab_hdr
->sh_info
)
695 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
696 while (h
->root
.type
== bfd_link_hash_indirect
697 || h
->root
.type
== bfd_link_hash_warning
)
698 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
700 /* PR15323, ref flags aren't set for references in the same
702 h
->root
.non_ir_ref
= 1;
705 switch (ELF32_R_TYPE (rel
->r_info
))
707 /* This relocation describes a 16-bit pointer to a function.
708 We may need to allocate a thunk in low memory; reserve memory
712 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
715 splt
= bfd_get_linker_section (dynobj
, ".plt");
718 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
719 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
720 | SEC_READONLY
| SEC_CODE
);
721 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
724 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
730 offset
= &h
->plt
.offset
;
733 if (local_plt_offsets
== NULL
)
738 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
739 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
740 if (local_plt_offsets
== NULL
)
742 elf_local_got_offsets (abfd
) = local_plt_offsets
;
744 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
745 local_plt_offsets
[i
] = (bfd_vma
) -1;
747 offset
= &local_plt_offsets
[r_symndx
];
750 if (*offset
== (bfd_vma
) -1)
752 *offset
= splt
->size
;
762 /* This must exist if dynobj is ever set. */
765 m32c_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
766 struct bfd_link_info
*info
)
771 /* As an extra sanity check, verify that all plt entries have
774 if ((dynobj
= elf_hash_table (info
)->dynobj
) != NULL
775 && (splt
= bfd_get_linker_section (dynobj
, ".plt")) != NULL
)
777 bfd_byte
*contents
= splt
->contents
;
778 unsigned int i
, size
= splt
->size
;
779 for (i
= 0; i
< size
; i
+= 4)
781 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
790 m32c_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
791 struct bfd_link_info
*info
)
796 if (info
->relocatable
)
799 dynobj
= elf_hash_table (info
)->dynobj
;
803 splt
= bfd_get_linker_section (dynobj
, ".plt");
804 BFD_ASSERT (splt
!= NULL
);
806 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
807 if (splt
->contents
== NULL
)
813 /* Function to set the ELF flag bits. */
816 m32c_elf_set_private_flags (bfd
*abfd
, flagword flags
)
818 elf_elfheader (abfd
)->e_flags
= flags
;
819 elf_flags_init (abfd
) = TRUE
;
823 /* Merge backend specific data from an object file to the output
824 object file when linking. */
827 m32c_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
829 flagword old_flags
, old_partial
;
830 flagword new_flags
, new_partial
;
831 bfd_boolean error
= FALSE
;
835 new_opt
[0] = old_opt
[0] = '\0';
836 new_flags
= elf_elfheader (ibfd
)->e_flags
;
837 old_flags
= elf_elfheader (obfd
)->e_flags
;
840 (*_bfd_error_handler
) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
841 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
842 bfd_get_filename (ibfd
));
845 if (!elf_flags_init (obfd
))
847 /* First call, no flags set. */
848 elf_flags_init (obfd
) = TRUE
;
849 elf_elfheader (obfd
)->e_flags
= new_flags
;
852 else if (new_flags
== old_flags
)
853 /* Compatible flags are ok. */
856 else /* Possibly incompatible flags. */
858 /* Warn if different cpu is used (allow a specific cpu to override
860 new_partial
= (new_flags
& EF_M32C_CPU_MASK
);
861 old_partial
= (old_flags
& EF_M32C_CPU_MASK
);
862 if (new_partial
== old_partial
)
869 default: strcat (new_opt
, " -m16c"); break;
870 case EF_M32C_CPU_M16C
: strcat (new_opt
, " -m16c"); break;
871 case EF_M32C_CPU_M32C
: strcat (new_opt
, " -m32c"); break;
876 default: strcat (old_opt
, " -m16c"); break;
877 case EF_M32C_CPU_M16C
: strcat (old_opt
, " -m16c"); break;
878 case EF_M32C_CPU_M32C
: strcat (old_opt
, " -m32c"); break;
882 /* Print out any mismatches from above. */
886 (*_bfd_error_handler
)
887 (_("%s: compiled with %s and linked with modules compiled with %s"),
888 bfd_get_filename (ibfd
), new_opt
, old_opt
);
891 new_flags
&= ~ EF_M32C_ALL_FLAGS
;
892 old_flags
&= ~ EF_M32C_ALL_FLAGS
;
894 /* Warn about any other mismatches. */
895 if (new_flags
!= old_flags
)
898 (*_bfd_error_handler
)
899 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
900 bfd_get_filename (ibfd
), (long)new_flags
, (long)old_flags
);
905 bfd_set_error (bfd_error_bad_value
);
912 m32c_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
914 FILE *file
= (FILE *) ptr
;
917 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
919 /* Print normal ELF private data. */
920 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
922 flags
= elf_elfheader (abfd
)->e_flags
;
923 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
925 switch (flags
& EF_M32C_CPU_MASK
)
928 case EF_M32C_CPU_M16C
: fprintf (file
, " -m16c"); break;
929 case EF_M32C_CPU_M32C
: fprintf (file
, " -m32c"); break;
936 /* Return the MACH for an e_flags value. */
939 elf32_m32c_machine (bfd
*abfd
)
941 switch (elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
)
943 case EF_M32C_CPU_M16C
: return bfd_mach_m16c
;
944 case EF_M32C_CPU_M32C
: return bfd_mach_m32c
;
947 return bfd_mach_m16c
;
951 m32c_elf_object_p (bfd
*abfd
)
953 bfd_default_set_arch_mach (abfd
, bfd_arch_m32c
,
954 elf32_m32c_machine (abfd
));
961 dump_symtab (bfd
* abfd
, void *internal_syms
, void *external_syms
)
964 Elf_Internal_Sym
*isymbuf
;
965 Elf_Internal_Sym
*isymend
;
966 Elf_Internal_Sym
*isym
;
967 Elf_Internal_Shdr
*symtab_hdr
;
968 bfd_boolean free_internal
= 0, free_external
= 0;
970 char * st_info_stb_str
;
976 internal_syms
= bfd_malloc (1000);
981 external_syms
= bfd_malloc (1000);
985 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
986 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data(abfd
)->s
->sizeof_sym
;
988 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
989 symtab_hdr
->sh_info
, 0,
990 internal_syms
, external_syms
, NULL
);
992 isymbuf
= internal_syms
;
993 isymend
= isymbuf
+ locsymcount
;
995 for (isym
= isymbuf
; isym
< isymend
; isym
++)
997 switch (ELF_ST_TYPE (isym
->st_info
))
1000 st_info_str
= "STT_FUNC";
1004 st_info_str
= "STT_SECTION";
1008 st_info_str
= "STT_FILE";
1012 st_info_str
= "STT_OBJECT";
1016 st_info_str
= "STT_TLS";
1023 switch (ELF_ST_BIND (isym
->st_info
))
1026 st_info_stb_str
= "STB_LOCAL";
1030 st_info_stb_str
= "STB_GLOBAL";
1034 st_info_stb_str
= "";
1037 switch (ELF_ST_VISIBILITY (isym
->st_other
))
1040 st_other_str
= "STV_DEFAULT";
1044 st_other_str
= "STV_INTERNAL";
1048 st_other_str
= "STV_PROTECTED";
1055 switch (isym
->st_shndx
)
1058 st_shndx_str
= "SHN_ABS";
1062 st_shndx_str
= "SHN_COMMON";
1066 st_shndx_str
= "SHN_UNDEF";
1073 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1074 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1076 (unsigned long) isym
->st_value
,
1077 (unsigned long) isym
->st_size
,
1079 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
1081 isym
->st_info
, st_info_str
, st_info_stb_str
,
1082 isym
->st_other
, st_other_str
,
1083 isym
->st_shndx
, st_shndx_str
);
1086 free (internal_syms
);
1088 free (external_syms
);
1092 m32c_get_reloc (long reloc
)
1094 if (0 <= reloc
&& reloc
< R_M32C_max
)
1095 return m32c_elf_howto_table
[reloc
].name
;
1101 /* Handle relaxing. */
1103 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1104 is within the low 64k, remove any entry for it in the plt. */
1106 struct relax_plt_data
1113 m32c_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1115 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1117 if (h
->plt
.offset
!= (bfd_vma
) -1)
1121 if (h
->root
.type
== bfd_link_hash_undefined
1122 || h
->root
.type
== bfd_link_hash_undefweak
)
1125 address
= (h
->root
.u
.def
.section
->output_section
->vma
1126 + h
->root
.u
.def
.section
->output_offset
1127 + h
->root
.u
.def
.value
);
1129 if (address
<= 0xffff)
1132 data
->splt
->size
-= 4;
1133 *data
->again
= TRUE
;
1140 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1141 previously had a plt entry, give it a new entry offset. */
1144 m32c_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1146 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1148 if (h
->plt
.offset
!= (bfd_vma
) -1)
1150 h
->plt
.offset
= *entry
;
1158 m32c_elf_relax_plt_section (asection
*splt
,
1159 struct bfd_link_info
*info
,
1162 struct relax_plt_data relax_plt_data
;
1165 /* Assume nothing changes. */
1168 if (info
->relocatable
)
1171 /* Quick check for an empty plt. */
1172 if (splt
->size
== 0)
1175 /* Map across all global symbols; see which ones happen to
1176 fall in the low 64k. */
1177 relax_plt_data
.splt
= splt
;
1178 relax_plt_data
.again
= again
;
1179 elf_link_hash_traverse (elf_hash_table (info
), m32c_relax_plt_check
,
1182 /* Likewise for local symbols, though that's somewhat less convenient
1183 as we have to walk the list of input bfds and swap in symbol data. */
1184 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1186 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1187 Elf_Internal_Shdr
*symtab_hdr
;
1188 Elf_Internal_Sym
*isymbuf
= NULL
;
1191 if (! local_plt_offsets
)
1194 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1195 if (symtab_hdr
->sh_info
!= 0)
1197 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1198 if (isymbuf
== NULL
)
1199 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1200 symtab_hdr
->sh_info
, 0,
1202 if (isymbuf
== NULL
)
1206 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1208 Elf_Internal_Sym
*isym
;
1212 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1215 isym
= &isymbuf
[idx
];
1216 if (isym
->st_shndx
== SHN_UNDEF
)
1218 else if (isym
->st_shndx
== SHN_ABS
)
1219 tsec
= bfd_abs_section_ptr
;
1220 else if (isym
->st_shndx
== SHN_COMMON
)
1221 tsec
= bfd_com_section_ptr
;
1223 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1225 address
= (tsec
->output_section
->vma
1226 + tsec
->output_offset
1228 if (address
<= 0xffff)
1230 local_plt_offsets
[idx
] = -1;
1237 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1239 if (! info
->keep_memory
)
1243 /* Cache the symbols for elf_link_input_bfd. */
1244 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1249 /* If we changed anything, walk the symbols again to reallocate
1250 .plt entry addresses. */
1251 if (*again
&& splt
->size
> 0)
1255 elf_link_hash_traverse (elf_hash_table (info
),
1256 m32c_relax_plt_realloc
, &entry
);
1258 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1260 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1261 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1264 if (! local_plt_offsets
)
1267 for (idx
= 0; idx
< nlocals
; ++idx
)
1268 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1270 local_plt_offsets
[idx
] = entry
;
1280 compare_reloc (const void *e1
, const void *e2
)
1282 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
1283 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
1285 if (i1
->r_offset
== i2
->r_offset
)
1288 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
1291 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1293 m32c_offset_for_reloc (bfd
*abfd
,
1294 Elf_Internal_Rela
*rel
,
1295 Elf_Internal_Shdr
*symtab_hdr
,
1296 Elf_External_Sym_Shndx
*shndx_buf ATTRIBUTE_UNUSED
,
1297 Elf_Internal_Sym
*intsyms
)
1301 /* Get the value of the symbol referred to by the reloc. */
1302 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1304 /* A local symbol. */
1305 Elf_Internal_Sym
*isym
;
1308 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1309 ssec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1310 symval
= isym
->st_value
;
1312 symval
+= ssec
->output_section
->vma
1313 + ssec
->output_offset
;
1318 struct elf_link_hash_entry
*h
;
1320 /* An external symbol. */
1321 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1322 h
= elf_sym_hashes (abfd
)[indx
];
1323 BFD_ASSERT (h
!= NULL
);
1325 if (h
->root
.type
!= bfd_link_hash_defined
1326 && h
->root
.type
!= bfd_link_hash_defweak
)
1327 /* This appears to be a reference to an undefined
1328 symbol. Just ignore it--it will be caught by the
1329 regular reloc processing. */
1332 symval
= (h
->root
.u
.def
.value
1333 + h
->root
.u
.def
.section
->output_section
->vma
1334 + h
->root
.u
.def
.section
->output_offset
);
1339 static int bytes_saved
= 0;
1341 static int bytes_to_reloc
[] = {
1349 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1351 /* Mask for the number of relocs associated with this insn. */
1352 #define RLA_RELOCS 0x0000000f
1353 /* Number of bytes gas emitted (before gas's relaxing) */
1354 #define RLA_NBYTES 0x00000ff0
1356 /* If the displacement is within the given range and the new encoding
1357 differs from the old encoding (the index), then the insn can be
1358 relaxed to the new encoding. */
1361 unsigned int max_disp
;
1362 unsigned char new_encoding
;
1365 static EncodingTable m16c_addr_encodings
[] = {
1366 { 0, 0, 0 }, /* R0 */
1367 { 0, 0, 1 }, /* R1 */
1368 { 0, 0, 2 }, /* R2 */
1369 { 0, 0, 3 }, /* R3 */
1370 { 0, 0, 4 }, /* A0 */
1371 { 0, 0, 5 }, /* A1 */
1372 { 0, 0, 6 }, /* [A0] */
1373 { 0, 0, 7 }, /* [A1] */
1374 { 1, 0, 6 }, /* udsp:8[A0] */
1375 { 1, 0, 7 }, /* udsp:8[A1] */
1376 { 1, 0, 10 }, /* udsp:8[SB] */
1377 { 1, 0, 11 }, /* sdsp:8[FB] */
1378 { 2, 255, 8 }, /* udsp:16[A0] */
1379 { 2, 255, 9 }, /* udsp:16[A1] */
1380 { 2, 255, 10 }, /* udsp:16[SB] */
1381 { 2, 0, 15 }, /* abs:16 */
1384 static EncodingTable m16c_jmpaddr_encodings
[] = {
1385 { 0, 0, 0 }, /* R0 */
1386 { 0, 0, 1 }, /* R1 */
1387 { 0, 0, 2 }, /* R2 */
1388 { 0, 0, 3 }, /* R3 */
1389 { 0, 0, 4 }, /* A0 */
1390 { 0, 0, 5 }, /* A1 */
1391 { 0, 0, 6 }, /* [A0] */
1392 { 0, 0, 7 }, /* [A1] */
1393 { 1, 0, 6 }, /* udsp:8[A0] */
1394 { 1, 0, 7 }, /* udsp:8[A1] */
1395 { 1, 0, 10 }, /* udsp:8[SB] */
1396 { 1, 0, 11 }, /* sdsp:8[FB] */
1397 { 3, 255, 8 }, /* udsp:20[A0] */
1398 { 3, 255, 9 }, /* udsp:20[A1] */
1399 { 2, 255, 10 }, /* udsp:16[SB] */
1400 { 2, 0, 15 }, /* abs:16 */
1403 static EncodingTable m32c_addr_encodings
[] = {
1404 { 0, 0, 0 }, /* [A0] */
1405 { 0, 0, 1 }, /* [A1] */
1406 { 0, 0, 2 }, /* A0 */
1407 { 0, 0, 3 }, /* A1 */
1408 { 1, 0, 0 }, /* udsp:8[A0] */
1409 { 1, 0, 1 }, /* udsp:8[A1] */
1410 { 1, 0, 6 }, /* udsp:8[SB] */
1411 { 1, 0, 7 }, /* sdsp:8[FB] */
1412 { 2, 255, 4 }, /* udsp:16[A0] */
1413 { 2, 255, 5 }, /* udsp:16[A1] */
1414 { 2, 255, 6 }, /* udsp:16[SB] */
1415 { 2, 127, 7 }, /* sdsp:16[FB] */
1416 { 3, 65535, 8 }, /* udsp:24[A0] */
1417 { 3, 65535, 9 }, /* udsp:24[A1] */
1418 { 3, 65535, 15 }, /* abs24 */
1419 { 2, 0, 15 }, /* abs16 */
1420 { 0, 0, 16 }, /* R2 */
1421 { 0, 0, 17 }, /* R3 */
1422 { 0, 0, 18 }, /* R0 */
1423 { 0, 0, 19 }, /* R1 */
1439 m32c_elf_relax_section
1442 struct bfd_link_info
* link_info
,
1443 bfd_boolean
* again
)
1445 Elf_Internal_Shdr
*symtab_hdr
;
1446 Elf_Internal_Shdr
*shndx_hdr
;
1447 Elf_Internal_Rela
*internal_relocs
;
1448 Elf_Internal_Rela
*free_relocs
= NULL
;
1449 Elf_Internal_Rela
*irel
, *irelend
, *srel
;
1450 bfd_byte
* contents
= NULL
;
1451 bfd_byte
* free_contents
= NULL
;
1452 Elf_Internal_Sym
*intsyms
= NULL
;
1453 Elf_Internal_Sym
*free_intsyms
= NULL
;
1454 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1457 if (abfd
== elf_hash_table (link_info
)->dynobj
1458 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1459 && strcmp (sec
->name
, ".plt") == 0)
1460 return m32c_elf_relax_plt_section (sec
, link_info
, again
);
1462 /* Assume nothing changes. */
1465 machine
= elf32_m32c_machine (abfd
);
1467 /* We don't have to do anything for a relocatable link, if
1468 this section does not have relocs, or if this is not a
1470 if (link_info
->relocatable
1471 || (sec
->flags
& SEC_RELOC
) == 0
1472 || sec
->reloc_count
== 0
1473 || (sec
->flags
& SEC_CODE
) == 0)
1476 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1477 shndx_hdr
= &elf_tdata (abfd
)->symtab_shndx_hdr
;
1479 /* Get the section contents. */
1480 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1481 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1482 /* Go get them off disk. */
1483 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1486 /* Read this BFD's symbols. */
1487 /* Get cached copy if it exists. */
1488 if (symtab_hdr
->contents
!= NULL
)
1490 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1494 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
1495 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1498 if (shndx_hdr
->sh_size
!= 0)
1502 amt
= symtab_hdr
->sh_info
;
1503 amt
*= sizeof (Elf_External_Sym_Shndx
);
1504 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1505 if (shndx_buf
== NULL
)
1507 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1508 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
1510 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1513 /* Get a copy of the native relocations. */
1514 internal_relocs
= (_bfd_elf_link_read_relocs
1515 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
1516 link_info
->keep_memory
));
1517 if (internal_relocs
== NULL
)
1519 if (! link_info
->keep_memory
)
1520 free_relocs
= internal_relocs
;
1522 /* The RL_ relocs must be just before the operand relocs they go
1523 with, so we must sort them to guarantee this. */
1524 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
1527 /* Walk through them looking for relaxing opportunities. */
1528 irelend
= internal_relocs
+ sec
->reloc_count
;
1530 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1533 unsigned char *insn
, *gap
, *einsn
;
1535 bfd_signed_vma pcrel
;
1541 EncodingTable
*enctbl
;
1544 if (ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_JUMP
1545 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_1ADDR
1546 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_2ADDR
)
1551 /* There will always be room for the relaxed insn, since it is smaller
1552 than the one it would replace. */
1553 BFD_ASSERT (irel
->r_offset
< sec
->size
);
1555 insn
= contents
+ irel
->r_offset
;
1556 relax_relocs
= irel
->r_addend
% 16;
1558 /* Ok, we only have three relocs we care about, and they're all
1559 fake. The lower four bits of the addend is always the number
1560 of following relocs (hence the qsort above) that are assigned
1561 to this opcode. The next 8 bits of the addend indicates the
1562 number of bytes in the insn. We use the rest of them
1563 ourselves as flags for the more expensive operations (defines
1564 above). The three relocs are:
1566 RL_JUMP: This marks all direct jump insns. We check the
1567 displacement and replace them with shorter jumps if
1568 they're in range. We also use this to find JMP.S
1569 insns and manually shorten them when we delete bytes.
1570 We have to decode these insns to figure out what to
1573 RL_1ADDR: This is a :G or :Q insn, which has a single
1574 "standard" operand. We have to extract the type
1575 field, see if it's a wide displacement, then figure
1576 out if we can replace it with a narrow displacement.
1577 We don't have to decode these insns.
1579 RL_2ADDR: Similarly, but two "standard" operands. Note that
1580 r_addend may still be 1, as standard operands don't
1581 always have displacements. Gas shouldn't give us one
1582 with zero operands, but since we don't know which one
1583 has the displacement, we check them both anyway.
1585 These all point to the beginning of the insn itself, not the
1588 Note that we only relax one step at a time, relying on the
1589 linker to call us repeatedly. Thus, there is no code for
1590 JMP.A->JMP.B although that will happen in two steps.
1591 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1594 /* Get the value of the symbol referred to by the reloc. Just
1595 in case this is the last reloc in the list, use the RL's
1596 addend to choose between this reloc (no addend) or the next
1597 (yes addend, which means at least one following reloc). */
1598 srel
= irel
+ (relax_relocs
? 1 : 0);
1599 symval
= OFFSET_FOR_RELOC (srel
);
1601 /* Setting gap_size nonzero is the flag which means "something
1605 new_type
= ELF32_R_TYPE(srel
->r_info
);
1607 pc
= sec
->output_section
->vma
+ sec
->output_offset
1609 pcrel
= symval
- pc
+ srel
->r_addend
;
1611 if (machine
== bfd_mach_m16c
)
1615 switch (ELF32_R_TYPE(irel
->r_info
))
1618 case R_M32C_RL_JUMP
:
1621 case 0xfe: /* jmp.b */
1622 if (pcrel
>= 2 && pcrel
<= 9)
1624 /* Relax JMP.B -> JMP.S. We need to get rid of
1625 the following reloc though. */
1626 insn
[0] = 0x60 | (pcrel
- 2);
1627 new_type
= R_M32C_NONE
;
1628 irel
->r_addend
= 0x10;
1634 case 0xf4: /* jmp.w */
1635 /* 128 is allowed because it will be one byte closer
1636 after relaxing. Likewise for all other pc-rel
1638 if (pcrel
<= 128 && pcrel
>= -128)
1640 /* Relax JMP.W -> JMP.B */
1643 new_type
= R_M32C_8_PCREL
;
1649 case 0xfc: /* jmp.a */
1650 if (pcrel
<= 32768 && pcrel
>= -32768)
1652 /* Relax JMP.A -> JMP.W */
1656 new_type
= R_M32C_16_PCREL
;
1662 case 0xfd: /* jsr.a */
1663 if (pcrel
<= 32768 && pcrel
>= -32768)
1665 /* Relax JSR.A -> JSR.W */
1669 new_type
= R_M32C_16_PCREL
;
1677 case R_M32C_RL_2ADDR
:
1678 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1680 enctbl
= m16c_addr_encodings
;
1682 enc
= (insn
[1] >> 4) & 0x0f;
1685 if (srel
->r_offset
== irel
->r_offset
+ posn
1686 && e
->new_encoding
!= enc
1687 && symval
<= e
->max_disp
)
1690 insn
[1] |= e
->new_encoding
<< 4;
1691 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1692 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1693 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1696 if (relax_relocs
== 2)
1702 case R_M32C_RL_1ADDR
:
1703 /* xxxx xxxx xxxx dest [disp] */
1705 enctbl
= m16c_addr_encodings
;
1708 /* Check the opcode for jumps. We know it's safe to
1709 do this because all 2ADDR insns are at least two
1711 enc
= insn
[0] * 256 + insn
[1];
1718 enctbl
= m16c_jmpaddr_encodings
;
1722 /* srel, posn, and enc must be set here. */
1724 symval
= OFFSET_FOR_RELOC (srel
);
1725 enc
= insn
[1] & 0x0f;
1728 if (srel
->r_offset
== irel
->r_offset
+ posn
1729 && e
->new_encoding
!= enc
1730 && symval
<= e
->max_disp
)
1733 insn
[1] |= e
->new_encoding
;
1734 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1735 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1736 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1742 } /* Ends switch (reloc type) for m16c. */
1744 else /* machine == bfd_mach_m32c */
1748 switch (ELF32_R_TYPE(irel
->r_info
))
1751 case R_M32C_RL_JUMP
:
1754 case 0xbb: /* jmp.b */
1755 if (pcrel
>= 2 && pcrel
<= 9)
1758 /* Relax JMP.B -> JMP.S. We need to get rid of
1759 the following reloc though. */
1760 insn
[0] = 0x4a | ((p
<< 3) & 0x30) | (p
& 1);
1761 new_type
= R_M32C_NONE
;
1762 irel
->r_addend
= 0x10;
1768 case 0xce: /* jmp.w */
1769 if (pcrel
<= 128 && pcrel
>= -128)
1771 /* Relax JMP.W -> JMP.B */
1774 new_type
= R_M32C_8_PCREL
;
1780 case 0xcc: /* jmp.a */
1781 if (pcrel
<= 32768 && pcrel
>= -32768)
1783 /* Relax JMP.A -> JMP.W */
1787 new_type
= R_M32C_16_PCREL
;
1793 case 0xcd: /* jsr.a */
1794 if (pcrel
<= 32768 && pcrel
>= -32768)
1796 /* Relax JSR.A -> JSR.W */
1800 new_type
= R_M32C_16_PCREL
;
1808 case R_M32C_RL_2ADDR
:
1809 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1815 /* prefix; remove it as far as the RL reloc is concerned. */
1820 enctbl
= m32c_addr_encodings
;
1821 enc
= ((einsn
[0] & 0x70) >> 2) | ((einsn
[1] & 0x30) >> 4);
1824 if (srel
->r_offset
== irel
->r_offset
+ posn
1825 && e
->new_encoding
!= enc
1826 && symval
<= e
->max_disp
)
1829 einsn
[0] |= (e
->new_encoding
& 0x1c) << 2;
1831 einsn
[1] |= (e
->new_encoding
& 0x03) << 4;
1832 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1833 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1834 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1837 if (relax_relocs
== 2)
1843 case R_M32C_RL_1ADDR
:
1844 /* xxxx DDDx DDxx xxxx [disp] */
1850 /* prefix; remove it as far as the RL reloc is concerned. */
1855 enctbl
= m32c_addr_encodings
;
1858 /* srel, posn, and enc must be set here. */
1860 symval
= OFFSET_FOR_RELOC (srel
);
1861 enc
= ((einsn
[0] & 0x0e) << 1) | ((einsn
[1] & 0xc0) >> 6);
1864 if (srel
->r_offset
== irel
->r_offset
+ posn
1865 && e
->new_encoding
!= enc
1866 && symval
<= e
->max_disp
)
1869 einsn
[0] |= (e
->new_encoding
& 0x1c) >> 1;
1871 einsn
[1] |= (e
->new_encoding
& 0x03) << 6;
1872 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1873 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1874 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1880 } /* Ends switch (reloc type) for m32c. */
1888 srel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (srel
->r_info
), new_type
);
1890 /* Note that we've changed the relocs, section contents, etc. */
1891 elf_section_data (sec
)->relocs
= internal_relocs
;
1894 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1895 free_contents
= NULL
;
1897 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1898 free_intsyms
= NULL
;
1900 bytes_saved
+= gap_size
;
1902 if (! m32c_elf_relax_delete_bytes(abfd
, sec
, gap
- contents
, gap_size
))
1905 } /* next relocation */
1907 if (free_relocs
!= NULL
)
1913 if (free_contents
!= NULL
)
1915 if (! link_info
->keep_memory
)
1916 free (free_contents
);
1917 /* Cache the section contents for elf_link_input_bfd. */
1919 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1921 free_contents
= NULL
;
1924 if (shndx_buf
!= NULL
)
1926 shndx_hdr
->contents
= NULL
;
1930 if (free_intsyms
!= NULL
)
1932 if (! link_info
->keep_memory
)
1933 free (free_intsyms
);
1934 /* Cache the symbols for elf_link_input_bfd. */
1937 symtab_hdr
->contents
= NULL
/* (unsigned char *) intsyms*/;
1940 free_intsyms
= NULL
;
1946 if (free_relocs
!= NULL
)
1948 if (free_contents
!= NULL
)
1949 free (free_contents
);
1950 if (shndx_buf
!= NULL
)
1952 shndx_hdr
->contents
= NULL
;
1955 if (free_intsyms
!= NULL
)
1956 free (free_intsyms
);
1960 /* Delete some bytes from a section while relaxing. */
1963 m32c_elf_relax_delete_bytes
1969 Elf_Internal_Shdr
*symtab_hdr
;
1970 Elf_Internal_Shdr
*shndx_hdr
;
1973 Elf_Internal_Rela
*irel
;
1974 Elf_Internal_Rela
*irelend
;
1976 Elf_Internal_Sym
*isym
;
1977 Elf_Internal_Sym
*isymend
;
1978 Elf_Internal_Sym
*intsyms
;
1979 Elf_External_Sym_Shndx
*shndx_buf
;
1980 Elf_External_Sym_Shndx
*shndx
;
1981 struct elf_link_hash_entry
** sym_hashes
;
1982 struct elf_link_hash_entry
** end_hashes
;
1983 unsigned int symcount
;
1985 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1989 irel
= elf_section_data (sec
)->relocs
;
1990 irelend
= irel
+ sec
->reloc_count
;
1992 /* Actually delete the bytes. */
1993 memmove (contents
+ addr
, contents
+ addr
+ count
, (size_t) (toaddr
- addr
- count
));
1996 /* Adjust all the relocs. */
1997 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1999 /* Get the new reloc address. */
2000 if (irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
)
2001 irel
->r_offset
-= count
;
2003 if (ELF32_R_TYPE(irel
->r_info
) == R_M32C_RL_JUMP
2004 && irel
->r_addend
== 0x10 /* one byte insn, no relocs */
2005 && irel
->r_offset
+ 1 < addr
2006 && irel
->r_offset
+ 7 > addr
)
2009 unsigned char *insn
= &contents
[irel
->r_offset
];
2011 /* This is a JMP.S, which we have to manually update. */
2012 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2014 if ((*insn
& 0xf8) != 0x60)
2020 if ((*insn
& 0xce) != 0x4a)
2022 disp
= ((disp
& 0x30) >> 3) | (disp
& 1);
2024 if (irel
->r_offset
+ disp
+ 2 >= addr
+count
)
2027 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2029 *insn
= (*insn
& 0xf8) | disp
;
2033 *insn
= (*insn
& 0xce) | ((disp
& 6) << 3) | (disp
& 1);
2039 /* Adjust the local symbols defined in this section. */
2040 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
2041 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2043 isymend
= isym
+ symtab_hdr
->sh_info
;
2045 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2046 shndx_hdr
= & elf_tdata (abfd
)->symtab_shndx_hdr
;
2047 shndx_buf
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
2050 for (; isym
< isymend
; isym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
2052 /* If the symbol is in the range of memory we just moved, we
2053 have to adjust its value. */
2054 if ((int) isym
->st_shndx
== sec_shndx
2055 && isym
->st_value
> addr
2056 && isym
->st_value
< toaddr
)
2058 isym
->st_value
-= count
;
2060 /* If the symbol *spans* the bytes we just deleted (i.e. it's
2061 *end* is in the moved bytes but it's *start* isn't), then we
2062 must adjust its size. */
2063 if ((int) isym
->st_shndx
== sec_shndx
2064 && isym
->st_value
< addr
2065 && isym
->st_value
+ isym
->st_size
> addr
2066 && isym
->st_value
+ isym
->st_size
< toaddr
)
2068 isym
->st_size
-= count
;
2072 /* Now adjust the global symbols defined in this section. */
2073 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2074 - symtab_hdr
->sh_info
);
2075 sym_hashes
= elf_sym_hashes (abfd
);
2076 // sym_hashes += symtab_hdr->sh_info;
2077 end_hashes
= sym_hashes
+ symcount
;
2079 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2081 struct elf_link_hash_entry
* sym_hash
= * sym_hashes
;
2084 (sym_hash
->root
.type
== bfd_link_hash_defined
2085 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2086 && sym_hash
->root
.u
.def
.section
== sec
)
2088 if (sym_hash
->root
.u
.def
.value
> addr
2089 && sym_hash
->root
.u
.def
.value
< toaddr
)
2091 sym_hash
->root
.u
.def
.value
-= count
;
2093 if (sym_hash
->root
.u
.def
.value
< addr
2094 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2095 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
2097 sym_hash
->size
-= count
;
2105 /* This is for versions of gcc prior to 4.3. */
2107 _bfd_m32c_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
2109 if ((elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
) == EF_M32C_CPU_M16C
)
2116 #define ELF_ARCH bfd_arch_m32c
2117 #define ELF_MACHINE_CODE EM_M32C
2118 #define ELF_MACHINE_ALT1 EM_M32C_OLD
2119 #define ELF_MAXPAGESIZE 0x100
2122 #define TARGET_BIG_SYM m32c_elf32_vec
2123 #define TARGET_BIG_NAME "elf32-m32c"
2125 #define TARGET_LITTLE_SYM m32c_elf32_vec
2126 #define TARGET_LITTLE_NAME "elf32-m32c"
2129 #define elf_info_to_howto_rel NULL
2130 #define elf_info_to_howto m32c_info_to_howto_rela
2131 #define elf_backend_object_p m32c_elf_object_p
2132 #define elf_backend_relocate_section m32c_elf_relocate_section
2133 #define elf_backend_check_relocs m32c_elf_check_relocs
2134 #define elf_backend_object_p m32c_elf_object_p
2135 #define elf_symbol_leading_char ('_')
2136 #define elf_backend_always_size_sections \
2137 m32c_elf_always_size_sections
2138 #define elf_backend_finish_dynamic_sections \
2139 m32c_elf_finish_dynamic_sections
2141 #define elf_backend_can_gc_sections 1
2142 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2144 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2145 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2146 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2147 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2148 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2149 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2151 #include "elf32-target.h"