1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2017 Free Software Foundation, Inc.
4 Contributed by Andrew Waterman (andrew@sifive.com).
5 Based on TILE-Gx and MIPS targets.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not,
21 see <http://www.gnu.org/licenses/>. */
23 /* This file handles RISC-V ELF targets. */
31 #include "elfxx-riscv.h"
32 #include "elf/riscv.h"
33 #include "opcode/riscv.h"
35 /* Internal relocations used exclusively by the relaxation pass. */
36 #define R_RISCV_DELETE (R_RISCV_max + 1)
40 #define MINUS_ONE ((bfd_vma)0 - 1)
42 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
44 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
46 /* The name of the dynamic interpreter. This is put in the .interp
49 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
50 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
52 #define ELF_ARCH bfd_arch_riscv
53 #define ELF_TARGET_ID RISCV_ELF_DATA
54 #define ELF_MACHINE_CODE EM_RISCV
55 #define ELF_MAXPAGESIZE 0x1000
56 #define ELF_COMMONPAGESIZE 0x1000
58 /* The RISC-V linker needs to keep track of the number of relocs that it
59 decides to copy as dynamic relocs in check_relocs for each symbol.
60 This is so that it can later discard them if they are found to be
61 unnecessary. We store the information in a field extending the
62 regular ELF linker hash table. */
64 struct riscv_elf_dyn_relocs
66 struct riscv_elf_dyn_relocs
*next
;
68 /* The input section of the reloc. */
71 /* Total number of relocs copied for the input section. */
74 /* Number of pc-relative relocs copied for the input section. */
75 bfd_size_type pc_count
;
78 /* RISC-V ELF linker hash entry. */
80 struct riscv_elf_link_hash_entry
82 struct elf_link_hash_entry elf
;
84 /* Track dynamic relocs copied for this symbol. */
85 struct riscv_elf_dyn_relocs
*dyn_relocs
;
95 #define riscv_elf_hash_entry(ent) \
96 ((struct riscv_elf_link_hash_entry *)(ent))
98 struct _bfd_riscv_elf_obj_tdata
100 struct elf_obj_tdata root
;
102 /* tls_type for each local got entry. */
103 char *local_got_tls_type
;
106 #define _bfd_riscv_elf_tdata(abfd) \
107 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
109 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
110 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
112 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
113 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
114 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
116 #define is_riscv_elf(bfd) \
117 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
118 && elf_tdata (bfd) != NULL \
119 && elf_object_id (bfd) == RISCV_ELF_DATA)
121 #include "elf/common.h"
122 #include "elf/internal.h"
124 struct riscv_elf_link_hash_table
126 struct elf_link_hash_table elf
;
128 /* Short-cuts to get to dynamic linker sections. */
131 /* Small local sym to section mapping cache. */
132 struct sym_cache sym_cache
;
134 /* The max alignment of output sections. */
135 bfd_vma max_alignment
;
139 /* Get the RISC-V ELF linker hash table from a link_info structure. */
140 #define riscv_elf_hash_table(p) \
141 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
142 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
145 riscv_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
147 Elf_Internal_Rela
*dst
)
149 cache_ptr
->howto
= riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst
->r_info
));
153 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
155 const struct elf_backend_data
*bed
;
158 bed
= get_elf_backend_data (abfd
);
159 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
160 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
165 #define PLT_HEADER_INSNS 8
166 #define PLT_ENTRY_INSNS 4
167 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
168 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
170 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
172 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
174 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
177 riscv_elf_got_plt_val (bfd_vma plt_index
, struct bfd_link_info
*info
)
179 return sec_addr (riscv_elf_hash_table (info
)->elf
.sgotplt
)
180 + GOTPLT_HEADER_SIZE
+ (plt_index
* GOT_ENTRY_SIZE
);
184 # define MATCH_LREG MATCH_LW
186 # define MATCH_LREG MATCH_LD
189 /* Generate a PLT header. */
192 riscv_make_plt_header (bfd_vma gotplt_addr
, bfd_vma addr
, uint32_t *entry
)
194 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
195 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
197 /* auipc t2, %hi(.got.plt)
198 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
199 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
200 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
201 addi t0, t2, %lo(.got.plt) # &.got.plt
202 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
203 l[w|d] t0, PTRSIZE(t0) # link map
206 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
207 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
208 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
209 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, -(PLT_HEADER_SIZE
+ 12));
210 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
211 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
212 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
213 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
216 /* Generate a PLT entry. */
219 riscv_make_plt_entry (bfd_vma got
, bfd_vma addr
, uint32_t *entry
)
221 /* auipc t3, %hi(.got.plt entry)
222 l[w|d] t3, %lo(.got.plt entry)(t3)
226 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
227 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
228 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
229 entry
[3] = RISCV_NOP
;
232 /* Create an entry in an RISC-V ELF linker hash table. */
234 static struct bfd_hash_entry
*
235 link_hash_newfunc (struct bfd_hash_entry
*entry
,
236 struct bfd_hash_table
*table
, const char *string
)
238 /* Allocate the structure if it has not already been allocated by a
243 bfd_hash_allocate (table
,
244 sizeof (struct riscv_elf_link_hash_entry
));
249 /* Call the allocation method of the superclass. */
250 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
253 struct riscv_elf_link_hash_entry
*eh
;
255 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
256 eh
->dyn_relocs
= NULL
;
257 eh
->tls_type
= GOT_UNKNOWN
;
263 /* Create a RISC-V ELF linker hash table. */
265 static struct bfd_link_hash_table
*
266 riscv_elf_link_hash_table_create (bfd
*abfd
)
268 struct riscv_elf_link_hash_table
*ret
;
269 bfd_size_type amt
= sizeof (struct riscv_elf_link_hash_table
);
271 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
275 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
276 sizeof (struct riscv_elf_link_hash_entry
),
283 ret
->max_alignment
= (bfd_vma
) -1;
284 return &ret
->elf
.root
;
287 /* Create the .got section. */
290 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
294 struct elf_link_hash_entry
*h
;
295 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
296 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
298 /* This function may be called more than once. */
299 if (htab
->sgot
!= NULL
)
302 flags
= bed
->dynamic_sec_flags
;
304 s
= bfd_make_section_anyway_with_flags (abfd
,
305 (bed
->rela_plts_and_copies_p
306 ? ".rela.got" : ".rel.got"),
307 (bed
->dynamic_sec_flags
310 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
314 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
316 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
320 /* The first bit of the global offset table is the header. */
321 s
->size
+= bed
->got_header_size
;
323 if (bed
->want_got_plt
)
325 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
327 || !bfd_set_section_alignment (abfd
, s
,
328 bed
->s
->log_file_align
))
332 /* Reserve room for the header. */
333 s
->size
+= GOTPLT_HEADER_SIZE
;
336 if (bed
->want_got_sym
)
338 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
339 section. We don't do this in the linker script because we don't want
340 to define the symbol if we are not creating a global offset
342 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
343 "_GLOBAL_OFFSET_TABLE_");
344 elf_hash_table (info
)->hgot
= h
;
352 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
353 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
357 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
358 struct bfd_link_info
*info
)
360 struct riscv_elf_link_hash_table
*htab
;
362 htab
= riscv_elf_hash_table (info
);
363 BFD_ASSERT (htab
!= NULL
);
365 if (!riscv_elf_create_got_section (dynobj
, info
))
368 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
371 if (!bfd_link_pic (info
))
374 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
375 SEC_ALLOC
| SEC_THREAD_LOCAL
);
378 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
379 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
385 /* Copy the extra info we tack onto an elf_link_hash_entry. */
388 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
389 struct elf_link_hash_entry
*dir
,
390 struct elf_link_hash_entry
*ind
)
392 struct riscv_elf_link_hash_entry
*edir
, *eind
;
394 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
395 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
397 if (eind
->dyn_relocs
!= NULL
)
399 if (edir
->dyn_relocs
!= NULL
)
401 struct riscv_elf_dyn_relocs
**pp
;
402 struct riscv_elf_dyn_relocs
*p
;
404 /* Add reloc counts against the indirect sym to the direct sym
405 list. Merge any entries against the same section. */
406 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
408 struct riscv_elf_dyn_relocs
*q
;
410 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
411 if (q
->sec
== p
->sec
)
413 q
->pc_count
+= p
->pc_count
;
414 q
->count
+= p
->count
;
421 *pp
= edir
->dyn_relocs
;
424 edir
->dyn_relocs
= eind
->dyn_relocs
;
425 eind
->dyn_relocs
= NULL
;
428 if (ind
->root
.type
== bfd_link_hash_indirect
429 && dir
->got
.refcount
<= 0)
431 edir
->tls_type
= eind
->tls_type
;
432 eind
->tls_type
= GOT_UNKNOWN
;
434 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
438 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
439 unsigned long symndx
, char tls_type
)
441 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
443 *new_tls_type
|= tls_type
;
444 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
446 (*_bfd_error_handler
)
447 (_("%B: `%s' accessed both as normal and thread local symbol"),
448 abfd
, h
? h
->root
.root
.string
: "<local>");
455 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
456 struct elf_link_hash_entry
*h
, long symndx
)
458 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
459 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
461 if (htab
->elf
.sgot
== NULL
)
463 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
469 h
->got
.refcount
+= 1;
473 /* This is a global offset table entry for a local symbol. */
474 if (elf_local_got_refcounts (abfd
) == NULL
)
476 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
477 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
479 _bfd_riscv_elf_local_got_tls_type (abfd
)
480 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
482 elf_local_got_refcounts (abfd
) [symndx
] += 1;
488 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
490 (*_bfd_error_handler
)
491 (_("%B: relocation %s against `%s' can not be used when making a shared "
492 "object; recompile with -fPIC"),
493 abfd
, riscv_elf_rtype_to_howto (r_type
)->name
,
494 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
495 bfd_set_error (bfd_error_bad_value
);
498 /* Look through the relocs for a section during the first phase, and
499 allocate space in the global offset table or procedure linkage
503 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
504 asection
*sec
, const Elf_Internal_Rela
*relocs
)
506 struct riscv_elf_link_hash_table
*htab
;
507 Elf_Internal_Shdr
*symtab_hdr
;
508 struct elf_link_hash_entry
**sym_hashes
;
509 const Elf_Internal_Rela
*rel
;
510 asection
*sreloc
= NULL
;
512 if (bfd_link_relocatable (info
))
515 htab
= riscv_elf_hash_table (info
);
516 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
517 sym_hashes
= elf_sym_hashes (abfd
);
519 if (htab
->elf
.dynobj
== NULL
)
520 htab
->elf
.dynobj
= abfd
;
522 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
525 unsigned int r_symndx
;
526 struct elf_link_hash_entry
*h
;
528 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
529 r_type
= ELFNN_R_TYPE (rel
->r_info
);
531 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
533 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
538 if (r_symndx
< symtab_hdr
->sh_info
)
542 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
543 while (h
->root
.type
== bfd_link_hash_indirect
544 || h
->root
.type
== bfd_link_hash_warning
)
545 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
550 case R_RISCV_TLS_GD_HI20
:
551 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
552 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
556 case R_RISCV_TLS_GOT_HI20
:
557 if (bfd_link_pic (info
))
558 info
->flags
|= DF_STATIC_TLS
;
559 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
560 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
564 case R_RISCV_GOT_HI20
:
565 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
566 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
570 case R_RISCV_CALL_PLT
:
571 /* This symbol requires a procedure linkage table entry. We
572 actually build the entry in adjust_dynamic_symbol,
573 because this might be a case of linking PIC code without
574 linking in any dynamic objects, in which case we don't
575 need to generate a procedure linkage table after all. */
580 h
->plt
.refcount
+= 1;
587 case R_RISCV_RVC_BRANCH
:
588 case R_RISCV_RVC_JUMP
:
589 case R_RISCV_PCREL_HI20
:
590 /* In shared libraries, these relocs are known to bind locally. */
591 if (bfd_link_pic (info
))
595 case R_RISCV_TPREL_HI20
:
596 if (!bfd_link_executable (info
))
597 return bad_static_reloc (abfd
, r_type
, h
);
599 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
603 if (bfd_link_pic (info
))
604 return bad_static_reloc (abfd
, r_type
, h
);
608 case R_RISCV_JUMP_SLOT
:
609 case R_RISCV_RELATIVE
:
615 /* This reloc might not bind locally. */
619 if (h
!= NULL
&& !bfd_link_pic (info
))
621 /* We may need a .plt entry if the function this reloc
622 refers to is in a shared lib. */
623 h
->plt
.refcount
+= 1;
626 /* If we are creating a shared library, and this is a reloc
627 against a global symbol, or a non PC relative reloc
628 against a local symbol, then we need to copy the reloc
629 into the shared library. However, if we are linking with
630 -Bsymbolic, we do not need to copy a reloc against a
631 global symbol which is defined in an object we are
632 including in the link (i.e., DEF_REGULAR is set). At
633 this point we have not seen all the input files, so it is
634 possible that DEF_REGULAR is not set now but will be set
635 later (it is never cleared). In case of a weak definition,
636 DEF_REGULAR may be cleared later by a strong definition in
637 a shared library. We account for that possibility below by
638 storing information in the relocs_copied field of the hash
639 table entry. A similar situation occurs when creating
640 shared libraries and symbol visibility changes render the
643 If on the other hand, we are creating an executable, we
644 may need to keep relocations for symbols satisfied by a
645 dynamic library if we manage to avoid copy relocs for the
647 if ((bfd_link_pic (info
)
648 && (sec
->flags
& SEC_ALLOC
) != 0
649 && (! riscv_elf_rtype_to_howto (r_type
)->pc_relative
652 || h
->root
.type
== bfd_link_hash_defweak
653 || !h
->def_regular
))))
654 || (!bfd_link_pic (info
)
655 && (sec
->flags
& SEC_ALLOC
) != 0
657 && (h
->root
.type
== bfd_link_hash_defweak
658 || !h
->def_regular
)))
660 struct riscv_elf_dyn_relocs
*p
;
661 struct riscv_elf_dyn_relocs
**head
;
663 /* When creating a shared object, we must copy these
664 relocs into the output file. We create a reloc
665 section in dynobj and make room for the reloc. */
668 sreloc
= _bfd_elf_make_dynamic_reloc_section
669 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
670 abfd
, /*rela?*/ TRUE
);
676 /* If this is a global symbol, we count the number of
677 relocations we need for this symbol. */
679 head
= &((struct riscv_elf_link_hash_entry
*) h
)->dyn_relocs
;
682 /* Track dynamic relocs needed for local syms too.
683 We really need local syms available to do this
688 Elf_Internal_Sym
*isym
;
690 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
695 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
699 vpp
= &elf_section_data (s
)->local_dynrel
;
700 head
= (struct riscv_elf_dyn_relocs
**) vpp
;
704 if (p
== NULL
|| p
->sec
!= sec
)
706 bfd_size_type amt
= sizeof *p
;
707 p
= ((struct riscv_elf_dyn_relocs
*)
708 bfd_alloc (htab
->elf
.dynobj
, amt
));
719 p
->pc_count
+= riscv_elf_rtype_to_howto (r_type
)->pc_relative
;
724 case R_RISCV_GNU_VTINHERIT
:
725 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
729 case R_RISCV_GNU_VTENTRY
:
730 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
743 riscv_elf_gc_mark_hook (asection
*sec
,
744 struct bfd_link_info
*info
,
745 Elf_Internal_Rela
*rel
,
746 struct elf_link_hash_entry
*h
,
747 Elf_Internal_Sym
*sym
)
750 switch (ELFNN_R_TYPE (rel
->r_info
))
752 case R_RISCV_GNU_VTINHERIT
:
753 case R_RISCV_GNU_VTENTRY
:
757 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
760 /* Adjust a symbol defined by a dynamic object and referenced by a
761 regular object. The current definition is in some section of the
762 dynamic object, but we're not including those sections. We have to
763 change the definition to something the rest of the link can
767 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
768 struct elf_link_hash_entry
*h
)
770 struct riscv_elf_link_hash_table
*htab
;
771 struct riscv_elf_link_hash_entry
* eh
;
772 struct riscv_elf_dyn_relocs
*p
;
776 htab
= riscv_elf_hash_table (info
);
777 BFD_ASSERT (htab
!= NULL
);
779 dynobj
= htab
->elf
.dynobj
;
781 /* Make sure we know what is going on here. */
782 BFD_ASSERT (dynobj
!= NULL
784 || h
->type
== STT_GNU_IFUNC
788 && !h
->def_regular
)));
790 /* If this is a function, put it in the procedure linkage table. We
791 will fill in the contents of the procedure linkage table later
792 (although we could actually do it here). */
793 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
795 if (h
->plt
.refcount
<= 0
796 || SYMBOL_CALLS_LOCAL (info
, h
)
797 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
798 && h
->root
.type
== bfd_link_hash_undefweak
))
800 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
801 input file, but the symbol was never referred to by a dynamic
802 object, or if all references were garbage collected. In such
803 a case, we don't actually need to build a PLT entry. */
804 h
->plt
.offset
= (bfd_vma
) -1;
811 h
->plt
.offset
= (bfd_vma
) -1;
813 /* If this is a weak symbol, and there is a real definition, the
814 processor independent code will have arranged for us to see the
815 real definition first, and we can just use the same value. */
818 struct elf_link_hash_entry
*def
= weakdef (h
);
819 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
820 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
821 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
825 /* This is a reference to a symbol defined by a dynamic object which
826 is not a function. */
828 /* If we are creating a shared library, we must presume that the
829 only references to the symbol are via the global offset table.
830 For such cases we need not do anything here; the relocations will
831 be handled correctly by relocate_section. */
832 if (bfd_link_pic (info
))
835 /* If there are no references to this symbol that do not use the
836 GOT, we don't need to generate a copy reloc. */
840 /* If -z nocopyreloc was given, we won't generate them either. */
841 if (info
->nocopyreloc
)
847 eh
= (struct riscv_elf_link_hash_entry
*) h
;
848 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
850 s
= p
->sec
->output_section
;
851 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
855 /* If we didn't find any dynamic relocs in read-only sections, then
856 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
863 /* We must allocate the symbol in our .dynbss section, which will
864 become part of the .bss section of the executable. There will be
865 an entry for this symbol in the .dynsym section. The dynamic
866 object will contain position independent code, so all references
867 from the dynamic object to this symbol will go through the global
868 offset table. The dynamic linker will use the .dynsym entry to
869 determine the address it must put in the global offset table, so
870 both the dynamic object and the regular object will refer to the
871 same memory location for the variable. */
873 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
874 to copy the initial value out of the dynamic object and into the
875 runtime process image. We need to remember the offset into the
876 .rel.bss section we are going to use. */
877 if (eh
->tls_type
& ~GOT_NORMAL
)
880 srel
= htab
->elf
.srelbss
;
882 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
884 s
= htab
->elf
.sdynrelro
;
885 srel
= htab
->elf
.sreldynrelro
;
889 s
= htab
->elf
.sdynbss
;
890 srel
= htab
->elf
.srelbss
;
892 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
894 srel
->size
+= sizeof (ElfNN_External_Rela
);
898 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
901 /* Allocate space in .plt, .got and associated reloc sections for
905 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
907 struct bfd_link_info
*info
;
908 struct riscv_elf_link_hash_table
*htab
;
909 struct riscv_elf_link_hash_entry
*eh
;
910 struct riscv_elf_dyn_relocs
*p
;
912 if (h
->root
.type
== bfd_link_hash_indirect
)
915 info
= (struct bfd_link_info
*) inf
;
916 htab
= riscv_elf_hash_table (info
);
917 BFD_ASSERT (htab
!= NULL
);
919 if (htab
->elf
.dynamic_sections_created
920 && h
->plt
.refcount
> 0)
922 /* Make sure this symbol is output as a dynamic symbol.
923 Undefined weak syms won't yet be marked as dynamic. */
927 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
931 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
933 asection
*s
= htab
->elf
.splt
;
936 s
->size
= PLT_HEADER_SIZE
;
938 h
->plt
.offset
= s
->size
;
940 /* Make room for this entry. */
941 s
->size
+= PLT_ENTRY_SIZE
;
943 /* We also need to make an entry in the .got.plt section. */
944 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
946 /* We also need to make an entry in the .rela.plt section. */
947 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
949 /* If this symbol is not defined in a regular file, and we are
950 not generating a shared library, then set the symbol to this
951 location in the .plt. This is required to make function
952 pointers compare as equal between the normal executable and
953 the shared library. */
954 if (! bfd_link_pic (info
)
957 h
->root
.u
.def
.section
= s
;
958 h
->root
.u
.def
.value
= h
->plt
.offset
;
963 h
->plt
.offset
= (bfd_vma
) -1;
969 h
->plt
.offset
= (bfd_vma
) -1;
973 if (h
->got
.refcount
> 0)
977 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
979 /* Make sure this symbol is output as a dynamic symbol.
980 Undefined weak syms won't yet be marked as dynamic. */
984 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
989 h
->got
.offset
= s
->size
;
990 dyn
= htab
->elf
.dynamic_sections_created
;
991 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
993 /* TLS_GD needs two dynamic relocs and two GOT slots. */
994 if (tls_type
& GOT_TLS_GD
)
996 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
997 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1000 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1001 if (tls_type
& GOT_TLS_IE
)
1003 s
->size
+= RISCV_ELF_WORD_BYTES
;
1004 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1009 s
->size
+= RISCV_ELF_WORD_BYTES
;
1010 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1011 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1015 h
->got
.offset
= (bfd_vma
) -1;
1017 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1018 if (eh
->dyn_relocs
== NULL
)
1021 /* In the shared -Bsymbolic case, discard space allocated for
1022 dynamic pc-relative relocs against symbols which turn out to be
1023 defined in regular objects. For the normal shared case, discard
1024 space for pc-relative relocs that have become local due to symbol
1025 visibility changes. */
1027 if (bfd_link_pic (info
))
1029 if (SYMBOL_CALLS_LOCAL (info
, h
))
1031 struct riscv_elf_dyn_relocs
**pp
;
1033 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1035 p
->count
-= p
->pc_count
;
1044 /* Also discard relocs on undefined weak syms with non-default
1046 if (eh
->dyn_relocs
!= NULL
1047 && h
->root
.type
== bfd_link_hash_undefweak
)
1049 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1050 eh
->dyn_relocs
= NULL
;
1052 /* Make sure undefined weak symbols are output as a dynamic
1054 else if (h
->dynindx
== -1
1055 && !h
->forced_local
)
1057 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1064 /* For the non-shared case, discard space for relocs against
1065 symbols which turn out to need copy relocs or are not
1071 || (htab
->elf
.dynamic_sections_created
1072 && (h
->root
.type
== bfd_link_hash_undefweak
1073 || h
->root
.type
== bfd_link_hash_undefined
))))
1075 /* Make sure this symbol is output as a dynamic symbol.
1076 Undefined weak syms won't yet be marked as dynamic. */
1077 if (h
->dynindx
== -1
1078 && !h
->forced_local
)
1080 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1084 /* If that succeeded, we know we'll be keeping all the
1086 if (h
->dynindx
!= -1)
1090 eh
->dyn_relocs
= NULL
;
1095 /* Finally, allocate space. */
1096 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1098 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1099 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1105 /* Find any dynamic relocs that apply to read-only sections. */
1108 readonly_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1110 struct riscv_elf_link_hash_entry
*eh
;
1111 struct riscv_elf_dyn_relocs
*p
;
1113 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1114 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1116 asection
*s
= p
->sec
->output_section
;
1118 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
1120 ((struct bfd_link_info
*) inf
)->flags
|= DF_TEXTREL
;
1128 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1130 struct riscv_elf_link_hash_table
*htab
;
1135 htab
= riscv_elf_hash_table (info
);
1136 BFD_ASSERT (htab
!= NULL
);
1137 dynobj
= htab
->elf
.dynobj
;
1138 BFD_ASSERT (dynobj
!= NULL
);
1140 if (elf_hash_table (info
)->dynamic_sections_created
)
1142 /* Set the contents of the .interp section to the interpreter. */
1143 if (bfd_link_executable (info
) && !info
->nointerp
)
1145 s
= bfd_get_linker_section (dynobj
, ".interp");
1146 BFD_ASSERT (s
!= NULL
);
1147 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1148 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1152 /* Set up .got offsets for local syms, and space for local dynamic
1154 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1156 bfd_signed_vma
*local_got
;
1157 bfd_signed_vma
*end_local_got
;
1158 char *local_tls_type
;
1159 bfd_size_type locsymcount
;
1160 Elf_Internal_Shdr
*symtab_hdr
;
1163 if (! is_riscv_elf (ibfd
))
1166 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1168 struct riscv_elf_dyn_relocs
*p
;
1170 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1172 if (!bfd_is_abs_section (p
->sec
)
1173 && bfd_is_abs_section (p
->sec
->output_section
))
1175 /* Input section has been discarded, either because
1176 it is a copy of a linkonce section or due to
1177 linker script /DISCARD/, so we'll be discarding
1180 else if (p
->count
!= 0)
1182 srel
= elf_section_data (p
->sec
)->sreloc
;
1183 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1184 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1185 info
->flags
|= DF_TEXTREL
;
1190 local_got
= elf_local_got_refcounts (ibfd
);
1194 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1195 locsymcount
= symtab_hdr
->sh_info
;
1196 end_local_got
= local_got
+ locsymcount
;
1197 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1199 srel
= htab
->elf
.srelgot
;
1200 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1204 *local_got
= s
->size
;
1205 s
->size
+= RISCV_ELF_WORD_BYTES
;
1206 if (*local_tls_type
& GOT_TLS_GD
)
1207 s
->size
+= RISCV_ELF_WORD_BYTES
;
1208 if (bfd_link_pic (info
)
1209 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1210 srel
->size
+= sizeof (ElfNN_External_Rela
);
1213 *local_got
= (bfd_vma
) -1;
1217 /* Allocate global sym .plt and .got entries, and space for global
1218 sym dynamic relocs. */
1219 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1221 if (htab
->elf
.sgotplt
)
1223 struct elf_link_hash_entry
*got
;
1224 got
= elf_link_hash_lookup (elf_hash_table (info
),
1225 "_GLOBAL_OFFSET_TABLE_",
1226 FALSE
, FALSE
, FALSE
);
1228 /* Don't allocate .got.plt section if there are no GOT nor PLT
1229 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1231 || !got
->ref_regular_nonweak
)
1232 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1233 && (htab
->elf
.splt
== NULL
1234 || htab
->elf
.splt
->size
== 0)
1235 && (htab
->elf
.sgot
== NULL
1236 || (htab
->elf
.sgot
->size
1237 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1238 htab
->elf
.sgotplt
->size
= 0;
1241 /* The check_relocs and adjust_dynamic_symbol entry points have
1242 determined the sizes of the various dynamic sections. Allocate
1244 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1246 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1249 if (s
== htab
->elf
.splt
1250 || s
== htab
->elf
.sgot
1251 || s
== htab
->elf
.sgotplt
1252 || s
== htab
->elf
.sdynbss
1253 || s
== htab
->elf
.sdynrelro
)
1255 /* Strip this section if we don't need it; see the
1258 else if (strncmp (s
->name
, ".rela", 5) == 0)
1262 /* We use the reloc_count field as a counter if we need
1263 to copy relocs into the output file. */
1269 /* It's not one of our sections. */
1275 /* If we don't need this section, strip it from the
1276 output file. This is mostly to handle .rela.bss and
1277 .rela.plt. We must create both sections in
1278 create_dynamic_sections, because they must be created
1279 before the linker maps input sections to output
1280 sections. The linker does that before
1281 adjust_dynamic_symbol is called, and it is that
1282 function which decides whether anything needs to go
1283 into these sections. */
1284 s
->flags
|= SEC_EXCLUDE
;
1288 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1291 /* Allocate memory for the section contents. Zero the memory
1292 for the benefit of .rela.plt, which has 4 unused entries
1293 at the beginning, and we don't want garbage. */
1294 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1295 if (s
->contents
== NULL
)
1299 if (elf_hash_table (info
)->dynamic_sections_created
)
1301 /* Add some entries to the .dynamic section. We fill in the
1302 values later, in riscv_elf_finish_dynamic_sections, but we
1303 must add the entries now so that we get the correct size for
1304 the .dynamic section. The DT_DEBUG entry is filled in by the
1305 dynamic linker and used by the debugger. */
1306 #define add_dynamic_entry(TAG, VAL) \
1307 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1309 if (bfd_link_executable (info
))
1311 if (!add_dynamic_entry (DT_DEBUG
, 0))
1315 if (htab
->elf
.srelplt
->size
!= 0)
1317 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1318 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1319 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1320 || !add_dynamic_entry (DT_JMPREL
, 0))
1324 if (!add_dynamic_entry (DT_RELA
, 0)
1325 || !add_dynamic_entry (DT_RELASZ
, 0)
1326 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
1329 /* If any dynamic relocs apply to a read-only section,
1330 then we need a DT_TEXTREL entry. */
1331 if ((info
->flags
& DF_TEXTREL
) == 0)
1332 elf_link_hash_traverse (&htab
->elf
, readonly_dynrelocs
, info
);
1334 if (info
->flags
& DF_TEXTREL
)
1336 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1340 #undef add_dynamic_entry
1346 #define DTP_OFFSET 0x800
1348 /* Return the relocation value for a TLS dtp-relative reloc. */
1351 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1353 /* If tls_sec is NULL, we should have signalled an error already. */
1354 if (elf_hash_table (info
)->tls_sec
== NULL
)
1356 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1359 /* Return the relocation value for a static TLS tp-relative relocation. */
1362 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1364 /* If tls_sec is NULL, we should have signalled an error already. */
1365 if (elf_hash_table (info
)->tls_sec
== NULL
)
1367 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1370 /* Return the global pointer's value, or 0 if it is not in use. */
1373 riscv_global_pointer_value (struct bfd_link_info
*info
)
1375 struct bfd_link_hash_entry
*h
;
1377 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1378 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1381 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1384 /* Emplace a static relocation. */
1386 static bfd_reloc_status_type
1387 perform_relocation (const reloc_howto_type
*howto
,
1388 const Elf_Internal_Rela
*rel
,
1390 asection
*input_section
,
1394 if (howto
->pc_relative
)
1395 value
-= sec_addr (input_section
) + rel
->r_offset
;
1396 value
+= rel
->r_addend
;
1398 switch (ELFNN_R_TYPE (rel
->r_info
))
1401 case R_RISCV_TPREL_HI20
:
1402 case R_RISCV_PCREL_HI20
:
1403 case R_RISCV_GOT_HI20
:
1404 case R_RISCV_TLS_GOT_HI20
:
1405 case R_RISCV_TLS_GD_HI20
:
1406 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1407 return bfd_reloc_overflow
;
1408 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1411 case R_RISCV_LO12_I
:
1412 case R_RISCV_GPREL_I
:
1413 case R_RISCV_TPREL_LO12_I
:
1414 case R_RISCV_TPREL_I
:
1415 case R_RISCV_PCREL_LO12_I
:
1416 value
= ENCODE_ITYPE_IMM (value
);
1419 case R_RISCV_LO12_S
:
1420 case R_RISCV_GPREL_S
:
1421 case R_RISCV_TPREL_LO12_S
:
1422 case R_RISCV_TPREL_S
:
1423 case R_RISCV_PCREL_LO12_S
:
1424 value
= ENCODE_STYPE_IMM (value
);
1428 case R_RISCV_CALL_PLT
:
1429 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1430 return bfd_reloc_overflow
;
1431 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1432 | (ENCODE_ITYPE_IMM (value
) << 32);
1436 if (!VALID_UJTYPE_IMM (value
))
1437 return bfd_reloc_overflow
;
1438 value
= ENCODE_UJTYPE_IMM (value
);
1441 case R_RISCV_BRANCH
:
1442 if (!VALID_SBTYPE_IMM (value
))
1443 return bfd_reloc_overflow
;
1444 value
= ENCODE_SBTYPE_IMM (value
);
1447 case R_RISCV_RVC_BRANCH
:
1448 if (!VALID_RVC_B_IMM (value
))
1449 return bfd_reloc_overflow
;
1450 value
= ENCODE_RVC_B_IMM (value
);
1453 case R_RISCV_RVC_JUMP
:
1454 if (!VALID_RVC_J_IMM (value
))
1455 return bfd_reloc_overflow
;
1456 value
= ENCODE_RVC_J_IMM (value
);
1459 case R_RISCV_RVC_LUI
:
1460 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1461 return bfd_reloc_overflow
;
1462 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1480 case R_RISCV_32_PCREL
:
1481 case R_RISCV_TLS_DTPREL32
:
1482 case R_RISCV_TLS_DTPREL64
:
1485 case R_RISCV_DELETE
:
1486 return bfd_reloc_ok
;
1489 return bfd_reloc_notsupported
;
1492 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1493 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1494 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1496 return bfd_reloc_ok
;
1499 /* Remember all PC-relative high-part relocs we've encountered to help us
1500 later resolve the corresponding low-part relocs. */
1506 } riscv_pcrel_hi_reloc
;
1508 typedef struct riscv_pcrel_lo_reloc
1510 asection
* input_section
;
1511 struct bfd_link_info
* info
;
1512 reloc_howto_type
* howto
;
1513 const Elf_Internal_Rela
* reloc
;
1516 bfd_byte
* contents
;
1517 struct riscv_pcrel_lo_reloc
* next
;
1518 } riscv_pcrel_lo_reloc
;
1523 riscv_pcrel_lo_reloc
*lo_relocs
;
1524 } riscv_pcrel_relocs
;
1527 riscv_pcrel_reloc_hash (const void *entry
)
1529 const riscv_pcrel_hi_reloc
*e
= entry
;
1530 return (hashval_t
)(e
->address
>> 2);
1534 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1536 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1537 return e1
->address
== e2
->address
;
1541 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1544 p
->lo_relocs
= NULL
;
1545 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1546 riscv_pcrel_reloc_eq
, free
);
1547 return p
->hi_relocs
!= NULL
;
1551 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1553 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1557 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1562 htab_delete (p
->hi_relocs
);
1566 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1567 struct bfd_link_info
*info
,
1571 const reloc_howto_type
*howto
,
1574 /* We may need to reference low addreses in PC-relative modes even when the
1575 * PC is far away from these addresses. For example, undefweak references
1576 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1577 * addresses that we can link PC-relative programs at, the linker can't
1578 * actually relocate references to those symbols. In order to allow these
1579 * programs to work we simply convert the PC-relative auipc sequences to
1580 * 0-relative lui sequences. */
1581 if (bfd_link_pic (info
))
1584 /* If it's possible to reference the symbol using auipc we do so, as that's
1585 * more in the spirit of the PC-relative relocations we're processing. */
1586 bfd_vma offset
= addr
- pc
;
1587 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1590 /* If it's impossible to reference this with a LUI-based offset then don't
1591 * bother to convert it at all so users still see the PC-relative relocation
1592 * in the truncation message. */
1593 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1596 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1598 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1599 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1600 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1605 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1606 bfd_vma value
, bfd_boolean absolute
)
1608 bfd_vma offset
= absolute
? value
: value
- addr
;
1609 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1610 riscv_pcrel_hi_reloc
**slot
=
1611 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1613 BFD_ASSERT (*slot
== NULL
);
1614 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1622 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1623 asection
*input_section
,
1624 struct bfd_link_info
*info
,
1625 reloc_howto_type
*howto
,
1626 const Elf_Internal_Rela
*reloc
,
1631 riscv_pcrel_lo_reloc
*entry
;
1632 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1635 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1636 name
, contents
, p
->lo_relocs
};
1637 p
->lo_relocs
= entry
;
1642 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1644 riscv_pcrel_lo_reloc
*r
;
1646 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1648 bfd
*input_bfd
= r
->input_section
->owner
;
1650 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1651 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1654 ((*r
->info
->callbacks
->reloc_overflow
)
1655 (r
->info
, NULL
, r
->name
, r
->howto
->name
, (bfd_vma
) 0,
1656 input_bfd
, r
->input_section
, r
->reloc
->r_offset
));
1660 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1661 input_bfd
, r
->contents
);
1667 /* Relocate a RISC-V ELF section.
1669 The RELOCATE_SECTION function is called by the new ELF backend linker
1670 to handle the relocations for a section.
1672 The relocs are always passed as Rela structures.
1674 This function is responsible for adjusting the section contents as
1675 necessary, and (if generating a relocatable output file) adjusting
1676 the reloc addend as necessary.
1678 This function does not have to worry about setting the reloc
1679 address or the reloc symbol index.
1681 LOCAL_SYMS is a pointer to the swapped in local symbols.
1683 LOCAL_SECTIONS is an array giving the section in the input file
1684 corresponding to the st_shndx field of each local symbol.
1686 The global hash table entry for the global symbols can be found
1687 via elf_sym_hashes (input_bfd).
1689 When generating relocatable output, this function must handle
1690 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1691 going to be the section symbol corresponding to the output
1692 section, which means that the addend must be adjusted
1696 riscv_elf_relocate_section (bfd
*output_bfd
,
1697 struct bfd_link_info
*info
,
1699 asection
*input_section
,
1701 Elf_Internal_Rela
*relocs
,
1702 Elf_Internal_Sym
*local_syms
,
1703 asection
**local_sections
)
1705 Elf_Internal_Rela
*rel
;
1706 Elf_Internal_Rela
*relend
;
1707 riscv_pcrel_relocs pcrel_relocs
;
1708 bfd_boolean ret
= FALSE
;
1709 asection
*sreloc
= elf_section_data (input_section
)->sreloc
;
1710 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1711 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1712 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1713 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1714 bfd_boolean absolute
;
1716 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1719 relend
= relocs
+ input_section
->reloc_count
;
1720 for (rel
= relocs
; rel
< relend
; rel
++)
1722 unsigned long r_symndx
;
1723 struct elf_link_hash_entry
*h
;
1724 Elf_Internal_Sym
*sym
;
1727 bfd_reloc_status_type r
= bfd_reloc_ok
;
1729 bfd_vma off
, ie_off
;
1730 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1731 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1732 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1733 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (r_type
);
1734 const char *msg
= NULL
;
1736 if (r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1739 /* This is a final link. */
1740 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1744 unresolved_reloc
= FALSE
;
1745 if (r_symndx
< symtab_hdr
->sh_info
)
1747 sym
= local_syms
+ r_symndx
;
1748 sec
= local_sections
[r_symndx
];
1749 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1753 bfd_boolean warned
, ignored
;
1755 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1756 r_symndx
, symtab_hdr
, sym_hashes
,
1758 unresolved_reloc
, warned
, ignored
);
1761 /* To avoid generating warning messages about truncated
1762 relocations, set the relocation's address to be the same as
1763 the start of this section. */
1764 if (input_section
->output_section
!= NULL
)
1765 relocation
= input_section
->output_section
->vma
;
1771 if (sec
!= NULL
&& discarded_section (sec
))
1772 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1773 rel
, 1, relend
, howto
, 0, contents
);
1775 if (bfd_link_relocatable (info
))
1779 name
= h
->root
.root
.string
;
1782 name
= (bfd_elf_string_from_elf_section
1783 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1784 if (name
== NULL
|| *name
== '\0')
1785 name
= bfd_section_name (input_bfd
, sec
);
1792 case R_RISCV_TPREL_ADD
:
1794 case R_RISCV_JUMP_SLOT
:
1795 case R_RISCV_RELATIVE
:
1796 /* These require nothing of us at all. */
1800 case R_RISCV_BRANCH
:
1801 case R_RISCV_RVC_BRANCH
:
1802 case R_RISCV_RVC_LUI
:
1803 case R_RISCV_LO12_I
:
1804 case R_RISCV_LO12_S
:
1809 case R_RISCV_32_PCREL
:
1810 case R_RISCV_DELETE
:
1811 /* These require no special handling beyond perform_relocation. */
1814 case R_RISCV_GOT_HI20
:
1817 bfd_boolean dyn
, pic
;
1819 off
= h
->got
.offset
;
1820 BFD_ASSERT (off
!= (bfd_vma
) -1);
1821 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1822 pic
= bfd_link_pic (info
);
1824 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
1825 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
1827 /* This is actually a static link, or it is a
1828 -Bsymbolic link and the symbol is defined
1829 locally, or the symbol was forced to be local
1830 because of a version file. We must initialize
1831 this entry in the global offset table. Since the
1832 offset must always be a multiple of the word size,
1833 we use the least significant bit to record whether
1834 we have initialized it already.
1836 When doing a dynamic link, we create a .rela.got
1837 relocation entry to initialize the value. This
1838 is done in the finish_dynamic_symbol routine. */
1843 bfd_put_NN (output_bfd
, relocation
,
1844 htab
->elf
.sgot
->contents
+ off
);
1849 unresolved_reloc
= FALSE
;
1853 BFD_ASSERT (local_got_offsets
!= NULL
1854 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1856 off
= local_got_offsets
[r_symndx
];
1858 /* The offset must always be a multiple of the word size.
1859 So, we can use the least significant bit to record
1860 whether we have already processed this entry. */
1865 if (bfd_link_pic (info
))
1868 Elf_Internal_Rela outrel
;
1870 /* We need to generate a R_RISCV_RELATIVE reloc
1871 for the dynamic linker. */
1872 s
= htab
->elf
.srelgot
;
1873 BFD_ASSERT (s
!= NULL
);
1875 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
1877 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
1878 outrel
.r_addend
= relocation
;
1880 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
1883 bfd_put_NN (output_bfd
, relocation
,
1884 htab
->elf
.sgot
->contents
+ off
);
1885 local_got_offsets
[r_symndx
] |= 1;
1888 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
1889 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1896 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1897 howto
= riscv_elf_rtype_to_howto (r_type
);
1898 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1899 relocation
, absolute
))
1900 r
= bfd_reloc_overflow
;
1908 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1909 contents
+ rel
->r_offset
);
1910 relocation
= old_value
+ relocation
;
1920 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1921 contents
+ rel
->r_offset
);
1922 relocation
= old_value
- relocation
;
1926 case R_RISCV_CALL_PLT
:
1929 case R_RISCV_RVC_JUMP
:
1930 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
1932 /* Refer to the PLT entry. */
1933 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
1934 unresolved_reloc
= FALSE
;
1938 case R_RISCV_TPREL_HI20
:
1939 relocation
= tpoff (info
, relocation
);
1942 case R_RISCV_TPREL_LO12_I
:
1943 case R_RISCV_TPREL_LO12_S
:
1944 relocation
= tpoff (info
, relocation
);
1947 case R_RISCV_TPREL_I
:
1948 case R_RISCV_TPREL_S
:
1949 relocation
= tpoff (info
, relocation
);
1950 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
1952 /* We can use tp as the base register. */
1953 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1954 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1955 insn
|= X_TP
<< OP_SH_RS1
;
1956 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1959 r
= bfd_reloc_overflow
;
1962 case R_RISCV_GPREL_I
:
1963 case R_RISCV_GPREL_S
:
1965 bfd_vma gp
= riscv_global_pointer_value (info
);
1966 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
1967 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
1969 /* We can use x0 or gp as the base register. */
1970 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1971 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1974 rel
->r_addend
-= gp
;
1975 insn
|= X_GP
<< OP_SH_RS1
;
1977 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1980 r
= bfd_reloc_overflow
;
1984 case R_RISCV_PCREL_HI20
:
1985 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1992 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1993 howto
= riscv_elf_rtype_to_howto (r_type
);
1994 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1995 relocation
+ rel
->r_addend
,
1997 r
= bfd_reloc_overflow
;
2000 case R_RISCV_PCREL_LO12_I
:
2001 case R_RISCV_PCREL_LO12_S
:
2002 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2003 howto
, rel
, relocation
, name
,
2006 r
= bfd_reloc_overflow
;
2009 case R_RISCV_TLS_DTPREL32
:
2010 case R_RISCV_TLS_DTPREL64
:
2011 relocation
= dtpoff (info
, relocation
);
2016 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2019 if ((bfd_link_pic (info
)
2021 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2022 || h
->root
.type
!= bfd_link_hash_undefweak
)
2023 && (! howto
->pc_relative
2024 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2025 || (!bfd_link_pic (info
)
2031 || h
->root
.type
== bfd_link_hash_undefweak
2032 || h
->root
.type
== bfd_link_hash_undefined
)))
2034 Elf_Internal_Rela outrel
;
2035 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2037 /* When generating a shared object, these relocations
2038 are copied into the output file to be resolved at run
2042 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2044 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2045 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2046 outrel
.r_offset
+= sec_addr (input_section
);
2048 if (skip_dynamic_relocation
)
2049 memset (&outrel
, 0, sizeof outrel
);
2050 else if (h
!= NULL
&& h
->dynindx
!= -1
2051 && !(bfd_link_pic (info
)
2052 && SYMBOLIC_BIND (info
, h
)
2055 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2056 outrel
.r_addend
= rel
->r_addend
;
2060 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2061 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2064 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2065 if (skip_static_relocation
)
2070 case R_RISCV_TLS_GOT_HI20
:
2074 case R_RISCV_TLS_GD_HI20
:
2077 off
= h
->got
.offset
;
2082 off
= local_got_offsets
[r_symndx
];
2083 local_got_offsets
[r_symndx
] |= 1;
2086 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2087 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2088 /* If this symbol is referenced by both GD and IE TLS, the IE
2089 reference's GOT slot follows the GD reference's slots. */
2091 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2092 ie_off
= 2 * GOT_ENTRY_SIZE
;
2098 Elf_Internal_Rela outrel
;
2100 bfd_boolean need_relocs
= FALSE
;
2102 if (htab
->elf
.srelgot
== NULL
)
2107 bfd_boolean dyn
, pic
;
2108 dyn
= htab
->elf
.dynamic_sections_created
;
2109 pic
= bfd_link_pic (info
);
2111 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2112 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2116 /* The GOT entries have not been initialized yet. Do it
2117 now, and emit any relocations. */
2118 if ((bfd_link_pic (info
) || indx
!= 0)
2120 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2121 || h
->root
.type
!= bfd_link_hash_undefweak
))
2124 if (tls_type
& GOT_TLS_GD
)
2128 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2129 outrel
.r_addend
= 0;
2130 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2131 bfd_put_NN (output_bfd
, 0,
2132 htab
->elf
.sgot
->contents
+ off
);
2133 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2136 BFD_ASSERT (! unresolved_reloc
);
2137 bfd_put_NN (output_bfd
,
2138 dtpoff (info
, relocation
),
2139 (htab
->elf
.sgot
->contents
+ off
+
2140 RISCV_ELF_WORD_BYTES
));
2144 bfd_put_NN (output_bfd
, 0,
2145 (htab
->elf
.sgot
->contents
+ off
+
2146 RISCV_ELF_WORD_BYTES
));
2147 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2148 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2149 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2154 /* If we are not emitting relocations for a
2155 general dynamic reference, then we must be in a
2156 static link or an executable link with the
2157 symbol binding locally. Mark it as belonging
2158 to module 1, the executable. */
2159 bfd_put_NN (output_bfd
, 1,
2160 htab
->elf
.sgot
->contents
+ off
);
2161 bfd_put_NN (output_bfd
,
2162 dtpoff (info
, relocation
),
2163 (htab
->elf
.sgot
->contents
+ off
+
2164 RISCV_ELF_WORD_BYTES
));
2168 if (tls_type
& GOT_TLS_IE
)
2172 bfd_put_NN (output_bfd
, 0,
2173 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2174 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2176 outrel
.r_addend
= 0;
2178 outrel
.r_addend
= tpoff (info
, relocation
);
2179 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2180 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2184 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2185 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2190 BFD_ASSERT (off
< (bfd_vma
) -2);
2191 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2192 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2194 r
= bfd_reloc_overflow
;
2195 unresolved_reloc
= FALSE
;
2199 r
= bfd_reloc_notsupported
;
2202 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2203 because such sections are not SEC_ALLOC and thus ld.so will
2204 not process them. */
2205 if (unresolved_reloc
2206 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2208 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2209 rel
->r_offset
) != (bfd_vma
) -1)
2211 (*_bfd_error_handler
)
2212 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
2217 h
->root
.root
.string
);
2221 if (r
== bfd_reloc_ok
)
2222 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2223 input_bfd
, contents
);
2230 case bfd_reloc_overflow
:
2231 info
->callbacks
->reloc_overflow
2232 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2233 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2236 case bfd_reloc_undefined
:
2237 info
->callbacks
->undefined_symbol
2238 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2242 case bfd_reloc_outofrange
:
2243 msg
= _("internal error: out of range error");
2246 case bfd_reloc_notsupported
:
2247 msg
= _("internal error: unsupported relocation error");
2250 case bfd_reloc_dangerous
:
2251 msg
= _("internal error: dangerous relocation");
2255 msg
= _("internal error: unknown error");
2260 info
->callbacks
->warning
2261 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
2265 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2267 riscv_free_pcrel_relocs (&pcrel_relocs
);
2271 /* Finish up dynamic symbol handling. We set the contents of various
2272 dynamic sections here. */
2275 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2276 struct bfd_link_info
*info
,
2277 struct elf_link_hash_entry
*h
,
2278 Elf_Internal_Sym
*sym
)
2280 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2281 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2283 if (h
->plt
.offset
!= (bfd_vma
) -1)
2285 /* We've decided to create a PLT entry for this symbol. */
2287 bfd_vma i
, header_address
, plt_idx
, got_address
;
2288 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2289 Elf_Internal_Rela rela
;
2291 BFD_ASSERT (h
->dynindx
!= -1);
2293 /* Calculate the address of the PLT header. */
2294 header_address
= sec_addr (htab
->elf
.splt
);
2296 /* Calculate the index of the entry. */
2297 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2299 /* Calculate the address of the .got.plt entry. */
2300 got_address
= riscv_elf_got_plt_val (plt_idx
, info
);
2302 /* Find out where the .plt entry should go. */
2303 loc
= htab
->elf
.splt
->contents
+ h
->plt
.offset
;
2305 /* Fill in the PLT entry itself. */
2306 riscv_make_plt_entry (got_address
, header_address
+ h
->plt
.offset
,
2308 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2309 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2311 /* Fill in the initial value of the .got.plt entry. */
2312 loc
= htab
->elf
.sgotplt
->contents
2313 + (got_address
- sec_addr (htab
->elf
.sgotplt
));
2314 bfd_put_NN (output_bfd
, sec_addr (htab
->elf
.splt
), loc
);
2316 /* Fill in the entry in the .rela.plt section. */
2317 rela
.r_offset
= got_address
;
2319 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2321 loc
= htab
->elf
.srelplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2322 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2324 if (!h
->def_regular
)
2326 /* Mark the symbol as undefined, rather than as defined in
2327 the .plt section. Leave the value alone. */
2328 sym
->st_shndx
= SHN_UNDEF
;
2329 /* If the symbol is weak, we do need to clear the value.
2330 Otherwise, the PLT entry would provide a definition for
2331 the symbol even if the symbol wasn't defined anywhere,
2332 and so the symbol would never be NULL. */
2333 if (!h
->ref_regular_nonweak
)
2338 if (h
->got
.offset
!= (bfd_vma
) -1
2339 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
2343 Elf_Internal_Rela rela
;
2345 /* This symbol has an entry in the GOT. Set it up. */
2347 sgot
= htab
->elf
.sgot
;
2348 srela
= htab
->elf
.srelgot
;
2349 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2351 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2353 /* If this is a -Bsymbolic link, and the symbol is defined
2354 locally, we just want to emit a RELATIVE reloc. Likewise if
2355 the symbol was forced to be local because of a version file.
2356 The entry in the global offset table will already have been
2357 initialized in the relocate_section function. */
2358 if (bfd_link_pic (info
)
2359 && (info
->symbolic
|| h
->dynindx
== -1)
2362 asection
*sec
= h
->root
.u
.def
.section
;
2363 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2364 rela
.r_addend
= (h
->root
.u
.def
.value
2365 + sec
->output_section
->vma
2366 + sec
->output_offset
);
2370 BFD_ASSERT (h
->dynindx
!= -1);
2371 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2375 bfd_put_NN (output_bfd
, 0,
2376 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
2377 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
2382 Elf_Internal_Rela rela
;
2385 /* This symbols needs a copy reloc. Set it up. */
2386 BFD_ASSERT (h
->dynindx
!= -1);
2388 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
2389 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
2391 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2392 s
= htab
->elf
.sreldynrelro
;
2394 s
= htab
->elf
.srelbss
;
2395 riscv_elf_append_rela (output_bfd
, s
, &rela
);
2398 /* Mark some specially defined symbols as absolute. */
2399 if (h
== htab
->elf
.hdynamic
2400 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
2401 sym
->st_shndx
= SHN_ABS
;
2406 /* Finish up the dynamic sections. */
2409 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
2410 bfd
*dynobj
, asection
*sdyn
)
2412 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2413 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2414 size_t dynsize
= bed
->s
->sizeof_dyn
;
2415 bfd_byte
*dyncon
, *dynconend
;
2417 dynconend
= sdyn
->contents
+ sdyn
->size
;
2418 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
2420 Elf_Internal_Dyn dyn
;
2423 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
2428 s
= htab
->elf
.sgotplt
;
2429 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2432 s
= htab
->elf
.srelplt
;
2433 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2436 s
= htab
->elf
.srelplt
;
2437 dyn
.d_un
.d_val
= s
->size
;
2443 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2449 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
2450 struct bfd_link_info
*info
)
2454 struct riscv_elf_link_hash_table
*htab
;
2456 htab
= riscv_elf_hash_table (info
);
2457 BFD_ASSERT (htab
!= NULL
);
2458 dynobj
= htab
->elf
.dynobj
;
2460 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2462 if (elf_hash_table (info
)->dynamic_sections_created
)
2467 splt
= htab
->elf
.splt
;
2468 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2470 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
2475 /* Fill in the head and tail entries in the procedure linkage table. */
2479 uint32_t plt_header
[PLT_HEADER_INSNS
];
2480 riscv_make_plt_header (sec_addr (htab
->elf
.sgotplt
),
2481 sec_addr (splt
), plt_header
);
2483 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
2484 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
2486 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2491 if (htab
->elf
.sgotplt
)
2493 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
2495 if (bfd_is_abs_section (output_section
))
2497 (*_bfd_error_handler
)
2498 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
2502 if (htab
->elf
.sgotplt
->size
> 0)
2504 /* Write the first two entries in .got.plt, needed for the dynamic
2506 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
2507 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
2508 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2511 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2516 asection
*output_section
= htab
->elf
.sgot
->output_section
;
2518 if (htab
->elf
.sgot
->size
> 0)
2520 /* Set the first entry in the global offset table to the address of
2521 the dynamic section. */
2522 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
2523 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
2526 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2532 /* Return address for Ith PLT stub in section PLT, for relocation REL
2533 or (bfd_vma) -1 if it should not be included. */
2536 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
2537 const arelent
*rel ATTRIBUTE_UNUSED
)
2539 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
2542 static enum elf_reloc_type_class
2543 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2544 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2545 const Elf_Internal_Rela
*rela
)
2547 switch (ELFNN_R_TYPE (rela
->r_info
))
2549 case R_RISCV_RELATIVE
:
2550 return reloc_class_relative
;
2551 case R_RISCV_JUMP_SLOT
:
2552 return reloc_class_plt
;
2554 return reloc_class_copy
;
2556 return reloc_class_normal
;
2560 /* Merge backend specific data from an object file to the output
2561 object file when linking. */
2564 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2566 bfd
*obfd
= info
->output_bfd
;
2567 flagword new_flags
= elf_elfheader (ibfd
)->e_flags
;
2568 flagword old_flags
= elf_elfheader (obfd
)->e_flags
;
2570 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
2573 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
2575 (*_bfd_error_handler
)
2576 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2577 " target emulation `%s' does not match `%s'"),
2578 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
2582 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
2585 if (! elf_flags_init (obfd
))
2587 elf_flags_init (obfd
) = TRUE
;
2588 elf_elfheader (obfd
)->e_flags
= new_flags
;
2592 /* Disallow linking different float ABIs. */
2593 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
2595 (*_bfd_error_handler
)
2596 (_("%B: can't link hard-float modules with soft-float modules"), ibfd
);
2600 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2601 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
2606 bfd_set_error (bfd_error_bad_value
);
2610 /* Delete some bytes from a section while relaxing. */
2613 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
)
2615 unsigned int i
, symcount
;
2616 bfd_vma toaddr
= sec
->size
;
2617 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
2618 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2619 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2620 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
2621 bfd_byte
*contents
= data
->this_hdr
.contents
;
2623 /* Actually delete the bytes. */
2625 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
2627 /* Adjust the location of all of the relocs. Note that we need not
2628 adjust the addends, since all PC-relative references must be against
2629 symbols, which we will adjust below. */
2630 for (i
= 0; i
< sec
->reloc_count
; i
++)
2631 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
2632 data
->relocs
[i
].r_offset
-= count
;
2634 /* Adjust the local symbols defined in this section. */
2635 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2637 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
2638 if (sym
->st_shndx
== sec_shndx
)
2640 /* If the symbol is in the range of memory we just moved, we
2641 have to adjust its value. */
2642 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
2643 sym
->st_value
-= count
;
2645 /* If the symbol *spans* the bytes we just deleted (i.e. its
2646 *end* is in the moved bytes but its *start* isn't), then we
2647 must adjust its size. */
2648 if (sym
->st_value
<= addr
2649 && sym
->st_value
+ sym
->st_size
> addr
2650 && sym
->st_value
+ sym
->st_size
<= toaddr
)
2651 sym
->st_size
-= count
;
2655 /* Now adjust the global symbols defined in this section. */
2656 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
2657 - symtab_hdr
->sh_info
);
2659 for (i
= 0; i
< symcount
; i
++)
2661 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
2663 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2664 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2665 && sym_hash
->root
.u
.def
.section
== sec
)
2667 /* As above, adjust the value if needed. */
2668 if (sym_hash
->root
.u
.def
.value
> addr
2669 && sym_hash
->root
.u
.def
.value
<= toaddr
)
2670 sym_hash
->root
.u
.def
.value
-= count
;
2672 /* As above, adjust the size if needed. */
2673 if (sym_hash
->root
.u
.def
.value
<= addr
2674 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2675 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
2676 sym_hash
->size
-= count
;
2683 /* A second format for recording PC-relative hi relocations. This stores the
2684 information required to relax them to GP-relative addresses. */
2686 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
2687 struct riscv_pcgp_hi_reloc
2694 riscv_pcgp_hi_reloc
*next
;
2697 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
2698 struct riscv_pcgp_lo_reloc
2701 riscv_pcgp_lo_reloc
*next
;
2706 riscv_pcgp_hi_reloc
*hi
;
2707 riscv_pcgp_lo_reloc
*lo
;
2708 } riscv_pcgp_relocs
;
2711 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
2719 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
2720 bfd
*abfd ATTRIBUTE_UNUSED
,
2721 asection
*sec ATTRIBUTE_UNUSED
)
2723 riscv_pcgp_hi_reloc
*c
;
2724 riscv_pcgp_lo_reloc
*l
;
2726 for (c
= p
->hi
; c
!= NULL
;)
2728 riscv_pcgp_hi_reloc
*next
= c
->next
;
2733 for (l
= p
->lo
; l
!= NULL
;)
2735 riscv_pcgp_lo_reloc
*next
= l
->next
;
2742 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
2743 bfd_vma hi_addend
, bfd_vma hi_addr
,
2744 unsigned hi_sym
, asection
*sym_sec
)
2746 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
2749 new->hi_sec_off
= hi_sec_off
;
2750 new->hi_addend
= hi_addend
;
2751 new->hi_addr
= hi_addr
;
2752 new->hi_sym
= hi_sym
;
2753 new->sym_sec
= sym_sec
;
2759 static riscv_pcgp_hi_reloc
*
2760 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2762 riscv_pcgp_hi_reloc
*c
;
2764 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2765 if (c
->hi_sec_off
== hi_sec_off
)
2771 riscv_delete_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2773 bfd_boolean out
= FALSE
;
2774 riscv_pcgp_hi_reloc
*c
;
2776 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2777 if (c
->hi_sec_off
== hi_sec_off
)
2784 riscv_use_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2786 bfd_boolean out
= FALSE
;
2787 riscv_pcgp_hi_reloc
*c
;
2789 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2790 if (c
->hi_sec_off
== hi_sec_off
)
2797 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2799 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
2802 new->hi_sec_off
= hi_sec_off
;
2809 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2811 riscv_pcgp_lo_reloc
*c
;
2813 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
2814 if (c
->hi_sec_off
== hi_sec_off
)
2820 riscv_delete_pcgp_lo_reloc (riscv_pcgp_relocs
*p ATTRIBUTE_UNUSED
,
2821 bfd_vma lo_sec_off ATTRIBUTE_UNUSED
,
2822 size_t bytes ATTRIBUTE_UNUSED
)
2827 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
2828 struct bfd_link_info
*,
2829 Elf_Internal_Rela
*,
2830 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
2831 riscv_pcgp_relocs
*);
2833 /* Relax AUIPC + JALR into JAL. */
2836 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
2837 struct bfd_link_info
*link_info
,
2838 Elf_Internal_Rela
*rel
,
2840 bfd_vma max_alignment
,
2841 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
2843 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
2845 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
2846 bfd_signed_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
2847 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
2848 bfd_vma auipc
, jalr
;
2849 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
2851 /* If the call crosses section boundaries, an alignment directive could
2852 cause the PC-relative offset to later increase. */
2853 if (VALID_UJTYPE_IMM (foff
) && sym_sec
->output_section
!= sec
->output_section
)
2854 foff
+= (foff
< 0 ? -max_alignment
: max_alignment
);
2856 /* See if this function call can be shortened. */
2857 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
2860 /* Shorten the function call. */
2861 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
2863 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
2864 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
2865 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
2866 rvc
= rvc
&& VALID_RVC_J_IMM (foff
) && ARCH_SIZE
== 32;
2868 if (rvc
&& (rd
== 0 || rd
== X_RA
))
2870 /* Relax to C.J[AL] rd, addr. */
2871 r_type
= R_RISCV_RVC_JUMP
;
2872 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
2875 else if (VALID_UJTYPE_IMM (foff
))
2877 /* Relax to JAL rd, addr. */
2878 r_type
= R_RISCV_JAL
;
2879 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
2881 else /* near_zero */
2883 /* Relax to JALR rd, x0, addr. */
2884 r_type
= R_RISCV_LO12_I
;
2885 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
2888 /* Replace the R_RISCV_CALL reloc. */
2889 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
2890 /* Replace the AUIPC. */
2891 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
2893 /* Delete unnecessary JALR. */
2895 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
);
2898 /* Traverse all output sections and return the max alignment. */
2901 _bfd_riscv_get_max_alignment (asection
*sec
)
2903 unsigned int max_alignment_power
= 0;
2906 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
2908 if (o
->alignment_power
> max_alignment_power
)
2909 max_alignment_power
= o
->alignment_power
;
2912 return (bfd_vma
) 1 << max_alignment_power
;
2915 /* Relax non-PIC global variable references. */
2918 _bfd_riscv_relax_lui (bfd
*abfd
,
2921 struct bfd_link_info
*link_info
,
2922 Elf_Internal_Rela
*rel
,
2924 bfd_vma max_alignment
,
2925 bfd_vma reserve_size
,
2927 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
2929 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
2930 bfd_vma gp
= riscv_global_pointer_value (link_info
);
2931 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
2933 /* Mergeable symbols and code might later move out of range. */
2934 if (sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
2937 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
2941 /* If gp and the symbol are in the same output section, then
2942 consider only that section's alignment. */
2943 struct bfd_link_hash_entry
*h
=
2944 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
2946 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
)
2947 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
2950 /* Is the reference in range of x0 or gp?
2951 Valid gp range conservatively because of alignment issue. */
2952 if (VALID_ITYPE_IMM (symval
)
2954 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
2956 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
)))
2958 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
2959 switch (ELFNN_R_TYPE (rel
->r_info
))
2961 case R_RISCV_LO12_I
:
2962 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
2965 case R_RISCV_LO12_S
:
2966 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
2970 /* We can delete the unnecessary LUI and reloc. */
2971 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
2973 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4);
2980 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2981 account for this assuming page alignment at worst. */
2983 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
2984 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
2985 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
+ ELF_MAXPAGESIZE
)))
2987 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
2988 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
2989 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
2990 if (rd
== 0 || rd
== X_SP
)
2993 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
2994 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
2996 /* Replace the R_RISCV_HI20 reloc. */
2997 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
3000 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2);
3006 /* Relax non-PIC TLS references. */
3009 _bfd_riscv_relax_tls_le (bfd
*abfd
,
3011 asection
*sym_sec ATTRIBUTE_UNUSED
,
3012 struct bfd_link_info
*link_info
,
3013 Elf_Internal_Rela
*rel
,
3015 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3016 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3018 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
)
3020 /* See if this symbol is in range of tp. */
3021 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
3024 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3025 switch (ELFNN_R_TYPE (rel
->r_info
))
3027 case R_RISCV_TPREL_LO12_I
:
3028 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
3031 case R_RISCV_TPREL_LO12_S
:
3032 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
3035 case R_RISCV_TPREL_HI20
:
3036 case R_RISCV_TPREL_ADD
:
3037 /* We can delete the unnecessary instruction and reloc. */
3038 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3040 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4);
3047 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3050 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
3052 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
3053 Elf_Internal_Rela
*rel
,
3055 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3056 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3057 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3058 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
)
3060 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3061 bfd_vma alignment
= 1, pos
;
3062 while (alignment
<= rel
->r_addend
)
3065 symval
-= rel
->r_addend
;
3066 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
3067 bfd_vma nop_bytes
= aligned_addr
- symval
;
3069 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3070 sec
->sec_flg0
= TRUE
;
3072 /* Make sure there are enough NOPs to actually achieve the alignment. */
3073 if (rel
->r_addend
< nop_bytes
)
3075 (*_bfd_error_handler
)
3076 (_("%B(%A+0x%lx): %d bytes required for alignment "
3077 "to %d-byte boundary, but only %d present"),
3078 abfd
, sym_sec
, rel
->r_offset
, nop_bytes
, alignment
, rel
->r_addend
);
3079 bfd_set_error (bfd_error_bad_value
);
3083 /* Delete the reloc. */
3084 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3086 /* If the number of NOPs is already correct, there's nothing to do. */
3087 if (nop_bytes
== rel
->r_addend
)
3090 /* Write as many RISC-V NOPs as we need. */
3091 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
3092 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
3094 /* Write a final RVC NOP if need be. */
3095 if (nop_bytes
% 4 != 0)
3096 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
3098 /* Delete the excess bytes. */
3099 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
3100 rel
->r_addend
- nop_bytes
);
3103 /* Relax PC-relative references to GP-relative references. */
3106 _bfd_riscv_relax_pc (bfd
*abfd
,
3109 struct bfd_link_info
*link_info
,
3110 Elf_Internal_Rela
*rel
,
3112 bfd_vma max_alignment
,
3113 bfd_vma reserve_size
,
3114 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3115 riscv_pcgp_relocs
*pcgp_relocs
)
3117 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3119 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3121 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3122 * actual target address. */
3123 riscv_pcgp_hi_reloc hi_reloc
= {0};
3124 switch (ELFNN_R_TYPE (rel
->r_info
))
3126 case R_RISCV_PCREL_LO12_I
:
3127 case R_RISCV_PCREL_LO12_S
:
3129 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
3130 symval
- sec_addr(sym_sec
));
3133 riscv_record_pcgp_lo_reloc (pcgp_relocs
, symval
- sec_addr(sym_sec
));
3138 symval
= hi_reloc
.hi_addr
;
3139 sym_sec
= hi_reloc
.sym_sec
;
3140 if (!riscv_use_pcgp_hi_reloc(pcgp_relocs
, hi
->hi_sec_off
))
3141 (*_bfd_error_handler
)
3142 (_("%B(%A+0x%lx): Unable to clear RISCV_PCREL_HI20 reloc"
3143 "for cooresponding RISCV_PCREL_LO12 reloc"),
3144 abfd
, sec
, rel
->r_offset
);
3148 case R_RISCV_PCREL_HI20
:
3149 /* Mergeable symbols and code might later move out of range. */
3150 if (sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
3153 /* If the cooresponding lo relocation has already been seen then it's not
3154 * safe to relax this relocation. */
3155 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
3166 /* If gp and the symbol are in the same output section, then
3167 consider only that section's alignment. */
3168 struct bfd_link_hash_entry
*h
=
3169 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
3170 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
)
3171 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3174 /* Is the reference in range of x0 or gp?
3175 Valid gp range conservatively because of alignment issue. */
3176 if (VALID_ITYPE_IMM (symval
)
3178 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3180 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
)))
3182 unsigned sym
= hi_reloc
.hi_sym
;
3183 switch (ELFNN_R_TYPE (rel
->r_info
))
3185 case R_RISCV_PCREL_LO12_I
:
3186 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3187 rel
->r_addend
+= hi_reloc
.hi_addend
;
3188 return riscv_delete_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
, 4);
3190 case R_RISCV_PCREL_LO12_S
:
3191 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3192 rel
->r_addend
+= hi_reloc
.hi_addend
;
3193 return riscv_delete_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
, 4);
3195 case R_RISCV_PCREL_HI20
:
3196 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
3200 ELFNN_R_SYM(rel
->r_info
),
3202 /* We can delete the unnecessary AUIPC and reloc. */
3203 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
3205 return riscv_delete_pcgp_hi_reloc (pcgp_relocs
, rel
->r_offset
);
3215 /* Relax PC-relative references to GP-relative references. */
3218 _bfd_riscv_relax_delete (bfd
*abfd
,
3220 asection
*sym_sec ATTRIBUTE_UNUSED
,
3221 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
3222 Elf_Internal_Rela
*rel
,
3223 bfd_vma symval ATTRIBUTE_UNUSED
,
3224 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3225 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3226 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3227 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
3229 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
))
3231 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
3235 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3236 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3237 disabled, handles code alignment directives. */
3240 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
3241 struct bfd_link_info
*info
,
3244 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
3245 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3246 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3247 Elf_Internal_Rela
*relocs
;
3248 bfd_boolean ret
= FALSE
;
3250 bfd_vma max_alignment
, reserve_size
= 0;
3251 riscv_pcgp_relocs pcgp_relocs
;
3255 if (bfd_link_relocatable (info
)
3257 || (sec
->flags
& SEC_RELOC
) == 0
3258 || sec
->reloc_count
== 0
3259 || (info
->disable_target_specific_optimizations
3260 && info
->relax_pass
== 0))
3263 riscv_init_pcgp_relocs (&pcgp_relocs
);
3265 /* Read this BFD's relocs if we haven't done so already. */
3267 relocs
= data
->relocs
;
3268 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3269 info
->keep_memory
)))
3274 max_alignment
= htab
->max_alignment
;
3275 if (max_alignment
== (bfd_vma
) -1)
3277 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3278 htab
->max_alignment
= max_alignment
;
3282 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3284 /* Examine and consider relaxing each reloc. */
3285 for (i
= 0; i
< sec
->reloc_count
; i
++)
3288 Elf_Internal_Rela
*rel
= relocs
+ i
;
3289 relax_func_t relax_func
;
3290 int type
= ELFNN_R_TYPE (rel
->r_info
);
3294 if (info
->relax_pass
== 0)
3296 if (type
== R_RISCV_CALL
|| type
== R_RISCV_CALL_PLT
)
3297 relax_func
= _bfd_riscv_relax_call
;
3298 else if (type
== R_RISCV_HI20
3299 || type
== R_RISCV_LO12_I
3300 || type
== R_RISCV_LO12_S
)
3301 relax_func
= _bfd_riscv_relax_lui
;
3302 else if (!bfd_link_pic(info
)
3303 && (type
== R_RISCV_PCREL_HI20
3304 || type
== R_RISCV_PCREL_LO12_I
3305 || type
== R_RISCV_PCREL_LO12_S
))
3306 relax_func
= _bfd_riscv_relax_pc
;
3307 else if (type
== R_RISCV_TPREL_HI20
3308 || type
== R_RISCV_TPREL_ADD
3309 || type
== R_RISCV_TPREL_LO12_I
3310 || type
== R_RISCV_TPREL_LO12_S
)
3311 relax_func
= _bfd_riscv_relax_tls_le
;
3315 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3316 if (i
== sec
->reloc_count
- 1
3317 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
3318 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
3321 /* Skip over the R_RISCV_RELAX. */
3324 else if (info
->relax_pass
== 1 && type
== R_RISCV_DELETE
)
3325 relax_func
= _bfd_riscv_relax_delete
;
3326 else if (info
->relax_pass
== 2 && type
== R_RISCV_ALIGN
)
3327 relax_func
= _bfd_riscv_relax_align
;
3331 data
->relocs
= relocs
;
3333 /* Read this BFD's contents if we haven't done so already. */
3334 if (!data
->this_hdr
.contents
3335 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
3338 /* Read this BFD's symbols if we haven't done so already. */
3339 if (symtab_hdr
->sh_info
!= 0
3340 && !symtab_hdr
->contents
3341 && !(symtab_hdr
->contents
=
3342 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3343 symtab_hdr
->sh_info
,
3344 0, NULL
, NULL
, NULL
)))
3347 /* Get the value of the symbol referred to by the reloc. */
3348 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
3350 /* A local symbol. */
3351 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
3352 + ELFNN_R_SYM (rel
->r_info
));
3353 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
3354 ? 0 : isym
->st_size
- rel
->r_addend
;
3356 if (isym
->st_shndx
== SHN_UNDEF
)
3357 sym_sec
= sec
, symval
= sec_addr (sec
) + rel
->r_offset
;
3360 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
3361 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
3362 if (sec_addr (sym_sec
) == 0)
3364 symval
= sec_addr (sym_sec
) + isym
->st_value
;
3370 struct elf_link_hash_entry
*h
;
3372 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
3373 h
= elf_sym_hashes (abfd
)[indx
];
3375 while (h
->root
.type
== bfd_link_hash_indirect
3376 || h
->root
.type
== bfd_link_hash_warning
)
3377 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3379 if (h
->plt
.offset
!= MINUS_ONE
)
3380 symval
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
3381 else if (h
->root
.u
.def
.section
->output_section
== NULL
3382 || (h
->root
.type
!= bfd_link_hash_defined
3383 && h
->root
.type
!= bfd_link_hash_defweak
))
3386 symval
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3388 if (h
->type
!= STT_FUNC
)
3390 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
3391 sym_sec
= h
->root
.u
.def
.section
;
3394 symval
+= rel
->r_addend
;
3396 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
3397 max_alignment
, reserve_size
, again
,
3405 if (relocs
!= data
->relocs
)
3407 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
3413 # define PRSTATUS_SIZE 0 /* FIXME */
3414 # define PRSTATUS_OFFSET_PR_CURSIG 12
3415 # define PRSTATUS_OFFSET_PR_PID 24
3416 # define PRSTATUS_OFFSET_PR_REG 72
3417 # define ELF_GREGSET_T_SIZE 128
3418 # define PRPSINFO_SIZE 128
3419 # define PRPSINFO_OFFSET_PR_PID 16
3420 # define PRPSINFO_OFFSET_PR_FNAME 32
3421 # define PRPSINFO_OFFSET_PR_PSARGS 48
3423 # define PRSTATUS_SIZE 376
3424 # define PRSTATUS_OFFSET_PR_CURSIG 12
3425 # define PRSTATUS_OFFSET_PR_PID 32
3426 # define PRSTATUS_OFFSET_PR_REG 112
3427 # define ELF_GREGSET_T_SIZE 256
3428 # define PRPSINFO_SIZE 136
3429 # define PRPSINFO_OFFSET_PR_PID 24
3430 # define PRPSINFO_OFFSET_PR_FNAME 40
3431 # define PRPSINFO_OFFSET_PR_PSARGS 56
3434 /* Support for core dump NOTE sections. */
3437 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3439 switch (note
->descsz
)
3444 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3446 elf_tdata (abfd
)->core
->signal
3447 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
3450 elf_tdata (abfd
)->core
->lwpid
3451 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
3455 /* Make a ".reg/999" section. */
3456 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
3457 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
3461 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3463 switch (note
->descsz
)
3468 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3470 elf_tdata (abfd
)->core
->pid
3471 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
3474 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
3475 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
3478 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
3479 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
3483 /* Note that for some reason, a spurious space is tacked
3484 onto the end of the args in some (at least one anyway)
3485 implementations, so strip it off if it exists. */
3488 char *command
= elf_tdata (abfd
)->core
->command
;
3489 int n
= strlen (command
);
3491 if (0 < n
&& command
[n
- 1] == ' ')
3492 command
[n
- 1] = '\0';
3498 /* Set the right mach type. */
3500 riscv_elf_object_p (bfd
*abfd
)
3502 /* There are only two mach types in RISCV currently. */
3503 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
3504 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
3506 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
3512 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3513 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3515 #define elf_backend_reloc_type_class riscv_reloc_type_class
3517 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3518 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3519 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3520 #define bfd_elfNN_bfd_merge_private_bfd_data \
3521 _bfd_riscv_elf_merge_private_bfd_data
3523 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3524 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3525 #define elf_backend_check_relocs riscv_elf_check_relocs
3526 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3527 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3528 #define elf_backend_relocate_section riscv_elf_relocate_section
3529 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3530 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3531 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3532 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3533 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3534 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3535 #define elf_backend_object_p riscv_elf_object_p
3536 #define elf_info_to_howto_rel NULL
3537 #define elf_info_to_howto riscv_info_to_howto_rela
3538 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3540 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3542 #define elf_backend_can_gc_sections 1
3543 #define elf_backend_can_refcount 1
3544 #define elf_backend_want_got_plt 1
3545 #define elf_backend_plt_readonly 1
3546 #define elf_backend_plt_alignment 4
3547 #define elf_backend_want_plt_sym 1
3548 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3549 #define elf_backend_want_dynrelro 1
3550 #define elf_backend_rela_normal 1
3551 #define elf_backend_default_execstack 0
3553 #include "elfNN-target.h"