1 /* 32-bit ELF support for C-SKY.
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
3 Contributed by C-SKY Microsystems and Mentor Graphics.
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. */
28 #include "opcode/csky.h"
30 #include "libiberty.h"
31 #include "elf32-csky.h"
33 /* Data structures used for merging different arch variants.
34 V1 (510/610) and V2 (8xx) processors are incompatible, but
35 we can merge wthin each family. */
43 typedef struct csky_arch_for_merge
46 const unsigned long arch_eflag
;
47 /* The files can merge only if they are in same class. */
48 enum merge_class
class;
49 /* When input files have different levels,
50 the target sets arch_eflag to the largest level file's arch_eflag. */
51 unsigned int class_level
;
52 /* Control whether to print warning when merging with different arch. */
53 unsigned int do_warning
;
54 } csky_arch_for_merge
;
56 static struct csky_arch_for_merge csky_archs
[] =
58 /* 510 and 610 merge to 610 without warning. */
59 { "510", CSKY_ARCH_510
, CSKY_V1
, 0, 0},
60 { "610", CSKY_ARCH_610
, CSKY_V1
, 1, 0},
61 /* 801, 802, 803, 807, 810 merge to largest one. */
62 { "801", CSKY_ARCH_801
, CSKY_V2
, 0, 1},
63 { "802", CSKY_ARCH_802
, CSKY_V2
, 1, 1},
64 { "803", CSKY_ARCH_803
, CSKY_V2
, 2, 1},
65 { "807", CSKY_ARCH_807
, CSKY_V2
, 3, 1},
66 { "810", CSKY_ARCH_810
, CSKY_V2
, 4, 1},
70 /* Return the ARCH bits out of ABFD. */
71 #define bfd_csky_arch(abfd) \
72 (elf_elfheader (abfd)->e_flags & CSKY_ARCH_MASK)
74 /* Return the ABI bits out of ABFD. */
75 #define bfd_csky_abi(abfd) \
76 (elf_elfheader (abfd)->e_flags & CSKY_ABI_MASK)
79 /* The index of a howto-item is implicitly equal to
80 the corresponding Relocation Type Encoding. */
81 static reloc_howto_type csky_elf_howto_table
[] =
84 HOWTO (R_CKCORE_NONE
, /* type */
88 FALSE
, /* pc_relative */
90 complain_overflow_dont
, /* complain_on_overflow */
91 NULL
, /* special_function */
92 "R_CKCORE_NONE", /* name */
93 FALSE
, /* partial_inplace */
96 FALSE
), /* pcrel_offset */
99 HOWTO (R_CKCORE_ADDR32
, /* type */
103 FALSE
, /* pc_relative */
105 complain_overflow_dont
, /* complain_on_overflow */
106 bfd_elf_generic_reloc
, /* special_function */
107 "R_CKCORE_ADDR32", /* name */
108 FALSE
, /* partial_inplace */
110 0xffffffff, /* dst_mask */
111 FALSE
), /* pcrel_offset */
113 /* 2: Only for csky v1. */
114 HOWTO (R_CKCORE_PCREL_IMM8BY4
, /* type */
118 TRUE
, /* pc_relative */
120 complain_overflow_bitfield
, /* complain_on_overflow */
121 NULL
, /* special_function */
122 "R_CKCORE_PCREL_IMM8BY4", /* name */
123 FALSE
, /* partial_inplace */
126 TRUE
), /* pcrel_offset */
128 /* 3: Only for csky v1. */
129 HOWTO (R_CKCORE_PCREL_IMM11BY2
, /* type */
133 TRUE
, /* pc_relative */
135 complain_overflow_signed
, /* complain_on_overflow */
136 bfd_elf_generic_reloc
, /* special_function */
137 "R_CKCORE_PCREL_IMM11BY2", /* name */
138 FALSE
, /* partial_inplace */
139 0x7ff, /* src_mask */
140 0x7ff, /* dst_mask */
141 TRUE
), /* pcrel_offset */
144 HOWTO (R_CKCORE_PCREL_IMM4BY2
,0,0,0,0,0,0,0,"R_CKCORE_PCREL_IMM4BY2",0,0,0,0),
147 HOWTO (R_CKCORE_PCREL32
, /* type */
151 TRUE
, /* pc_relative */
153 complain_overflow_dont
, /* complain_on_overflow */
154 bfd_elf_generic_reloc
, /* special_function */
155 "R_CKCORE_PCREL32", /* name */
156 FALSE
, /* partial_inplace */
158 0xffffffff, /* dst_mask */
159 TRUE
), /* pcrel_offset */
161 /* 6: Only for csky v1. */
162 HOWTO (R_CKCORE_PCREL_JSR_IMM11BY2
, /* type */
166 TRUE
, /* pc_relative */
168 complain_overflow_signed
, /* complain_on_overflow */
169 bfd_elf_generic_reloc
, /* special_function */
170 "R_CKCORE_PCREL_JSR_IMM11BY2", /* name */
171 FALSE
, /* partial_inplace */
172 0x7ff, /* src_mask */
173 0x7ff, /* dst_mask */
174 TRUE
), /* pcrel_offset */
176 /* 7: GNU extension to record C++ vtable member usage. */
177 HOWTO (R_CKCORE_GNU_VTENTRY
, /* type */
181 FALSE
, /* pc_relative */
183 complain_overflow_dont
, /* complain_on_overflow */
184 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
185 "R_CKCORE_GNU_VTENTRY", /* name */
186 FALSE
, /* partial_inplace */
189 FALSE
), /* pcrel_offset */
191 /* 8: GNU extension to record C++ vtable hierarchy. */
192 HOWTO (R_CKCORE_GNU_VTINHERIT
, /* type */
196 FALSE
, /* pc_relative */
198 complain_overflow_dont
, /* complain_on_overflow */
199 NULL
, /* special_function */
200 "R_CKCORE_GNU_VTINHERIT", /* name */
201 FALSE
, /* partial_inplace */
204 FALSE
), /* pcrel_offset */
207 HOWTO (R_CKCORE_RELATIVE
, /* type */
211 FALSE
, /* pc_relative */
213 complain_overflow_signed
, /* complain_on_overflow */
214 bfd_elf_generic_reloc
, /* special_function */
215 "R_CKCORE_RELATIVE", /* name */
216 TRUE
, /* partial_inplace */
218 0xffffffff, /* dst_mask */
219 FALSE
), /* pcrel_offset */
222 /* FIXME: It is a bug that copy relocations are not implemented. */
223 HOWTO (R_CKCORE_COPY
, /* type */
227 FALSE
, /* pc_relative */
229 complain_overflow_bitfield
, /* complain_on_overflow */
230 bfd_elf_generic_reloc
, /* special_function */
231 "R_CKCORE_COPY", /* name */
232 TRUE
, /* partial_inplace */
233 0xffffffff, /* src_mask */
234 0xffffffff, /* dst_mask */
235 FALSE
), /* pcrel_offset */
238 HOWTO (R_CKCORE_GLOB_DAT
,0,0,0,0,0,0,0,"R_CKCORE_GLOB_DAT",0,0,0,0),
241 HOWTO (R_CKCORE_JUMP_SLOT
,0,0,0,0,0,0,0,"R_CKCORE_JUMP_SLOT",0,0,0,0),
244 HOWTO (R_CKCORE_GOTOFF
, /* type */
248 FALSE
, /* pc_relative */
250 complain_overflow_dont
, /* complain_on_overflow */
251 bfd_elf_generic_reloc
, /* special_function */
252 "R_CKCORE_GOTOFF", /* name */
253 TRUE
, /* partial_inplace */
255 0xffffffffl
, /* dst_mask */
256 FALSE
), /* pcrel_offset */
259 HOWTO (R_CKCORE_GOTPC
, /* type */
263 TRUE
, /* pc_relative */
265 complain_overflow_dont
, /* complain_on_overflow */
266 bfd_elf_generic_reloc
, /* special_function */
267 "R_CKCORE_GOTPC", /* name */
268 TRUE
, /* partial_inplace */
270 0xffffffff, /* dst_mask */
271 FALSE
), /* pcrel_offset */
274 HOWTO (R_CKCORE_GOT32
, /* type */
278 FALSE
, /* pc_relative */
280 complain_overflow_dont
, /* complain_on_overflow */
281 bfd_elf_generic_reloc
, /* special_function */
282 "R_CKCORE_GOT32", /* name */
283 TRUE
, /* partial_inplace */
285 0xffffffff, /* dst_mask */
286 TRUE
), /* pcrel_offset */
289 HOWTO (R_CKCORE_PLT32
, /* type */
293 FALSE
, /* pc_relative */
295 complain_overflow_dont
, /* complain_on_overflow */
296 bfd_elf_generic_reloc
, /* special_function */
297 "R_CKCORE_PLT32", /* name */
298 TRUE
, /* partial_inplace */
300 0xffffffff, /* dst_mask */
301 TRUE
), /* pcrel_offset */
304 HOWTO (R_CKCORE_ADDRGOT
,0,0,0,0,0,0,0,"R_CKCORE_ADDRGOT",0,0,0,0),
307 HOWTO (R_CKCORE_ADDRPLT
,0,0,0,0,0,0,0,"R_CKCORE_ADDRPLT",0,0,0,0),
309 /* 19: Only for csky v2. */
310 HOWTO (R_CKCORE_PCREL_IMM26BY2
, /* type */
314 TRUE
, /* pc_relative */
316 complain_overflow_signed
, /* complain_on_overflow */
317 bfd_elf_generic_reloc
, /* special_function */
318 "R_CKCORE_PCREL_IMM26BY2", /* name */
319 FALSE
, /* partial_inplace */
321 0x3ffffff, /* dst_mask */
322 TRUE
), /* pcrel_offset */
324 /* 20: Only for csky v2. */
325 HOWTO (R_CKCORE_PCREL_IMM16BY2
, /* type */
329 TRUE
, /* pc_relative */
331 complain_overflow_signed
, /* complain_on_overflow */
332 NULL
, /* special_function */
333 "R_CKCORE_PCREL_IMM16BY2", /* name */
334 FALSE
, /* partial_inplace */
336 0xffff, /* dst_mask */
337 TRUE
), /* pcrel_offset */
339 /* 21: Only for csky v2. */
340 HOWTO (R_CKCORE_PCREL_IMM16BY4
, /* type */
344 TRUE
, /* pc_relative */
346 complain_overflow_bitfield
, /* complain_on_overflow */
347 NULL
, /* special_function */
348 "R_CKCORE_PCREL_IMM16BY4", /* name */
349 FALSE
, /* partial_inplace */
350 0xffff0000, /* src_mask */
351 0xffff, /* dst_mask */
352 TRUE
), /* pcrel_offset */
354 /* 22: Only for csky v2. */
355 HOWTO (R_CKCORE_PCREL_IMM10BY2
, /* type */
359 TRUE
, /* pc_relative */
361 complain_overflow_signed
, /* complain_on_overflow */
362 bfd_elf_generic_reloc
, /* special_function */
363 "R_CKCORE_PCREL_IMM10BY2", /* name */
364 FALSE
, /* partial_inplace */
366 0x3ff, /* dst_mask */
367 TRUE
), /* pcrel_offset */
369 /* 23: Only for csky v2. */
370 HOWTO (R_CKCORE_PCREL_IMM10BY4
, /* type */
374 TRUE
, /* pc_relative */
376 complain_overflow_bitfield
, /* complain_on_overflow */
377 NULL
, /* special_function */
378 "R_CKCORE_PCREL_IMM10BY4", /* name */
379 FALSE
, /* partial_inplace */
381 0x3ff, /* dst_mask */
382 TRUE
), /* pcrel_offset */
384 /* 24: Only for csky v2. */
385 HOWTO (R_CKCORE_ADDR_HI16
, /* type */
389 FALSE
, /* pc_relative */
391 complain_overflow_dont
, /* complain_on_overflow */
392 bfd_elf_generic_reloc
, /* special_function */
393 "R_CKCORE_ADDR_HI16", /* name */
394 FALSE
, /* partial_inplace */
396 0xffff, /* dst_mask */
397 FALSE
), /* pcrel_offset */
400 HOWTO (R_CKCORE_ADDR_LO16
, /* type */
404 FALSE
, /* pc_relative */
406 complain_overflow_dont
, /* complain_on_overflow */
407 bfd_elf_generic_reloc
, /* special_function */
408 "R_CKCORE_ADDR_LO16", /* name */
409 FALSE
, /* partial_inplace */
411 0xffff, /* dst_mask */
412 FALSE
), /* pcrel_offset */
415 HOWTO (R_CKCORE_GOTPC_HI16
, /* type */
419 TRUE
, /* pc_relative */
421 complain_overflow_dont
, /* complain_on_overflow */
422 bfd_elf_generic_reloc
, /* special_function */
423 "R_CKCORE_GOTPC_HI16", /* name */
424 FALSE
, /* partial_inplace */
426 0xffff, /* dst_mask */
427 FALSE
), /* pcrel_offset */
430 HOWTO (R_CKCORE_GOTPC_LO16
, /* type */
434 TRUE
, /* pc_relative */
436 complain_overflow_dont
, /* complain_on_overflow */
437 bfd_elf_generic_reloc
, /* special_function */
438 "R_CKCORE_GOTPC_LO16", /* name */
439 FALSE
, /* partial_inplace */
441 0xffff, /* dst_mask */
442 FALSE
), /* pcrel_offset */
445 HOWTO (R_CKCORE_GOTOFF_HI16
, /* type */
449 FALSE
, /* pc_relative */
451 complain_overflow_dont
, /* complain_on_overflow */
452 bfd_elf_generic_reloc
, /* special_function */
453 "R_CKCORE_GOTOFF_HI16", /* name */
454 FALSE
, /* partial_inplace */
456 0xffff, /* dst_mask */
457 FALSE
), /* pcrel_offset */
460 HOWTO (R_CKCORE_GOTOFF_LO16
, /* type */
464 FALSE
, /* pc_relative */
466 complain_overflow_dont
, /* complain_on_overflow */
467 bfd_elf_generic_reloc
, /* special_function */
468 "R_CKCORE_GOTOFF_LO16", /* name */
469 FALSE
, /* partial_inplace */
471 0xffff, /* dst_mask */
472 FALSE
), /* pcrel_offset */
475 HOWTO (R_CKCORE_GOT12
, /* type */
479 FALSE
, /* pc_relative */
481 complain_overflow_bitfield
, /* complain_on_overflow */
482 bfd_elf_generic_reloc
, /* special_function */
483 "R_CKCORE_GOT12", /* name */
484 TRUE
, /* partial_inplace */
486 0xfff, /* dst_mask */
487 FALSE
), /* pcrel_offset */
490 HOWTO (R_CKCORE_GOT_HI16
, /* type */
494 FALSE
, /* pc_relative */
496 complain_overflow_dont
, /* complain_on_overflow */
497 bfd_elf_generic_reloc
, /* special_function */
498 "R_CKCORE_GOT_HI16", /* name */
499 TRUE
, /* partial_inplace */
501 0xffff, /* dst_mask */
502 FALSE
), /* pcrel_offset */
505 HOWTO (R_CKCORE_GOT_LO16
, /* type */
509 FALSE
, /* pc_relative */
511 complain_overflow_dont
, /* complain_on_overflow */
512 bfd_elf_generic_reloc
, /* special_function */
513 "R_CKCORE_GOT_LO16", /* name */
514 TRUE
, /* partial_inplace */
516 0xffff, /* dst_mask */
517 FALSE
), /* pcrel_offset */
520 HOWTO (R_CKCORE_PLT12
, /* type */
524 FALSE
, /* pc_relative */
526 complain_overflow_bitfield
, /* complain_on_overflow */
527 bfd_elf_generic_reloc
, /* special_function */
528 "R_CKCORE_PLT12", /* name */
529 TRUE
, /* partial_inplace */
531 0xfff, /* dst_mask */
532 FALSE
), /* pcrel_offset */
535 HOWTO (R_CKCORE_PLT_HI16
, /* type */
539 FALSE
, /* pc_relative */
541 complain_overflow_dont
, /* complain_on_overflow */
542 bfd_elf_generic_reloc
, /* special_function */
543 "R_CKCORE_PLT_HI16", /* name */
544 TRUE
, /* partial_inplace */
546 0xffff, /* dst_mask */
547 FALSE
), /* pcrel_offset */
550 HOWTO (R_CKCORE_PLT_LO16
, /* type */
554 FALSE
, /* pc_relative */
556 complain_overflow_dont
, /* complain_on_overflow */
557 bfd_elf_generic_reloc
, /* special_function */
558 "R_CKCORE_PLT_LO16", /* name */
559 TRUE
, /* partial_inplace */
561 0xffff, /* dst_mask */
562 FALSE
), /* pcrel_offset */
565 HOWTO (R_CKCORE_ADDRGOT_HI16
,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
568 HOWTO (R_CKCORE_ADDRGOT_LO16
,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
571 HOWTO (R_CKCORE_ADDRPLT_HI16
,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
574 HOWTO (R_CKCORE_ADDRPLT_LO16
,0,0,0,0,0,0,0,"R_CKCORE_",0,0,0,0),
577 HOWTO (R_CKCORE_PCREL_JSR_IMM26BY2
, /* type */
581 TRUE
, /* pc_relative */
583 complain_overflow_signed
, /* complain_on_overflow */
584 bfd_elf_generic_reloc
, /* special_function */
585 "R_CKCORE_PCREL_JSR_IMM26BY2", /* name */
586 FALSE
, /* partial_inplace */
588 0x3ffffff, /* dst_mask */
589 TRUE
), /* pcrel_offset */
592 HOWTO (R_CKCORE_TOFFSET_LO16
, /* type */
596 FALSE
, /* pc_relative */
598 complain_overflow_unsigned
, /* complain_on_overflow */
599 NULL
, /* special_function */
600 "R_CKCORE_TOFFSET_LO16", /* name */
601 FALSE
, /* partial_inplace */
603 0xffff, /* dst_mask */
604 FALSE
), /* pcrel_offset */
607 HOWTO (R_CKCORE_DOFFSET_LO16
, /* type */
611 FALSE
, /* pc_relative */
613 complain_overflow_unsigned
, /* complain_on_overflow */
614 NULL
, /* special_function */
615 "R_CKCORE_DOFFSET_LO16", /* name */
616 FALSE
, /* partial_inplace */
618 0xffff, /* dst_mask */
619 FALSE
), /* pcrel_offset */
622 HOWTO (R_CKCORE_PCREL_IMM18BY2
, /* type */
626 TRUE
, /* pc_relative */
628 complain_overflow_signed
, /* complain_on_overflow */
629 NULL
, /* special_function */
630 "R_CKCORE_PCREL_IMM18BY2", /* name */
631 FALSE
, /* partial_inplace */
633 0x3ffff, /* dst_mask */
634 TRUE
), /* pcrel_offset */
637 HOWTO (R_CKCORE_DOFFSET_IMM18
, /* type */
641 FALSE
, /* pc_relative */
643 complain_overflow_unsigned
, /* complain_on_overflow */
644 NULL
, /* special_function */
645 "R_CKCORE_DOFFSET_IMM18", /* name */
646 FALSE
, /* partial_inplace */
648 0x3ffff, /* dst_mask */
649 FALSE
), /* pcrel_offset */
652 HOWTO (R_CKCORE_DOFFSET_IMM18BY2
, /* type */
656 FALSE
, /* pc_relative */
658 complain_overflow_unsigned
, /* complain_on_overflow */
659 NULL
, /* special_function */
660 "R_CKCORE_DOFFSET_IMM18BY2", /* name */
661 FALSE
, /* partial_inplace */
663 0x3ffff, /* dst_mask */
664 FALSE
), /* pcrel_offset */
667 HOWTO (R_CKCORE_DOFFSET_IMM18BY4
, /* type */
671 FALSE
, /* pc_relative */
673 complain_overflow_unsigned
, /* complain_on_overflow */
674 NULL
, /* special_function */
675 "R_CKCORE_DOFFSET_IMM18BY4", /* name */
676 FALSE
, /* partial_inplace */
678 0x3ffff, /* dst_mask */
679 FALSE
), /* pcrel_offset */
682 HOWTO (R_CKCORE_GOTOFF_IMM18
, /* type */
686 FALSE
, /* pc_relative */
688 complain_overflow_bitfield
, /* complain_on_overflow */
689 bfd_elf_generic_reloc
, /* special_function */
690 "R_CKCORE_GOTOFF_IMM18", /* name */
691 TRUE
, /* partial_inplace */
692 0xfffc, /* src_mask */
693 0x3ffff, /* dst_mask */
694 FALSE
), /* pcrel_offset */
697 HOWTO (R_CKCORE_GOT_IMM18BY4
, /* type */
701 FALSE
, /* pc_relative */
703 complain_overflow_bitfield
, /* complain_on_overflow */
704 bfd_elf_generic_reloc
, /* special_function */
705 "R_CKCORE_GOT_IMM18BY4", /* name */
706 TRUE
, /* partial_inplace */
707 0xfffc, /* src_mask */
708 0x3ffff, /* dst_mask */
709 FALSE
), /* pcrel_offset */
712 HOWTO (R_CKCORE_PLT_IMM18BY4
, /* type */
716 FALSE
, /* pc_relative */
718 complain_overflow_bitfield
, /* complain_on_overflow */
719 bfd_elf_generic_reloc
, /* special_function */
720 "R_CKCORE_PLT_IMM18BY4", /* name */
721 TRUE
, /* partial_inplace */
722 0xfffc, /* src_mask */
723 0x3ffff, /* dst_mask */
724 TRUE
), /* pcrel_offset */
727 HOWTO (R_CKCORE_PCREL_IMM7BY4
, /* type */
731 TRUE
, /* pc_relative */
733 complain_overflow_bitfield
, /* complain_on_overflow */
734 bfd_elf_generic_reloc
, /* special_function */
735 "R_CKCORE_PCREL_IMM7BY4", /* name */
736 FALSE
, /* partial_inplace */
737 0xec1f, /* src_mask */
738 0x31f, /* dst_mask */
739 TRUE
), /* pcrel_offset */
741 /* 51: for static nptl. */
742 HOWTO (R_CKCORE_TLS_LE32
, /* type */
746 FALSE
, /* pc_relative */
748 complain_overflow_dont
, /* complain_on_overflow */
749 bfd_elf_generic_reloc
, /* special_function */
750 "R_CKCORE_TLS_LE32", /* name */
751 FALSE
, /* partial_inplace */
753 0xffffffff, /* dst_mask */
754 TRUE
), /* pcrel_offset */
756 /* 52: for static nptl. */
757 HOWTO (R_CKCORE_TLS_IE32
, /* type */
761 FALSE
, /* pc_relative */
763 complain_overflow_dont
, /* complain_on_overflow */
764 bfd_elf_generic_reloc
, /* special_function */
765 "R_CKCORE_TLS_IE32", /* name */
766 FALSE
, /* partial_inplace */
768 0xffffffff, /* dst_mask */
769 TRUE
), /* pcrel_offset */
771 /* 53: for pic nptl. */
772 HOWTO (R_CKCORE_TLS_GD32
, /* type */
776 FALSE
, /* pc_relative */
778 complain_overflow_dont
, /* complain_on_overflow */
779 bfd_elf_generic_reloc
, /* special_function */
780 "R_CKCORE_TLS_GD32", /* name */
781 FALSE
, /* partial_inplace */
783 0xffffffff, /* dst_mask */
784 TRUE
), /* pcrel_offset */
786 /* 54: for pic nptl. */
787 HOWTO (R_CKCORE_TLS_LDM32
, /* type */
791 FALSE
, /* pc_relative */
793 complain_overflow_dont
, /* complain_on_overflow */
794 bfd_elf_generic_reloc
, /* special_function */
795 "R_CKCORE_TLS_LDM32", /* name */
796 FALSE
, /* partial_inplace */
798 0xffffffff, /* dst_mask */
799 TRUE
), /* pcrel_offset */
801 /* 55: for pic nptl. */
802 HOWTO (R_CKCORE_TLS_LDO32
, /* type */
806 FALSE
, /* pc_relative */
808 complain_overflow_dont
, /* complain_on_overflow */
809 bfd_elf_generic_reloc
, /* special_function */
810 "R_CKCORE_TLS_LDO32", /* name */
811 FALSE
, /* partial_inplace */
813 0xffffffff, /* dst_mask */
814 TRUE
), /* pcrel_offset */
816 /* 56: for linker. */
817 HOWTO (R_CKCORE_TLS_DTPMOD32
,0,0,0,0,0,0,0,"R_CKCORE_TLS_DTPMOD32",0,0,0,0),
819 /* 57: for linker. */
820 HOWTO (R_CKCORE_TLS_DTPOFF32
,0,0,0,0,0,0,0,"R_CKCORE_TLS_DTPOFF32",0,0,0,0),
822 /* 58: for linker. */
823 HOWTO (R_CKCORE_TLS_TPOFF32
,0,0,0,0,0,0,0,"R_CKCORE_TLS_TPOFF32",0,0,0,0),
825 /* 59: for ck807f. */
826 HOWTO (R_CKCORE_PCREL_FLRW_IMM8BY4
, /* type */
830 TRUE
, /* pc_relative */
832 complain_overflow_bitfield
, /* complain_on_overflow */
833 NULL
, /* special_function */
834 "R_CKCORE_PCREL_FLRW_IMM8BY4", /* name */
835 FALSE
, /* partial_inplace */
836 0xfe1fff0f, /* src_mask */
837 0x1e000f0, /* dst_mask */
838 TRUE
), /* pcrel_offset */
840 /* 60: for 810 not to generate jsri. */
841 HOWTO (R_CKCORE_NOJSRI
, /* type */
845 FALSE
, /* pc_relative */
847 complain_overflow_dont
, /* complain_on_overflow */
848 bfd_elf_generic_reloc
, /* special_function */
849 "R_CKCORE_NOJSRI", /* name */
850 FALSE
, /* partial_inplace */
851 0xffff, /* src_mask */
852 0xffff, /* dst_mask */
853 FALSE
), /* pcrel_offset */
855 /* 61: for callgraph. */
856 HOWTO (R_CKCORE_CALLGRAPH
, /* type */
860 FALSE
, /* pc_relative */
862 complain_overflow_dont
, /* complain_on_overflow */
863 NULL
, /* special_function */
864 "R_CKCORE_CALLGRAPH", /* name */
865 FALSE
, /* partial_inplace */
868 TRUE
), /* pcrel_offset */
871 HOWTO (R_CKCORE_IRELATIVE
,0,0,0,0,0,0,0,"R_CKCORE_IRELATIVE",0,0,0,0),
873 /* 63: for bloop instruction */
874 HOWTO (R_CKCORE_PCREL_BLOOP_IMM4BY4
, /* type */
880 complain_overflow_signed
, /* complain_on_overflow */
881 bfd_elf_generic_reloc
, /* special_function */
882 "R_CKCORE_PCREL_BLOOP_IMM4BY4", /* name */
883 FALSE
, /* partial_inplace */
886 TRUE
), /* pcrel_offset */
887 /* 64: for bloop instruction */
888 HOWTO (R_CKCORE_PCREL_BLOOP_IMM12BY4
, /* type */
894 complain_overflow_signed
, /* complain_on_overflow */
895 bfd_elf_generic_reloc
, /* special_function */
896 "R_CKCORE_PCREL_BLOOP_IMM12BY4", /* name */
897 FALSE
, /* partial_inplace */
899 0xfff, /* dst_mask */
900 TRUE
), /* pcrel_offset */
906 /* Whether GOT overflow checking is needed. */
907 static int check_got_overflow
= 0;
909 /* Whether the target 32 bits is forced so that the high
910 16 bits is at the low address. */
911 static int need_reverse_bits
;
913 /* Used for relaxation. See csky_relocate_contents. */
914 static bfd_vma read_content_substitute
;
917 The way the following two look-up functions work demands
918 that BFD_RELOC_CKCORE_xxx are defined contiguously. */
920 static reloc_howto_type
*
921 csky_elf_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
922 bfd_reloc_code_real_type code
)
924 int csky_code
= code
- BFD_RELOC_CKCORE_NONE
;
926 if (csky_code
< 0 || csky_code
>= R_CKCORE_MAX
)
931 csky_code
= R_CKCORE_NONE
;
934 csky_code
= R_CKCORE_ADDR32
;
936 case BFD_RELOC_32_PCREL
:
937 csky_code
= R_CKCORE_PCREL32
;
939 case BFD_RELOC_VTABLE_INHERIT
:
940 csky_code
= R_CKCORE_GNU_VTINHERIT
;
942 case BFD_RELOC_VTABLE_ENTRY
:
943 csky_code
= R_CKCORE_GNU_VTENTRY
;
946 csky_code
= R_CKCORE_RELATIVE
;
949 return (reloc_howto_type
*)NULL
;
952 /* Note: when adding csky bfd reloc types in bfd-in2.h
953 and csky elf reloc types in elf/csky.h,
954 the order of the two reloc type tables should be consistent. */
955 return &csky_elf_howto_table
[csky_code
];
958 static reloc_howto_type
*
959 csky_elf_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
963 for (i
= 0; i
< R_CKCORE_MAX
; i
++)
964 if (strcasecmp (csky_elf_howto_table
[i
].name
, r_name
) == 0)
965 return &csky_elf_howto_table
[i
];
969 static reloc_howto_type
*
970 elf32_csky_howto_from_type (unsigned int r_type
)
972 if (r_type
< R_CKCORE_MAX
)
973 return &csky_elf_howto_table
[r_type
];
979 csky_elf_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
981 Elf_Internal_Rela
*dst
)
985 r_type
= ELF32_R_TYPE (dst
->r_info
);
986 cache_ptr
->howto
= elf32_csky_howto_from_type (r_type
);
987 if (cache_ptr
->howto
== NULL
)
989 /* xgettext:c-format */
990 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
992 bfd_set_error (bfd_error_bad_value
);
998 /* The Global Offset Table max size. */
999 #define GOT_MAX_SIZE 0xFFFF8
1001 /* The name of the dynamic interpreter. This is put in the .interp
1003 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
1005 /* The size in bytes of an entry in the procedure linkage table. */
1006 #define PLT_ENTRY_SIZE 12
1007 #define PLT_ENTRY_SIZE_P 16
1009 /* The first entry in a procedure linkage table looks like
1010 this. It is set up so that any shared library function that is
1011 called before the relocation has been set up calls the dynamic
1013 static const bfd_vma csky_elf_plt_entry_v2
[PLT_ENTRY_SIZE
/ 4] =
1015 0xd99c2002, /* ldw r12, (gb, 8) */
1016 0xea0d0000, /* movi r13,offset */
1017 0xe8cc0000 /* jmp r12 */
1020 static const bfd_vma csky_elf_plt_entry_v1
[PLT_ENTRY_SIZE
/ 2 ] =
1022 0x25f0, /* subi r0, 32 */
1023 0x9200, /* stw r2, (r0, 0) */
1024 0x9310, /* stw r3, (r0, 4) */
1025 0x822e, /* ldw r2, (gb, 8) */
1026 0x7301, /* lrw r3, #offset */
1027 0x00c2, /* jmp r2 */
1030 /* Branch stub support. */
1039 bfd_boolean use_branch_stub
= TRUE
;
1043 enum stub_insn_type type
;
1044 unsigned int r_type
;
1048 static const insn_sequence elf32_csky_stub_long_branch
[] =
1050 {0xea8d0002, INSN32
, R_CKCORE_NONE
, 0x0}, /* lrw t1,[pc+8] */
1051 {0x7834, INSN16
, R_CKCORE_NONE
, 0x0}, /* jmp t1 */
1052 {0x6c03, INSN16
, R_CKCORE_NONE
, 0x0}, /* nop */
1053 {0x0, DATA_TYPE
, R_CKCORE_ADDR32
, 0x0} /* .long addr */
1056 static const insn_sequence elf32_csky_stub_long_branch_jmpi
[] =
1058 {0xeac00001, INSN32
, R_CKCORE_NONE
, 0x0}, /* jmpi [pc+4] */
1059 {0x0, DATA_TYPE
, R_CKCORE_ADDR32
, 0x0} /* .long addr */
1062 /* The bsr instruction offset limit. */
1063 #define BSR_MAX_FWD_BRANCH_OFFSET (((1 << 25) - 1) << 1)
1064 #define BSR_MAX_BWD_BRANCH_OFFSET (-(1 << 26))
1066 #define STUB_SUFFIX ".stub"
1067 #define STUB_ENTRY_NAME "__%s_veneer"
1069 /* One entry per long/short branch stub defined above. */
1071 DEF_STUB(long_branch) \
1072 DEF_STUB(long_branch_jmpi)
1074 #define DEF_STUB(x) csky_stub_##x,
1075 enum elf32_csky_stub_type
1084 const insn_sequence
* template_sequence
;
1088 #define DEF_STUB(x) {elf32_csky_stub_##x, ARRAY_SIZE(elf32_csky_stub_##x)},
1089 static const stub_def stub_definitions
[] = {
1094 /* The size of the thread control block. */
1097 struct csky_elf_obj_tdata
1099 struct elf_obj_tdata root
;
1101 /* tls_type for each local got entry. */
1102 char *local_got_tls_type
;
1105 #define csky_elf_local_got_tls_type(bfd) \
1106 (csky_elf_tdata (bfd)->local_got_tls_type)
1108 #define csky_elf_tdata(bfd) \
1109 ((struct csky_elf_obj_tdata *) (bfd)->tdata.any)
1111 struct elf32_csky_stub_hash_entry
1113 /* Base hash table entry structure. */
1114 struct bfd_hash_entry root
;
1116 /* The stub section. */
1119 /* Offset within stub_sec of the beginning of this stub. */
1120 bfd_vma stub_offset
;
1122 /* Given the symbol's value and its section we can determine its final
1123 value when building the stubs (so the stub knows where to jump). */
1124 bfd_vma target_value
;
1125 asection
*target_section
;
1127 /* Offset to apply to relocation referencing target_value. */
1128 bfd_vma target_addend
;
1130 /* The stub type. */
1131 enum elf32_csky_stub_type stub_type
;
1132 /* Its encoding size in bytes. */
1135 const insn_sequence
*stub_template
;
1136 /* The size of the template (number of entries). */
1137 int stub_template_size
;
1139 /* The symbol table entry, if any, that this was derived from. */
1140 struct csky_elf_link_hash_entry
*h
;
1142 /* Destination symbol type. */
1143 unsigned char st_type
;
1145 /* Where this stub is being called from, or, in the case of combined
1146 stub sections, the first input section in the group. */
1149 /* The name for the local symbol at the start of this stub. The
1150 stub name in the hash table has to be unique; this does not, so
1151 it can be friendlier. */
1155 #define csky_stub_hash_lookup(table, string, create, copy) \
1156 ((struct elf32_csky_stub_hash_entry *) \
1157 bfd_hash_lookup ((table), (string), (create), (copy)))
1159 /* C-SKY ELF linker hash entry. */
1160 struct csky_elf_link_hash_entry
1162 struct elf_link_hash_entry elf
;
1164 /* For sub jsri2bsr relocs count. */
1165 int jsri2bsr_refcount
;
1166 /* Track dynamic relocs copied for this symbol. */
1167 struct elf_dyn_relocs
*dyn_relocs
;
1169 #define GOT_UNKNOWN 0
1170 #define GOT_NORMAL 1
1171 #define GOT_TLS_GD 2
1172 #define GOT_TLS_IE 4
1174 unsigned char tls_type
;
1176 /* A pointer to the most recently used stub hash entry against this
1178 struct elf32_csky_stub_hash_entry
*stub_cache
;
1181 /* Traverse an C-SKY ELF linker hash table. */
1182 #define csky_elf_link_hash_traverse(table, func, info) \
1183 (elf_link_hash_traverse \
1185 (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
1188 /* Get the C-SKY ELF linker hash table from a link_info structure. */
1189 #define csky_elf_hash_table(info) \
1190 ((elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
1192 ? ((struct csky_elf_link_hash_table *) ((info)->hash)) \
1195 #define csky_elf_hash_entry(ent) ((struct csky_elf_link_hash_entry*)(ent))
1197 /* Array to keep track of which stub sections have been created, and
1198 information on stub grouping. */
1201 /* This is the section to which stubs in the group will be
1204 /* The stub section. */
1208 /* C-SKY ELF linker hash table. */
1209 struct csky_elf_link_hash_table
1211 struct elf_link_hash_table elf
;
1213 /* Small local sym cache. */
1214 struct sym_cache sym_cache
;
1216 /* Data for R_CKCORE_TLS_LDM32 relocations. */
1219 bfd_signed_vma refcount
;
1223 /* The stub hash table. */
1224 struct bfd_hash_table stub_hash_table
;
1226 /* Linker stub bfd. */
1229 /* Linker call-backs. */
1230 asection
* (*add_stub_section
) (const char *, asection
*);
1231 void (*layout_sections_again
) (void);
1233 /* Array to keep track of which stub sections have been created, and
1234 * information on stub grouping. */
1235 struct map_stub
*stub_group
;
1237 /* Number of elements in stub_group. */
1238 unsigned int top_id
;
1240 /* Assorted information used by elf32_csky_size_stubs. */
1241 unsigned int bfd_count
;
1242 unsigned int top_index
;
1243 asection
**input_list
;
1246 /* We can't change vectors in the bfd target which will apply to
1247 data sections, however we only do this to the text sections. */
1250 csky_get_insn_32 (bfd
*input_bfd
,
1253 if (bfd_big_endian (input_bfd
))
1254 return bfd_get_32 (input_bfd
, location
);
1256 return (bfd_get_16 (input_bfd
, location
) << 16
1257 | bfd_get_16 (input_bfd
, location
+ 2));
1261 csky_put_insn_32 (bfd
*input_bfd
,
1265 if (bfd_big_endian (input_bfd
))
1266 bfd_put_32 (input_bfd
, x
, location
);
1269 bfd_put_16 (input_bfd
, x
>> 16, location
);
1270 bfd_put_16 (input_bfd
, x
& 0xffff, location
+ 2);
1274 /* Find or create a stub section. Returns a pointer to the stub section, and
1275 the section to which the stub section will be attached (in *LINK_SEC_P).
1276 LINK_SEC_P may be NULL. */
1279 elf32_csky_create_or_find_stub_sec (asection
**link_sec_p
, asection
*section
,
1280 struct csky_elf_link_hash_table
*htab
)
1285 link_sec
= htab
->stub_group
[section
->id
].link_sec
;
1286 stub_sec
= htab
->stub_group
[section
->id
].stub_sec
;
1287 if (stub_sec
== NULL
)
1289 stub_sec
= htab
->stub_group
[link_sec
->id
].stub_sec
;
1290 if (stub_sec
== NULL
)
1296 namelen
= strlen (link_sec
->name
);
1297 len
= namelen
+ sizeof (STUB_SUFFIX
);
1298 s_name
= bfd_alloc (htab
->stub_bfd
, len
);
1302 memcpy (s_name
, link_sec
->name
, namelen
);
1303 memcpy (s_name
+ namelen
, STUB_SUFFIX
, sizeof (STUB_SUFFIX
));
1304 stub_sec
= (*htab
->add_stub_section
) (s_name
, link_sec
);
1305 if (stub_sec
== NULL
)
1307 htab
->stub_group
[link_sec
->id
].stub_sec
= stub_sec
;
1309 htab
->stub_group
[section
->id
].stub_sec
= stub_sec
;
1313 *link_sec_p
= link_sec
;
1318 /* Build a name for an entry in the stub hash table. */
1321 elf32_csky_stub_name (const asection
*input_section
,
1322 const asection
*sym_sec
,
1323 const struct csky_elf_link_hash_entry
*hash
,
1324 const Elf_Internal_Rela
*rel
)
1331 len
= 8 + 1 + strlen (hash
->elf
.root
.root
.string
) + 1 + 8 + 1;
1332 stub_name
= bfd_malloc (len
);
1333 if (stub_name
!= NULL
)
1334 sprintf (stub_name
, "%08x_%s+%x",
1335 input_section
->id
& 0xffffffff,
1336 hash
->elf
.root
.root
.string
,
1337 (int) rel
->r_addend
& 0xffffffff);
1341 len
= 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
1342 stub_name
= bfd_malloc (len
);
1343 if (stub_name
!= NULL
)
1344 sprintf (stub_name
, "%08x_%x:%x+%x",
1345 input_section
->id
& 0xffffffff,
1346 sym_sec
->id
& 0xffffffff,
1347 (int) ELF32_R_SYM (rel
->r_info
) & 0xffffffff,
1348 (int) rel
->r_addend
& 0xffffffff);
1354 /* Determine the type of stub needed, if any, for a call. */
1356 static enum elf32_csky_stub_type
1357 csky_type_of_stub (struct bfd_link_info
*info
,
1358 asection
*input_sec
,
1359 const Elf_Internal_Rela
*rel
,
1360 unsigned char st_type
,
1361 struct csky_elf_link_hash_entry
*hash
,
1362 bfd_vma destination
,
1363 asection
*sym_sec ATTRIBUTE_UNUSED
,
1364 bfd
*input_bfd ATTRIBUTE_UNUSED
,
1365 const char *name ATTRIBUTE_UNUSED
)
1368 bfd_signed_vma branch_offset
;
1369 unsigned int r_type
;
1370 enum elf32_csky_stub_type stub_type
= csky_stub_none
;
1371 struct elf_link_hash_entry
* h
= &hash
->elf
;
1373 /* We don't know the actual type of destination in case it is of
1374 type STT_SECTION: give up. */
1375 if (st_type
== STT_SECTION
)
1378 location
= (input_sec
->output_offset
1379 + input_sec
->output_section
->vma
1382 branch_offset
= (bfd_signed_vma
)(destination
- location
);
1383 r_type
= ELF32_R_TYPE (rel
->r_info
);
1384 if (r_type
== R_CKCORE_PCREL_IMM26BY2
1386 && ((h
->def_dynamic
&& !h
->def_regular
)
1387 || (bfd_link_pic (info
)
1388 && h
->root
.type
== bfd_link_hash_defweak
)))
1389 || branch_offset
> BSR_MAX_FWD_BRANCH_OFFSET
1390 || branch_offset
< BSR_MAX_BWD_BRANCH_OFFSET
))
1392 if (bfd_csky_arch (info
->output_bfd
) == CSKY_ARCH_810
1393 || bfd_csky_arch (info
->output_bfd
) == CSKY_ARCH_807
)
1394 stub_type
= csky_stub_long_branch_jmpi
;
1396 stub_type
= csky_stub_long_branch
;
1402 /* Create an entry in an C-SKY ELF linker hash table. */
1404 static struct bfd_hash_entry
*
1405 csky_elf_link_hash_newfunc (struct bfd_hash_entry
* entry
,
1406 struct bfd_hash_table
* table
,
1407 const char * string
)
1409 struct csky_elf_link_hash_entry
* ret
=
1410 (struct csky_elf_link_hash_entry
*) entry
;
1412 /* Allocate the structure if it has not already been allocated by a
1416 ret
= (struct csky_elf_link_hash_entry
*)
1417 bfd_hash_allocate (table
,
1418 sizeof (struct csky_elf_link_hash_entry
));
1420 return (struct bfd_hash_entry
*) ret
;
1423 /* Call the allocation method of the superclass. */
1424 ret
= ((struct csky_elf_link_hash_entry
*)
1425 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*)ret
,
1429 struct csky_elf_link_hash_entry
*eh
;
1431 eh
= (struct csky_elf_link_hash_entry
*) ret
;
1432 eh
->dyn_relocs
= NULL
;
1433 eh
->plt_refcount
= 0;
1434 eh
->jsri2bsr_refcount
= 0;
1435 eh
->tls_type
= GOT_NORMAL
;
1436 ret
->stub_cache
= NULL
;
1439 return (struct bfd_hash_entry
*) ret
;
1442 /* Initialize an entry in the stub hash table. */
1444 static struct bfd_hash_entry
*
1445 stub_hash_newfunc (struct bfd_hash_entry
*entry
,
1446 struct bfd_hash_table
*table
,
1449 /* Allocate the structure if it has not already been allocated by a
1453 entry
= ((struct bfd_hash_entry
*)
1454 bfd_hash_allocate (table
,
1455 sizeof (struct elf32_csky_stub_hash_entry
)));
1460 /* Call the allocation method of the superclass. */
1461 entry
= bfd_hash_newfunc (entry
, table
, string
);
1464 struct elf32_csky_stub_hash_entry
*eh
;
1466 /* Initialize the local fields. */
1467 eh
= (struct elf32_csky_stub_hash_entry
*) entry
;
1468 eh
->stub_sec
= NULL
;
1469 eh
->stub_offset
= 0;
1470 eh
->target_value
= 0;
1471 eh
->target_section
= NULL
;
1472 eh
->target_addend
= 0;
1473 eh
->stub_type
= csky_stub_none
;
1475 eh
->stub_template
= NULL
;
1476 eh
->stub_template_size
= -1;
1479 eh
->output_name
= NULL
;
1485 /* Free the derived linker hash table. */
1488 csky_elf_link_hash_table_free (bfd
*obfd
)
1490 struct csky_elf_link_hash_table
*ret
1491 = (struct csky_elf_link_hash_table
*) obfd
->link
.hash
;
1493 bfd_hash_table_free (&ret
->stub_hash_table
);
1494 _bfd_elf_link_hash_table_free (obfd
);
1497 /* Create an CSKY elf linker hash table. */
1499 static struct bfd_link_hash_table
*
1500 csky_elf_link_hash_table_create (bfd
*abfd
)
1502 struct csky_elf_link_hash_table
*ret
;
1503 size_t amt
= sizeof (struct csky_elf_link_hash_table
);
1505 ret
= (struct csky_elf_link_hash_table
*) bfd_zmalloc (amt
);
1509 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1510 csky_elf_link_hash_newfunc
,
1511 sizeof (struct csky_elf_link_hash_entry
),
1518 if (!bfd_hash_table_init (&ret
->stub_hash_table
, stub_hash_newfunc
,
1519 sizeof (struct elf32_csky_stub_hash_entry
)))
1524 ret
->elf
.root
.hash_table_free
= csky_elf_link_hash_table_free
;
1525 return &ret
->elf
.root
;
1529 csky_elf_mkobject (bfd
*abfd
)
1531 return bfd_elf_allocate_object (abfd
, sizeof (struct csky_elf_obj_tdata
),
1535 /* Adjust a symbol defined by a dynamic object and referenced by a
1536 regular object. The current definition is in some section of the
1537 dynamic object, but we're not including those sections. We have to
1538 change the definition to something the rest of the link can
1542 csky_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
1543 struct elf_link_hash_entry
*h
)
1545 struct csky_elf_link_hash_entry
*eh
;
1546 struct csky_elf_link_hash_table
*htab
;
1549 eh
= (struct csky_elf_link_hash_entry
*)h
;
1553 htab
= csky_elf_hash_table (info
);
1557 /* Clear jsri2bsr_refcount, if creating shared library files. */
1558 if (bfd_link_pic (info
) && eh
->jsri2bsr_refcount
> 0)
1559 eh
->jsri2bsr_refcount
= 0;
1561 /* If there is a function, put it in the procedure linkage table. We
1562 will fill in the contents of the procedure linkage table later. */
1565 /* Calls to STT_GNU_IFUNC symbols always use a PLT, even if the
1566 symbol binds locally. */
1567 if (h
->plt
.refcount
<= 0
1568 || (h
->type
!= STT_GNU_IFUNC
1569 && (SYMBOL_CALLS_LOCAL (info
, h
)
1570 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1571 && h
->root
.type
== bfd_link_hash_undefweak
))))
1574 /* This case can occur if we saw a PLT32 reloc in an input
1575 file, but the symbol was never referred to by a dynamic
1576 object, or if all references were garbage collected. In
1577 such a case, we don't actually need to build a procedure
1578 linkage table, and we can just do a PC32 reloc instead. */
1579 h
->plt
.offset
= (bfd_vma
) -1;
1581 if (h
->got
.refcount
== 0)
1582 h
->got
.refcount
+= 1;
1584 else if (h
->got
.refcount
!= 0)
1586 h
->got
.refcount
-= eh
->plt_refcount
;
1587 eh
->plt_refcount
= 0;
1592 /* It's possible that we incorrectly decided a .plt reloc was
1593 needed for an R_CKCORE_PC32 or similar reloc to a non-function
1594 sym in check_relocs. We can't decide accurately between function
1595 and non-function syms in check_relocs; objects loaded later in
1596 the link may change h->type. So fix it now. */
1597 h
->plt
.offset
= (bfd_vma
) -1;
1599 /* If this is a weak symbol, and there is a real definition, the
1600 processor independent code will have arranged for us to see the
1601 real definition first, and we can just use the same value. */
1602 if (h
->is_weakalias
)
1604 struct elf_link_hash_entry
*def
= weakdef (h
);
1605 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1606 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1607 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1611 /* If there are no non-GOT references, we do not need a copy
1613 if (!h
->non_got_ref
)
1616 /* This is a reference to a symbol defined by a dynamic object which
1617 is not a function. */
1619 /* If we are creating a shared library, we must presume that the
1620 only references to the symbol are via the global offset table.
1621 For such cases we need not do anything here; the relocations will
1622 be handled correctly by relocate_section. */
1623 if (bfd_link_pic (info
) || htab
->elf
.is_relocatable_executable
)
1626 /* We must allocate the symbol in our .dynbss section, which will
1627 become part of the .bss section of the executable. There will be
1628 an entry for this symbol in the .dynsym section. The dynamic
1629 object will contain position independent code, so all references
1630 from the dynamic object to this symbol will go through the global
1631 offset table. The dynamic linker will use the .dynsym entry to
1632 determine the address it must put in the global offset table, so
1633 both the dynamic object and the regular object will refer to the
1634 same memory location for the variable. */
1635 /* We must generate a R_CKCORE_COPY reloc to tell the dynamic linker to
1636 copy the initial value out of the dynamic object and into the
1637 runtime process image. We need to remember the offset into the
1638 .rela.bss section we are going to use. */
1639 if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1641 s
= htab
->elf
.sdynrelro
;
1642 srel
= htab
->elf
.sreldynrelro
;
1646 s
= htab
->elf
.sdynbss
;
1647 srel
= htab
->elf
.srelbss
;
1649 if (info
->nocopyreloc
== 0
1650 && (h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0
1655 srel
->size
+= sizeof (Elf32_External_Rela
);
1657 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1664 /* Allocate space in .plt, .got and associated reloc sections for
1668 csky_allocate_dynrelocs (struct elf_link_hash_entry
*h
, PTR inf
)
1670 struct bfd_link_info
*info
;
1671 struct csky_elf_link_hash_table
*htab
;
1672 struct csky_elf_link_hash_entry
*eh
;
1673 struct elf_dyn_relocs
*p
;
1675 /* For indirect case, such as _ZdlPv to _ZdlPv@@GLIBCXX_3.4. */
1676 if (h
->root
.type
== bfd_link_hash_indirect
)
1679 if (h
->root
.type
== bfd_link_hash_warning
)
1680 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1683 info
= (struct bfd_link_info
*) inf
;
1684 htab
= csky_elf_hash_table (info
);
1687 /*TODO: how to deal with weak symbol relocs. */
1688 if ((htab
->elf
.dynamic_sections_created
|| h
->type
== STT_GNU_IFUNC
)
1689 && h
->plt
.refcount
> 0)
1691 /* Make sure this symbol is output as a dynamic symbol.
1692 Undefined weak syms won't yet be marked as dynamic. */
1693 if (h
->dynindx
== -1 && !h
->forced_local
1694 && h
->root
.type
== bfd_link_hash_undefweak
1695 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
1697 if (bfd_link_pic (info
) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h
))
1699 asection
*splt
= htab
->elf
.splt
;
1701 /* If this is the first .plt entry, make room for the special
1703 if (splt
->size
== 0)
1705 if (bfd_csky_abi (info
->output_bfd
) == CSKY_ABI_V1
)
1706 splt
->size
+= PLT_ENTRY_SIZE_P
;
1708 splt
->size
+= PLT_ENTRY_SIZE
;
1710 h
->plt
.offset
= splt
->size
;
1712 /* If this symbol is not defined in a regular file, and we are
1713 not generating a shared library, then set the symbol to this
1714 location in the .plt. This is required to make function
1715 pointers compare as equal between the normal executable and
1716 the shared library. */
1717 if (!bfd_link_pic (info
) && !h
->def_regular
)
1719 h
->root
.u
.def
.section
= splt
;
1720 h
->root
.u
.def
.value
= h
->plt
.offset
;
1723 /* Make room for this entry. */
1724 if (bfd_csky_abi (info
->output_bfd
) == CSKY_ABI_V1
)
1725 splt
->size
+= PLT_ENTRY_SIZE_P
;
1727 splt
->size
+= PLT_ENTRY_SIZE
;
1728 /* We also need to make an entry in the .rela.plt section. */
1729 htab
->elf
.srelplt
->size
+= sizeof (Elf32_External_Rela
);
1731 /* We also need to make an entry in the .got.plt section, which
1732 will be placed in the .got section by the linker script. */
1733 htab
->elf
.sgotplt
->size
+= 4;
1737 h
->plt
.offset
= (bfd_vma
) -1;
1743 h
->plt
.offset
= (bfd_vma
) -1;
1747 if (h
->got
.refcount
> 0)
1753 int tls_type
= csky_elf_hash_entry (h
)->tls_type
;
1754 /* Make sure this symbol is output as a dynamic symbol.
1755 Undefined weak syms won't yet be marked as dynamic. */
1756 if (h
->dynindx
== -1 && !h
->forced_local
1757 && h
->root
.type
== bfd_link_hash_undefweak
1758 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
1761 sgot
= htab
->elf
.sgot
;
1762 h
->got
.offset
= sgot
->size
;
1763 BFD_ASSERT (tls_type
!= GOT_UNKNOWN
);
1764 if (tls_type
== GOT_NORMAL
)
1765 /* Non-TLS symbols need one GOT slot. */
1769 if (tls_type
& GOT_TLS_GD
)
1770 /* R_CKCORE_TLS_GD32 needs 2 consecutive GOT slots. */
1772 if (tls_type
& GOT_TLS_IE
)
1773 /* R_CKCORE_TLS_IE32 needs one GOT slot. */
1776 dyn
= htab
->elf
.dynamic_sections_created
;
1778 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1779 && (! bfd_link_pic (info
) || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
1782 if (tls_type
!= GOT_NORMAL
1783 && (bfd_link_pic (info
) || indx
!= 0)
1784 && ((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1785 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1786 || h
->root
.type
!= bfd_link_hash_undefweak
))
1788 if (tls_type
& GOT_TLS_IE
)
1789 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1790 if (tls_type
& GOT_TLS_GD
)
1791 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1792 if ((tls_type
& GOT_TLS_GD
) && indx
!= 0)
1793 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1795 else if (((ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
1796 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1797 || h
->root
.type
!= bfd_link_hash_undefweak
)
1798 && (bfd_link_pic (info
)
1799 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, 0, h
)
1800 || h
->plt
.offset
== (bfd_vma
) -1))
1801 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
1804 h
->got
.offset
= (bfd_vma
) -1;
1806 eh
= (struct csky_elf_link_hash_entry
*) h
;
1807 if (eh
->dyn_relocs
== NULL
)
1810 /* In the shared -Bsymbolic case, discard space allocated for
1811 dynamic pc-relative relocs against symbols which turn out to be
1812 defined in regular objects. For the normal shared case, discard
1813 space for pc-relative relocs that have become local due to symbol
1814 visibility changes. */
1816 if (bfd_link_pic (info
))
1818 if (SYMBOL_CALLS_LOCAL (info
, h
))
1820 struct elf_dyn_relocs
**pp
;
1822 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1824 p
->count
-= p
->pc_count
;
1833 if (eh
->jsri2bsr_refcount
1834 && h
->root
.type
== bfd_link_hash_defined
1835 && eh
->dyn_relocs
!= NULL
)
1836 eh
->dyn_relocs
->count
-= eh
->jsri2bsr_refcount
;
1838 /* Also discard relocs on undefined weak syms with non-default
1840 if (eh
->dyn_relocs
!= NULL
1841 && h
->root
.type
== bfd_link_hash_undefweak
)
1843 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1844 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1845 eh
->dyn_relocs
= NULL
;
1847 /* Make sure undefined weak symbols are output as a dynamic
1849 else if (h
->dynindx
== -1
1851 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1858 /* For the non-shared case, discard space for relocs against
1859 symbols which turn out to need copy relocs or are not
1863 && ((h
->def_dynamic
&& !h
->def_regular
)
1864 || (htab
->elf
.dynamic_sections_created
1865 && (h
->root
.type
== bfd_link_hash_undefweak
1866 || h
->root
.type
== bfd_link_hash_indirect
1867 || h
->root
.type
== bfd_link_hash_undefined
))))
1869 /* Make sure this symbol is output as a dynamic symbol.
1870 Undefined weak syms won't yet be marked as dynamic. */
1871 if (h
->dynindx
== -1 && !h
->forced_local
1872 && h
->root
.type
== bfd_link_hash_undefweak
)
1874 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1878 /* If that succeeded, we know we'll be keeping all the
1880 if (h
->dynindx
!= -1)
1884 eh
->dyn_relocs
= NULL
;
1889 /* Finally, allocate space. */
1890 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1892 asection
*srelgot
= htab
->elf
.srelgot
;
1893 srelgot
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
1900 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
1902 struct elf_dyn_relocs
*p
;
1904 for (p
= csky_elf_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1906 asection
*s
= p
->sec
->output_section
;
1908 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1914 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1915 read-only sections. */
1918 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1922 if (h
->root
.type
== bfd_link_hash_indirect
)
1925 sec
= readonly_dynrelocs (h
);
1928 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1930 info
->flags
|= DF_TEXTREL
;
1931 info
->callbacks
->minfo
1932 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1933 sec
->owner
, h
->root
.root
.string
, sec
);
1935 /* Not an error, just cut short the traversal. */
1941 /* Set the sizes of the dynamic sections. */
1944 csky_elf_size_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1945 struct bfd_link_info
*info
)
1947 struct csky_elf_link_hash_table
*htab
;
1953 htab
= csky_elf_hash_table (info
);
1956 dynobj
= htab
->elf
.dynobj
;
1960 if (htab
->elf
.dynamic_sections_created
)
1962 /* Set the contents of the .interp section to the interpreter. */
1963 if (!bfd_link_pic (info
) && !info
->nointerp
)
1965 s
= bfd_get_section_by_name (dynobj
, ".interp");
1966 BFD_ASSERT (s
!= NULL
);
1967 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
1968 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
1972 /* Set up .got offsets for local syms, and space for local dynamic
1974 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1976 bfd_signed_vma
*local_got_refcounts
;
1977 bfd_signed_vma
*end_local_got
;
1978 bfd_size_type locsymcount
;
1979 Elf_Internal_Shdr
*symtab_hdr
;
1980 asection
*srelgot
, *sgot
;
1981 char *local_tls_type
;
1983 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
)
1986 sgot
= htab
->elf
.sgot
;
1987 srelgot
= htab
->elf
.srelgot
;
1989 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1991 struct elf_dyn_relocs
*p
;
1993 for (p
= *((struct elf_dyn_relocs
**)
1994 &elf_section_data (s
)->local_dynrel
);
1998 if (!bfd_is_abs_section (p
->sec
)
1999 && bfd_is_abs_section (p
->sec
->output_section
))
2000 /* Input section has been discarded, either because
2001 it is a copy of a linkonce section or due to
2002 linker script /DISCARD/, so we'll be discarding
2005 else if (p
->count
!= 0)
2007 srelgot
->size
+= p
->count
* sizeof (Elf32_External_Rela
);
2008 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
2009 info
->flags
|= DF_TEXTREL
;
2014 local_got_refcounts
= elf_local_got_refcounts (ibfd
);
2015 if (!local_got_refcounts
)
2018 symtab_hdr
= &elf_tdata (ibfd
)->symtab_hdr
;
2019 locsymcount
= symtab_hdr
->sh_info
;
2020 end_local_got
= local_got_refcounts
+ locsymcount
;
2021 local_tls_type
= csky_elf_local_got_tls_type (ibfd
);
2023 for (; local_got_refcounts
< end_local_got
;
2024 ++local_got_refcounts
, ++local_tls_type
)
2026 if (*local_got_refcounts
> 0)
2028 /* GOT_TLS_GD and GOT_TLS_IE type for TLS, GOT_NORMAL type
2029 for GOT. If output file is shared library, we should output
2030 GOT_TLS_GD type relocation in .rel.got. */
2031 *local_got_refcounts
= sgot
->size
;
2032 if (*local_tls_type
& GOT_TLS_GD
)
2033 /* TLS_GD relocs need an 8-byte structure in the GOT. */
2035 if (*local_tls_type
& GOT_TLS_IE
)
2037 if (*local_tls_type
== GOT_NORMAL
)
2039 if (bfd_link_pic (info
) || *local_tls_type
== GOT_TLS_GD
)
2040 srelgot
->size
+= sizeof (Elf32_External_Rela
);
2043 *local_got_refcounts
= (bfd_vma
) -1;
2047 if (htab
->tls_ldm_got
.refcount
> 0)
2049 /* Allocate two GOT entries and one dynamic relocation (if necessary)
2050 for R_CSKY_TLS_LDM32 relocations. */
2051 htab
->tls_ldm_got
.offset
= htab
->elf
.sgot
->size
;
2052 htab
->elf
.sgot
->size
+= 8;
2053 if (bfd_link_pic (info
))
2054 htab
->elf
.srelgot
->size
+= sizeof (Elf32_External_Rela
);
2057 htab
->tls_ldm_got
.offset
= -1;
2059 /* Allocate global sym .plt and .got entries, and space for global
2060 sym dynamic relocs. */
2061 elf_link_hash_traverse (&htab
->elf
, csky_allocate_dynrelocs
, (PTR
) info
);
2063 /* Check for GOT overflow. */
2064 if (check_got_overflow
== 1
2065 && htab
->elf
.sgot
->size
+ htab
->elf
.sgotplt
->size
> GOT_MAX_SIZE
)
2067 _bfd_error_handler (_("GOT table size out of range")); /* */
2071 /* We now have determined the sizes of the various dynamic sections.
2072 Allocate memory for them. */
2074 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2076 bfd_boolean strip_section
= TRUE
;
2078 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2081 if (s
== htab
->elf
.splt
2082 || s
== htab
->elf
.sgot
2083 || s
== htab
->elf
.sgotplt
2084 || s
== htab
->elf
.sdynrelro
2085 || s
== htab
->elf
.sreldynrelro
)
2087 /* Strip this section if we don't need it;
2088 see the comment below. */
2089 /* We'd like to strip these sections if they aren't needed, but if
2090 we've exported dynamic symbols from them we must leave them.
2091 It's too late to tell BFD to get rid of the symbols. */
2093 if (htab
->elf
.hplt
!= NULL
)
2094 strip_section
= FALSE
;
2096 else if (CONST_STRNEQ (bfd_section_name (s
), ".rel") )
2101 /* We use the reloc_count field as a counter if we need
2102 to copy relocs into the output file. */
2106 /* It's not one of our sections, so don't allocate space. */
2109 /* Strip this section if we don't need it; see the
2113 /* If we don't need this section, strip it from the
2114 output file. This is mostly to handle .rel.bss and
2115 .rel.plt. We must create both sections in
2116 create_dynamic_sections, because they must be created
2117 before the linker maps input sections to output
2118 sections. The linker does that before
2119 adjust_dynamic_symbol is called, and it is that
2120 function which decides whether anything needs to go
2121 into these sections. */
2123 s
->flags
|= SEC_EXCLUDE
;
2127 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2130 /* Allocate memory for the section contents. We use bfd_zalloc
2131 here in case unused entries are not reclaimed before the
2132 section's contents are written out. This should not happen,
2133 but this way if it does, we get a R_CKCORE_NONE reloc instead
2135 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2136 if (s
->contents
== NULL
)
2140 if (htab
->elf
.dynamic_sections_created
)
2142 /* Add some entries to the .dynamic section. We fill in the
2143 values later, in csky_elf_finish_dynamic_sections, but we
2144 must add the entries now so that we get the correct size for
2145 the .dynamic section. The DT_DEBUG entry is filled in by the
2146 dynamic linker and used by the debugger. */
2147 #define add_dynamic_entry(TAG, VAL) \
2148 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2150 if (bfd_link_executable (info
) && !add_dynamic_entry (DT_DEBUG
, 0))
2153 if (htab
->elf
.sgot
->size
!= 0 || htab
->elf
.splt
->size
)
2155 if (!add_dynamic_entry (DT_PLTGOT
, 0)
2156 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
2157 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
2158 || !add_dynamic_entry (DT_JMPREL
, 0))
2164 if (!add_dynamic_entry (DT_RELA
, 0)
2165 || !add_dynamic_entry (DT_RELASZ
, 0)
2166 || !add_dynamic_entry (DT_RELAENT
,
2167 sizeof (Elf32_External_Rela
)))
2170 /* If any dynamic relocs apply to a read-only section,
2171 then we need a DT_TEXTREL entry. */
2172 if ((info
->flags
& DF_TEXTREL
) == 0)
2173 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
2175 if ((info
->flags
& DF_TEXTREL
) != 0
2176 && !add_dynamic_entry (DT_TEXTREL
, 0))
2180 #undef add_dynamic_entry
2185 /* Finish up dynamic symbol handling. We set the contents of various
2186 dynamic sections here. */
2189 csky_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2190 struct bfd_link_info
*info
,
2191 struct elf_link_hash_entry
*h
,
2192 Elf_Internal_Sym
*sym
)
2194 struct csky_elf_link_hash_table
*htab
;
2196 htab
= csky_elf_hash_table (info
);
2200 /* Sanity check to make sure no unexpected symbol reaches here.
2201 This matches the test in csky_elf_relocate_section handling
2202 of GOT/PLT entries. */
2203 BFD_ASSERT (! (h
->dynindx
== -1
2205 && h
->root
.type
!= bfd_link_hash_undefweak
2206 && bfd_link_pic (info
)));
2208 if (h
->plt
.offset
!= (bfd_vma
) -1)
2212 Elf_Internal_Rela rel
;
2214 asection
*plt
, *relplt
, *gotplt
;
2216 plt
= htab
->elf
.splt
;
2217 relplt
= htab
->elf
.srelplt
;
2218 gotplt
= htab
->elf
.sgotplt
;
2220 /* This symbol has an entry in the procedure linkage table. Set
2222 BFD_ASSERT (h
->dynindx
!= -1
2223 || ((h
->forced_local
|| bfd_link_executable (info
))
2224 && h
->def_regular
));
2225 BFD_ASSERT (plt
!= NULL
&& gotplt
!= NULL
&& relplt
!= NULL
);
2226 if (bfd_csky_abi (output_bfd
) == CSKY_ABI_V2
)
2227 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE
- 1;
2229 plt_index
= h
->plt
.offset
/ PLT_ENTRY_SIZE_P
- 1;
2230 got_offset
= (plt_index
+ 3) * 4;
2232 /* Fill in the entry in the procedure linkage table. */
2233 if (bfd_csky_abi (output_bfd
) == CSKY_ABI_V2
)
2235 csky_put_insn_32 (output_bfd
, csky_elf_plt_entry_v2
[0],
2236 plt
->contents
+ h
->plt
.offset
);
2237 csky_put_insn_32 (output_bfd
,
2238 (csky_elf_plt_entry_v2
[1] | plt_index
),
2239 plt
->contents
+ h
->plt
.offset
+ 4);
2240 csky_put_insn_32 (output_bfd
, csky_elf_plt_entry_v2
[2],
2241 plt
->contents
+ h
->plt
.offset
+ 8);
2246 for (i
= 0; i
< 6; i
++)
2247 bfd_put_16 (output_bfd
, csky_elf_plt_entry_v1
[i
],
2248 plt
->contents
+ h
->plt
.offset
+ i
* 2);
2249 bfd_put_32 (output_bfd
, plt_index
,
2250 plt
->contents
+ h
->plt
.offset
+ i
* 2);
2253 /* Fill in the entry in the .rel.plt section. */
2254 rel
.r_offset
= (htab
->elf
.sgotplt
->output_section
->vma
2255 + htab
->elf
.sgotplt
->output_offset
2257 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CKCORE_JUMP_SLOT
);
2258 rel
.r_addend
= (plt
->output_section
->vma
2259 + plt
->output_offset
2261 loc
= (htab
->elf
.srelplt
->contents
2262 + plt_index
* sizeof (Elf32_External_Rela
));
2265 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2266 if (! h
->def_regular
)
2268 /* Mark the symbol as undefined, rather than as defined in
2269 the .plt section. Leave the value alone. */
2270 sym
->st_shndx
= SHN_UNDEF
;
2271 /* If the symbol is weak, we do need to clear the value.
2272 Otherwise, the PLT entry would provide a definition for
2273 the symbol even if the symbol wasn't defined anywhere,
2274 and so the symbol would never be NULL. Leave the value if
2275 there were any relocations where pointer equality matters
2276 (this is a clue for the dynamic linker, to make function
2277 pointer comparisons work between an application and shared
2279 if (!h
->ref_regular_nonweak
|| !h
->pointer_equality_needed
)
2284 /* Fill in the entry in the .got section. */
2285 if (h
->got
.offset
!= (bfd_vma
) -1
2286 && ((csky_elf_hash_entry (h
)->tls_type
& GOT_TLS_GD
) == 0)
2287 && ((csky_elf_hash_entry (h
)->tls_type
& GOT_TLS_IE
) == 0))
2289 Elf_Internal_Rela rel
;
2292 /* This symbol has an entry in the global offset table.
2294 BFD_ASSERT (htab
->elf
.sgot
!= NULL
&& htab
->elf
.srelgot
!= NULL
);
2296 rel
.r_offset
= (htab
->elf
.sgot
->output_section
->vma
2297 + htab
->elf
.sgot
->output_offset
2298 + (h
->got
.offset
& ~(bfd_vma
) 1));
2300 /* If this is a static link, or it is a -Bsymbolic link and the
2301 symbol is defined locally or was forced to be local because
2302 of a version file, we just want to emit a RELATIVE reloc.
2303 The entry in the global offset table will already have been
2304 initialized in the relocate_section function. */
2305 if (bfd_link_pic (info
) && SYMBOL_REFERENCES_LOCAL (info
, h
))
2307 BFD_ASSERT ((h
->got
.offset
& 1) != 0);
2308 rel
.r_info
= ELF32_R_INFO (0, R_CKCORE_RELATIVE
);
2309 rel
.r_addend
= (h
->root
.u
.def
.value
2310 + h
->root
.u
.def
.section
->output_offset
2311 + h
->root
.u
.def
.section
->output_section
->vma
);
2315 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
2316 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
2317 htab
->elf
.sgot
->contents
+ h
->got
.offset
);
2318 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CKCORE_GLOB_DAT
);
2322 loc
= htab
->elf
.srelgot
->contents
;
2323 loc
+= htab
->elf
.srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2326 bfd_elf32_swap_reloca_out (output_bfd
, &rel
, loc
);
2332 Elf_Internal_Rela rela
;
2335 /* This symbol needs a copy reloc. Set it up. */
2336 BFD_ASSERT (h
->dynindx
!= -1
2337 && (h
->root
.type
== bfd_link_hash_defined
2338 || h
->root
.type
== bfd_link_hash_defweak
));
2340 rela
.r_offset
= (h
->root
.u
.def
.value
2341 + h
->root
.u
.def
.section
->output_section
->vma
2342 + h
->root
.u
.def
.section
->output_offset
);
2343 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CKCORE_COPY
);
2345 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2346 s
= htab
->elf
.sreldynrelro
;
2348 s
= htab
->elf
.srelbss
;
2349 BFD_ASSERT (s
!= NULL
);
2350 loc
= s
->contents
+ s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
2351 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
2354 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2355 if (strcmp (h
->root
.root
.string
, "_DYNAMIC") == 0
2356 || strcmp (h
->root
.root
.string
, "_GLOBAL_OFFSET_TABLE_") == 0)
2357 sym
->st_shndx
= SHN_ABS
;
2362 /* Finish up the dynamic sections. */
2365 csky_elf_finish_dynamic_sections (bfd
*output_bfd
,
2366 struct bfd_link_info
*info
)
2368 struct csky_elf_link_hash_table
*htab
;
2373 htab
= csky_elf_hash_table (info
);
2377 dynobj
= htab
->elf
.dynobj
;
2378 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
2380 if (htab
->elf
.dynamic_sections_created
)
2382 Elf32_External_Dyn
*dyncon
, *dynconend
;
2384 BFD_ASSERT (sdyn
!= NULL
&& htab
->elf
.sgot
!= NULL
);
2386 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2387 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2388 for (; dyncon
< dynconend
; dyncon
++)
2390 Elf_Internal_Dyn dyn
;
2391 bfd_boolean size
= FALSE
;
2392 const char *name
= NULL
;
2394 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2412 dyn
.d_un
.d_ptr
= htab
->elf
.sgot
->output_section
->vma
;
2415 dyn
.d_un
.d_ptr
= htab
->elf
.srelplt
->output_section
->vma
2416 + htab
->elf
.srelplt
->output_offset
;
2422 asection
*s
= bfd_get_section_by_name (output_bfd
, name
);
2427 dyn
.d_un
.d_ptr
= s
->vma
;
2429 dyn
.d_un
.d_val
= s
->size
;
2431 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2435 /* Fill in the first three entries in the global offset table. */
2436 if (htab
->elf
.sgotplt
)
2437 got_sec
= htab
->elf
.sgotplt
;
2439 got_sec
= htab
->elf
.sgot
;
2440 if (got_sec
!= NULL
)
2442 if (got_sec
->size
> 0)
2444 bfd_put_32 (output_bfd
,
2445 (sdyn
== NULL
? (bfd_vma
) 0
2446 : sdyn
->output_section
->vma
+ sdyn
->output_offset
),
2448 bfd_put_32 (output_bfd
, (bfd_vma
) 0, got_sec
->contents
+ 4);
2449 bfd_put_32 (output_bfd
, (bfd_vma
) 0, got_sec
->contents
+ 8);
2451 elf_section_data (got_sec
->output_section
)->this_hdr
.sh_entsize
= 4;
2456 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2459 csky_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
2460 struct elf_link_hash_entry
*dir
,
2461 struct elf_link_hash_entry
*ind
)
2463 struct csky_elf_link_hash_entry
*edir
, *eind
;
2465 edir
= (struct csky_elf_link_hash_entry
*) dir
;
2466 eind
= (struct csky_elf_link_hash_entry
*) ind
;
2468 if (eind
->dyn_relocs
!= NULL
)
2470 if (edir
->dyn_relocs
!= NULL
)
2472 struct elf_dyn_relocs
**pp
;
2473 struct elf_dyn_relocs
*p
;
2475 /* Add reloc counts against the indirect sym to the direct sym
2476 list. Merge any entries against the same section. */
2477 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
2479 struct elf_dyn_relocs
*q
;
2481 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
2482 if (q
->sec
== p
->sec
)
2484 q
->pc_count
+= p
->pc_count
;
2485 q
->count
+= p
->count
;
2492 *pp
= edir
->dyn_relocs
;
2494 edir
->dyn_relocs
= eind
->dyn_relocs
;
2495 eind
->dyn_relocs
= NULL
;
2497 if (ind
->root
.type
== bfd_link_hash_indirect
2498 && dir
->got
.refcount
<= 0)
2500 edir
->tls_type
= eind
->tls_type
;
2501 eind
->tls_type
= GOT_UNKNOWN
;
2503 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
2506 /* Used to decide how to sort relocs in an optimal manner for the
2507 dynamic linker, before writing them out. */
2509 static enum elf_reloc_type_class
2510 csky_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2511 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2512 const Elf_Internal_Rela
*rela
)
2514 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2516 case R_CKCORE_RELATIVE
:
2517 return reloc_class_relative
;
2518 case R_CKCORE_JUMP_SLOT
:
2519 return reloc_class_plt
;
2521 return reloc_class_copy
;
2522 case R_CKCORE_IRELATIVE
:
2523 return reloc_class_ifunc
;
2525 return reloc_class_normal
;
2529 /* Return the section that should be marked against GC for a given
2533 csky_elf_gc_mark_hook (asection
*sec
,
2534 struct bfd_link_info
*info
,
2535 Elf_Internal_Rela
*rel
,
2536 struct elf_link_hash_entry
*h
,
2537 Elf_Internal_Sym
*sym
)
2541 switch (ELF32_R_TYPE (rel
->r_info
))
2543 case R_CKCORE_GNU_VTINHERIT
:
2544 case R_CKCORE_GNU_VTENTRY
:
2549 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2552 /* Look through the relocs for a section during the first phase.
2553 Since we don't do .gots or .plts, we just need to consider the
2554 virtual table relocs for gc. */
2557 csky_elf_check_relocs (bfd
* abfd
,
2558 struct bfd_link_info
* info
,
2560 const Elf_Internal_Rela
* relocs
)
2562 Elf_Internal_Shdr
* symtab_hdr
;
2563 struct elf_link_hash_entry
** sym_hashes
;
2564 const Elf_Internal_Rela
* rel
;
2565 const Elf_Internal_Rela
* rel_end
;
2566 struct csky_elf_link_hash_table
*htab
;
2569 /* if output type is relocatable, return. */
2570 if (bfd_link_relocatable (info
))
2573 htab
= csky_elf_hash_table (info
);
2577 symtab_hdr
= & elf_tdata (abfd
)->symtab_hdr
;
2578 sym_hashes
= elf_sym_hashes (abfd
);
2580 rel_end
= relocs
+ sec
->reloc_count
;
2582 for (rel
= relocs
; rel
< rel_end
; rel
++)
2584 struct elf_link_hash_entry
*h
;
2585 unsigned long r_symndx
;
2586 Elf_Internal_Sym
*isym
;
2589 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2590 r_type
= ELF32_R_TYPE (rel
->r_info
);
2591 if (r_symndx
< symtab_hdr
->sh_info
)
2593 /* A local symbol. */
2594 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2603 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
2604 while (h
->root
.type
== bfd_link_hash_indirect
2605 || h
->root
.type
== bfd_link_hash_warning
)
2606 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2611 case R_CKCORE_PCREL_IMM26BY2
:
2612 case R_CKCORE_PCREL_IMM11BY2
:
2613 case R_CKCORE_PCREL_JSR_IMM11BY2
:
2614 case R_CKCORE_PCREL_JSR_IMM26BY2
:
2615 /* If the symbol is '*UND*', means this reloc is used for
2616 * callgraph, don't need to leave to shared object. */
2619 /* Else fall through. */
2620 case R_CKCORE_ADDR32
:
2621 case R_CKCORE_ADDR_HI16
:
2622 case R_CKCORE_ADDR_LO16
:
2624 && bfd_link_executable (info
)
2625 && r_type
== R_CKCORE_ADDR32
2626 && h
->type
== STT_OBJECT
2627 && (sec
->flags
& SEC_ALLOC
) != 0
2628 && (sec
->flags
& SEC_READONLY
))
2629 /* If this reloc is in a read-only section, we might
2630 need a copy reloc. We can't check reliably at this
2631 stage whether the section is read-only, as input
2632 sections have not yet been mapped to output sections.
2633 Tentatively set the flag for now, and correct in
2634 adjust_dynamic_symbol. */
2637 /* If we are creating a shared library or relocatable executable,
2638 and this is a reloc against a global symbol, then we need to
2639 copy the reloc into the shared library. However, if we are
2640 linking with -Bsymbolic, we do not need to copy a reloc
2641 against a global symbol which is defined in an object we are
2642 including in the link (i.e., DEF_REGULAR is set). At
2643 this point we have not seen all the input files, so it is
2644 possible that DEF_REGULAR is not set now but will be set
2645 later (it is never cleared). We account for that possibility
2646 below by storing information in the relocs_copied field of
2647 the hash table entry. */
2648 if ((bfd_link_pic (info
) && (sec
->flags
& SEC_ALLOC
) != 0)
2649 || (!bfd_link_pic (info
)
2650 && (sec
->flags
& SEC_ALLOC
) != 0
2652 && (h
->root
.type
== bfd_link_hash_defweak
2653 || !h
->def_regular
)))
2655 struct elf_dyn_relocs
*p
;
2656 struct elf_dyn_relocs
**head
;
2657 /* We must copy these reloc types into the output file.
2658 Create a reloc section in dynobj and make room for
2662 if (htab
->elf
.dynobj
== NULL
)
2663 htab
->elf
.dynobj
= abfd
;
2665 sreloc
= _bfd_elf_make_dynamic_reloc_section
2666 (sec
, htab
->elf
.dynobj
, 2, abfd
, TRUE
);
2672 if (h
== NULL
&& !use_branch_stub
2673 && ((ELF32_R_TYPE (rel
->r_info
)
2674 == R_CKCORE_PCREL_IMM26BY2
)
2675 || (ELF32_R_TYPE (rel
->r_info
)
2676 == R_CKCORE_PCREL_IMM11BY2
)))
2679 /* If this is a global symbol, we count the number of
2680 relocations we need for this symbol. */
2683 struct csky_elf_link_hash_entry
*eh
;
2684 eh
= (struct csky_elf_link_hash_entry
*)h
;
2685 if ((ELF32_R_TYPE (rel
->r_info
)
2686 == R_CKCORE_PCREL_JSR_IMM26BY2
)
2687 || (ELF32_R_TYPE (rel
->r_info
)
2688 == R_CKCORE_PCREL_JSR_IMM11BY2
))
2689 eh
->jsri2bsr_refcount
+= 1;
2690 head
= &eh
->dyn_relocs
;
2694 /* Track dynamic relocs needed for local syms too.
2695 We really need local syms available to do this
2699 Elf_Internal_Sym
*loc_isym
;
2701 loc_isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
2703 if (loc_isym
== NULL
)
2705 s
= bfd_section_from_elf_index (abfd
, loc_isym
->st_shndx
);
2708 vpp
= &elf_section_data (s
)->local_dynrel
;
2709 head
= (struct elf_dyn_relocs
**)vpp
;
2713 if (p
== NULL
|| p
->sec
!= sec
)
2715 size_t amt
= sizeof *p
;
2716 p
= ((struct elf_dyn_relocs
*)
2717 bfd_alloc (htab
->elf
.dynobj
, amt
));
2727 if (ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_PCREL_IMM26BY2
2728 || ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_PCREL_IMM11BY2
)
2734 case R_CKCORE_PLT_IMM18BY4
:
2735 case R_CKCORE_PLT32
:
2736 /* This symbol requires a procedure linkage table entry. We
2737 actually build the entry in adjust_dynamic_symbol,
2738 because this might be a case of linking PIC code which is
2739 never referenced by a dynamic object, in which case we
2740 don't need to generate a procedure linkage table entry
2743 /* If this is a local symbol, we resolve it directly without
2744 creating a procedure linkage table entry. */
2747 if (ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_PLT_IMM18BY4
)
2748 check_got_overflow
= 1;
2751 h
->plt
.refcount
+= 1;
2752 h
->got
.refcount
+= 1;
2753 ((struct csky_elf_link_hash_entry
*)h
)->plt_refcount
+= 1;
2756 case R_CKCORE_GOT12
:
2757 case R_CKCORE_PLT12
:
2758 case R_CKCORE_GOT32
:
2759 case R_CKCORE_GOT_HI16
:
2760 case R_CKCORE_GOT_LO16
:
2761 case R_CKCORE_PLT_HI16
:
2762 case R_CKCORE_PLT_LO16
:
2763 case R_CKCORE_GOT_IMM18BY4
:
2764 case R_CKCORE_TLS_IE32
:
2765 case R_CKCORE_TLS_GD32
:
2767 int tls_type
, old_tls_type
;
2770 && bfd_link_executable (info
)
2771 && r_type
== R_CKCORE_GOT_IMM18BY4
2772 && (sec
->flags
& SEC_ALLOC
) != 0
2773 && (sec
->flags
& SEC_READONLY
))
2774 /* If this reloc is in a read-only section, we might
2775 need a copy reloc. We can't check reliably at this
2776 stage whether the section is read-only, as input
2777 sections have not yet been mapped to output sections.
2778 Tentatively set the flag for now, and correct in
2779 adjust_dynamic_symbol. */
2782 switch (ELF32_R_TYPE (rel
->r_info
))
2784 case R_CKCORE_TLS_IE32
:
2785 tls_type
= GOT_TLS_IE
;
2787 case R_CKCORE_TLS_GD32
:
2788 tls_type
= GOT_TLS_GD
;
2791 tls_type
= GOT_NORMAL
;
2796 if (ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_GOT_IMM18BY4
)
2797 check_got_overflow
= 1;
2798 h
->got
.refcount
+= 1;
2799 old_tls_type
= csky_elf_hash_entry (h
)->tls_type
;
2803 bfd_signed_vma
*local_got_refcounts
;
2805 /* This is a global offset table entry for a local symbol. */
2806 /* we can write a new function named
2807 elf32_csky_allocate_local_sym_info() to replace
2809 local_got_refcounts
= elf_local_got_refcounts (abfd
);
2810 if (local_got_refcounts
== NULL
)
2814 size
= symtab_hdr
->sh_info
;
2815 size
*= (sizeof (bfd_signed_vma
) + sizeof (char));
2816 local_got_refcounts
= ((bfd_signed_vma
*)
2817 bfd_zalloc (abfd
, size
));
2818 if (local_got_refcounts
== NULL
)
2820 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2821 csky_elf_local_got_tls_type (abfd
)
2822 = (char *) (local_got_refcounts
+ symtab_hdr
->sh_info
);
2824 local_got_refcounts
[r_symndx
] += 1;
2825 old_tls_type
= csky_elf_local_got_tls_type (abfd
)[r_symndx
];
2828 /* We will already have issued an error message if there is a
2829 TLS / non-TLS mismatch, based on the symbol type. We don't
2830 support any linker relaxations. So just combine any TLS
2832 if (old_tls_type
!= GOT_UNKNOWN
&& old_tls_type
!= GOT_NORMAL
2833 && tls_type
!= GOT_NORMAL
)
2834 tls_type
|= old_tls_type
;
2836 if (old_tls_type
!= tls_type
)
2839 csky_elf_hash_entry (h
)->tls_type
= tls_type
;
2841 csky_elf_local_got_tls_type (abfd
)[r_symndx
] = tls_type
;
2846 case R_CKCORE_TLS_LDM32
:
2847 if (ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_TLS_LDM32
)
2848 htab
->tls_ldm_got
.refcount
++;
2851 case R_CKCORE_GOTOFF
:
2852 case R_CKCORE_GOTPC
:
2853 case R_CKCORE_GOTOFF_HI16
:
2854 case R_CKCORE_GOTOFF_LO16
:
2855 case R_CKCORE_GOTPC_HI16
:
2856 case R_CKCORE_GOTPC_LO16
:
2857 case R_CKCORE_GOTOFF_IMM18
:
2858 if (htab
->elf
.sgot
== NULL
)
2860 if (htab
->elf
.dynobj
== NULL
)
2861 htab
->elf
.dynobj
= abfd
;
2862 if (!_bfd_elf_create_got_section (htab
->elf
.dynobj
, info
))
2867 /* This relocation describes the C++ object vtable hierarchy.
2868 Reconstruct it for later use during GC. */
2869 case R_CKCORE_GNU_VTINHERIT
:
2870 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2874 /* This relocation describes which C++ vtable entries are actually
2875 used. Record for later use during GC. */
2876 case R_CKCORE_GNU_VTENTRY
:
2877 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
2886 static const struct bfd_elf_special_section csky_elf_special_sections
[]=
2888 { STRING_COMMA_LEN (".ctors"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2889 { STRING_COMMA_LEN (".dtors"), -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
2890 { NULL
, 0, 0, 0, 0 }
2893 /* Function to keep CSKY specific flags in the ELF header. */
2896 csky_elf_set_private_flags (bfd
* abfd
, flagword flags
)
2898 BFD_ASSERT (! elf_flags_init (abfd
)
2899 || elf_elfheader (abfd
)->e_flags
== flags
);
2901 elf_elfheader (abfd
)->e_flags
= flags
;
2902 elf_flags_init (abfd
) = TRUE
;
2906 static csky_arch_for_merge
*
2907 csky_find_arch_with_eflag (const unsigned long arch_eflag
)
2909 csky_arch_for_merge
*csky_arch
= NULL
;
2911 for (csky_arch
= csky_archs
; csky_arch
->name
!= NULL
; csky_arch
++)
2912 if (csky_arch
->arch_eflag
== arch_eflag
)
2914 if (csky_arch
== NULL
)
2916 _bfd_error_handler (_("warning: unrecognized arch eflag '%#lx'"),
2918 bfd_set_error (bfd_error_wrong_format
);
2923 /* Merge backend specific data from an object file to the output
2924 object file when linking. */
2927 csky_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2929 bfd
*obfd
= info
->output_bfd
;
2932 csky_arch_for_merge
*old_arch
= NULL
;
2933 csky_arch_for_merge
*new_arch
= NULL
;
2935 /* Check if we have the same endianness. */
2936 if (! _bfd_generic_verify_endian_match (ibfd
, info
))
2939 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
2940 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
2943 new_flags
= elf_elfheader (ibfd
)->e_flags
;
2944 old_flags
= elf_elfheader (obfd
)->e_flags
;
2946 if (! elf_flags_init (obfd
))
2948 /* First call, no flags set. */
2949 elf_flags_init (obfd
) = TRUE
;
2950 elf_elfheader (obfd
)->e_flags
= new_flags
;
2952 else if (new_flags
== old_flags
)
2955 else if (new_flags
== 0 || old_flags
== 0)
2956 /* When one flag is 0, assign the other one's flag. */
2957 elf_elfheader (obfd
)->e_flags
= new_flags
| old_flags
;
2960 flagword newest_flag
= 0;
2962 if ((new_flags
& CSKY_ARCH_MASK
) != 0
2963 && (old_flags
& CSKY_ARCH_MASK
) != 0)
2965 new_arch
= csky_find_arch_with_eflag (new_flags
& CSKY_ARCH_MASK
);
2966 old_arch
= csky_find_arch_with_eflag (old_flags
& CSKY_ARCH_MASK
);
2967 /* Collect flags like e, f, g. */
2968 newest_flag
= (old_flags
& (~CSKY_ARCH_MASK
))
2969 | (new_flags
& (~CSKY_ARCH_MASK
));
2970 if (new_arch
!= NULL
&& old_arch
!= NULL
)
2972 if (new_arch
->class != old_arch
->class)
2975 /* xgettext:c-format */
2976 (_("%pB: machine flag conflict with target"), ibfd
);
2977 bfd_set_error (bfd_error_wrong_format
);
2980 else if (new_arch
->class_level
!= old_arch
->class_level
)
2982 csky_arch_for_merge
*newest_arch
2983 = (new_arch
->class_level
> old_arch
->class_level
2984 ? new_arch
: old_arch
);
2985 if (new_arch
->do_warning
|| old_arch
->do_warning
)
2988 /* xgettext:c-format */
2989 (_("warning: file %pB's arch flag ck%s conflicts with "
2990 "target ck%s, using ck%s"),
2991 ibfd
, new_arch
->name
, old_arch
->name
,
2993 bfd_set_error (bfd_error_wrong_format
);
2996 newest_flag
|= newest_arch
->arch_eflag
;
2999 newest_flag
|= ((new_flags
& (CSKY_ARCH_MASK
| CSKY_ABI_MASK
))
3001 & (CSKY_ARCH_MASK
| CSKY_ABI_MASK
)));
3004 newest_flag
|= ((new_flags
& (CSKY_ARCH_MASK
| CSKY_ABI_MASK
))
3005 | (old_flags
& (CSKY_ARCH_MASK
| CSKY_ABI_MASK
)));
3008 newest_flag
|= ((new_flags
& (CSKY_ARCH_MASK
| CSKY_ABI_MASK
))
3009 | (old_flags
& (CSKY_ARCH_MASK
| CSKY_ABI_MASK
)));
3011 elf_elfheader (obfd
)->e_flags
= newest_flag
;
3016 /* Ignore the discarded relocs in special sections in link time. */
3019 csky_elf_ignore_discarded_relocs (asection
*sec
)
3021 if (strcmp (sec
->name
, ".csky_stack_size") == 0)
3026 /* .csky_stack_size are not referenced directly. This pass marks all of
3027 them as required. */
3030 elf32_csky_gc_mark_extra_sections (struct bfd_link_info
*info
,
3031 elf_gc_mark_hook_fn gc_mark_hook ATTRIBUTE_UNUSED
)
3035 _bfd_elf_gc_mark_extra_sections (info
, gc_mark_hook
);
3037 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3041 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3042 if (strcmp (o
->name
, ".csky_stack_size") == 0)
3049 /* The linker repeatedly calls this function for each input section,
3050 in the order that input sections are linked into output sections.
3051 Build lists of input sections to determine groupings between which
3052 we may insert linker stubs. */
3055 elf32_csky_next_input_section (struct bfd_link_info
*info
,
3058 struct csky_elf_link_hash_table
*htab
= csky_elf_hash_table (info
);
3061 if (isec
->output_section
->index
<= htab
->top_index
)
3063 asection
**list
= htab
->input_list
+ isec
->output_section
->index
;
3065 if (*list
!= bfd_abs_section_ptr
)
3067 /* Steal the link_sec pointer for our list. */
3068 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3069 /* This happens to make the list in reverse order,
3070 which we reverse later in group_sections. */
3071 PREV_SEC (isec
) = *list
;
3077 /* See whether we can group stub sections together. Grouping stub
3078 sections may result in fewer stubs. More importantly, we need to
3079 put all .init* and .fini* stubs at the end of the .init or
3080 .fini output sections respectively, because glibc splits the
3081 _init and _fini functions into multiple parts. Putting a stub in
3082 the middle of a function is not a good idea. */
3085 group_sections (struct csky_elf_link_hash_table
*htab
,
3086 bfd_size_type stub_group_size
,
3087 bfd_boolean stubs_always_after_branch
)
3089 asection
**list
= htab
->input_list
;
3093 asection
*tail
= *list
;
3096 if (tail
== bfd_abs_section_ptr
)
3099 /* Reverse the list: we must avoid placing stubs at the
3100 beginning of the section because the beginning of the text
3101 section may be required for an interrupt vector in bare metal
3103 #define NEXT_SEC PREV_SEC
3105 while (tail
!= NULL
)
3107 /* Pop from tail. */
3108 asection
*item
= tail
;
3109 tail
= PREV_SEC (item
);
3112 NEXT_SEC (item
) = head
;
3116 while (head
!= NULL
)
3120 bfd_vma stub_group_start
= head
->output_offset
;
3121 bfd_vma end_of_next
;
3124 while (NEXT_SEC (curr
) != NULL
)
3126 next
= NEXT_SEC (curr
);
3127 end_of_next
= next
->output_offset
+ next
->size
;
3128 if (end_of_next
- stub_group_start
>= stub_group_size
)
3129 /* End of NEXT is too far from start, so stop. */
3134 /* OK, the size from the start to the start of CURR is less
3135 * than stub_group_size and thus can be handled by one stub
3136 * section. (Or the head section is itself larger than
3137 * stub_group_size, in which case we may be toast.)
3138 * We should really be keeping track of the total size of
3139 * stubs added here, as stubs contribute to the final output
3143 next
= NEXT_SEC (head
);
3144 /* Set up this stub group. */
3145 htab
->stub_group
[head
->id
].link_sec
= curr
;
3147 while (head
!= curr
&& (head
= next
) != NULL
);
3149 /* But wait, there's more! Input sections up to stub_group_size
3150 * bytes after the stub section can be handled by it too. */
3151 if (!stubs_always_after_branch
)
3153 stub_group_start
= curr
->output_offset
+ curr
->size
;
3155 while (next
!= NULL
)
3157 end_of_next
= next
->output_offset
+ next
->size
;
3158 if (end_of_next
- stub_group_start
>= stub_group_size
)
3159 /* End of NEXT is too far from stubs, so stop. */
3161 /* Add NEXT to the stub group. */
3163 next
= NEXT_SEC (head
);
3164 htab
->stub_group
[head
->id
].link_sec
= curr
;
3170 while (list
++ != htab
->input_list
+ htab
->top_index
);
3172 free (htab
->input_list
);
3177 /* If the symbol referenced by bsr is defined in shared object file,
3178 or it is a weak symbol and we aim to create shared object file,
3179 we must create a stub for this bsr. */
3182 sym_must_create_stub (struct elf_link_hash_entry
*h
,
3183 struct bfd_link_info
*info
)
3186 && ((h
->def_dynamic
&& !h
->def_regular
)
3187 || (bfd_link_pic (info
) && h
->root
.type
== bfd_link_hash_defweak
)))
3193 /* Calculate the template, template size and instruction size for a stub.
3194 Return value is the instruction size. */
3197 find_stub_size_and_template (enum elf32_csky_stub_type stub_type
,
3198 const insn_sequence
**stub_template
,
3199 int *stub_template_size
)
3201 const insn_sequence
*template_sequence
= NULL
;
3202 int template_size
= 0;
3206 template_sequence
= stub_definitions
[stub_type
].template_sequence
;
3207 template_size
= stub_definitions
[stub_type
].template_size
;
3210 for (i
= 0; i
< template_size
; i
++)
3212 switch (template_sequence
[i
].type
)
3230 *stub_template
= template_sequence
;
3231 if (stub_template_size
)
3232 *stub_template_size
= template_size
;
3237 /* As above, but don't actually build the stub. Just bump offset so
3238 we know stub section sizes. */
3241 csky_size_one_stub (struct bfd_hash_entry
*gen_entry
,
3242 void * in_arg ATTRIBUTE_UNUSED
)
3244 struct elf32_csky_stub_hash_entry
*stub_entry
;
3245 const insn_sequence
*template_sequence
= NULL
;
3246 int template_size
= 0;
3249 /* Massage our args to the form they really have. */
3250 stub_entry
= (struct elf32_csky_stub_hash_entry
*) gen_entry
;
3252 BFD_ASSERT (stub_entry
->stub_type
> csky_stub_none
3253 && stub_entry
->stub_type
< ARRAY_SIZE (stub_definitions
));
3254 size
= find_stub_size_and_template (stub_entry
->stub_type
,
3255 &template_sequence
, &template_size
);
3256 stub_entry
->stub_size
= size
;
3257 stub_entry
->stub_template
= template_sequence
;
3258 stub_entry
->stub_template_size
= template_size
;
3260 size
= (size
+ 7) & ~7;
3261 stub_entry
->stub_sec
->size
+= size
;
3265 /* Add a new stub entry to the stub hash. Not all fields of the new
3266 stub entry are initialised. */
3268 static struct elf32_csky_stub_hash_entry
*
3269 elf32_csky_add_stub (const char *stub_name
,
3271 struct csky_elf_link_hash_table
*htab
)
3275 struct elf32_csky_stub_hash_entry
*stub_entry
;
3277 stub_sec
= elf32_csky_create_or_find_stub_sec (&link_sec
, section
, htab
);
3278 if (stub_sec
== NULL
)
3281 /* Enter this entry into the linker stub hash table. */
3282 stub_entry
= csky_stub_hash_lookup (&htab
->stub_hash_table
, stub_name
,
3284 if (stub_entry
== NULL
)
3286 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
3287 section
->owner
, stub_name
);
3291 stub_entry
->stub_sec
= stub_sec
;
3292 stub_entry
->stub_offset
= 0;
3293 stub_entry
->id_sec
= link_sec
;
3298 /* Determine and set the size of the stub section for a final link.
3299 The basic idea here is to examine all the relocations looking for
3300 PC-relative calls to a target that is unreachable with a "bsr"
3304 elf32_csky_size_stubs (bfd
*output_bfd
,
3306 struct bfd_link_info
*info
,
3307 bfd_signed_vma group_size
,
3308 asection
*(*add_stub_section
) (const char*, asection
*),
3309 void (*layout_sections_again
) (void))
3311 bfd_size_type stub_group_size
;
3312 bfd_boolean stubs_always_after_branch
;
3313 struct csky_elf_link_hash_table
*htab
= csky_elf_hash_table (info
);
3318 /* Propagate mach to stub bfd, because it may not have been
3319 finalized when we created stub_bfd. */
3320 bfd_set_arch_mach (stub_bfd
, bfd_get_arch (output_bfd
),
3321 bfd_get_mach (output_bfd
));
3323 /* Stash our params away. */
3324 htab
->stub_bfd
= stub_bfd
;
3325 htab
->add_stub_section
= add_stub_section
;
3326 htab
->layout_sections_again
= layout_sections_again
;
3327 stubs_always_after_branch
= group_size
< 0;
3330 stub_group_size
= -group_size
;
3332 stub_group_size
= group_size
;
3334 if (stub_group_size
== 1)
3335 /* The 'bsr' range in abiv2 is +-64MB has to be used as the
3336 default maximum size.
3337 This value is 128K less than that, which allows for 131072
3338 byte stubs. If we exceed that, then we will fail to link.
3339 The user will have to relink with an explicit group size
3341 stub_group_size
= 66977792;
3343 group_sections (htab
, stub_group_size
, stubs_always_after_branch
);
3348 unsigned int bfd_indx
;
3350 bfd_boolean stub_changed
= FALSE
;
3352 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
3354 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
3356 Elf_Internal_Shdr
*symtab_hdr
;
3358 Elf_Internal_Sym
*local_syms
= NULL
;
3360 /* We'll need the symbol table in a second. */
3361 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3362 if (symtab_hdr
->sh_info
== 0)
3365 /* Walk over each section attached to the input bfd. */
3366 for (section
= input_bfd
->sections
;
3368 section
= section
->next
)
3370 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
3372 /* If there aren't any relocs, then there's nothing more
3374 if ((section
->flags
& SEC_RELOC
) == 0
3375 || section
->reloc_count
== 0
3376 || (section
->flags
& SEC_CODE
) == 0)
3379 /* If this section is a link-once section that will be
3380 discarded, then don't create any stubs. */
3381 if (section
->output_section
== NULL
3382 || section
->output_section
->owner
!= output_bfd
)
3385 /* Get the relocs. */
3386 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
,
3391 if (internal_relocs
== NULL
)
3392 goto error_ret_free_local
;
3394 /* Now examine each relocation. */
3395 irela
= internal_relocs
;
3396 irelaend
= irela
+ section
->reloc_count
;
3397 for (; irela
< irelaend
; irela
++)
3399 unsigned int r_type
, r_indx
;
3400 enum elf32_csky_stub_type stub_type
;
3401 struct elf32_csky_stub_hash_entry
*stub_entry
;
3404 bfd_vma destination
;
3405 struct csky_elf_link_hash_entry
*hash
;
3406 const char *sym_name
;
3408 const asection
*id_sec
;
3409 unsigned char st_type
;
3411 r_type
= ELF32_R_TYPE (irela
->r_info
);
3412 r_indx
= ELF32_R_SYM (irela
->r_info
);
3413 if (r_type
>= (unsigned int) R_CKCORE_MAX
)
3415 bfd_set_error (bfd_error_bad_value
);
3416 error_ret_free_internal
:
3417 if (elf_section_data (section
)->relocs
== NULL
)
3418 free (internal_relocs
);
3419 goto error_ret_free_local
;
3422 /* Only look for stubs on branch instructions. */
3423 if (r_type
!= (unsigned int) R_CKCORE_PCREL_IMM26BY2
)
3425 /* Now determine the call target, its name, value,
3432 if (r_indx
< symtab_hdr
->sh_info
)
3434 /* It's a local symbol. */
3435 Elf_Internal_Sym
*sym
;
3436 Elf_Internal_Shdr
*hdr
;
3437 if (local_syms
== NULL
)
3439 (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3440 if (local_syms
== NULL
)
3443 bfd_elf_get_elf_syms (input_bfd
,
3445 symtab_hdr
->sh_info
,
3446 0, NULL
, NULL
, NULL
);
3447 if (local_syms
== NULL
)
3448 goto error_ret_free_internal
;
3450 sym
= local_syms
+ r_indx
;
3451 hdr
= elf_elfsections (input_bfd
)[sym
->st_shndx
];
3452 sym_sec
= hdr
->bfd_section
;
3454 /* This is an undefined symbol. It can never
3457 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3458 sym_value
= sym
->st_value
;
3459 destination
= (sym_value
+ irela
->r_addend
3460 + sym_sec
->output_offset
3461 + sym_sec
->output_section
->vma
);
3462 st_type
= ELF_ST_TYPE (sym
->st_info
);
3464 bfd_elf_string_from_elf_section (input_bfd
,
3465 symtab_hdr
->sh_link
,
3470 /* It's an external symbol. */
3472 e_indx
= r_indx
- symtab_hdr
->sh_info
;
3473 hash
= ((struct csky_elf_link_hash_entry
*)
3474 elf_sym_hashes (input_bfd
)[e_indx
]);
3476 while (hash
->elf
.root
.type
== bfd_link_hash_indirect
3477 || hash
->elf
.root
.type
== bfd_link_hash_warning
)
3478 hash
= ((struct csky_elf_link_hash_entry
*)
3479 hash
->elf
.root
.u
.i
.link
);
3480 if (hash
->elf
.root
.type
== bfd_link_hash_defined
3481 || hash
->elf
.root
.type
== bfd_link_hash_defweak
)
3483 sym_sec
= hash
->elf
.root
.u
.def
.section
;
3484 sym_value
= hash
->elf
.root
.u
.def
.value
;
3486 struct csky_elf_link_hash_table
*globals
=
3487 csky_elf_hash_table (info
);
3488 /* FIXME For a destination in a shared library. */
3489 if (globals
->elf
.splt
!= NULL
&& hash
!= NULL
3490 && hash
->elf
.plt
.offset
!= (bfd_vma
) -1)
3492 else if (sym_sec
->output_section
!= NULL
)
3493 destination
= (sym_value
+ irela
->r_addend
3494 + sym_sec
->output_offset
3495 + sym_sec
->output_section
->vma
);
3497 else if (hash
->elf
.root
.type
== bfd_link_hash_undefined
3498 || (hash
->elf
.root
.type
3499 == bfd_link_hash_undefweak
))
3500 /* FIXME For a destination in a shared library. */
3504 bfd_set_error (bfd_error_bad_value
);
3505 goto error_ret_free_internal
;
3507 st_type
= ELF_ST_TYPE (hash
->elf
.type
);
3508 sym_name
= hash
->elf
.root
.root
.string
;
3512 /* Determine what (if any) linker stub is needed. */
3513 stub_type
= csky_type_of_stub (info
, section
, irela
,
3515 destination
, sym_sec
,
3516 input_bfd
, sym_name
);
3517 if (stub_type
== csky_stub_none
)
3520 /* Support for grouping stub sections. */
3521 id_sec
= htab
->stub_group
[section
->id
].link_sec
;
3523 /* Get the name of this stub. */
3524 stub_name
= elf32_csky_stub_name (id_sec
, sym_sec
, hash
,
3527 goto error_ret_free_internal
;
3528 /* We've either created a stub for this reloc already,
3529 or we are about to. */
3531 = csky_stub_hash_lookup (&htab
->stub_hash_table
,
3534 if (stub_entry
!= NULL
)
3536 /* The proper stub has already been created. */
3538 stub_entry
->target_value
= sym_value
;
3541 stub_entry
= elf32_csky_add_stub (stub_name
, section
,
3543 if (stub_entry
== NULL
)
3546 goto error_ret_free_internal
;
3548 stub_entry
->target_value
= sym_value
;
3549 stub_entry
->target_section
= sym_sec
;
3550 stub_entry
->stub_type
= stub_type
;
3551 stub_entry
->h
= hash
;
3552 stub_entry
->st_type
= st_type
;
3554 if (sym_name
== NULL
)
3555 sym_name
= "unnamed";
3556 stub_entry
->output_name
=
3557 bfd_alloc (htab
->stub_bfd
,
3558 (sizeof (STUB_ENTRY_NAME
)
3559 + strlen (sym_name
)));
3560 if (stub_entry
->output_name
== NULL
)
3563 goto error_ret_free_internal
;
3565 sprintf (stub_entry
->output_name
, STUB_ENTRY_NAME
,
3567 stub_changed
= TRUE
;
3571 /* We're done with the internal relocs, free them. */
3572 if (elf_section_data (section
)->relocs
== NULL
)
3573 free (internal_relocs
);
3578 /* OK, we've added some stubs. Find out the new size of the
3580 for (stub_sec
= htab
->stub_bfd
->sections
;
3582 stub_sec
= stub_sec
->next
)
3584 /* Ignore non-stub sections. */
3585 if (!strstr (stub_sec
->name
, STUB_SUFFIX
))
3589 bfd_hash_traverse (&htab
->stub_hash_table
, csky_size_one_stub
, htab
);
3590 /* Ask the linker to do its stuff. */
3591 (*htab
->layout_sections_again
) ();
3595 error_ret_free_local
:
3600 csky_build_one_stub (struct bfd_hash_entry
*gen_entry
,
3604 struct elf32_csky_stub_hash_entry
*stub_entry
;
3605 struct bfd_link_info
*info
;
3612 const insn_sequence
*template_sequence
;
3614 struct csky_elf_link_hash_table
* globals
;
3615 int stub_reloc_idx
[MAXRELOCS
] = {-1, -1};
3616 int stub_reloc_offset
[MAXRELOCS
] = {0, 0};
3618 struct elf_link_hash_entry
*h
= NULL
;
3620 /* Massage our args to the form they really have. */
3621 stub_entry
= (struct elf32_csky_stub_hash_entry
*)gen_entry
;
3622 info
= (struct bfd_link_info
*) in_arg
;
3624 /* Fail if the target section could not be assigned to an output
3625 section. The user should fix his linker script. */
3626 if (stub_entry
->target_section
->output_section
== NULL
3627 && info
->non_contiguous_regions
)
3628 info
->callbacks
->einfo (_("%F%P: Could not assign '%pA' to an output section. "
3629 "Retry without --enable-non-contiguous-regions.\n"),
3630 stub_entry
->target_section
);
3632 globals
= csky_elf_hash_table (info
);
3633 if (globals
== NULL
)
3635 stub_sec
= stub_entry
->stub_sec
;
3637 /* Make a note of the offset within the stubs for this entry. */
3638 stub_entry
->stub_offset
= stub_sec
->size
;
3639 loc
= stub_sec
->contents
+ stub_entry
->stub_offset
;
3641 stub_bfd
= stub_sec
->owner
;
3643 /* This is the address of the stub destination. */
3644 h
= &stub_entry
->h
->elf
;
3645 if (sym_must_create_stub (h
, info
)
3646 && !(bfd_link_pic (info
)
3647 && h
->root
.type
== bfd_link_hash_defweak
3649 && !h
->def_dynamic
))
3652 sym_value
= (stub_entry
->target_value
3653 + stub_entry
->target_section
->output_offset
3654 + stub_entry
->target_section
->output_section
->vma
);
3656 template_sequence
= stub_entry
->stub_template
;
3657 template_size
= stub_entry
->stub_template_size
;
3660 for (i
= 0; i
< template_size
; i
++)
3661 switch (template_sequence
[i
].type
)
3664 bfd_put_16 (stub_bfd
, (bfd_vma
) template_sequence
[i
].data
,
3669 csky_put_insn_32 (stub_bfd
, (bfd_vma
) template_sequence
[i
].data
,
3674 bfd_put_32 (stub_bfd
, (bfd_vma
) template_sequence
[i
].data
,
3676 stub_reloc_idx
[nrelocs
] = i
;
3677 stub_reloc_offset
[nrelocs
++] = size
;
3684 stub_sec
->size
+= size
;
3686 /* Stub size has already been computed in csky_size_one_stub. Check
3688 BFD_ASSERT (size
== stub_entry
->stub_size
);
3690 /* Assume there is at least one and at most MAXRELOCS entries to relocate
3692 BFD_ASSERT (nrelocs
!= 0 && nrelocs
<= MAXRELOCS
);
3694 for (i
= 0; i
< nrelocs
; i
++)
3696 if (sym_must_create_stub (h
, info
))
3698 Elf_Internal_Rela outrel
;
3699 asection
* sreloc
= globals
->elf
.srelgot
;
3701 outrel
.r_offset
= stub_entry
->stub_offset
+ stub_reloc_offset
[i
];
3703 ELF32_R_INFO (h
->dynindx
,
3704 template_sequence
[stub_reloc_idx
[i
]].r_type
);
3705 outrel
.r_addend
= template_sequence
[stub_reloc_idx
[i
]].reloc_addend
;
3707 loc
= sreloc
->contents
;
3708 loc
+= sreloc
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3711 bfd_elf32_swap_reloca_out (info
->output_bfd
, &outrel
, loc
);
3713 _bfd_final_link_relocate (elf32_csky_howto_from_type
3714 (template_sequence
[stub_reloc_idx
[i
]].r_type
),
3715 stub_bfd
, stub_sec
, stub_sec
->contents
,
3716 stub_entry
->stub_offset
+ stub_reloc_offset
[i
],
3717 sym_value
+ stub_entry
->target_addend
,
3718 template_sequence
[stub_reloc_idx
[i
]].reloc_addend
);
3725 /* Build all the stubs associated with the current output file. The
3726 stubs are kept in a hash table attached to the main linker hash
3727 table. We also set up the .plt entries for statically linked PIC
3728 functions here. This function is called via arm_elf_finish in the
3732 elf32_csky_build_stubs (struct bfd_link_info
*info
)
3735 struct bfd_hash_table
*table
;
3736 struct csky_elf_link_hash_table
*htab
;
3738 htab
= csky_elf_hash_table (info
);
3743 for (stub_sec
= htab
->stub_bfd
->sections
;
3745 stub_sec
= stub_sec
->next
)
3749 /* Ignore non-stub sections. */
3750 if (!strstr (stub_sec
->name
, STUB_SUFFIX
))
3753 /* Allocate memory to hold the linker stubs. */
3754 size
= stub_sec
->size
;
3755 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, size
);
3756 if (stub_sec
->contents
== NULL
&& size
!= 0)
3761 /* Build the stubs as directed by the stub hash table. */
3762 table
= &htab
->stub_hash_table
;
3763 bfd_hash_traverse (table
, csky_build_one_stub
, info
);
3768 /* Set up various things so that we can make a list of input sections
3769 for each output section included in the link. Returns -1 on error,
3770 0 when no stubs will be needed, and 1 on success. */
3773 elf32_csky_setup_section_lists (bfd
*output_bfd
,
3774 struct bfd_link_info
*info
)
3777 unsigned int bfd_count
;
3778 unsigned int top_id
, top_index
;
3780 asection
**input_list
, **list
;
3782 struct csky_elf_link_hash_table
*htab
= csky_elf_hash_table (info
);
3786 if (! is_elf_hash_table (htab
))
3789 /* Count the number of input BFDs and find the top input section id. */
3790 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
3792 input_bfd
= input_bfd
->link
.next
)
3795 for (section
= input_bfd
->sections
;
3797 section
= section
->next
)
3798 if (top_id
< section
->id
)
3799 top_id
= section
->id
;
3801 htab
->bfd_count
= bfd_count
;
3802 amt
= sizeof (struct map_stub
) * (top_id
+ 1);
3803 htab
->stub_group
= bfd_zmalloc (amt
);
3804 if (htab
->stub_group
== NULL
)
3807 /* We can't use output_bfd->section_count here to find the top output
3808 section index as some sections may have been removed, and
3809 _bfd_strip_section_from_output doesn't renumber the indices. */
3810 for (section
= output_bfd
->sections
, top_index
= 0;
3812 section
= section
->next
)
3813 if (top_index
< section
->index
)
3814 top_index
= section
->index
;
3815 htab
->top_index
= top_index
;
3816 amt
= sizeof (asection
*) * (top_index
+ 1);
3817 input_list
= bfd_malloc (amt
);
3818 htab
->input_list
= input_list
;
3819 if (input_list
== NULL
)
3821 /* For sections we aren't interested in, mark their entries with a
3822 value we can check later. */
3823 list
= input_list
+ top_index
;
3825 *list
= bfd_abs_section_ptr
;
3826 while (list
-- != input_list
);
3827 for (section
= output_bfd
->sections
;
3829 section
= section
->next
)
3830 if ((section
->flags
& SEC_CODE
) != 0)
3831 input_list
[section
->index
] = NULL
;
3836 static bfd_reloc_status_type
3837 csky_relocate_contents (reloc_howto_type
*howto
,
3844 bfd_reloc_status_type flag
;
3845 unsigned int rightshift
= howto
->rightshift
;
3846 unsigned int bitpos
= howto
->bitpos
;
3848 /* If the size is negative, negate RELOCATION. This isn't very
3850 if (howto
->size
< 0)
3851 relocation
= -relocation
;
3853 /* FIXME: these macros should be defined at file head or head file head. */
3854 #define CSKY_INSN_ADDI_TO_SUBI 0x04000000
3855 #define CSKY_INSN_MOV_RTB 0xc41d4820 // mov32 rx, r29, 0
3856 #define CSKY_INSN_MOV_RDB 0xc41c4820 // mov32 rx, r28, 0
3857 #define CSKY_INSN_GET_ADDI_RZ(x) (((x) & 0x03e00000) >> 21)
3858 #define CSKY_INSN_SET_MOV_RZ(x) ((x) & 0x0000001f)
3859 #define CSKY_INSN_JSRI_TO_LRW 0xea9a0000
3860 #define CSKY_INSN_JSR_R26 0xe8fa0000
3862 /* Get the value we are going to relocate. */
3863 size
= bfd_get_reloc_size (howto
);
3870 x
= bfd_get_8 (input_bfd
, location
);
3873 x
= bfd_get_16 (input_bfd
, location
);
3876 if (need_reverse_bits
)
3878 x
= csky_get_insn_32 (input_bfd
, location
);
3880 if (R_CKCORE_DOFFSET_LO16
== howto
->type
)
3882 if ((signed) relocation
< 0)
3884 x
|= CSKY_INSN_ADDI_TO_SUBI
;
3885 relocation
= -relocation
;
3887 else if (0 == relocation
)
3888 x
= (CSKY_INSN_MOV_RDB
|
3889 CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x
)));
3891 else if (R_CKCORE_TOFFSET_LO16
== howto
->type
)
3893 if ((signed) relocation
< 0)
3895 x
|= CSKY_INSN_ADDI_TO_SUBI
;
3896 relocation
= -relocation
;
3898 else if (0 == relocation
)
3899 x
= (CSKY_INSN_MOV_RTB
|
3900 CSKY_INSN_SET_MOV_RZ (CSKY_INSN_GET_ADDI_RZ (x
)));
3904 x
= bfd_get_32 (input_bfd
, location
);
3907 /* Check for overflow. FIXME: We may drop bits during the addition
3908 which we don't check for. We must either check at every single
3909 operation, which would be tedious, or we must do the computations
3910 in a type larger than bfd_vma, which would be inefficient. */
3911 flag
= bfd_reloc_ok
;
3912 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
3921 /* Get the values to be added together. For signed and unsigned
3922 relocations, we assume that all values should be truncated to
3923 the size of an address. For bitfields, all the bits matter.
3924 See also bfd_check_overflow. */
3925 #define N_ONES(n) (((((bfd_vma) 1 << ((n) - 1)) - 1) << 1) | 1)
3926 fieldmask
= N_ONES (howto
->bitsize
);
3927 signmask
= ~fieldmask
;
3928 addrmask
= N_ONES (bfd_arch_bits_per_address (input_bfd
)) | fieldmask
;
3929 a
= (relocation
& addrmask
) >> rightshift
;
3930 if (read_content_substitute
)
3931 x
= read_content_substitute
;
3932 b
= (x
& howto
->src_mask
& addrmask
) >> bitpos
;
3934 switch (howto
->complain_on_overflow
)
3936 case complain_overflow_signed
:
3937 /* If any sign bits are set, all sign bits must be set.
3938 That is, A must be a valid negative address after
3940 signmask
= ~(fieldmask
>> 1);
3943 case complain_overflow_bitfield
:
3944 /* Much like the signed check, but for a field one bit
3945 wider. We allow a bitfield to represent numbers in the
3946 range -2**n to 2**n-1, where n is the number of bits in the
3947 field. Note that when bfd_vma is 32 bits, a 32-bit reloc
3948 can't overflow, which is exactly what we want. */
3950 if (ss
!= 0 && ss
!= ((addrmask
>> rightshift
) & signmask
))
3951 flag
= bfd_reloc_overflow
;
3952 /* We only need this next bit of code if the sign bit of B
3953 is below the sign bit of A. This would only happen if
3954 SRC_MASK had fewer bits than BITSIZE. Note that if
3955 SRC_MASK has more bits than BITSIZE, we can get into
3956 trouble; we would need to verify that B is in range, as
3957 we do for A above. */
3958 ss
= ((~howto
->src_mask
) >> 1) & howto
->src_mask
;
3961 /* Set all the bits above the sign bit. */
3964 /* Now we can do the addition. */
3967 /* See if the result has the correct sign. Bits above the
3968 sign bit are junk now; ignore them. If the sum is
3969 positive, make sure we did not have all negative inputs;
3970 if the sum is negative, make sure we did not have all
3971 positive inputs. The test below looks only at the sign
3972 bits, and it really just
3973 SIGN (A) == SIGN (B) && SIGN (A) != SIGN (SUM)
3975 We mask with addrmask here to explicitly allow an address
3976 wrap-around. The Linux kernel relies on it, and it is
3977 the only way to write assembler code which can run when
3978 loaded at a location 0x80000000 away from the location at
3979 which it is linked. */
3981 if (((~(a
^ b
)) & (a
^ sum
)) & signmask
& addrmask
)
3982 flag
= bfd_reloc_overflow
;
3984 case complain_overflow_unsigned
:
3985 /* Checking for an unsigned overflow is relatively easy:
3986 trim the addresses and add, and trim the result as well.
3987 Overflow is normally indicated when the result does not
3988 fit in the field. However, we also need to consider the
3989 case when, e.g., fieldmask is 0x7fffffff or smaller, an
3990 input is 0x80000000, and bfd_vma is only 32 bits; then we
3991 will get sum == 0, but there is an overflow, since the
3992 inputs did not fit in the field. Instead of doing a
3993 separate test, we can check for this by or-ing in the
3994 operands when testing for the sum overflowing its final
3996 sum
= (a
+ b
) & addrmask
;
3997 if ((a
| b
| sum
) & signmask
)
3998 flag
= bfd_reloc_overflow
;
4005 /* Put RELOCATION in the right bits. */
4006 relocation
>>= (bfd_vma
) rightshift
;
4008 if ((howto
->type
== R_CKCORE_DOFFSET_LO16
4009 || howto
->type
== R_CKCORE_TOFFSET_LO16
)
4011 /* Do nothing lsli32 rx, rz, 0. */
4015 /* Fir V1, all this relocation must be x -1. */
4016 if (howto
->type
== R_CKCORE_PCREL_IMM11BY2
4017 || howto
->type
== R_CKCORE_PCREL_JSR_IMM11BY2
4018 || howto
->type
== R_CKCORE_DOFFSET_LO16
4019 || howto
->type
== R_CKCORE_TOFFSET_LO16
)
4021 else if (howto
->type
== R_CKCORE_PCREL_IMM7BY4
)
4022 relocation
= (relocation
& 0x1f) + ((relocation
<< 3) & 0x300);
4023 else if (howto
->type
== R_CKCORE_PCREL_FLRW_IMM8BY4
)
4025 = ((relocation
<< 4) & 0xf0) + ((relocation
<< 17) & 0x1e00000);
4026 else if (howto
->type
== R_CKCORE_NOJSRI
)
4028 x
= (x
& howto
->dst_mask
) | CSKY_INSN_JSRI_TO_LRW
;
4030 csky_put_insn_32 (input_bfd
, CSKY_INSN_JSR_R26
, location
+ 4);
4033 relocation
<<= (bfd_vma
) bitpos
;
4034 /* Add RELOCATION to the right bits of X. */
4035 x
= ((x
& ~howto
->dst_mask
)
4036 | (((x
& howto
->src_mask
) + relocation
) & howto
->dst_mask
));
4038 /* Put the relocated value back in the object file. */
4044 bfd_put_8 (input_bfd
, x
, location
);
4047 bfd_put_16 (input_bfd
, x
, location
);
4050 if (need_reverse_bits
)
4051 csky_put_insn_32 (input_bfd
, x
, location
);
4053 bfd_put_32 (input_bfd
, x
, location
);
4059 /* Look up an entry in the stub hash. Stub entries are cached because
4060 creating the stub name takes a bit of time. */
4062 static struct elf32_csky_stub_hash_entry
*
4063 elf32_csky_get_stub_entry (const asection
*input_section
,
4064 const asection
*sym_sec
,
4065 struct elf_link_hash_entry
*hash
,
4066 const Elf_Internal_Rela
*rel
,
4067 struct csky_elf_link_hash_table
*htab
)
4069 struct elf32_csky_stub_hash_entry
*stub_entry
;
4070 struct csky_elf_link_hash_entry
*h
4071 = (struct csky_elf_link_hash_entry
*) hash
;
4072 const asection
*id_sec
;
4074 if ((input_section
->flags
& SEC_CODE
) == 0)
4077 /* If this input section is part of a group of sections sharing one
4078 stub section, then use the id of the first section in the group.
4079 Stub names need to include a section id, as there may well be
4080 more than one stub used to reach say, printf, and we need to
4081 distinguish between them. */
4082 id_sec
= htab
->stub_group
[input_section
->id
].link_sec
;
4083 if (h
!= NULL
&& h
->stub_cache
!= NULL
4084 && h
->stub_cache
->h
== h
&& h
->stub_cache
->id_sec
== id_sec
)
4085 stub_entry
= h
->stub_cache
;
4089 stub_name
= elf32_csky_stub_name (id_sec
, sym_sec
, h
, rel
);
4090 if (stub_name
== NULL
)
4092 stub_entry
= csky_stub_hash_lookup (&htab
->stub_hash_table
,
4093 stub_name
, FALSE
, FALSE
);
4095 h
->stub_cache
= stub_entry
;
4102 static bfd_reloc_status_type
4103 csky_final_link_relocate (reloc_howto_type
*howto
,
4105 asection
*input_section
,
4113 /* Sanity check the address. */
4114 if (address
> bfd_get_section_limit (input_bfd
, input_section
))
4115 return bfd_reloc_outofrange
;
4117 /* This function assumes that we are dealing with a basic relocation
4118 against a symbol. We want to compute the value of the symbol to
4119 relocate to. This is just VALUE, the value of the symbol,
4120 plus ADDEND, any addend associated with the reloc. */
4121 relocation
= value
+ addend
;
4123 /* If the relocation is PC relative, we want to set RELOCATION to
4124 the distance between the symbol (currently in RELOCATION) and the
4125 location we are relocating. Some targets (e.g., i386-aout)
4126 arrange for the contents of the section to be the negative of the
4127 offset of the location within the section; for such targets
4128 pcrel_offset is FALSE. Other targets (e.g., m88kbcs or ELF)
4129 simply leave the contents of the section as zero; for such
4130 targets pcrel_offset is TRUE. If pcrel_offset is FALSE we do not
4131 need to subtract out the offset of the location within the
4132 section (which is just ADDRESS). */
4133 if (howto
->pc_relative
)
4135 relocation
-= (input_section
->output_section
->vma
4136 + input_section
->output_offset
);
4137 if (howto
->pcrel_offset
)
4138 relocation
-= address
;
4141 return csky_relocate_contents (howto
, input_bfd
, relocation
,
4142 contents
+ address
);
4146 /* Return the base VMA address which should be subtracted from real addresses
4147 when resolving @dtpoff relocation.
4148 This is PT_TLS segment p_vaddr. */
4151 dtpoff_base (struct bfd_link_info
*info
)
4153 /* If tls_sec is NULL, we should have signalled an error already. */
4154 if (elf_hash_table (info
)->tls_sec
== NULL
)
4156 return elf_hash_table (info
)->tls_sec
->vma
;
4159 /* Return the relocation value for @tpoff relocation
4160 if STT_TLS virtual address is ADDRESS. */
4163 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
4165 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
4168 /* If tls_sec is NULL, we should have signalled an error already. */
4169 if (htab
->tls_sec
== NULL
)
4171 base
= align_power ((bfd_vma
) TCB_SIZE
, htab
->tls_sec
->alignment_power
);
4172 return address
- htab
->tls_sec
->vma
+ base
;
4175 /* Relocate a csky section. */
4178 csky_elf_relocate_section (bfd
* output_bfd
,
4179 struct bfd_link_info
* info
,
4181 asection
* input_section
,
4182 bfd_byte
* contents
,
4183 Elf_Internal_Rela
* relocs
,
4184 Elf_Internal_Sym
* local_syms
,
4185 asection
** local_sections
)
4187 Elf_Internal_Shdr
*symtab_hdr
;
4188 struct elf_link_hash_entry
**sym_hashes
;
4189 Elf_Internal_Rela
*rel
;
4190 Elf_Internal_Rela
*relend
;
4192 bfd_boolean ret
= TRUE
;
4193 struct csky_elf_link_hash_table
* htab
;
4194 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
4196 htab
= csky_elf_hash_table (info
);
4200 symtab_hdr
= & elf_symtab_hdr (input_bfd
);
4201 sym_hashes
= elf_sym_hashes (input_bfd
);
4204 relend
= relocs
+ input_section
->reloc_count
;
4205 for (; rel
< relend
; rel
++)
4207 enum elf_csky_reloc_type r_type
4208 = (enum elf_csky_reloc_type
) ELF32_R_TYPE (rel
->r_info
);
4209 unsigned long r_symndx
;
4210 reloc_howto_type
* howto
;
4211 Elf_Internal_Sym
* sym
;
4215 struct elf_link_hash_entry
* h
;
4216 bfd_vma addend
= (bfd_vma
)rel
->r_addend
;
4217 bfd_reloc_status_type r
= bfd_reloc_ok
;
4218 bfd_boolean unresolved_reloc
= FALSE
;
4219 int do_final_relocate
= TRUE
;
4220 bfd_boolean relative_reloc
= FALSE
;
4221 bfd_signed_vma disp
;
4223 /* Ignore these relocation types:
4224 R_CKCORE_GNU_VTINHERIT, R_CKCORE_GNU_VTENTRY. */
4225 if (r_type
== R_CKCORE_GNU_VTINHERIT
|| r_type
== R_CKCORE_GNU_VTENTRY
)
4228 if ((unsigned) r_type
>= (unsigned) R_CKCORE_MAX
)
4230 /* The r_type is error, not support it. */
4231 /* xgettext:c-format */
4232 _bfd_error_handler (_("%pB: unsupported relocation type: %#x"),
4234 bfd_set_error (bfd_error_bad_value
);
4239 howto
= &csky_elf_howto_table
[(int) r_type
];
4241 r_symndx
= ELF32_R_SYM(rel
->r_info
);
4245 unresolved_reloc
= FALSE
;
4247 if (r_symndx
< symtab_hdr
->sh_info
)
4249 /* Get symbol table entry. */
4250 sym
= local_syms
+ r_symndx
;
4251 sec
= local_sections
[r_symndx
];
4252 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
4253 addend
= (bfd_vma
)rel
->r_addend
;
4257 bfd_boolean warned
, ignored
;
4259 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
4260 r_symndx
, symtab_hdr
, sym_hashes
,
4262 unresolved_reloc
, warned
, ignored
);
4265 if (sec
!= NULL
&& discarded_section (sec
))
4267 /* For relocs against symbols from removed linkonce sections,
4268 or sections discarded by a linker script, we just want the
4269 section contents zeroed. Avoid any special processing.
4270 And if the symbol is referenced in '.csky_stack_size' section,
4271 set the address to SEC_DISCARDED(0xffffffff). */
4273 /* The .csky_stack_size section is just for callgraph. */
4274 if (strcmp (input_section
->name
, ".csky_stack_size") == 0)
4276 /* FIXME: it should define in head file. */
4277 #define SEC_DISCARDED 0xffffffff
4278 bfd_put_32 (input_bfd
, SEC_DISCARDED
, contents
+ rel
->r_offset
);
4285 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
4286 rel
, 1, relend
, howto
, 0,
4290 if (bfd_link_relocatable (info
))
4293 read_content_substitute
= 0;
4297 + (bfd_signed_vma
) addend
4298 - input_section
->output_section
->vma
4299 - input_section
->output_offset
4301 /* It is for ck8xx. */
4302 #define CSKY_INSN_BSR32 0xe0000000
4303 /* It is for ck5xx/ck6xx. */
4304 #define CSKY_INSN_BSR16 0xf800
4305 #define within_range(x, L) (-(1 << (L - 1)) < (x) && (x) < (1 << (L -1)) - 2)
4306 switch (howto
->type
)
4308 case R_CKCORE_PCREL_IMM18BY2
:
4309 /* When h is NULL, means the instruction written as
4311 if the highest bit is set, prevent the high 32bits
4312 turn to 0xffffffff when signed extern in 64bit
4314 if (h
== NULL
&& (addend
& 0x80000000))
4315 addend
&= 0xffffffff;
4318 case R_CKCORE_PCREL32
:
4321 case R_CKCORE_GOT12
:
4322 case R_CKCORE_PLT12
:
4323 case R_CKCORE_GOT_HI16
:
4324 case R_CKCORE_GOT_LO16
:
4325 case R_CKCORE_PLT_HI16
:
4326 case R_CKCORE_PLT_LO16
:
4327 case R_CKCORE_GOT32
:
4328 case R_CKCORE_GOT_IMM18BY4
:
4329 /* Relocation is to the entry for this symbol in the global
4331 BFD_ASSERT (htab
->elf
.sgot
!= NULL
);
4334 /* Global symbol is defined by other modules. */
4336 off
= h
->got
.offset
;
4337 dyn
= htab
->elf
.dynamic_sections_created
;
4338 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4339 bfd_link_pic (info
), h
)
4340 || (bfd_link_pic (info
) && SYMBOL_REFERENCES_LOCAL (info
,h
))
4341 || (ELF_ST_VISIBILITY(h
->other
)
4342 && h
->root
.type
== bfd_link_hash_undefweak
))
4344 /* This is actually a static link, or it is a
4345 -Bsymbolic link and the symbol is defined
4346 locally, or the symbol was forced to be local
4347 because of a version file. We must initialize
4348 this entry in the global offset table. Since the
4349 offset must always be a multiple of 4, we use the
4350 least significant bit to record whether we have
4351 initialized it already.
4352 When doing a dynamic link, we create a .rela.dyn
4353 relocation entry to initialize the value. This
4354 is done in the finish_dynamic_symbol routine. FIXME */
4359 bfd_put_32 (output_bfd
, relocation
,
4360 htab
->elf
.sgot
->contents
+ off
);
4363 /* TRUE if relative relocation should be generated. GOT reference to
4364 global symbol in PIC will lead to dynamic symbol. It becomes a
4365 problem when "time" or "times" is defined as a variable in an
4366 executable, clashing with functions of the same name in libc. If a
4367 symbol isn't undefined weak symbol, don't make it dynamic in PIC and
4368 generate relative relocation. */
4369 #define GENERATE_RELATIVE_RELOC_P(INFO, H) \
4370 ((H)->dynindx == -1 \
4371 && !(H)->forced_local \
4372 && (H)->root.type != bfd_link_hash_undefweak \
4373 && bfd_link_pic (INFO))
4375 if (GENERATE_RELATIVE_RELOC_P (info
, h
))
4376 /* If this symbol isn't dynamic
4377 in PIC, generate R_CKCORE_RELATIVE here. */
4378 relative_reloc
= TRUE
;
4382 unresolved_reloc
= FALSE
;
4383 } /* End if h != NULL. */
4386 BFD_ASSERT (local_got_offsets
!= NULL
);
4387 off
= local_got_offsets
[r_symndx
];
4389 /* The offset must always be a multiple of 4. We use
4390 the least significant bit to record whether we have
4391 already generated the necessary reloc. */
4396 bfd_put_32 (output_bfd
, relocation
,
4397 htab
->elf
.sgot
->contents
+ off
);
4398 local_got_offsets
[r_symndx
] |= 1;
4399 if (bfd_link_pic (info
))
4400 relative_reloc
= TRUE
;
4406 Elf_Internal_Rela outrel
;
4409 srelgot
= htab
->elf
.srelgot
;
4410 BFD_ASSERT (srelgot
!= NULL
);
4413 = (htab
->elf
.sgot
->output_section
->vma
4414 + htab
->elf
.sgot
->output_offset
+ off
);
4415 outrel
.r_info
= ELF32_R_INFO (0, R_CKCORE_RELATIVE
);
4416 outrel
.r_addend
= relocation
;
4417 loc
= srelgot
->contents
;
4418 loc
+= (srelgot
->reloc_count
++ * sizeof (Elf32_External_Rela
));
4420 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4422 relocation
= htab
->elf
.sgot
->output_offset
+ off
;
4425 case R_CKCORE_GOTOFF_IMM18
:
4426 case R_CKCORE_GOTOFF
:
4427 case R_CKCORE_GOTOFF_HI16
:
4428 case R_CKCORE_GOTOFF_LO16
:
4429 /* Relocation is relative to the start of the global offset
4431 /* Note that sgot->output_offset is not involved in this
4432 calculation. We always want the start of .got. If we
4433 defined _GLOBAL_OFFSET_TABLE in a different way, as is
4434 permitted by the ABI, we might have to change this
4436 relocation
-= htab
->elf
.sgot
->output_section
->vma
;
4439 case R_CKCORE_GOTPC
:
4440 case R_CKCORE_GOTPC_HI16
:
4441 case R_CKCORE_GOTPC_LO16
:
4442 /* Use global offset table as symbol value. */
4443 relocation
= htab
->elf
.sgot
->output_section
->vma
;
4445 unresolved_reloc
= FALSE
;
4448 case R_CKCORE_DOFFSET_IMM18
:
4449 case R_CKCORE_DOFFSET_IMM18BY2
:
4450 case R_CKCORE_DOFFSET_IMM18BY4
:
4452 asection
*sdata
= bfd_get_section_by_name (output_bfd
, ".data");
4453 relocation
-= sdata
->output_section
->vma
;
4457 case R_CKCORE_DOFFSET_LO16
:
4459 asection
*sdata
= bfd_get_section_by_name (output_bfd
, ".data");
4460 relocation
-= sdata
->output_section
->vma
;
4464 case R_CKCORE_TOFFSET_LO16
:
4466 asection
*stext
= bfd_get_section_by_name (output_bfd
, ".text");
4468 relocation
-= stext
->output_section
->vma
;
4472 case R_CKCORE_PLT_IMM18BY4
:
4473 case R_CKCORE_PLT32
:
4474 /* Relocation is to the entry for this symbol in the
4475 procedure linkage table. */
4477 /* Resolve a PLT32 reloc against a local symbol directly,
4478 without using the procedure linkage table. */
4482 if (h
->plt
.offset
== (bfd_vma
) -1 || htab
->elf
.splt
== NULL
)
4484 /* We didn't make a PLT entry for this symbol. This
4485 happens when statically linking PIC code, or when
4486 using -Bsymbolic. */
4487 if (h
->got
.offset
!= (bfd_vma
) -1)
4491 off
= h
->got
.offset
;
4492 dyn
= htab
->elf
.dynamic_sections_created
;
4493 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4494 bfd_link_pic (info
), h
)
4495 || (bfd_link_pic (info
)
4496 && SYMBOL_REFERENCES_LOCAL (info
, h
))
4497 || (ELF_ST_VISIBILITY (h
->other
)
4498 && h
->root
.type
== bfd_link_hash_undefweak
))
4500 /* This is actually a static link, or it is a
4501 -Bsymbolic link and the symbol is defined
4502 locally, or the symbol was forced to be local
4503 because of a version file. We must initialize
4504 this entry in the global offset table. Since the
4505 offset must always be a multiple of 4, we use the
4506 least significant bit to record whether we have
4507 initialized it already.
4509 When doing a dynamic link, we create a .rela.dyn
4510 relocation entry to initialize the value. This
4511 is done in the finish_dynamic_symbol routine.
4518 if (GENERATE_RELATIVE_RELOC_P (info
, h
))
4519 relative_reloc
= TRUE
;
4522 bfd_put_32 (output_bfd
, relocation
,
4523 htab
->elf
.sgot
->contents
+ off
);
4528 Elf_Internal_Rela outrel
;
4531 srelgot
= htab
->elf
.srelgot
;
4532 BFD_ASSERT (srelgot
!= NULL
);
4535 = (htab
->elf
.sgot
->output_section
->vma
4536 + htab
->elf
.sgot
->output_offset
+ off
);
4537 outrel
.r_info
= ELF32_R_INFO (0, R_CKCORE_RELATIVE
);
4538 outrel
.r_addend
= relocation
;
4539 loc
= srelgot
->contents
;
4540 loc
+= (srelgot
->reloc_count
++
4541 * sizeof (Elf32_External_Rela
));
4543 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4545 relocation
= off
+ htab
->elf
.sgot
->output_offset
;
4549 /* The relocation is the got offset. */
4550 if (bfd_csky_abi (output_bfd
) == CSKY_ABI_V2
)
4551 relocation
= (h
->plt
.offset
/ PLT_ENTRY_SIZE
+ 2) * 4;
4553 relocation
= (h
->plt
.offset
/ PLT_ENTRY_SIZE_P
+ 2) * 4;
4554 unresolved_reloc
= FALSE
;
4557 case R_CKCORE_PCREL_IMM26BY2
:
4558 case R_CKCORE_PCREL_JSR_IMM26BY2
:
4559 case R_CKCORE_PCREL_JSR_IMM11BY2
:
4560 case R_CKCORE_PCREL_IMM11BY2
:
4561 case R_CKCORE_CALLGRAPH
:
4562 /* Emit callgraph information first. */
4563 /* TODO: deal with callgraph. */
4564 if (ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_CALLGRAPH
)
4566 /* Some reloc need further handling. */
4567 /* h == NULL means the symbol is a local symbol,
4568 r_symndx == 0 means the symbol is 'ABS' and
4569 the relocation is already handled in assemble,
4570 here just use for callgraph. */
4571 /* TODO: deal with callgraph. */
4572 if (h
== NULL
&& r_symndx
== 0)
4574 do_final_relocate
= FALSE
;
4578 /* Ignore weak references to undefined symbols. */
4579 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
)
4581 do_final_relocate
= FALSE
;
4585 /* Using branch stub. */
4586 if (use_branch_stub
== TRUE
4587 && ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_PCREL_IMM26BY2
)
4589 struct elf32_csky_stub_hash_entry
*stub_entry
= NULL
;
4590 if (sym_must_create_stub (h
, info
))
4591 stub_entry
= elf32_csky_get_stub_entry (input_section
,
4594 else if (disp
> BSR_MAX_FWD_BRANCH_OFFSET
4595 || disp
< BSR_MAX_BWD_BRANCH_OFFSET
)
4596 stub_entry
= elf32_csky_get_stub_entry (input_section
,
4599 if (stub_entry
!= NULL
)
4601 = (stub_entry
->stub_offset
4602 + stub_entry
->stub_sec
->output_offset
4603 + stub_entry
->stub_sec
->output_section
->vma
);
4608 || (h
->root
.type
== bfd_link_hash_defined
4609 && h
->dynindx
== -1)
4610 || ((h
->def_regular
&& !h
->def_dynamic
)
4611 && (h
->root
.type
!= bfd_link_hash_defweak
4612 || ! bfd_link_pic (info
))))
4614 if (ELF32_R_TYPE (rel
->r_info
) == R_CKCORE_PCREL_JSR_IMM26BY2
)
4616 if (within_range (disp
, 26))
4618 /* In range for BSR32. */
4619 howto
= &csky_elf_howto_table
[R_CKCORE_PCREL_IMM26BY2
];
4620 read_content_substitute
= CSKY_INSN_BSR32
;
4622 else if (bfd_csky_arch (output_bfd
) == CSKY_ARCH_810
)
4623 /* if bsr32 cannot reach, generate
4624 "lrw r25, label; jsr r25" instead of
4626 howto
= &csky_elf_howto_table
[R_CKCORE_NOJSRI
];
4627 } /* if ELF32_R_TYPE (rel->r_info)... */
4628 else if (ELF32_R_TYPE (rel
->r_info
)
4629 == R_CKCORE_PCREL_JSR_IMM11BY2
)
4631 if (within_range (disp
, 11))
4633 /* In range for BSR16. */
4634 howto
= &csky_elf_howto_table
[R_CKCORE_PCREL_IMM11BY2
];
4635 read_content_substitute
= CSKY_INSN_BSR16
;
4639 } /* else if h == NULL... */
4641 else if (bfd_csky_arch (output_bfd
) == CSKY_ARCH_810
4642 && (ELF32_R_TYPE (rel
->r_info
)
4643 == R_CKCORE_PCREL_JSR_IMM26BY2
))
4645 howto
= &csky_elf_howto_table
[R_CKCORE_NOJSRI
];
4648 /* Other situation, h->def_dynamic == 1,
4649 undefined_symbol when output file is shared object, etc. */
4650 /* Else fall through. */
4652 case R_CKCORE_ADDR_HI16
:
4653 case R_CKCORE_ADDR_LO16
:
4654 if (bfd_link_pic (info
)
4655 || (!bfd_link_pic (info
)
4659 && ((h
->def_dynamic
&& !h
->def_regular
)
4660 || (htab
->elf
.dynamic_sections_created
4661 && (h
->root
.type
== bfd_link_hash_undefweak
4662 || h
->root
.type
== bfd_link_hash_undefined
4663 || h
->root
.type
== bfd_link_hash_indirect
)))))
4665 Elf_Internal_Rela outrel
;
4666 bfd_boolean skip
, relocate
;
4669 /* When generating a shared object, these relocations
4670 are copied into the output file to be resolved at
4676 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4678 if (outrel
.r_offset
== (bfd_vma
) -1)
4680 else if (outrel
.r_offset
== (bfd_vma
) -2)
4685 outrel
.r_offset
+= (input_section
->output_section
->vma
4686 + input_section
->output_offset
);
4688 memset (&outrel
, 0, sizeof (outrel
));
4691 && (!bfd_link_pic (info
)
4692 || (!SYMBOLIC_BIND (info
, h
)
4693 && h
->root
.type
== bfd_link_hash_defweak
)
4694 || !h
->def_regular
))
4696 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4697 outrel
.r_addend
= rel
->r_addend
;
4701 /* This symbol is local, or marked to become local. */
4703 outrel
.r_info
= ELF32_R_INFO (0, r_type
);
4704 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4706 loc
= htab
->elf
.srelgot
->contents
;
4707 loc
+= (htab
->elf
.srelgot
->reloc_count
++
4708 * sizeof (Elf32_External_Rela
));
4711 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4713 /* If this reloc is against an external symbol, we do not
4714 want to diddle with the addend. Otherwise, we need to
4715 include the symbol value so that it becomes an addend
4716 for the dynamic reloc. */
4719 } /* if bfd_link_pic (info) ... */
4722 case R_CKCORE_ADDR32
:
4723 /* r_symndx will be zero only for relocs against symbols
4724 from removed linkonce sections, or sections discarded
4726 This relocation don't nedd to handle, the value will
4727 be set to SEC_DISCARDED(0xffffffff). */
4729 && strcmp (sec
->name
, ".csky_stack_size") == 0)
4731 do_final_relocate
= FALSE
;
4734 if (r_symndx
>= symtab_hdr
->sh_info
4736 && bfd_link_executable (info
))
4739 if (r_symndx
== 0 || (input_section
->flags
& SEC_ALLOC
) == 0)
4742 if (bfd_link_pic (info
)
4745 && ((h
->def_dynamic
&& !h
->def_regular
)
4746 || (htab
->elf
.dynamic_sections_created
4747 && (h
->root
.type
== bfd_link_hash_undefweak
4748 || h
->root
.type
== bfd_link_hash_undefined
4749 || h
->root
.type
== bfd_link_hash_indirect
)))))
4751 Elf_Internal_Rela outrel
;
4752 bfd_boolean skip
, relocate
;
4755 /* When generating a shared object, these relocations
4756 are copied into the output file to be resolved at
4762 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
4765 if (outrel
.r_offset
== (bfd_vma
) -1)
4767 else if (outrel
.r_offset
== (bfd_vma
) -2)
4773 outrel
.r_offset
+= (input_section
->output_section
->vma
4774 + input_section
->output_offset
);
4777 memset (&outrel
, 0, sizeof (outrel
));
4780 && (!bfd_link_pic (info
)
4781 || (!SYMBOLIC_BIND (info
, h
)
4782 && h
->root
.type
== bfd_link_hash_defweak
)
4783 || !h
->def_regular
))
4785 outrel
.r_info
= ELF32_R_INFO (h
->dynindx
, r_type
);
4786 outrel
.r_addend
= rel
->r_addend
;
4790 /* This symbol is local, or marked to become local. */
4791 outrel
.r_info
= ELF32_R_INFO (0, R_CKCORE_RELATIVE
);
4792 outrel
.r_addend
= relocation
+ rel
->r_addend
;
4795 loc
= htab
->elf
.srelgot
->contents
;
4796 loc
+= (htab
->elf
.srelgot
->reloc_count
++
4797 * sizeof (Elf32_External_Rela
));
4800 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4802 /* If this reloc is against an external symbol, we do
4803 want to diddle with the addend. Otherwise, we need to
4804 include the symbol value so that it becomes an addend
4805 for the dynamic reloc. */
4811 case R_CKCORE_TLS_LDO32
:
4812 relocation
= relocation
- dtpoff_base (info
);
4815 case R_CKCORE_TLS_LDM32
:
4816 BFD_ASSERT (htab
->elf
.sgot
!= NULL
);
4817 off
= htab
->tls_ldm_got
.offset
;
4822 /* If we don't know the module number,
4823 create a relocation for it. */
4824 if (!bfd_link_executable (info
))
4826 Elf_Internal_Rela outrel
;
4829 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
);
4830 outrel
.r_addend
= 0;
4832 = (htab
->elf
.sgot
->output_section
->vma
4833 + htab
->elf
.sgot
->output_offset
+ off
);
4834 outrel
.r_info
= ELF32_R_INFO (0, R_CKCORE_TLS_DTPMOD32
);
4835 bfd_put_32 (output_bfd
, outrel
.r_addend
,
4836 htab
->elf
.sgot
->contents
+ off
);
4838 loc
= htab
->elf
.srelgot
->contents
;
4839 loc
+= (htab
->elf
.srelgot
->reloc_count
++
4840 * sizeof (Elf32_External_Rela
));
4842 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
4845 bfd_put_32 (output_bfd
, 1,
4846 htab
->elf
.sgot
->contents
+ off
);
4847 htab
->tls_ldm_got
.offset
|= 1;
4850 = (htab
->elf
.sgot
->output_section
->vma
4851 + htab
->elf
.sgot
->output_offset
+ off
4852 - (input_section
->output_section
->vma
4853 + input_section
->output_offset
+ rel
->r_offset
));
4855 case R_CKCORE_TLS_LE32
:
4856 if (bfd_link_dll (info
))
4859 /* xgettext:c-format */
4860 (_("%pB(%pA+%#" PRIx64
"): %s relocation not permitted "
4861 "in shared object"),
4862 input_bfd
, input_section
, (uint64_t)rel
->r_offset
,
4867 relocation
= tpoff (info
, relocation
);
4869 case R_CKCORE_TLS_GD32
:
4870 case R_CKCORE_TLS_IE32
:
4875 BFD_ASSERT (htab
->elf
.sgot
!= NULL
);
4881 dyn
= htab
->elf
.dynamic_sections_created
;
4882 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
4883 bfd_link_pic (info
), h
)
4884 && (!bfd_link_pic (info
)
4885 || !SYMBOL_REFERENCES_LOCAL (info
, h
)))
4887 unresolved_reloc
= FALSE
;
4890 off
= h
->got
.offset
;
4891 tls_type
= ((struct csky_elf_link_hash_entry
*)h
)->tls_type
;
4895 BFD_ASSERT (local_got_offsets
!= NULL
);
4896 off
= local_got_offsets
[r_symndx
];
4897 tls_type
= csky_elf_local_got_tls_type (input_bfd
)[r_symndx
];
4900 BFD_ASSERT (tls_type
!= GOT_UNKNOWN
);
4906 bfd_boolean need_relocs
= FALSE
;
4907 Elf_Internal_Rela outrel
;
4908 bfd_byte
*loc
= NULL
;
4910 /* The GOT entries have not been initialized yet. Do it
4911 now, and emit any relocations. If both an IE GOT and a
4912 GD GOT are necessary, we emit the GD first. */
4913 if ((!bfd_link_executable (info
) || indx
!= 0)
4915 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
4916 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
4917 || h
->root
.type
!= bfd_link_hash_undefined
))
4920 BFD_ASSERT (htab
->elf
.srelgot
!= NULL
);
4922 loc
= htab
->elf
.srelgot
->contents
;
4923 loc
+= (htab
->elf
.srelgot
->reloc_count
4924 * sizeof (Elf32_External_Rela
));
4926 if (tls_type
& GOT_TLS_GD
)
4930 outrel
.r_addend
= 0;
4932 = (htab
->elf
.sgot
->output_section
->vma
4933 + htab
->elf
.sgot
->output_offset
4936 = ELF32_R_INFO (indx
, R_CKCORE_TLS_DTPMOD32
);
4937 bfd_put_32 (output_bfd
, outrel
.r_addend
,
4938 htab
->elf
.sgot
->contents
+ cur_off
);
4940 bfd_elf32_swap_reloca_out (output_bfd
,
4942 loc
+= sizeof (Elf32_External_Rela
);
4943 htab
->elf
.srelgot
->reloc_count
++;
4945 bfd_put_32 (output_bfd
,
4946 relocation
- dtpoff_base (info
),
4947 (htab
->elf
.sgot
->contents
4951 outrel
.r_addend
= 0;
4953 = ELF32_R_INFO (indx
, R_CKCORE_TLS_DTPOFF32
);
4954 outrel
.r_offset
+= 4;
4955 bfd_put_32 (output_bfd
, outrel
.r_addend
,
4956 (htab
->elf
.sgot
->contents
4960 R_CKCORE_TLS_DTPOFF32
);
4962 bfd_elf32_swap_reloca_out (output_bfd
,
4965 htab
->elf
.srelgot
->reloc_count
++;
4966 loc
+= sizeof (Elf32_External_Rela
);
4972 /* If are not emitting relocations for a
4973 general dynamic reference, then we must be in a
4974 static link or an executable link with the
4975 symbol binding locally. Mark it as belonging
4976 to module 1, the executable. */
4977 bfd_put_32 (output_bfd
, 1,
4978 htab
->elf
.sgot
->contents
+ cur_off
);
4979 bfd_put_32 (output_bfd
,
4980 relocation
- dtpoff_base (info
),
4981 htab
->elf
.sgot
->contents
4986 if (tls_type
& GOT_TLS_IE
)
4991 outrel
.r_addend
= relocation
- dtpoff_base (info
);
4993 outrel
.r_addend
= 0;
4995 = (htab
->elf
.sgot
->output_section
->vma
4996 + htab
->elf
.sgot
->output_offset
+ cur_off
);
4998 = ELF32_R_INFO (indx
, R_CKCORE_TLS_TPOFF32
);
5000 bfd_put_32 (output_bfd
, outrel
.r_addend
,
5001 htab
->elf
.sgot
->contents
+ cur_off
);
5003 bfd_elf32_swap_reloca_out (output_bfd
,
5005 htab
->elf
.srelgot
->reloc_count
++;
5006 loc
+= sizeof (Elf32_External_Rela
);
5009 bfd_put_32 (output_bfd
, tpoff (info
, relocation
),
5010 htab
->elf
.sgot
->contents
+ cur_off
);
5015 local_got_offsets
[r_symndx
] |= 1;
5017 if ((tls_type
& GOT_TLS_GD
) && howto
->type
!= R_CKCORE_TLS_GD32
)
5020 = (htab
->elf
.sgot
->output_section
->vma
5021 + htab
->elf
.sgot
->output_offset
+ off
5022 - (input_section
->output_section
->vma
5023 + input_section
->output_offset
5028 /* No substitution when final linking. */
5029 read_content_substitute
= 0;
5031 } /* End switch (howto->type). */
5033 /* Make sure 32-bit data in the text section will not be affected by
5034 our special endianness.
5035 However, this currently affects noting, since the ADDR32 howto type
5036 does no change with the data read. But we may need this mechanism in
5039 if (howto
->size
== 2
5040 && (howto
->type
== R_CKCORE_ADDR32
5041 || howto
->type
== R_CKCORE_PCREL32
5042 || howto
->type
== R_CKCORE_GOT32
5043 || howto
->type
== R_CKCORE_GOTOFF
5044 || howto
->type
== R_CKCORE_GOTPC
5045 || howto
->type
== R_CKCORE_PLT32
5046 || howto
->type
== R_CKCORE_TLS_LE32
5047 || howto
->type
== R_CKCORE_TLS_IE32
5048 || howto
->type
== R_CKCORE_TLS_LDM32
5049 || howto
->type
== R_CKCORE_TLS_GD32
5050 || howto
->type
== R_CKCORE_TLS_LDO32
5051 || howto
->type
== R_CKCORE_RELATIVE
))
5052 need_reverse_bits
= 0;
5054 need_reverse_bits
= 1;
5055 /* Do the final link. */
5056 if (howto
->type
!= R_CKCORE_PCREL_JSR_IMM11BY2
5057 && howto
->type
!= R_CKCORE_PCREL_JSR_IMM26BY2
5058 && howto
->type
!= R_CKCORE_CALLGRAPH
5059 && do_final_relocate
)
5060 r
= csky_final_link_relocate (howto
, input_bfd
, input_section
,
5061 contents
, rel
->r_offset
,
5062 relocation
, addend
);
5064 if (r
!= bfd_reloc_ok
)
5071 case bfd_reloc_overflow
:
5076 name
= bfd_elf_string_from_elf_section (input_bfd
,
5077 symtab_hdr
->sh_link
,
5082 name
= bfd_section_name (sec
);
5084 (*info
->callbacks
->reloc_overflow
)
5086 (h
? &h
->root
: NULL
),
5087 name
, howto
->name
, (bfd_vma
) 0,
5088 input_bfd
, input_section
, rel
->r_offset
);
5092 } /* End for (;rel < relend; rel++). */
5097 csky_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
5102 switch (note
->descsz
)
5106 /* Sizeof (struct elf_prstatus) on C-SKY V1 arch. */
5108 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
5109 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
5113 /* Sizeof (struct elf_prstatus) on C-SKY V1 arch. */
5115 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
5116 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
5121 /* Make a ".reg/999" section. */
5122 return _bfd_elfcore_make_pseudosection (abfd
, ".reg",
5123 size
, note
->descpos
+ offset
);
5127 csky_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
5129 switch (note
->descsz
)
5134 /* Sizeof (struct elf_prpsinfo) on linux csky. */
5136 elf_tdata (abfd
)->core
->program
5137 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
5138 elf_tdata (abfd
)->core
->command
5139 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
5142 /* Note that for some reason, a spurious space is tacked
5143 onto the end of the args in some (at least one anyway)
5144 implementations, so strip it off if it exists. */
5146 char *command
= elf_tdata (abfd
)->core
->command
;
5147 int n
= strlen (command
);
5149 if (0 < n
&& command
[n
- 1] == ' ')
5150 command
[n
- 1] = '\0';
5156 /* End of external entry points for sizing and building linker stubs. */
5158 /* CPU-related basic API. */
5159 #define TARGET_BIG_SYM csky_elf32_be_vec
5160 #define TARGET_BIG_NAME "elf32-csky-big"
5161 #define TARGET_LITTLE_SYM csky_elf32_le_vec
5162 #define TARGET_LITTLE_NAME "elf32-csky-little"
5163 #define ELF_ARCH bfd_arch_csky
5164 #define ELF_MACHINE_CODE EM_CSKY
5165 #define ELF_MACHINE_ALT1 EM_CSKY_OLD
5166 #define ELF_MAXPAGESIZE 0x1000
5167 #define elf_info_to_howto csky_elf_info_to_howto
5168 #define elf_info_to_howto_rel NULL
5169 #define elf_backend_special_sections csky_elf_special_sections
5170 #define bfd_elf32_bfd_link_hash_table_create csky_elf_link_hash_table_create
5172 /* Target related API. */
5173 #define bfd_elf32_mkobject csky_elf_mkobject
5174 #define bfd_elf32_bfd_merge_private_bfd_data csky_elf_merge_private_bfd_data
5175 #define bfd_elf32_bfd_set_private_flags csky_elf_set_private_flags
5176 #define elf_backend_copy_indirect_symbol csky_elf_copy_indirect_symbol
5178 /* GC section related API. */
5179 #define elf_backend_can_gc_sections 1
5180 #define elf_backend_gc_mark_hook csky_elf_gc_mark_hook
5181 #define elf_backend_gc_mark_extra_sections elf32_csky_gc_mark_extra_sections
5183 /* Relocation related API. */
5184 #define elf_backend_reloc_type_class csky_elf_reloc_type_class
5185 #define bfd_elf32_bfd_reloc_type_lookup csky_elf_reloc_type_lookup
5186 #define bfd_elf32_bfd_reloc_name_lookup csky_elf_reloc_name_lookup
5187 #define elf_backend_ignore_discarded_relocs csky_elf_ignore_discarded_relocs
5188 #define elf_backend_relocate_section csky_elf_relocate_section
5189 #define elf_backend_check_relocs csky_elf_check_relocs
5191 /* Dynamic relocate related API. */
5192 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections
5193 #define elf_backend_adjust_dynamic_symbol csky_elf_adjust_dynamic_symbol
5194 #define elf_backend_size_dynamic_sections csky_elf_size_dynamic_sections
5195 #define elf_backend_finish_dynamic_symbol csky_elf_finish_dynamic_symbol
5196 #define elf_backend_finish_dynamic_sections csky_elf_finish_dynamic_sections
5197 #define elf_backend_rela_normal 1
5198 #define elf_backend_can_refcount 1
5199 #define elf_backend_plt_readonly 1
5200 #define elf_backend_want_got_sym 1
5201 #define elf_backend_want_dynrelro 1
5202 #define elf_backend_got_header_size 12
5203 #define elf_backend_want_got_plt 1
5205 /* C-SKY coredump support. */
5206 #define elf_backend_grok_prstatus csky_elf_grok_prstatus
5207 #define elf_backend_grok_psinfo csky_elf_grok_psinfo
5209 #include "elf32-target.h"