1 /* BFD back-end for National Semiconductor's CRX ELF
2 Copyright (C) 2004-2020 Free Software Foundation, Inc.
3 Written by Tomer Levi, NSC, Israel.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
29 static reloc_howto_type
*elf_crx_reloc_type_lookup
30 (bfd
*, bfd_reloc_code_real_type
);
31 static bfd_boolean elf_crx_info_to_howto
32 (bfd
*, arelent
*, Elf_Internal_Rela
*);
33 static bfd_boolean elf32_crx_relax_delete_bytes
34 (struct bfd_link_info
*, bfd
*, asection
*, bfd_vma
, int);
35 static bfd_reloc_status_type crx_elf_final_link_relocate
36 (reloc_howto_type
*, bfd
*, bfd
*, asection
*,
37 bfd_byte
*, bfd_vma
, bfd_vma
, bfd_vma
,
38 struct bfd_link_info
*, asection
*, int);
39 static bfd_boolean elf32_crx_relocate_section
40 (bfd
*, struct bfd_link_info
*, bfd
*, asection
*, bfd_byte
*,
41 Elf_Internal_Rela
*, Elf_Internal_Sym
*, asection
**);
42 static bfd_boolean elf32_crx_relax_section
43 (bfd
*, asection
*, struct bfd_link_info
*, bfd_boolean
*);
44 static bfd_byte
* elf32_crx_get_relocated_section_contents
45 (bfd
*, struct bfd_link_info
*, struct bfd_link_order
*,
46 bfd_byte
*, bfd_boolean
, asymbol
**);
48 /* crx_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */
52 bfd_reloc_code_real_type bfd_reloc_enum
; /* BFD relocation enum. */
53 unsigned short crx_reloc_type
; /* CRX relocation type. */
56 static const struct crx_reloc_map crx_reloc_map
[R_CRX_MAX
] =
58 {BFD_RELOC_NONE
, R_CRX_NONE
},
59 {BFD_RELOC_CRX_REL4
, R_CRX_REL4
},
60 {BFD_RELOC_CRX_REL8
, R_CRX_REL8
},
61 {BFD_RELOC_CRX_REL8_CMP
, R_CRX_REL8_CMP
},
62 {BFD_RELOC_CRX_REL16
, R_CRX_REL16
},
63 {BFD_RELOC_CRX_REL24
, R_CRX_REL24
},
64 {BFD_RELOC_CRX_REL32
, R_CRX_REL32
},
65 {BFD_RELOC_CRX_REGREL12
, R_CRX_REGREL12
},
66 {BFD_RELOC_CRX_REGREL22
, R_CRX_REGREL22
},
67 {BFD_RELOC_CRX_REGREL28
, R_CRX_REGREL28
},
68 {BFD_RELOC_CRX_REGREL32
, R_CRX_REGREL32
},
69 {BFD_RELOC_CRX_ABS16
, R_CRX_ABS16
},
70 {BFD_RELOC_CRX_ABS32
, R_CRX_ABS32
},
71 {BFD_RELOC_CRX_NUM8
, R_CRX_NUM8
},
72 {BFD_RELOC_CRX_NUM16
, R_CRX_NUM16
},
73 {BFD_RELOC_CRX_NUM32
, R_CRX_NUM32
},
74 {BFD_RELOC_CRX_IMM16
, R_CRX_IMM16
},
75 {BFD_RELOC_CRX_IMM32
, R_CRX_IMM32
},
76 {BFD_RELOC_CRX_SWITCH8
, R_CRX_SWITCH8
},
77 {BFD_RELOC_CRX_SWITCH16
, R_CRX_SWITCH16
},
78 {BFD_RELOC_CRX_SWITCH32
, R_CRX_SWITCH32
}
81 static reloc_howto_type crx_elf_howto_table
[] =
83 HOWTO (R_CRX_NONE
, /* type */
87 FALSE
, /* pc_relative */
89 complain_overflow_dont
,/* complain_on_overflow */
90 bfd_elf_generic_reloc
, /* special_function */
91 "R_CRX_NONE", /* name */
92 FALSE
, /* partial_inplace */
95 FALSE
), /* pcrel_offset */
97 HOWTO (R_CRX_REL4
, /* type */
101 TRUE
, /* pc_relative */
103 complain_overflow_bitfield
,/* complain_on_overflow */
104 bfd_elf_generic_reloc
, /* special_function */
105 "R_CRX_REL4", /* name */
106 FALSE
, /* partial_inplace */
109 FALSE
), /* pcrel_offset */
111 HOWTO (R_CRX_REL8
, /* type */
115 TRUE
, /* pc_relative */
117 complain_overflow_bitfield
,/* complain_on_overflow */
118 bfd_elf_generic_reloc
, /* special_function */
119 "R_CRX_REL8", /* name */
120 FALSE
, /* partial_inplace */
123 FALSE
), /* pcrel_offset */
125 HOWTO (R_CRX_REL8_CMP
, /* type */
129 TRUE
, /* pc_relative */
131 complain_overflow_bitfield
,/* complain_on_overflow */
132 bfd_elf_generic_reloc
, /* special_function */
133 "R_CRX_REL8_CMP", /* name */
134 FALSE
, /* partial_inplace */
137 FALSE
), /* pcrel_offset */
139 HOWTO (R_CRX_REL16
, /* type */
143 TRUE
, /* pc_relative */
145 complain_overflow_bitfield
,/* complain_on_overflow */
146 bfd_elf_generic_reloc
, /* special_function */
147 "R_CRX_REL16", /* name */
148 FALSE
, /* partial_inplace */
150 0xffff, /* dst_mask */
151 FALSE
), /* pcrel_offset */
153 HOWTO (R_CRX_REL24
, /* type */
157 TRUE
, /* pc_relative */
159 complain_overflow_bitfield
,/* complain_on_overflow */
160 bfd_elf_generic_reloc
, /* special_function */
161 "R_CRX_REL24", /* name */
162 FALSE
, /* partial_inplace */
164 0xffffff, /* dst_mask */
165 FALSE
), /* pcrel_offset */
167 HOWTO (R_CRX_REL32
, /* type */
171 TRUE
, /* pc_relative */
173 complain_overflow_bitfield
,/* complain_on_overflow */
174 bfd_elf_generic_reloc
, /* special_function */
175 "R_CRX_REL32", /* name */
176 FALSE
, /* partial_inplace */
178 0xffffffff, /* dst_mask */
179 FALSE
), /* pcrel_offset */
181 HOWTO (R_CRX_REGREL12
, /* type */
185 FALSE
, /* pc_relative */
187 complain_overflow_bitfield
,/* complain_on_overflow */
188 bfd_elf_generic_reloc
, /* special_function */
189 "R_CRX_REGREL12", /* name */
190 FALSE
, /* partial_inplace */
192 0xfff, /* dst_mask */
193 FALSE
), /* pcrel_offset */
195 HOWTO (R_CRX_REGREL22
, /* type */
199 FALSE
, /* pc_relative */
201 complain_overflow_bitfield
,/* complain_on_overflow */
202 bfd_elf_generic_reloc
, /* special_function */
203 "R_CRX_REGREL22", /* name */
204 FALSE
, /* partial_inplace */
206 0x3fffff, /* dst_mask */
207 FALSE
), /* pcrel_offset */
209 HOWTO (R_CRX_REGREL28
, /* type */
213 FALSE
, /* pc_relative */
215 complain_overflow_bitfield
,/* complain_on_overflow */
216 bfd_elf_generic_reloc
, /* special_function */
217 "R_CRX_REGREL28", /* name */
218 FALSE
, /* partial_inplace */
220 0xfffffff, /* dst_mask */
221 FALSE
), /* pcrel_offset */
223 HOWTO (R_CRX_REGREL32
, /* type */
227 FALSE
, /* pc_relative */
229 complain_overflow_bitfield
,/* complain_on_overflow */
230 bfd_elf_generic_reloc
, /* special_function */
231 "R_CRX_REGREL32", /* name */
232 FALSE
, /* partial_inplace */
234 0xffffffff, /* dst_mask */
235 FALSE
), /* pcrel_offset */
237 HOWTO (R_CRX_ABS16
, /* type */
241 FALSE
, /* pc_relative */
243 complain_overflow_bitfield
,/* complain_on_overflow */
244 bfd_elf_generic_reloc
, /* special_function */
245 "R_CRX_ABS16", /* name */
246 FALSE
, /* partial_inplace */
248 0xffff, /* dst_mask */
249 FALSE
), /* pcrel_offset */
251 HOWTO (R_CRX_ABS32
, /* type */
255 FALSE
, /* pc_relative */
257 complain_overflow_bitfield
,/* complain_on_overflow */
258 bfd_elf_generic_reloc
, /* special_function */
259 "R_CRX_ABS32", /* name */
260 FALSE
, /* partial_inplace */
262 0xffffffff, /* dst_mask */
263 FALSE
), /* pcrel_offset */
265 HOWTO (R_CRX_NUM8
, /* type */
269 FALSE
, /* pc_relative */
271 complain_overflow_bitfield
,/* complain_on_overflow */
272 bfd_elf_generic_reloc
, /* special_function */
273 "R_CRX_NUM8", /* name */
274 FALSE
, /* partial_inplace */
277 FALSE
), /* pcrel_offset */
279 HOWTO (R_CRX_NUM16
, /* type */
283 FALSE
, /* pc_relative */
285 complain_overflow_bitfield
,/* complain_on_overflow */
286 bfd_elf_generic_reloc
, /* special_function */
287 "R_CRX_NUM16", /* name */
288 FALSE
, /* partial_inplace */
290 0xffff, /* dst_mask */
291 FALSE
), /* pcrel_offset */
293 HOWTO (R_CRX_NUM32
, /* type */
297 FALSE
, /* pc_relative */
299 complain_overflow_bitfield
,/* complain_on_overflow */
300 bfd_elf_generic_reloc
, /* special_function */
301 "R_CRX_NUM32", /* name */
302 FALSE
, /* partial_inplace */
304 0xffffffff, /* dst_mask */
305 FALSE
), /* pcrel_offset */
307 HOWTO (R_CRX_IMM16
, /* type */
311 FALSE
, /* pc_relative */
313 complain_overflow_bitfield
,/* complain_on_overflow */
314 bfd_elf_generic_reloc
, /* special_function */
315 "R_CRX_IMM16", /* name */
316 FALSE
, /* partial_inplace */
318 0xffff, /* dst_mask */
319 FALSE
), /* pcrel_offset */
321 HOWTO (R_CRX_IMM32
, /* type */
325 FALSE
, /* pc_relative */
327 complain_overflow_bitfield
,/* complain_on_overflow */
328 bfd_elf_generic_reloc
, /* special_function */
329 "R_CRX_IMM32", /* name */
330 FALSE
, /* partial_inplace */
332 0xffffffff, /* dst_mask */
333 FALSE
), /* pcrel_offset */
335 /* An 8 bit switch table entry. This is generated for an expression
336 such as ``.byte L1 - L2''. The offset holds the difference
337 between the reloc address and L2. */
338 HOWTO (R_CRX_SWITCH8
, /* type */
340 0, /* size (0 = byte, 1 = short, 2 = long) */
342 FALSE
, /* pc_relative */
344 complain_overflow_unsigned
, /* complain_on_overflow */
345 bfd_elf_generic_reloc
, /* special_function */
346 "R_CRX_SWITCH8", /* name */
347 FALSE
, /* partial_inplace */
350 TRUE
), /* pcrel_offset */
352 /* A 16 bit switch table entry. This is generated for an expression
353 such as ``.word L1 - L2''. The offset holds the difference
354 between the reloc address and L2. */
355 HOWTO (R_CRX_SWITCH16
, /* type */
357 1, /* size (0 = byte, 1 = short, 2 = long) */
359 FALSE
, /* pc_relative */
361 complain_overflow_unsigned
, /* complain_on_overflow */
362 bfd_elf_generic_reloc
, /* special_function */
363 "R_CRX_SWITCH16", /* name */
364 FALSE
, /* partial_inplace */
366 0xffff, /* dst_mask */
367 TRUE
), /* pcrel_offset */
369 /* A 32 bit switch table entry. This is generated for an expression
370 such as ``.long L1 - L2''. The offset holds the difference
371 between the reloc address and L2. */
372 HOWTO (R_CRX_SWITCH32
, /* type */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
376 FALSE
, /* pc_relative */
378 complain_overflow_unsigned
, /* complain_on_overflow */
379 bfd_elf_generic_reloc
, /* special_function */
380 "R_CRX_SWITCH32", /* name */
381 FALSE
, /* partial_inplace */
383 0xffffffff, /* dst_mask */
384 TRUE
) /* pcrel_offset */
387 /* Retrieve a howto ptr using a BFD reloc_code. */
389 static reloc_howto_type
*
390 elf_crx_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
391 bfd_reloc_code_real_type code
)
395 for (i
= 0; i
< R_CRX_MAX
; i
++)
396 if (code
== crx_reloc_map
[i
].bfd_reloc_enum
)
397 return &crx_elf_howto_table
[crx_reloc_map
[i
].crx_reloc_type
];
399 printf ("This relocation Type is not supported -0x%x\n", code
);
403 static reloc_howto_type
*
404 elf_crx_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
410 i
< sizeof (crx_elf_howto_table
) / sizeof (crx_elf_howto_table
[0]);
412 if (crx_elf_howto_table
[i
].name
!= NULL
413 && strcasecmp (crx_elf_howto_table
[i
].name
, r_name
) == 0)
414 return &crx_elf_howto_table
[i
];
419 /* Retrieve a howto ptr using an internal relocation entry. */
422 elf_crx_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
423 Elf_Internal_Rela
*dst
)
425 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
426 if (r_type
>= R_CRX_MAX
)
428 /* xgettext:c-format */
429 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
431 bfd_set_error (bfd_error_bad_value
);
434 cache_ptr
->howto
= &crx_elf_howto_table
[r_type
];
438 /* Perform a relocation as part of a final link. */
440 static bfd_reloc_status_type
441 crx_elf_final_link_relocate (reloc_howto_type
*howto
, bfd
*input_bfd
,
442 bfd
*output_bfd ATTRIBUTE_UNUSED
,
443 asection
*input_section
, bfd_byte
*contents
,
444 bfd_vma offset
, bfd_vma Rvalue
, bfd_vma addend
,
445 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
446 asection
*sec ATTRIBUTE_UNUSED
,
447 int is_local ATTRIBUTE_UNUSED
)
449 unsigned short r_type
= howto
->type
;
450 bfd_byte
*hit_data
= contents
+ offset
;
451 bfd_vma reloc_bits
, check
;
467 /* 'hit_data' is relative to the start of the instruction, not the
468 relocation offset. Advance it to account for the exact offset. */
473 /* This relocation type is used only in 'Branch if Equal to 0'
474 instructions and requires special handling. */
485 /* We only care about the addend, where the difference between
486 expressions is kept. */
493 if (howto
->pc_relative
)
495 /* Subtract the address of the section containing the location. */
496 Rvalue
-= (input_section
->output_section
->vma
497 + input_section
->output_offset
);
498 /* Subtract the position of the location within the section. */
502 /* Add in supplied addend. */
505 /* Complain if the bitfield overflows, whether it is considered
506 as signed or unsigned. */
507 check
= Rvalue
>> howto
->rightshift
;
509 /* Assumes two's complement. This expression avoids
510 overflow if howto->bitsize is the number of bits in
512 reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
514 if (((bfd_vma
) check
& ~reloc_bits
) != 0
515 && (((bfd_vma
) check
& ~reloc_bits
)
516 != (-(bfd_vma
) 1 & ~reloc_bits
)))
518 /* The above right shift is incorrect for a signed
519 value. See if turning on the upper bits fixes the
521 if (howto
->rightshift
&& (bfd_signed_vma
) Rvalue
< 0)
523 check
|= ((bfd_vma
) - 1
525 >> howto
->rightshift
));
526 if (((bfd_vma
) check
& ~reloc_bits
)
527 != (-(bfd_vma
) 1 & ~reloc_bits
))
528 return bfd_reloc_overflow
;
531 return bfd_reloc_overflow
;
534 /* Drop unwanted bits from the value we are relocating to. */
535 Rvalue
>>= (bfd_vma
) howto
->rightshift
;
537 /* Apply dst_mask to select only relocatable part of the insn. */
538 Rvalue
&= howto
->dst_mask
;
543 if (r_type
== R_CRX_REL4
)
546 Rvalue
|= (bfd_get_8 (input_bfd
, hit_data
) & 0x0f);
549 bfd_put_8 (input_bfd
, (unsigned char) Rvalue
, hit_data
);
553 if (r_type
== R_CRX_REGREL12
)
554 Rvalue
|= (bfd_get_16 (input_bfd
, hit_data
) & 0xf000);
556 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
560 if (r_type
== R_CRX_REL24
561 || r_type
== R_CRX_REGREL22
562 || r_type
== R_CRX_REGREL28
)
563 Rvalue
|= (((bfd_get_16 (input_bfd
, hit_data
) << 16) |
564 bfd_get_16 (input_bfd
, hit_data
+ 2)) & ~howto
->dst_mask
);
566 if (r_type
== R_CRX_NUM32
|| r_type
== R_CRX_SWITCH32
)
567 /* Relocation on DATA is purely little-endian, that is, for a
568 multi-byte datum, the lowest address in memory contains the
569 little end of the datum, that is, the least significant byte.
570 Therefore we use BFD's byte Putting functions. */
571 bfd_put_32 (input_bfd
, Rvalue
, hit_data
);
573 /* Relocation on INSTRUCTIONS is different : Instructions are
574 word-addressable, that is, each word itself is arranged according
575 to little-endian convention, whereas the words are arranged with
576 respect to one another in BIG ENDIAN fashion.
577 When there is an immediate value that spans a word boundary, it is
578 split in a big-endian way with respect to the words. */
580 bfd_put_16 (input_bfd
, (Rvalue
>> 16) & 0xffff, hit_data
);
581 bfd_put_16 (input_bfd
, Rvalue
& 0xffff, hit_data
+ 2);
586 return bfd_reloc_notsupported
;
592 /* Delete some bytes from a section while relaxing. */
595 elf32_crx_relax_delete_bytes (struct bfd_link_info
*link_info
, bfd
*abfd
,
596 asection
*sec
, bfd_vma addr
, int count
)
598 Elf_Internal_Shdr
*symtab_hdr
;
599 unsigned int sec_shndx
;
601 Elf_Internal_Rela
*irel
, *irelend
;
603 Elf_Internal_Sym
*isym
;
604 Elf_Internal_Sym
*isymend
;
605 struct elf_link_hash_entry
**sym_hashes
;
606 struct elf_link_hash_entry
**end_hashes
;
607 struct elf_link_hash_entry
**start_hashes
;
608 unsigned int symcount
;
610 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
612 contents
= elf_section_data (sec
)->this_hdr
.contents
;
616 irel
= elf_section_data (sec
)->relocs
;
617 irelend
= irel
+ sec
->reloc_count
;
619 /* Actually delete the bytes. */
620 memmove (contents
+ addr
, contents
+ addr
+ count
,
621 (size_t) (toaddr
- addr
- count
));
624 /* Adjust all the relocs. */
625 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
627 /* Get the new reloc address. */
628 if ((irel
->r_offset
> addr
629 && irel
->r_offset
< toaddr
))
630 irel
->r_offset
-= count
;
633 /* Adjust the local symbols defined in this section. */
634 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
635 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
636 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
638 if (isym
->st_shndx
== sec_shndx
639 && isym
->st_value
> addr
640 && isym
->st_value
< toaddr
)
642 /* Adjust the addend of SWITCH relocations in this section,
643 which reference this local symbol. */
644 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
646 unsigned long r_symndx
;
647 Elf_Internal_Sym
*rsym
;
648 bfd_vma addsym
, subsym
;
650 /* Skip if not a SWITCH relocation. */
651 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_SWITCH8
652 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_SWITCH16
653 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_SWITCH32
)
656 r_symndx
= ELF32_R_SYM (irel
->r_info
);
657 rsym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ r_symndx
;
659 /* Skip if not the local adjusted symbol. */
663 addsym
= isym
->st_value
;
664 subsym
= addsym
- irel
->r_addend
;
666 /* Fix the addend only when -->> (addsym > addr >= subsym). */
668 irel
->r_addend
-= count
;
673 isym
->st_value
-= count
;
677 /* Now adjust the global symbols defined in this section. */
678 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
679 - symtab_hdr
->sh_info
);
680 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
681 end_hashes
= sym_hashes
+ symcount
;
683 for (; sym_hashes
< end_hashes
; sym_hashes
++)
685 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
687 /* The '--wrap SYMBOL' option is causing a pain when the object file,
688 containing the definition of __wrap_SYMBOL, includes a direct
689 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
690 the same symbol (which is __wrap_SYMBOL), but still exist as two
691 different symbols in 'sym_hashes', we don't want to adjust
692 the global symbol __wrap_SYMBOL twice.
693 This check is only relevant when symbols are being wrapped. */
694 if (link_info
->wrap_hash
!= NULL
)
696 struct elf_link_hash_entry
**cur_sym_hashes
;
698 /* Loop only over the symbols whom been already checked. */
699 for (cur_sym_hashes
= start_hashes
; cur_sym_hashes
< sym_hashes
;
702 /* If the current symbol is identical to 'sym_hash', that means
703 the symbol was already adjusted (or at least checked). */
704 if (*cur_sym_hashes
== sym_hash
)
707 /* Don't adjust the symbol again. */
708 if (cur_sym_hashes
< sym_hashes
)
712 if ((sym_hash
->root
.type
== bfd_link_hash_defined
713 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
714 && sym_hash
->root
.u
.def
.section
== sec
715 && sym_hash
->root
.u
.def
.value
> addr
716 && sym_hash
->root
.u
.def
.value
< toaddr
)
717 sym_hash
->root
.u
.def
.value
-= count
;
723 /* This is a version of bfd_generic_get_relocated_section_contents
724 which uses elf32_crx_relocate_section. */
727 elf32_crx_get_relocated_section_contents (bfd
*output_bfd
,
728 struct bfd_link_info
*link_info
,
729 struct bfd_link_order
*link_order
,
731 bfd_boolean relocatable
,
734 Elf_Internal_Shdr
*symtab_hdr
;
735 asection
*input_section
= link_order
->u
.indirect
.section
;
736 bfd
*input_bfd
= input_section
->owner
;
737 asection
**sections
= NULL
;
738 Elf_Internal_Rela
*internal_relocs
= NULL
;
739 Elf_Internal_Sym
*isymbuf
= NULL
;
741 /* We only need to handle the case of relaxing, or of having a
742 particular set of section contents, specially. */
744 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
745 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
750 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
752 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
753 (size_t) input_section
->size
);
755 if ((input_section
->flags
& SEC_RELOC
) != 0
756 && input_section
->reloc_count
> 0)
758 Elf_Internal_Sym
*isym
;
759 Elf_Internal_Sym
*isymend
;
763 internal_relocs
= (_bfd_elf_link_read_relocs
764 (input_bfd
, input_section
, NULL
,
765 (Elf_Internal_Rela
*) NULL
, FALSE
));
766 if (internal_relocs
== NULL
)
769 if (symtab_hdr
->sh_info
!= 0)
771 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
773 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
774 symtab_hdr
->sh_info
, 0,
780 amt
= symtab_hdr
->sh_info
;
781 amt
*= sizeof (asection
*);
782 sections
= bfd_malloc (amt
);
783 if (sections
== NULL
&& amt
!= 0)
786 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
787 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
791 if (isym
->st_shndx
== SHN_UNDEF
)
792 isec
= bfd_und_section_ptr
;
793 else if (isym
->st_shndx
== SHN_ABS
)
794 isec
= bfd_abs_section_ptr
;
795 else if (isym
->st_shndx
== SHN_COMMON
)
796 isec
= bfd_com_section_ptr
;
798 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
803 if (! elf32_crx_relocate_section (output_bfd
, link_info
, input_bfd
,
804 input_section
, data
, internal_relocs
,
809 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
811 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
812 free (internal_relocs
);
819 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
821 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
822 free (internal_relocs
);
826 /* Relocate a CRX ELF section. */
829 elf32_crx_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
830 bfd
*input_bfd
, asection
*input_section
,
831 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
832 Elf_Internal_Sym
*local_syms
,
833 asection
**local_sections
)
835 Elf_Internal_Shdr
*symtab_hdr
;
836 struct elf_link_hash_entry
**sym_hashes
;
837 Elf_Internal_Rela
*rel
, *relend
;
839 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
840 sym_hashes
= elf_sym_hashes (input_bfd
);
843 relend
= relocs
+ input_section
->reloc_count
;
844 for (; rel
< relend
; rel
++)
847 reloc_howto_type
*howto
;
848 unsigned long r_symndx
;
849 Elf_Internal_Sym
*sym
;
851 struct elf_link_hash_entry
*h
;
853 bfd_reloc_status_type r
;
855 r_symndx
= ELF32_R_SYM (rel
->r_info
);
856 r_type
= ELF32_R_TYPE (rel
->r_info
);
857 howto
= crx_elf_howto_table
+ (r_type
);
862 if (r_symndx
< symtab_hdr
->sh_info
)
864 sym
= local_syms
+ r_symndx
;
865 sec
= local_sections
[r_symndx
];
866 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
870 bfd_boolean unresolved_reloc
, warned
, ignored
;
872 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
873 r_symndx
, symtab_hdr
, sym_hashes
,
875 unresolved_reloc
, warned
, ignored
);
878 if (sec
!= NULL
&& discarded_section (sec
))
879 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
880 rel
, 1, relend
, howto
, 0, contents
);
882 if (bfd_link_relocatable (info
))
885 r
= crx_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
887 contents
, rel
->r_offset
,
888 relocation
, rel
->r_addend
,
889 info
, sec
, h
== NULL
);
891 if (r
!= bfd_reloc_ok
)
894 const char *msg
= (const char *) 0;
897 name
= h
->root
.root
.string
;
900 name
= (bfd_elf_string_from_elf_section
901 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
902 if (name
== NULL
|| *name
== '\0')
903 name
= bfd_section_name (sec
);
908 case bfd_reloc_overflow
:
909 (*info
->callbacks
->reloc_overflow
)
910 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
911 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
914 case bfd_reloc_undefined
:
915 (*info
->callbacks
->undefined_symbol
)
916 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
919 case bfd_reloc_outofrange
:
920 msg
= _("internal error: out of range error");
923 case bfd_reloc_notsupported
:
924 msg
= _("internal error: unsupported relocation error");
927 case bfd_reloc_dangerous
:
928 msg
= _("internal error: dangerous error");
932 msg
= _("internal error: unknown error");
936 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
937 input_section
, rel
->r_offset
);
946 /* This function handles relaxing for the CRX.
948 There's quite a few relaxing opportunites available on the CRX:
950 * bal/bcond:32 -> bal/bcond:16 2 bytes
951 * bcond:16 -> bcond:8 2 bytes
952 * cmpbcond:24 -> cmpbcond:8 2 bytes
953 * arithmetic imm32 -> arithmetic imm16 2 bytes
955 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
958 elf32_crx_relax_section (bfd
*abfd
, asection
*sec
,
959 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
961 Elf_Internal_Shdr
*symtab_hdr
;
962 Elf_Internal_Rela
*internal_relocs
;
963 Elf_Internal_Rela
*irel
, *irelend
;
964 bfd_byte
*contents
= NULL
;
965 Elf_Internal_Sym
*isymbuf
= NULL
;
967 /* Assume nothing changes. */
970 /* We don't have to do anything for a relocatable link, if
971 this section does not have relocs, or if this is not a
973 if (bfd_link_relocatable (link_info
)
974 || (sec
->flags
& SEC_RELOC
) == 0
975 || sec
->reloc_count
== 0
976 || (sec
->flags
& SEC_CODE
) == 0)
979 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
981 /* Get a copy of the native relocations. */
982 internal_relocs
= (_bfd_elf_link_read_relocs
983 (abfd
, sec
, NULL
, (Elf_Internal_Rela
*) NULL
,
984 link_info
->keep_memory
));
985 if (internal_relocs
== NULL
)
988 /* Walk through them looking for relaxing opportunities. */
989 irelend
= internal_relocs
+ sec
->reloc_count
;
990 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
994 /* If this isn't something that can be relaxed, then ignore
996 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_REL32
997 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_REL16
998 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_REL24
999 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CRX_IMM32
)
1002 /* Get the section contents if we haven't done so already. */
1003 if (contents
== NULL
)
1005 /* Get cached copy if it exists. */
1006 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1007 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1008 /* Go get them off disk. */
1009 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1013 /* Read this BFD's local symbols if we haven't done so already. */
1014 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1016 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1017 if (isymbuf
== NULL
)
1018 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1019 symtab_hdr
->sh_info
, 0,
1021 if (isymbuf
== NULL
)
1025 /* Get the value of the symbol referred to by the reloc. */
1026 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1028 /* A local symbol. */
1029 Elf_Internal_Sym
*isym
;
1032 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1033 if (isym
->st_shndx
== SHN_UNDEF
)
1034 sym_sec
= bfd_und_section_ptr
;
1035 else if (isym
->st_shndx
== SHN_ABS
)
1036 sym_sec
= bfd_abs_section_ptr
;
1037 else if (isym
->st_shndx
== SHN_COMMON
)
1038 sym_sec
= bfd_com_section_ptr
;
1040 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1041 symval
= (isym
->st_value
1042 + sym_sec
->output_section
->vma
1043 + sym_sec
->output_offset
);
1048 struct elf_link_hash_entry
*h
;
1050 /* An external symbol. */
1051 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1052 h
= elf_sym_hashes (abfd
)[indx
];
1053 BFD_ASSERT (h
!= NULL
);
1055 if (h
->root
.type
!= bfd_link_hash_defined
1056 && h
->root
.type
!= bfd_link_hash_defweak
)
1057 /* This appears to be a reference to an undefined
1058 symbol. Just ignore it--it will be caught by the
1059 regular reloc processing. */
1062 symval
= (h
->root
.u
.def
.value
1063 + h
->root
.u
.def
.section
->output_section
->vma
1064 + h
->root
.u
.def
.section
->output_offset
);
1067 /* For simplicity of coding, we are going to modify the section
1068 contents, the section relocs, and the BFD symbol table. We
1069 must tell the rest of the code not to free up this
1070 information. It would be possible to instead create a table
1071 of changes which have to be made, as is done in coff-mips.c;
1072 that would be more work, but would require less memory when
1073 the linker is run. */
1075 /* Try to turn a 32bit pc-relative branch/call into
1076 a 16bit pc-relative branch/call. */
1077 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CRX_REL32
)
1079 bfd_vma value
= symval
;
1081 /* Deal with pc-relative gunk. */
1082 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1083 value
-= irel
->r_offset
;
1084 value
+= irel
->r_addend
;
1086 /* See if the value will fit in 16 bits, note the high value is
1087 0xfffe + 2 as the target will be two bytes closer if we are
1089 if ((long) value
< 0x10000 && (long) value
> -0x10002)
1091 unsigned short code
;
1093 /* Get the opcode. */
1094 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1096 /* Verify it's a 'bal'/'bcond' and fix the opcode. */
1097 if ((code
& 0xfff0) == 0x3170)
1098 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
+ 1);
1099 else if ((code
& 0xf0ff) == 0x707f)
1100 bfd_put_8 (abfd
, 0x7e, contents
+ irel
->r_offset
);
1104 /* Note that we've changed the relocs, section contents, etc. */
1105 elf_section_data (sec
)->relocs
= internal_relocs
;
1106 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1107 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1109 /* Fix the relocation's type. */
1110 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1113 /* Delete two bytes of data. */
1114 if (!elf32_crx_relax_delete_bytes (link_info
, abfd
, sec
,
1115 irel
->r_offset
+ 2, 2))
1118 /* That will change things, so, we should relax again.
1119 Note that this is not required, and it may be slow. */
1124 /* Try to turn a 16bit pc-relative branch into an
1125 8bit pc-relative branch. */
1126 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CRX_REL16
)
1128 bfd_vma value
= symval
;
1130 /* Deal with pc-relative gunk. */
1131 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1132 value
-= irel
->r_offset
;
1133 value
+= irel
->r_addend
;
1135 /* See if the value will fit in 8 bits, note the high value is
1136 0xfc + 2 as the target will be two bytes closer if we are
1138 if ((long) value
< 0xfe && (long) value
> -0x100)
1140 unsigned short code
;
1142 /* Get the opcode. */
1143 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1145 /* Verify it's a 'bcond' opcode. */
1146 if ((code
& 0xf0ff) != 0x707e)
1149 /* Note that we've changed the relocs, section contents, etc. */
1150 elf_section_data (sec
)->relocs
= internal_relocs
;
1151 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1152 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1154 /* Fix the relocation's type. */
1155 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1158 /* Delete two bytes of data. */
1159 if (!elf32_crx_relax_delete_bytes (link_info
, abfd
, sec
,
1160 irel
->r_offset
+ 2, 2))
1163 /* That will change things, so, we should relax again.
1164 Note that this is not required, and it may be slow. */
1169 /* Try to turn a 24bit pc-relative cmp&branch into
1170 an 8bit pc-relative cmp&branch. */
1171 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CRX_REL24
)
1173 bfd_vma value
= symval
;
1175 /* Deal with pc-relative gunk. */
1176 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1177 value
-= irel
->r_offset
;
1178 value
+= irel
->r_addend
;
1180 /* See if the value will fit in 8 bits, note the high value is
1181 0x7e + 2 as the target will be two bytes closer if we are
1183 if ((long) value
< 0x100 && (long) value
> -0x100)
1185 unsigned short code
;
1187 /* Get the opcode. */
1188 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1190 /* Verify it's a 'cmp&branch' opcode. */
1191 if ((code
& 0xfff0) != 0x3180 && (code
& 0xfff0) != 0x3190
1192 && (code
& 0xfff0) != 0x31a0 && (code
& 0xfff0) != 0x31c0
1193 && (code
& 0xfff0) != 0x31d0 && (code
& 0xfff0) != 0x31e0
1194 /* Or a Co-processor branch ('bcop'). */
1195 && (code
& 0xfff0) != 0x3010 && (code
& 0xfff0) != 0x3110)
1198 /* Note that we've changed the relocs, section contents, etc. */
1199 elf_section_data (sec
)->relocs
= internal_relocs
;
1200 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1201 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1203 /* Fix the opcode. */
1204 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
+ 1);
1206 /* Fix the relocation's type. */
1207 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1210 /* Delete two bytes of data. */
1211 if (!elf32_crx_relax_delete_bytes (link_info
, abfd
, sec
,
1212 irel
->r_offset
+ 4, 2))
1215 /* That will change things, so, we should relax again.
1216 Note that this is not required, and it may be slow. */
1221 /* Try to turn a 32bit immediate address into
1222 a 16bit immediate address. */
1223 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CRX_IMM32
)
1225 bfd_vma value
= symval
;
1227 /* See if the value will fit in 16 bits. */
1228 if ((long) value
< 0x7fff && (long) value
> -0x8000)
1230 unsigned short code
;
1232 /* Get the opcode. */
1233 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1235 /* Verify it's a 'arithmetic double'. */
1236 if ((code
& 0xf0f0) != 0x20f0)
1239 /* Note that we've changed the relocs, section contents, etc. */
1240 elf_section_data (sec
)->relocs
= internal_relocs
;
1241 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1242 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1244 /* Fix the opcode. */
1245 bfd_put_8 (abfd
, (code
& 0xff) - 0x10, contents
+ irel
->r_offset
);
1247 /* Fix the relocation's type. */
1248 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1251 /* Delete two bytes of data. */
1252 if (!elf32_crx_relax_delete_bytes (link_info
, abfd
, sec
,
1253 irel
->r_offset
+ 2, 2))
1256 /* That will change things, so, we should relax again.
1257 Note that this is not required, and it may be slow. */
1264 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1266 if (! link_info
->keep_memory
)
1270 /* Cache the symbols for elf_link_input_bfd. */
1271 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1275 if (contents
!= NULL
1276 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1278 if (! link_info
->keep_memory
)
1282 /* Cache the section contents for elf_link_input_bfd. */
1283 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1287 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
1288 free (internal_relocs
);
1293 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1295 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
1297 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
1298 free (internal_relocs
);
1303 /* Definitions for setting CRX target vector. */
1304 #define TARGET_LITTLE_SYM crx_elf32_vec
1305 #define TARGET_LITTLE_NAME "elf32-crx"
1306 #define ELF_ARCH bfd_arch_crx
1307 #define ELF_MACHINE_CODE EM_CRX
1308 #define ELF_MAXPAGESIZE 0x1
1309 #define elf_symbol_leading_char '_'
1311 #define bfd_elf32_bfd_reloc_type_lookup elf_crx_reloc_type_lookup
1312 #define bfd_elf32_bfd_reloc_name_lookup \
1313 elf_crx_reloc_name_lookup
1314 #define elf_info_to_howto elf_crx_info_to_howto
1315 #define elf_info_to_howto_rel NULL
1316 #define elf_backend_relocate_section elf32_crx_relocate_section
1317 #define bfd_elf32_bfd_relax_section elf32_crx_relax_section
1318 #define bfd_elf32_bfd_get_relocated_section_contents \
1319 elf32_crx_get_relocated_section_contents
1320 #define elf_backend_can_gc_sections 1
1321 #define elf_backend_rela_normal 1
1323 #include "elf32-target.h"