1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 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 (!bfd_link_relocatable (info
))
481 (*info
->callbacks
->undefined_symbol
) (info
, h
->root
.root
.string
,
482 input_bfd
, input_section
,
483 rel
->r_offset
, TRUE
);
486 if (sec
!= NULL
&& discarded_section (sec
))
487 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
488 rel
, 1, relend
, howto
, 0, contents
);
490 if (bfd_link_relocatable (info
))
492 /* This is a relocatable link. We don't have to change
493 anything, unless the reloc is against a section symbol,
494 in which case we have to adjust according to where the
495 section symbol winds up in the output section. */
496 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
497 rel
->r_addend
+= sec
->output_offset
;
501 switch (ELF32_R_TYPE (rel
->r_info
))
508 plt_offset
= &h
->plt
.offset
;
510 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
512 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
513 relocation, *plt_offset);*/
514 if (relocation
<= 0xffff)
516 /* If the symbol is in range for a 16-bit address, we should
517 have deallocated the plt entry in relax_section. */
518 BFD_ASSERT (*plt_offset
== (bfd_vma
) -1);
522 /* If the symbol is out of range for a 16-bit address,
523 we must have allocated a plt entry. */
524 BFD_ASSERT (*plt_offset
!= (bfd_vma
) -1);
526 /* If this is the first time we've processed this symbol,
527 fill in the plt entry with the correct symbol address. */
528 if ((*plt_offset
& 1) == 0)
532 x
= 0x000000fc; /* jmpf */
533 x
|= (relocation
<< 8) & 0xffffff00;
534 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
538 relocation
= (splt
->output_section
->vma
539 + splt
->output_offset
540 + (*plt_offset
& -2));
543 char *newname
= bfd_malloc (strlen(name
)+5);
544 strcpy (newname
, name
);
545 strcat(newname
, ".plt");
546 _bfd_generic_link_add_one_symbol (info
,
549 BSF_FUNCTION
| BSF_WEAK
,
568 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
569 m32c_elf_howto_table
[ELF32_R_TYPE(rel
->r_info
)].name
,
570 rel
->r_offset
+ input_section
->output_section
->vma
+ input_section
->output_offset
,
571 relocation
, rel
->r_addend
);
575 printf (" %02x", contents
[rel
->r_offset
+i
]);
579 switch (ELF32_R_TYPE(rel
->r_info
))
582 /* Like m32c_apply_reloc_24, we must handle this one separately. */
583 relocation
+= rel
->r_addend
;
585 /* Sanity check the address. */
586 if (rel
->r_offset
+ 3
587 > bfd_get_section_limit_octets (input_bfd
, input_section
))
588 r
= bfd_reloc_outofrange
;
591 bfd_put_8 (input_bfd
, relocation
& 0xff, contents
+ rel
->r_offset
);
592 bfd_put_8 (input_bfd
, (relocation
>> 8) & 0xff, contents
+ rel
->r_offset
+ 1);
593 bfd_put_8 (input_bfd
, (relocation
>> 16) & 0xff, contents
+ rel
->r_offset
+ 2);
600 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
601 contents
, rel
->r_offset
, relocation
,
606 if (r
!= bfd_reloc_ok
)
608 const char * msg
= (const char *) NULL
;
612 case bfd_reloc_overflow
:
613 (*info
->callbacks
->reloc_overflow
)
614 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
615 input_bfd
, input_section
, rel
->r_offset
);
618 case bfd_reloc_undefined
:
619 (*info
->callbacks
->undefined_symbol
)
620 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
623 case bfd_reloc_outofrange
:
624 msg
= _("internal error: out of range error");
627 case bfd_reloc_notsupported
:
628 msg
= _("internal error: unsupported relocation error");
631 case bfd_reloc_dangerous
:
632 msg
= _("internal error: dangerous relocation");
636 msg
= _("internal error: unknown error");
641 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
642 input_section
, rel
->r_offset
);
649 /* We support 16-bit pointers to code above 64k by generating a thunk
650 below 64k containing a JMP instruction to the final address. */
653 m32c_elf_check_relocs
655 struct bfd_link_info
* info
,
657 const Elf_Internal_Rela
* relocs
)
659 Elf_Internal_Shdr
* symtab_hdr
;
660 struct elf_link_hash_entry
** sym_hashes
;
661 const Elf_Internal_Rela
* rel
;
662 const Elf_Internal_Rela
* rel_end
;
663 bfd_vma
*local_plt_offsets
;
667 if (bfd_link_relocatable (info
))
670 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
671 sym_hashes
= elf_sym_hashes (abfd
);
672 local_plt_offsets
= elf_local_got_offsets (abfd
);
674 dynobj
= elf_hash_table(info
)->dynobj
;
676 rel_end
= relocs
+ sec
->reloc_count
;
677 for (rel
= relocs
; rel
< rel_end
; rel
++)
679 struct elf_link_hash_entry
*h
;
680 unsigned long r_symndx
;
683 r_symndx
= ELF32_R_SYM (rel
->r_info
);
684 if (r_symndx
< symtab_hdr
->sh_info
)
688 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
689 while (h
->root
.type
== bfd_link_hash_indirect
690 || h
->root
.type
== bfd_link_hash_warning
)
691 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
693 /* PR15323, ref flags aren't set for references in the same
695 h
->root
.non_ir_ref
= 1;
698 switch (ELF32_R_TYPE (rel
->r_info
))
700 /* This relocation describes a 16-bit pointer to a function.
701 We may need to allocate a thunk in low memory; reserve memory
705 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
708 splt
= bfd_get_linker_section (dynobj
, ".plt");
711 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
712 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
713 | SEC_READONLY
| SEC_CODE
);
714 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
717 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
723 offset
= &h
->plt
.offset
;
726 if (local_plt_offsets
== NULL
)
731 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
732 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
733 if (local_plt_offsets
== NULL
)
735 elf_local_got_offsets (abfd
) = local_plt_offsets
;
737 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
738 local_plt_offsets
[i
] = (bfd_vma
) -1;
740 offset
= &local_plt_offsets
[r_symndx
];
743 if (*offset
== (bfd_vma
) -1)
745 *offset
= splt
->size
;
755 /* This must exist if dynobj is ever set. */
758 m32c_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
759 struct bfd_link_info
*info
)
764 /* As an extra sanity check, verify that all plt entries have
767 if ((dynobj
= elf_hash_table (info
)->dynobj
) != NULL
768 && (splt
= bfd_get_linker_section (dynobj
, ".plt")) != NULL
)
770 bfd_byte
*contents
= splt
->contents
;
771 unsigned int i
, size
= splt
->size
;
772 for (i
= 0; i
< size
; i
+= 4)
774 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
783 m32c_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
784 struct bfd_link_info
*info
)
789 if (bfd_link_relocatable (info
))
792 dynobj
= elf_hash_table (info
)->dynobj
;
796 splt
= bfd_get_linker_section (dynobj
, ".plt");
797 BFD_ASSERT (splt
!= NULL
);
799 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
800 if (splt
->contents
== NULL
)
806 /* Function to set the ELF flag bits. */
809 m32c_elf_set_private_flags (bfd
*abfd
, flagword flags
)
811 elf_elfheader (abfd
)->e_flags
= flags
;
812 elf_flags_init (abfd
) = TRUE
;
816 /* Merge backend specific data from an object file to the output
817 object file when linking. */
820 m32c_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
822 bfd
*obfd
= info
->output_bfd
;
823 flagword old_flags
, old_partial
;
824 flagword new_flags
, new_partial
;
825 bfd_boolean error
= FALSE
;
829 new_opt
[0] = old_opt
[0] = '\0';
830 new_flags
= elf_elfheader (ibfd
)->e_flags
;
831 old_flags
= elf_elfheader (obfd
)->e_flags
;
835 ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
836 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
837 bfd_get_filename (ibfd
));
840 if (!elf_flags_init (obfd
))
842 /* First call, no flags set. */
843 elf_flags_init (obfd
) = TRUE
;
844 elf_elfheader (obfd
)->e_flags
= new_flags
;
847 else if (new_flags
== old_flags
)
848 /* Compatible flags are ok. */
851 else /* Possibly incompatible flags. */
853 /* Warn if different cpu is used (allow a specific cpu to override
855 new_partial
= (new_flags
& EF_M32C_CPU_MASK
);
856 old_partial
= (old_flags
& EF_M32C_CPU_MASK
);
857 if (new_partial
== old_partial
)
864 default: strcat (new_opt
, " -m16c"); break;
865 case EF_M32C_CPU_M16C
: strcat (new_opt
, " -m16c"); break;
866 case EF_M32C_CPU_M32C
: strcat (new_opt
, " -m32c"); break;
871 default: strcat (old_opt
, " -m16c"); break;
872 case EF_M32C_CPU_M16C
: strcat (old_opt
, " -m16c"); break;
873 case EF_M32C_CPU_M32C
: strcat (old_opt
, " -m32c"); break;
877 /* Print out any mismatches from above. */
882 (_("%s: compiled with %s and linked with modules compiled with %s"),
883 bfd_get_filename (ibfd
), new_opt
, old_opt
);
886 new_flags
&= ~ EF_M32C_ALL_FLAGS
;
887 old_flags
&= ~ EF_M32C_ALL_FLAGS
;
889 /* Warn about any other mismatches. */
890 if (new_flags
!= old_flags
)
894 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
895 bfd_get_filename (ibfd
), (long)new_flags
, (long)old_flags
);
900 bfd_set_error (bfd_error_bad_value
);
907 m32c_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
909 FILE *file
= (FILE *) ptr
;
912 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
914 /* Print normal ELF private data. */
915 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
917 flags
= elf_elfheader (abfd
)->e_flags
;
918 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
920 switch (flags
& EF_M32C_CPU_MASK
)
923 case EF_M32C_CPU_M16C
: fprintf (file
, " -m16c"); break;
924 case EF_M32C_CPU_M32C
: fprintf (file
, " -m32c"); break;
931 /* Return the MACH for an e_flags value. */
934 elf32_m32c_machine (bfd
*abfd
)
936 switch (elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
)
938 case EF_M32C_CPU_M16C
: return bfd_mach_m16c
;
939 case EF_M32C_CPU_M32C
: return bfd_mach_m32c
;
942 return bfd_mach_m16c
;
946 m32c_elf_object_p (bfd
*abfd
)
948 bfd_default_set_arch_mach (abfd
, bfd_arch_m32c
,
949 elf32_m32c_machine (abfd
));
956 dump_symtab (bfd
* abfd
, void *internal_syms
, void *external_syms
)
959 Elf_Internal_Sym
*isymbuf
;
960 Elf_Internal_Sym
*isymend
;
961 Elf_Internal_Sym
*isym
;
962 Elf_Internal_Shdr
*symtab_hdr
;
963 bfd_boolean free_internal
= 0, free_external
= 0;
965 char * st_info_stb_str
;
971 internal_syms
= bfd_malloc (1000);
976 external_syms
= bfd_malloc (1000);
980 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
981 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data(abfd
)->s
->sizeof_sym
;
983 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
984 symtab_hdr
->sh_info
, 0,
985 internal_syms
, external_syms
, NULL
);
987 isymbuf
= internal_syms
;
988 isymend
= isymbuf
+ locsymcount
;
990 for (isym
= isymbuf
; isym
< isymend
; isym
++)
992 switch (ELF_ST_TYPE (isym
->st_info
))
995 st_info_str
= "STT_FUNC";
999 st_info_str
= "STT_SECTION";
1003 st_info_str
= "STT_FILE";
1007 st_info_str
= "STT_OBJECT";
1011 st_info_str
= "STT_TLS";
1018 switch (ELF_ST_BIND (isym
->st_info
))
1021 st_info_stb_str
= "STB_LOCAL";
1025 st_info_stb_str
= "STB_GLOBAL";
1029 st_info_stb_str
= "";
1032 switch (ELF_ST_VISIBILITY (isym
->st_other
))
1035 st_other_str
= "STV_DEFAULT";
1039 st_other_str
= "STV_INTERNAL";
1043 st_other_str
= "STV_PROTECTED";
1050 switch (isym
->st_shndx
)
1053 st_shndx_str
= "SHN_ABS";
1057 st_shndx_str
= "SHN_COMMON";
1061 st_shndx_str
= "SHN_UNDEF";
1068 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1069 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1071 (unsigned long) isym
->st_value
,
1072 (unsigned long) isym
->st_size
,
1074 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
1076 isym
->st_info
, st_info_str
, st_info_stb_str
,
1077 isym
->st_other
, st_other_str
,
1078 isym
->st_shndx
, st_shndx_str
);
1081 free (internal_syms
);
1083 free (external_syms
);
1087 m32c_get_reloc (long reloc
)
1089 if (0 <= reloc
&& reloc
< R_M32C_max
)
1090 return m32c_elf_howto_table
[reloc
].name
;
1096 /* Handle relaxing. */
1098 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1099 is within the low 64k, remove any entry for it in the plt. */
1101 struct relax_plt_data
1108 m32c_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1110 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1112 if (h
->plt
.offset
!= (bfd_vma
) -1)
1116 if (h
->root
.type
== bfd_link_hash_undefined
1117 || h
->root
.type
== bfd_link_hash_undefweak
)
1120 address
= (h
->root
.u
.def
.section
->output_section
->vma
1121 + h
->root
.u
.def
.section
->output_offset
1122 + h
->root
.u
.def
.value
);
1124 if (address
<= 0xffff)
1127 data
->splt
->size
-= 4;
1128 *data
->again
= TRUE
;
1135 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1136 previously had a plt entry, give it a new entry offset. */
1139 m32c_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1141 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1143 if (h
->plt
.offset
!= (bfd_vma
) -1)
1145 h
->plt
.offset
= *entry
;
1153 m32c_elf_relax_plt_section (asection
*splt
,
1154 struct bfd_link_info
*info
,
1157 struct relax_plt_data relax_plt_data
;
1160 /* Assume nothing changes. */
1163 if (bfd_link_relocatable (info
))
1166 /* Quick check for an empty plt. */
1167 if (splt
->size
== 0)
1170 /* Map across all global symbols; see which ones happen to
1171 fall in the low 64k. */
1172 relax_plt_data
.splt
= splt
;
1173 relax_plt_data
.again
= again
;
1174 elf_link_hash_traverse (elf_hash_table (info
), m32c_relax_plt_check
,
1177 /* Likewise for local symbols, though that's somewhat less convenient
1178 as we have to walk the list of input bfds and swap in symbol data. */
1179 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1181 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1182 Elf_Internal_Shdr
*symtab_hdr
;
1183 Elf_Internal_Sym
*isymbuf
= NULL
;
1186 if (! local_plt_offsets
)
1189 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1190 if (symtab_hdr
->sh_info
!= 0)
1192 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1193 if (isymbuf
== NULL
)
1194 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1195 symtab_hdr
->sh_info
, 0,
1197 if (isymbuf
== NULL
)
1201 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1203 Elf_Internal_Sym
*isym
;
1207 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1210 isym
= &isymbuf
[idx
];
1211 if (isym
->st_shndx
== SHN_UNDEF
)
1213 else if (isym
->st_shndx
== SHN_ABS
)
1214 tsec
= bfd_abs_section_ptr
;
1215 else if (isym
->st_shndx
== SHN_COMMON
)
1216 tsec
= bfd_com_section_ptr
;
1218 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1220 address
= (tsec
->output_section
->vma
1221 + tsec
->output_offset
1223 if (address
<= 0xffff)
1225 local_plt_offsets
[idx
] = -1;
1232 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1234 if (! info
->keep_memory
)
1238 /* Cache the symbols for elf_link_input_bfd. */
1239 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1244 /* If we changed anything, walk the symbols again to reallocate
1245 .plt entry addresses. */
1246 if (*again
&& splt
->size
> 0)
1250 elf_link_hash_traverse (elf_hash_table (info
),
1251 m32c_relax_plt_realloc
, &entry
);
1253 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1255 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1256 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1259 if (! local_plt_offsets
)
1262 for (idx
= 0; idx
< nlocals
; ++idx
)
1263 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1265 local_plt_offsets
[idx
] = entry
;
1275 compare_reloc (const void *e1
, const void *e2
)
1277 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
1278 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
1280 if (i1
->r_offset
== i2
->r_offset
)
1283 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
1286 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1288 m32c_offset_for_reloc (bfd
*abfd
,
1289 Elf_Internal_Rela
*rel
,
1290 Elf_Internal_Shdr
*symtab_hdr
,
1291 Elf_External_Sym_Shndx
*shndx_buf ATTRIBUTE_UNUSED
,
1292 Elf_Internal_Sym
*intsyms
)
1296 /* Get the value of the symbol referred to by the reloc. */
1297 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1299 /* A local symbol. */
1300 Elf_Internal_Sym
*isym
;
1303 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1304 ssec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1305 symval
= isym
->st_value
;
1307 symval
+= ssec
->output_section
->vma
1308 + ssec
->output_offset
;
1313 struct elf_link_hash_entry
*h
;
1315 /* An external symbol. */
1316 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1317 h
= elf_sym_hashes (abfd
)[indx
];
1318 BFD_ASSERT (h
!= NULL
);
1320 if (h
->root
.type
!= bfd_link_hash_defined
1321 && h
->root
.type
!= bfd_link_hash_defweak
)
1322 /* This appears to be a reference to an undefined
1323 symbol. Just ignore it--it will be caught by the
1324 regular reloc processing. */
1327 symval
= (h
->root
.u
.def
.value
1328 + h
->root
.u
.def
.section
->output_section
->vma
1329 + h
->root
.u
.def
.section
->output_offset
);
1334 static int bytes_saved
= 0;
1336 static int bytes_to_reloc
[] = {
1344 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1346 /* Mask for the number of relocs associated with this insn. */
1347 #define RLA_RELOCS 0x0000000f
1348 /* Number of bytes gas emitted (before gas's relaxing) */
1349 #define RLA_NBYTES 0x00000ff0
1351 /* If the displacement is within the given range and the new encoding
1352 differs from the old encoding (the index), then the insn can be
1353 relaxed to the new encoding. */
1356 unsigned int max_disp
;
1357 unsigned char new_encoding
;
1360 static EncodingTable m16c_addr_encodings
[] = {
1361 { 0, 0, 0 }, /* R0 */
1362 { 0, 0, 1 }, /* R1 */
1363 { 0, 0, 2 }, /* R2 */
1364 { 0, 0, 3 }, /* R3 */
1365 { 0, 0, 4 }, /* A0 */
1366 { 0, 0, 5 }, /* A1 */
1367 { 0, 0, 6 }, /* [A0] */
1368 { 0, 0, 7 }, /* [A1] */
1369 { 1, 0, 6 }, /* udsp:8[A0] */
1370 { 1, 0, 7 }, /* udsp:8[A1] */
1371 { 1, 0, 10 }, /* udsp:8[SB] */
1372 { 1, 0, 11 }, /* sdsp:8[FB] */
1373 { 2, 255, 8 }, /* udsp:16[A0] */
1374 { 2, 255, 9 }, /* udsp:16[A1] */
1375 { 2, 255, 10 }, /* udsp:16[SB] */
1376 { 2, 0, 15 }, /* abs:16 */
1379 static EncodingTable m16c_jmpaddr_encodings
[] = {
1380 { 0, 0, 0 }, /* R0 */
1381 { 0, 0, 1 }, /* R1 */
1382 { 0, 0, 2 }, /* R2 */
1383 { 0, 0, 3 }, /* R3 */
1384 { 0, 0, 4 }, /* A0 */
1385 { 0, 0, 5 }, /* A1 */
1386 { 0, 0, 6 }, /* [A0] */
1387 { 0, 0, 7 }, /* [A1] */
1388 { 1, 0, 6 }, /* udsp:8[A0] */
1389 { 1, 0, 7 }, /* udsp:8[A1] */
1390 { 1, 0, 10 }, /* udsp:8[SB] */
1391 { 1, 0, 11 }, /* sdsp:8[FB] */
1392 { 3, 255, 8 }, /* udsp:20[A0] */
1393 { 3, 255, 9 }, /* udsp:20[A1] */
1394 { 2, 255, 10 }, /* udsp:16[SB] */
1395 { 2, 0, 15 }, /* abs:16 */
1398 static EncodingTable m32c_addr_encodings
[] = {
1399 { 0, 0, 0 }, /* [A0] */
1400 { 0, 0, 1 }, /* [A1] */
1401 { 0, 0, 2 }, /* A0 */
1402 { 0, 0, 3 }, /* A1 */
1403 { 1, 0, 0 }, /* udsp:8[A0] */
1404 { 1, 0, 1 }, /* udsp:8[A1] */
1405 { 1, 0, 6 }, /* udsp:8[SB] */
1406 { 1, 0, 7 }, /* sdsp:8[FB] */
1407 { 2, 255, 4 }, /* udsp:16[A0] */
1408 { 2, 255, 5 }, /* udsp:16[A1] */
1409 { 2, 255, 6 }, /* udsp:16[SB] */
1410 { 2, 127, 7 }, /* sdsp:16[FB] */
1411 { 3, 65535, 8 }, /* udsp:24[A0] */
1412 { 3, 65535, 9 }, /* udsp:24[A1] */
1413 { 3, 65535, 15 }, /* abs24 */
1414 { 2, 0, 15 }, /* abs16 */
1415 { 0, 0, 16 }, /* R2 */
1416 { 0, 0, 17 }, /* R3 */
1417 { 0, 0, 18 }, /* R0 */
1418 { 0, 0, 19 }, /* R1 */
1434 m32c_elf_relax_section
1437 struct bfd_link_info
* link_info
,
1438 bfd_boolean
* again
)
1440 Elf_Internal_Shdr
*symtab_hdr
;
1441 Elf_Internal_Shdr
*shndx_hdr
;
1442 Elf_Internal_Rela
*internal_relocs
;
1443 Elf_Internal_Rela
*free_relocs
= NULL
;
1444 Elf_Internal_Rela
*irel
, *irelend
, *srel
;
1445 bfd_byte
* contents
= NULL
;
1446 bfd_byte
* free_contents
= NULL
;
1447 Elf_Internal_Sym
*intsyms
= NULL
;
1448 Elf_Internal_Sym
*free_intsyms
= NULL
;
1449 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1452 if (abfd
== elf_hash_table (link_info
)->dynobj
1453 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1454 && strcmp (sec
->name
, ".plt") == 0)
1455 return m32c_elf_relax_plt_section (sec
, link_info
, again
);
1457 /* Assume nothing changes. */
1460 machine
= elf32_m32c_machine (abfd
);
1462 /* We don't have to do anything for a relocatable link, if
1463 this section does not have relocs, or if this is not a
1465 if (bfd_link_relocatable (link_info
)
1466 || (sec
->flags
& SEC_RELOC
) == 0
1467 || sec
->reloc_count
== 0
1468 || (sec
->flags
& SEC_CODE
) == 0)
1471 symtab_hdr
= & elf_symtab_hdr (abfd
);
1472 if (elf_symtab_shndx_list (abfd
))
1473 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
1477 /* Get the section contents. */
1478 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1479 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1480 /* Go get them off disk. */
1481 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1484 /* Read this BFD's symbols. */
1485 /* Get cached copy if it exists. */
1486 if (symtab_hdr
->contents
!= NULL
)
1488 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1492 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
1493 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1496 if (shndx_hdr
&& shndx_hdr
->sh_size
!= 0)
1500 amt
= symtab_hdr
->sh_info
;
1501 amt
*= sizeof (Elf_External_Sym_Shndx
);
1502 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1503 if (shndx_buf
== NULL
)
1505 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1506 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
1508 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1511 /* Get a copy of the native relocations. */
1512 internal_relocs
= (_bfd_elf_link_read_relocs
1513 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
1514 link_info
->keep_memory
));
1515 if (internal_relocs
== NULL
)
1517 if (! link_info
->keep_memory
)
1518 free_relocs
= internal_relocs
;
1520 /* The RL_ relocs must be just before the operand relocs they go
1521 with, so we must sort them to guarantee this. */
1522 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
1525 /* Walk through them looking for relaxing opportunities. */
1526 irelend
= internal_relocs
+ sec
->reloc_count
;
1528 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1531 unsigned char *insn
, *gap
, *einsn
;
1533 bfd_signed_vma pcrel
;
1539 EncodingTable
*enctbl
;
1542 if (ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_JUMP
1543 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_1ADDR
1544 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_2ADDR
)
1549 /* There will always be room for the relaxed insn, since it is smaller
1550 than the one it would replace. */
1551 BFD_ASSERT (irel
->r_offset
< sec
->size
);
1553 insn
= contents
+ irel
->r_offset
;
1554 relax_relocs
= irel
->r_addend
% 16;
1556 /* Ok, we only have three relocs we care about, and they're all
1557 fake. The lower four bits of the addend is always the number
1558 of following relocs (hence the qsort above) that are assigned
1559 to this opcode. The next 8 bits of the addend indicates the
1560 number of bytes in the insn. We use the rest of them
1561 ourselves as flags for the more expensive operations (defines
1562 above). The three relocs are:
1564 RL_JUMP: This marks all direct jump insns. We check the
1565 displacement and replace them with shorter jumps if
1566 they're in range. We also use this to find JMP.S
1567 insns and manually shorten them when we delete bytes.
1568 We have to decode these insns to figure out what to
1571 RL_1ADDR: This is a :G or :Q insn, which has a single
1572 "standard" operand. We have to extract the type
1573 field, see if it's a wide displacement, then figure
1574 out if we can replace it with a narrow displacement.
1575 We don't have to decode these insns.
1577 RL_2ADDR: Similarly, but two "standard" operands. Note that
1578 r_addend may still be 1, as standard operands don't
1579 always have displacements. Gas shouldn't give us one
1580 with zero operands, but since we don't know which one
1581 has the displacement, we check them both anyway.
1583 These all point to the beginning of the insn itself, not the
1586 Note that we only relax one step at a time, relying on the
1587 linker to call us repeatedly. Thus, there is no code for
1588 JMP.A->JMP.B although that will happen in two steps.
1589 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1592 /* Get the value of the symbol referred to by the reloc. Just
1593 in case this is the last reloc in the list, use the RL's
1594 addend to choose between this reloc (no addend) or the next
1595 (yes addend, which means at least one following reloc). */
1596 srel
= irel
+ (relax_relocs
? 1 : 0);
1597 symval
= OFFSET_FOR_RELOC (srel
);
1599 /* Setting gap_size nonzero is the flag which means "something
1603 new_type
= ELF32_R_TYPE(srel
->r_info
);
1605 pc
= sec
->output_section
->vma
+ sec
->output_offset
1607 pcrel
= symval
- pc
+ srel
->r_addend
;
1609 if (machine
== bfd_mach_m16c
)
1613 switch (ELF32_R_TYPE(irel
->r_info
))
1616 case R_M32C_RL_JUMP
:
1619 case 0xfe: /* jmp.b */
1620 if (pcrel
>= 2 && pcrel
<= 9)
1622 /* Relax JMP.B -> JMP.S. We need to get rid of
1623 the following reloc though. */
1624 insn
[0] = 0x60 | (pcrel
- 2);
1625 new_type
= R_M32C_NONE
;
1626 irel
->r_addend
= 0x10;
1632 case 0xf4: /* jmp.w */
1633 /* 128 is allowed because it will be one byte closer
1634 after relaxing. Likewise for all other pc-rel
1636 if (pcrel
<= 128 && pcrel
>= -128)
1638 /* Relax JMP.W -> JMP.B */
1641 new_type
= R_M32C_8_PCREL
;
1647 case 0xfc: /* jmp.a */
1648 if (pcrel
<= 32768 && pcrel
>= -32768)
1650 /* Relax JMP.A -> JMP.W */
1654 new_type
= R_M32C_16_PCREL
;
1660 case 0xfd: /* jsr.a */
1661 if (pcrel
<= 32768 && pcrel
>= -32768)
1663 /* Relax JSR.A -> JSR.W */
1667 new_type
= R_M32C_16_PCREL
;
1675 case R_M32C_RL_2ADDR
:
1676 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1678 enctbl
= m16c_addr_encodings
;
1680 enc
= (insn
[1] >> 4) & 0x0f;
1683 if (srel
->r_offset
== irel
->r_offset
+ posn
1684 && e
->new_encoding
!= enc
1685 && symval
<= e
->max_disp
)
1688 insn
[1] |= e
->new_encoding
<< 4;
1689 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1690 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1691 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1694 if (relax_relocs
== 2)
1700 case R_M32C_RL_1ADDR
:
1701 /* xxxx xxxx xxxx dest [disp] */
1703 enctbl
= m16c_addr_encodings
;
1706 /* Check the opcode for jumps. We know it's safe to
1707 do this because all 2ADDR insns are at least two
1709 enc
= insn
[0] * 256 + insn
[1];
1716 enctbl
= m16c_jmpaddr_encodings
;
1720 /* srel, posn, and enc must be set here. */
1722 symval
= OFFSET_FOR_RELOC (srel
);
1723 enc
= insn
[1] & 0x0f;
1726 if (srel
->r_offset
== irel
->r_offset
+ posn
1727 && e
->new_encoding
!= enc
1728 && symval
<= e
->max_disp
)
1731 insn
[1] |= e
->new_encoding
;
1732 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1733 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1734 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1740 } /* Ends switch (reloc type) for m16c. */
1742 else /* machine == bfd_mach_m32c */
1746 switch (ELF32_R_TYPE(irel
->r_info
))
1749 case R_M32C_RL_JUMP
:
1752 case 0xbb: /* jmp.b */
1753 if (pcrel
>= 2 && pcrel
<= 9)
1756 /* Relax JMP.B -> JMP.S. We need to get rid of
1757 the following reloc though. */
1758 insn
[0] = 0x4a | ((p
<< 3) & 0x30) | (p
& 1);
1759 new_type
= R_M32C_NONE
;
1760 irel
->r_addend
= 0x10;
1766 case 0xce: /* jmp.w */
1767 if (pcrel
<= 128 && pcrel
>= -128)
1769 /* Relax JMP.W -> JMP.B */
1772 new_type
= R_M32C_8_PCREL
;
1778 case 0xcc: /* jmp.a */
1779 if (pcrel
<= 32768 && pcrel
>= -32768)
1781 /* Relax JMP.A -> JMP.W */
1785 new_type
= R_M32C_16_PCREL
;
1791 case 0xcd: /* jsr.a */
1792 if (pcrel
<= 32768 && pcrel
>= -32768)
1794 /* Relax JSR.A -> JSR.W */
1798 new_type
= R_M32C_16_PCREL
;
1806 case R_M32C_RL_2ADDR
:
1807 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1813 /* prefix; remove it as far as the RL reloc is concerned. */
1818 enctbl
= m32c_addr_encodings
;
1819 enc
= ((einsn
[0] & 0x70) >> 2) | ((einsn
[1] & 0x30) >> 4);
1822 if (srel
->r_offset
== irel
->r_offset
+ posn
1823 && e
->new_encoding
!= enc
1824 && symval
<= e
->max_disp
)
1827 einsn
[0] |= (e
->new_encoding
& 0x1c) << 2;
1829 einsn
[1] |= (e
->new_encoding
& 0x03) << 4;
1830 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1831 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1832 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1835 if (relax_relocs
== 2)
1841 case R_M32C_RL_1ADDR
:
1842 /* xxxx DDDx DDxx xxxx [disp] */
1848 /* prefix; remove it as far as the RL reloc is concerned. */
1853 enctbl
= m32c_addr_encodings
;
1856 /* srel, posn, and enc must be set here. */
1858 symval
= OFFSET_FOR_RELOC (srel
);
1859 enc
= ((einsn
[0] & 0x0e) << 1) | ((einsn
[1] & 0xc0) >> 6);
1862 if (srel
->r_offset
== irel
->r_offset
+ posn
1863 && e
->new_encoding
!= enc
1864 && symval
<= e
->max_disp
)
1867 einsn
[0] |= (e
->new_encoding
& 0x1c) >> 1;
1869 einsn
[1] |= (e
->new_encoding
& 0x03) << 6;
1870 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1871 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1872 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1878 } /* Ends switch (reloc type) for m32c. */
1886 srel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (srel
->r_info
), new_type
);
1888 /* Note that we've changed the relocs, section contents, etc. */
1889 elf_section_data (sec
)->relocs
= internal_relocs
;
1892 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1893 free_contents
= NULL
;
1895 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1896 free_intsyms
= NULL
;
1898 bytes_saved
+= gap_size
;
1900 if (! m32c_elf_relax_delete_bytes(abfd
, sec
, gap
- contents
, gap_size
))
1903 } /* next relocation */
1905 if (free_relocs
!= NULL
)
1911 if (free_contents
!= NULL
)
1913 if (! link_info
->keep_memory
)
1914 free (free_contents
);
1915 /* Cache the section contents for elf_link_input_bfd. */
1917 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1919 free_contents
= NULL
;
1922 if (shndx_buf
!= NULL
)
1924 shndx_hdr
->contents
= NULL
;
1928 if (free_intsyms
!= NULL
)
1930 if (! link_info
->keep_memory
)
1931 free (free_intsyms
);
1932 /* Cache the symbols for elf_link_input_bfd. */
1935 symtab_hdr
->contents
= NULL
/* (unsigned char *) intsyms*/;
1938 free_intsyms
= NULL
;
1944 if (free_relocs
!= NULL
)
1946 if (free_contents
!= NULL
)
1947 free (free_contents
);
1948 if (shndx_buf
!= NULL
)
1950 shndx_hdr
->contents
= NULL
;
1953 if (free_intsyms
!= NULL
)
1954 free (free_intsyms
);
1958 /* Delete some bytes from a section while relaxing. */
1961 m32c_elf_relax_delete_bytes
1967 Elf_Internal_Shdr
*symtab_hdr
;
1968 Elf_Internal_Shdr
*shndx_hdr
;
1971 Elf_Internal_Rela
*irel
;
1972 Elf_Internal_Rela
*irelend
;
1974 Elf_Internal_Sym
*isym
;
1975 Elf_Internal_Sym
*isymend
;
1976 Elf_Internal_Sym
*intsyms
;
1977 Elf_External_Sym_Shndx
*shndx_buf
;
1978 Elf_External_Sym_Shndx
*shndx
;
1979 struct elf_link_hash_entry
** sym_hashes
;
1980 struct elf_link_hash_entry
** end_hashes
;
1981 unsigned int symcount
;
1983 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1987 irel
= elf_section_data (sec
)->relocs
;
1988 irelend
= irel
+ sec
->reloc_count
;
1990 /* Actually delete the bytes. */
1991 memmove (contents
+ addr
, contents
+ addr
+ count
, (size_t) (toaddr
- addr
- count
));
1994 /* Adjust all the relocs. */
1995 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1997 /* Get the new reloc address. */
1998 if (irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
)
1999 irel
->r_offset
-= count
;
2001 if (ELF32_R_TYPE(irel
->r_info
) == R_M32C_RL_JUMP
2002 && irel
->r_addend
== 0x10 /* one byte insn, no relocs */
2003 && irel
->r_offset
+ 1 < addr
2004 && irel
->r_offset
+ 7 > addr
)
2007 unsigned char *insn
= &contents
[irel
->r_offset
];
2009 /* This is a JMP.S, which we have to manually update. */
2010 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2012 if ((*insn
& 0xf8) != 0x60)
2018 if ((*insn
& 0xce) != 0x4a)
2020 disp
= ((disp
& 0x30) >> 3) | (disp
& 1);
2022 if (irel
->r_offset
+ disp
+ 2 >= addr
+count
)
2025 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2027 *insn
= (*insn
& 0xf8) | disp
;
2031 *insn
= (*insn
& 0xce) | ((disp
& 6) << 3) | (disp
& 1);
2037 /* Adjust the local symbols defined in this section. */
2038 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
2039 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2041 isymend
= isym
+ symtab_hdr
->sh_info
;
2043 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2044 if (elf_symtab_shndx_list (abfd
))
2046 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
2047 shndx_buf
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
2056 for (; isym
< isymend
; isym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
2058 /* If the symbol is in the range of memory we just moved, we
2059 have to adjust its value. */
2060 if ((int) isym
->st_shndx
== sec_shndx
2061 && isym
->st_value
> addr
2062 && isym
->st_value
< toaddr
)
2064 isym
->st_value
-= count
;
2066 /* If the symbol *spans* the bytes we just deleted (i.e. it's
2067 *end* is in the moved bytes but it's *start* isn't), then we
2068 must adjust its size. */
2069 if ((int) isym
->st_shndx
== sec_shndx
2070 && isym
->st_value
< addr
2071 && isym
->st_value
+ isym
->st_size
> addr
2072 && isym
->st_value
+ isym
->st_size
< toaddr
)
2074 isym
->st_size
-= count
;
2078 /* Now adjust the global symbols defined in this section. */
2079 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2080 - symtab_hdr
->sh_info
);
2081 sym_hashes
= elf_sym_hashes (abfd
);
2082 // sym_hashes += symtab_hdr->sh_info;
2083 end_hashes
= sym_hashes
+ symcount
;
2085 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2087 struct elf_link_hash_entry
* sym_hash
= * sym_hashes
;
2090 (sym_hash
->root
.type
== bfd_link_hash_defined
2091 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2092 && sym_hash
->root
.u
.def
.section
== sec
)
2094 if (sym_hash
->root
.u
.def
.value
> addr
2095 && sym_hash
->root
.u
.def
.value
< toaddr
)
2097 sym_hash
->root
.u
.def
.value
-= count
;
2099 if (sym_hash
->root
.u
.def
.value
< addr
2100 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2101 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
2103 sym_hash
->size
-= count
;
2111 /* This is for versions of gcc prior to 4.3. */
2113 _bfd_m32c_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
2115 if ((elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
) == EF_M32C_CPU_M16C
)
2122 #define ELF_ARCH bfd_arch_m32c
2123 #define ELF_MACHINE_CODE EM_M32C
2124 #define ELF_MACHINE_ALT1 EM_M32C_OLD
2125 #define ELF_MAXPAGESIZE 0x100
2128 #define TARGET_BIG_SYM m32c_elf32_vec
2129 #define TARGET_BIG_NAME "elf32-m32c"
2131 #define TARGET_LITTLE_SYM m32c_elf32_vec
2132 #define TARGET_LITTLE_NAME "elf32-m32c"
2135 #define elf_info_to_howto_rel NULL
2136 #define elf_info_to_howto m32c_info_to_howto_rela
2137 #define elf_backend_object_p m32c_elf_object_p
2138 #define elf_backend_relocate_section m32c_elf_relocate_section
2139 #define elf_backend_check_relocs m32c_elf_check_relocs
2140 #define elf_backend_object_p m32c_elf_object_p
2141 #define elf_symbol_leading_char ('_')
2142 #define elf_backend_always_size_sections \
2143 m32c_elf_always_size_sections
2144 #define elf_backend_finish_dynamic_sections \
2145 m32c_elf_finish_dynamic_sections
2147 #define elf_backend_can_gc_sections 1
2148 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2150 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2151 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2152 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2153 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2154 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2155 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2157 #include "elf32-target.h"