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
;
690 /* PR15323, ref flags aren't set for references in the same
692 h
->root
.non_ir_ref
= 1;
695 switch (ELF32_R_TYPE (rel
->r_info
))
697 /* This relocation describes a 16-bit pointer to a function.
698 We may need to allocate a thunk in low memory; reserve memory
702 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
703 splt
= elf_hash_table (info
)->splt
;
706 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
707 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
708 | SEC_READONLY
| SEC_CODE
);
709 splt
= bfd_make_section_anyway_with_flags (dynobj
, ".plt",
711 elf_hash_table (info
)->splt
= splt
;
713 || ! bfd_set_section_alignment (dynobj
, splt
, 1))
718 offset
= &h
->plt
.offset
;
721 if (local_plt_offsets
== NULL
)
726 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
727 local_plt_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
728 if (local_plt_offsets
== NULL
)
730 elf_local_got_offsets (abfd
) = local_plt_offsets
;
732 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
733 local_plt_offsets
[i
] = (bfd_vma
) -1;
735 offset
= &local_plt_offsets
[r_symndx
];
738 if (*offset
== (bfd_vma
) -1)
740 *offset
= splt
->size
;
750 /* This must exist if dynobj is ever set. */
753 m32c_elf_finish_dynamic_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
754 struct bfd_link_info
*info
)
756 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
757 asection
*splt
= elf_hash_table (info
)->splt
;
759 /* As an extra sanity check, verify that all plt entries have
762 if (dynobj
!= NULL
&& splt
!= NULL
)
764 bfd_byte
*contents
= splt
->contents
;
765 unsigned int i
, size
= splt
->size
;
766 for (i
= 0; i
< size
; i
+= 4)
768 unsigned int x
= bfd_get_32 (dynobj
, contents
+ i
);
777 m32c_elf_always_size_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
778 struct bfd_link_info
*info
)
783 if (bfd_link_relocatable (info
))
786 dynobj
= elf_hash_table (info
)->dynobj
;
790 splt
= elf_hash_table (info
)->splt
;
791 BFD_ASSERT (splt
!= NULL
);
793 splt
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, splt
->size
);
794 if (splt
->contents
== NULL
)
800 /* Function to set the ELF flag bits. */
803 m32c_elf_set_private_flags (bfd
*abfd
, flagword flags
)
805 elf_elfheader (abfd
)->e_flags
= flags
;
806 elf_flags_init (abfd
) = TRUE
;
810 /* Merge backend specific data from an object file to the output
811 object file when linking. */
814 m32c_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
816 bfd
*obfd
= info
->output_bfd
;
817 flagword old_flags
, old_partial
;
818 flagword new_flags
, new_partial
;
819 bfd_boolean error
= FALSE
;
823 new_opt
[0] = old_opt
[0] = '\0';
824 new_flags
= elf_elfheader (ibfd
)->e_flags
;
825 old_flags
= elf_elfheader (obfd
)->e_flags
;
829 ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
830 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
831 bfd_get_filename (ibfd
));
834 if (!elf_flags_init (obfd
))
836 /* First call, no flags set. */
837 elf_flags_init (obfd
) = TRUE
;
838 elf_elfheader (obfd
)->e_flags
= new_flags
;
841 else if (new_flags
== old_flags
)
842 /* Compatible flags are ok. */
845 else /* Possibly incompatible flags. */
847 /* Warn if different cpu is used (allow a specific cpu to override
849 new_partial
= (new_flags
& EF_M32C_CPU_MASK
);
850 old_partial
= (old_flags
& EF_M32C_CPU_MASK
);
851 if (new_partial
== old_partial
)
858 default: strcat (new_opt
, " -m16c"); break;
859 case EF_M32C_CPU_M16C
: strcat (new_opt
, " -m16c"); break;
860 case EF_M32C_CPU_M32C
: strcat (new_opt
, " -m32c"); break;
865 default: strcat (old_opt
, " -m16c"); break;
866 case EF_M32C_CPU_M16C
: strcat (old_opt
, " -m16c"); break;
867 case EF_M32C_CPU_M32C
: strcat (old_opt
, " -m32c"); break;
871 /* Print out any mismatches from above. */
876 /* xgettext:c-format */
877 (_("%s: compiled with %s and linked with modules compiled with %s"),
878 bfd_get_filename (ibfd
), new_opt
, old_opt
);
881 new_flags
&= ~ EF_M32C_ALL_FLAGS
;
882 old_flags
&= ~ EF_M32C_ALL_FLAGS
;
884 /* Warn about any other mismatches. */
885 if (new_flags
!= old_flags
)
889 /* xgettext:c-format */
890 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
891 bfd_get_filename (ibfd
), (long)new_flags
, (long)old_flags
);
896 bfd_set_error (bfd_error_bad_value
);
903 m32c_elf_print_private_bfd_data (bfd
*abfd
, void *ptr
)
905 FILE *file
= (FILE *) ptr
;
908 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
910 /* Print normal ELF private data. */
911 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
913 flags
= elf_elfheader (abfd
)->e_flags
;
914 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
916 switch (flags
& EF_M32C_CPU_MASK
)
919 case EF_M32C_CPU_M16C
: fprintf (file
, " -m16c"); break;
920 case EF_M32C_CPU_M32C
: fprintf (file
, " -m32c"); break;
927 /* Return the MACH for an e_flags value. */
930 elf32_m32c_machine (bfd
*abfd
)
932 switch (elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
)
934 case EF_M32C_CPU_M16C
: return bfd_mach_m16c
;
935 case EF_M32C_CPU_M32C
: return bfd_mach_m32c
;
938 return bfd_mach_m16c
;
942 m32c_elf_object_p (bfd
*abfd
)
944 bfd_default_set_arch_mach (abfd
, bfd_arch_m32c
,
945 elf32_m32c_machine (abfd
));
952 dump_symtab (bfd
* abfd
, void *internal_syms
, void *external_syms
)
955 Elf_Internal_Sym
*isymbuf
;
956 Elf_Internal_Sym
*isymend
;
957 Elf_Internal_Sym
*isym
;
958 Elf_Internal_Shdr
*symtab_hdr
;
959 bfd_boolean free_internal
= 0, free_external
= 0;
961 char * st_info_stb_str
;
967 internal_syms
= bfd_malloc (1000);
972 external_syms
= bfd_malloc (1000);
976 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
977 locsymcount
= symtab_hdr
->sh_size
/ get_elf_backend_data(abfd
)->s
->sizeof_sym
;
979 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
980 symtab_hdr
->sh_info
, 0,
981 internal_syms
, external_syms
, NULL
);
983 isymbuf
= internal_syms
;
984 isymend
= isymbuf
+ locsymcount
;
986 for (isym
= isymbuf
; isym
< isymend
; isym
++)
988 switch (ELF_ST_TYPE (isym
->st_info
))
991 st_info_str
= "STT_FUNC";
995 st_info_str
= "STT_SECTION";
999 st_info_str
= "STT_FILE";
1003 st_info_str
= "STT_OBJECT";
1007 st_info_str
= "STT_TLS";
1014 switch (ELF_ST_BIND (isym
->st_info
))
1017 st_info_stb_str
= "STB_LOCAL";
1021 st_info_stb_str
= "STB_GLOBAL";
1025 st_info_stb_str
= "";
1028 switch (ELF_ST_VISIBILITY (isym
->st_other
))
1031 st_other_str
= "STV_DEFAULT";
1035 st_other_str
= "STV_INTERNAL";
1039 st_other_str
= "STV_PROTECTED";
1046 switch (isym
->st_shndx
)
1049 st_shndx_str
= "SHN_ABS";
1053 st_shndx_str
= "SHN_COMMON";
1057 st_shndx_str
= "SHN_UNDEF";
1064 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1065 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1067 (unsigned long) isym
->st_value
,
1068 (unsigned long) isym
->st_size
,
1070 bfd_elf_string_from_elf_section (abfd
, symtab_hdr
->sh_link
,
1072 isym
->st_info
, st_info_str
, st_info_stb_str
,
1073 isym
->st_other
, st_other_str
,
1074 isym
->st_shndx
, st_shndx_str
);
1077 free (internal_syms
);
1079 free (external_syms
);
1083 m32c_get_reloc (long reloc
)
1085 if (0 <= reloc
&& reloc
< R_M32C_max
)
1086 return m32c_elf_howto_table
[reloc
].name
;
1092 /* Handle relaxing. */
1094 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1095 is within the low 64k, remove any entry for it in the plt. */
1097 struct relax_plt_data
1104 m32c_relax_plt_check (struct elf_link_hash_entry
*h
, void * xdata
)
1106 struct relax_plt_data
*data
= (struct relax_plt_data
*) xdata
;
1108 if (h
->plt
.offset
!= (bfd_vma
) -1)
1112 if (h
->root
.type
== bfd_link_hash_undefined
1113 || h
->root
.type
== bfd_link_hash_undefweak
)
1116 address
= (h
->root
.u
.def
.section
->output_section
->vma
1117 + h
->root
.u
.def
.section
->output_offset
1118 + h
->root
.u
.def
.value
);
1120 if (address
<= 0xffff)
1123 data
->splt
->size
-= 4;
1124 *data
->again
= TRUE
;
1131 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1132 previously had a plt entry, give it a new entry offset. */
1135 m32c_relax_plt_realloc (struct elf_link_hash_entry
*h
, void * xdata
)
1137 bfd_vma
*entry
= (bfd_vma
*) xdata
;
1139 if (h
->plt
.offset
!= (bfd_vma
) -1)
1141 h
->plt
.offset
= *entry
;
1149 m32c_elf_relax_plt_section (asection
*splt
,
1150 struct bfd_link_info
*info
,
1153 struct relax_plt_data relax_plt_data
;
1156 /* Assume nothing changes. */
1159 if (bfd_link_relocatable (info
))
1162 /* Quick check for an empty plt. */
1163 if (splt
->size
== 0)
1166 /* Map across all global symbols; see which ones happen to
1167 fall in the low 64k. */
1168 relax_plt_data
.splt
= splt
;
1169 relax_plt_data
.again
= again
;
1170 elf_link_hash_traverse (elf_hash_table (info
), m32c_relax_plt_check
,
1173 /* Likewise for local symbols, though that's somewhat less convenient
1174 as we have to walk the list of input bfds and swap in symbol data. */
1175 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1177 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1178 Elf_Internal_Shdr
*symtab_hdr
;
1179 Elf_Internal_Sym
*isymbuf
= NULL
;
1182 if (! local_plt_offsets
)
1185 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
1186 if (symtab_hdr
->sh_info
!= 0)
1188 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1189 if (isymbuf
== NULL
)
1190 isymbuf
= bfd_elf_get_elf_syms (ibfd
, symtab_hdr
,
1191 symtab_hdr
->sh_info
, 0,
1193 if (isymbuf
== NULL
)
1197 for (idx
= 0; idx
< symtab_hdr
->sh_info
; ++idx
)
1199 Elf_Internal_Sym
*isym
;
1203 if (local_plt_offsets
[idx
] == (bfd_vma
) -1)
1206 isym
= &isymbuf
[idx
];
1207 if (isym
->st_shndx
== SHN_UNDEF
)
1209 else if (isym
->st_shndx
== SHN_ABS
)
1210 tsec
= bfd_abs_section_ptr
;
1211 else if (isym
->st_shndx
== SHN_COMMON
)
1212 tsec
= bfd_com_section_ptr
;
1214 tsec
= bfd_section_from_elf_index (ibfd
, isym
->st_shndx
);
1216 address
= (tsec
->output_section
->vma
1217 + tsec
->output_offset
1219 if (address
<= 0xffff)
1221 local_plt_offsets
[idx
] = -1;
1228 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1230 if (! info
->keep_memory
)
1234 /* Cache the symbols for elf_link_input_bfd. */
1235 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1240 /* If we changed anything, walk the symbols again to reallocate
1241 .plt entry addresses. */
1242 if (*again
&& splt
->size
> 0)
1246 elf_link_hash_traverse (elf_hash_table (info
),
1247 m32c_relax_plt_realloc
, &entry
);
1249 for (ibfd
= info
->input_bfds
; ibfd
; ibfd
= ibfd
->link
.next
)
1251 bfd_vma
*local_plt_offsets
= elf_local_got_offsets (ibfd
);
1252 unsigned int nlocals
= elf_tdata (ibfd
)->symtab_hdr
.sh_info
;
1255 if (! local_plt_offsets
)
1258 for (idx
= 0; idx
< nlocals
; ++idx
)
1259 if (local_plt_offsets
[idx
] != (bfd_vma
) -1)
1261 local_plt_offsets
[idx
] = entry
;
1271 compare_reloc (const void *e1
, const void *e2
)
1273 const Elf_Internal_Rela
*i1
= (const Elf_Internal_Rela
*) e1
;
1274 const Elf_Internal_Rela
*i2
= (const Elf_Internal_Rela
*) e2
;
1276 if (i1
->r_offset
== i2
->r_offset
)
1279 return i1
->r_offset
< i2
->r_offset
? -1 : 1;
1282 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1284 m32c_offset_for_reloc (bfd
*abfd
,
1285 Elf_Internal_Rela
*rel
,
1286 Elf_Internal_Shdr
*symtab_hdr
,
1287 Elf_External_Sym_Shndx
*shndx_buf ATTRIBUTE_UNUSED
,
1288 Elf_Internal_Sym
*intsyms
)
1292 /* Get the value of the symbol referred to by the reloc. */
1293 if (ELF32_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
1295 /* A local symbol. */
1296 Elf_Internal_Sym
*isym
;
1299 isym
= intsyms
+ ELF32_R_SYM (rel
->r_info
);
1300 ssec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1301 symval
= isym
->st_value
;
1303 symval
+= ssec
->output_section
->vma
1304 + ssec
->output_offset
;
1309 struct elf_link_hash_entry
*h
;
1311 /* An external symbol. */
1312 indx
= ELF32_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
1313 h
= elf_sym_hashes (abfd
)[indx
];
1314 BFD_ASSERT (h
!= NULL
);
1316 if (h
->root
.type
!= bfd_link_hash_defined
1317 && h
->root
.type
!= bfd_link_hash_defweak
)
1318 /* This appears to be a reference to an undefined
1319 symbol. Just ignore it--it will be caught by the
1320 regular reloc processing. */
1323 symval
= (h
->root
.u
.def
.value
1324 + h
->root
.u
.def
.section
->output_section
->vma
1325 + h
->root
.u
.def
.section
->output_offset
);
1330 static int bytes_saved
= 0;
1332 static int bytes_to_reloc
[] = {
1340 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1342 /* Mask for the number of relocs associated with this insn. */
1343 #define RLA_RELOCS 0x0000000f
1344 /* Number of bytes gas emitted (before gas's relaxing) */
1345 #define RLA_NBYTES 0x00000ff0
1347 /* If the displacement is within the given range and the new encoding
1348 differs from the old encoding (the index), then the insn can be
1349 relaxed to the new encoding. */
1352 unsigned int max_disp
;
1353 unsigned char new_encoding
;
1356 static EncodingTable m16c_addr_encodings
[] = {
1357 { 0, 0, 0 }, /* R0 */
1358 { 0, 0, 1 }, /* R1 */
1359 { 0, 0, 2 }, /* R2 */
1360 { 0, 0, 3 }, /* R3 */
1361 { 0, 0, 4 }, /* A0 */
1362 { 0, 0, 5 }, /* A1 */
1363 { 0, 0, 6 }, /* [A0] */
1364 { 0, 0, 7 }, /* [A1] */
1365 { 1, 0, 6 }, /* udsp:8[A0] */
1366 { 1, 0, 7 }, /* udsp:8[A1] */
1367 { 1, 0, 10 }, /* udsp:8[SB] */
1368 { 1, 0, 11 }, /* sdsp:8[FB] */
1369 { 2, 255, 8 }, /* udsp:16[A0] */
1370 { 2, 255, 9 }, /* udsp:16[A1] */
1371 { 2, 255, 10 }, /* udsp:16[SB] */
1372 { 2, 0, 15 }, /* abs:16 */
1375 static EncodingTable m16c_jmpaddr_encodings
[] = {
1376 { 0, 0, 0 }, /* R0 */
1377 { 0, 0, 1 }, /* R1 */
1378 { 0, 0, 2 }, /* R2 */
1379 { 0, 0, 3 }, /* R3 */
1380 { 0, 0, 4 }, /* A0 */
1381 { 0, 0, 5 }, /* A1 */
1382 { 0, 0, 6 }, /* [A0] */
1383 { 0, 0, 7 }, /* [A1] */
1384 { 1, 0, 6 }, /* udsp:8[A0] */
1385 { 1, 0, 7 }, /* udsp:8[A1] */
1386 { 1, 0, 10 }, /* udsp:8[SB] */
1387 { 1, 0, 11 }, /* sdsp:8[FB] */
1388 { 3, 255, 8 }, /* udsp:20[A0] */
1389 { 3, 255, 9 }, /* udsp:20[A1] */
1390 { 2, 255, 10 }, /* udsp:16[SB] */
1391 { 2, 0, 15 }, /* abs:16 */
1394 static EncodingTable m32c_addr_encodings
[] = {
1395 { 0, 0, 0 }, /* [A0] */
1396 { 0, 0, 1 }, /* [A1] */
1397 { 0, 0, 2 }, /* A0 */
1398 { 0, 0, 3 }, /* A1 */
1399 { 1, 0, 0 }, /* udsp:8[A0] */
1400 { 1, 0, 1 }, /* udsp:8[A1] */
1401 { 1, 0, 6 }, /* udsp:8[SB] */
1402 { 1, 0, 7 }, /* sdsp:8[FB] */
1403 { 2, 255, 4 }, /* udsp:16[A0] */
1404 { 2, 255, 5 }, /* udsp:16[A1] */
1405 { 2, 255, 6 }, /* udsp:16[SB] */
1406 { 2, 127, 7 }, /* sdsp:16[FB] */
1407 { 3, 65535, 8 }, /* udsp:24[A0] */
1408 { 3, 65535, 9 }, /* udsp:24[A1] */
1409 { 3, 65535, 15 }, /* abs24 */
1410 { 2, 0, 15 }, /* abs16 */
1411 { 0, 0, 16 }, /* R2 */
1412 { 0, 0, 17 }, /* R3 */
1413 { 0, 0, 18 }, /* R0 */
1414 { 0, 0, 19 }, /* R1 */
1430 m32c_elf_relax_section
1433 struct bfd_link_info
* link_info
,
1434 bfd_boolean
* again
)
1436 Elf_Internal_Shdr
*symtab_hdr
;
1437 Elf_Internal_Shdr
*shndx_hdr
;
1438 Elf_Internal_Rela
*internal_relocs
;
1439 Elf_Internal_Rela
*free_relocs
= NULL
;
1440 Elf_Internal_Rela
*irel
, *irelend
, *srel
;
1441 bfd_byte
* contents
= NULL
;
1442 bfd_byte
* free_contents
= NULL
;
1443 Elf_Internal_Sym
*intsyms
= NULL
;
1444 Elf_Internal_Sym
*free_intsyms
= NULL
;
1445 Elf_External_Sym_Shndx
*shndx_buf
= NULL
;
1448 if (abfd
== elf_hash_table (link_info
)->dynobj
1449 && (sec
->flags
& SEC_LINKER_CREATED
) != 0
1450 && strcmp (sec
->name
, ".plt") == 0)
1451 return m32c_elf_relax_plt_section (sec
, link_info
, again
);
1453 /* Assume nothing changes. */
1456 machine
= elf32_m32c_machine (abfd
);
1458 /* We don't have to do anything for a relocatable link, if
1459 this section does not have relocs, or if this is not a
1461 if (bfd_link_relocatable (link_info
)
1462 || (sec
->flags
& SEC_RELOC
) == 0
1463 || sec
->reloc_count
== 0
1464 || (sec
->flags
& SEC_CODE
) == 0)
1467 symtab_hdr
= & elf_symtab_hdr (abfd
);
1468 if (elf_symtab_shndx_list (abfd
))
1469 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
1473 /* Get the section contents. */
1474 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1475 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1476 /* Go get them off disk. */
1477 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1480 /* Read this BFD's symbols. */
1481 /* Get cached copy if it exists. */
1482 if (symtab_hdr
->contents
!= NULL
)
1484 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1488 intsyms
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
, symtab_hdr
->sh_info
, 0, NULL
, NULL
, NULL
);
1489 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1492 if (shndx_hdr
&& shndx_hdr
->sh_size
!= 0)
1496 amt
= symtab_hdr
->sh_info
;
1497 amt
*= sizeof (Elf_External_Sym_Shndx
);
1498 shndx_buf
= (Elf_External_Sym_Shndx
*) bfd_malloc (amt
);
1499 if (shndx_buf
== NULL
)
1501 if (bfd_seek (abfd
, shndx_hdr
->sh_offset
, SEEK_SET
) != 0
1502 || bfd_bread (shndx_buf
, amt
, abfd
) != amt
)
1504 shndx_hdr
->contents
= (bfd_byte
*) shndx_buf
;
1507 /* Get a copy of the native relocations. */
1508 internal_relocs
= (_bfd_elf_link_read_relocs
1509 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
1510 link_info
->keep_memory
));
1511 if (internal_relocs
== NULL
)
1513 if (! link_info
->keep_memory
)
1514 free_relocs
= internal_relocs
;
1516 /* The RL_ relocs must be just before the operand relocs they go
1517 with, so we must sort them to guarantee this. */
1518 qsort (internal_relocs
, sec
->reloc_count
, sizeof (Elf_Internal_Rela
),
1521 /* Walk through them looking for relaxing opportunities. */
1522 irelend
= internal_relocs
+ sec
->reloc_count
;
1524 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1527 unsigned char *insn
, *gap
, *einsn
;
1529 bfd_signed_vma pcrel
;
1535 EncodingTable
*enctbl
;
1538 if (ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_JUMP
1539 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_1ADDR
1540 && ELF32_R_TYPE(irel
->r_info
) != R_M32C_RL_2ADDR
)
1545 /* There will always be room for the relaxed insn, since it is smaller
1546 than the one it would replace. */
1547 BFD_ASSERT (irel
->r_offset
< sec
->size
);
1549 insn
= contents
+ irel
->r_offset
;
1550 relax_relocs
= irel
->r_addend
% 16;
1552 /* Ok, we only have three relocs we care about, and they're all
1553 fake. The lower four bits of the addend is always the number
1554 of following relocs (hence the qsort above) that are assigned
1555 to this opcode. The next 8 bits of the addend indicates the
1556 number of bytes in the insn. We use the rest of them
1557 ourselves as flags for the more expensive operations (defines
1558 above). The three relocs are:
1560 RL_JUMP: This marks all direct jump insns. We check the
1561 displacement and replace them with shorter jumps if
1562 they're in range. We also use this to find JMP.S
1563 insns and manually shorten them when we delete bytes.
1564 We have to decode these insns to figure out what to
1567 RL_1ADDR: This is a :G or :Q insn, which has a single
1568 "standard" operand. We have to extract the type
1569 field, see if it's a wide displacement, then figure
1570 out if we can replace it with a narrow displacement.
1571 We don't have to decode these insns.
1573 RL_2ADDR: Similarly, but two "standard" operands. Note that
1574 r_addend may still be 1, as standard operands don't
1575 always have displacements. Gas shouldn't give us one
1576 with zero operands, but since we don't know which one
1577 has the displacement, we check them both anyway.
1579 These all point to the beginning of the insn itself, not the
1582 Note that we only relax one step at a time, relying on the
1583 linker to call us repeatedly. Thus, there is no code for
1584 JMP.A->JMP.B although that will happen in two steps.
1585 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1588 /* Get the value of the symbol referred to by the reloc. Just
1589 in case this is the last reloc in the list, use the RL's
1590 addend to choose between this reloc (no addend) or the next
1591 (yes addend, which means at least one following reloc). */
1592 srel
= irel
+ (relax_relocs
? 1 : 0);
1593 symval
= OFFSET_FOR_RELOC (srel
);
1595 /* Setting gap_size nonzero is the flag which means "something
1599 new_type
= ELF32_R_TYPE(srel
->r_info
);
1601 pc
= sec
->output_section
->vma
+ sec
->output_offset
1603 pcrel
= symval
- pc
+ srel
->r_addend
;
1605 if (machine
== bfd_mach_m16c
)
1609 switch (ELF32_R_TYPE(irel
->r_info
))
1612 case R_M32C_RL_JUMP
:
1615 case 0xfe: /* jmp.b */
1616 if (pcrel
>= 2 && pcrel
<= 9)
1618 /* Relax JMP.B -> JMP.S. We need to get rid of
1619 the following reloc though. */
1620 insn
[0] = 0x60 | (pcrel
- 2);
1621 new_type
= R_M32C_NONE
;
1622 irel
->r_addend
= 0x10;
1628 case 0xf4: /* jmp.w */
1629 /* 128 is allowed because it will be one byte closer
1630 after relaxing. Likewise for all other pc-rel
1632 if (pcrel
<= 128 && pcrel
>= -128)
1634 /* Relax JMP.W -> JMP.B */
1637 new_type
= R_M32C_8_PCREL
;
1643 case 0xfc: /* jmp.a */
1644 if (pcrel
<= 32768 && pcrel
>= -32768)
1646 /* Relax JMP.A -> JMP.W */
1650 new_type
= R_M32C_16_PCREL
;
1656 case 0xfd: /* jsr.a */
1657 if (pcrel
<= 32768 && pcrel
>= -32768)
1659 /* Relax JSR.A -> JSR.W */
1663 new_type
= R_M32C_16_PCREL
;
1671 case R_M32C_RL_2ADDR
:
1672 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1674 enctbl
= m16c_addr_encodings
;
1676 enc
= (insn
[1] >> 4) & 0x0f;
1679 if (srel
->r_offset
== irel
->r_offset
+ posn
1680 && e
->new_encoding
!= enc
1681 && symval
<= e
->max_disp
)
1684 insn
[1] |= e
->new_encoding
<< 4;
1685 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1686 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1687 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1690 if (relax_relocs
== 2)
1696 case R_M32C_RL_1ADDR
:
1697 /* xxxx xxxx xxxx dest [disp] */
1699 enctbl
= m16c_addr_encodings
;
1702 /* Check the opcode for jumps. We know it's safe to
1703 do this because all 2ADDR insns are at least two
1705 enc
= insn
[0] * 256 + insn
[1];
1712 enctbl
= m16c_jmpaddr_encodings
;
1716 /* srel, posn, and enc must be set here. */
1718 symval
= OFFSET_FOR_RELOC (srel
);
1719 enc
= insn
[1] & 0x0f;
1722 if (srel
->r_offset
== irel
->r_offset
+ posn
1723 && e
->new_encoding
!= enc
1724 && symval
<= e
->max_disp
)
1727 insn
[1] |= e
->new_encoding
;
1728 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1729 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1730 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1736 } /* Ends switch (reloc type) for m16c. */
1738 else /* machine == bfd_mach_m32c */
1742 switch (ELF32_R_TYPE(irel
->r_info
))
1745 case R_M32C_RL_JUMP
:
1748 case 0xbb: /* jmp.b */
1749 if (pcrel
>= 2 && pcrel
<= 9)
1752 /* Relax JMP.B -> JMP.S. We need to get rid of
1753 the following reloc though. */
1754 insn
[0] = 0x4a | ((p
<< 3) & 0x30) | (p
& 1);
1755 new_type
= R_M32C_NONE
;
1756 irel
->r_addend
= 0x10;
1762 case 0xce: /* jmp.w */
1763 if (pcrel
<= 128 && pcrel
>= -128)
1765 /* Relax JMP.W -> JMP.B */
1768 new_type
= R_M32C_8_PCREL
;
1774 case 0xcc: /* jmp.a */
1775 if (pcrel
<= 32768 && pcrel
>= -32768)
1777 /* Relax JMP.A -> JMP.W */
1781 new_type
= R_M32C_16_PCREL
;
1787 case 0xcd: /* jsr.a */
1788 if (pcrel
<= 32768 && pcrel
>= -32768)
1790 /* Relax JSR.A -> JSR.W */
1794 new_type
= R_M32C_16_PCREL
;
1802 case R_M32C_RL_2ADDR
:
1803 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1809 /* prefix; remove it as far as the RL reloc is concerned. */
1814 enctbl
= m32c_addr_encodings
;
1815 enc
= ((einsn
[0] & 0x70) >> 2) | ((einsn
[1] & 0x30) >> 4);
1818 if (srel
->r_offset
== irel
->r_offset
+ posn
1819 && e
->new_encoding
!= enc
1820 && symval
<= e
->max_disp
)
1823 einsn
[0] |= (e
->new_encoding
& 0x1c) << 2;
1825 einsn
[1] |= (e
->new_encoding
& 0x03) << 4;
1826 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1827 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1828 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1831 if (relax_relocs
== 2)
1837 case R_M32C_RL_1ADDR
:
1838 /* xxxx DDDx DDxx xxxx [disp] */
1844 /* prefix; remove it as far as the RL reloc is concerned. */
1849 enctbl
= m32c_addr_encodings
;
1852 /* srel, posn, and enc must be set here. */
1854 symval
= OFFSET_FOR_RELOC (srel
);
1855 enc
= ((einsn
[0] & 0x0e) << 1) | ((einsn
[1] & 0xc0) >> 6);
1858 if (srel
->r_offset
== irel
->r_offset
+ posn
1859 && e
->new_encoding
!= enc
1860 && symval
<= e
->max_disp
)
1863 einsn
[0] |= (e
->new_encoding
& 0x1c) >> 1;
1865 einsn
[1] |= (e
->new_encoding
& 0x03) << 6;
1866 gap_size
= e
->bytes
- enctbl
[e
->new_encoding
].bytes
;
1867 gap
= insn
+ posn
+ enctbl
[e
->new_encoding
].bytes
;
1868 new_type
= bytes_to_reloc
[enctbl
[e
->new_encoding
].bytes
];
1874 } /* Ends switch (reloc type) for m32c. */
1882 srel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (srel
->r_info
), new_type
);
1884 /* Note that we've changed the relocs, section contents, etc. */
1885 elf_section_data (sec
)->relocs
= internal_relocs
;
1888 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1889 free_contents
= NULL
;
1891 symtab_hdr
->contents
= (bfd_byte
*) intsyms
;
1892 free_intsyms
= NULL
;
1894 bytes_saved
+= gap_size
;
1896 if (! m32c_elf_relax_delete_bytes(abfd
, sec
, gap
- contents
, gap_size
))
1899 } /* next relocation */
1901 if (free_relocs
!= NULL
)
1907 if (free_contents
!= NULL
)
1909 if (! link_info
->keep_memory
)
1910 free (free_contents
);
1911 /* Cache the section contents for elf_link_input_bfd. */
1913 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1915 free_contents
= NULL
;
1918 if (shndx_buf
!= NULL
)
1920 shndx_hdr
->contents
= NULL
;
1924 if (free_intsyms
!= NULL
)
1926 if (! link_info
->keep_memory
)
1927 free (free_intsyms
);
1928 /* Cache the symbols for elf_link_input_bfd. */
1931 symtab_hdr
->contents
= NULL
/* (unsigned char *) intsyms*/;
1934 free_intsyms
= NULL
;
1940 if (free_relocs
!= NULL
)
1942 if (free_contents
!= NULL
)
1943 free (free_contents
);
1944 if (shndx_buf
!= NULL
)
1946 shndx_hdr
->contents
= NULL
;
1949 if (free_intsyms
!= NULL
)
1950 free (free_intsyms
);
1954 /* Delete some bytes from a section while relaxing. */
1957 m32c_elf_relax_delete_bytes
1963 Elf_Internal_Shdr
*symtab_hdr
;
1964 Elf_Internal_Shdr
*shndx_hdr
;
1967 Elf_Internal_Rela
*irel
;
1968 Elf_Internal_Rela
*irelend
;
1970 Elf_Internal_Sym
*isym
;
1971 Elf_Internal_Sym
*isymend
;
1972 Elf_Internal_Sym
*intsyms
;
1973 Elf_External_Sym_Shndx
*shndx_buf
;
1974 Elf_External_Sym_Shndx
*shndx
;
1975 struct elf_link_hash_entry
** sym_hashes
;
1976 struct elf_link_hash_entry
** end_hashes
;
1977 unsigned int symcount
;
1979 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1983 irel
= elf_section_data (sec
)->relocs
;
1984 irelend
= irel
+ sec
->reloc_count
;
1986 /* Actually delete the bytes. */
1987 memmove (contents
+ addr
, contents
+ addr
+ count
, (size_t) (toaddr
- addr
- count
));
1990 /* Adjust all the relocs. */
1991 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1993 /* Get the new reloc address. */
1994 if (irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
)
1995 irel
->r_offset
-= count
;
1997 if (ELF32_R_TYPE(irel
->r_info
) == R_M32C_RL_JUMP
1998 && irel
->r_addend
== 0x10 /* one byte insn, no relocs */
1999 && irel
->r_offset
+ 1 < addr
2000 && irel
->r_offset
+ 7 > addr
)
2003 unsigned char *insn
= &contents
[irel
->r_offset
];
2005 /* This is a JMP.S, which we have to manually update. */
2006 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2008 if ((*insn
& 0xf8) != 0x60)
2014 if ((*insn
& 0xce) != 0x4a)
2016 disp
= ((disp
& 0x30) >> 3) | (disp
& 1);
2018 if (irel
->r_offset
+ disp
+ 2 >= addr
+count
)
2021 if (elf32_m32c_machine (abfd
) == bfd_mach_m16c
)
2023 *insn
= (*insn
& 0xf8) | disp
;
2027 *insn
= (*insn
& 0xce) | ((disp
& 6) << 3) | (disp
& 1);
2033 /* Adjust the local symbols defined in this section. */
2034 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
2035 intsyms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2037 isymend
= isym
+ symtab_hdr
->sh_info
;
2039 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2040 if (elf_symtab_shndx_list (abfd
))
2042 shndx_hdr
= & elf_symtab_shndx_list (abfd
)->hdr
;
2043 shndx_buf
= (Elf_External_Sym_Shndx
*) shndx_hdr
->contents
;
2052 for (; isym
< isymend
; isym
++, shndx
= (shndx
? shndx
+ 1 : NULL
))
2054 /* If the symbol is in the range of memory we just moved, we
2055 have to adjust its value. */
2056 if ((int) isym
->st_shndx
== sec_shndx
2057 && isym
->st_value
> addr
2058 && isym
->st_value
< toaddr
)
2060 isym
->st_value
-= count
;
2062 /* If the symbol *spans* the bytes we just deleted (i.e. it's
2063 *end* is in the moved bytes but it's *start* isn't), then we
2064 must adjust its size. */
2065 if ((int) isym
->st_shndx
== sec_shndx
2066 && isym
->st_value
< addr
2067 && isym
->st_value
+ isym
->st_size
> addr
2068 && isym
->st_value
+ isym
->st_size
< toaddr
)
2070 isym
->st_size
-= count
;
2074 /* Now adjust the global symbols defined in this section. */
2075 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
2076 - symtab_hdr
->sh_info
);
2077 sym_hashes
= elf_sym_hashes (abfd
);
2078 // sym_hashes += symtab_hdr->sh_info;
2079 end_hashes
= sym_hashes
+ symcount
;
2081 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2083 struct elf_link_hash_entry
* sym_hash
= * sym_hashes
;
2086 (sym_hash
->root
.type
== bfd_link_hash_defined
2087 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2088 && sym_hash
->root
.u
.def
.section
== sec
)
2090 if (sym_hash
->root
.u
.def
.value
> addr
2091 && sym_hash
->root
.u
.def
.value
< toaddr
)
2093 sym_hash
->root
.u
.def
.value
-= count
;
2095 if (sym_hash
->root
.u
.def
.value
< addr
2096 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2097 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
< toaddr
)
2099 sym_hash
->size
-= count
;
2107 /* This is for versions of gcc prior to 4.3. */
2109 _bfd_m32c_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
2111 if ((elf_elfheader (abfd
)->e_flags
& EF_M32C_CPU_MASK
) == EF_M32C_CPU_M16C
)
2118 #define ELF_ARCH bfd_arch_m32c
2119 #define ELF_MACHINE_CODE EM_M32C
2120 #define ELF_MACHINE_ALT1 EM_M32C_OLD
2121 #define ELF_MAXPAGESIZE 0x100
2124 #define TARGET_BIG_SYM m32c_elf32_vec
2125 #define TARGET_BIG_NAME "elf32-m32c"
2127 #define TARGET_LITTLE_SYM m32c_elf32_vec
2128 #define TARGET_LITTLE_NAME "elf32-m32c"
2131 #define elf_info_to_howto_rel NULL
2132 #define elf_info_to_howto m32c_info_to_howto_rela
2133 #define elf_backend_object_p m32c_elf_object_p
2134 #define elf_backend_relocate_section m32c_elf_relocate_section
2135 #define elf_backend_check_relocs m32c_elf_check_relocs
2136 #define elf_backend_object_p m32c_elf_object_p
2137 #define elf_symbol_leading_char ('_')
2138 #define elf_backend_always_size_sections \
2139 m32c_elf_always_size_sections
2140 #define elf_backend_finish_dynamic_sections \
2141 m32c_elf_finish_dynamic_sections
2143 #define elf_backend_can_gc_sections 1
2144 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2146 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2147 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2148 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2149 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2150 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2151 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2153 #include "elf32-target.h"