1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2021 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"
43 /* Internal relocations used exclusively by the relaxation pass. */
44 #define R_RISCV_DELETE (R_RISCV_max + 1)
48 #define MINUS_ONE ((bfd_vma)0 - 1)
50 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
52 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
54 /* The name of the dynamic interpreter. This is put in the .interp
57 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
58 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
60 #define ELF_ARCH bfd_arch_riscv
61 #define ELF_TARGET_ID RISCV_ELF_DATA
62 #define ELF_MACHINE_CODE EM_RISCV
63 #define ELF_MAXPAGESIZE 0x1000
64 #define ELF_COMMONPAGESIZE 0x1000
66 /* RISC-V ELF linker hash entry. */
68 struct riscv_elf_link_hash_entry
70 struct elf_link_hash_entry elf
;
80 #define riscv_elf_hash_entry(ent) \
81 ((struct riscv_elf_link_hash_entry *) (ent))
83 struct _bfd_riscv_elf_obj_tdata
85 struct elf_obj_tdata root
;
87 /* tls_type for each local got entry. */
88 char *local_got_tls_type
;
91 #define _bfd_riscv_elf_tdata(abfd) \
92 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
94 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
95 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
97 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
98 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
99 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
101 #define is_riscv_elf(bfd) \
102 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
103 && elf_tdata (bfd) != NULL \
104 && elf_object_id (bfd) == RISCV_ELF_DATA)
107 elfNN_riscv_mkobject (bfd
*abfd
)
109 return bfd_elf_allocate_object (abfd
,
110 sizeof (struct _bfd_riscv_elf_obj_tdata
),
114 #include "elf/common.h"
115 #include "elf/internal.h"
117 struct riscv_elf_link_hash_table
119 struct elf_link_hash_table elf
;
121 /* Short-cuts to get to dynamic linker sections. */
124 /* The max alignment of output sections. */
125 bfd_vma max_alignment
;
127 /* Used by local STT_GNU_IFUNC symbols. */
128 htab_t loc_hash_table
;
129 void * loc_hash_memory
;
131 /* The index of the last unused .rel.iplt slot. */
132 bfd_vma last_iplt_index
;
135 /* Instruction access functions. */
136 #define riscv_get_insn(bits, ptr) \
137 ((bits) == 16 ? bfd_getl16 (ptr) \
138 : (bits) == 32 ? bfd_getl32 (ptr) \
139 : (bits) == 64 ? bfd_getl64 (ptr) \
140 : (abort (), (bfd_vma) - 1))
141 #define riscv_put_insn(bits, val, ptr) \
142 ((bits) == 16 ? bfd_putl16 (val, ptr) \
143 : (bits) == 32 ? bfd_putl32 (val, ptr) \
144 : (bits) == 64 ? bfd_putl64 (val, ptr) \
145 : (abort (), (void) 0))
147 /* Get the RISC-V ELF linker hash table from a link_info structure. */
148 #define riscv_elf_hash_table(p) \
149 ((is_elf_hash_table ((p)->hash) \
150 && elf_hash_table_id (elf_hash_table (p)) == RISCV_ELF_DATA) \
151 ? (struct riscv_elf_link_hash_table *) (p)->hash : NULL)
154 riscv_info_to_howto_rela (bfd
*abfd
,
156 Elf_Internal_Rela
*dst
)
158 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
159 return cache_ptr
->howto
!= NULL
;
163 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
165 const struct elf_backend_data
*bed
;
168 bed
= get_elf_backend_data (abfd
);
169 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
170 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
173 /* Return true if a relocation is modifying an instruction. */
176 riscv_is_insn_reloc (const reloc_howto_type
*howto
)
178 /* Heuristic: A multibyte destination with a nontrivial mask
180 return (howto
->bitsize
> 8
181 && howto
->dst_mask
!= 0
182 && ~(howto
->dst_mask
| (howto
->bitsize
< sizeof(bfd_vma
) * CHAR_BIT
183 ? (MINUS_ONE
<< howto
->bitsize
) : (bfd_vma
)0)) != 0);
187 #define PLT_HEADER_INSNS 8
188 #define PLT_ENTRY_INSNS 4
189 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
190 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
191 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
192 /* Reserve two entries of GOTPLT for ld.so, one is used for PLT resolver,
193 the other is used for link map. Other targets also reserve one more
194 entry used for runtime profile? */
195 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
197 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
200 # define MATCH_LREG MATCH_LW
202 # define MATCH_LREG MATCH_LD
205 /* Generate a PLT header. */
208 riscv_make_plt_header (bfd
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
211 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
212 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
214 /* RVE has no t3 register, so this won't work, and is not supported. */
215 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
217 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
222 /* auipc t2, %hi(.got.plt)
223 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
224 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
225 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
226 addi t0, t2, %lo(.got.plt) # &.got.plt
227 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
228 l[w|d] t0, PTRSIZE(t0) # link map
231 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
232 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
233 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
234 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, (uint32_t) -(PLT_HEADER_SIZE
+ 12));
235 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
236 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
237 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
238 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
243 /* Generate a PLT entry. */
246 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
249 /* RVE has no t3 register, so this won't work, and is not supported. */
250 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
252 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
257 /* auipc t3, %hi(.got.plt entry)
258 l[w|d] t3, %lo(.got.plt entry)(t3)
262 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
263 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
264 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
265 entry
[3] = RISCV_NOP
;
270 /* Create an entry in an RISC-V ELF linker hash table. */
272 static struct bfd_hash_entry
*
273 link_hash_newfunc (struct bfd_hash_entry
*entry
,
274 struct bfd_hash_table
*table
, const char *string
)
276 /* Allocate the structure if it has not already been allocated by a
281 bfd_hash_allocate (table
,
282 sizeof (struct riscv_elf_link_hash_entry
));
287 /* Call the allocation method of the superclass. */
288 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
291 struct riscv_elf_link_hash_entry
*eh
;
293 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
294 eh
->tls_type
= GOT_UNKNOWN
;
300 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
301 for local symbol so that we can handle local STT_GNU_IFUNC symbols
302 as global symbol. We reuse indx and dynstr_index for local symbol
303 hash since they aren't used by global symbols in this backend. */
306 riscv_elf_local_htab_hash (const void *ptr
)
308 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) ptr
;
309 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
312 /* Compare local hash entries. */
315 riscv_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
317 struct elf_link_hash_entry
*h1
= (struct elf_link_hash_entry
*) ptr1
;
318 struct elf_link_hash_entry
*h2
= (struct elf_link_hash_entry
*) ptr2
;
320 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
323 /* Find and/or create a hash entry for local symbol. */
325 static struct elf_link_hash_entry
*
326 riscv_elf_get_local_sym_hash (struct riscv_elf_link_hash_table
*htab
,
327 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
330 struct riscv_elf_link_hash_entry eh
, *ret
;
331 asection
*sec
= abfd
->sections
;
332 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
333 ELFNN_R_SYM (rel
->r_info
));
336 eh
.elf
.indx
= sec
->id
;
337 eh
.elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
338 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &eh
, h
,
339 create
? INSERT
: NO_INSERT
);
346 ret
= (struct riscv_elf_link_hash_entry
*) *slot
;
350 ret
= (struct riscv_elf_link_hash_entry
*)
351 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
352 sizeof (struct riscv_elf_link_hash_entry
));
355 memset (ret
, 0, sizeof (*ret
));
356 ret
->elf
.indx
= sec
->id
;
357 ret
->elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
358 ret
->elf
.dynindx
= -1;
364 /* Destroy a RISC-V elf linker hash table. */
367 riscv_elf_link_hash_table_free (bfd
*obfd
)
369 struct riscv_elf_link_hash_table
*ret
370 = (struct riscv_elf_link_hash_table
*) obfd
->link
.hash
;
372 if (ret
->loc_hash_table
)
373 htab_delete (ret
->loc_hash_table
);
374 if (ret
->loc_hash_memory
)
375 objalloc_free ((struct objalloc
*) ret
->loc_hash_memory
);
377 _bfd_elf_link_hash_table_free (obfd
);
380 /* Create a RISC-V ELF linker hash table. */
382 static struct bfd_link_hash_table
*
383 riscv_elf_link_hash_table_create (bfd
*abfd
)
385 struct riscv_elf_link_hash_table
*ret
;
386 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
388 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
392 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
393 sizeof (struct riscv_elf_link_hash_entry
),
400 ret
->max_alignment
= (bfd_vma
) -1;
402 /* Create hash table for local ifunc. */
403 ret
->loc_hash_table
= htab_try_create (1024,
404 riscv_elf_local_htab_hash
,
405 riscv_elf_local_htab_eq
,
407 ret
->loc_hash_memory
= objalloc_create ();
408 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
410 riscv_elf_link_hash_table_free (abfd
);
413 ret
->elf
.root
.hash_table_free
= riscv_elf_link_hash_table_free
;
415 return &ret
->elf
.root
;
418 /* Create the .got section. */
421 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
425 struct elf_link_hash_entry
*h
;
426 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
427 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
429 /* This function may be called more than once. */
430 if (htab
->sgot
!= NULL
)
433 flags
= bed
->dynamic_sec_flags
;
435 s
= bfd_make_section_anyway_with_flags (abfd
,
436 (bed
->rela_plts_and_copies_p
437 ? ".rela.got" : ".rel.got"),
438 (bed
->dynamic_sec_flags
441 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
445 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
447 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
451 /* The first bit of the global offset table is the header. */
452 s
->size
+= bed
->got_header_size
;
454 if (bed
->want_got_plt
)
456 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
458 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
462 /* Reserve room for the header. */
463 s
->size
+= GOTPLT_HEADER_SIZE
;
466 if (bed
->want_got_sym
)
468 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
469 section. We don't do this in the linker script because we don't want
470 to define the symbol if we are not creating a global offset
472 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
473 "_GLOBAL_OFFSET_TABLE_");
474 elf_hash_table (info
)->hgot
= h
;
482 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
483 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
487 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
488 struct bfd_link_info
*info
)
490 struct riscv_elf_link_hash_table
*htab
;
492 htab
= riscv_elf_hash_table (info
);
493 BFD_ASSERT (htab
!= NULL
);
495 if (!riscv_elf_create_got_section (dynobj
, info
))
498 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
501 if (!bfd_link_pic (info
))
503 /* Technically, this section doesn't have contents. It is used as the
504 target of TLS copy relocs, to copy TLS data from shared libraries into
505 the executable. However, if we don't mark it as loadable, then it
506 matches the IS_TBSS test in ldlang.c, and there is no run-time address
507 space allocated for it even though it has SEC_ALLOC. That test is
508 correct for .tbss, but not correct for this section. There is also
509 a second problem that having a section with no contents can only work
510 if it comes after all sections with contents in the same segment,
511 but the linker script does not guarantee that. This is just mixed in
512 with other .tdata.* sections. We can fix both problems by lying and
513 saying that there are contents. This section is expected to be small
514 so this should not cause a significant extra program startup cost. */
516 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
517 (SEC_ALLOC
| SEC_THREAD_LOCAL
518 | SEC_LOAD
| SEC_DATA
520 | SEC_LINKER_CREATED
));
523 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
524 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
530 /* Copy the extra info we tack onto an elf_link_hash_entry. */
533 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
534 struct elf_link_hash_entry
*dir
,
535 struct elf_link_hash_entry
*ind
)
537 struct riscv_elf_link_hash_entry
*edir
, *eind
;
539 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
540 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
542 if (ind
->root
.type
== bfd_link_hash_indirect
543 && dir
->got
.refcount
<= 0)
545 edir
->tls_type
= eind
->tls_type
;
546 eind
->tls_type
= GOT_UNKNOWN
;
548 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
552 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
553 unsigned long symndx
, char tls_type
)
555 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
557 *new_tls_type
|= tls_type
;
558 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
560 (*_bfd_error_handler
)
561 (_("%pB: `%s' accessed both as normal and thread local symbol"),
562 abfd
, h
? h
->root
.root
.string
: "<local>");
569 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
570 struct elf_link_hash_entry
*h
, long symndx
)
572 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
573 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
575 if (htab
->elf
.sgot
== NULL
)
577 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
583 h
->got
.refcount
+= 1;
587 /* This is a global offset table entry for a local symbol. */
588 if (elf_local_got_refcounts (abfd
) == NULL
)
590 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
591 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
593 _bfd_riscv_elf_local_got_tls_type (abfd
)
594 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
596 elf_local_got_refcounts (abfd
) [symndx
] += 1;
602 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
604 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
606 /* We propably can improve the information to tell users that they
607 should be recompile the code with -fPIC or -fPIE, just like what
609 (*_bfd_error_handler
)
610 (_("%pB: relocation %s against `%s' can not be used when making a shared "
611 "object; recompile with -fPIC"),
612 abfd
, r
? r
->name
: _("<unknown>"),
613 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
614 bfd_set_error (bfd_error_bad_value
);
618 /* Look through the relocs for a section during the first phase, and
619 allocate space in the global offset table or procedure linkage
623 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
624 asection
*sec
, const Elf_Internal_Rela
*relocs
)
626 struct riscv_elf_link_hash_table
*htab
;
627 Elf_Internal_Shdr
*symtab_hdr
;
628 struct elf_link_hash_entry
**sym_hashes
;
629 const Elf_Internal_Rela
*rel
;
630 asection
*sreloc
= NULL
;
632 if (bfd_link_relocatable (info
))
635 htab
= riscv_elf_hash_table (info
);
636 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
637 sym_hashes
= elf_sym_hashes (abfd
);
639 if (htab
->elf
.dynobj
== NULL
)
640 htab
->elf
.dynobj
= abfd
;
642 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
645 unsigned int r_symndx
;
646 struct elf_link_hash_entry
*h
;
648 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
649 r_type
= ELFNN_R_TYPE (rel
->r_info
);
651 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
653 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
658 if (r_symndx
< symtab_hdr
->sh_info
)
660 /* A local symbol. */
661 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
666 /* Check relocation against local STT_GNU_IFUNC symbol. */
667 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
669 h
= riscv_elf_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
673 /* Fake STT_GNU_IFUNC global symbol. */
674 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
676 h
->type
= STT_GNU_IFUNC
;
680 h
->root
.type
= bfd_link_hash_defined
;
687 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
688 while (h
->root
.type
== bfd_link_hash_indirect
689 || h
->root
.type
== bfd_link_hash_warning
)
690 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
700 case R_RISCV_CALL_PLT
:
702 case R_RISCV_GOT_HI20
:
703 case R_RISCV_PCREL_HI20
:
704 /* Create the ifunc sections, iplt and ipltgot, for static
706 if (h
->type
== STT_GNU_IFUNC
707 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
715 /* It is referenced by a non-shared object. */
721 case R_RISCV_TLS_GD_HI20
:
722 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
723 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
727 case R_RISCV_TLS_GOT_HI20
:
728 if (bfd_link_pic (info
))
729 info
->flags
|= DF_STATIC_TLS
;
730 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
731 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
735 case R_RISCV_GOT_HI20
:
736 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
737 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
742 case R_RISCV_CALL_PLT
:
743 /* These symbol requires a procedure linkage table entry.
744 We actually build the entry in adjust_dynamic_symbol,
745 because these might be a case of linking PIC code without
746 linking in any dynamic objects, in which case we don't
747 need to generate a procedure linkage table after all. */
749 /* If it is a local symbol, then we resolve it directly
750 without creating a PLT entry. */
755 h
->plt
.refcount
+= 1;
758 case R_RISCV_PCREL_HI20
:
760 && h
->type
== STT_GNU_IFUNC
)
763 h
->pointer_equality_needed
= 1;
765 /* We don't use the PCREL_HI20 in the data section,
766 so we always need the plt when it refers to
768 h
->plt
.refcount
+= 1;
774 case R_RISCV_RVC_BRANCH
:
775 case R_RISCV_RVC_JUMP
:
776 /* In shared libraries and pie, these relocs are known
778 if (bfd_link_pic (info
))
782 case R_RISCV_TPREL_HI20
:
783 if (!bfd_link_executable (info
))
784 return bad_static_reloc (abfd
, r_type
, h
);
786 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
790 if (bfd_link_pic (info
))
791 return bad_static_reloc (abfd
, r_type
, h
);
795 case R_RISCV_JUMP_SLOT
:
796 case R_RISCV_RELATIVE
:
804 && (!bfd_link_pic (info
)
805 || h
->type
== STT_GNU_IFUNC
))
807 /* This reloc might not bind locally. */
809 h
->pointer_equality_needed
= 1;
812 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
814 /* We may need a .plt entry if the symbol is a function
815 defined in a shared lib or is a function referenced
816 from the code or read-only section. */
817 h
->plt
.refcount
+= 1;
821 /* If we are creating a shared library, and this is a reloc
822 against a global symbol, or a non PC relative reloc
823 against a local symbol, then we need to copy the reloc
824 into the shared library. However, if we are linking with
825 -Bsymbolic, we do not need to copy a reloc against a
826 global symbol which is defined in an object we are
827 including in the link (i.e., DEF_REGULAR is set). At
828 this point we have not seen all the input files, so it is
829 possible that DEF_REGULAR is not set now but will be set
830 later (it is never cleared). In case of a weak definition,
831 DEF_REGULAR may be cleared later by a strong definition in
832 a shared library. We account for that possibility below by
833 storing information in the relocs_copied field of the hash
834 table entry. A similar situation occurs when creating
835 shared libraries and symbol visibility changes render the
838 If on the other hand, we are creating an executable, we
839 may need to keep relocations for symbols satisfied by a
840 dynamic library if we manage to avoid copy relocs for the
843 Generate dynamic pointer relocation against STT_GNU_IFUNC
844 symbol in the non-code section (R_RISCV_32/R_RISCV_64). */
845 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
847 if ((bfd_link_pic (info
)
848 && (sec
->flags
& SEC_ALLOC
) != 0
849 && ((r
!= NULL
&& !r
->pc_relative
)
852 || h
->root
.type
== bfd_link_hash_defweak
853 || !h
->def_regular
))))
854 || (!bfd_link_pic (info
)
855 && (sec
->flags
& SEC_ALLOC
) != 0
857 && (h
->root
.type
== bfd_link_hash_defweak
859 || (!bfd_link_pic (info
)
861 && h
->type
== STT_GNU_IFUNC
862 && (sec
->flags
& SEC_CODE
) == 0))
864 struct elf_dyn_relocs
*p
;
865 struct elf_dyn_relocs
**head
;
867 /* When creating a shared object, we must copy these
868 relocs into the output file. We create a reloc
869 section in dynobj and make room for the reloc. */
872 sreloc
= _bfd_elf_make_dynamic_reloc_section
873 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
874 abfd
, /*rela?*/ TRUE
);
880 /* If this is a global symbol, we count the number of
881 relocations we need for this symbol. */
883 head
= &h
->dyn_relocs
;
886 /* Track dynamic relocs needed for local syms too.
887 We really need local syms available to do this
892 Elf_Internal_Sym
*isym
;
894 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
899 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
903 vpp
= &elf_section_data (s
)->local_dynrel
;
904 head
= (struct elf_dyn_relocs
**) vpp
;
908 if (p
== NULL
|| p
->sec
!= sec
)
910 size_t amt
= sizeof *p
;
911 p
= ((struct elf_dyn_relocs
*)
912 bfd_alloc (htab
->elf
.dynobj
, amt
));
923 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
928 case R_RISCV_GNU_VTINHERIT
:
929 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
933 case R_RISCV_GNU_VTENTRY
:
934 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
947 riscv_elf_gc_mark_hook (asection
*sec
,
948 struct bfd_link_info
*info
,
949 Elf_Internal_Rela
*rel
,
950 struct elf_link_hash_entry
*h
,
951 Elf_Internal_Sym
*sym
)
954 switch (ELFNN_R_TYPE (rel
->r_info
))
956 case R_RISCV_GNU_VTINHERIT
:
957 case R_RISCV_GNU_VTENTRY
:
961 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
964 /* Adjust a symbol defined by a dynamic object and referenced by a
965 regular object. The current definition is in some section of the
966 dynamic object, but we're not including those sections. We have to
967 change the definition to something the rest of the link can
971 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
972 struct elf_link_hash_entry
*h
)
974 struct riscv_elf_link_hash_table
*htab
;
975 struct riscv_elf_link_hash_entry
* eh
;
979 htab
= riscv_elf_hash_table (info
);
980 BFD_ASSERT (htab
!= NULL
);
982 dynobj
= htab
->elf
.dynobj
;
984 /* Make sure we know what is going on here. */
985 BFD_ASSERT (dynobj
!= NULL
987 || h
->type
== STT_GNU_IFUNC
991 && !h
->def_regular
)));
993 /* If this is a function, put it in the procedure linkage table. We
994 will fill in the contents of the procedure linkage table later
995 (although we could actually do it here). */
996 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
998 if (h
->plt
.refcount
<= 0
999 || (h
->type
!= STT_GNU_IFUNC
1000 && (SYMBOL_CALLS_LOCAL (info
, h
)
1001 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1002 && h
->root
.type
== bfd_link_hash_undefweak
))))
1004 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
1005 input file, but the symbol was never referred to by a dynamic
1006 object, or if all references were garbage collected. In such
1007 a case, we don't actually need to build a PLT entry. */
1008 h
->plt
.offset
= (bfd_vma
) -1;
1015 h
->plt
.offset
= (bfd_vma
) -1;
1017 /* If this is a weak symbol, and there is a real definition, the
1018 processor independent code will have arranged for us to see the
1019 real definition first, and we can just use the same value. */
1020 if (h
->is_weakalias
)
1022 struct elf_link_hash_entry
*def
= weakdef (h
);
1023 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1024 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1025 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1029 /* This is a reference to a symbol defined by a dynamic object which
1030 is not a function. */
1032 /* If we are creating a shared library, we must presume that the
1033 only references to the symbol are via the global offset table.
1034 For such cases we need not do anything here; the relocations will
1035 be handled correctly by relocate_section. */
1036 if (bfd_link_pic (info
))
1039 /* If there are no references to this symbol that do not use the
1040 GOT, we don't need to generate a copy reloc. */
1041 if (!h
->non_got_ref
)
1044 /* If -z nocopyreloc was given, we won't generate them either. */
1045 if (info
->nocopyreloc
)
1051 /* If we don't find any dynamic relocs in read-only sections, then
1052 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1053 if (!_bfd_elf_readonly_dynrelocs (h
))
1059 /* We must allocate the symbol in our .dynbss section, which will
1060 become part of the .bss section of the executable. There will be
1061 an entry for this symbol in the .dynsym section. The dynamic
1062 object will contain position independent code, so all references
1063 from the dynamic object to this symbol will go through the global
1064 offset table. The dynamic linker will use the .dynsym entry to
1065 determine the address it must put in the global offset table, so
1066 both the dynamic object and the regular object will refer to the
1067 same memory location for the variable. */
1069 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
1070 to copy the initial value out of the dynamic object and into the
1071 runtime process image. We need to remember the offset into the
1072 .rel.bss section we are going to use. */
1073 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1074 if (eh
->tls_type
& ~GOT_NORMAL
)
1076 s
= htab
->sdyntdata
;
1077 srel
= htab
->elf
.srelbss
;
1079 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1081 s
= htab
->elf
.sdynrelro
;
1082 srel
= htab
->elf
.sreldynrelro
;
1086 s
= htab
->elf
.sdynbss
;
1087 srel
= htab
->elf
.srelbss
;
1089 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1091 srel
->size
+= sizeof (ElfNN_External_Rela
);
1095 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1098 /* Allocate space in .plt, .got and associated reloc sections for
1102 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1104 struct bfd_link_info
*info
;
1105 struct riscv_elf_link_hash_table
*htab
;
1106 struct elf_dyn_relocs
*p
;
1108 if (h
->root
.type
== bfd_link_hash_indirect
)
1111 info
= (struct bfd_link_info
*) inf
;
1112 htab
= riscv_elf_hash_table (info
);
1113 BFD_ASSERT (htab
!= NULL
);
1115 /* When we are generating pde, make sure gp symbol is output as a
1116 dynamic symbol. Then ld.so can set the gp register earlier, before
1117 resolving the ifunc. */
1118 if (!bfd_link_pic (info
)
1119 && htab
->elf
.dynamic_sections_created
1120 && strcmp (h
->root
.root
.string
, RISCV_GP_SYMBOL
) == 0
1121 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1124 /* Since STT_GNU_IFUNC symbols must go through PLT, we handle them
1125 in the allocate_ifunc_dynrelocs and allocate_local_ifunc_dynrelocs,
1126 if they are defined and referenced in a non-shared object. */
1127 if (h
->type
== STT_GNU_IFUNC
1130 else if (htab
->elf
.dynamic_sections_created
1131 && h
->plt
.refcount
> 0)
1133 /* Make sure this symbol is output as a dynamic symbol.
1134 Undefined weak syms won't yet be marked as dynamic. */
1135 if (h
->dynindx
== -1
1136 && !h
->forced_local
)
1138 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1142 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1144 asection
*s
= htab
->elf
.splt
;
1147 s
->size
= PLT_HEADER_SIZE
;
1149 h
->plt
.offset
= s
->size
;
1151 /* Make room for this entry. */
1152 s
->size
+= PLT_ENTRY_SIZE
;
1154 /* We also need to make an entry in the .got.plt section. */
1155 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
1157 /* We also need to make an entry in the .rela.plt section. */
1158 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
1160 /* If this symbol is not defined in a regular file, and we are
1161 not generating a shared library, then set the symbol to this
1162 location in the .plt. This is required to make function
1163 pointers compare as equal between the normal executable and
1164 the shared library. */
1165 if (! bfd_link_pic (info
)
1168 h
->root
.u
.def
.section
= s
;
1169 h
->root
.u
.def
.value
= h
->plt
.offset
;
1174 h
->plt
.offset
= (bfd_vma
) -1;
1180 h
->plt
.offset
= (bfd_vma
) -1;
1184 if (h
->got
.refcount
> 0)
1188 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
1190 /* Make sure this symbol is output as a dynamic symbol.
1191 Undefined weak syms won't yet be marked as dynamic. */
1192 if (h
->dynindx
== -1
1193 && !h
->forced_local
)
1195 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1200 h
->got
.offset
= s
->size
;
1201 dyn
= htab
->elf
.dynamic_sections_created
;
1202 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
1204 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1205 if (tls_type
& GOT_TLS_GD
)
1207 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
1208 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1211 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1212 if (tls_type
& GOT_TLS_IE
)
1214 s
->size
+= RISCV_ELF_WORD_BYTES
;
1215 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1220 s
->size
+= RISCV_ELF_WORD_BYTES
;
1221 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1222 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1223 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1227 h
->got
.offset
= (bfd_vma
) -1;
1229 if (h
->dyn_relocs
== NULL
)
1232 /* In the shared -Bsymbolic case, discard space allocated for
1233 dynamic pc-relative relocs against symbols which turn out to be
1234 defined in regular objects. For the normal shared case, discard
1235 space for pc-relative relocs that have become local due to symbol
1236 visibility changes. */
1238 if (bfd_link_pic (info
))
1240 if (SYMBOL_CALLS_LOCAL (info
, h
))
1242 struct elf_dyn_relocs
**pp
;
1244 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1246 p
->count
-= p
->pc_count
;
1255 /* Also discard relocs on undefined weak syms with non-default
1257 if (h
->dyn_relocs
!= NULL
1258 && h
->root
.type
== bfd_link_hash_undefweak
)
1260 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1261 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1262 h
->dyn_relocs
= NULL
;
1264 /* Make sure undefined weak symbols are output as a dynamic
1266 else if (h
->dynindx
== -1
1267 && !h
->forced_local
)
1269 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1276 /* For the non-shared case, discard space for relocs against
1277 symbols which turn out to need copy relocs or are not
1283 || (htab
->elf
.dynamic_sections_created
1284 && (h
->root
.type
== bfd_link_hash_undefweak
1285 || h
->root
.type
== bfd_link_hash_undefined
))))
1287 /* Make sure this symbol is output as a dynamic symbol.
1288 Undefined weak syms won't yet be marked as dynamic. */
1289 if (h
->dynindx
== -1
1290 && !h
->forced_local
)
1292 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1296 /* If that succeeded, we know we'll be keeping all the
1298 if (h
->dynindx
!= -1)
1302 h
->dyn_relocs
= NULL
;
1307 /* Finally, allocate space. */
1308 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1310 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1311 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1317 /* Allocate space in .plt, .got and associated reloc sections for
1318 ifunc dynamic relocs. */
1321 allocate_ifunc_dynrelocs (struct elf_link_hash_entry
*h
,
1324 struct bfd_link_info
*info
;
1326 if (h
->root
.type
== bfd_link_hash_indirect
)
1329 if (h
->root
.type
== bfd_link_hash_warning
)
1330 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1332 info
= (struct bfd_link_info
*) inf
;
1334 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1335 here if it is defined and referenced in a non-shared object. */
1336 if (h
->type
== STT_GNU_IFUNC
1338 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
1347 /* Allocate space in .plt, .got and associated reloc sections for
1348 local ifunc dynamic relocs. */
1351 allocate_local_ifunc_dynrelocs (void **slot
, void *inf
)
1353 struct elf_link_hash_entry
*h
1354 = (struct elf_link_hash_entry
*) *slot
;
1356 if (h
->type
!= STT_GNU_IFUNC
1360 || h
->root
.type
!= bfd_link_hash_defined
)
1363 return allocate_ifunc_dynrelocs (h
, inf
);
1367 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1369 struct riscv_elf_link_hash_table
*htab
;
1374 htab
= riscv_elf_hash_table (info
);
1375 BFD_ASSERT (htab
!= NULL
);
1376 dynobj
= htab
->elf
.dynobj
;
1377 BFD_ASSERT (dynobj
!= NULL
);
1379 if (elf_hash_table (info
)->dynamic_sections_created
)
1381 /* Set the contents of the .interp section to the interpreter. */
1382 if (bfd_link_executable (info
) && !info
->nointerp
)
1384 s
= bfd_get_linker_section (dynobj
, ".interp");
1385 BFD_ASSERT (s
!= NULL
);
1386 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1387 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1391 /* Set up .got offsets for local syms, and space for local dynamic
1393 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1395 bfd_signed_vma
*local_got
;
1396 bfd_signed_vma
*end_local_got
;
1397 char *local_tls_type
;
1398 bfd_size_type locsymcount
;
1399 Elf_Internal_Shdr
*symtab_hdr
;
1402 if (! is_riscv_elf (ibfd
))
1405 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1407 struct elf_dyn_relocs
*p
;
1409 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1411 if (!bfd_is_abs_section (p
->sec
)
1412 && bfd_is_abs_section (p
->sec
->output_section
))
1414 /* Input section has been discarded, either because
1415 it is a copy of a linkonce section or due to
1416 linker script /DISCARD/, so we'll be discarding
1419 else if (p
->count
!= 0)
1421 srel
= elf_section_data (p
->sec
)->sreloc
;
1422 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1423 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1424 info
->flags
|= DF_TEXTREL
;
1429 local_got
= elf_local_got_refcounts (ibfd
);
1433 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1434 locsymcount
= symtab_hdr
->sh_info
;
1435 end_local_got
= local_got
+ locsymcount
;
1436 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1438 srel
= htab
->elf
.srelgot
;
1439 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1443 *local_got
= s
->size
;
1444 s
->size
+= RISCV_ELF_WORD_BYTES
;
1445 if (*local_tls_type
& GOT_TLS_GD
)
1446 s
->size
+= RISCV_ELF_WORD_BYTES
;
1447 if (bfd_link_pic (info
)
1448 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1449 srel
->size
+= sizeof (ElfNN_External_Rela
);
1452 *local_got
= (bfd_vma
) -1;
1456 /* Allocate .plt and .got entries and space dynamic relocs for
1458 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1460 /* Allocate .plt and .got entries and space dynamic relocs for
1461 global ifunc symbols. */
1462 elf_link_hash_traverse (&htab
->elf
, allocate_ifunc_dynrelocs
, info
);
1464 /* Allocate .plt and .got entries and space dynamic relocs for
1465 local ifunc symbols. */
1466 htab_traverse (htab
->loc_hash_table
, allocate_local_ifunc_dynrelocs
, info
);
1468 /* Used to resolve the dynamic relocs overwite problems when
1469 generating static executable. */
1470 if (htab
->elf
.irelplt
)
1471 htab
->last_iplt_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1473 if (htab
->elf
.sgotplt
)
1475 struct elf_link_hash_entry
*got
;
1476 got
= elf_link_hash_lookup (elf_hash_table (info
),
1477 "_GLOBAL_OFFSET_TABLE_",
1478 FALSE
, FALSE
, FALSE
);
1480 /* Don't allocate .got.plt section if there are no GOT nor PLT
1481 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1483 || !got
->ref_regular_nonweak
)
1484 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1485 && (htab
->elf
.splt
== NULL
1486 || htab
->elf
.splt
->size
== 0)
1487 && (htab
->elf
.sgot
== NULL
1488 || (htab
->elf
.sgot
->size
1489 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1490 htab
->elf
.sgotplt
->size
= 0;
1493 /* The check_relocs and adjust_dynamic_symbol entry points have
1494 determined the sizes of the various dynamic sections. Allocate
1496 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1498 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1501 if (s
== htab
->elf
.splt
1502 || s
== htab
->elf
.sgot
1503 || s
== htab
->elf
.sgotplt
1504 || s
== htab
->elf
.iplt
1505 || s
== htab
->elf
.igotplt
1506 || s
== htab
->elf
.sdynbss
1507 || s
== htab
->elf
.sdynrelro
1508 || s
== htab
->sdyntdata
)
1510 /* Strip this section if we don't need it; see the
1513 else if (strncmp (s
->name
, ".rela", 5) == 0)
1517 /* We use the reloc_count field as a counter if we need
1518 to copy relocs into the output file. */
1524 /* It's not one of our sections. */
1530 /* If we don't need this section, strip it from the
1531 output file. This is mostly to handle .rela.bss and
1532 .rela.plt. We must create both sections in
1533 create_dynamic_sections, because they must be created
1534 before the linker maps input sections to output
1535 sections. The linker does that before
1536 adjust_dynamic_symbol is called, and it is that
1537 function which decides whether anything needs to go
1538 into these sections. */
1539 s
->flags
|= SEC_EXCLUDE
;
1543 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1546 /* Allocate memory for the section contents. Zero the memory
1547 for the benefit of .rela.plt, which has 4 unused entries
1548 at the beginning, and we don't want garbage. */
1549 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1550 if (s
->contents
== NULL
)
1554 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, TRUE
);
1558 #define DTP_OFFSET 0x800
1560 /* Return the relocation value for a TLS dtp-relative reloc. */
1563 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1565 /* If tls_sec is NULL, we should have signalled an error already. */
1566 if (elf_hash_table (info
)->tls_sec
== NULL
)
1568 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1571 /* Return the relocation value for a static TLS tp-relative relocation. */
1574 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1576 /* If tls_sec is NULL, we should have signalled an error already. */
1577 if (elf_hash_table (info
)->tls_sec
== NULL
)
1579 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1582 /* Return the global pointer's value, or 0 if it is not in use. */
1585 riscv_global_pointer_value (struct bfd_link_info
*info
)
1587 struct bfd_link_hash_entry
*h
;
1589 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1590 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1593 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1596 /* Emplace a static relocation. */
1598 static bfd_reloc_status_type
1599 perform_relocation (const reloc_howto_type
*howto
,
1600 const Elf_Internal_Rela
*rel
,
1602 asection
*input_section
,
1606 if (howto
->pc_relative
)
1607 value
-= sec_addr (input_section
) + rel
->r_offset
;
1608 value
+= rel
->r_addend
;
1610 switch (ELFNN_R_TYPE (rel
->r_info
))
1613 case R_RISCV_TPREL_HI20
:
1614 case R_RISCV_PCREL_HI20
:
1615 case R_RISCV_GOT_HI20
:
1616 case R_RISCV_TLS_GOT_HI20
:
1617 case R_RISCV_TLS_GD_HI20
:
1618 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1619 return bfd_reloc_overflow
;
1620 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1623 case R_RISCV_LO12_I
:
1624 case R_RISCV_GPREL_I
:
1625 case R_RISCV_TPREL_LO12_I
:
1626 case R_RISCV_TPREL_I
:
1627 case R_RISCV_PCREL_LO12_I
:
1628 value
= ENCODE_ITYPE_IMM (value
);
1631 case R_RISCV_LO12_S
:
1632 case R_RISCV_GPREL_S
:
1633 case R_RISCV_TPREL_LO12_S
:
1634 case R_RISCV_TPREL_S
:
1635 case R_RISCV_PCREL_LO12_S
:
1636 value
= ENCODE_STYPE_IMM (value
);
1640 case R_RISCV_CALL_PLT
:
1641 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1642 return bfd_reloc_overflow
;
1643 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1644 | (ENCODE_ITYPE_IMM (value
) << 32);
1648 if (!VALID_UJTYPE_IMM (value
))
1649 return bfd_reloc_overflow
;
1650 value
= ENCODE_UJTYPE_IMM (value
);
1653 case R_RISCV_BRANCH
:
1654 if (!VALID_SBTYPE_IMM (value
))
1655 return bfd_reloc_overflow
;
1656 value
= ENCODE_SBTYPE_IMM (value
);
1659 case R_RISCV_RVC_BRANCH
:
1660 if (!VALID_RVC_B_IMM (value
))
1661 return bfd_reloc_overflow
;
1662 value
= ENCODE_RVC_B_IMM (value
);
1665 case R_RISCV_RVC_JUMP
:
1666 if (!VALID_RVC_J_IMM (value
))
1667 return bfd_reloc_overflow
;
1668 value
= ENCODE_RVC_J_IMM (value
);
1671 case R_RISCV_RVC_LUI
:
1672 if (RISCV_CONST_HIGH_PART (value
) == 0)
1674 /* Linker relaxation can convert an address equal to or greater than
1675 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1676 valid immediate. We can fix this by converting it to a C.LI. */
1677 bfd_vma insn
= riscv_get_insn (howto
->bitsize
,
1678 contents
+ rel
->r_offset
);
1679 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1680 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1681 value
= ENCODE_RVC_IMM (0);
1683 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1684 return bfd_reloc_overflow
;
1686 value
= ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1704 case R_RISCV_32_PCREL
:
1705 case R_RISCV_TLS_DTPREL32
:
1706 case R_RISCV_TLS_DTPREL64
:
1709 case R_RISCV_DELETE
:
1710 return bfd_reloc_ok
;
1713 return bfd_reloc_notsupported
;
1717 if (riscv_is_insn_reloc (howto
))
1718 word
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1720 word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1721 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1722 if (riscv_is_insn_reloc (howto
))
1723 riscv_put_insn (howto
->bitsize
, word
, contents
+ rel
->r_offset
);
1725 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1727 return bfd_reloc_ok
;
1730 /* Remember all PC-relative high-part relocs we've encountered to help us
1731 later resolve the corresponding low-part relocs. */
1737 } riscv_pcrel_hi_reloc
;
1739 typedef struct riscv_pcrel_lo_reloc
1741 asection
*input_section
;
1742 struct bfd_link_info
*info
;
1743 reloc_howto_type
*howto
;
1744 const Elf_Internal_Rela
*reloc
;
1748 struct riscv_pcrel_lo_reloc
*next
;
1749 } riscv_pcrel_lo_reloc
;
1754 riscv_pcrel_lo_reloc
*lo_relocs
;
1755 } riscv_pcrel_relocs
;
1758 riscv_pcrel_reloc_hash (const void *entry
)
1760 const riscv_pcrel_hi_reloc
*e
= entry
;
1761 return (hashval_t
)(e
->address
>> 2);
1765 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1767 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1768 return e1
->address
== e2
->address
;
1772 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1774 p
->lo_relocs
= NULL
;
1775 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1776 riscv_pcrel_reloc_eq
, free
);
1777 return p
->hi_relocs
!= NULL
;
1781 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1783 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1787 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1792 htab_delete (p
->hi_relocs
);
1796 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1797 struct bfd_link_info
*info
,
1801 const reloc_howto_type
*howto
,
1802 bfd
*input_bfd ATTRIBUTE_UNUSED
)
1804 /* We may need to reference low addreses in PC-relative modes even when the
1805 PC is far away from these addresses. For example, undefweak references
1806 need to produce the address 0 when linked. As 0 is far from the arbitrary
1807 addresses that we can link PC-relative programs at, the linker can't
1808 actually relocate references to those symbols. In order to allow these
1809 programs to work we simply convert the PC-relative auipc sequences to
1810 0-relative lui sequences. */
1811 if (bfd_link_pic (info
))
1814 /* If it's possible to reference the symbol using auipc we do so, as that's
1815 more in the spirit of the PC-relative relocations we're processing. */
1816 bfd_vma offset
= addr
- pc
;
1817 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1820 /* If it's impossible to reference this with a LUI-based offset then don't
1821 bother to convert it at all so users still see the PC-relative relocation
1822 in the truncation message. */
1823 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1826 rel
->r_info
= ELFNN_R_INFO (addr
, R_RISCV_HI20
);
1828 bfd_vma insn
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1829 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1830 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1835 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1836 bfd_vma value
, bfd_boolean absolute
)
1838 bfd_vma offset
= absolute
? value
: value
- addr
;
1839 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1840 riscv_pcrel_hi_reloc
**slot
=
1841 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1843 BFD_ASSERT (*slot
== NULL
);
1844 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1852 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1853 asection
*input_section
,
1854 struct bfd_link_info
*info
,
1855 reloc_howto_type
*howto
,
1856 const Elf_Internal_Rela
*reloc
,
1861 riscv_pcrel_lo_reloc
*entry
;
1862 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1865 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1866 name
, contents
, p
->lo_relocs
};
1867 p
->lo_relocs
= entry
;
1872 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1874 riscv_pcrel_lo_reloc
*r
;
1876 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1878 bfd
*input_bfd
= r
->input_section
->owner
;
1880 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1881 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1883 /* Check for overflow into bit 11 when adding reloc addend. */
1884 || (!(entry
->value
& 0x800)
1885 && ((entry
->value
+ r
->reloc
->r_addend
) & 0x800)))
1887 char *string
= (entry
== NULL
1888 ? "%pcrel_lo missing matching %pcrel_hi"
1889 : "%pcrel_lo overflow with an addend");
1890 (*r
->info
->callbacks
->reloc_dangerous
)
1891 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1895 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1896 input_bfd
, r
->contents
);
1902 /* Relocate a RISC-V ELF section.
1904 The RELOCATE_SECTION function is called by the new ELF backend linker
1905 to handle the relocations for a section.
1907 The relocs are always passed as Rela structures.
1909 This function is responsible for adjusting the section contents as
1910 necessary, and (if generating a relocatable output file) adjusting
1911 the reloc addend as necessary.
1913 This function does not have to worry about setting the reloc
1914 address or the reloc symbol index.
1916 LOCAL_SYMS is a pointer to the swapped in local symbols.
1918 LOCAL_SECTIONS is an array giving the section in the input file
1919 corresponding to the st_shndx field of each local symbol.
1921 The global hash table entry for the global symbols can be found
1922 via elf_sym_hashes (input_bfd).
1924 When generating relocatable output, this function must handle
1925 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1926 going to be the section symbol corresponding to the output
1927 section, which means that the addend must be adjusted
1931 riscv_elf_relocate_section (bfd
*output_bfd
,
1932 struct bfd_link_info
*info
,
1934 asection
*input_section
,
1936 Elf_Internal_Rela
*relocs
,
1937 Elf_Internal_Sym
*local_syms
,
1938 asection
**local_sections
)
1940 Elf_Internal_Rela
*rel
;
1941 Elf_Internal_Rela
*relend
;
1942 riscv_pcrel_relocs pcrel_relocs
;
1943 bfd_boolean ret
= FALSE
;
1944 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1945 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1946 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1947 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1948 bfd_boolean absolute
;
1950 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1953 relend
= relocs
+ input_section
->reloc_count
;
1954 for (rel
= relocs
; rel
< relend
; rel
++)
1956 unsigned long r_symndx
;
1957 struct elf_link_hash_entry
*h
;
1958 Elf_Internal_Sym
*sym
;
1961 bfd_reloc_status_type r
= bfd_reloc_ok
;
1962 const char *name
= NULL
;
1963 bfd_vma off
, ie_off
;
1964 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1965 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1966 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1967 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1968 const char *msg
= NULL
;
1969 char *msg_buf
= NULL
;
1970 bfd_boolean resolved_to_zero
;
1973 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1976 /* This is a final link. */
1977 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1981 unresolved_reloc
= FALSE
;
1982 if (r_symndx
< symtab_hdr
->sh_info
)
1984 sym
= local_syms
+ r_symndx
;
1985 sec
= local_sections
[r_symndx
];
1986 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1988 /* Relocate against local STT_GNU_IFUNC symbol. */
1989 if (!bfd_link_relocatable (info
)
1990 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
1992 h
= riscv_elf_get_local_sym_hash (htab
, input_bfd
, rel
, FALSE
);
1996 /* Set STT_GNU_IFUNC symbol value. */
1997 h
->root
.u
.def
.value
= sym
->st_value
;
1998 h
->root
.u
.def
.section
= sec
;
2003 bfd_boolean warned
, ignored
;
2005 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2006 r_symndx
, symtab_hdr
, sym_hashes
,
2008 unresolved_reloc
, warned
, ignored
);
2011 /* To avoid generating warning messages about truncated
2012 relocations, set the relocation's address to be the same as
2013 the start of this section. */
2014 if (input_section
->output_section
!= NULL
)
2015 relocation
= input_section
->output_section
->vma
;
2021 if (sec
!= NULL
&& discarded_section (sec
))
2022 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2023 rel
, 1, relend
, howto
, 0, contents
);
2025 if (bfd_link_relocatable (info
))
2028 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2029 it here if it is defined in a non-shared object. */
2031 && h
->type
== STT_GNU_IFUNC
2034 asection
*plt
, *base_got
;
2036 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2038 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2039 STT_GNU_IFUNC symbol as STT_FUNC. */
2040 if (elf_section_type (input_section
) == SHT_NOTE
)
2043 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2044 sections because such sections are not SEC_ALLOC and
2045 thus ld.so will not process them. */
2046 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
2051 else if (h
->plt
.offset
== (bfd_vma
) -1
2052 /* The following relocation may not need the .plt entries
2053 when all references to a STT_GNU_IFUNC symbols are done
2054 via GOT or static function pointers. */
2055 && r_type
!= R_RISCV_32
2056 && r_type
!= R_RISCV_64
2057 && r_type
!= R_RISCV_HI20
2058 && r_type
!= R_RISCV_GOT_HI20
2059 && r_type
!= R_RISCV_LO12_I
2060 && r_type
!= R_RISCV_LO12_S
)
2061 goto bad_ifunc_reloc
;
2063 /* STT_GNU_IFUNC symbol must go through PLT. */
2064 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2065 relocation
= plt
->output_section
->vma
2066 + plt
->output_offset
2073 if (rel
->r_addend
!= 0)
2075 if (h
->root
.root
.string
)
2076 name
= h
->root
.root
.string
;
2078 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2081 /* xgettext:c-format */
2082 (_("%pB: relocation %s against STT_GNU_IFUNC "
2083 "symbol `%s' has non-zero addend: %" PRId64
),
2084 input_bfd
, howto
->name
, name
, (int64_t) rel
->r_addend
);
2085 bfd_set_error (bfd_error_bad_value
);
2089 /* Generate dynamic relocation only when there is a non-GOT
2090 reference in a shared object or there is no PLT. */
2091 if ((bfd_link_pic (info
) && h
->non_got_ref
)
2092 || h
->plt
.offset
== (bfd_vma
) -1)
2094 Elf_Internal_Rela outrel
;
2097 /* Need a dynamic relocation to get the real function
2099 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2103 if (outrel
.r_offset
== (bfd_vma
) -1
2104 || outrel
.r_offset
== (bfd_vma
) -2)
2107 outrel
.r_offset
+= input_section
->output_section
->vma
2108 + input_section
->output_offset
;
2110 if (h
->dynindx
== -1
2112 || bfd_link_executable (info
))
2114 info
->callbacks
->minfo
2115 (_("Local IFUNC function `%s' in %pB\n"),
2116 h
->root
.root
.string
,
2117 h
->root
.u
.def
.section
->owner
);
2119 /* This symbol is resolved locally. */
2120 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2121 outrel
.r_addend
= h
->root
.u
.def
.value
2122 + h
->root
.u
.def
.section
->output_section
->vma
2123 + h
->root
.u
.def
.section
->output_offset
;
2127 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2128 outrel
.r_addend
= 0;
2131 /* Dynamic relocations are stored in
2132 1. .rela.ifunc section in PIC object.
2133 2. .rela.got section in dynamic executable.
2134 3. .rela.iplt section in static executable. */
2135 if (bfd_link_pic (info
))
2136 sreloc
= htab
->elf
.irelifunc
;
2137 else if (htab
->elf
.splt
!= NULL
)
2138 sreloc
= htab
->elf
.srelgot
;
2140 sreloc
= htab
->elf
.irelplt
;
2142 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2144 /* If this reloc is against an external symbol, we
2145 do not want to fiddle with the addend. Otherwise,
2146 we need to include the symbol value so that it
2147 becomes an addend for the dynamic reloc. For an
2148 internal symbol, we have updated addend. */
2153 case R_RISCV_GOT_HI20
:
2154 base_got
= htab
->elf
.sgot
;
2155 off
= h
->got
.offset
;
2157 if (base_got
== NULL
)
2160 if (off
== (bfd_vma
) -1)
2164 /* We can't use h->got.offset here to save state, or
2165 even just remember the offset, as finish_dynamic_symbol
2166 would use that as offset into .got. */
2168 if (htab
->elf
.splt
!= NULL
)
2170 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
)
2172 off
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2173 base_got
= htab
->elf
.sgotplt
;
2177 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2178 off
= plt_idx
* GOT_ENTRY_SIZE
;
2179 base_got
= htab
->elf
.igotplt
;
2182 if (h
->dynindx
== -1
2186 /* This references the local definition. We must
2187 initialize this entry in the global offset table.
2188 Since the offset must always be a multiple of 8,
2189 we use the least significant bit to record
2190 whether we have initialized it already.
2192 When doing a dynamic link, we create a .rela.got
2193 relocation entry to initialize the value. This
2194 is done in the finish_dynamic_symbol routine. */
2199 bfd_put_NN (output_bfd
, relocation
,
2200 base_got
->contents
+ off
);
2201 /* Note that this is harmless for the case,
2202 as -1 | 1 still is -1. */
2208 relocation
= base_got
->output_section
->vma
2209 + base_got
->output_offset
+ off
;
2211 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2212 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2214 r
= bfd_reloc_notsupported
;
2215 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2217 r
= bfd_reloc_overflow
;
2221 case R_RISCV_CALL_PLT
:
2223 case R_RISCV_LO12_I
:
2224 case R_RISCV_LO12_S
:
2227 case R_RISCV_PCREL_HI20
:
2228 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2229 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2231 r
= bfd_reloc_notsupported
;
2232 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2234 r
= bfd_reloc_overflow
;
2239 if (h
->root
.root
.string
)
2240 name
= h
->root
.root
.string
;
2242 /* The entry of local ifunc is fake in global hash table,
2243 we should find the name by the original local symbol. */
2244 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2247 /* xgettext:c-format */
2248 (_("%pB: relocation %s against STT_GNU_IFUNC "
2249 "symbol `%s' isn't supported"), input_bfd
,
2251 bfd_set_error (bfd_error_bad_value
);
2258 name
= h
->root
.root
.string
;
2261 name
= (bfd_elf_string_from_elf_section
2262 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2263 if (name
== NULL
|| *name
== '\0')
2264 name
= bfd_section_name (sec
);
2267 resolved_to_zero
= (h
!= NULL
2268 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
2274 case R_RISCV_TPREL_ADD
:
2276 case R_RISCV_JUMP_SLOT
:
2277 case R_RISCV_RELATIVE
:
2278 /* These require nothing of us at all. */
2282 case R_RISCV_BRANCH
:
2283 case R_RISCV_RVC_BRANCH
:
2284 case R_RISCV_RVC_LUI
:
2285 case R_RISCV_LO12_I
:
2286 case R_RISCV_LO12_S
:
2291 case R_RISCV_32_PCREL
:
2292 case R_RISCV_DELETE
:
2293 /* These require no special handling beyond perform_relocation. */
2296 case R_RISCV_GOT_HI20
:
2299 bfd_boolean dyn
, pic
;
2301 off
= h
->got
.offset
;
2302 BFD_ASSERT (off
!= (bfd_vma
) -1);
2303 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2304 pic
= bfd_link_pic (info
);
2306 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2307 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
2309 /* This is actually a static link, or it is a
2310 -Bsymbolic link and the symbol is defined
2311 locally, or the symbol was forced to be local
2312 because of a version file. We must initialize
2313 this entry in the global offset table. Since the
2314 offset must always be a multiple of the word size,
2315 we use the least significant bit to record whether
2316 we have initialized it already.
2318 When doing a dynamic link, we create a .rela.got
2319 relocation entry to initialize the value. This
2320 is done in the finish_dynamic_symbol routine. */
2325 bfd_put_NN (output_bfd
, relocation
,
2326 htab
->elf
.sgot
->contents
+ off
);
2331 unresolved_reloc
= FALSE
;
2335 BFD_ASSERT (local_got_offsets
!= NULL
2336 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2338 off
= local_got_offsets
[r_symndx
];
2340 /* The offset must always be a multiple of the word size.
2341 So, we can use the least significant bit to record
2342 whether we have already processed this entry. */
2347 if (bfd_link_pic (info
))
2350 Elf_Internal_Rela outrel
;
2352 /* We need to generate a R_RISCV_RELATIVE reloc
2353 for the dynamic linker. */
2354 s
= htab
->elf
.srelgot
;
2355 BFD_ASSERT (s
!= NULL
);
2357 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2359 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2360 outrel
.r_addend
= relocation
;
2362 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
2365 bfd_put_NN (output_bfd
, relocation
,
2366 htab
->elf
.sgot
->contents
+ off
);
2367 local_got_offsets
[r_symndx
] |= 1;
2370 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
2371 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2378 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2379 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2381 r
= bfd_reloc_notsupported
;
2382 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2383 relocation
, absolute
))
2384 r
= bfd_reloc_overflow
;
2392 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2393 contents
+ rel
->r_offset
);
2394 relocation
= old_value
+ relocation
;
2404 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2405 contents
+ rel
->r_offset
);
2406 relocation
= old_value
- relocation
;
2411 case R_RISCV_CALL_PLT
:
2412 /* Handle a call to an undefined weak function. This won't be
2413 relaxed, so we have to handle it here. */
2414 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
2415 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
2417 /* We can use x0 as the base register. */
2418 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
2419 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2420 bfd_putl32 (insn
, contents
+ rel
->r_offset
+ 4);
2421 /* Set the relocation value so that we get 0 after the pc
2422 relative adjustment. */
2423 relocation
= sec_addr (input_section
) + rel
->r_offset
;
2428 case R_RISCV_RVC_JUMP
:
2429 /* This line has to match the check in _bfd_riscv_relax_section. */
2430 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
2432 /* Refer to the PLT entry. */
2433 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
2434 unresolved_reloc
= FALSE
;
2438 case R_RISCV_TPREL_HI20
:
2439 relocation
= tpoff (info
, relocation
);
2442 case R_RISCV_TPREL_LO12_I
:
2443 case R_RISCV_TPREL_LO12_S
:
2444 relocation
= tpoff (info
, relocation
);
2447 case R_RISCV_TPREL_I
:
2448 case R_RISCV_TPREL_S
:
2449 relocation
= tpoff (info
, relocation
);
2450 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
2452 /* We can use tp as the base register. */
2453 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2454 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2455 insn
|= X_TP
<< OP_SH_RS1
;
2456 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2459 r
= bfd_reloc_overflow
;
2462 case R_RISCV_GPREL_I
:
2463 case R_RISCV_GPREL_S
:
2465 bfd_vma gp
= riscv_global_pointer_value (info
);
2466 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2467 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2469 /* We can use x0 or gp as the base register. */
2470 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2471 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2474 rel
->r_addend
-= gp
;
2475 insn
|= X_GP
<< OP_SH_RS1
;
2477 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2480 r
= bfd_reloc_overflow
;
2484 case R_RISCV_PCREL_HI20
:
2485 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2492 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2493 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2495 r
= bfd_reloc_notsupported
;
2496 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2497 relocation
+ rel
->r_addend
,
2499 r
= bfd_reloc_overflow
;
2502 case R_RISCV_PCREL_LO12_I
:
2503 case R_RISCV_PCREL_LO12_S
:
2504 /* We don't allow section symbols plus addends as the auipc address,
2505 because then riscv_relax_delete_bytes would have to search through
2506 all relocs to update these addends. This is also ambiguous, as
2507 we do allow offsets to be added to the target address, which are
2508 not to be used to find the auipc address. */
2509 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2510 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2513 msg
= _("%pcrel_lo section symbol with an addend");
2514 r
= bfd_reloc_dangerous
;
2518 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2519 howto
, rel
, relocation
, name
,
2522 r
= bfd_reloc_overflow
;
2525 case R_RISCV_TLS_DTPREL32
:
2526 case R_RISCV_TLS_DTPREL64
:
2527 relocation
= dtpoff (info
, relocation
);
2532 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2535 if ((bfd_link_pic (info
)
2537 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2538 && !resolved_to_zero
)
2539 || h
->root
.type
!= bfd_link_hash_undefweak
)
2540 && (!howto
->pc_relative
2541 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2542 || (!bfd_link_pic (info
)
2548 || h
->root
.type
== bfd_link_hash_undefweak
2549 || h
->root
.type
== bfd_link_hash_undefined
)))
2551 Elf_Internal_Rela outrel
;
2553 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2555 /* When generating a shared object, these relocations
2556 are copied into the output file to be resolved at run
2560 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2562 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2563 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2564 outrel
.r_offset
+= sec_addr (input_section
);
2566 if (skip_dynamic_relocation
)
2567 memset (&outrel
, 0, sizeof outrel
);
2568 else if (h
!= NULL
&& h
->dynindx
!= -1
2569 && !(bfd_link_pic (info
)
2570 && SYMBOLIC_BIND (info
, h
)
2573 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2574 outrel
.r_addend
= rel
->r_addend
;
2578 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2579 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2582 sreloc
= elf_section_data (input_section
)->sreloc
;
2583 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2584 if (skip_static_relocation
)
2589 case R_RISCV_TLS_GOT_HI20
:
2593 case R_RISCV_TLS_GD_HI20
:
2596 off
= h
->got
.offset
;
2601 off
= local_got_offsets
[r_symndx
];
2602 local_got_offsets
[r_symndx
] |= 1;
2605 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2606 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2607 /* If this symbol is referenced by both GD and IE TLS, the IE
2608 reference's GOT slot follows the GD reference's slots. */
2610 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2611 ie_off
= 2 * GOT_ENTRY_SIZE
;
2617 Elf_Internal_Rela outrel
;
2619 bfd_boolean need_relocs
= FALSE
;
2621 if (htab
->elf
.srelgot
== NULL
)
2626 bfd_boolean dyn
, pic
;
2627 dyn
= htab
->elf
.dynamic_sections_created
;
2628 pic
= bfd_link_pic (info
);
2630 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2631 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2635 /* The GOT entries have not been initialized yet. Do it
2636 now, and emit any relocations. */
2637 if ((bfd_link_pic (info
) || indx
!= 0)
2639 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2640 || h
->root
.type
!= bfd_link_hash_undefweak
))
2643 if (tls_type
& GOT_TLS_GD
)
2647 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2648 outrel
.r_addend
= 0;
2649 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2650 bfd_put_NN (output_bfd
, 0,
2651 htab
->elf
.sgot
->contents
+ off
);
2652 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2655 BFD_ASSERT (! unresolved_reloc
);
2656 bfd_put_NN (output_bfd
,
2657 dtpoff (info
, relocation
),
2658 (htab
->elf
.sgot
->contents
2659 + off
+ RISCV_ELF_WORD_BYTES
));
2663 bfd_put_NN (output_bfd
, 0,
2664 (htab
->elf
.sgot
->contents
2665 + off
+ RISCV_ELF_WORD_BYTES
));
2666 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2667 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2668 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2673 /* If we are not emitting relocations for a
2674 general dynamic reference, then we must be in a
2675 static link or an executable link with the
2676 symbol binding locally. Mark it as belonging
2677 to module 1, the executable. */
2678 bfd_put_NN (output_bfd
, 1,
2679 htab
->elf
.sgot
->contents
+ off
);
2680 bfd_put_NN (output_bfd
,
2681 dtpoff (info
, relocation
),
2682 (htab
->elf
.sgot
->contents
2683 + off
+ RISCV_ELF_WORD_BYTES
));
2687 if (tls_type
& GOT_TLS_IE
)
2691 bfd_put_NN (output_bfd
, 0,
2692 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2693 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2695 outrel
.r_addend
= 0;
2697 outrel
.r_addend
= tpoff (info
, relocation
);
2698 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2699 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2703 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2704 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2709 BFD_ASSERT (off
< (bfd_vma
) -2);
2710 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2711 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2713 r
= bfd_reloc_overflow
;
2714 unresolved_reloc
= FALSE
;
2718 r
= bfd_reloc_notsupported
;
2721 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2722 because such sections are not SEC_ALLOC and thus ld.so will
2723 not process them. */
2724 if (unresolved_reloc
2725 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2727 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2728 rel
->r_offset
) != (bfd_vma
) -1)
2733 case R_RISCV_RVC_JUMP
:
2734 if (asprintf (&msg_buf
,
2735 _("%%X%%P: relocation %s against `%s' can "
2736 "not be used when making a shared object; "
2737 "recompile with -fPIC\n"),
2739 h
->root
.root
.string
) == -1)
2744 if (asprintf (&msg_buf
,
2745 _("%%X%%P: unresolvable %s relocation against "
2748 h
->root
.root
.string
) == -1)
2754 r
= bfd_reloc_notsupported
;
2758 if (r
== bfd_reloc_ok
)
2759 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2760 input_bfd
, contents
);
2762 /* We should have already detected the error and set message before.
2763 If the error message isn't set since the linker runs out of memory
2764 or we don't set it before, then we should set the default message
2765 with the "internal error" string here. */
2771 case bfd_reloc_overflow
:
2772 info
->callbacks
->reloc_overflow
2773 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2774 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2777 case bfd_reloc_undefined
:
2778 info
->callbacks
->undefined_symbol
2779 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2783 case bfd_reloc_outofrange
:
2785 msg
= _("%X%P: internal error: out of range error\n");
2788 case bfd_reloc_notsupported
:
2790 msg
= _("%X%P: internal error: unsupported relocation error\n");
2793 case bfd_reloc_dangerous
:
2794 /* The error message should already be set. */
2796 msg
= _("dangerous relocation error");
2797 info
->callbacks
->reloc_dangerous
2798 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2802 msg
= _("%X%P: internal error: unknown error\n");
2806 /* Do not report error message for the dangerous relocation again. */
2807 if (msg
&& r
!= bfd_reloc_dangerous
)
2808 info
->callbacks
->einfo (msg
);
2810 /* Free the unused `msg_buf`. */
2813 /* We already reported the error via a callback, so don't try to report
2814 it again by returning false. That leads to spurious errors. */
2819 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2821 riscv_free_pcrel_relocs (&pcrel_relocs
);
2825 /* Finish up dynamic symbol handling. We set the contents of various
2826 dynamic sections here. */
2829 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2830 struct bfd_link_info
*info
,
2831 struct elf_link_hash_entry
*h
,
2832 Elf_Internal_Sym
*sym
)
2834 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2835 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2837 if (h
->plt
.offset
!= (bfd_vma
) -1)
2839 /* We've decided to create a PLT entry for this symbol. */
2841 bfd_vma i
, header_address
, plt_idx
, got_offset
, got_address
;
2842 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2843 Elf_Internal_Rela rela
;
2844 asection
*plt
, *gotplt
, *relplt
;
2846 /* When building a static executable, use .iplt, .igot.plt and
2847 .rela.iplt sections for STT_GNU_IFUNC symbols. */
2848 if (htab
->elf
.splt
!= NULL
)
2850 plt
= htab
->elf
.splt
;
2851 gotplt
= htab
->elf
.sgotplt
;
2852 relplt
= htab
->elf
.srelplt
;
2856 plt
= htab
->elf
.iplt
;
2857 gotplt
= htab
->elf
.igotplt
;
2858 relplt
= htab
->elf
.irelplt
;
2861 /* This symbol has an entry in the procedure linkage table. Set
2863 if ((h
->dynindx
== -1
2864 && !((h
->forced_local
|| bfd_link_executable (info
))
2866 && h
->type
== STT_GNU_IFUNC
))
2872 /* Calculate the address of the PLT header. */
2873 header_address
= sec_addr (plt
);
2875 /* Calculate the index of the entry and the offset of .got.plt entry.
2876 For static executables, we don't reserve anything. */
2877 if (plt
== htab
->elf
.splt
)
2879 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2880 got_offset
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2884 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2885 got_offset
= plt_idx
* GOT_ENTRY_SIZE
;
2888 /* Calculate the address of the .got.plt entry. */
2889 got_address
= sec_addr (gotplt
) + got_offset
;
2891 /* Find out where the .plt entry should go. */
2892 loc
= plt
->contents
+ h
->plt
.offset
;
2894 /* Fill in the PLT entry itself. */
2895 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2896 header_address
+ h
->plt
.offset
,
2900 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2901 bfd_putl32 (plt_entry
[i
], loc
+ 4*i
);
2903 /* Fill in the initial value of the .got.plt entry. */
2904 loc
= gotplt
->contents
+ (got_address
- sec_addr (gotplt
));
2905 bfd_put_NN (output_bfd
, sec_addr (plt
), loc
);
2907 rela
.r_offset
= got_address
;
2909 if (h
->dynindx
== -1
2910 || ((bfd_link_executable (info
)
2911 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2913 && h
->type
== STT_GNU_IFUNC
))
2915 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2916 h
->root
.root
.string
,
2917 h
->root
.u
.def
.section
->owner
);
2919 /* If an STT_GNU_IFUNC symbol is locally defined, generate
2920 R_RISCV_IRELATIVE instead of R_RISCV_JUMP_SLOT. */
2921 asection
*sec
= h
->root
.u
.def
.section
;
2922 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2923 rela
.r_addend
= h
->root
.u
.def
.value
2924 + sec
->output_section
->vma
2925 + sec
->output_offset
;
2929 /* Fill in the entry in the .rela.plt section. */
2930 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2934 loc
= relplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2935 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2937 if (!h
->def_regular
)
2939 /* Mark the symbol as undefined, rather than as defined in
2940 the .plt section. Leave the value alone. */
2941 sym
->st_shndx
= SHN_UNDEF
;
2942 /* If the symbol is weak, we do need to clear the value.
2943 Otherwise, the PLT entry would provide a definition for
2944 the symbol even if the symbol wasn't defined anywhere,
2945 and so the symbol would never be NULL. */
2946 if (!h
->ref_regular_nonweak
)
2951 if (h
->got
.offset
!= (bfd_vma
) -1
2952 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2953 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2957 Elf_Internal_Rela rela
;
2958 bfd_boolean use_elf_append_rela
= TRUE
;
2960 /* This symbol has an entry in the GOT. Set it up. */
2962 sgot
= htab
->elf
.sgot
;
2963 srela
= htab
->elf
.srelgot
;
2964 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2966 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2968 /* Handle the ifunc symbol in GOT entry. */
2970 && h
->type
== STT_GNU_IFUNC
)
2972 if (h
->plt
.offset
== (bfd_vma
) -1)
2974 /* STT_GNU_IFUNC is referenced without PLT. */
2976 if (htab
->elf
.splt
== NULL
)
2978 /* Use .rela.iplt section to store .got relocations
2979 in static executable. */
2980 srela
= htab
->elf
.irelplt
;
2982 /* Do not use riscv_elf_append_rela to add dynamic
2984 use_elf_append_rela
= FALSE
;
2987 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
2989 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2990 h
->root
.root
.string
,
2991 h
->root
.u
.def
.section
->owner
);
2993 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2994 rela
.r_addend
= (h
->root
.u
.def
.value
2995 + h
->root
.u
.def
.section
->output_section
->vma
2996 + h
->root
.u
.def
.section
->output_offset
);
3000 /* Generate R_RISCV_NN. */
3001 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3002 BFD_ASSERT (h
->dynindx
!= -1);
3003 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3007 else if (bfd_link_pic (info
))
3009 /* Generate R_RISCV_NN. */
3010 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3011 BFD_ASSERT (h
->dynindx
!= -1);
3012 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3019 if (!h
->pointer_equality_needed
)
3022 /* For non-shared object, we can't use .got.plt, which
3023 contains the real function address if we need pointer
3024 equality. We load the GOT entry with the PLT entry. */
3025 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3026 bfd_put_NN (output_bfd
, (plt
->output_section
->vma
3027 + plt
->output_offset
3029 htab
->elf
.sgot
->contents
3030 + (h
->got
.offset
& ~(bfd_vma
) 1));
3034 else if (bfd_link_pic (info
)
3035 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3037 /* If this is a local symbol reference, we just want to emit
3038 a RELATIVE reloc. This can happen if it is a -Bsymbolic link,
3039 or a pie link, or the symbol was forced to be local because
3040 of a version file. The entry in the global offset table will
3041 already have been initialized in the relocate_section function. */
3042 BFD_ASSERT ((h
->got
.offset
& 1) != 0);
3043 asection
*sec
= h
->root
.u
.def
.section
;
3044 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
3045 rela
.r_addend
= (h
->root
.u
.def
.value
3046 + sec
->output_section
->vma
3047 + sec
->output_offset
);
3051 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3052 BFD_ASSERT (h
->dynindx
!= -1);
3053 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3057 bfd_put_NN (output_bfd
, 0,
3058 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3060 if (use_elf_append_rela
)
3061 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
3064 /* Use riscv_elf_append_rela to add the dynamic relocs into
3065 .rela.iplt may cause the overwrite problems. Since we insert
3066 the relocs for PLT didn't handle the reloc_index of .rela.iplt,
3067 but the riscv_elf_append_rela adds the relocs to the place
3068 that are calculated from the reloc_index (in seqential).
3070 One solution is that add these dynamic relocs (GOT IFUNC)
3071 from the last of .rela.iplt section. */
3072 bfd_vma iplt_idx
= htab
->last_iplt_index
--;
3073 bfd_byte
*loc
= srela
->contents
3074 + iplt_idx
* sizeof (ElfNN_External_Rela
);
3075 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
3081 Elf_Internal_Rela rela
;
3084 /* This symbols needs a copy reloc. Set it up. */
3085 BFD_ASSERT (h
->dynindx
!= -1);
3087 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3088 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
3090 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
3091 s
= htab
->elf
.sreldynrelro
;
3093 s
= htab
->elf
.srelbss
;
3094 riscv_elf_append_rela (output_bfd
, s
, &rela
);
3097 /* Mark some specially defined symbols as absolute. */
3098 if (h
== htab
->elf
.hdynamic
3099 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
3100 sym
->st_shndx
= SHN_ABS
;
3105 /* Finish up local dynamic symbol handling. We set the contents of
3106 various dynamic sections here. */
3109 riscv_elf_finish_local_dynamic_symbol (void **slot
, void *inf
)
3111 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) *slot
;
3112 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3114 return riscv_elf_finish_dynamic_symbol (info
->output_bfd
, info
, h
, NULL
);
3117 /* Finish up the dynamic sections. */
3120 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3121 bfd
*dynobj
, asection
*sdyn
)
3123 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3124 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
3125 size_t dynsize
= bed
->s
->sizeof_dyn
;
3126 bfd_byte
*dyncon
, *dynconend
;
3128 dynconend
= sdyn
->contents
+ sdyn
->size
;
3129 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
3131 Elf_Internal_Dyn dyn
;
3134 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
3139 s
= htab
->elf
.sgotplt
;
3140 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3143 s
= htab
->elf
.srelplt
;
3144 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3147 s
= htab
->elf
.srelplt
;
3148 dyn
.d_un
.d_val
= s
->size
;
3154 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3160 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
3161 struct bfd_link_info
*info
)
3165 struct riscv_elf_link_hash_table
*htab
;
3167 htab
= riscv_elf_hash_table (info
);
3168 BFD_ASSERT (htab
!= NULL
);
3169 dynobj
= htab
->elf
.dynobj
;
3171 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3173 if (elf_hash_table (info
)->dynamic_sections_created
)
3178 splt
= htab
->elf
.splt
;
3179 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3181 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
3186 /* Fill in the head and tail entries in the procedure linkage table. */
3190 uint32_t plt_header
[PLT_HEADER_INSNS
];
3191 ret
= riscv_make_plt_header (output_bfd
,
3192 sec_addr (htab
->elf
.sgotplt
),
3193 sec_addr (splt
), plt_header
);
3197 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
3198 bfd_putl32 (plt_header
[i
], splt
->contents
+ 4*i
);
3200 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
3205 if (htab
->elf
.sgotplt
)
3207 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
3209 if (bfd_is_abs_section (output_section
))
3211 (*_bfd_error_handler
)
3212 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
3216 if (htab
->elf
.sgotplt
->size
> 0)
3218 /* Write the first two entries in .got.plt, needed for the dynamic
3220 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
3221 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
3222 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
3225 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3230 asection
*output_section
= htab
->elf
.sgot
->output_section
;
3232 if (htab
->elf
.sgot
->size
> 0)
3234 /* Set the first entry in the global offset table to the address of
3235 the dynamic section. */
3236 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
3237 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
3240 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3243 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
3244 htab_traverse (htab
->loc_hash_table
,
3245 riscv_elf_finish_local_dynamic_symbol
,
3251 /* Return address for Ith PLT stub in section PLT, for relocation REL
3252 or (bfd_vma) -1 if it should not be included. */
3255 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
3256 const arelent
*rel ATTRIBUTE_UNUSED
)
3258 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
3261 static enum elf_reloc_type_class
3262 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3263 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3264 const Elf_Internal_Rela
*rela
)
3266 switch (ELFNN_R_TYPE (rela
->r_info
))
3268 case R_RISCV_RELATIVE
:
3269 return reloc_class_relative
;
3270 case R_RISCV_JUMP_SLOT
:
3271 return reloc_class_plt
;
3273 return reloc_class_copy
;
3275 return reloc_class_normal
;
3279 /* Given the ELF header flags in FLAGS, it returns a string that describes the
3283 riscv_float_abi_string (flagword flags
)
3285 switch (flags
& EF_RISCV_FLOAT_ABI
)
3287 case EF_RISCV_FLOAT_ABI_SOFT
:
3288 return "soft-float";
3290 case EF_RISCV_FLOAT_ABI_SINGLE
:
3291 return "single-float";
3293 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3294 return "double-float";
3296 case EF_RISCV_FLOAT_ABI_QUAD
:
3297 return "quad-float";
3304 /* The information of architecture elf attributes. */
3305 static riscv_subset_list_t in_subsets
;
3306 static riscv_subset_list_t out_subsets
;
3307 static riscv_subset_list_t merged_subsets
;
3309 /* Predicator for standard extension. */
3312 riscv_std_ext_p (const char *name
)
3314 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
3317 /* Check if the versions are compatible. */
3320 riscv_version_mismatch (bfd
*ibfd
,
3321 struct riscv_subset_t
*in
,
3322 struct riscv_subset_t
*out
)
3324 if (in
== NULL
|| out
== NULL
)
3327 /* Since there are no version conflicts for now, we just report
3328 warning when the versions are mis-matched. */
3329 if (in
->major_version
!= out
->major_version
3330 || in
->minor_version
!= out
->minor_version
)
3333 (_("warning: %pB: mis-matched ISA version %d.%d for '%s' "
3334 "extension, the output version is %d.%d"),
3340 out
->minor_version
);
3342 /* Update the output ISA versions to the newest ones. */
3343 if ((in
->major_version
> out
->major_version
)
3344 || (in
->major_version
== out
->major_version
3345 && in
->minor_version
> out
->minor_version
))
3347 out
->major_version
= in
->major_version
;
3348 out
->minor_version
= in
->minor_version
;
3355 /* Return true if subset is 'i' or 'e'. */
3358 riscv_i_or_e_p (bfd
*ibfd
,
3360 struct riscv_subset_t
*subset
)
3362 if ((strcasecmp (subset
->name
, "e") != 0)
3363 && (strcasecmp (subset
->name
, "i") != 0))
3366 (_("error: %pB: corrupted ISA string '%s'. "
3367 "First letter should be 'i' or 'e' but got '%s'"),
3368 ibfd
, arch
, subset
->name
);
3374 /* Merge standard extensions.
3377 Return FALSE if failed to merge.
3381 `in_arch`: Raw ISA string for input object.
3382 `out_arch`: Raw ISA string for output object.
3383 `pin`: Subset list for input object.
3384 `pout`: Subset list for output object. */
3387 riscv_merge_std_ext (bfd
*ibfd
,
3388 const char *in_arch
,
3389 const char *out_arch
,
3390 struct riscv_subset_t
**pin
,
3391 struct riscv_subset_t
**pout
)
3393 const char *standard_exts
= riscv_supported_std_ext ();
3395 struct riscv_subset_t
*in
= *pin
;
3396 struct riscv_subset_t
*out
= *pout
;
3398 /* First letter should be 'i' or 'e'. */
3399 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
3402 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
3405 if (strcasecmp (in
->name
, out
->name
) != 0)
3407 /* TODO: We might allow merge 'i' with 'e'. */
3409 (_("error: %pB: mis-matched ISA string to merge '%s' and '%s'"),
3410 ibfd
, in
->name
, out
->name
);
3413 else if (!riscv_version_mismatch (ibfd
, in
, out
))
3416 riscv_add_subset (&merged_subsets
,
3417 out
->name
, out
->major_version
, out
->minor_version
);
3422 /* Handle standard extension first. */
3423 for (p
= standard_exts
; *p
; ++p
)
3425 struct riscv_subset_t
*ext_in
, *ext_out
, *ext_merged
;
3426 char find_ext
[2] = {*p
, '\0'};
3427 bfd_boolean find_in
, find_out
;
3429 find_in
= riscv_lookup_subset (&in_subsets
, find_ext
, &ext_in
);
3430 find_out
= riscv_lookup_subset (&out_subsets
, find_ext
, &ext_out
);
3432 if (!find_in
&& !find_out
)
3437 && !riscv_version_mismatch (ibfd
, ext_in
, ext_out
))
3440 ext_merged
= find_out
? ext_out
: ext_in
;
3441 riscv_add_subset (&merged_subsets
, ext_merged
->name
,
3442 ext_merged
->major_version
, ext_merged
->minor_version
);
3445 /* Skip all standard extensions. */
3446 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
3447 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
3455 /* Merge multi letter extensions. PIN is a pointer to the head of the input
3456 object subset list. Likewise for POUT and the output object. Return TRUE
3457 on success and FALSE when a conflict is found. */
3460 riscv_merge_multi_letter_ext (bfd
*ibfd
,
3461 riscv_subset_t
**pin
,
3462 riscv_subset_t
**pout
)
3464 riscv_subset_t
*in
= *pin
;
3465 riscv_subset_t
*out
= *pout
;
3466 riscv_subset_t
*tail
;
3472 cmp
= riscv_compare_subsets (in
->name
, out
->name
);
3476 /* `in' comes before `out', append `in' and increment. */
3477 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
3483 /* `out' comes before `in', append `out' and increment. */
3484 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3485 out
->minor_version
);
3490 /* Both present, check version and increment both. */
3491 if (!riscv_version_mismatch (ibfd
, in
, out
))
3494 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3495 out
->minor_version
);
3503 /* If we're here, either `in' or `out' is running longer than
3504 the other. So, we need to append the corresponding tail. */
3505 tail
= in
? in
: out
;
3508 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
3509 tail
->minor_version
);
3517 /* Merge Tag_RISCV_arch attribute. */
3520 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
3522 riscv_subset_t
*in
, *out
;
3523 char *merged_arch_str
;
3525 unsigned xlen_in
, xlen_out
;
3526 merged_subsets
.head
= NULL
;
3527 merged_subsets
.tail
= NULL
;
3529 riscv_parse_subset_t rpe_in
;
3530 riscv_parse_subset_t rpe_out
;
3532 /* Only assembler needs to check the default version of ISA, so just set
3533 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */
3534 rpe_in
.subset_list
= &in_subsets
;
3535 rpe_in
.error_handler
= _bfd_error_handler
;
3536 rpe_in
.xlen
= &xlen_in
;
3537 rpe_in
.get_default_version
= NULL
;
3539 rpe_out
.subset_list
= &out_subsets
;
3540 rpe_out
.error_handler
= _bfd_error_handler
;
3541 rpe_out
.xlen
= &xlen_out
;
3542 rpe_out
.get_default_version
= NULL
;
3544 if (in_arch
== NULL
&& out_arch
== NULL
)
3547 if (in_arch
== NULL
&& out_arch
!= NULL
)
3550 if (in_arch
!= NULL
&& out_arch
== NULL
)
3553 /* Parse subset from ISA string. */
3554 if (!riscv_parse_subset (&rpe_in
, in_arch
))
3557 if (!riscv_parse_subset (&rpe_out
, out_arch
))
3560 /* Checking XLEN. */
3561 if (xlen_out
!= xlen_in
)
3564 (_("error: %pB: ISA string of input (%s) doesn't match "
3565 "output (%s)"), ibfd
, in_arch
, out_arch
);
3569 /* Merge subset list. */
3570 in
= in_subsets
.head
;
3571 out
= out_subsets
.head
;
3573 /* Merge standard extension. */
3574 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
3577 /* Merge all non-single letter extensions with single call. */
3578 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
3581 if (xlen_in
!= xlen_out
)
3584 (_("error: %pB: XLEN of input (%u) doesn't match "
3585 "output (%u)"), ibfd
, xlen_in
, xlen_out
);
3589 if (xlen_in
!= ARCH_SIZE
)
3592 (_("error: %pB: unsupported XLEN (%u), you might be "
3593 "using wrong emulation"), ibfd
, xlen_in
);
3597 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
3599 /* Release the subset lists. */
3600 riscv_release_subset_list (&in_subsets
);
3601 riscv_release_subset_list (&out_subsets
);
3602 riscv_release_subset_list (&merged_subsets
);
3604 return merged_arch_str
;
3607 /* Merge object attributes from IBFD into output_bfd of INFO.
3608 Raise an error if there are conflicting attributes. */
3611 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3613 bfd
*obfd
= info
->output_bfd
;
3614 obj_attribute
*in_attr
;
3615 obj_attribute
*out_attr
;
3616 bfd_boolean result
= TRUE
;
3617 bfd_boolean priv_attrs_merged
= FALSE
;
3618 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3621 /* Skip linker created files. */
3622 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3625 /* Skip any input that doesn't have an attribute section.
3626 This enables to link object files without attribute section with
3628 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3631 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3633 /* This is the first object. Copy the attributes. */
3634 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3636 out_attr
= elf_known_obj_attributes_proc (obfd
);
3638 /* Use the Tag_null value to indicate the attributes have been
3645 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3646 out_attr
= elf_known_obj_attributes_proc (obfd
);
3648 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3652 case Tag_RISCV_arch
:
3653 if (!out_attr
[Tag_RISCV_arch
].s
)
3654 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3655 else if (in_attr
[Tag_RISCV_arch
].s
3656 && out_attr
[Tag_RISCV_arch
].s
)
3658 /* Check compatible. */
3660 riscv_merge_arch_attr_info (ibfd
,
3661 in_attr
[Tag_RISCV_arch
].s
,
3662 out_attr
[Tag_RISCV_arch
].s
);
3663 if (merged_arch
== NULL
)
3666 out_attr
[Tag_RISCV_arch
].s
= "";
3669 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3673 case Tag_RISCV_priv_spec
:
3674 case Tag_RISCV_priv_spec_minor
:
3675 case Tag_RISCV_priv_spec_revision
:
3676 /* If we have handled the privileged elf attributes, then skip it. */
3677 if (!priv_attrs_merged
)
3679 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
3680 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
3681 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
3682 enum riscv_priv_spec_class in_priv_spec
;
3683 enum riscv_priv_spec_class out_priv_spec
;
3685 /* Get the privileged spec class from elf attributes. */
3686 riscv_get_priv_spec_class_from_numbers (in_attr
[Tag_a
].i
,
3690 riscv_get_priv_spec_class_from_numbers (out_attr
[Tag_a
].i
,
3695 /* Allow to link the object without the privileged specs. */
3696 if (out_priv_spec
== PRIV_SPEC_CLASS_NONE
)
3698 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3699 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3700 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3702 else if (in_priv_spec
!= PRIV_SPEC_CLASS_NONE
3703 && in_priv_spec
!= out_priv_spec
)
3706 (_("warning: %pB use privileged spec version %u.%u.%u but "
3707 "the output use version %u.%u.%u"),
3716 /* The privileged spec v1.9.1 can not be linked with others
3717 since the conflicts, so we plan to drop it in a year or
3719 if (in_priv_spec
== PRIV_SPEC_CLASS_1P9P1
3720 || out_priv_spec
== PRIV_SPEC_CLASS_1P9P1
)
3723 (_("warning: privileged spec version 1.9.1 can not be "
3724 "linked with other spec versions"));
3727 /* Update the output privileged spec to the newest one. */
3728 if (in_priv_spec
> out_priv_spec
)
3730 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3731 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3732 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3735 priv_attrs_merged
= TRUE
;
3739 case Tag_RISCV_unaligned_access
:
3740 out_attr
[i
].i
|= in_attr
[i
].i
;
3743 case Tag_RISCV_stack_align
:
3744 if (out_attr
[i
].i
== 0)
3745 out_attr
[i
].i
= in_attr
[i
].i
;
3746 else if (in_attr
[i
].i
!= 0
3747 && out_attr
[i
].i
!= 0
3748 && out_attr
[i
].i
!= in_attr
[i
].i
)
3751 (_("error: %pB use %u-byte stack aligned but the output "
3752 "use %u-byte stack aligned"),
3753 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3759 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3762 /* If out_attr was copied from in_attr then it won't have a type yet. */
3763 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3764 out_attr
[i
].type
= in_attr
[i
].type
;
3767 /* Merge Tag_compatibility attributes and any common GNU ones. */
3768 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3771 /* Check for any attributes not known on RISC-V. */
3772 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3777 /* Merge backend specific data from an object file to the output
3778 object file when linking. */
3781 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3783 bfd
*obfd
= info
->output_bfd
;
3784 flagword new_flags
, old_flags
;
3786 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3789 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3791 (*_bfd_error_handler
)
3792 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3793 " target emulation `%s' does not match `%s'"),
3794 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3798 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3801 if (!riscv_merge_attributes (ibfd
, info
))
3804 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3805 old_flags
= elf_elfheader (obfd
)->e_flags
;
3807 if (! elf_flags_init (obfd
))
3809 elf_flags_init (obfd
) = TRUE
;
3810 elf_elfheader (obfd
)->e_flags
= new_flags
;
3814 /* Check to see if the input BFD actually contains any sections. If not,
3815 its flags may not have been initialized either, but it cannot actually
3816 cause any incompatibility. Do not short-circuit dynamic objects; their
3817 section list may be emptied by elf_link_add_object_symbols.
3819 Also check to see if there are no code sections in the input. In this
3820 case, there is no need to check for code specific flags. */
3821 if (!(ibfd
->flags
& DYNAMIC
))
3823 bfd_boolean null_input_bfd
= TRUE
;
3824 bfd_boolean only_data_sections
= TRUE
;
3827 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3829 if ((bfd_section_flags (sec
)
3830 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3831 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3832 only_data_sections
= FALSE
;
3834 null_input_bfd
= FALSE
;
3838 if (null_input_bfd
|| only_data_sections
)
3842 /* Disallow linking different float ABIs. */
3843 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3845 (*_bfd_error_handler
)
3846 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3847 riscv_float_abi_string (new_flags
),
3848 riscv_float_abi_string (old_flags
));
3852 /* Disallow linking RVE and non-RVE. */
3853 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3855 (*_bfd_error_handler
)
3856 (_("%pB: can't link RVE with other target"), ibfd
);
3860 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3861 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3866 bfd_set_error (bfd_error_bad_value
);
3870 /* Delete some bytes from a section while relaxing. */
3873 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3874 struct bfd_link_info
*link_info
)
3876 unsigned int i
, symcount
;
3877 bfd_vma toaddr
= sec
->size
;
3878 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3879 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3880 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3881 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3882 bfd_byte
*contents
= data
->this_hdr
.contents
;
3884 /* Actually delete the bytes. */
3886 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3888 /* Adjust the location of all of the relocs. Note that we need not
3889 adjust the addends, since all PC-relative references must be against
3890 symbols, which we will adjust below. */
3891 for (i
= 0; i
< sec
->reloc_count
; i
++)
3892 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3893 data
->relocs
[i
].r_offset
-= count
;
3895 /* Adjust the local symbols defined in this section. */
3896 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3898 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3899 if (sym
->st_shndx
== sec_shndx
)
3901 /* If the symbol is in the range of memory we just moved, we
3902 have to adjust its value. */
3903 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3904 sym
->st_value
-= count
;
3906 /* If the symbol *spans* the bytes we just deleted (i.e. its
3907 *end* is in the moved bytes but its *start* isn't), then we
3908 must adjust its size.
3910 This test needs to use the original value of st_value, otherwise
3911 we might accidentally decrease size when deleting bytes right
3912 before the symbol. But since deleted relocs can't span across
3913 symbols, we can't have both a st_value and a st_size decrease,
3914 so it is simpler to just use an else. */
3915 else if (sym
->st_value
<= addr
3916 && sym
->st_value
+ sym
->st_size
> addr
3917 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3918 sym
->st_size
-= count
;
3922 /* Now adjust the global symbols defined in this section. */
3923 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3924 - symtab_hdr
->sh_info
);
3926 for (i
= 0; i
< symcount
; i
++)
3928 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3930 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3931 containing the definition of __wrap_SYMBOL, includes a direct
3932 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3933 the same symbol (which is __wrap_SYMBOL), but still exist as two
3934 different symbols in 'sym_hashes', we don't want to adjust
3935 the global symbol __wrap_SYMBOL twice.
3937 The same problem occurs with symbols that are versioned_hidden, as
3938 foo becomes an alias for foo@BAR, and hence they need the same
3940 if (link_info
->wrap_hash
!= NULL
3941 || sym_hash
->versioned
== versioned_hidden
)
3943 struct elf_link_hash_entry
**cur_sym_hashes
;
3945 /* Loop only over the symbols which have already been checked. */
3946 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3949 /* If the current symbol is identical to 'sym_hash', that means
3950 the symbol was already adjusted (or at least checked). */
3951 if (*cur_sym_hashes
== sym_hash
)
3954 /* Don't adjust the symbol again. */
3955 if (cur_sym_hashes
< &sym_hashes
[i
])
3959 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3960 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3961 && sym_hash
->root
.u
.def
.section
== sec
)
3963 /* As above, adjust the value if needed. */
3964 if (sym_hash
->root
.u
.def
.value
> addr
3965 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3966 sym_hash
->root
.u
.def
.value
-= count
;
3968 /* As above, adjust the size if needed. */
3969 else if (sym_hash
->root
.u
.def
.value
<= addr
3970 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3971 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3972 sym_hash
->size
-= count
;
3979 /* A second format for recording PC-relative hi relocations. This stores the
3980 information required to relax them to GP-relative addresses. */
3982 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3983 struct riscv_pcgp_hi_reloc
3990 bfd_boolean undefined_weak
;
3991 riscv_pcgp_hi_reloc
*next
;
3994 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3995 struct riscv_pcgp_lo_reloc
3998 riscv_pcgp_lo_reloc
*next
;
4003 riscv_pcgp_hi_reloc
*hi
;
4004 riscv_pcgp_lo_reloc
*lo
;
4005 } riscv_pcgp_relocs
;
4007 /* Initialize the pcgp reloc info in P. */
4010 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
4017 /* Free the pcgp reloc info in P. */
4020 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
4021 bfd
*abfd ATTRIBUTE_UNUSED
,
4022 asection
*sec ATTRIBUTE_UNUSED
)
4024 riscv_pcgp_hi_reloc
*c
;
4025 riscv_pcgp_lo_reloc
*l
;
4027 for (c
= p
->hi
; c
!= NULL
; )
4029 riscv_pcgp_hi_reloc
*next
= c
->next
;
4034 for (l
= p
->lo
; l
!= NULL
; )
4036 riscv_pcgp_lo_reloc
*next
= l
->next
;
4042 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
4043 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
4044 relax the corresponding lo part reloc. */
4047 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
4048 bfd_vma hi_addend
, bfd_vma hi_addr
,
4049 unsigned hi_sym
, asection
*sym_sec
,
4050 bfd_boolean undefined_weak
)
4052 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof (*new));
4055 new->hi_sec_off
= hi_sec_off
;
4056 new->hi_addend
= hi_addend
;
4057 new->hi_addr
= hi_addr
;
4058 new->hi_sym
= hi_sym
;
4059 new->sym_sec
= sym_sec
;
4060 new->undefined_weak
= undefined_weak
;
4066 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4067 This is used by a lo part reloc to find the corresponding hi part reloc. */
4069 static riscv_pcgp_hi_reloc
*
4070 riscv_find_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4072 riscv_pcgp_hi_reloc
*c
;
4074 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
4075 if (c
->hi_sec_off
== hi_sec_off
)
4080 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
4081 This is used to record relocs that can't be relaxed. */
4084 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4086 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof (*new));
4089 new->hi_sec_off
= hi_sec_off
;
4095 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4096 This is used by a hi part reloc to find the corresponding lo part reloc. */
4099 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4101 riscv_pcgp_lo_reloc
*c
;
4103 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
4104 if (c
->hi_sec_off
== hi_sec_off
)
4109 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
4110 struct bfd_link_info
*,
4111 Elf_Internal_Rela
*,
4112 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
4113 riscv_pcgp_relocs
*,
4114 bfd_boolean undefined_weak
);
4116 /* Relax AUIPC + JALR into JAL. */
4119 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
4120 struct bfd_link_info
*link_info
,
4121 Elf_Internal_Rela
*rel
,
4123 bfd_vma max_alignment
,
4124 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4126 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4127 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4129 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4130 bfd_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
4131 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/ 2) < RISCV_IMM_REACH
;
4132 bfd_vma auipc
, jalr
;
4133 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4135 /* If the call crosses section boundaries, an alignment directive could
4136 cause the PC-relative offset to later increase, so we need to add in the
4137 max alignment of any section inclusive from the call to the target.
4138 Otherwise, we only need to use the alignment of the current section. */
4139 if (VALID_UJTYPE_IMM (foff
))
4141 if (sym_sec
->output_section
== sec
->output_section
4142 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4143 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4144 foff
+= ((bfd_signed_vma
) foff
< 0 ? -max_alignment
: max_alignment
);
4147 /* See if this function call can be shortened. */
4148 if (!VALID_UJTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
4151 /* Shorten the function call. */
4152 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
4154 auipc
= bfd_getl32 (contents
+ rel
->r_offset
);
4155 jalr
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
4156 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
4157 rvc
= rvc
&& VALID_RVC_J_IMM (foff
);
4159 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
4160 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
4164 /* Relax to C.J[AL] rd, addr. */
4165 r_type
= R_RISCV_RVC_JUMP
;
4166 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
4169 else if (VALID_UJTYPE_IMM (foff
))
4171 /* Relax to JAL rd, addr. */
4172 r_type
= R_RISCV_JAL
;
4173 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
4177 /* Near zero, relax to JALR rd, x0, addr. */
4178 r_type
= R_RISCV_LO12_I
;
4179 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
4182 /* Replace the R_RISCV_CALL reloc. */
4183 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
4184 /* Replace the AUIPC. */
4185 riscv_put_insn (8 * len
, auipc
, contents
+ rel
->r_offset
);
4187 /* Delete unnecessary JALR. */
4189 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
4193 /* Traverse all output sections and return the max alignment. */
4196 _bfd_riscv_get_max_alignment (asection
*sec
)
4198 unsigned int max_alignment_power
= 0;
4201 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
4203 if (o
->alignment_power
> max_alignment_power
)
4204 max_alignment_power
= o
->alignment_power
;
4207 return (bfd_vma
) 1 << max_alignment_power
;
4210 /* Relax non-PIC global variable references to GP-relative references. */
4213 _bfd_riscv_relax_lui (bfd
*abfd
,
4216 struct bfd_link_info
*link_info
,
4217 Elf_Internal_Rela
*rel
,
4219 bfd_vma max_alignment
,
4220 bfd_vma reserve_size
,
4222 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4223 bfd_boolean undefined_weak
)
4225 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4226 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4227 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4229 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4233 /* If gp and the symbol are in the same output section, which is not the
4234 abs section, then consider only that output section's alignment. */
4235 struct bfd_link_hash_entry
*h
=
4236 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
4238 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4239 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4240 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4243 /* Is the reference in range of x0 or gp?
4244 Valid gp range conservatively because of alignment issue. */
4246 || (VALID_ITYPE_IMM (symval
)
4248 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4250 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4252 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
4253 switch (ELFNN_R_TYPE (rel
->r_info
))
4255 case R_RISCV_LO12_I
:
4258 /* Change the RS1 to zero. */
4259 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4260 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4261 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4264 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4267 case R_RISCV_LO12_S
:
4270 /* Change the RS1 to zero. */
4271 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4272 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4273 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4276 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4280 /* We can delete the unnecessary LUI and reloc. */
4281 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4283 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
4291 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
4292 account for this assuming page alignment at worst. In the presence of
4293 RELRO segment the linker aligns it by one page size, therefore sections
4294 after the segment can be moved more than one page. */
4297 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
4298 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
4299 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
4300 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
4301 : ELF_MAXPAGESIZE
)))
4303 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
4304 bfd_vma lui
= bfd_getl32 (contents
+ rel
->r_offset
);
4305 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
4306 if (rd
== 0 || rd
== X_SP
)
4309 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
4310 bfd_putl32 (lui
, contents
+ rel
->r_offset
);
4312 /* Replace the R_RISCV_HI20 reloc. */
4313 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
4316 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
4323 /* Relax non-PIC TLS references to TP-relative references. */
4326 _bfd_riscv_relax_tls_le (bfd
*abfd
,
4328 asection
*sym_sec ATTRIBUTE_UNUSED
,
4329 struct bfd_link_info
*link_info
,
4330 Elf_Internal_Rela
*rel
,
4332 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4333 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4335 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
4336 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4338 /* See if this symbol is in range of tp. */
4339 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
4342 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4343 switch (ELFNN_R_TYPE (rel
->r_info
))
4345 case R_RISCV_TPREL_LO12_I
:
4346 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
4349 case R_RISCV_TPREL_LO12_S
:
4350 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
4353 case R_RISCV_TPREL_HI20
:
4354 case R_RISCV_TPREL_ADD
:
4355 /* We can delete the unnecessary instruction and reloc. */
4356 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4358 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
4365 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
4368 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
4370 struct bfd_link_info
*link_info
,
4371 Elf_Internal_Rela
*rel
,
4373 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4374 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4375 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4376 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
4377 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4379 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4380 bfd_vma alignment
= 1, pos
;
4381 while (alignment
<= rel
->r_addend
)
4384 symval
-= rel
->r_addend
;
4385 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
4386 bfd_vma nop_bytes
= aligned_addr
- symval
;
4388 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
4389 sec
->sec_flg0
= TRUE
;
4391 /* Make sure there are enough NOPs to actually achieve the alignment. */
4392 if (rel
->r_addend
< nop_bytes
)
4395 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
4396 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
4397 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
4398 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
4399 bfd_set_error (bfd_error_bad_value
);
4403 /* Delete the reloc. */
4404 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4406 /* If the number of NOPs is already correct, there's nothing to do. */
4407 if (nop_bytes
== rel
->r_addend
)
4410 /* Write as many RISC-V NOPs as we need. */
4411 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
4412 bfd_putl32 (RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
4414 /* Write a final RVC NOP if need be. */
4415 if (nop_bytes
% 4 != 0)
4416 bfd_putl16 (RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
4418 /* Delete the excess bytes. */
4419 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
4420 rel
->r_addend
- nop_bytes
, link_info
);
4423 /* Relax PC-relative references to GP-relative references. */
4426 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
4429 struct bfd_link_info
*link_info
,
4430 Elf_Internal_Rela
*rel
,
4432 bfd_vma max_alignment
,
4433 bfd_vma reserve_size
,
4434 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4435 riscv_pcgp_relocs
*pcgp_relocs
,
4436 bfd_boolean undefined_weak
)
4438 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4439 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4441 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4443 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
4444 actual target address. */
4445 riscv_pcgp_hi_reloc hi_reloc
;
4446 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
4447 switch (ELFNN_R_TYPE (rel
->r_info
))
4449 case R_RISCV_PCREL_LO12_I
:
4450 case R_RISCV_PCREL_LO12_S
:
4452 /* If the %lo has an addend, it isn't for the label pointing at the
4453 hi part instruction, but rather for the symbol pointed at by the
4454 hi part instruction. So we must subtract it here for the lookup.
4455 It is still used below in the final symbol address. */
4456 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
4457 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
4461 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
4466 symval
= hi_reloc
.hi_addr
;
4467 sym_sec
= hi_reloc
.sym_sec
;
4469 /* We can not know whether the undefined weak symbol is referenced
4470 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
4471 we have to record the 'undefined_weak' flag when handling the
4472 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
4473 undefined_weak
= hi_reloc
.undefined_weak
;
4477 case R_RISCV_PCREL_HI20
:
4478 /* Mergeable symbols and code might later move out of range. */
4479 if (! undefined_weak
4480 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
4483 /* If the cooresponding lo relocation has already been seen then it's not
4484 safe to relax this relocation. */
4485 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
4496 /* If gp and the symbol are in the same output section, which is not the
4497 abs section, then consider only that output section's alignment. */
4498 struct bfd_link_hash_entry
*h
=
4499 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
4501 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4502 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4503 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4506 /* Is the reference in range of x0 or gp?
4507 Valid gp range conservatively because of alignment issue. */
4509 || (VALID_ITYPE_IMM (symval
)
4511 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4513 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4515 unsigned sym
= hi_reloc
.hi_sym
;
4516 switch (ELFNN_R_TYPE (rel
->r_info
))
4518 case R_RISCV_PCREL_LO12_I
:
4521 /* Change the RS1 to zero, and then modify the relocation
4522 type to R_RISCV_LO12_I. */
4523 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4524 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4525 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4526 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
4527 rel
->r_addend
= hi_reloc
.hi_addend
;
4531 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4532 rel
->r_addend
+= hi_reloc
.hi_addend
;
4536 case R_RISCV_PCREL_LO12_S
:
4539 /* Change the RS1 to zero, and then modify the relocation
4540 type to R_RISCV_LO12_S. */
4541 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4542 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4543 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4544 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
4545 rel
->r_addend
= hi_reloc
.hi_addend
;
4549 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4550 rel
->r_addend
+= hi_reloc
.hi_addend
;
4554 case R_RISCV_PCREL_HI20
:
4555 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
4559 ELFNN_R_SYM(rel
->r_info
),
4562 /* We can delete the unnecessary AUIPC and reloc. */
4563 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
4575 /* Delete the bytes for R_RISCV_DELETE. */
4578 _bfd_riscv_relax_delete (bfd
*abfd
,
4580 asection
*sym_sec ATTRIBUTE_UNUSED
,
4581 struct bfd_link_info
*link_info
,
4582 Elf_Internal_Rela
*rel
,
4583 bfd_vma symval ATTRIBUTE_UNUSED
,
4584 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4585 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4586 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4587 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4588 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4590 if (!riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
4593 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4599 Pass 0: Shortens code sequences for LUI/CALL/TPREL relocs.
4600 Pass 1: Shortens code sequences for PCREL relocs.
4601 Pass 2: Deletes the bytes that pass 1 made obselete.
4602 Pass 3: Which cannot be disabled, handles code alignment directives. */
4605 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
4606 struct bfd_link_info
*info
,
4609 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
4610 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4611 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
4612 Elf_Internal_Rela
*relocs
;
4613 bfd_boolean ret
= FALSE
;
4615 bfd_vma max_alignment
, reserve_size
= 0;
4616 riscv_pcgp_relocs pcgp_relocs
;
4620 if (bfd_link_relocatable (info
)
4622 || (sec
->flags
& SEC_RELOC
) == 0
4623 || sec
->reloc_count
== 0
4624 || (info
->disable_target_specific_optimizations
4625 && info
->relax_pass
< 2))
4628 riscv_init_pcgp_relocs (&pcgp_relocs
);
4630 /* Read this BFD's relocs if we haven't done so already. */
4632 relocs
= data
->relocs
;
4633 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4634 info
->keep_memory
)))
4639 max_alignment
= htab
->max_alignment
;
4640 if (max_alignment
== (bfd_vma
) -1)
4642 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4643 htab
->max_alignment
= max_alignment
;
4647 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4649 /* Examine and consider relaxing each reloc. */
4650 for (i
= 0; i
< sec
->reloc_count
; i
++)
4653 Elf_Internal_Rela
*rel
= relocs
+ i
;
4654 relax_func_t relax_func
;
4655 int type
= ELFNN_R_TYPE (rel
->r_info
);
4658 bfd_boolean undefined_weak
= FALSE
;
4661 if (info
->relax_pass
== 0)
4663 if (type
== R_RISCV_CALL
4664 || type
== R_RISCV_CALL_PLT
)
4665 relax_func
= _bfd_riscv_relax_call
;
4666 else if (type
== R_RISCV_HI20
4667 || type
== R_RISCV_LO12_I
4668 || type
== R_RISCV_LO12_S
)
4669 relax_func
= _bfd_riscv_relax_lui
;
4670 else if (type
== R_RISCV_TPREL_HI20
4671 || type
== R_RISCV_TPREL_ADD
4672 || type
== R_RISCV_TPREL_LO12_I
4673 || type
== R_RISCV_TPREL_LO12_S
)
4674 relax_func
= _bfd_riscv_relax_tls_le
;
4678 else if (info
->relax_pass
== 1
4679 && !bfd_link_pic (info
)
4680 && (type
== R_RISCV_PCREL_HI20
4681 || type
== R_RISCV_PCREL_LO12_I
4682 || type
== R_RISCV_PCREL_LO12_S
))
4683 relax_func
= _bfd_riscv_relax_pc
;
4684 else if (info
->relax_pass
== 2 && type
== R_RISCV_DELETE
)
4685 relax_func
= _bfd_riscv_relax_delete
;
4686 else if (info
->relax_pass
== 3 && type
== R_RISCV_ALIGN
)
4687 relax_func
= _bfd_riscv_relax_align
;
4691 if (info
->relax_pass
< 2)
4693 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4694 if (i
== sec
->reloc_count
- 1
4695 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4696 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4699 /* Skip over the R_RISCV_RELAX. */
4703 data
->relocs
= relocs
;
4705 /* Read this BFD's contents if we haven't done so already. */
4706 if (!data
->this_hdr
.contents
4707 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4710 /* Read this BFD's symbols if we haven't done so already. */
4711 if (symtab_hdr
->sh_info
!= 0
4712 && !symtab_hdr
->contents
4713 && !(symtab_hdr
->contents
=
4714 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4715 symtab_hdr
->sh_info
,
4716 0, NULL
, NULL
, NULL
)))
4719 /* Get the value of the symbol referred to by the reloc. */
4720 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4722 /* A local symbol. */
4723 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4724 + ELFNN_R_SYM (rel
->r_info
));
4725 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4726 ? 0 : isym
->st_size
- rel
->r_addend
;
4728 /* Relocate against local STT_GNU_IFUNC symbol. we have created
4729 a fake global symbol entry for this, so deal with the local ifunc
4731 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4734 if (isym
->st_shndx
== SHN_UNDEF
)
4735 sym_sec
= sec
, symval
= rel
->r_offset
;
4738 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4739 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4741 /* The purpose of this code is unknown. It breaks linker scripts
4742 for embedded development that place sections at address zero.
4743 This code is believed to be unnecessary. Disabling it but not
4744 yet removing it, in case something breaks. */
4745 if (sec_addr (sym_sec
) == 0)
4748 symval
= isym
->st_value
;
4750 symtype
= ELF_ST_TYPE (isym
->st_info
);
4755 struct elf_link_hash_entry
*h
;
4757 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4758 h
= elf_sym_hashes (abfd
)[indx
];
4760 while (h
->root
.type
== bfd_link_hash_indirect
4761 || h
->root
.type
== bfd_link_hash_warning
)
4762 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4764 /* Disable the relaxation for ifunc. */
4765 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
4768 if (h
->root
.type
== bfd_link_hash_undefweak
4769 && (relax_func
== _bfd_riscv_relax_lui
4770 || relax_func
== _bfd_riscv_relax_pc
))
4772 /* For the lui and auipc relaxations, since the symbol
4773 value of an undefined weak symbol is always be zero,
4774 we can optimize the patterns into a single LI/MV/ADDI
4777 Note that, creating shared libraries and pie output may
4778 break the rule above. Fortunately, since we do not relax
4779 pc relocs when creating shared libraries and pie output,
4780 and the absolute address access for R_RISCV_HI20 isn't
4781 allowed when "-fPIC" is set, the problem of creating shared
4782 libraries can not happen currently. Once we support the
4783 auipc relaxations when creating shared libraries, then we will
4784 need the more rigorous checking for this optimization. */
4785 undefined_weak
= TRUE
;
4788 /* This line has to match the check in riscv_elf_relocate_section
4789 in the R_RISCV_CALL[_PLT] case. */
4790 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4792 sym_sec
= htab
->elf
.splt
;
4793 symval
= h
->plt
.offset
;
4795 else if (undefined_weak
)
4798 sym_sec
= bfd_und_section_ptr
;
4800 else if ((h
->root
.type
== bfd_link_hash_defined
4801 || h
->root
.type
== bfd_link_hash_defweak
)
4802 && h
->root
.u
.def
.section
!= NULL
4803 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4805 symval
= h
->root
.u
.def
.value
;
4806 sym_sec
= h
->root
.u
.def
.section
;
4811 if (h
->type
!= STT_FUNC
)
4813 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4817 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4818 && (sym_sec
->flags
& SEC_MERGE
))
4820 /* At this stage in linking, no SEC_MERGE symbol has been
4821 adjusted, so all references to such symbols need to be
4822 passed through _bfd_merged_section_offset. (Later, in
4823 relocate_section, all SEC_MERGE symbols *except* for
4824 section symbols have been adjusted.)
4826 gas may reduce relocations against symbols in SEC_MERGE
4827 sections to a relocation against the section symbol when
4828 the original addend was zero. When the reloc is against
4829 a section symbol we should include the addend in the
4830 offset passed to _bfd_merged_section_offset, since the
4831 location of interest is the original symbol. On the
4832 other hand, an access to "sym+addend" where "sym" is not
4833 a section symbol should not include the addend; Such an
4834 access is presumed to be an offset from "sym"; The
4835 location of interest is just "sym". */
4836 if (symtype
== STT_SECTION
)
4837 symval
+= rel
->r_addend
;
4839 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4840 elf_section_data (sym_sec
)->sec_info
,
4843 if (symtype
!= STT_SECTION
)
4844 symval
+= rel
->r_addend
;
4847 symval
+= rel
->r_addend
;
4849 symval
+= sec_addr (sym_sec
);
4851 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4852 max_alignment
, reserve_size
, again
,
4853 &pcgp_relocs
, undefined_weak
))
4860 if (relocs
!= data
->relocs
)
4862 riscv_free_pcgp_relocs (&pcgp_relocs
, abfd
, sec
);
4868 # define PRSTATUS_SIZE 204
4869 # define PRSTATUS_OFFSET_PR_CURSIG 12
4870 # define PRSTATUS_OFFSET_PR_PID 24
4871 # define PRSTATUS_OFFSET_PR_REG 72
4872 # define ELF_GREGSET_T_SIZE 128
4873 # define PRPSINFO_SIZE 128
4874 # define PRPSINFO_OFFSET_PR_PID 16
4875 # define PRPSINFO_OFFSET_PR_FNAME 32
4876 # define PRPSINFO_OFFSET_PR_PSARGS 48
4878 # define PRSTATUS_SIZE 376
4879 # define PRSTATUS_OFFSET_PR_CURSIG 12
4880 # define PRSTATUS_OFFSET_PR_PID 32
4881 # define PRSTATUS_OFFSET_PR_REG 112
4882 # define ELF_GREGSET_T_SIZE 256
4883 # define PRPSINFO_SIZE 136
4884 # define PRPSINFO_OFFSET_PR_PID 24
4885 # define PRPSINFO_OFFSET_PR_FNAME 40
4886 # define PRPSINFO_OFFSET_PR_PSARGS 56
4889 /* Support for core dump NOTE sections. */
4892 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4894 switch (note
->descsz
)
4899 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4901 elf_tdata (abfd
)->core
->signal
4902 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
4905 elf_tdata (abfd
)->core
->lwpid
4906 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
4910 /* Make a ".reg/999" section. */
4911 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
4912 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
4916 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4918 switch (note
->descsz
)
4923 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
4925 elf_tdata (abfd
)->core
->pid
4926 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
4929 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
4930 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
, 16);
4933 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
4934 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
, 80);
4938 /* Note that for some reason, a spurious space is tacked
4939 onto the end of the args in some (at least one anyway)
4940 implementations, so strip it off if it exists. */
4943 char *command
= elf_tdata (abfd
)->core
->command
;
4944 int n
= strlen (command
);
4946 if (0 < n
&& command
[n
- 1] == ' ')
4947 command
[n
- 1] = '\0';
4953 /* Set the right mach type. */
4956 riscv_elf_object_p (bfd
*abfd
)
4958 /* There are only two mach types in RISCV currently. */
4959 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0
4960 || strcmp (abfd
->xvec
->name
, "elf32-bigriscv") == 0)
4961 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
4963 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
4968 /* Determine whether an object attribute tag takes an integer, a
4972 riscv_elf_obj_attrs_arg_type (int tag
)
4974 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
4977 #define TARGET_LITTLE_SYM riscv_elfNN_vec
4978 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
4979 #define TARGET_BIG_SYM riscv_elfNN_be_vec
4980 #define TARGET_BIG_NAME "elfNN-bigriscv"
4982 #define elf_backend_reloc_type_class riscv_reloc_type_class
4984 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
4985 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4986 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
4987 #define bfd_elfNN_bfd_merge_private_bfd_data \
4988 _bfd_riscv_elf_merge_private_bfd_data
4990 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
4991 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
4992 #define elf_backend_check_relocs riscv_elf_check_relocs
4993 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
4994 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
4995 #define elf_backend_relocate_section riscv_elf_relocate_section
4996 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
4997 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
4998 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
4999 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
5000 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
5001 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
5002 #define elf_backend_object_p riscv_elf_object_p
5003 #define elf_info_to_howto_rel NULL
5004 #define elf_info_to_howto riscv_info_to_howto_rela
5005 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
5006 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
5008 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5010 #define elf_backend_can_gc_sections 1
5011 #define elf_backend_can_refcount 1
5012 #define elf_backend_want_got_plt 1
5013 #define elf_backend_plt_readonly 1
5014 #define elf_backend_plt_alignment 4
5015 #define elf_backend_want_plt_sym 1
5016 #define elf_backend_got_header_size (ARCH_SIZE / 8)
5017 #define elf_backend_want_dynrelro 1
5018 #define elf_backend_rela_normal 1
5019 #define elf_backend_default_execstack 0
5021 #undef elf_backend_obj_attrs_vendor
5022 #define elf_backend_obj_attrs_vendor "riscv"
5023 #undef elf_backend_obj_attrs_arg_type
5024 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
5025 #undef elf_backend_obj_attrs_section_type
5026 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
5027 #undef elf_backend_obj_attrs_section
5028 #define elf_backend_obj_attrs_section ".riscv.attributes"
5030 #include "elfNN-target.h"