1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2018 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 /* RISC-V ELF linker hash entry. */
60 struct riscv_elf_link_hash_entry
62 struct elf_link_hash_entry elf
;
64 /* Track dynamic relocs copied for this symbol. */
65 struct elf_dyn_relocs
*dyn_relocs
;
75 #define riscv_elf_hash_entry(ent) \
76 ((struct riscv_elf_link_hash_entry *)(ent))
78 struct _bfd_riscv_elf_obj_tdata
80 struct elf_obj_tdata root
;
82 /* tls_type for each local got entry. */
83 char *local_got_tls_type
;
86 #define _bfd_riscv_elf_tdata(abfd) \
87 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
89 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
90 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
92 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
93 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
94 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
96 #define is_riscv_elf(bfd) \
97 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
98 && elf_tdata (bfd) != NULL \
99 && elf_object_id (bfd) == RISCV_ELF_DATA)
101 #include "elf/common.h"
102 #include "elf/internal.h"
104 struct riscv_elf_link_hash_table
106 struct elf_link_hash_table elf
;
108 /* Short-cuts to get to dynamic linker sections. */
111 /* Small local sym to section mapping cache. */
112 struct sym_cache sym_cache
;
114 /* The max alignment of output sections. */
115 bfd_vma max_alignment
;
119 /* Get the RISC-V ELF linker hash table from a link_info structure. */
120 #define riscv_elf_hash_table(p) \
121 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
122 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
125 riscv_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
127 Elf_Internal_Rela
*dst
)
129 cache_ptr
->howto
= riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst
->r_info
));
133 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
135 const struct elf_backend_data
*bed
;
138 bed
= get_elf_backend_data (abfd
);
139 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
140 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
145 #define PLT_HEADER_INSNS 8
146 #define PLT_ENTRY_INSNS 4
147 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
148 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
150 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
152 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
154 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
157 riscv_elf_got_plt_val (bfd_vma plt_index
, struct bfd_link_info
*info
)
159 return sec_addr (riscv_elf_hash_table (info
)->elf
.sgotplt
)
160 + GOTPLT_HEADER_SIZE
+ (plt_index
* GOT_ENTRY_SIZE
);
164 # define MATCH_LREG MATCH_LW
166 # define MATCH_LREG MATCH_LD
169 /* Generate a PLT header. */
172 riscv_make_plt_header (bfd_vma gotplt_addr
, bfd_vma addr
, uint32_t *entry
)
174 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
175 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
177 /* auipc t2, %hi(.got.plt)
178 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
179 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
180 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
181 addi t0, t2, %lo(.got.plt) # &.got.plt
182 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
183 l[w|d] t0, PTRSIZE(t0) # link map
186 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
187 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
188 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
189 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, -(PLT_HEADER_SIZE
+ 12));
190 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
191 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
192 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
193 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
196 /* Generate a PLT entry. */
199 riscv_make_plt_entry (bfd_vma got
, bfd_vma addr
, uint32_t *entry
)
201 /* auipc t3, %hi(.got.plt entry)
202 l[w|d] t3, %lo(.got.plt entry)(t3)
206 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
207 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
208 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
209 entry
[3] = RISCV_NOP
;
212 /* Create an entry in an RISC-V ELF linker hash table. */
214 static struct bfd_hash_entry
*
215 link_hash_newfunc (struct bfd_hash_entry
*entry
,
216 struct bfd_hash_table
*table
, const char *string
)
218 /* Allocate the structure if it has not already been allocated by a
223 bfd_hash_allocate (table
,
224 sizeof (struct riscv_elf_link_hash_entry
));
229 /* Call the allocation method of the superclass. */
230 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
233 struct riscv_elf_link_hash_entry
*eh
;
235 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
236 eh
->dyn_relocs
= NULL
;
237 eh
->tls_type
= GOT_UNKNOWN
;
243 /* Create a RISC-V ELF linker hash table. */
245 static struct bfd_link_hash_table
*
246 riscv_elf_link_hash_table_create (bfd
*abfd
)
248 struct riscv_elf_link_hash_table
*ret
;
249 bfd_size_type amt
= sizeof (struct riscv_elf_link_hash_table
);
251 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
255 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
256 sizeof (struct riscv_elf_link_hash_entry
),
263 ret
->max_alignment
= (bfd_vma
) -1;
264 return &ret
->elf
.root
;
267 /* Create the .got section. */
270 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
274 struct elf_link_hash_entry
*h
;
275 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
276 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
278 /* This function may be called more than once. */
279 if (htab
->sgot
!= NULL
)
282 flags
= bed
->dynamic_sec_flags
;
284 s
= bfd_make_section_anyway_with_flags (abfd
,
285 (bed
->rela_plts_and_copies_p
286 ? ".rela.got" : ".rel.got"),
287 (bed
->dynamic_sec_flags
290 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
294 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
296 || !bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
300 /* The first bit of the global offset table is the header. */
301 s
->size
+= bed
->got_header_size
;
303 if (bed
->want_got_plt
)
305 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
307 || !bfd_set_section_alignment (abfd
, s
,
308 bed
->s
->log_file_align
))
312 /* Reserve room for the header. */
313 s
->size
+= GOTPLT_HEADER_SIZE
;
316 if (bed
->want_got_sym
)
318 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
319 section. We don't do this in the linker script because we don't want
320 to define the symbol if we are not creating a global offset
322 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
323 "_GLOBAL_OFFSET_TABLE_");
324 elf_hash_table (info
)->hgot
= h
;
332 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
333 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
337 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
338 struct bfd_link_info
*info
)
340 struct riscv_elf_link_hash_table
*htab
;
342 htab
= riscv_elf_hash_table (info
);
343 BFD_ASSERT (htab
!= NULL
);
345 if (!riscv_elf_create_got_section (dynobj
, info
))
348 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
351 if (!bfd_link_pic (info
))
354 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
355 SEC_ALLOC
| SEC_THREAD_LOCAL
);
358 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
359 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
365 /* Copy the extra info we tack onto an elf_link_hash_entry. */
368 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
369 struct elf_link_hash_entry
*dir
,
370 struct elf_link_hash_entry
*ind
)
372 struct riscv_elf_link_hash_entry
*edir
, *eind
;
374 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
375 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
377 if (eind
->dyn_relocs
!= NULL
)
379 if (edir
->dyn_relocs
!= NULL
)
381 struct elf_dyn_relocs
**pp
;
382 struct elf_dyn_relocs
*p
;
384 /* Add reloc counts against the indirect sym to the direct sym
385 list. Merge any entries against the same section. */
386 for (pp
= &eind
->dyn_relocs
; (p
= *pp
) != NULL
; )
388 struct elf_dyn_relocs
*q
;
390 for (q
= edir
->dyn_relocs
; q
!= NULL
; q
= q
->next
)
391 if (q
->sec
== p
->sec
)
393 q
->pc_count
+= p
->pc_count
;
394 q
->count
+= p
->count
;
401 *pp
= edir
->dyn_relocs
;
404 edir
->dyn_relocs
= eind
->dyn_relocs
;
405 eind
->dyn_relocs
= NULL
;
408 if (ind
->root
.type
== bfd_link_hash_indirect
409 && dir
->got
.refcount
<= 0)
411 edir
->tls_type
= eind
->tls_type
;
412 eind
->tls_type
= GOT_UNKNOWN
;
414 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
418 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
419 unsigned long symndx
, char tls_type
)
421 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
423 *new_tls_type
|= tls_type
;
424 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
426 (*_bfd_error_handler
)
427 (_("%B: `%s' accessed both as normal and thread local symbol"),
428 abfd
, h
? h
->root
.root
.string
: "<local>");
435 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
436 struct elf_link_hash_entry
*h
, long symndx
)
438 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
439 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
441 if (htab
->elf
.sgot
== NULL
)
443 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
449 h
->got
.refcount
+= 1;
453 /* This is a global offset table entry for a local symbol. */
454 if (elf_local_got_refcounts (abfd
) == NULL
)
456 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
457 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
459 _bfd_riscv_elf_local_got_tls_type (abfd
)
460 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
462 elf_local_got_refcounts (abfd
) [symndx
] += 1;
468 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
470 (*_bfd_error_handler
)
471 (_("%B: relocation %s against `%s' can not be used when making a shared "
472 "object; recompile with -fPIC"),
473 abfd
, riscv_elf_rtype_to_howto (r_type
)->name
,
474 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
475 bfd_set_error (bfd_error_bad_value
);
478 /* Look through the relocs for a section during the first phase, and
479 allocate space in the global offset table or procedure linkage
483 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
484 asection
*sec
, const Elf_Internal_Rela
*relocs
)
486 struct riscv_elf_link_hash_table
*htab
;
487 Elf_Internal_Shdr
*symtab_hdr
;
488 struct elf_link_hash_entry
**sym_hashes
;
489 const Elf_Internal_Rela
*rel
;
490 asection
*sreloc
= NULL
;
492 if (bfd_link_relocatable (info
))
495 htab
= riscv_elf_hash_table (info
);
496 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
497 sym_hashes
= elf_sym_hashes (abfd
);
499 if (htab
->elf
.dynobj
== NULL
)
500 htab
->elf
.dynobj
= abfd
;
502 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
505 unsigned int r_symndx
;
506 struct elf_link_hash_entry
*h
;
508 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
509 r_type
= ELFNN_R_TYPE (rel
->r_info
);
511 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
513 (*_bfd_error_handler
) (_("%B: bad symbol index: %d"),
518 if (r_symndx
< symtab_hdr
->sh_info
)
522 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
523 while (h
->root
.type
== bfd_link_hash_indirect
524 || h
->root
.type
== bfd_link_hash_warning
)
525 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
530 case R_RISCV_TLS_GD_HI20
:
531 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
532 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
536 case R_RISCV_TLS_GOT_HI20
:
537 if (bfd_link_pic (info
))
538 info
->flags
|= DF_STATIC_TLS
;
539 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
540 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
544 case R_RISCV_GOT_HI20
:
545 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
546 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
550 case R_RISCV_CALL_PLT
:
551 /* This symbol requires a procedure linkage table entry. We
552 actually build the entry in adjust_dynamic_symbol,
553 because this might be a case of linking PIC code without
554 linking in any dynamic objects, in which case we don't
555 need to generate a procedure linkage table after all. */
560 h
->plt
.refcount
+= 1;
567 case R_RISCV_RVC_BRANCH
:
568 case R_RISCV_RVC_JUMP
:
569 case R_RISCV_PCREL_HI20
:
570 /* In shared libraries, these relocs are known to bind locally. */
571 if (bfd_link_pic (info
))
575 case R_RISCV_TPREL_HI20
:
576 if (!bfd_link_executable (info
))
577 return bad_static_reloc (abfd
, r_type
, h
);
579 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
583 if (bfd_link_pic (info
))
584 return bad_static_reloc (abfd
, r_type
, h
);
588 case R_RISCV_JUMP_SLOT
:
589 case R_RISCV_RELATIVE
:
595 /* This reloc might not bind locally. */
599 if (h
!= NULL
&& !bfd_link_pic (info
))
601 /* We may need a .plt entry if the function this reloc
602 refers to is in a shared lib. */
603 h
->plt
.refcount
+= 1;
606 /* If we are creating a shared library, and this is a reloc
607 against a global symbol, or a non PC relative reloc
608 against a local symbol, then we need to copy the reloc
609 into the shared library. However, if we are linking with
610 -Bsymbolic, we do not need to copy a reloc against a
611 global symbol which is defined in an object we are
612 including in the link (i.e., DEF_REGULAR is set). At
613 this point we have not seen all the input files, so it is
614 possible that DEF_REGULAR is not set now but will be set
615 later (it is never cleared). In case of a weak definition,
616 DEF_REGULAR may be cleared later by a strong definition in
617 a shared library. We account for that possibility below by
618 storing information in the relocs_copied field of the hash
619 table entry. A similar situation occurs when creating
620 shared libraries and symbol visibility changes render the
623 If on the other hand, we are creating an executable, we
624 may need to keep relocations for symbols satisfied by a
625 dynamic library if we manage to avoid copy relocs for the
627 if ((bfd_link_pic (info
)
628 && (sec
->flags
& SEC_ALLOC
) != 0
629 && (! riscv_elf_rtype_to_howto (r_type
)->pc_relative
632 || h
->root
.type
== bfd_link_hash_defweak
633 || !h
->def_regular
))))
634 || (!bfd_link_pic (info
)
635 && (sec
->flags
& SEC_ALLOC
) != 0
637 && (h
->root
.type
== bfd_link_hash_defweak
638 || !h
->def_regular
)))
640 struct elf_dyn_relocs
*p
;
641 struct elf_dyn_relocs
**head
;
643 /* When creating a shared object, we must copy these
644 relocs into the output file. We create a reloc
645 section in dynobj and make room for the reloc. */
648 sreloc
= _bfd_elf_make_dynamic_reloc_section
649 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
650 abfd
, /*rela?*/ TRUE
);
656 /* If this is a global symbol, we count the number of
657 relocations we need for this symbol. */
659 head
= &((struct riscv_elf_link_hash_entry
*) h
)->dyn_relocs
;
662 /* Track dynamic relocs needed for local syms too.
663 We really need local syms available to do this
668 Elf_Internal_Sym
*isym
;
670 isym
= bfd_sym_from_r_symndx (&htab
->sym_cache
,
675 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
679 vpp
= &elf_section_data (s
)->local_dynrel
;
680 head
= (struct elf_dyn_relocs
**) vpp
;
684 if (p
== NULL
|| p
->sec
!= sec
)
686 bfd_size_type amt
= sizeof *p
;
687 p
= ((struct elf_dyn_relocs
*)
688 bfd_alloc (htab
->elf
.dynobj
, amt
));
699 p
->pc_count
+= riscv_elf_rtype_to_howto (r_type
)->pc_relative
;
704 case R_RISCV_GNU_VTINHERIT
:
705 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
709 case R_RISCV_GNU_VTENTRY
:
710 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
723 riscv_elf_gc_mark_hook (asection
*sec
,
724 struct bfd_link_info
*info
,
725 Elf_Internal_Rela
*rel
,
726 struct elf_link_hash_entry
*h
,
727 Elf_Internal_Sym
*sym
)
730 switch (ELFNN_R_TYPE (rel
->r_info
))
732 case R_RISCV_GNU_VTINHERIT
:
733 case R_RISCV_GNU_VTENTRY
:
737 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
740 /* Find dynamic relocs for H that apply to read-only sections. */
743 readonly_dynrelocs (struct elf_link_hash_entry
*h
)
745 struct elf_dyn_relocs
*p
;
747 for (p
= riscv_elf_hash_entry (h
)->dyn_relocs
; p
!= NULL
; p
= p
->next
)
749 asection
*s
= p
->sec
->output_section
;
751 if (s
!= NULL
&& (s
->flags
& SEC_READONLY
) != 0)
757 /* Adjust a symbol defined by a dynamic object and referenced by a
758 regular object. The current definition is in some section of the
759 dynamic object, but we're not including those sections. We have to
760 change the definition to something the rest of the link can
764 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
765 struct elf_link_hash_entry
*h
)
767 struct riscv_elf_link_hash_table
*htab
;
768 struct riscv_elf_link_hash_entry
* eh
;
772 htab
= riscv_elf_hash_table (info
);
773 BFD_ASSERT (htab
!= NULL
);
775 dynobj
= htab
->elf
.dynobj
;
777 /* Make sure we know what is going on here. */
778 BFD_ASSERT (dynobj
!= NULL
780 || h
->type
== STT_GNU_IFUNC
784 && !h
->def_regular
)));
786 /* If this is a function, put it in the procedure linkage table. We
787 will fill in the contents of the procedure linkage table later
788 (although we could actually do it here). */
789 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
791 if (h
->plt
.refcount
<= 0
792 || SYMBOL_CALLS_LOCAL (info
, h
)
793 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
794 && h
->root
.type
== bfd_link_hash_undefweak
))
796 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
797 input file, but the symbol was never referred to by a dynamic
798 object, or if all references were garbage collected. In such
799 a case, we don't actually need to build a PLT entry. */
800 h
->plt
.offset
= (bfd_vma
) -1;
807 h
->plt
.offset
= (bfd_vma
) -1;
809 /* If this is a weak symbol, and there is a real definition, the
810 processor independent code will have arranged for us to see the
811 real definition first, and we can just use the same value. */
814 struct elf_link_hash_entry
*def
= weakdef (h
);
815 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
816 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
817 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
821 /* This is a reference to a symbol defined by a dynamic object which
822 is not a function. */
824 /* If we are creating a shared library, we must presume that the
825 only references to the symbol are via the global offset table.
826 For such cases we need not do anything here; the relocations will
827 be handled correctly by relocate_section. */
828 if (bfd_link_pic (info
))
831 /* If there are no references to this symbol that do not use the
832 GOT, we don't need to generate a copy reloc. */
836 /* If -z nocopyreloc was given, we won't generate them either. */
837 if (info
->nocopyreloc
)
843 /* If we don't find any dynamic relocs in read-only sections, then
844 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
845 if (!readonly_dynrelocs (h
))
851 /* We must allocate the symbol in our .dynbss section, which will
852 become part of the .bss section of the executable. There will be
853 an entry for this symbol in the .dynsym section. The dynamic
854 object will contain position independent code, so all references
855 from the dynamic object to this symbol will go through the global
856 offset table. The dynamic linker will use the .dynsym entry to
857 determine the address it must put in the global offset table, so
858 both the dynamic object and the regular object will refer to the
859 same memory location for the variable. */
861 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
862 to copy the initial value out of the dynamic object and into the
863 runtime process image. We need to remember the offset into the
864 .rel.bss section we are going to use. */
865 eh
= (struct riscv_elf_link_hash_entry
*) h
;
866 if (eh
->tls_type
& ~GOT_NORMAL
)
869 srel
= htab
->elf
.srelbss
;
871 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
873 s
= htab
->elf
.sdynrelro
;
874 srel
= htab
->elf
.sreldynrelro
;
878 s
= htab
->elf
.sdynbss
;
879 srel
= htab
->elf
.srelbss
;
881 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
883 srel
->size
+= sizeof (ElfNN_External_Rela
);
887 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
890 /* Allocate space in .plt, .got and associated reloc sections for
894 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
896 struct bfd_link_info
*info
;
897 struct riscv_elf_link_hash_table
*htab
;
898 struct riscv_elf_link_hash_entry
*eh
;
899 struct elf_dyn_relocs
*p
;
901 if (h
->root
.type
== bfd_link_hash_indirect
)
904 info
= (struct bfd_link_info
*) inf
;
905 htab
= riscv_elf_hash_table (info
);
906 BFD_ASSERT (htab
!= NULL
);
908 if (htab
->elf
.dynamic_sections_created
909 && h
->plt
.refcount
> 0)
911 /* Make sure this symbol is output as a dynamic symbol.
912 Undefined weak syms won't yet be marked as dynamic. */
916 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
920 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
922 asection
*s
= htab
->elf
.splt
;
925 s
->size
= PLT_HEADER_SIZE
;
927 h
->plt
.offset
= s
->size
;
929 /* Make room for this entry. */
930 s
->size
+= PLT_ENTRY_SIZE
;
932 /* We also need to make an entry in the .got.plt section. */
933 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
935 /* We also need to make an entry in the .rela.plt section. */
936 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
938 /* If this symbol is not defined in a regular file, and we are
939 not generating a shared library, then set the symbol to this
940 location in the .plt. This is required to make function
941 pointers compare as equal between the normal executable and
942 the shared library. */
943 if (! bfd_link_pic (info
)
946 h
->root
.u
.def
.section
= s
;
947 h
->root
.u
.def
.value
= h
->plt
.offset
;
952 h
->plt
.offset
= (bfd_vma
) -1;
958 h
->plt
.offset
= (bfd_vma
) -1;
962 if (h
->got
.refcount
> 0)
966 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
968 /* Make sure this symbol is output as a dynamic symbol.
969 Undefined weak syms won't yet be marked as dynamic. */
973 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
978 h
->got
.offset
= s
->size
;
979 dyn
= htab
->elf
.dynamic_sections_created
;
980 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
982 /* TLS_GD needs two dynamic relocs and two GOT slots. */
983 if (tls_type
& GOT_TLS_GD
)
985 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
986 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
989 /* TLS_IE needs one dynamic reloc and one GOT slot. */
990 if (tls_type
& GOT_TLS_IE
)
992 s
->size
+= RISCV_ELF_WORD_BYTES
;
993 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
998 s
->size
+= RISCV_ELF_WORD_BYTES
;
999 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
))
1000 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1004 h
->got
.offset
= (bfd_vma
) -1;
1006 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1007 if (eh
->dyn_relocs
== NULL
)
1010 /* In the shared -Bsymbolic case, discard space allocated for
1011 dynamic pc-relative relocs against symbols which turn out to be
1012 defined in regular objects. For the normal shared case, discard
1013 space for pc-relative relocs that have become local due to symbol
1014 visibility changes. */
1016 if (bfd_link_pic (info
))
1018 if (SYMBOL_CALLS_LOCAL (info
, h
))
1020 struct elf_dyn_relocs
**pp
;
1022 for (pp
= &eh
->dyn_relocs
; (p
= *pp
) != NULL
; )
1024 p
->count
-= p
->pc_count
;
1033 /* Also discard relocs on undefined weak syms with non-default
1035 if (eh
->dyn_relocs
!= NULL
1036 && h
->root
.type
== bfd_link_hash_undefweak
)
1038 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
1039 eh
->dyn_relocs
= NULL
;
1041 /* Make sure undefined weak symbols are output as a dynamic
1043 else if (h
->dynindx
== -1
1044 && !h
->forced_local
)
1046 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1053 /* For the non-shared case, discard space for relocs against
1054 symbols which turn out to need copy relocs or are not
1060 || (htab
->elf
.dynamic_sections_created
1061 && (h
->root
.type
== bfd_link_hash_undefweak
1062 || h
->root
.type
== bfd_link_hash_undefined
))))
1064 /* Make sure this symbol is output as a dynamic symbol.
1065 Undefined weak syms won't yet be marked as dynamic. */
1066 if (h
->dynindx
== -1
1067 && !h
->forced_local
)
1069 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1073 /* If that succeeded, we know we'll be keeping all the
1075 if (h
->dynindx
!= -1)
1079 eh
->dyn_relocs
= NULL
;
1084 /* Finally, allocate space. */
1085 for (p
= eh
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1087 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1088 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1094 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1095 read-only sections. */
1098 maybe_set_textrel (struct elf_link_hash_entry
*h
, void *info_p
)
1102 if (h
->root
.type
== bfd_link_hash_indirect
)
1105 sec
= readonly_dynrelocs (h
);
1108 struct bfd_link_info
*info
= (struct bfd_link_info
*) info_p
;
1110 info
->flags
|= DF_TEXTREL
;
1111 info
->callbacks
->minfo
1112 (_("%B: dynamic relocation against `%T' in read-only section `%A'\n"),
1113 sec
->owner
, h
->root
.root
.string
, sec
);
1115 /* Not an error, just cut short the traversal. */
1122 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1124 struct riscv_elf_link_hash_table
*htab
;
1129 htab
= riscv_elf_hash_table (info
);
1130 BFD_ASSERT (htab
!= NULL
);
1131 dynobj
= htab
->elf
.dynobj
;
1132 BFD_ASSERT (dynobj
!= NULL
);
1134 if (elf_hash_table (info
)->dynamic_sections_created
)
1136 /* Set the contents of the .interp section to the interpreter. */
1137 if (bfd_link_executable (info
) && !info
->nointerp
)
1139 s
= bfd_get_linker_section (dynobj
, ".interp");
1140 BFD_ASSERT (s
!= NULL
);
1141 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1142 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1146 /* Set up .got offsets for local syms, and space for local dynamic
1148 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1150 bfd_signed_vma
*local_got
;
1151 bfd_signed_vma
*end_local_got
;
1152 char *local_tls_type
;
1153 bfd_size_type locsymcount
;
1154 Elf_Internal_Shdr
*symtab_hdr
;
1157 if (! is_riscv_elf (ibfd
))
1160 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1162 struct elf_dyn_relocs
*p
;
1164 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1166 if (!bfd_is_abs_section (p
->sec
)
1167 && bfd_is_abs_section (p
->sec
->output_section
))
1169 /* Input section has been discarded, either because
1170 it is a copy of a linkonce section or due to
1171 linker script /DISCARD/, so we'll be discarding
1174 else if (p
->count
!= 0)
1176 srel
= elf_section_data (p
->sec
)->sreloc
;
1177 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1178 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1179 info
->flags
|= DF_TEXTREL
;
1184 local_got
= elf_local_got_refcounts (ibfd
);
1188 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1189 locsymcount
= symtab_hdr
->sh_info
;
1190 end_local_got
= local_got
+ locsymcount
;
1191 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1193 srel
= htab
->elf
.srelgot
;
1194 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1198 *local_got
= s
->size
;
1199 s
->size
+= RISCV_ELF_WORD_BYTES
;
1200 if (*local_tls_type
& GOT_TLS_GD
)
1201 s
->size
+= RISCV_ELF_WORD_BYTES
;
1202 if (bfd_link_pic (info
)
1203 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1204 srel
->size
+= sizeof (ElfNN_External_Rela
);
1207 *local_got
= (bfd_vma
) -1;
1211 /* Allocate global sym .plt and .got entries, and space for global
1212 sym dynamic relocs. */
1213 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1215 if (htab
->elf
.sgotplt
)
1217 struct elf_link_hash_entry
*got
;
1218 got
= elf_link_hash_lookup (elf_hash_table (info
),
1219 "_GLOBAL_OFFSET_TABLE_",
1220 FALSE
, FALSE
, FALSE
);
1222 /* Don't allocate .got.plt section if there are no GOT nor PLT
1223 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1225 || !got
->ref_regular_nonweak
)
1226 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1227 && (htab
->elf
.splt
== NULL
1228 || htab
->elf
.splt
->size
== 0)
1229 && (htab
->elf
.sgot
== NULL
1230 || (htab
->elf
.sgot
->size
1231 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1232 htab
->elf
.sgotplt
->size
= 0;
1235 /* The check_relocs and adjust_dynamic_symbol entry points have
1236 determined the sizes of the various dynamic sections. Allocate
1238 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1240 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1243 if (s
== htab
->elf
.splt
1244 || s
== htab
->elf
.sgot
1245 || s
== htab
->elf
.sgotplt
1246 || s
== htab
->elf
.sdynbss
1247 || s
== htab
->elf
.sdynrelro
)
1249 /* Strip this section if we don't need it; see the
1252 else if (strncmp (s
->name
, ".rela", 5) == 0)
1256 /* We use the reloc_count field as a counter if we need
1257 to copy relocs into the output file. */
1263 /* It's not one of our sections. */
1269 /* If we don't need this section, strip it from the
1270 output file. This is mostly to handle .rela.bss and
1271 .rela.plt. We must create both sections in
1272 create_dynamic_sections, because they must be created
1273 before the linker maps input sections to output
1274 sections. The linker does that before
1275 adjust_dynamic_symbol is called, and it is that
1276 function which decides whether anything needs to go
1277 into these sections. */
1278 s
->flags
|= SEC_EXCLUDE
;
1282 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1285 /* Allocate memory for the section contents. Zero the memory
1286 for the benefit of .rela.plt, which has 4 unused entries
1287 at the beginning, and we don't want garbage. */
1288 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1289 if (s
->contents
== NULL
)
1293 if (elf_hash_table (info
)->dynamic_sections_created
)
1295 /* Add some entries to the .dynamic section. We fill in the
1296 values later, in riscv_elf_finish_dynamic_sections, but we
1297 must add the entries now so that we get the correct size for
1298 the .dynamic section. The DT_DEBUG entry is filled in by the
1299 dynamic linker and used by the debugger. */
1300 #define add_dynamic_entry(TAG, VAL) \
1301 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1303 if (bfd_link_executable (info
))
1305 if (!add_dynamic_entry (DT_DEBUG
, 0))
1309 if (htab
->elf
.srelplt
->size
!= 0)
1311 if (!add_dynamic_entry (DT_PLTGOT
, 0)
1312 || !add_dynamic_entry (DT_PLTRELSZ
, 0)
1313 || !add_dynamic_entry (DT_PLTREL
, DT_RELA
)
1314 || !add_dynamic_entry (DT_JMPREL
, 0))
1318 if (!add_dynamic_entry (DT_RELA
, 0)
1319 || !add_dynamic_entry (DT_RELASZ
, 0)
1320 || !add_dynamic_entry (DT_RELAENT
, sizeof (ElfNN_External_Rela
)))
1323 /* If any dynamic relocs apply to a read-only section,
1324 then we need a DT_TEXTREL entry. */
1325 if ((info
->flags
& DF_TEXTREL
) == 0)
1326 elf_link_hash_traverse (&htab
->elf
, maybe_set_textrel
, info
);
1328 if (info
->flags
& DF_TEXTREL
)
1330 if (!add_dynamic_entry (DT_TEXTREL
, 0))
1334 #undef add_dynamic_entry
1340 #define DTP_OFFSET 0x800
1342 /* Return the relocation value for a TLS dtp-relative reloc. */
1345 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1347 /* If tls_sec is NULL, we should have signalled an error already. */
1348 if (elf_hash_table (info
)->tls_sec
== NULL
)
1350 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1353 /* Return the relocation value for a static TLS tp-relative relocation. */
1356 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1358 /* If tls_sec is NULL, we should have signalled an error already. */
1359 if (elf_hash_table (info
)->tls_sec
== NULL
)
1361 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1364 /* Return the global pointer's value, or 0 if it is not in use. */
1367 riscv_global_pointer_value (struct bfd_link_info
*info
)
1369 struct bfd_link_hash_entry
*h
;
1371 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1372 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1375 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1378 /* Emplace a static relocation. */
1380 static bfd_reloc_status_type
1381 perform_relocation (const reloc_howto_type
*howto
,
1382 const Elf_Internal_Rela
*rel
,
1384 asection
*input_section
,
1388 if (howto
->pc_relative
)
1389 value
-= sec_addr (input_section
) + rel
->r_offset
;
1390 value
+= rel
->r_addend
;
1392 switch (ELFNN_R_TYPE (rel
->r_info
))
1395 case R_RISCV_TPREL_HI20
:
1396 case R_RISCV_PCREL_HI20
:
1397 case R_RISCV_GOT_HI20
:
1398 case R_RISCV_TLS_GOT_HI20
:
1399 case R_RISCV_TLS_GD_HI20
:
1400 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1401 return bfd_reloc_overflow
;
1402 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1405 case R_RISCV_LO12_I
:
1406 case R_RISCV_GPREL_I
:
1407 case R_RISCV_TPREL_LO12_I
:
1408 case R_RISCV_TPREL_I
:
1409 case R_RISCV_PCREL_LO12_I
:
1410 value
= ENCODE_ITYPE_IMM (value
);
1413 case R_RISCV_LO12_S
:
1414 case R_RISCV_GPREL_S
:
1415 case R_RISCV_TPREL_LO12_S
:
1416 case R_RISCV_TPREL_S
:
1417 case R_RISCV_PCREL_LO12_S
:
1418 value
= ENCODE_STYPE_IMM (value
);
1422 case R_RISCV_CALL_PLT
:
1423 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1424 return bfd_reloc_overflow
;
1425 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1426 | (ENCODE_ITYPE_IMM (value
) << 32);
1430 if (!VALID_UJTYPE_IMM (value
))
1431 return bfd_reloc_overflow
;
1432 value
= ENCODE_UJTYPE_IMM (value
);
1435 case R_RISCV_BRANCH
:
1436 if (!VALID_SBTYPE_IMM (value
))
1437 return bfd_reloc_overflow
;
1438 value
= ENCODE_SBTYPE_IMM (value
);
1441 case R_RISCV_RVC_BRANCH
:
1442 if (!VALID_RVC_B_IMM (value
))
1443 return bfd_reloc_overflow
;
1444 value
= ENCODE_RVC_B_IMM (value
);
1447 case R_RISCV_RVC_JUMP
:
1448 if (!VALID_RVC_J_IMM (value
))
1449 return bfd_reloc_overflow
;
1450 value
= ENCODE_RVC_J_IMM (value
);
1453 case R_RISCV_RVC_LUI
:
1454 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1455 return bfd_reloc_overflow
;
1456 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1474 case R_RISCV_32_PCREL
:
1475 case R_RISCV_TLS_DTPREL32
:
1476 case R_RISCV_TLS_DTPREL64
:
1479 case R_RISCV_DELETE
:
1480 return bfd_reloc_ok
;
1483 return bfd_reloc_notsupported
;
1486 bfd_vma word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1487 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1488 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1490 return bfd_reloc_ok
;
1493 /* Remember all PC-relative high-part relocs we've encountered to help us
1494 later resolve the corresponding low-part relocs. */
1500 } riscv_pcrel_hi_reloc
;
1502 typedef struct riscv_pcrel_lo_reloc
1504 asection
* input_section
;
1505 struct bfd_link_info
* info
;
1506 reloc_howto_type
* howto
;
1507 const Elf_Internal_Rela
* reloc
;
1510 bfd_byte
* contents
;
1511 struct riscv_pcrel_lo_reloc
* next
;
1512 } riscv_pcrel_lo_reloc
;
1517 riscv_pcrel_lo_reloc
*lo_relocs
;
1518 } riscv_pcrel_relocs
;
1521 riscv_pcrel_reloc_hash (const void *entry
)
1523 const riscv_pcrel_hi_reloc
*e
= entry
;
1524 return (hashval_t
)(e
->address
>> 2);
1528 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1530 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1531 return e1
->address
== e2
->address
;
1535 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1538 p
->lo_relocs
= NULL
;
1539 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1540 riscv_pcrel_reloc_eq
, free
);
1541 return p
->hi_relocs
!= NULL
;
1545 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1547 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1551 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1556 htab_delete (p
->hi_relocs
);
1560 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1561 struct bfd_link_info
*info
,
1565 const reloc_howto_type
*howto
,
1568 /* We may need to reference low addreses in PC-relative modes even when the
1569 * PC is far away from these addresses. For example, undefweak references
1570 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1571 * addresses that we can link PC-relative programs at, the linker can't
1572 * actually relocate references to those symbols. In order to allow these
1573 * programs to work we simply convert the PC-relative auipc sequences to
1574 * 0-relative lui sequences. */
1575 if (bfd_link_pic (info
))
1578 /* If it's possible to reference the symbol using auipc we do so, as that's
1579 * more in the spirit of the PC-relative relocations we're processing. */
1580 bfd_vma offset
= addr
- pc
;
1581 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1584 /* If it's impossible to reference this with a LUI-based offset then don't
1585 * bother to convert it at all so users still see the PC-relative relocation
1586 * in the truncation message. */
1587 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1590 rel
->r_info
= ELFNN_R_INFO(addr
, R_RISCV_HI20
);
1592 bfd_vma insn
= bfd_get(howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1593 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1594 bfd_put(howto
->bitsize
, input_bfd
, insn
, contents
+ rel
->r_offset
);
1599 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1600 bfd_vma value
, bfd_boolean absolute
)
1602 bfd_vma offset
= absolute
? value
: value
- addr
;
1603 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1604 riscv_pcrel_hi_reloc
**slot
=
1605 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1607 BFD_ASSERT (*slot
== NULL
);
1608 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1616 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1617 asection
*input_section
,
1618 struct bfd_link_info
*info
,
1619 reloc_howto_type
*howto
,
1620 const Elf_Internal_Rela
*reloc
,
1625 riscv_pcrel_lo_reloc
*entry
;
1626 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1629 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1630 name
, contents
, p
->lo_relocs
};
1631 p
->lo_relocs
= entry
;
1636 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1638 riscv_pcrel_lo_reloc
*r
;
1640 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1642 bfd
*input_bfd
= r
->input_section
->owner
;
1644 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1645 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1648 ((*r
->info
->callbacks
->reloc_overflow
)
1649 (r
->info
, NULL
, r
->name
, r
->howto
->name
, (bfd_vma
) 0,
1650 input_bfd
, r
->input_section
, r
->reloc
->r_offset
));
1654 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1655 input_bfd
, r
->contents
);
1661 /* Relocate a RISC-V ELF section.
1663 The RELOCATE_SECTION function is called by the new ELF backend linker
1664 to handle the relocations for a section.
1666 The relocs are always passed as Rela structures.
1668 This function is responsible for adjusting the section contents as
1669 necessary, and (if generating a relocatable output file) adjusting
1670 the reloc addend as necessary.
1672 This function does not have to worry about setting the reloc
1673 address or the reloc symbol index.
1675 LOCAL_SYMS is a pointer to the swapped in local symbols.
1677 LOCAL_SECTIONS is an array giving the section in the input file
1678 corresponding to the st_shndx field of each local symbol.
1680 The global hash table entry for the global symbols can be found
1681 via elf_sym_hashes (input_bfd).
1683 When generating relocatable output, this function must handle
1684 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1685 going to be the section symbol corresponding to the output
1686 section, which means that the addend must be adjusted
1690 riscv_elf_relocate_section (bfd
*output_bfd
,
1691 struct bfd_link_info
*info
,
1693 asection
*input_section
,
1695 Elf_Internal_Rela
*relocs
,
1696 Elf_Internal_Sym
*local_syms
,
1697 asection
**local_sections
)
1699 Elf_Internal_Rela
*rel
;
1700 Elf_Internal_Rela
*relend
;
1701 riscv_pcrel_relocs pcrel_relocs
;
1702 bfd_boolean ret
= FALSE
;
1703 asection
*sreloc
= elf_section_data (input_section
)->sreloc
;
1704 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1705 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1706 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1707 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1708 bfd_boolean absolute
;
1710 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1713 relend
= relocs
+ input_section
->reloc_count
;
1714 for (rel
= relocs
; rel
< relend
; rel
++)
1716 unsigned long r_symndx
;
1717 struct elf_link_hash_entry
*h
;
1718 Elf_Internal_Sym
*sym
;
1721 bfd_reloc_status_type r
= bfd_reloc_ok
;
1723 bfd_vma off
, ie_off
;
1724 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1725 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1726 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1727 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (r_type
);
1728 const char *msg
= NULL
;
1730 if (r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1733 /* This is a final link. */
1734 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1738 unresolved_reloc
= FALSE
;
1739 if (r_symndx
< symtab_hdr
->sh_info
)
1741 sym
= local_syms
+ r_symndx
;
1742 sec
= local_sections
[r_symndx
];
1743 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1747 bfd_boolean warned
, ignored
;
1749 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1750 r_symndx
, symtab_hdr
, sym_hashes
,
1752 unresolved_reloc
, warned
, ignored
);
1755 /* To avoid generating warning messages about truncated
1756 relocations, set the relocation's address to be the same as
1757 the start of this section. */
1758 if (input_section
->output_section
!= NULL
)
1759 relocation
= input_section
->output_section
->vma
;
1765 if (sec
!= NULL
&& discarded_section (sec
))
1766 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1767 rel
, 1, relend
, howto
, 0, contents
);
1769 if (bfd_link_relocatable (info
))
1773 name
= h
->root
.root
.string
;
1776 name
= (bfd_elf_string_from_elf_section
1777 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1778 if (name
== NULL
|| *name
== '\0')
1779 name
= bfd_section_name (input_bfd
, sec
);
1786 case R_RISCV_TPREL_ADD
:
1788 case R_RISCV_JUMP_SLOT
:
1789 case R_RISCV_RELATIVE
:
1790 /* These require nothing of us at all. */
1794 case R_RISCV_BRANCH
:
1795 case R_RISCV_RVC_BRANCH
:
1796 case R_RISCV_RVC_LUI
:
1797 case R_RISCV_LO12_I
:
1798 case R_RISCV_LO12_S
:
1803 case R_RISCV_32_PCREL
:
1804 case R_RISCV_DELETE
:
1805 /* These require no special handling beyond perform_relocation. */
1808 case R_RISCV_GOT_HI20
:
1811 bfd_boolean dyn
, pic
;
1813 off
= h
->got
.offset
;
1814 BFD_ASSERT (off
!= (bfd_vma
) -1);
1815 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1816 pic
= bfd_link_pic (info
);
1818 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
1819 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
1821 /* This is actually a static link, or it is a
1822 -Bsymbolic link and the symbol is defined
1823 locally, or the symbol was forced to be local
1824 because of a version file. We must initialize
1825 this entry in the global offset table. Since the
1826 offset must always be a multiple of the word size,
1827 we use the least significant bit to record whether
1828 we have initialized it already.
1830 When doing a dynamic link, we create a .rela.got
1831 relocation entry to initialize the value. This
1832 is done in the finish_dynamic_symbol routine. */
1837 bfd_put_NN (output_bfd
, relocation
,
1838 htab
->elf
.sgot
->contents
+ off
);
1843 unresolved_reloc
= FALSE
;
1847 BFD_ASSERT (local_got_offsets
!= NULL
1848 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
1850 off
= local_got_offsets
[r_symndx
];
1852 /* The offset must always be a multiple of the word size.
1853 So, we can use the least significant bit to record
1854 whether we have already processed this entry. */
1859 if (bfd_link_pic (info
))
1862 Elf_Internal_Rela outrel
;
1864 /* We need to generate a R_RISCV_RELATIVE reloc
1865 for the dynamic linker. */
1866 s
= htab
->elf
.srelgot
;
1867 BFD_ASSERT (s
!= NULL
);
1869 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
1871 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
1872 outrel
.r_addend
= relocation
;
1874 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
1877 bfd_put_NN (output_bfd
, relocation
,
1878 htab
->elf
.sgot
->contents
+ off
);
1879 local_got_offsets
[r_symndx
] |= 1;
1882 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
1883 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1890 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1891 howto
= riscv_elf_rtype_to_howto (r_type
);
1892 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1893 relocation
, absolute
))
1894 r
= bfd_reloc_overflow
;
1902 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1903 contents
+ rel
->r_offset
);
1904 relocation
= old_value
+ relocation
;
1914 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
1915 contents
+ rel
->r_offset
);
1916 relocation
= old_value
- relocation
;
1920 case R_RISCV_CALL_PLT
:
1923 case R_RISCV_RVC_JUMP
:
1924 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
1926 /* Refer to the PLT entry. */
1927 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
1928 unresolved_reloc
= FALSE
;
1932 case R_RISCV_TPREL_HI20
:
1933 relocation
= tpoff (info
, relocation
);
1936 case R_RISCV_TPREL_LO12_I
:
1937 case R_RISCV_TPREL_LO12_S
:
1938 relocation
= tpoff (info
, relocation
);
1941 case R_RISCV_TPREL_I
:
1942 case R_RISCV_TPREL_S
:
1943 relocation
= tpoff (info
, relocation
);
1944 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
1946 /* We can use tp as the base register. */
1947 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1948 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1949 insn
|= X_TP
<< OP_SH_RS1
;
1950 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1953 r
= bfd_reloc_overflow
;
1956 case R_RISCV_GPREL_I
:
1957 case R_RISCV_GPREL_S
:
1959 bfd_vma gp
= riscv_global_pointer_value (info
);
1960 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
1961 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
1963 /* We can use x0 or gp as the base register. */
1964 bfd_vma insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1965 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
1968 rel
->r_addend
-= gp
;
1969 insn
|= X_GP
<< OP_SH_RS1
;
1971 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
1974 r
= bfd_reloc_overflow
;
1978 case R_RISCV_PCREL_HI20
:
1979 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
1986 r_type
= ELFNN_R_TYPE (rel
->r_info
);
1987 howto
= riscv_elf_rtype_to_howto (r_type
);
1988 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
1989 relocation
+ rel
->r_addend
,
1991 r
= bfd_reloc_overflow
;
1994 case R_RISCV_PCREL_LO12_I
:
1995 case R_RISCV_PCREL_LO12_S
:
1996 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
1997 howto
, rel
, relocation
, name
,
2000 r
= bfd_reloc_overflow
;
2003 case R_RISCV_TLS_DTPREL32
:
2004 case R_RISCV_TLS_DTPREL64
:
2005 relocation
= dtpoff (info
, relocation
);
2010 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2013 if ((bfd_link_pic (info
)
2015 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2016 || h
->root
.type
!= bfd_link_hash_undefweak
)
2017 && (! howto
->pc_relative
2018 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2019 || (!bfd_link_pic (info
)
2025 || h
->root
.type
== bfd_link_hash_undefweak
2026 || h
->root
.type
== bfd_link_hash_undefined
)))
2028 Elf_Internal_Rela outrel
;
2029 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2031 /* When generating a shared object, these relocations
2032 are copied into the output file to be resolved at run
2036 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2038 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2039 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2040 outrel
.r_offset
+= sec_addr (input_section
);
2042 if (skip_dynamic_relocation
)
2043 memset (&outrel
, 0, sizeof outrel
);
2044 else if (h
!= NULL
&& h
->dynindx
!= -1
2045 && !(bfd_link_pic (info
)
2046 && SYMBOLIC_BIND (info
, h
)
2049 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2050 outrel
.r_addend
= rel
->r_addend
;
2054 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2055 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2058 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2059 if (skip_static_relocation
)
2064 case R_RISCV_TLS_GOT_HI20
:
2068 case R_RISCV_TLS_GD_HI20
:
2071 off
= h
->got
.offset
;
2076 off
= local_got_offsets
[r_symndx
];
2077 local_got_offsets
[r_symndx
] |= 1;
2080 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2081 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2082 /* If this symbol is referenced by both GD and IE TLS, the IE
2083 reference's GOT slot follows the GD reference's slots. */
2085 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2086 ie_off
= 2 * GOT_ENTRY_SIZE
;
2092 Elf_Internal_Rela outrel
;
2094 bfd_boolean need_relocs
= FALSE
;
2096 if (htab
->elf
.srelgot
== NULL
)
2101 bfd_boolean dyn
, pic
;
2102 dyn
= htab
->elf
.dynamic_sections_created
;
2103 pic
= bfd_link_pic (info
);
2105 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2106 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2110 /* The GOT entries have not been initialized yet. Do it
2111 now, and emit any relocations. */
2112 if ((bfd_link_pic (info
) || indx
!= 0)
2114 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2115 || h
->root
.type
!= bfd_link_hash_undefweak
))
2118 if (tls_type
& GOT_TLS_GD
)
2122 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2123 outrel
.r_addend
= 0;
2124 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2125 bfd_put_NN (output_bfd
, 0,
2126 htab
->elf
.sgot
->contents
+ off
);
2127 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2130 BFD_ASSERT (! unresolved_reloc
);
2131 bfd_put_NN (output_bfd
,
2132 dtpoff (info
, relocation
),
2133 (htab
->elf
.sgot
->contents
+ off
+
2134 RISCV_ELF_WORD_BYTES
));
2138 bfd_put_NN (output_bfd
, 0,
2139 (htab
->elf
.sgot
->contents
+ off
+
2140 RISCV_ELF_WORD_BYTES
));
2141 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2142 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2143 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2148 /* If we are not emitting relocations for a
2149 general dynamic reference, then we must be in a
2150 static link or an executable link with the
2151 symbol binding locally. Mark it as belonging
2152 to module 1, the executable. */
2153 bfd_put_NN (output_bfd
, 1,
2154 htab
->elf
.sgot
->contents
+ off
);
2155 bfd_put_NN (output_bfd
,
2156 dtpoff (info
, relocation
),
2157 (htab
->elf
.sgot
->contents
+ off
+
2158 RISCV_ELF_WORD_BYTES
));
2162 if (tls_type
& GOT_TLS_IE
)
2166 bfd_put_NN (output_bfd
, 0,
2167 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2168 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2170 outrel
.r_addend
= 0;
2172 outrel
.r_addend
= tpoff (info
, relocation
);
2173 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2174 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2178 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2179 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2184 BFD_ASSERT (off
< (bfd_vma
) -2);
2185 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2186 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2188 r
= bfd_reloc_overflow
;
2189 unresolved_reloc
= FALSE
;
2193 r
= bfd_reloc_notsupported
;
2196 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2197 because such sections are not SEC_ALLOC and thus ld.so will
2198 not process them. */
2199 if (unresolved_reloc
2200 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2202 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2203 rel
->r_offset
) != (bfd_vma
) -1)
2205 (*_bfd_error_handler
)
2206 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
2211 h
->root
.root
.string
);
2215 if (r
== bfd_reloc_ok
)
2216 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2217 input_bfd
, contents
);
2224 case bfd_reloc_overflow
:
2225 info
->callbacks
->reloc_overflow
2226 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2227 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2230 case bfd_reloc_undefined
:
2231 info
->callbacks
->undefined_symbol
2232 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2236 case bfd_reloc_outofrange
:
2237 msg
= _("internal error: out of range error");
2240 case bfd_reloc_notsupported
:
2241 msg
= _("internal error: unsupported relocation error");
2244 case bfd_reloc_dangerous
:
2245 msg
= _("internal error: dangerous relocation");
2249 msg
= _("internal error: unknown error");
2254 info
->callbacks
->warning
2255 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
2256 /* We already reported the error via a callback, so don't try to report
2257 it again by returning false. That leads to spurious errors. */
2262 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2264 riscv_free_pcrel_relocs (&pcrel_relocs
);
2268 /* Finish up dynamic symbol handling. We set the contents of various
2269 dynamic sections here. */
2272 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2273 struct bfd_link_info
*info
,
2274 struct elf_link_hash_entry
*h
,
2275 Elf_Internal_Sym
*sym
)
2277 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2278 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2280 if (h
->plt
.offset
!= (bfd_vma
) -1)
2282 /* We've decided to create a PLT entry for this symbol. */
2284 bfd_vma i
, header_address
, plt_idx
, got_address
;
2285 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2286 Elf_Internal_Rela rela
;
2288 BFD_ASSERT (h
->dynindx
!= -1);
2290 /* Calculate the address of the PLT header. */
2291 header_address
= sec_addr (htab
->elf
.splt
);
2293 /* Calculate the index of the entry. */
2294 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2296 /* Calculate the address of the .got.plt entry. */
2297 got_address
= riscv_elf_got_plt_val (plt_idx
, info
);
2299 /* Find out where the .plt entry should go. */
2300 loc
= htab
->elf
.splt
->contents
+ h
->plt
.offset
;
2302 /* Fill in the PLT entry itself. */
2303 riscv_make_plt_entry (got_address
, header_address
+ h
->plt
.offset
,
2305 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2306 bfd_put_32 (output_bfd
, plt_entry
[i
], loc
+ 4*i
);
2308 /* Fill in the initial value of the .got.plt entry. */
2309 loc
= htab
->elf
.sgotplt
->contents
2310 + (got_address
- sec_addr (htab
->elf
.sgotplt
));
2311 bfd_put_NN (output_bfd
, sec_addr (htab
->elf
.splt
), loc
);
2313 /* Fill in the entry in the .rela.plt section. */
2314 rela
.r_offset
= got_address
;
2316 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2318 loc
= htab
->elf
.srelplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2319 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2321 if (!h
->def_regular
)
2323 /* Mark the symbol as undefined, rather than as defined in
2324 the .plt section. Leave the value alone. */
2325 sym
->st_shndx
= SHN_UNDEF
;
2326 /* If the symbol is weak, we do need to clear the value.
2327 Otherwise, the PLT entry would provide a definition for
2328 the symbol even if the symbol wasn't defined anywhere,
2329 and so the symbol would never be NULL. */
2330 if (!h
->ref_regular_nonweak
)
2335 if (h
->got
.offset
!= (bfd_vma
) -1
2336 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
2340 Elf_Internal_Rela rela
;
2342 /* This symbol has an entry in the GOT. Set it up. */
2344 sgot
= htab
->elf
.sgot
;
2345 srela
= htab
->elf
.srelgot
;
2346 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2348 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2350 /* If this is a -Bsymbolic link, and the symbol is defined
2351 locally, we just want to emit a RELATIVE reloc. Likewise if
2352 the symbol was forced to be local because of a version file.
2353 The entry in the global offset table will already have been
2354 initialized in the relocate_section function. */
2355 if (bfd_link_pic (info
)
2356 && (info
->symbolic
|| h
->dynindx
== -1)
2359 asection
*sec
= h
->root
.u
.def
.section
;
2360 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2361 rela
.r_addend
= (h
->root
.u
.def
.value
2362 + sec
->output_section
->vma
2363 + sec
->output_offset
);
2367 BFD_ASSERT (h
->dynindx
!= -1);
2368 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
2372 bfd_put_NN (output_bfd
, 0,
2373 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
2374 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
2379 Elf_Internal_Rela rela
;
2382 /* This symbols needs a copy reloc. Set it up. */
2383 BFD_ASSERT (h
->dynindx
!= -1);
2385 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
2386 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
2388 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
2389 s
= htab
->elf
.sreldynrelro
;
2391 s
= htab
->elf
.srelbss
;
2392 riscv_elf_append_rela (output_bfd
, s
, &rela
);
2395 /* Mark some specially defined symbols as absolute. */
2396 if (h
== htab
->elf
.hdynamic
2397 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
2398 sym
->st_shndx
= SHN_ABS
;
2403 /* Finish up the dynamic sections. */
2406 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
2407 bfd
*dynobj
, asection
*sdyn
)
2409 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2410 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2411 size_t dynsize
= bed
->s
->sizeof_dyn
;
2412 bfd_byte
*dyncon
, *dynconend
;
2414 dynconend
= sdyn
->contents
+ sdyn
->size
;
2415 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
2417 Elf_Internal_Dyn dyn
;
2420 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
2425 s
= htab
->elf
.sgotplt
;
2426 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2429 s
= htab
->elf
.srelplt
;
2430 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2433 s
= htab
->elf
.srelplt
;
2434 dyn
.d_un
.d_val
= s
->size
;
2440 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2446 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
2447 struct bfd_link_info
*info
)
2451 struct riscv_elf_link_hash_table
*htab
;
2453 htab
= riscv_elf_hash_table (info
);
2454 BFD_ASSERT (htab
!= NULL
);
2455 dynobj
= htab
->elf
.dynobj
;
2457 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2459 if (elf_hash_table (info
)->dynamic_sections_created
)
2464 splt
= htab
->elf
.splt
;
2465 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
2467 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
2472 /* Fill in the head and tail entries in the procedure linkage table. */
2476 uint32_t plt_header
[PLT_HEADER_INSNS
];
2477 riscv_make_plt_header (sec_addr (htab
->elf
.sgotplt
),
2478 sec_addr (splt
), plt_header
);
2480 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
2481 bfd_put_32 (output_bfd
, plt_header
[i
], splt
->contents
+ 4*i
);
2483 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
2488 if (htab
->elf
.sgotplt
)
2490 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
2492 if (bfd_is_abs_section (output_section
))
2494 (*_bfd_error_handler
)
2495 (_("discarded output section: `%A'"), htab
->elf
.sgotplt
);
2499 if (htab
->elf
.sgotplt
->size
> 0)
2501 /* Write the first two entries in .got.plt, needed for the dynamic
2503 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
2504 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
2505 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
2508 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2513 asection
*output_section
= htab
->elf
.sgot
->output_section
;
2515 if (htab
->elf
.sgot
->size
> 0)
2517 /* Set the first entry in the global offset table to the address of
2518 the dynamic section. */
2519 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
2520 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
2523 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
2529 /* Return address for Ith PLT stub in section PLT, for relocation REL
2530 or (bfd_vma) -1 if it should not be included. */
2533 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
2534 const arelent
*rel ATTRIBUTE_UNUSED
)
2536 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
2539 static enum elf_reloc_type_class
2540 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2541 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2542 const Elf_Internal_Rela
*rela
)
2544 switch (ELFNN_R_TYPE (rela
->r_info
))
2546 case R_RISCV_RELATIVE
:
2547 return reloc_class_relative
;
2548 case R_RISCV_JUMP_SLOT
:
2549 return reloc_class_plt
;
2551 return reloc_class_copy
;
2553 return reloc_class_normal
;
2557 /* Merge backend specific data from an object file to the output
2558 object file when linking. */
2561 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
2563 bfd
*obfd
= info
->output_bfd
;
2564 flagword new_flags
= elf_elfheader (ibfd
)->e_flags
;
2565 flagword old_flags
= elf_elfheader (obfd
)->e_flags
;
2567 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
2570 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
2572 (*_bfd_error_handler
)
2573 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2574 " target emulation `%s' does not match `%s'"),
2575 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
2579 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
2582 if (! elf_flags_init (obfd
))
2584 elf_flags_init (obfd
) = TRUE
;
2585 elf_elfheader (obfd
)->e_flags
= new_flags
;
2589 /* Disallow linking different float ABIs. */
2590 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
2592 (*_bfd_error_handler
)
2593 (_("%B: can't link hard-float modules with soft-float modules"), ibfd
);
2597 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2598 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
2603 bfd_set_error (bfd_error_bad_value
);
2607 /* Delete some bytes from a section while relaxing. */
2610 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
2611 struct bfd_link_info
*link_info
)
2613 unsigned int i
, symcount
;
2614 bfd_vma toaddr
= sec
->size
;
2615 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
2616 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2617 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
2618 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
2619 bfd_byte
*contents
= data
->this_hdr
.contents
;
2621 /* Actually delete the bytes. */
2623 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
2625 /* Adjust the location of all of the relocs. Note that we need not
2626 adjust the addends, since all PC-relative references must be against
2627 symbols, which we will adjust below. */
2628 for (i
= 0; i
< sec
->reloc_count
; i
++)
2629 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
2630 data
->relocs
[i
].r_offset
-= count
;
2632 /* Adjust the local symbols defined in this section. */
2633 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
2635 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
2636 if (sym
->st_shndx
== sec_shndx
)
2638 /* If the symbol is in the range of memory we just moved, we
2639 have to adjust its value. */
2640 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
2641 sym
->st_value
-= count
;
2643 /* If the symbol *spans* the bytes we just deleted (i.e. its
2644 *end* is in the moved bytes but its *start* isn't), then we
2645 must adjust its size. */
2646 if (sym
->st_value
<= addr
2647 && sym
->st_value
+ sym
->st_size
> addr
2648 && sym
->st_value
+ sym
->st_size
<= toaddr
)
2649 sym
->st_size
-= count
;
2653 /* Now adjust the global symbols defined in this section. */
2654 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
2655 - symtab_hdr
->sh_info
);
2657 for (i
= 0; i
< symcount
; i
++)
2659 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
2661 /* The '--wrap SYMBOL' option is causing a pain when the object file,
2662 containing the definition of __wrap_SYMBOL, includes a direct
2663 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
2664 the same symbol (which is __wrap_SYMBOL), but still exist as two
2665 different symbols in 'sym_hashes', we don't want to adjust
2666 the global symbol __wrap_SYMBOL twice.
2667 This check is only relevant when symbols are being wrapped. */
2668 if (link_info
->wrap_hash
!= NULL
)
2670 struct elf_link_hash_entry
**cur_sym_hashes
;
2672 /* Loop only over the symbols which have already been checked. */
2673 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
2676 /* If the current symbol is identical to 'sym_hash', that means
2677 the symbol was already adjusted (or at least checked). */
2678 if (*cur_sym_hashes
== sym_hash
)
2681 /* Don't adjust the symbol again. */
2682 if (cur_sym_hashes
< &sym_hashes
[i
])
2686 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2687 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
2688 && sym_hash
->root
.u
.def
.section
== sec
)
2690 /* As above, adjust the value if needed. */
2691 if (sym_hash
->root
.u
.def
.value
> addr
2692 && sym_hash
->root
.u
.def
.value
<= toaddr
)
2693 sym_hash
->root
.u
.def
.value
-= count
;
2695 /* As above, adjust the size if needed. */
2696 if (sym_hash
->root
.u
.def
.value
<= addr
2697 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
2698 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
2699 sym_hash
->size
-= count
;
2706 /* A second format for recording PC-relative hi relocations. This stores the
2707 information required to relax them to GP-relative addresses. */
2709 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
2710 struct riscv_pcgp_hi_reloc
2717 riscv_pcgp_hi_reloc
*next
;
2720 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
2721 struct riscv_pcgp_lo_reloc
2724 riscv_pcgp_lo_reloc
*next
;
2729 riscv_pcgp_hi_reloc
*hi
;
2730 riscv_pcgp_lo_reloc
*lo
;
2731 } riscv_pcgp_relocs
;
2734 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
2742 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
2743 bfd
*abfd ATTRIBUTE_UNUSED
,
2744 asection
*sec ATTRIBUTE_UNUSED
)
2746 riscv_pcgp_hi_reloc
*c
;
2747 riscv_pcgp_lo_reloc
*l
;
2749 for (c
= p
->hi
; c
!= NULL
;)
2751 riscv_pcgp_hi_reloc
*next
= c
->next
;
2756 for (l
= p
->lo
; l
!= NULL
;)
2758 riscv_pcgp_lo_reloc
*next
= l
->next
;
2765 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
2766 bfd_vma hi_addend
, bfd_vma hi_addr
,
2767 unsigned hi_sym
, asection
*sym_sec
)
2769 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof(*new));
2772 new->hi_sec_off
= hi_sec_off
;
2773 new->hi_addend
= hi_addend
;
2774 new->hi_addr
= hi_addr
;
2775 new->hi_sym
= hi_sym
;
2776 new->sym_sec
= sym_sec
;
2782 static riscv_pcgp_hi_reloc
*
2783 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2785 riscv_pcgp_hi_reloc
*c
;
2787 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2788 if (c
->hi_sec_off
== hi_sec_off
)
2794 riscv_delete_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2796 bfd_boolean out
= FALSE
;
2797 riscv_pcgp_hi_reloc
*c
;
2799 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2800 if (c
->hi_sec_off
== hi_sec_off
)
2807 riscv_use_pcgp_hi_reloc(riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2809 bfd_boolean out
= FALSE
;
2810 riscv_pcgp_hi_reloc
*c
;
2812 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
2813 if (c
->hi_sec_off
== hi_sec_off
)
2820 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2822 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof(*new));
2825 new->hi_sec_off
= hi_sec_off
;
2832 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
2834 riscv_pcgp_lo_reloc
*c
;
2836 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
2837 if (c
->hi_sec_off
== hi_sec_off
)
2843 riscv_delete_pcgp_lo_reloc (riscv_pcgp_relocs
*p ATTRIBUTE_UNUSED
,
2844 bfd_vma lo_sec_off ATTRIBUTE_UNUSED
,
2845 size_t bytes ATTRIBUTE_UNUSED
)
2850 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
2851 struct bfd_link_info
*,
2852 Elf_Internal_Rela
*,
2853 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
2854 riscv_pcgp_relocs
*);
2856 /* Relax AUIPC + JALR into JAL. */
2859 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
2860 struct bfd_link_info
*link_info
,
2861 Elf_Internal_Rela
*rel
,
2863 bfd_vma max_alignment
,
2864 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
2866 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
2868 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
2869 bfd_signed_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
2870 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/2) < RISCV_IMM_REACH
;
2871 bfd_vma auipc
, jalr
;
2872 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
2874 /* If the call crosses section boundaries, an alignment directive could
2875 cause the PC-relative offset to later increase. */
2876 if (VALID_UJTYPE_IMM (foff
) && sym_sec
->output_section
!= sec
->output_section
)
2877 foff
+= (foff
< 0 ? -max_alignment
: max_alignment
);
2879 /* See if this function call can be shortened. */
2880 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
2883 /* Shorten the function call. */
2884 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
2886 auipc
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
2887 jalr
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
+ 4);
2888 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
2889 rvc
= rvc
&& VALID_RVC_J_IMM (foff
) && ARCH_SIZE
== 32;
2891 if (rvc
&& (rd
== 0 || rd
== X_RA
))
2893 /* Relax to C.J[AL] rd, addr. */
2894 r_type
= R_RISCV_RVC_JUMP
;
2895 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
2898 else if (VALID_UJTYPE_IMM (foff
))
2900 /* Relax to JAL rd, addr. */
2901 r_type
= R_RISCV_JAL
;
2902 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
2904 else /* near_zero */
2906 /* Relax to JALR rd, x0, addr. */
2907 r_type
= R_RISCV_LO12_I
;
2908 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
2911 /* Replace the R_RISCV_CALL reloc. */
2912 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
2913 /* Replace the AUIPC. */
2914 bfd_put (8 * len
, abfd
, auipc
, contents
+ rel
->r_offset
);
2916 /* Delete unnecessary JALR. */
2918 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
2922 /* Traverse all output sections and return the max alignment. */
2925 _bfd_riscv_get_max_alignment (asection
*sec
)
2927 unsigned int max_alignment_power
= 0;
2930 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
2932 if (o
->alignment_power
> max_alignment_power
)
2933 max_alignment_power
= o
->alignment_power
;
2936 return (bfd_vma
) 1 << max_alignment_power
;
2939 /* Relax non-PIC global variable references. */
2942 _bfd_riscv_relax_lui (bfd
*abfd
,
2945 struct bfd_link_info
*link_info
,
2946 Elf_Internal_Rela
*rel
,
2948 bfd_vma max_alignment
,
2949 bfd_vma reserve_size
,
2951 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
2953 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
2954 bfd_vma gp
= riscv_global_pointer_value (link_info
);
2955 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
2957 /* Mergeable symbols and code might later move out of range. */
2958 if (sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
2961 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
2965 /* If gp and the symbol are in the same output section, then
2966 consider only that section's alignment. */
2967 struct bfd_link_hash_entry
*h
=
2968 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
2970 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
)
2971 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
2974 /* Is the reference in range of x0 or gp?
2975 Valid gp range conservatively because of alignment issue. */
2976 if (VALID_ITYPE_IMM (symval
)
2978 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
2980 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
)))
2982 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
2983 switch (ELFNN_R_TYPE (rel
->r_info
))
2985 case R_RISCV_LO12_I
:
2986 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
2989 case R_RISCV_LO12_S
:
2990 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
2994 /* We can delete the unnecessary LUI and reloc. */
2995 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
2997 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
3005 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3006 account for this assuming page alignment at worst. */
3008 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
3009 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
3010 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
+ ELF_MAXPAGESIZE
)))
3012 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3013 bfd_vma lui
= bfd_get_32 (abfd
, contents
+ rel
->r_offset
);
3014 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
3015 if (rd
== 0 || rd
== X_SP
)
3018 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
3019 bfd_put_32 (abfd
, lui
, contents
+ rel
->r_offset
);
3021 /* Replace the R_RISCV_HI20 reloc. */
3022 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
3025 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
3032 /* Relax non-PIC TLS references. */
3035 _bfd_riscv_relax_tls_le (bfd
*abfd
,
3037 asection
*sym_sec ATTRIBUTE_UNUSED
,
3038 struct bfd_link_info
*link_info
,
3039 Elf_Internal_Rela
*rel
,
3041 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3042 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3044 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
)
3046 /* See if this symbol is in range of tp. */
3047 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
3050 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3051 switch (ELFNN_R_TYPE (rel
->r_info
))
3053 case R_RISCV_TPREL_LO12_I
:
3054 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
3057 case R_RISCV_TPREL_LO12_S
:
3058 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
3061 case R_RISCV_TPREL_HI20
:
3062 case R_RISCV_TPREL_ADD
:
3063 /* We can delete the unnecessary instruction and reloc. */
3064 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3066 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
3073 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3076 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
3078 struct bfd_link_info
*link_info
,
3079 Elf_Internal_Rela
*rel
,
3081 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3082 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3083 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3084 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
)
3086 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
3087 bfd_vma alignment
= 1, pos
;
3088 while (alignment
<= rel
->r_addend
)
3091 symval
-= rel
->r_addend
;
3092 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
3093 bfd_vma nop_bytes
= aligned_addr
- symval
;
3095 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3096 sec
->sec_flg0
= TRUE
;
3098 /* Make sure there are enough NOPs to actually achieve the alignment. */
3099 if (rel
->r_addend
< nop_bytes
)
3101 (*_bfd_error_handler
)
3102 (_("%B(%A+0x%lx): %d bytes required for alignment "
3103 "to %d-byte boundary, but only %d present"),
3104 abfd
, sym_sec
, rel
->r_offset
, nop_bytes
, alignment
, rel
->r_addend
);
3105 bfd_set_error (bfd_error_bad_value
);
3109 /* Delete the reloc. */
3110 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
3112 /* If the number of NOPs is already correct, there's nothing to do. */
3113 if (nop_bytes
== rel
->r_addend
)
3116 /* Write as many RISC-V NOPs as we need. */
3117 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
3118 bfd_put_32 (abfd
, RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
3120 /* Write a final RVC NOP if need be. */
3121 if (nop_bytes
% 4 != 0)
3122 bfd_put_16 (abfd
, RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
3124 /* Delete the excess bytes. */
3125 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
3126 rel
->r_addend
- nop_bytes
, link_info
);
3129 /* Relax PC-relative references to GP-relative references. */
3132 _bfd_riscv_relax_pc (bfd
*abfd
,
3135 struct bfd_link_info
*link_info
,
3136 Elf_Internal_Rela
*rel
,
3138 bfd_vma max_alignment
,
3139 bfd_vma reserve_size
,
3140 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3141 riscv_pcgp_relocs
*pcgp_relocs
)
3143 bfd_vma gp
= riscv_global_pointer_value (link_info
);
3145 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
3147 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3148 * actual target address. */
3149 riscv_pcgp_hi_reloc hi_reloc
;
3150 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
3151 switch (ELFNN_R_TYPE (rel
->r_info
))
3153 case R_RISCV_PCREL_LO12_I
:
3154 case R_RISCV_PCREL_LO12_S
:
3156 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
3157 symval
- sec_addr(sym_sec
));
3160 riscv_record_pcgp_lo_reloc (pcgp_relocs
, symval
- sec_addr(sym_sec
));
3165 symval
= hi_reloc
.hi_addr
;
3166 sym_sec
= hi_reloc
.sym_sec
;
3167 if (!riscv_use_pcgp_hi_reloc(pcgp_relocs
, hi
->hi_sec_off
))
3168 (*_bfd_error_handler
)
3169 (_("%B(%A+0x%lx): Unable to clear RISCV_PCREL_HI20 reloc"
3170 "for cooresponding RISCV_PCREL_LO12 reloc"),
3171 abfd
, sec
, rel
->r_offset
);
3175 case R_RISCV_PCREL_HI20
:
3176 /* Mergeable symbols and code might later move out of range. */
3177 if (sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
3180 /* If the cooresponding lo relocation has already been seen then it's not
3181 * safe to relax this relocation. */
3182 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
3193 /* If gp and the symbol are in the same output section, then
3194 consider only that section's alignment. */
3195 struct bfd_link_hash_entry
*h
=
3196 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
3197 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
)
3198 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
3201 /* Is the reference in range of x0 or gp?
3202 Valid gp range conservatively because of alignment issue. */
3203 if (VALID_ITYPE_IMM (symval
)
3205 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
3207 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
)))
3209 unsigned sym
= hi_reloc
.hi_sym
;
3210 switch (ELFNN_R_TYPE (rel
->r_info
))
3212 case R_RISCV_PCREL_LO12_I
:
3213 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
3214 rel
->r_addend
+= hi_reloc
.hi_addend
;
3215 return riscv_delete_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
, 4);
3217 case R_RISCV_PCREL_LO12_S
:
3218 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
3219 rel
->r_addend
+= hi_reloc
.hi_addend
;
3220 return riscv_delete_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
, 4);
3222 case R_RISCV_PCREL_HI20
:
3223 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
3227 ELFNN_R_SYM(rel
->r_info
),
3229 /* We can delete the unnecessary AUIPC and reloc. */
3230 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
3232 return riscv_delete_pcgp_hi_reloc (pcgp_relocs
, rel
->r_offset
);
3242 /* Relax PC-relative references to GP-relative references. */
3245 _bfd_riscv_relax_delete (bfd
*abfd
,
3247 asection
*sym_sec ATTRIBUTE_UNUSED
,
3248 struct bfd_link_info
*link_info
,
3249 Elf_Internal_Rela
*rel
,
3250 bfd_vma symval ATTRIBUTE_UNUSED
,
3251 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
3252 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
3253 bfd_boolean
*again ATTRIBUTE_UNUSED
,
3254 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
)
3256 if (!riscv_relax_delete_bytes(abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
3259 rel
->r_info
= ELFNN_R_INFO(0, R_RISCV_NONE
);
3263 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3264 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3265 disabled, handles code alignment directives. */
3268 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
3269 struct bfd_link_info
*info
,
3272 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
3273 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3274 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3275 Elf_Internal_Rela
*relocs
;
3276 bfd_boolean ret
= FALSE
;
3278 bfd_vma max_alignment
, reserve_size
= 0;
3279 riscv_pcgp_relocs pcgp_relocs
;
3283 if (bfd_link_relocatable (info
)
3285 || (sec
->flags
& SEC_RELOC
) == 0
3286 || sec
->reloc_count
== 0
3287 || (info
->disable_target_specific_optimizations
3288 && info
->relax_pass
== 0))
3291 riscv_init_pcgp_relocs (&pcgp_relocs
);
3293 /* Read this BFD's relocs if we haven't done so already. */
3295 relocs
= data
->relocs
;
3296 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
3297 info
->keep_memory
)))
3302 max_alignment
= htab
->max_alignment
;
3303 if (max_alignment
== (bfd_vma
) -1)
3305 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3306 htab
->max_alignment
= max_alignment
;
3310 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
3312 /* Examine and consider relaxing each reloc. */
3313 for (i
= 0; i
< sec
->reloc_count
; i
++)
3316 Elf_Internal_Rela
*rel
= relocs
+ i
;
3317 relax_func_t relax_func
;
3318 int type
= ELFNN_R_TYPE (rel
->r_info
);
3322 if (info
->relax_pass
== 0)
3324 if (type
== R_RISCV_CALL
|| type
== R_RISCV_CALL_PLT
)
3325 relax_func
= _bfd_riscv_relax_call
;
3326 else if (type
== R_RISCV_HI20
3327 || type
== R_RISCV_LO12_I
3328 || type
== R_RISCV_LO12_S
)
3329 relax_func
= _bfd_riscv_relax_lui
;
3330 else if (!bfd_link_pic(info
)
3331 && (type
== R_RISCV_PCREL_HI20
3332 || type
== R_RISCV_PCREL_LO12_I
3333 || type
== R_RISCV_PCREL_LO12_S
))
3334 relax_func
= _bfd_riscv_relax_pc
;
3335 else if (type
== R_RISCV_TPREL_HI20
3336 || type
== R_RISCV_TPREL_ADD
3337 || type
== R_RISCV_TPREL_LO12_I
3338 || type
== R_RISCV_TPREL_LO12_S
)
3339 relax_func
= _bfd_riscv_relax_tls_le
;
3343 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3344 if (i
== sec
->reloc_count
- 1
3345 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
3346 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
3349 /* Skip over the R_RISCV_RELAX. */
3352 else if (info
->relax_pass
== 1 && type
== R_RISCV_DELETE
)
3353 relax_func
= _bfd_riscv_relax_delete
;
3354 else if (info
->relax_pass
== 2 && type
== R_RISCV_ALIGN
)
3355 relax_func
= _bfd_riscv_relax_align
;
3359 data
->relocs
= relocs
;
3361 /* Read this BFD's contents if we haven't done so already. */
3362 if (!data
->this_hdr
.contents
3363 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
3366 /* Read this BFD's symbols if we haven't done so already. */
3367 if (symtab_hdr
->sh_info
!= 0
3368 && !symtab_hdr
->contents
3369 && !(symtab_hdr
->contents
=
3370 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
3371 symtab_hdr
->sh_info
,
3372 0, NULL
, NULL
, NULL
)))
3375 /* Get the value of the symbol referred to by the reloc. */
3376 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
3378 /* A local symbol. */
3379 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
3380 + ELFNN_R_SYM (rel
->r_info
));
3381 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
3382 ? 0 : isym
->st_size
- rel
->r_addend
;
3384 if (isym
->st_shndx
== SHN_UNDEF
)
3385 sym_sec
= sec
, symval
= sec_addr (sec
) + rel
->r_offset
;
3388 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
3389 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
3390 if (sec_addr (sym_sec
) == 0)
3392 symval
= sec_addr (sym_sec
) + isym
->st_value
;
3398 struct elf_link_hash_entry
*h
;
3400 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
3401 h
= elf_sym_hashes (abfd
)[indx
];
3403 while (h
->root
.type
== bfd_link_hash_indirect
3404 || h
->root
.type
== bfd_link_hash_warning
)
3405 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
3407 if (h
->plt
.offset
!= MINUS_ONE
)
3408 symval
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
3409 else if (h
->root
.u
.def
.section
->output_section
== NULL
3410 || (h
->root
.type
!= bfd_link_hash_defined
3411 && h
->root
.type
!= bfd_link_hash_defweak
))
3414 symval
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3416 if (h
->type
!= STT_FUNC
)
3418 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
3419 sym_sec
= h
->root
.u
.def
.section
;
3422 symval
+= rel
->r_addend
;
3424 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
3425 max_alignment
, reserve_size
, again
,
3433 if (relocs
!= data
->relocs
)
3435 riscv_free_pcgp_relocs(&pcgp_relocs
, abfd
, sec
);
3441 # define PRSTATUS_SIZE 0 /* FIXME */
3442 # define PRSTATUS_OFFSET_PR_CURSIG 12
3443 # define PRSTATUS_OFFSET_PR_PID 24
3444 # define PRSTATUS_OFFSET_PR_REG 72
3445 # define ELF_GREGSET_T_SIZE 128
3446 # define PRPSINFO_SIZE 128
3447 # define PRPSINFO_OFFSET_PR_PID 16
3448 # define PRPSINFO_OFFSET_PR_FNAME 32
3449 # define PRPSINFO_OFFSET_PR_PSARGS 48
3451 # define PRSTATUS_SIZE 376
3452 # define PRSTATUS_OFFSET_PR_CURSIG 12
3453 # define PRSTATUS_OFFSET_PR_PID 32
3454 # define PRSTATUS_OFFSET_PR_REG 112
3455 # define ELF_GREGSET_T_SIZE 256
3456 # define PRPSINFO_SIZE 136
3457 # define PRPSINFO_OFFSET_PR_PID 24
3458 # define PRPSINFO_OFFSET_PR_FNAME 40
3459 # define PRPSINFO_OFFSET_PR_PSARGS 56
3462 /* Support for core dump NOTE sections. */
3465 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3467 switch (note
->descsz
)
3472 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3474 elf_tdata (abfd
)->core
->signal
3475 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
3478 elf_tdata (abfd
)->core
->lwpid
3479 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
3483 /* Make a ".reg/999" section. */
3484 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
3485 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
3489 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3491 switch (note
->descsz
)
3496 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3498 elf_tdata (abfd
)->core
->pid
3499 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
3502 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
3503 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
3506 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
3507 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
3511 /* Note that for some reason, a spurious space is tacked
3512 onto the end of the args in some (at least one anyway)
3513 implementations, so strip it off if it exists. */
3516 char *command
= elf_tdata (abfd
)->core
->command
;
3517 int n
= strlen (command
);
3519 if (0 < n
&& command
[n
- 1] == ' ')
3520 command
[n
- 1] = '\0';
3526 /* Set the right mach type. */
3528 riscv_elf_object_p (bfd
*abfd
)
3530 /* There are only two mach types in RISCV currently. */
3531 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0)
3532 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
3534 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
3540 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3541 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3543 #define elf_backend_reloc_type_class riscv_reloc_type_class
3545 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3546 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3547 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3548 #define bfd_elfNN_bfd_merge_private_bfd_data \
3549 _bfd_riscv_elf_merge_private_bfd_data
3551 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3552 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3553 #define elf_backend_check_relocs riscv_elf_check_relocs
3554 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3555 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3556 #define elf_backend_relocate_section riscv_elf_relocate_section
3557 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3558 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3559 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3560 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3561 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3562 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3563 #define elf_backend_object_p riscv_elf_object_p
3564 #define elf_info_to_howto_rel NULL
3565 #define elf_info_to_howto riscv_info_to_howto_rela
3566 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3568 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3570 #define elf_backend_can_gc_sections 1
3571 #define elf_backend_can_refcount 1
3572 #define elf_backend_want_got_plt 1
3573 #define elf_backend_plt_readonly 1
3574 #define elf_backend_plt_alignment 4
3575 #define elf_backend_want_plt_sym 1
3576 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3577 #define elf_backend_want_dynrelro 1
3578 #define elf_backend_rela_normal 1
3579 #define elf_backend_default_execstack 0
3581 #include "elfNN-target.h"