1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005-2017 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 /* xgettext:c-format */
305 _bfd_error_handler (_("%B: invalid M32C reloc number: %d"), abfd
, r_type
);
308 cache_ptr
->howto
= & m32c_elf_howto_table
[r_type
];
313 /* Apply R_M32C_24 relocations. We have to do this because it's not a
314 power-of-two size, and the generic code may think it overruns the
315 section if it's right at the end.
317 Must return something other than bfd_reloc_continue to avoid the
318 above problem. Typical return values include bfd_reloc_ok or
322 static bfd_reloc_status_type
m32c_apply_reloc_24 (bfd
*abfd ATTRIBUTE_UNUSED
,
323 arelent
*reloc_entry
,
325 void *vdata_start ATTRIBUTE_UNUSED
,
326 asection
*input_section
,
327 bfd
*ibfd ATTRIBUTE_UNUSED
,
328 char **error_msg ATTRIBUTE_UNUSED
)
331 bfd_reloc_status_type s
;
333 s
= bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
,
335 input_section
, ibfd
, error_msg
);
336 if (s
!= bfd_reloc_continue
)
339 /* Get symbol value. (Common symbols are special.) */
340 if (bfd_is_com_section (symbol
->section
))
343 relocation
= symbol
->value
;
345 relocation
+= symbol
->section
->output_offset
;
347 /* Add in supplied addend. */
348 relocation
+= reloc_entry
->addend
;
350 reloc_entry
->addend
= relocation
;
351 reloc_entry
->address
+= input_section
->output_offset
;
355 /* Relocate an M32C ELF section.
356 There is some attempt to make this function usable for many architectures,
357 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
358 if only to serve as a learning tool.
360 The RELOCATE_SECTION function is called by the new ELF backend linker
361 to handle the relocations for a section.
363 The relocs are always passed as Rela structures; if the section
364 actually uses Rel structures, the r_addend field will always be
367 This function is responsible for adjusting the section contents as
368 necessary, and (if using Rela relocs and generating a relocatable
369 output file) adjusting the reloc addend as necessary.
371 This function does not have to worry about setting the reloc
372 address or the reloc symbol index.
374 LOCAL_SYMS is a pointer to the swapped in local symbols.
376 LOCAL_SECTIONS is an array giving the section in the input file
377 corresponding to the st_shndx field of each local symbol.
379 The global hash table entry for the global symbols can be found
380 via elf_sym_hashes (input_bfd).
382 When generating relocatable output, this function must handle
383 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
384 going to be the section symbol corresponding to the output
385 section, which means that the addend must be adjusted
389 m32c_elf_relocate_section
390 (bfd
* output_bfd ATTRIBUTE_UNUSED
,
391 struct bfd_link_info
* info
,
393 asection
* input_section
,
395 Elf_Internal_Rela
* relocs
,
396 Elf_Internal_Sym
* local_syms
,
397 asection
** local_sections
)
399 Elf_Internal_Shdr
* symtab_hdr
;
400 struct elf_link_hash_entry
** sym_hashes
;
401 Elf_Internal_Rela
* rel
;
402 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 splt
= elf_hash_table (info
)->splt
;
411 for (rel
= relocs
; rel
< relend
; rel
++)
413 reloc_howto_type
* howto
;
414 unsigned long r_symndx
;
415 Elf_Internal_Sym
* sym
;
417 struct elf_link_hash_entry
* h
;
419 bfd_reloc_status_type r
;
420 const char * name
= NULL
;
423 r_type
= ELF32_R_TYPE (rel
->r_info
);
425 /* These are only used for relaxing; we don't actually relocate
426 anything with them, so skip them. */
427 if (r_type
== R_M32C_RL_JUMP
428 || r_type
== R_M32C_RL_1ADDR
429 || r_type
== R_M32C_RL_2ADDR
)
432 r_symndx
= ELF32_R_SYM (rel
->r_info
);
434 howto
= m32c_elf_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
440 if (r_symndx
< symtab_hdr
->sh_info
)
442 sym
= local_syms
+ r_symndx
;
443 sec
= local_sections
[r_symndx
];
444 relocation
= (sec
->output_section
->vma
448 name
= bfd_elf_string_from_elf_section
449 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
450 name
= (sym
->st_name
== 0) ? bfd_section_name (input_bfd
, sec
) : name
;
454 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
456 if (info
->wrap_hash
!= NULL
457 && (input_section
->flags
& SEC_DEBUGGING
) != 0)
458 h
= ((struct elf_link_hash_entry
*)
459 unwrap_hash_lookup (info
, input_bfd
, &h
->root
));
461 while (h
->root
.type
== bfd_link_hash_indirect
462 || h
->root
.type
== bfd_link_hash_warning
)
463 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
465 name
= h
->root
.root
.string
;
467 if (h
->root
.type
== bfd_link_hash_defined
468 || h
->root
.type
== bfd_link_hash_defweak
)
470 sec
= h
->root
.u
.def
.section
;
471 relocation
= (h
->root
.u
.def
.value
472 + sec
->output_section
->vma
473 + sec
->output_offset
);
475 else if (h
->root
.type
== bfd_link_hash_undefweak
)
477 else if (!bfd_link_relocatable (info
))
478 (*info
->callbacks
->undefined_symbol
) (info
, h
->root
.root
.string
,
479 input_bfd
, input_section
,
480 rel
->r_offset
, TRUE
);
483 if (sec
!= NULL
&& discarded_section (sec
))
484 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
485 rel
, 1, relend
, howto
, 0, contents
);
487 if (bfd_link_relocatable (info
))
489 /* This is a relocatable link. We don't have to change
490 anything, unless the reloc is against a section symbol,
491 in which case we have to adjust according to where the
492 section symbol winds up in the output section. */
493 if (sym
!= NULL
&& ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
494 rel
->r_addend
+= sec
->output_offset
;
498 switch (ELF32_R_TYPE (rel
->r_info
))
505 plt_offset
= &h
->plt
.offset
;
507 plt_offset
= elf_local_got_offsets (input_bfd
) + r_symndx
;
509 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
510 relocation, *plt_offset);*/
511 if (relocation
<= 0xffff)
513 /* If the symbol is in range for a 16-bit address, we should
514 have deallocated the plt entry in relax_section. */
515 BFD_ASSERT (*plt_offset
== (bfd_vma
) -1);
519 /* If the symbol is out of range for a 16-bit address,
520 we must have allocated a plt entry. */
521 BFD_ASSERT (*plt_offset
!= (bfd_vma
) -1);
523 /* If this is the first time we've processed this symbol,
524 fill in the plt entry with the correct symbol address. */
525 if ((*plt_offset
& 1) == 0)
529 x
= 0x000000fc; /* jmpf */
530 x
|= (relocation
<< 8) & 0xffffff00;
531 bfd_put_32 (input_bfd
, x
, splt
->contents
+ *plt_offset
);
535 relocation
= (splt
->output_section
->vma
536 + splt
->output_offset
537 + (*plt_offset
& -2));
540 char *newname
= bfd_malloc (strlen(name
)+5);
541 strcpy (newname
, name
);
542 strcat(newname
, ".plt");
543 _bfd_generic_link_add_one_symbol (info
,
546 BSF_FUNCTION
| BSF_WEAK
,
565 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
566 m32c_elf_howto_table
[ELF32_R_TYPE(rel
->r_info
)].name
,
567 rel
->r_offset
+ input_section
->output_section
->vma
+ input_section
->output_offset
,
568 relocation
, rel
->r_addend
);
572 printf (" %02x", contents
[rel
->r_offset
+i
]);
576 switch (ELF32_R_TYPE(rel
->r_info
))
579 /* Like m32c_apply_reloc_24, we must handle this one separately. */
580 relocation
+= rel
->r_addend
;
582 /* Sanity check the address. */
583 if (rel
->r_offset
+ 3
584 > bfd_get_section_limit_octets (input_bfd
, input_section
))
585 r
= bfd_reloc_outofrange
;
588 bfd_put_8 (input_bfd
, relocation
& 0xff, contents
+ rel
->r_offset
);
589 bfd_put_8 (input_bfd
, (relocation
>> 8) & 0xff, contents
+ rel
->r_offset
+ 1);
590 bfd_put_8 (input_bfd
, (relocation
>> 16) & 0xff, contents
+ rel
->r_offset
+ 2);
597 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
598 contents
, rel
->r_offset
, relocation
,
603 if (r
!= bfd_reloc_ok
)
605 const char * msg
= (const char *) NULL
;
609 case bfd_reloc_overflow
:
610 (*info
->callbacks
->reloc_overflow
)
611 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
, (bfd_vma
) 0,
612 input_bfd
, input_section
, rel
->r_offset
);
615 case bfd_reloc_undefined
:
616 (*info
->callbacks
->undefined_symbol
)
617 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
620 case bfd_reloc_outofrange
:
621 msg
= _("internal error: out of range error");
624 case bfd_reloc_notsupported
:
625 msg
= _("internal error: unsupported relocation error");
628 case bfd_reloc_dangerous
:
629 msg
= _("internal error: dangerous relocation");
633 msg
= _("internal error: unknown error");
638 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
639 input_section
, rel
->r_offset
);
646 /* We support 16-bit pointers to code above 64k by generating a thunk
647 below 64k containing a JMP instruction to the final address. */
650 m32c_elf_check_relocs
652 struct bfd_link_info
* info
,
654 const Elf_Internal_Rela
* relocs
)
656 Elf_Internal_Shdr
* symtab_hdr
;
657 struct elf_link_hash_entry
** sym_hashes
;
658 const Elf_Internal_Rela
* rel
;
659 const Elf_Internal_Rela
* rel_end
;
660 bfd_vma
*local_plt_offsets
;
664 if (bfd_link_relocatable (info
))
667 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
668 sym_hashes
= elf_sym_hashes (abfd
);
669 local_plt_offsets
= elf_local_got_offsets (abfd
);
671 dynobj
= elf_hash_table(info
)->dynobj
;
673 rel_end
= relocs
+ sec
->reloc_count
;
674 for (rel
= relocs
; rel
< rel_end
; rel
++)
676 struct elf_link_hash_entry
*h
;
677 unsigned long r_symndx
;
680 r_symndx
= ELF32_R_SYM (rel
->r_info
);
681 if (r_symndx
< symtab_hdr
->sh_info
)
685 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
686 while (h
->root
.type
== bfd_link_hash_indirect
687 || h
->root
.type
== bfd_link_hash_warning
)
688 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
691 switch (ELF32_R_TYPE (rel
->r_info
))
693 /* This relocation describes a 16-bit pointer to a function.
694 We may need to allocate a thunk in low memory; reserve memory
698 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
699 splt
= elf_hash_table (info
)->splt
;
702 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
703 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
704 | SEC_READONLY
| SEC_CODE
);
705 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
707 elf_hash_table (info
)->splt
= splt
;
709 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
714 offset
= &h
->plt
.offset
;
717 if (local_plt_offsets
== NULL
)
722 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
723 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
724 if (local_plt_offsets
== NULL
)
726 elf_local_got_offsets (abfd
) = local_plt_offsets
;
728 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
729 local_plt_offsets
[i
] = (bfd_vma
) -1;
731 offset
= &local_plt_offsets
[r_symndx
];
734 if (*offset
== (bfd_vma
) -1)
736 *offset
= splt
->size
;
746 /* This must exist if dynobj is ever set. */
749 m32c_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
750 struct bfd_link_info
*info
)
752 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
753 asection
*splt
= elf_hash_table (info
)->splt
;
755 /* As an extra sanity check, verify that all plt entries have
758 if (dynobj
!= NULL
&& splt
!= NULL
)
760 bfd_byte
*contents
= splt
->contents
;
761 unsigned int i
, size
= splt
->size
;
762 for (i
= 0; i
< size
; i
+= 4)
764 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
773 m32c_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
774 struct bfd_link_info
*info
)
779 if (bfd_link_relocatable (info
))
782 dynobj
= elf_hash_table (info
)->dynobj
;
786 splt
= elf_hash_table (info
)->splt
;
787 BFD_ASSERT (splt
!= NULL
);
789 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
790 if (splt
->contents
== NULL
)
796 /* Function to set the ELF flag bits. */
799 m32c_elf_set_private_flags (bfd
*abfd
, flagword flags
)
801 elf_elfheader (abfd
)->e_flags
= flags
;
802 elf_flags_init (abfd
) = TRUE
;
806 /* Merge backend specific data from an object file to the output
807 object file when linking. */
810 m32c_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
812 bfd
*obfd
= info
->output_bfd
;
813 flagword old_flags
, old_partial
;
814 flagword new_flags
, new_partial
;
815 bfd_boolean error
= FALSE
;
819 new_opt
[0] = old_opt
[0] = '\0';
820 new_flags
= elf_elfheader (ibfd
)->e_flags
;
821 old_flags
= elf_elfheader (obfd
)->e_flags
;
825 ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %s",
826 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
827 bfd_get_filename (ibfd
));
830 if (!elf_flags_init (obfd
))
832 /* First call, no flags set. */
833 elf_flags_init (obfd
) = TRUE
;
834 elf_elfheader (obfd
)->e_flags
= new_flags
;
837 else if (new_flags
== old_flags
)
838 /* Compatible flags are ok. */
841 else /* Possibly incompatible flags. */
843 /* Warn if different cpu is used (allow a specific cpu to override
845 new_partial
= (new_flags
& EF_M32C_CPU_MASK
);
846 old_partial
= (old_flags
& EF_M32C_CPU_MASK
);
847 if (new_partial
== old_partial
)
854 default: strcat (new_opt
, " -m16c"); break;
855 case EF_M32C_CPU_M16C
: strcat (new_opt
, " -m16c"); break;
856 case EF_M32C_CPU_M32C
: strcat (new_opt
, " -m32c"); break;
861 default: strcat (old_opt
, " -m16c"); break;
862 case EF_M32C_CPU_M16C
: strcat (old_opt
, " -m16c"); break;
863 case EF_M32C_CPU_M32C
: strcat (old_opt
, " -m32c"); break;
867 /* Print out any mismatches from above. */
872 /* xgettext:c-format */
873 (_("%B: compiled with %s and linked with modules compiled with %s"),
874 ibfd
, new_opt
, old_opt
);
877 new_flags
&= ~ EF_M32C_ALL_FLAGS
;
878 old_flags
&= ~ EF_M32C_ALL_FLAGS
;
880 /* Warn about any other mismatches. */
881 if (new_flags
!= old_flags
)
885 /* xgettext:c-format */
886 (_("%B: uses different e_flags (%#x) fields"
887 " than previous modules (%#x)"),
888 ibfd
, new_flags
, old_flags
);
893 bfd_set_error (bfd_error_bad_value
);
900 m32c_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
902 FILE *file
= (FILE *) ptr
;
905 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
907 /* Print normal ELF private data. */
908 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
910 flags
= elf_elfheader (abfd
)->e_flags
;
911 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
913 switch (flags
& EF_M32C_CPU_MASK
)
916 case EF_M32C_CPU_M16C
: fprintf (file
, " -m16c"); break;
917 case EF_M32C_CPU_M32C
: fprintf (file
, " -m32c"); break;
924 /* Return the MACH for an e_flags value. */
927 elf32_m32c_machine (bfd
*abfd
)
929 switch (elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
)
931 case EF_M32C_CPU_M16C
: return bfd_mach_m16c
;
932 case EF_M32C_CPU_M32C
: return bfd_mach_m32c
;
935 return bfd_mach_m16c
;
939 m32c_elf_object_p (bfd
*abfd
)
941 bfd_default_set_arch_mach (abfd
, bfd_arch_m32c
,
942 elf32_m32c_machine (abfd
));
949 dump_symtab (bfd
* abfd
, void *internal_syms
, void *external_syms
)
952 Elf_Internal_Sym
*isymbuf
;
953 Elf_Internal_Sym
*isymend
;
954 Elf_Internal_Sym
*isym
;
955 Elf_Internal_Shdr
*symtab_hdr
;
956 bfd_boolean free_internal
= 0, free_external
= 0;
958 char * st_info_stb_str
;
964 internal_syms
= bfd_malloc (1000);
969 external_syms
= bfd_malloc (1000);
973 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
974 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data(abfd
)->s
->sizeof_sym
;
976 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
977 symtab_hdr
->sh_info
, 0,
978 internal_syms
, external_syms
, NULL
);
980 isymbuf
= internal_syms
;
981 isymend
= isymbuf
+ locsymcount
;
983 for (isym
= isymbuf
; isym
< isymend
; isym
++)
985 switch (ELF_ST_TYPE (isym
->st_info
))
988 st_info_str
= "STT_FUNC";
992 st_info_str
= "STT_SECTION";
996 st_info_str
= "STT_FILE";
1000 st_info_str
= "STT_OBJECT";
1004 st_info_str
= "STT_TLS";
1011 switch (ELF_ST_BIND (isym
->st_info
))
1014 st_info_stb_str
= "STB_LOCAL";
1018 st_info_stb_str
= "STB_GLOBAL";
1022 st_info_stb_str
= "";
1025 switch (ELF_ST_VISIBILITY (isym
->st_other
))
1028 st_other_str
= "STV_DEFAULT";
1032 st_other_str
= "STV_INTERNAL";
1036 st_other_str
= "STV_PROTECTED";
1043 switch (isym
->st_shndx
)
1046 st_shndx_str
= "SHN_ABS";
1050 st_shndx_str
= "SHN_COMMON";
1054 st_shndx_str
= "SHN_UNDEF";
1061 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1062 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1064 (unsigned long) isym
->st_value
,
1065 (unsigned long) isym
->st_size
,
1067 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
1069 isym
->st_info
, st_info_str
, st_info_stb_str
,
1070 isym
->st_other
, st_other_str
,
1071 isym
->st_shndx
, st_shndx_str
);
1074 free (internal_syms
);
1076 free (external_syms
);
1080 m32c_get_reloc (long reloc
)
1082 if (0 <= reloc
&& reloc
< R_M32C_max
)
1083 return m32c_elf_howto_table
[reloc
].name
;
1089 /* Handle relaxing. */
1091 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1092 is within the low 64k, remove any entry for it in the plt. */
1094 struct relax_plt_data
1101 m32c_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1103 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1105 if (h
->plt
.offset
!= (bfd_vma
) -1)
1109 if (h
->root
.type
== bfd_link_hash_undefined
1110 || h
->root
.type
== bfd_link_hash_undefweak
)
1113 address
= (h
->root
.u
.def
.section
->output_section
->vma
1114 + h
->root
.u
.def
.section
->output_offset
1115 + h
->root
.u
.def
.value
);
1117 if (address
<= 0xffff)
1120 data
->splt
->size
-= 4;
1121 *data
->again
= TRUE
;
1128 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1129 previously had a plt entry, give it a new entry offset. */
1132 m32c_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1134 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1136 if (h
->plt
.offset
!= (bfd_vma
) -1)
1138 h
->plt
.offset
= *entry
;
1146 m32c_elf_relax_plt_section (asection
*splt
,
1147 struct bfd_link_info
*info
,
1150 struct relax_plt_data relax_plt_data
;
1153 /* Assume nothing changes. */
1156 if (bfd_link_relocatable (info
))
1159 /* Quick check for an empty plt. */
1160 if (splt
->size
== 0)
1163 /* Map across all global symbols; see which ones happen to
1164 fall in the low 64k. */
1165 relax_plt_data
.splt
= splt
;
1166 relax_plt_data
.again
= again
;
1167 elf_link_hash_traverse (elf_hash_table (info
), m32c_relax_plt_check
,
1170 /* Likewise for local symbols, though that's somewhat less convenient
1171 as we have to walk the list of input bfds and swap in symbol data. */
1172 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1174 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1175 Elf_Internal_Shdr
*symtab_hdr
;
1176 Elf_Internal_Sym
*isymbuf
= NULL
;
1179 if (! local_plt_offsets
)
1182 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1183 if (symtab_hdr
->sh_info
!= 0)
1185 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1186 if (isymbuf
== NULL
)
1187 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1188 symtab_hdr
->sh_info
, 0,
1190 if (isymbuf
== NULL
)
1194 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1196 Elf_Internal_Sym
*isym
;
1200 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1203 isym
= &isymbuf
[idx
];
1204 if (isym
->st_shndx
== SHN_UNDEF
)
1206 else if (isym
->st_shndx
== SHN_ABS
)
1207 tsec
= bfd_abs_section_ptr
;
1208 else if (isym
->st_shndx
== SHN_COMMON
)
1209 tsec
= bfd_com_section_ptr
;
1211 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1213 address
= (tsec
->output_section
->vma
1214 + tsec
->output_offset
1216 if (address
<= 0xffff)
1218 local_plt_offsets
[idx
] = -1;
1225 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1227 if (! info
->keep_memory
)
1231 /* Cache the symbols for elf_link_input_bfd. */
1232 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1237 /* If we changed anything, walk the symbols again to reallocate
1238 .plt entry addresses. */
1239 if (*again
&& splt
->size
> 0)
1243 elf_link_hash_traverse (elf_hash_table (info
),
1244 m32c_relax_plt_realloc
, &entry
);
1246 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1248 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1249 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1252 if (! local_plt_offsets
)
1255 for (idx
= 0; idx
< nlocals
; ++idx
)
1256 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1258 local_plt_offsets
[idx
] = entry
;
1268 compare_reloc (const void *e1
, const void *e2
)
1270 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
1271 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
1273 if (i1
->r_offset
== i2
->r_offset
)
1276 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
1279 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1281 m32c_offset_for_reloc (bfd
*abfd
,
1282 Elf_Internal_Rela
*rel
,
1283 Elf_Internal_Shdr
*symtab_hdr
,
1284 Elf_External_Sym_Shndx
*shndx_buf ATTRIBUTE_UNUSED
,
1285 Elf_Internal_Sym
*intsyms
)
1289 /* Get the value of the symbol referred to by the reloc. */
1290 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1292 /* A local symbol. */
1293 Elf_Internal_Sym
*isym
;
1296 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1297 ssec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1298 symval
= isym
->st_value
;
1300 symval
+= ssec
->output_section
->vma
1301 + ssec
->output_offset
;
1306 struct elf_link_hash_entry
*h
;
1308 /* An external symbol. */
1309 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1310 h
= elf_sym_hashes (abfd
)[indx
];
1311 BFD_ASSERT (h
!= NULL
);
1313 if (h
->root
.type
!= bfd_link_hash_defined
1314 && h
->root
.type
!= bfd_link_hash_defweak
)
1315 /* This appears to be a reference to an undefined
1316 symbol. Just ignore it--it will be caught by the
1317 regular reloc processing. */
1320 symval
= (h
->root
.u
.def
.value
1321 + h
->root
.u
.def
.section
->output_section
->vma
1322 + h
->root
.u
.def
.section
->output_offset
);
1327 static int bytes_saved
= 0;
1329 static int bytes_to_reloc
[] = {
1337 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1339 /* Mask for the number of relocs associated with this insn. */
1340 #define RLA_RELOCS 0x0000000f
1341 /* Number of bytes gas emitted (before gas's relaxing) */
1342 #define RLA_NBYTES 0x00000ff0
1344 /* If the displacement is within the given range and the new encoding
1345 differs from the old encoding (the index), then the insn can be
1346 relaxed to the new encoding. */
1349 unsigned int max_disp
;
1350 unsigned char new_encoding
;
1353 static EncodingTable m16c_addr_encodings
[] = {
1354 { 0, 0, 0 }, /* R0 */
1355 { 0, 0, 1 }, /* R1 */
1356 { 0, 0, 2 }, /* R2 */
1357 { 0, 0, 3 }, /* R3 */
1358 { 0, 0, 4 }, /* A0 */
1359 { 0, 0, 5 }, /* A1 */
1360 { 0, 0, 6 }, /* [A0] */
1361 { 0, 0, 7 }, /* [A1] */
1362 { 1, 0, 6 }, /* udsp:8[A0] */
1363 { 1, 0, 7 }, /* udsp:8[A1] */
1364 { 1, 0, 10 }, /* udsp:8[SB] */
1365 { 1, 0, 11 }, /* sdsp:8[FB] */
1366 { 2, 255, 8 }, /* udsp:16[A0] */
1367 { 2, 255, 9 }, /* udsp:16[A1] */
1368 { 2, 255, 10 }, /* udsp:16[SB] */
1369 { 2, 0, 15 }, /* abs:16 */
1372 static EncodingTable m16c_jmpaddr_encodings
[] = {
1373 { 0, 0, 0 }, /* R0 */
1374 { 0, 0, 1 }, /* R1 */
1375 { 0, 0, 2 }, /* R2 */
1376 { 0, 0, 3 }, /* R3 */
1377 { 0, 0, 4 }, /* A0 */
1378 { 0, 0, 5 }, /* A1 */
1379 { 0, 0, 6 }, /* [A0] */
1380 { 0, 0, 7 }, /* [A1] */
1381 { 1, 0, 6 }, /* udsp:8[A0] */
1382 { 1, 0, 7 }, /* udsp:8[A1] */
1383 { 1, 0, 10 }, /* udsp:8[SB] */
1384 { 1, 0, 11 }, /* sdsp:8[FB] */
1385 { 3, 255, 8 }, /* udsp:20[A0] */
1386 { 3, 255, 9 }, /* udsp:20[A1] */
1387 { 2, 255, 10 }, /* udsp:16[SB] */
1388 { 2, 0, 15 }, /* abs:16 */
1391 static EncodingTable m32c_addr_encodings
[] = {
1392 { 0, 0, 0 }, /* [A0] */
1393 { 0, 0, 1 }, /* [A1] */
1394 { 0, 0, 2 }, /* A0 */
1395 { 0, 0, 3 }, /* A1 */
1396 { 1, 0, 0 }, /* udsp:8[A0] */
1397 { 1, 0, 1 }, /* udsp:8[A1] */
1398 { 1, 0, 6 }, /* udsp:8[SB] */
1399 { 1, 0, 7 }, /* sdsp:8[FB] */
1400 { 2, 255, 4 }, /* udsp:16[A0] */
1401 { 2, 255, 5 }, /* udsp:16[A1] */
1402 { 2, 255, 6 }, /* udsp:16[SB] */
1403 { 2, 127, 7 }, /* sdsp:16[FB] */
1404 { 3, 65535, 8 }, /* udsp:24[A0] */
1405 { 3, 65535, 9 }, /* udsp:24[A1] */
1406 { 3, 65535, 15 }, /* abs24 */
1407 { 2, 0, 15 }, /* abs16 */
1408 { 0, 0, 16 }, /* R2 */
1409 { 0, 0, 17 }, /* R3 */
1410 { 0, 0, 18 }, /* R0 */
1411 { 0, 0, 19 }, /* R1 */
1427 m32c_elf_relax_section
1430 struct bfd_link_info
* link_info
,
1431 bfd_boolean
* again
)
1433 Elf_Internal_Shdr
*symtab_hdr
;
1434 Elf_Internal_Shdr
*shndx_hdr
;
1435 Elf_Internal_Rela
*internal_relocs
;
1436 Elf_Internal_Rela
*free_relocs
= NULL
;
1437 Elf_Internal_Rela
*irel
, *irelend
, *srel
;
1438 bfd_byte
* contents
= NULL
;
1439 bfd_byte
* free_contents
= NULL
;
1440 Elf_Internal_Sym
*intsyms
= NULL
;
1441 Elf_Internal_Sym
*free_intsyms
= NULL
;
1442 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1445 if (abfd
== elf_hash_table (link_info
)->dynobj
1446 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1447 && strcmp (sec
->name
, ".plt") == 0)
1448 return m32c_elf_relax_plt_section (sec
, link_info
, again
);
1450 /* Assume nothing changes. */
1453 machine
= elf32_m32c_machine (abfd
);
1455 /* We don't have to do anything for a relocatable link, if
1456 this section does not have relocs, or if this is not a
1458 if (bfd_link_relocatable (link_info
)
1459 || (sec
->flags
& SEC_RELOC
) == 0
1460 || sec
->reloc_count
== 0
1461 || (sec
->flags
& SEC_CODE
) == 0)
1464 symtab_hdr
= & elf_symtab_hdr (abfd
);
1465 if (elf_symtab_shndx_list (abfd
))
1466 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
1470 /* Get the section contents. */
1471 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1472 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1473 /* Go get them off disk. */
1474 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1477 /* Read this BFD's symbols. */
1478 /* Get cached copy if it exists. */
1479 if (symtab_hdr
->contents
!= NULL
)
1481 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1485 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
1486 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1489 if (shndx_hdr
&& shndx_hdr
->sh_size
!= 0)
1493 amt
= symtab_hdr
->sh_info
;
1494 amt
*= sizeof (Elf_External_Sym_Shndx
);
1495 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1496 if (shndx_buf
== NULL
)
1498 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1499 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
1501 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1504 /* Get a copy of the native relocations. */
1505 internal_relocs
= (_bfd_elf_link_read_relocs
1506 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
1507 link_info
->keep_memory
));
1508 if (internal_relocs
== NULL
)
1510 if (! link_info
->keep_memory
)
1511 free_relocs
= internal_relocs
;
1513 /* The RL_ relocs must be just before the operand relocs they go
1514 with, so we must sort them to guarantee this. */
1515 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
1518 /* Walk through them looking for relaxing opportunities. */
1519 irelend
= internal_relocs
+ sec
->reloc_count
;
1521 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1524 unsigned char *insn
, *gap
, *einsn
;
1526 bfd_signed_vma pcrel
;
1532 EncodingTable
*enctbl
;
1535 if (ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_JUMP
1536 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_1ADDR
1537 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_2ADDR
)
1542 /* There will always be room for the relaxed insn, since it is smaller
1543 than the one it would replace. */
1544 BFD_ASSERT (irel
->r_offset
< sec
->size
);
1546 insn
= contents
+ irel
->r_offset
;
1547 relax_relocs
= irel
->r_addend
% 16;
1549 /* Ok, we only have three relocs we care about, and they're all
1550 fake. The lower four bits of the addend is always the number
1551 of following relocs (hence the qsort above) that are assigned
1552 to this opcode. The next 8 bits of the addend indicates the
1553 number of bytes in the insn. We use the rest of them
1554 ourselves as flags for the more expensive operations (defines
1555 above). The three relocs are:
1557 RL_JUMP: This marks all direct jump insns. We check the
1558 displacement and replace them with shorter jumps if
1559 they're in range. We also use this to find JMP.S
1560 insns and manually shorten them when we delete bytes.
1561 We have to decode these insns to figure out what to
1564 RL_1ADDR: This is a :G or :Q insn, which has a single
1565 "standard" operand. We have to extract the type
1566 field, see if it's a wide displacement, then figure
1567 out if we can replace it with a narrow displacement.
1568 We don't have to decode these insns.
1570 RL_2ADDR: Similarly, but two "standard" operands. Note that
1571 r_addend may still be 1, as standard operands don't
1572 always have displacements. Gas shouldn't give us one
1573 with zero operands, but since we don't know which one
1574 has the displacement, we check them both anyway.
1576 These all point to the beginning of the insn itself, not the
1579 Note that we only relax one step at a time, relying on the
1580 linker to call us repeatedly. Thus, there is no code for
1581 JMP.A->JMP.B although that will happen in two steps.
1582 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1585 /* Get the value of the symbol referred to by the reloc. Just
1586 in case this is the last reloc in the list, use the RL's
1587 addend to choose between this reloc (no addend) or the next
1588 (yes addend, which means at least one following reloc). */
1589 srel
= irel
+ (relax_relocs
? 1 : 0);
1590 symval
= OFFSET_FOR_RELOC (srel
);
1592 /* Setting gap_size nonzero is the flag which means "something
1596 new_type
= ELF32_R_TYPE(srel
->r_info
);
1598 pc
= sec
->output_section
->vma
+ sec
->output_offset
1600 pcrel
= symval
- pc
+ srel
->r_addend
;
1602 if (machine
== bfd_mach_m16c
)
1606 switch (ELF32_R_TYPE(irel
->r_info
))
1609 case R_M32C_RL_JUMP
:
1612 case 0xfe: /* jmp.b */
1613 if (pcrel
>= 2 && pcrel
<= 9)
1615 /* Relax JMP.B -> JMP.S. We need to get rid of
1616 the following reloc though. */
1617 insn
[0] = 0x60 | (pcrel
- 2);
1618 new_type
= R_M32C_NONE
;
1619 irel
->r_addend
= 0x10;
1625 case 0xf4: /* jmp.w */
1626 /* 128 is allowed because it will be one byte closer
1627 after relaxing. Likewise for all other pc-rel
1629 if (pcrel
<= 128 && pcrel
>= -128)
1631 /* Relax JMP.W -> JMP.B */
1634 new_type
= R_M32C_8_PCREL
;
1640 case 0xfc: /* jmp.a */
1641 if (pcrel
<= 32768 && pcrel
>= -32768)
1643 /* Relax JMP.A -> JMP.W */
1647 new_type
= R_M32C_16_PCREL
;
1653 case 0xfd: /* jsr.a */
1654 if (pcrel
<= 32768 && pcrel
>= -32768)
1656 /* Relax JSR.A -> JSR.W */
1660 new_type
= R_M32C_16_PCREL
;
1668 case R_M32C_RL_2ADDR
:
1669 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1671 enctbl
= m16c_addr_encodings
;
1673 enc
= (insn
[1] >> 4) & 0x0f;
1676 if (srel
->r_offset
== irel
->r_offset
+ posn
1677 && e
->new_encoding
!= enc
1678 && symval
<= e
->max_disp
)
1681 insn
[1] |= e
->new_encoding
<< 4;
1682 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1683 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1684 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1687 if (relax_relocs
== 2)
1693 case R_M32C_RL_1ADDR
:
1694 /* xxxx xxxx xxxx dest [disp] */
1696 enctbl
= m16c_addr_encodings
;
1699 /* Check the opcode for jumps. We know it's safe to
1700 do this because all 2ADDR insns are at least two
1702 enc
= insn
[0] * 256 + insn
[1];
1709 enctbl
= m16c_jmpaddr_encodings
;
1713 /* srel, posn, and enc must be set here. */
1715 symval
= OFFSET_FOR_RELOC (srel
);
1716 enc
= insn
[1] & 0x0f;
1719 if (srel
->r_offset
== irel
->r_offset
+ posn
1720 && e
->new_encoding
!= enc
1721 && symval
<= e
->max_disp
)
1724 insn
[1] |= e
->new_encoding
;
1725 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1726 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1727 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1733 } /* Ends switch (reloc type) for m16c. */
1735 else /* machine == bfd_mach_m32c */
1739 switch (ELF32_R_TYPE(irel
->r_info
))
1742 case R_M32C_RL_JUMP
:
1745 case 0xbb: /* jmp.b */
1746 if (pcrel
>= 2 && pcrel
<= 9)
1749 /* Relax JMP.B -> JMP.S. We need to get rid of
1750 the following reloc though. */
1751 insn
[0] = 0x4a | ((p
<< 3) & 0x30) | (p
& 1);
1752 new_type
= R_M32C_NONE
;
1753 irel
->r_addend
= 0x10;
1759 case 0xce: /* jmp.w */
1760 if (pcrel
<= 128 && pcrel
>= -128)
1762 /* Relax JMP.W -> JMP.B */
1765 new_type
= R_M32C_8_PCREL
;
1771 case 0xcc: /* jmp.a */
1772 if (pcrel
<= 32768 && pcrel
>= -32768)
1774 /* Relax JMP.A -> JMP.W */
1778 new_type
= R_M32C_16_PCREL
;
1784 case 0xcd: /* jsr.a */
1785 if (pcrel
<= 32768 && pcrel
>= -32768)
1787 /* Relax JSR.A -> JSR.W */
1791 new_type
= R_M32C_16_PCREL
;
1799 case R_M32C_RL_2ADDR
:
1800 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1806 /* prefix; remove it as far as the RL reloc is concerned. */
1811 enctbl
= m32c_addr_encodings
;
1812 enc
= ((einsn
[0] & 0x70) >> 2) | ((einsn
[1] & 0x30) >> 4);
1815 if (srel
->r_offset
== irel
->r_offset
+ posn
1816 && e
->new_encoding
!= enc
1817 && symval
<= e
->max_disp
)
1820 einsn
[0] |= (e
->new_encoding
& 0x1c) << 2;
1822 einsn
[1] |= (e
->new_encoding
& 0x03) << 4;
1823 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1824 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1825 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1828 if (relax_relocs
== 2)
1834 case R_M32C_RL_1ADDR
:
1835 /* xxxx DDDx DDxx xxxx [disp] */
1841 /* prefix; remove it as far as the RL reloc is concerned. */
1846 enctbl
= m32c_addr_encodings
;
1849 /* srel, posn, and enc must be set here. */
1851 symval
= OFFSET_FOR_RELOC (srel
);
1852 enc
= ((einsn
[0] & 0x0e) << 1) | ((einsn
[1] & 0xc0) >> 6);
1855 if (srel
->r_offset
== irel
->r_offset
+ posn
1856 && e
->new_encoding
!= enc
1857 && symval
<= e
->max_disp
)
1860 einsn
[0] |= (e
->new_encoding
& 0x1c) >> 1;
1862 einsn
[1] |= (e
->new_encoding
& 0x03) << 6;
1863 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1864 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1865 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1871 } /* Ends switch (reloc type) for m32c. */
1879 srel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (srel
->r_info
), new_type
);
1881 /* Note that we've changed the relocs, section contents, etc. */
1882 elf_section_data (sec
)->relocs
= internal_relocs
;
1885 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1886 free_contents
= NULL
;
1888 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1889 free_intsyms
= NULL
;
1891 bytes_saved
+= gap_size
;
1893 if (! m32c_elf_relax_delete_bytes(abfd
, sec
, gap
- contents
, gap_size
))
1896 } /* next relocation */
1898 if (free_relocs
!= NULL
)
1904 if (free_contents
!= NULL
)
1906 if (! link_info
->keep_memory
)
1907 free (free_contents
);
1908 /* Cache the section contents for elf_link_input_bfd. */
1910 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1912 free_contents
= NULL
;
1915 if (shndx_buf
!= NULL
)
1917 shndx_hdr
->contents
= NULL
;
1921 if (free_intsyms
!= NULL
)
1923 if (! link_info
->keep_memory
)
1924 free (free_intsyms
);
1925 /* Cache the symbols for elf_link_input_bfd. */
1928 symtab_hdr
->contents
= NULL
/* (unsigned char *) intsyms*/;
1931 free_intsyms
= NULL
;
1937 if (free_relocs
!= NULL
)
1939 if (free_contents
!= NULL
)
1940 free (free_contents
);
1941 if (shndx_buf
!= NULL
)
1943 shndx_hdr
->contents
= NULL
;
1946 if (free_intsyms
!= NULL
)
1947 free (free_intsyms
);
1951 /* Delete some bytes from a section while relaxing. */
1954 m32c_elf_relax_delete_bytes
1960 Elf_Internal_Shdr
*symtab_hdr
;
1961 Elf_Internal_Shdr
*shndx_hdr
;
1964 Elf_Internal_Rela
*irel
;
1965 Elf_Internal_Rela
*irelend
;
1967 Elf_Internal_Sym
*isym
;
1968 Elf_Internal_Sym
*isymend
;
1969 Elf_Internal_Sym
*intsyms
;
1970 Elf_External_Sym_Shndx
*shndx_buf
;
1971 Elf_External_Sym_Shndx
*shndx
;
1972 struct elf_link_hash_entry
** sym_hashes
;
1973 struct elf_link_hash_entry
** end_hashes
;
1974 unsigned int symcount
;
1976 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1980 irel
= elf_section_data (sec
)->relocs
;
1981 irelend
= irel
+ sec
->reloc_count
;
1983 /* Actually delete the bytes. */
1984 memmove (contents
+ addr
, contents
+ addr
+ count
, (size_t) (toaddr
- addr
- count
));
1987 /* Adjust all the relocs. */
1988 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1990 /* Get the new reloc address. */
1991 if (irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
)
1992 irel
->r_offset
-= count
;
1994 if (ELF32_R_TYPE(irel
->r_info
) == R_M32C_RL_JUMP
1995 && irel
->r_addend
== 0x10 /* one byte insn, no relocs */
1996 && irel
->r_offset
+ 1 < addr
1997 && irel
->r_offset
+ 7 > addr
)
2000 unsigned char *insn
= &contents
[irel
->r_offset
];
2002 /* This is a JMP.S, which we have to manually update. */
2003 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2005 if ((*insn
& 0xf8) != 0x60)
2011 if ((*insn
& 0xce) != 0x4a)
2013 disp
= ((disp
& 0x30) >> 3) | (disp
& 1);
2015 if (irel
->r_offset
+ disp
+ 2 >= addr
+count
)
2018 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2020 *insn
= (*insn
& 0xf8) | disp
;
2024 *insn
= (*insn
& 0xce) | ((disp
& 6) << 3) | (disp
& 1);
2030 /* Adjust the local symbols defined in this section. */
2031 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
2032 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2034 isymend
= isym
+ symtab_hdr
->sh_info
;
2036 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2037 if (elf_symtab_shndx_list (abfd
))
2039 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
2040 shndx_buf
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
2049 for (; isym
< isymend
; isym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
2051 /* If the symbol is in the range of memory we just moved, we
2052 have to adjust its value. */
2053 if ((int) isym
->st_shndx
== sec_shndx
2054 && isym
->st_value
> addr
2055 && isym
->st_value
< toaddr
)
2057 isym
->st_value
-= count
;
2059 /* If the symbol *spans* the bytes we just deleted (i.e. it's
2060 *end* is in the moved bytes but it's *start* isn't), then we
2061 must adjust its size. */
2062 if ((int) isym
->st_shndx
== sec_shndx
2063 && isym
->st_value
< addr
2064 && isym
->st_value
+ isym
->st_size
> addr
2065 && isym
->st_value
+ isym
->st_size
< toaddr
)
2067 isym
->st_size
-= count
;
2071 /* Now adjust the global symbols defined in this section. */
2072 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2073 - symtab_hdr
->sh_info
);
2074 sym_hashes
= elf_sym_hashes (abfd
);
2075 // sym_hashes += symtab_hdr->sh_info;
2076 end_hashes
= sym_hashes
+ symcount
;
2078 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2080 struct elf_link_hash_entry
* sym_hash
= * sym_hashes
;
2083 (sym_hash
->root
.type
== bfd_link_hash_defined
2084 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2085 && sym_hash
->root
.u
.def
.section
== sec
)
2087 if (sym_hash
->root
.u
.def
.value
> addr
2088 && sym_hash
->root
.u
.def
.value
< toaddr
)
2090 sym_hash
->root
.u
.def
.value
-= count
;
2092 if (sym_hash
->root
.u
.def
.value
< addr
2093 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2094 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
2096 sym_hash
->size
-= count
;
2104 /* This is for versions of gcc prior to 4.3. */
2106 _bfd_m32c_elf_eh_frame_address_size (bfd
*abfd
,
2107 const 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"