1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2023 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"
41 /* Internal relocations used exclusively by the relaxation pass. */
42 #define R_RISCV_DELETE (R_RISCV_max + 1)
46 #define MINUS_ONE ((bfd_vma)0 - 1)
48 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
50 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
52 /* The name of the dynamic interpreter. This is put in the .interp
55 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
56 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
58 #define ELF_ARCH bfd_arch_riscv
59 #define ELF_TARGET_ID RISCV_ELF_DATA
60 #define ELF_MACHINE_CODE EM_RISCV
61 #define ELF_MAXPAGESIZE 0x1000
62 #define ELF_COMMONPAGESIZE 0x1000
64 #define RISCV_ATTRIBUTES_SECTION_NAME ".riscv.attributes"
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
;
134 /* The data segment phase, don't relax the section
135 when it is exp_seg_relro_adjust. */
136 int *data_segment_phase
;
138 /* Relocations for variant CC symbols may be present. */
142 /* Instruction access functions. */
143 #define riscv_get_insn(bits, ptr) \
144 ((bits) == 16 ? bfd_getl16 (ptr) \
145 : (bits) == 32 ? bfd_getl32 (ptr) \
146 : (bits) == 64 ? bfd_getl64 (ptr) \
147 : (abort (), (bfd_vma) - 1))
148 #define riscv_put_insn(bits, val, ptr) \
149 ((bits) == 16 ? bfd_putl16 (val, ptr) \
150 : (bits) == 32 ? bfd_putl32 (val, ptr) \
151 : (bits) == 64 ? bfd_putl64 (val, ptr) \
152 : (abort (), (void) 0))
154 /* Get the RISC-V ELF linker hash table from a link_info structure. */
155 #define riscv_elf_hash_table(p) \
156 ((is_elf_hash_table ((p)->hash) \
157 && elf_hash_table_id (elf_hash_table (p)) == RISCV_ELF_DATA) \
158 ? (struct riscv_elf_link_hash_table *) (p)->hash : NULL)
161 riscv_info_to_howto_rela (bfd
*abfd
,
163 Elf_Internal_Rela
*dst
)
165 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
166 return cache_ptr
->howto
!= NULL
;
170 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
172 const struct elf_backend_data
*bed
;
175 bed
= get_elf_backend_data (abfd
);
176 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
177 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
180 /* Return true if a relocation is modifying an instruction. */
183 riscv_is_insn_reloc (const reloc_howto_type
*howto
)
185 /* Heuristic: A multibyte destination with a nontrivial mask
187 return (howto
->bitsize
> 8
188 && howto
->dst_mask
!= 0
189 && ~(howto
->dst_mask
| (howto
->bitsize
< sizeof(bfd_vma
) * CHAR_BIT
190 ? (MINUS_ONE
<< howto
->bitsize
) : (bfd_vma
)0)) != 0);
194 #define PLT_HEADER_INSNS 8
195 #define PLT_ENTRY_INSNS 4
196 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
197 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
198 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
199 /* Reserve two entries of GOTPLT for ld.so, one is used for PLT resolver,
200 the other is used for link map. Other targets also reserve one more
201 entry used for runtime profile? */
202 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
204 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
207 # define MATCH_LREG MATCH_LW
209 # define MATCH_LREG MATCH_LD
212 /* Generate a PLT header. */
215 riscv_make_plt_header (bfd
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
218 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
219 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
221 /* RVE has no t3 register, so this won't work, and is not supported. */
222 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
224 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
229 /* auipc t2, %hi(.got.plt)
230 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
231 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
232 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
233 addi t0, t2, %lo(.got.plt) # &.got.plt
234 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
235 l[w|d] t0, PTRSIZE(t0) # link map
238 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
239 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
240 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
241 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, (uint32_t) -(PLT_HEADER_SIZE
+ 12));
242 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
243 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
244 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
245 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
250 /* Generate a PLT entry. */
253 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
256 /* RVE has no t3 register, so this won't work, and is not supported. */
257 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
259 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
264 /* auipc t3, %hi(.got.plt entry)
265 l[w|d] t3, %lo(.got.plt entry)(t3)
269 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
270 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
271 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
272 entry
[3] = RISCV_NOP
;
277 /* Create an entry in an RISC-V ELF linker hash table. */
279 static struct bfd_hash_entry
*
280 link_hash_newfunc (struct bfd_hash_entry
*entry
,
281 struct bfd_hash_table
*table
, const char *string
)
283 /* Allocate the structure if it has not already been allocated by a
288 bfd_hash_allocate (table
,
289 sizeof (struct riscv_elf_link_hash_entry
));
294 /* Call the allocation method of the superclass. */
295 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
298 struct riscv_elf_link_hash_entry
*eh
;
300 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
301 eh
->tls_type
= GOT_UNKNOWN
;
307 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
308 for local symbol so that we can handle local STT_GNU_IFUNC symbols
309 as global symbol. We reuse indx and dynstr_index for local symbol
310 hash since they aren't used by global symbols in this backend. */
313 riscv_elf_local_htab_hash (const void *ptr
)
315 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) ptr
;
316 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
319 /* Compare local hash entries. */
322 riscv_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
324 struct elf_link_hash_entry
*h1
= (struct elf_link_hash_entry
*) ptr1
;
325 struct elf_link_hash_entry
*h2
= (struct elf_link_hash_entry
*) ptr2
;
327 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
330 /* Find and/or create a hash entry for local symbol. */
332 static struct elf_link_hash_entry
*
333 riscv_elf_get_local_sym_hash (struct riscv_elf_link_hash_table
*htab
,
334 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
337 struct riscv_elf_link_hash_entry eh
, *ret
;
338 asection
*sec
= abfd
->sections
;
339 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
340 ELFNN_R_SYM (rel
->r_info
));
343 eh
.elf
.indx
= sec
->id
;
344 eh
.elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
345 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &eh
, h
,
346 create
? INSERT
: NO_INSERT
);
353 ret
= (struct riscv_elf_link_hash_entry
*) *slot
;
357 ret
= (struct riscv_elf_link_hash_entry
*)
358 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
359 sizeof (struct riscv_elf_link_hash_entry
));
362 memset (ret
, 0, sizeof (*ret
));
363 ret
->elf
.indx
= sec
->id
;
364 ret
->elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
365 ret
->elf
.dynindx
= -1;
371 /* Destroy a RISC-V elf linker hash table. */
374 riscv_elf_link_hash_table_free (bfd
*obfd
)
376 struct riscv_elf_link_hash_table
*ret
377 = (struct riscv_elf_link_hash_table
*) obfd
->link
.hash
;
379 if (ret
->loc_hash_table
)
380 htab_delete (ret
->loc_hash_table
);
381 if (ret
->loc_hash_memory
)
382 objalloc_free ((struct objalloc
*) ret
->loc_hash_memory
);
384 _bfd_elf_link_hash_table_free (obfd
);
387 /* Create a RISC-V ELF linker hash table. */
389 static struct bfd_link_hash_table
*
390 riscv_elf_link_hash_table_create (bfd
*abfd
)
392 struct riscv_elf_link_hash_table
*ret
;
393 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
395 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
399 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
400 sizeof (struct riscv_elf_link_hash_entry
),
407 ret
->max_alignment
= (bfd_vma
) -1;
409 /* Create hash table for local ifunc. */
410 ret
->loc_hash_table
= htab_try_create (1024,
411 riscv_elf_local_htab_hash
,
412 riscv_elf_local_htab_eq
,
414 ret
->loc_hash_memory
= objalloc_create ();
415 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
417 riscv_elf_link_hash_table_free (abfd
);
420 ret
->elf
.root
.hash_table_free
= riscv_elf_link_hash_table_free
;
422 return &ret
->elf
.root
;
425 /* Create the .got section. */
428 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
432 struct elf_link_hash_entry
*h
;
433 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
434 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
436 /* This function may be called more than once. */
437 if (htab
->sgot
!= NULL
)
440 flags
= bed
->dynamic_sec_flags
;
442 s
= bfd_make_section_anyway_with_flags (abfd
,
443 (bed
->rela_plts_and_copies_p
444 ? ".rela.got" : ".rel.got"),
445 (bed
->dynamic_sec_flags
448 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
452 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
454 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
458 /* The first bit of the global offset table is the header. */
459 s
->size
+= bed
->got_header_size
;
461 if (bed
->want_got_plt
)
463 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
465 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
469 /* Reserve room for the header. */
470 s
->size
+= GOTPLT_HEADER_SIZE
;
473 if (bed
->want_got_sym
)
475 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
476 section. We don't do this in the linker script because we don't want
477 to define the symbol if we are not creating a global offset
479 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
480 "_GLOBAL_OFFSET_TABLE_");
481 elf_hash_table (info
)->hgot
= h
;
489 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
490 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
494 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
495 struct bfd_link_info
*info
)
497 struct riscv_elf_link_hash_table
*htab
;
499 htab
= riscv_elf_hash_table (info
);
500 BFD_ASSERT (htab
!= NULL
);
502 if (!riscv_elf_create_got_section (dynobj
, info
))
505 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
508 if (!bfd_link_pic (info
))
510 /* Technically, this section doesn't have contents. It is used as the
511 target of TLS copy relocs, to copy TLS data from shared libraries into
512 the executable. However, if we don't mark it as loadable, then it
513 matches the IS_TBSS test in ldlang.c, and there is no run-time address
514 space allocated for it even though it has SEC_ALLOC. That test is
515 correct for .tbss, but not correct for this section. There is also
516 a second problem that having a section with no contents can only work
517 if it comes after all sections with contents in the same segment,
518 but the linker script does not guarantee that. This is just mixed in
519 with other .tdata.* sections. We can fix both problems by lying and
520 saying that there are contents. This section is expected to be small
521 so this should not cause a significant extra program startup cost. */
523 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
524 (SEC_ALLOC
| SEC_THREAD_LOCAL
525 | SEC_LOAD
| SEC_DATA
527 | SEC_LINKER_CREATED
));
530 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
531 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
537 /* Copy the extra info we tack onto an elf_link_hash_entry. */
540 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
541 struct elf_link_hash_entry
*dir
,
542 struct elf_link_hash_entry
*ind
)
544 struct riscv_elf_link_hash_entry
*edir
, *eind
;
546 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
547 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
549 if (ind
->root
.type
== bfd_link_hash_indirect
550 && dir
->got
.refcount
<= 0)
552 edir
->tls_type
= eind
->tls_type
;
553 eind
->tls_type
= GOT_UNKNOWN
;
555 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
559 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
560 unsigned long symndx
, char tls_type
)
562 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
564 *new_tls_type
|= tls_type
;
565 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
567 (*_bfd_error_handler
)
568 (_("%pB: `%s' accessed both as normal and thread local symbol"),
569 abfd
, h
? h
->root
.root
.string
: "<local>");
576 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
577 struct elf_link_hash_entry
*h
, long symndx
)
579 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
580 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
582 if (htab
->elf
.sgot
== NULL
)
584 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
590 h
->got
.refcount
+= 1;
594 /* This is a global offset table entry for a local symbol. */
595 if (elf_local_got_refcounts (abfd
) == NULL
)
597 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
598 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
600 _bfd_riscv_elf_local_got_tls_type (abfd
)
601 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
603 elf_local_got_refcounts (abfd
) [symndx
] += 1;
609 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
611 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
613 /* We propably can improve the information to tell users that they
614 should be recompile the code with -fPIC or -fPIE, just like what
616 (*_bfd_error_handler
)
617 (_("%pB: relocation %s against `%s' can not be used when making a shared "
618 "object; recompile with -fPIC"),
619 abfd
, r
? r
->name
: _("<unknown>"),
620 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
621 bfd_set_error (bfd_error_bad_value
);
625 /* Look through the relocs for a section during the first phase, and
626 allocate space in the global offset table or procedure linkage
630 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
631 asection
*sec
, const Elf_Internal_Rela
*relocs
)
633 struct riscv_elf_link_hash_table
*htab
;
634 Elf_Internal_Shdr
*symtab_hdr
;
635 struct elf_link_hash_entry
**sym_hashes
;
636 const Elf_Internal_Rela
*rel
;
637 asection
*sreloc
= NULL
;
639 if (bfd_link_relocatable (info
))
642 htab
= riscv_elf_hash_table (info
);
643 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
644 sym_hashes
= elf_sym_hashes (abfd
);
646 if (htab
->elf
.dynobj
== NULL
)
647 htab
->elf
.dynobj
= abfd
;
649 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
652 unsigned int r_symndx
;
653 struct elf_link_hash_entry
*h
;
655 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
656 r_type
= ELFNN_R_TYPE (rel
->r_info
);
658 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
660 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
665 if (r_symndx
< symtab_hdr
->sh_info
)
667 /* A local symbol. */
668 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
673 /* Check relocation against local STT_GNU_IFUNC symbol. */
674 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
676 h
= riscv_elf_get_local_sym_hash (htab
, abfd
, rel
, true);
680 /* Fake STT_GNU_IFUNC global symbol. */
681 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
683 h
->type
= STT_GNU_IFUNC
;
687 h
->root
.type
= bfd_link_hash_defined
;
694 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
695 while (h
->root
.type
== bfd_link_hash_indirect
696 || h
->root
.type
== bfd_link_hash_warning
)
697 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
707 case R_RISCV_CALL_PLT
:
709 case R_RISCV_GOT_HI20
:
710 case R_RISCV_PCREL_HI20
:
711 /* Create the ifunc sections, iplt and ipltgot, for static
713 if (h
->type
== STT_GNU_IFUNC
714 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
722 /* It is referenced by a non-shared object. */
728 case R_RISCV_TLS_GD_HI20
:
729 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
730 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
734 case R_RISCV_TLS_GOT_HI20
:
735 if (bfd_link_pic (info
))
736 info
->flags
|= DF_STATIC_TLS
;
737 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
738 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
742 case R_RISCV_GOT_HI20
:
743 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
744 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
749 case R_RISCV_CALL_PLT
:
750 /* These symbol requires a procedure linkage table entry.
751 We actually build the entry in adjust_dynamic_symbol,
752 because these might be a case of linking PIC code without
753 linking in any dynamic objects, in which case we don't
754 need to generate a procedure linkage table after all. */
756 /* If it is a local symbol, then we resolve it directly
757 without creating a PLT entry. */
762 h
->plt
.refcount
+= 1;
765 case R_RISCV_PCREL_HI20
:
767 && h
->type
== STT_GNU_IFUNC
)
770 h
->pointer_equality_needed
= 1;
772 /* We don't use the PCREL_HI20 in the data section,
773 so we always need the plt when it refers to
775 h
->plt
.refcount
+= 1;
781 case R_RISCV_RVC_BRANCH
:
782 case R_RISCV_RVC_JUMP
:
783 /* In shared libraries and pie, these relocs are known
785 if (bfd_link_pic (info
))
789 case R_RISCV_TPREL_HI20
:
790 if (!bfd_link_executable (info
))
791 return bad_static_reloc (abfd
, r_type
, h
);
793 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
797 if (bfd_link_pic (info
))
798 return bad_static_reloc (abfd
, r_type
, h
);
802 case R_RISCV_JUMP_SLOT
:
803 case R_RISCV_RELATIVE
:
811 && (!bfd_link_pic (info
)
812 || h
->type
== STT_GNU_IFUNC
))
814 /* This reloc might not bind locally. */
816 h
->pointer_equality_needed
= 1;
819 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
821 /* We may need a .plt entry if the symbol is a function
822 defined in a shared lib or is a function referenced
823 from the code or read-only section. */
824 h
->plt
.refcount
+= 1;
828 /* If we are creating a shared library, and this is a reloc
829 against a global symbol, or a non PC relative reloc
830 against a local symbol, then we need to copy the reloc
831 into the shared library. However, if we are linking with
832 -Bsymbolic, we do not need to copy a reloc against a
833 global symbol which is defined in an object we are
834 including in the link (i.e., DEF_REGULAR is set). At
835 this point we have not seen all the input files, so it is
836 possible that DEF_REGULAR is not set now but will be set
837 later (it is never cleared). In case of a weak definition,
838 DEF_REGULAR may be cleared later by a strong definition in
839 a shared library. We account for that possibility below by
840 storing information in the relocs_copied field of the hash
841 table entry. A similar situation occurs when creating
842 shared libraries and symbol visibility changes render the
845 If on the other hand, we are creating an executable, we
846 may need to keep relocations for symbols satisfied by a
847 dynamic library if we manage to avoid copy relocs for the
850 Generate dynamic pointer relocation against STT_GNU_IFUNC
851 symbol in the non-code section (R_RISCV_32/R_RISCV_64). */
852 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
854 if ((bfd_link_pic (info
)
855 && (sec
->flags
& SEC_ALLOC
) != 0
856 && ((r
!= NULL
&& !r
->pc_relative
)
859 || h
->root
.type
== bfd_link_hash_defweak
860 || !h
->def_regular
))))
861 || (!bfd_link_pic (info
)
862 && (sec
->flags
& SEC_ALLOC
) != 0
864 && (h
->root
.type
== bfd_link_hash_defweak
866 || (!bfd_link_pic (info
)
868 && h
->type
== STT_GNU_IFUNC
869 && (sec
->flags
& SEC_CODE
) == 0))
871 struct elf_dyn_relocs
*p
;
872 struct elf_dyn_relocs
**head
;
874 /* When creating a shared object, we must copy these
875 relocs into the output file. We create a reloc
876 section in dynobj and make room for the reloc. */
879 sreloc
= _bfd_elf_make_dynamic_reloc_section
880 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
881 abfd
, /*rela?*/ true);
887 /* If this is a global symbol, we count the number of
888 relocations we need for this symbol. */
890 head
= &h
->dyn_relocs
;
893 /* Track dynamic relocs needed for local syms too.
894 We really need local syms available to do this
899 Elf_Internal_Sym
*isym
;
901 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
906 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
910 vpp
= &elf_section_data (s
)->local_dynrel
;
911 head
= (struct elf_dyn_relocs
**) vpp
;
915 if (p
== NULL
|| p
->sec
!= sec
)
917 size_t amt
= sizeof *p
;
918 p
= ((struct elf_dyn_relocs
*)
919 bfd_alloc (htab
->elf
.dynobj
, amt
));
930 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
943 /* Adjust a symbol defined by a dynamic object and referenced by a
944 regular object. The current definition is in some section of the
945 dynamic object, but we're not including those sections. We have to
946 change the definition to something the rest of the link can
950 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
951 struct elf_link_hash_entry
*h
)
953 struct riscv_elf_link_hash_table
*htab
;
954 struct riscv_elf_link_hash_entry
* eh
;
958 htab
= riscv_elf_hash_table (info
);
959 BFD_ASSERT (htab
!= NULL
);
961 dynobj
= htab
->elf
.dynobj
;
963 /* Make sure we know what is going on here. */
964 BFD_ASSERT (dynobj
!= NULL
966 || h
->type
== STT_GNU_IFUNC
970 && !h
->def_regular
)));
972 /* If this is a function, put it in the procedure linkage table. We
973 will fill in the contents of the procedure linkage table later
974 (although we could actually do it here). */
975 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
977 if (h
->plt
.refcount
<= 0
978 || (h
->type
!= STT_GNU_IFUNC
979 && (SYMBOL_CALLS_LOCAL (info
, h
)
980 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
981 && h
->root
.type
== bfd_link_hash_undefweak
))))
983 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
984 input file, but the symbol was never referred to by a dynamic
985 object, or if all references were garbage collected. In such
986 a case, we don't actually need to build a PLT entry. */
987 h
->plt
.offset
= (bfd_vma
) -1;
994 h
->plt
.offset
= (bfd_vma
) -1;
996 /* If this is a weak symbol, and there is a real definition, the
997 processor independent code will have arranged for us to see the
998 real definition first, and we can just use the same value. */
1001 struct elf_link_hash_entry
*def
= weakdef (h
);
1002 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1003 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1004 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1008 /* This is a reference to a symbol defined by a dynamic object which
1009 is not a function. */
1011 /* If we are creating a shared library, we must presume that the
1012 only references to the symbol are via the global offset table.
1013 For such cases we need not do anything here; the relocations will
1014 be handled correctly by relocate_section. */
1015 if (bfd_link_pic (info
))
1018 /* If there are no references to this symbol that do not use the
1019 GOT, we don't need to generate a copy reloc. */
1020 if (!h
->non_got_ref
)
1023 /* If -z nocopyreloc was given, we won't generate them either. */
1024 if (info
->nocopyreloc
)
1030 /* If we don't find any dynamic relocs in read-only sections, then
1031 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1032 if (!_bfd_elf_readonly_dynrelocs (h
))
1038 /* We must allocate the symbol in our .dynbss section, which will
1039 become part of the .bss section of the executable. There will be
1040 an entry for this symbol in the .dynsym section. The dynamic
1041 object will contain position independent code, so all references
1042 from the dynamic object to this symbol will go through the global
1043 offset table. The dynamic linker will use the .dynsym entry to
1044 determine the address it must put in the global offset table, so
1045 both the dynamic object and the regular object will refer to the
1046 same memory location for the variable. */
1048 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
1049 to copy the initial value out of the dynamic object and into the
1050 runtime process image. We need to remember the offset into the
1051 .rel.bss section we are going to use. */
1052 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1053 if (eh
->tls_type
& ~GOT_NORMAL
)
1055 s
= htab
->sdyntdata
;
1056 srel
= htab
->elf
.srelbss
;
1058 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1060 s
= htab
->elf
.sdynrelro
;
1061 srel
= htab
->elf
.sreldynrelro
;
1065 s
= htab
->elf
.sdynbss
;
1066 srel
= htab
->elf
.srelbss
;
1068 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1070 srel
->size
+= sizeof (ElfNN_External_Rela
);
1074 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1077 /* Allocate space in .plt, .got and associated reloc sections for
1081 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1083 struct bfd_link_info
*info
;
1084 struct riscv_elf_link_hash_table
*htab
;
1085 struct elf_dyn_relocs
*p
;
1087 if (h
->root
.type
== bfd_link_hash_indirect
)
1090 info
= (struct bfd_link_info
*) inf
;
1091 htab
= riscv_elf_hash_table (info
);
1092 BFD_ASSERT (htab
!= NULL
);
1094 /* When we are generating pde, make sure gp symbol is output as a
1095 dynamic symbol. Then ld.so can set the gp register earlier, before
1096 resolving the ifunc. */
1097 if (!bfd_link_pic (info
)
1098 && htab
->elf
.dynamic_sections_created
1099 && strcmp (h
->root
.root
.string
, RISCV_GP_SYMBOL
) == 0
1100 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1103 /* Since STT_GNU_IFUNC symbols must go through PLT, we handle them
1104 in the allocate_ifunc_dynrelocs and allocate_local_ifunc_dynrelocs,
1105 if they are defined and referenced in a non-shared object. */
1106 if (h
->type
== STT_GNU_IFUNC
1109 else if (htab
->elf
.dynamic_sections_created
1110 && h
->plt
.refcount
> 0)
1112 /* Make sure this symbol is output as a dynamic symbol.
1113 Undefined weak syms won't yet be marked as dynamic. */
1114 if (h
->dynindx
== -1
1115 && !h
->forced_local
)
1117 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1121 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1123 asection
*s
= htab
->elf
.splt
;
1126 s
->size
= PLT_HEADER_SIZE
;
1128 h
->plt
.offset
= s
->size
;
1130 /* Make room for this entry. */
1131 s
->size
+= PLT_ENTRY_SIZE
;
1133 /* We also need to make an entry in the .got.plt section. */
1134 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
1136 /* We also need to make an entry in the .rela.plt section. */
1137 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
1139 /* If this symbol is not defined in a regular file, and we are
1140 not generating a shared library, then set the symbol to this
1141 location in the .plt. This is required to make function
1142 pointers compare as equal between the normal executable and
1143 the shared library. */
1144 if (! bfd_link_pic (info
)
1147 h
->root
.u
.def
.section
= s
;
1148 h
->root
.u
.def
.value
= h
->plt
.offset
;
1151 /* If the symbol has STO_RISCV_VARIANT_CC flag, then raise the
1152 variant_cc flag of riscv_elf_link_hash_table. */
1153 if (h
->other
& STO_RISCV_VARIANT_CC
)
1154 htab
->variant_cc
= 1;
1158 h
->plt
.offset
= (bfd_vma
) -1;
1164 h
->plt
.offset
= (bfd_vma
) -1;
1168 if (h
->got
.refcount
> 0)
1172 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
1174 /* Make sure this symbol is output as a dynamic symbol.
1175 Undefined weak syms won't yet be marked as dynamic. */
1176 if (h
->dynindx
== -1
1177 && !h
->forced_local
)
1179 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1184 h
->got
.offset
= s
->size
;
1185 dyn
= htab
->elf
.dynamic_sections_created
;
1186 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
1188 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1189 if (tls_type
& GOT_TLS_GD
)
1191 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
1192 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1195 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1196 if (tls_type
& GOT_TLS_IE
)
1198 s
->size
+= RISCV_ELF_WORD_BYTES
;
1199 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1204 s
->size
+= RISCV_ELF_WORD_BYTES
;
1205 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1206 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1207 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1211 h
->got
.offset
= (bfd_vma
) -1;
1213 if (h
->dyn_relocs
== NULL
)
1216 /* In the shared -Bsymbolic case, discard space allocated for
1217 dynamic pc-relative relocs against symbols which turn out to be
1218 defined in regular objects. For the normal shared case, discard
1219 space for pc-relative relocs that have become local due to symbol
1220 visibility changes. */
1222 if (bfd_link_pic (info
))
1224 if (SYMBOL_CALLS_LOCAL (info
, h
))
1226 struct elf_dyn_relocs
**pp
;
1228 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1230 p
->count
-= p
->pc_count
;
1239 /* Also discard relocs on undefined weak syms with non-default
1241 if (h
->dyn_relocs
!= NULL
1242 && h
->root
.type
== bfd_link_hash_undefweak
)
1244 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1245 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1246 h
->dyn_relocs
= NULL
;
1248 /* Make sure undefined weak symbols are output as a dynamic
1250 else if (h
->dynindx
== -1
1251 && !h
->forced_local
)
1253 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1260 /* For the non-shared case, discard space for relocs against
1261 symbols which turn out to need copy relocs or are not
1267 || (htab
->elf
.dynamic_sections_created
1268 && (h
->root
.type
== bfd_link_hash_undefweak
1269 || h
->root
.type
== bfd_link_hash_undefined
))))
1271 /* Make sure this symbol is output as a dynamic symbol.
1272 Undefined weak syms won't yet be marked as dynamic. */
1273 if (h
->dynindx
== -1
1274 && !h
->forced_local
)
1276 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1280 /* If that succeeded, we know we'll be keeping all the
1282 if (h
->dynindx
!= -1)
1286 h
->dyn_relocs
= NULL
;
1291 /* Finally, allocate space. */
1292 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1294 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1295 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1301 /* Allocate space in .plt, .got and associated reloc sections for
1302 ifunc dynamic relocs. */
1305 allocate_ifunc_dynrelocs (struct elf_link_hash_entry
*h
,
1308 struct bfd_link_info
*info
;
1310 if (h
->root
.type
== bfd_link_hash_indirect
)
1313 if (h
->root
.type
== bfd_link_hash_warning
)
1314 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1316 info
= (struct bfd_link_info
*) inf
;
1318 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1319 here if it is defined and referenced in a non-shared object. */
1320 if (h
->type
== STT_GNU_IFUNC
1322 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
1331 /* Allocate space in .plt, .got and associated reloc sections for
1332 local ifunc dynamic relocs. */
1335 allocate_local_ifunc_dynrelocs (void **slot
, void *inf
)
1337 struct elf_link_hash_entry
*h
1338 = (struct elf_link_hash_entry
*) *slot
;
1340 if (h
->type
!= STT_GNU_IFUNC
1344 || h
->root
.type
!= bfd_link_hash_defined
)
1347 return allocate_ifunc_dynrelocs (h
, inf
);
1351 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1353 struct riscv_elf_link_hash_table
*htab
;
1358 htab
= riscv_elf_hash_table (info
);
1359 BFD_ASSERT (htab
!= NULL
);
1360 dynobj
= htab
->elf
.dynobj
;
1361 BFD_ASSERT (dynobj
!= NULL
);
1363 if (elf_hash_table (info
)->dynamic_sections_created
)
1365 /* Set the contents of the .interp section to the interpreter. */
1366 if (bfd_link_executable (info
) && !info
->nointerp
)
1368 s
= bfd_get_linker_section (dynobj
, ".interp");
1369 BFD_ASSERT (s
!= NULL
);
1370 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1371 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1375 /* Set up .got offsets for local syms, and space for local dynamic
1377 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1379 bfd_signed_vma
*local_got
;
1380 bfd_signed_vma
*end_local_got
;
1381 char *local_tls_type
;
1382 bfd_size_type locsymcount
;
1383 Elf_Internal_Shdr
*symtab_hdr
;
1386 if (! is_riscv_elf (ibfd
))
1389 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1391 struct elf_dyn_relocs
*p
;
1393 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1395 if (!bfd_is_abs_section (p
->sec
)
1396 && bfd_is_abs_section (p
->sec
->output_section
))
1398 /* Input section has been discarded, either because
1399 it is a copy of a linkonce section or due to
1400 linker script /DISCARD/, so we'll be discarding
1403 else if (p
->count
!= 0)
1405 srel
= elf_section_data (p
->sec
)->sreloc
;
1406 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1407 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1408 info
->flags
|= DF_TEXTREL
;
1413 local_got
= elf_local_got_refcounts (ibfd
);
1417 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1418 locsymcount
= symtab_hdr
->sh_info
;
1419 end_local_got
= local_got
+ locsymcount
;
1420 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1422 srel
= htab
->elf
.srelgot
;
1423 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1427 *local_got
= s
->size
;
1428 s
->size
+= RISCV_ELF_WORD_BYTES
;
1429 if (*local_tls_type
& GOT_TLS_GD
)
1430 s
->size
+= RISCV_ELF_WORD_BYTES
;
1431 if (bfd_link_pic (info
)
1432 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1433 srel
->size
+= sizeof (ElfNN_External_Rela
);
1436 *local_got
= (bfd_vma
) -1;
1440 /* Allocate .plt and .got entries and space dynamic relocs for
1442 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1444 /* Allocate .plt and .got entries and space dynamic relocs for
1445 global ifunc symbols. */
1446 elf_link_hash_traverse (&htab
->elf
, allocate_ifunc_dynrelocs
, info
);
1448 /* Allocate .plt and .got entries and space dynamic relocs for
1449 local ifunc symbols. */
1450 htab_traverse (htab
->loc_hash_table
, allocate_local_ifunc_dynrelocs
, info
);
1452 /* Used to resolve the dynamic relocs overwite problems when
1453 generating static executable. */
1454 if (htab
->elf
.irelplt
)
1455 htab
->last_iplt_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1457 if (htab
->elf
.sgotplt
)
1459 struct elf_link_hash_entry
*got
;
1460 got
= elf_link_hash_lookup (elf_hash_table (info
),
1461 "_GLOBAL_OFFSET_TABLE_",
1462 false, false, false);
1464 /* Don't allocate .got.plt section if there are no GOT nor PLT
1465 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1467 || !got
->ref_regular_nonweak
)
1468 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1469 && (htab
->elf
.splt
== NULL
1470 || htab
->elf
.splt
->size
== 0)
1471 && (htab
->elf
.sgot
== NULL
1472 || (htab
->elf
.sgot
->size
1473 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1474 htab
->elf
.sgotplt
->size
= 0;
1477 /* The check_relocs and adjust_dynamic_symbol entry points have
1478 determined the sizes of the various dynamic sections. Allocate
1480 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1482 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1485 if (s
== htab
->elf
.splt
1486 || s
== htab
->elf
.sgot
1487 || s
== htab
->elf
.sgotplt
1488 || s
== htab
->elf
.iplt
1489 || s
== htab
->elf
.igotplt
1490 || s
== htab
->elf
.sdynbss
1491 || s
== htab
->elf
.sdynrelro
1492 || s
== htab
->sdyntdata
)
1494 /* Strip this section if we don't need it; see the
1497 else if (startswith (s
->name
, ".rela"))
1501 /* We use the reloc_count field as a counter if we need
1502 to copy relocs into the output file. */
1508 /* It's not one of our sections. */
1514 /* If we don't need this section, strip it from the
1515 output file. This is mostly to handle .rela.bss and
1516 .rela.plt. We must create both sections in
1517 create_dynamic_sections, because they must be created
1518 before the linker maps input sections to output
1519 sections. The linker does that before
1520 adjust_dynamic_symbol is called, and it is that
1521 function which decides whether anything needs to go
1522 into these sections. */
1523 s
->flags
|= SEC_EXCLUDE
;
1527 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1530 /* Allocate memory for the section contents. Zero the memory
1531 for the benefit of .rela.plt, which has 4 unused entries
1532 at the beginning, and we don't want garbage. */
1533 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1534 if (s
->contents
== NULL
)
1538 /* Add dynamic entries. */
1539 if (elf_hash_table (info
)->dynamic_sections_created
)
1541 if (!_bfd_elf_add_dynamic_tags (output_bfd
, info
, true))
1544 if (htab
->variant_cc
1545 && !_bfd_elf_add_dynamic_entry (info
, DT_RISCV_VARIANT_CC
, 0))
1553 #define DTP_OFFSET 0x800
1555 /* Return the relocation value for a TLS dtp-relative reloc. */
1558 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1560 /* If tls_sec is NULL, we should have signalled an error already. */
1561 if (elf_hash_table (info
)->tls_sec
== NULL
)
1563 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1566 /* Return the relocation value for a static TLS tp-relative relocation. */
1569 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1571 /* If tls_sec is NULL, we should have signalled an error already. */
1572 if (elf_hash_table (info
)->tls_sec
== NULL
)
1574 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1577 /* Return the global pointer's value, or 0 if it is not in use. */
1580 riscv_global_pointer_value (struct bfd_link_info
*info
)
1582 struct bfd_link_hash_entry
*h
;
1584 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, false, false, true);
1585 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1588 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1591 /* Emplace a static relocation. */
1593 static bfd_reloc_status_type
1594 perform_relocation (const reloc_howto_type
*howto
,
1595 const Elf_Internal_Rela
*rel
,
1597 asection
*input_section
,
1601 if (howto
->pc_relative
)
1602 value
-= sec_addr (input_section
) + rel
->r_offset
;
1603 value
+= rel
->r_addend
;
1605 switch (ELFNN_R_TYPE (rel
->r_info
))
1608 case R_RISCV_TPREL_HI20
:
1609 case R_RISCV_PCREL_HI20
:
1610 case R_RISCV_GOT_HI20
:
1611 case R_RISCV_TLS_GOT_HI20
:
1612 case R_RISCV_TLS_GD_HI20
:
1613 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1614 return bfd_reloc_overflow
;
1615 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1618 case R_RISCV_LO12_I
:
1619 case R_RISCV_GPREL_I
:
1620 case R_RISCV_TPREL_LO12_I
:
1621 case R_RISCV_TPREL_I
:
1622 case R_RISCV_PCREL_LO12_I
:
1623 value
= ENCODE_ITYPE_IMM (value
);
1626 case R_RISCV_LO12_S
:
1627 case R_RISCV_GPREL_S
:
1628 case R_RISCV_TPREL_LO12_S
:
1629 case R_RISCV_TPREL_S
:
1630 case R_RISCV_PCREL_LO12_S
:
1631 value
= ENCODE_STYPE_IMM (value
);
1635 case R_RISCV_CALL_PLT
:
1636 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1637 return bfd_reloc_overflow
;
1638 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1639 | (ENCODE_ITYPE_IMM (value
) << 32);
1643 if (!VALID_JTYPE_IMM (value
))
1644 return bfd_reloc_overflow
;
1645 value
= ENCODE_JTYPE_IMM (value
);
1648 case R_RISCV_BRANCH
:
1649 if (!VALID_BTYPE_IMM (value
))
1650 return bfd_reloc_overflow
;
1651 value
= ENCODE_BTYPE_IMM (value
);
1654 case R_RISCV_RVC_BRANCH
:
1655 if (!VALID_CBTYPE_IMM (value
))
1656 return bfd_reloc_overflow
;
1657 value
= ENCODE_CBTYPE_IMM (value
);
1660 case R_RISCV_RVC_JUMP
:
1661 if (!VALID_CJTYPE_IMM (value
))
1662 return bfd_reloc_overflow
;
1663 value
= ENCODE_CJTYPE_IMM (value
);
1666 case R_RISCV_RVC_LUI
:
1667 if (RISCV_CONST_HIGH_PART (value
) == 0)
1669 /* Linker relaxation can convert an address equal to or greater than
1670 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1671 valid immediate. We can fix this by converting it to a C.LI. */
1672 bfd_vma insn
= riscv_get_insn (howto
->bitsize
,
1673 contents
+ rel
->r_offset
);
1674 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1675 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1676 value
= ENCODE_CITYPE_IMM (0);
1678 else if (!VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1679 return bfd_reloc_overflow
;
1681 value
= ENCODE_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1699 case R_RISCV_32_PCREL
:
1700 case R_RISCV_TLS_DTPREL32
:
1701 case R_RISCV_TLS_DTPREL64
:
1704 case R_RISCV_DELETE
:
1705 return bfd_reloc_ok
;
1708 return bfd_reloc_notsupported
;
1712 if (riscv_is_insn_reloc (howto
))
1713 word
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1715 word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1716 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1717 if (riscv_is_insn_reloc (howto
))
1718 riscv_put_insn (howto
->bitsize
, word
, contents
+ rel
->r_offset
);
1720 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1722 return bfd_reloc_ok
;
1725 /* Remember all PC-relative high-part relocs we've encountered to help us
1726 later resolve the corresponding low-part relocs. */
1732 /* Relocation value with addend. */
1734 /* Original reloc type. */
1736 } riscv_pcrel_hi_reloc
;
1738 typedef struct riscv_pcrel_lo_reloc
1740 /* PC value of auipc. */
1742 /* Internal relocation. */
1743 const Elf_Internal_Rela
*reloc
;
1744 /* Record the following information helps to resolve the %pcrel
1745 which cross different input section. For now we build a hash
1746 for pcrel at the start of riscv_elf_relocate_section, and then
1747 free the hash at the end. But riscv_elf_relocate_section only
1748 handles an input section at a time, so that means we can only
1749 resolve the %pcrel_hi and %pcrel_lo which are in the same input
1750 section. Otherwise, we will report dangerous relocation errors
1751 for those %pcrel which are not in the same input section. */
1752 asection
*input_section
;
1753 struct bfd_link_info
*info
;
1754 reloc_howto_type
*howto
;
1756 /* The next riscv_pcrel_lo_reloc. */
1757 struct riscv_pcrel_lo_reloc
*next
;
1758 } riscv_pcrel_lo_reloc
;
1762 /* Hash table for riscv_pcrel_hi_reloc. */
1764 /* Linked list for riscv_pcrel_lo_reloc. */
1765 riscv_pcrel_lo_reloc
*lo_relocs
;
1766 } riscv_pcrel_relocs
;
1769 riscv_pcrel_reloc_hash (const void *entry
)
1771 const riscv_pcrel_hi_reloc
*e
= entry
;
1772 return (hashval_t
)(e
->address
>> 2);
1776 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1778 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1779 return e1
->address
== e2
->address
;
1783 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1785 p
->lo_relocs
= NULL
;
1786 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1787 riscv_pcrel_reloc_eq
, free
);
1788 return p
->hi_relocs
!= NULL
;
1792 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1794 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1798 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1803 htab_delete (p
->hi_relocs
);
1807 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1808 struct bfd_link_info
*info
,
1812 const reloc_howto_type
*howto
)
1814 /* We may need to reference low addreses in PC-relative modes even when the
1815 PC is far away from these addresses. For example, undefweak references
1816 need to produce the address 0 when linked. As 0 is far from the arbitrary
1817 addresses that we can link PC-relative programs at, the linker can't
1818 actually relocate references to those symbols. In order to allow these
1819 programs to work we simply convert the PC-relative auipc sequences to
1820 0-relative lui sequences. */
1821 if (bfd_link_pic (info
))
1824 /* If it's possible to reference the symbol using auipc we do so, as that's
1825 more in the spirit of the PC-relative relocations we're processing. */
1826 bfd_vma offset
= addr
- pc
;
1827 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1830 /* If it's impossible to reference this with a LUI-based offset then don't
1831 bother to convert it at all so users still see the PC-relative relocation
1832 in the truncation message. */
1833 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1836 rel
->r_info
= ELFNN_R_INFO (addr
, R_RISCV_HI20
);
1838 bfd_vma insn
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1839 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1840 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1845 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
,
1851 bfd_vma offset
= absolute
? value
: value
- addr
;
1852 riscv_pcrel_hi_reloc entry
= {addr
, offset
, type
};
1853 riscv_pcrel_hi_reloc
**slot
=
1854 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1856 BFD_ASSERT (*slot
== NULL
);
1857 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1865 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1867 const Elf_Internal_Rela
*reloc
,
1868 asection
*input_section
,
1869 struct bfd_link_info
*info
,
1870 reloc_howto_type
*howto
,
1873 riscv_pcrel_lo_reloc
*entry
;
1874 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1877 *entry
= (riscv_pcrel_lo_reloc
) {addr
, reloc
, input_section
, info
,
1878 howto
, contents
, p
->lo_relocs
};
1879 p
->lo_relocs
= entry
;
1884 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1886 riscv_pcrel_lo_reloc
*r
;
1888 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1890 bfd
*input_bfd
= r
->input_section
->owner
;
1892 riscv_pcrel_hi_reloc search
= {r
->address
, 0, 0};
1893 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1894 /* There may be a risk if the %pcrel_lo with addend refers to
1895 an IFUNC symbol. The %pcrel_hi has been relocated to plt,
1896 so the corresponding %pcrel_lo with addend looks wrong. */
1897 char *string
= NULL
;
1899 string
= _("%pcrel_lo missing matching %pcrel_hi");
1900 else if (entry
->type
== R_RISCV_GOT_HI20
1901 && r
->reloc
->r_addend
!= 0)
1902 string
= _("%pcrel_lo with addend isn't allowed for R_RISCV_GOT_HI20");
1903 else if (RISCV_CONST_HIGH_PART (entry
->value
)
1904 != RISCV_CONST_HIGH_PART (entry
->value
+ r
->reloc
->r_addend
))
1906 /* Check the overflow when adding reloc addend. */
1907 if (asprintf (&string
,
1908 _("%%pcrel_lo overflow with an addend, the "
1909 "value of %%pcrel_hi is 0x%" PRIx64
" without "
1910 "any addend, but may be 0x%" PRIx64
" after "
1911 "adding the %%pcrel_lo addend"),
1912 (int64_t) RISCV_CONST_HIGH_PART (entry
->value
),
1913 (int64_t) RISCV_CONST_HIGH_PART
1914 (entry
->value
+ r
->reloc
->r_addend
)) == -1)
1915 string
= _("%pcrel_lo overflow with an addend");
1920 (*r
->info
->callbacks
->reloc_dangerous
)
1921 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1925 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1926 input_bfd
, r
->contents
);
1932 /* Relocate a RISC-V ELF section.
1934 The RELOCATE_SECTION function is called by the new ELF backend linker
1935 to handle the relocations for a section.
1937 The relocs are always passed as Rela structures.
1939 This function is responsible for adjusting the section contents as
1940 necessary, and (if generating a relocatable output file) adjusting
1941 the reloc addend as necessary.
1943 This function does not have to worry about setting the reloc
1944 address or the reloc symbol index.
1946 LOCAL_SYMS is a pointer to the swapped in local symbols.
1948 LOCAL_SECTIONS is an array giving the section in the input file
1949 corresponding to the st_shndx field of each local symbol.
1951 The global hash table entry for the global symbols can be found
1952 via elf_sym_hashes (input_bfd).
1954 When generating relocatable output, this function must handle
1955 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1956 going to be the section symbol corresponding to the output
1957 section, which means that the addend must be adjusted
1961 riscv_elf_relocate_section (bfd
*output_bfd
,
1962 struct bfd_link_info
*info
,
1964 asection
*input_section
,
1966 Elf_Internal_Rela
*relocs
,
1967 Elf_Internal_Sym
*local_syms
,
1968 asection
**local_sections
)
1970 Elf_Internal_Rela
*rel
;
1971 Elf_Internal_Rela
*relend
;
1972 riscv_pcrel_relocs pcrel_relocs
;
1974 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1975 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1976 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1977 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1980 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1983 relend
= relocs
+ input_section
->reloc_count
;
1984 for (rel
= relocs
; rel
< relend
; rel
++)
1986 unsigned long r_symndx
;
1987 struct elf_link_hash_entry
*h
;
1988 Elf_Internal_Sym
*sym
;
1991 bfd_reloc_status_type r
= bfd_reloc_ok
;
1992 const char *name
= NULL
;
1993 bfd_vma off
, ie_off
;
1994 bool unresolved_reloc
, is_ie
= false;
1995 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1996 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1997 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1998 const char *msg
= NULL
;
1999 char *msg_buf
= NULL
;
2000 bool resolved_to_zero
;
2005 /* This is a final link. */
2006 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
2010 unresolved_reloc
= false;
2011 if (r_symndx
< symtab_hdr
->sh_info
)
2013 sym
= local_syms
+ r_symndx
;
2014 sec
= local_sections
[r_symndx
];
2015 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2017 /* Relocate against local STT_GNU_IFUNC symbol. */
2018 if (!bfd_link_relocatable (info
)
2019 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
2021 h
= riscv_elf_get_local_sym_hash (htab
, input_bfd
, rel
, false);
2025 /* Set STT_GNU_IFUNC symbol value. */
2026 h
->root
.u
.def
.value
= sym
->st_value
;
2027 h
->root
.u
.def
.section
= sec
;
2032 bool warned
, ignored
;
2034 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2035 r_symndx
, symtab_hdr
, sym_hashes
,
2037 unresolved_reloc
, warned
, ignored
);
2040 /* To avoid generating warning messages about truncated
2041 relocations, set the relocation's address to be the same as
2042 the start of this section. */
2043 if (input_section
->output_section
!= NULL
)
2044 relocation
= input_section
->output_section
->vma
;
2050 if (sec
!= NULL
&& discarded_section (sec
))
2051 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2052 rel
, 1, relend
, howto
, 0, contents
);
2054 if (bfd_link_relocatable (info
))
2057 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2058 it here if it is defined in a non-shared object. */
2060 && h
->type
== STT_GNU_IFUNC
2063 asection
*plt
, *base_got
;
2065 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2067 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2068 STT_GNU_IFUNC symbol as STT_FUNC. */
2069 if (elf_section_type (input_section
) == SHT_NOTE
)
2072 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2073 sections because such sections are not SEC_ALLOC and
2074 thus ld.so will not process them. */
2075 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
2080 else if (h
->plt
.offset
== (bfd_vma
) -1
2081 /* The following relocation may not need the .plt entries
2082 when all references to a STT_GNU_IFUNC symbols are done
2083 via GOT or static function pointers. */
2084 && r_type
!= R_RISCV_32
2085 && r_type
!= R_RISCV_64
2086 && r_type
!= R_RISCV_HI20
2087 && r_type
!= R_RISCV_GOT_HI20
2088 && r_type
!= R_RISCV_LO12_I
2089 && r_type
!= R_RISCV_LO12_S
)
2090 goto bad_ifunc_reloc
;
2092 /* STT_GNU_IFUNC symbol must go through PLT. */
2093 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2094 relocation
= plt
->output_section
->vma
2095 + plt
->output_offset
2102 if (rel
->r_addend
!= 0)
2104 if (h
->root
.root
.string
)
2105 name
= h
->root
.root
.string
;
2107 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2110 /* xgettext:c-format */
2111 (_("%pB: relocation %s against STT_GNU_IFUNC "
2112 "symbol `%s' has non-zero addend: %" PRId64
),
2113 input_bfd
, howto
->name
, name
, (int64_t) rel
->r_addend
);
2114 bfd_set_error (bfd_error_bad_value
);
2118 /* Generate dynamic relocation only when there is a non-GOT
2119 reference in a shared object or there is no PLT. */
2120 if ((bfd_link_pic (info
) && h
->non_got_ref
)
2121 || h
->plt
.offset
== (bfd_vma
) -1)
2123 Elf_Internal_Rela outrel
;
2126 /* Need a dynamic relocation to get the real function
2128 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2132 if (outrel
.r_offset
== (bfd_vma
) -1
2133 || outrel
.r_offset
== (bfd_vma
) -2)
2136 outrel
.r_offset
+= input_section
->output_section
->vma
2137 + input_section
->output_offset
;
2139 if (h
->dynindx
== -1
2141 || bfd_link_executable (info
))
2143 info
->callbacks
->minfo
2144 (_("Local IFUNC function `%s' in %pB\n"),
2145 h
->root
.root
.string
,
2146 h
->root
.u
.def
.section
->owner
);
2148 /* This symbol is resolved locally. */
2149 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2150 outrel
.r_addend
= h
->root
.u
.def
.value
2151 + h
->root
.u
.def
.section
->output_section
->vma
2152 + h
->root
.u
.def
.section
->output_offset
;
2156 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2157 outrel
.r_addend
= 0;
2160 /* Dynamic relocations are stored in
2161 1. .rela.ifunc section in PIC object.
2162 2. .rela.got section in dynamic executable.
2163 3. .rela.iplt section in static executable. */
2164 if (bfd_link_pic (info
))
2165 sreloc
= htab
->elf
.irelifunc
;
2166 else if (htab
->elf
.splt
!= NULL
)
2167 sreloc
= htab
->elf
.srelgot
;
2169 sreloc
= htab
->elf
.irelplt
;
2171 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2173 /* If this reloc is against an external symbol, we
2174 do not want to fiddle with the addend. Otherwise,
2175 we need to include the symbol value so that it
2176 becomes an addend for the dynamic reloc. For an
2177 internal symbol, we have updated addend. */
2182 case R_RISCV_GOT_HI20
:
2183 base_got
= htab
->elf
.sgot
;
2184 off
= h
->got
.offset
;
2186 if (base_got
== NULL
)
2189 if (off
== (bfd_vma
) -1)
2193 /* We can't use h->got.offset here to save state, or
2194 even just remember the offset, as finish_dynamic_symbol
2195 would use that as offset into .got. */
2197 if (htab
->elf
.splt
!= NULL
)
2199 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
)
2201 off
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2202 base_got
= htab
->elf
.sgotplt
;
2206 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2207 off
= plt_idx
* GOT_ENTRY_SIZE
;
2208 base_got
= htab
->elf
.igotplt
;
2211 if (h
->dynindx
== -1
2215 /* This references the local definition. We must
2216 initialize this entry in the global offset table.
2217 Since the offset must always be a multiple of 8,
2218 we use the least significant bit to record
2219 whether we have initialized it already.
2221 When doing a dynamic link, we create a .rela.got
2222 relocation entry to initialize the value. This
2223 is done in the finish_dynamic_symbol routine. */
2228 bfd_put_NN (output_bfd
, relocation
,
2229 base_got
->contents
+ off
);
2230 /* Note that this is harmless for the case,
2231 as -1 | 1 still is -1. */
2237 relocation
= base_got
->output_section
->vma
2238 + base_got
->output_offset
+ off
;
2240 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2243 r
= bfd_reloc_overflow
;
2247 case R_RISCV_CALL_PLT
:
2249 case R_RISCV_LO12_I
:
2250 case R_RISCV_LO12_S
:
2253 case R_RISCV_PCREL_HI20
:
2254 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2257 r
= bfd_reloc_overflow
;
2262 if (h
->root
.root
.string
)
2263 name
= h
->root
.root
.string
;
2265 /* The entry of local ifunc is fake in global hash table,
2266 we should find the name by the original local symbol. */
2267 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2270 /* xgettext:c-format */
2271 (_("%pB: relocation %s against STT_GNU_IFUNC "
2272 "symbol `%s' isn't supported"), input_bfd
,
2274 bfd_set_error (bfd_error_bad_value
);
2281 name
= h
->root
.root
.string
;
2284 name
= (bfd_elf_string_from_elf_section
2285 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2286 if (name
== NULL
|| *name
== '\0')
2287 name
= bfd_section_name (sec
);
2290 resolved_to_zero
= (h
!= NULL
2291 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
2297 case R_RISCV_TPREL_ADD
:
2299 case R_RISCV_JUMP_SLOT
:
2300 case R_RISCV_RELATIVE
:
2301 /* These require nothing of us at all. */
2305 case R_RISCV_BRANCH
:
2306 case R_RISCV_RVC_BRANCH
:
2307 case R_RISCV_RVC_LUI
:
2308 case R_RISCV_LO12_I
:
2309 case R_RISCV_LO12_S
:
2314 case R_RISCV_32_PCREL
:
2315 case R_RISCV_DELETE
:
2316 /* These require no special handling beyond perform_relocation. */
2319 case R_RISCV_GOT_HI20
:
2324 off
= h
->got
.offset
;
2325 BFD_ASSERT (off
!= (bfd_vma
) -1);
2326 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2327 pic
= bfd_link_pic (info
);
2329 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2330 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
2332 /* This is actually a static link, or it is a
2333 -Bsymbolic link and the symbol is defined
2334 locally, or the symbol was forced to be local
2335 because of a version file. We must initialize
2336 this entry in the global offset table. Since the
2337 offset must always be a multiple of the word size,
2338 we use the least significant bit to record whether
2339 we have initialized it already.
2341 When doing a dynamic link, we create a .rela.got
2342 relocation entry to initialize the value. This
2343 is done in the finish_dynamic_symbol routine. */
2348 bfd_put_NN (output_bfd
, relocation
,
2349 htab
->elf
.sgot
->contents
+ off
);
2354 unresolved_reloc
= false;
2358 BFD_ASSERT (local_got_offsets
!= NULL
2359 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2361 off
= local_got_offsets
[r_symndx
];
2363 /* The offset must always be a multiple of the word size.
2364 So, we can use the least significant bit to record
2365 whether we have already processed this entry. */
2370 if (bfd_link_pic (info
))
2373 Elf_Internal_Rela outrel
;
2375 /* We need to generate a R_RISCV_RELATIVE reloc
2376 for the dynamic linker. */
2377 s
= htab
->elf
.srelgot
;
2378 BFD_ASSERT (s
!= NULL
);
2380 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2382 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2383 outrel
.r_addend
= relocation
;
2385 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
2388 bfd_put_NN (output_bfd
, relocation
,
2389 htab
->elf
.sgot
->contents
+ off
);
2390 local_got_offsets
[r_symndx
] |= 1;
2394 if (rel
->r_addend
!= 0)
2396 msg
= _("The addend isn't allowed for R_RISCV_GOT_HI20");
2397 r
= bfd_reloc_dangerous
;
2401 /* Address of got entry. */
2402 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
2403 absolute
= riscv_zero_pcrel_hi_reloc (rel
, info
, pc
,
2404 relocation
, contents
,
2406 /* Update howto if relocation is changed. */
2407 howto
= riscv_elf_rtype_to_howto (input_bfd
,
2408 ELFNN_R_TYPE (rel
->r_info
));
2410 r
= bfd_reloc_notsupported
;
2411 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2414 r
= bfd_reloc_overflow
;
2423 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2424 contents
+ rel
->r_offset
);
2425 relocation
= old_value
+ relocation
;
2431 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2432 contents
+ rel
->r_offset
);
2433 relocation
= (old_value
& ~howto
->dst_mask
)
2434 | (((old_value
& howto
->dst_mask
) - relocation
)
2444 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2445 contents
+ rel
->r_offset
);
2446 relocation
= old_value
- relocation
;
2451 case R_RISCV_CALL_PLT
:
2452 /* Handle a call to an undefined weak function. This won't be
2453 relaxed, so we have to handle it here. */
2454 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
2455 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
2457 /* We can use x0 as the base register. */
2458 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
2459 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2460 bfd_putl32 (insn
, contents
+ rel
->r_offset
+ 4);
2461 /* Set the relocation value so that we get 0 after the pc
2462 relative adjustment. */
2463 relocation
= sec_addr (input_section
) + rel
->r_offset
;
2468 case R_RISCV_RVC_JUMP
:
2469 if (bfd_link_pic (info
) && h
!= NULL
)
2471 if (h
->plt
.offset
!= MINUS_ONE
)
2473 /* Refer to the PLT entry. This check has to match the
2474 check in _bfd_riscv_relax_section. */
2475 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
2476 unresolved_reloc
= false;
2478 else if (!SYMBOL_REFERENCES_LOCAL (info
, h
)
2479 && (input_section
->flags
& SEC_ALLOC
) != 0
2480 && (input_section
->flags
& SEC_READONLY
) != 0
2481 && ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
)
2483 /* PR 28509, when generating the shared object, these
2484 referenced symbols may bind externally, which means
2485 they will be exported to the dynamic symbol table,
2486 and are preemptible by default. These symbols cannot
2487 be referenced by the non-pic relocations, like
2488 R_RISCV_JAL and R_RISCV_RVC_JUMP relocations.
2490 However, consider that linker may relax the R_RISCV_CALL
2491 relocations to R_RISCV_JAL or R_RISCV_RVC_JUMP, if
2492 these relocations are relocated to the plt entries,
2493 then we won't report error for them.
2495 Perhaps we also need the similar checks for the
2496 R_RISCV_BRANCH and R_RISCV_RVC_BRANCH relocations. */
2497 if (asprintf (&msg_buf
,
2498 _("%%X%%P: relocation %s against `%s' which "
2499 "may bind externally can not be used when "
2500 "making a shared object; recompile "
2502 howto
->name
, h
->root
.root
.string
) == -1)
2505 r
= bfd_reloc_notsupported
;
2510 case R_RISCV_TPREL_HI20
:
2511 relocation
= tpoff (info
, relocation
);
2514 case R_RISCV_TPREL_LO12_I
:
2515 case R_RISCV_TPREL_LO12_S
:
2516 relocation
= tpoff (info
, relocation
);
2519 case R_RISCV_TPREL_I
:
2520 case R_RISCV_TPREL_S
:
2521 relocation
= tpoff (info
, relocation
);
2522 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
2524 /* We can use tp as the base register. */
2525 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2526 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2527 insn
|= X_TP
<< OP_SH_RS1
;
2528 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2531 r
= bfd_reloc_overflow
;
2534 case R_RISCV_GPREL_I
:
2535 case R_RISCV_GPREL_S
:
2537 bfd_vma gp
= riscv_global_pointer_value (info
);
2538 bool x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2539 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2541 /* We can use x0 or gp as the base register. */
2542 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2543 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2546 rel
->r_addend
-= gp
;
2547 insn
|= X_GP
<< OP_SH_RS1
;
2549 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2552 r
= bfd_reloc_overflow
;
2556 case R_RISCV_PCREL_HI20
:
2557 absolute
= riscv_zero_pcrel_hi_reloc (rel
, info
, pc
, relocation
,
2559 /* Update howto if relocation is changed. */
2560 howto
= riscv_elf_rtype_to_howto (input_bfd
,
2561 ELFNN_R_TYPE (rel
->r_info
));
2563 r
= bfd_reloc_notsupported
;
2564 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2565 relocation
+ rel
->r_addend
,
2567 r
= bfd_reloc_overflow
;
2570 case R_RISCV_PCREL_LO12_I
:
2571 case R_RISCV_PCREL_LO12_S
:
2572 /* We don't allow section symbols plus addends as the auipc address,
2573 because then riscv_relax_delete_bytes would have to search through
2574 all relocs to update these addends. This is also ambiguous, as
2575 we do allow offsets to be added to the target address, which are
2576 not to be used to find the auipc address. */
2577 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2578 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2581 msg
= _("%pcrel_lo section symbol with an addend");
2582 r
= bfd_reloc_dangerous
;
2586 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, relocation
, rel
,
2587 input_section
, info
, howto
,
2590 r
= bfd_reloc_overflow
;
2593 case R_RISCV_TLS_DTPREL32
:
2594 case R_RISCV_TLS_DTPREL64
:
2595 relocation
= dtpoff (info
, relocation
);
2600 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2603 if ((bfd_link_pic (info
)
2605 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2606 && !resolved_to_zero
)
2607 || h
->root
.type
!= bfd_link_hash_undefweak
)
2608 && (!howto
->pc_relative
2609 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2610 || (!bfd_link_pic (info
)
2616 || h
->root
.type
== bfd_link_hash_undefweak
2617 || h
->root
.type
== bfd_link_hash_undefined
)))
2619 Elf_Internal_Rela outrel
;
2621 bool skip_static_relocation
, skip_dynamic_relocation
;
2623 /* When generating a shared object, these relocations
2624 are copied into the output file to be resolved at run
2628 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2630 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2631 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2632 outrel
.r_offset
+= sec_addr (input_section
);
2634 if (skip_dynamic_relocation
)
2635 memset (&outrel
, 0, sizeof outrel
);
2636 else if (h
!= NULL
&& h
->dynindx
!= -1
2637 && !(bfd_link_pic (info
)
2638 && SYMBOLIC_BIND (info
, h
)
2641 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2642 outrel
.r_addend
= rel
->r_addend
;
2646 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2647 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2650 sreloc
= elf_section_data (input_section
)->sreloc
;
2651 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2652 if (skip_static_relocation
)
2657 case R_RISCV_TLS_GOT_HI20
:
2661 case R_RISCV_TLS_GD_HI20
:
2664 off
= h
->got
.offset
;
2669 off
= local_got_offsets
[r_symndx
];
2670 local_got_offsets
[r_symndx
] |= 1;
2673 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2674 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2675 /* If this symbol is referenced by both GD and IE TLS, the IE
2676 reference's GOT slot follows the GD reference's slots. */
2678 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2679 ie_off
= 2 * GOT_ENTRY_SIZE
;
2685 Elf_Internal_Rela outrel
;
2687 bool need_relocs
= false;
2689 if (htab
->elf
.srelgot
== NULL
)
2695 dyn
= htab
->elf
.dynamic_sections_created
;
2696 pic
= bfd_link_pic (info
);
2698 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2699 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2703 /* The GOT entries have not been initialized yet. Do it
2704 now, and emit any relocations. */
2705 if ((bfd_link_pic (info
) || indx
!= 0)
2707 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2708 || h
->root
.type
!= bfd_link_hash_undefweak
))
2711 if (tls_type
& GOT_TLS_GD
)
2715 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2716 outrel
.r_addend
= 0;
2717 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2718 bfd_put_NN (output_bfd
, 0,
2719 htab
->elf
.sgot
->contents
+ off
);
2720 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2723 BFD_ASSERT (! unresolved_reloc
);
2724 bfd_put_NN (output_bfd
,
2725 dtpoff (info
, relocation
),
2726 (htab
->elf
.sgot
->contents
2727 + off
+ RISCV_ELF_WORD_BYTES
));
2731 bfd_put_NN (output_bfd
, 0,
2732 (htab
->elf
.sgot
->contents
2733 + off
+ RISCV_ELF_WORD_BYTES
));
2734 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2735 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2736 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2741 /* If we are not emitting relocations for a
2742 general dynamic reference, then we must be in a
2743 static link or an executable link with the
2744 symbol binding locally. Mark it as belonging
2745 to module 1, the executable. */
2746 bfd_put_NN (output_bfd
, 1,
2747 htab
->elf
.sgot
->contents
+ off
);
2748 bfd_put_NN (output_bfd
,
2749 dtpoff (info
, relocation
),
2750 (htab
->elf
.sgot
->contents
2751 + off
+ RISCV_ELF_WORD_BYTES
));
2755 if (tls_type
& GOT_TLS_IE
)
2759 bfd_put_NN (output_bfd
, 0,
2760 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2761 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2763 outrel
.r_addend
= 0;
2765 outrel
.r_addend
= tpoff (info
, relocation
);
2766 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2767 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2771 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2772 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2777 BFD_ASSERT (off
< (bfd_vma
) -2);
2778 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2779 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2782 r
= bfd_reloc_overflow
;
2783 unresolved_reloc
= false;
2787 r
= bfd_reloc_notsupported
;
2790 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2791 because such sections are not SEC_ALLOC and thus ld.so will
2792 not process them. */
2793 if (unresolved_reloc
2794 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2796 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2797 rel
->r_offset
) != (bfd_vma
) -1)
2799 if (asprintf (&msg_buf
,
2800 _("%%X%%P: unresolvable %s relocation against "
2803 h
->root
.root
.string
) == -1)
2806 r
= bfd_reloc_notsupported
;
2810 if (r
== bfd_reloc_ok
)
2811 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2812 input_bfd
, contents
);
2814 /* We should have already detected the error and set message before.
2815 If the error message isn't set since the linker runs out of memory
2816 or we don't set it before, then we should set the default message
2817 with the "internal error" string here. */
2823 case bfd_reloc_overflow
:
2824 info
->callbacks
->reloc_overflow
2825 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2826 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2829 case bfd_reloc_undefined
:
2830 info
->callbacks
->undefined_symbol
2831 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2835 case bfd_reloc_outofrange
:
2837 msg
= _("%X%P: internal error: out of range error\n");
2840 case bfd_reloc_notsupported
:
2842 msg
= _("%X%P: internal error: unsupported relocation error\n");
2845 case bfd_reloc_dangerous
:
2846 /* The error message should already be set. */
2848 msg
= _("dangerous relocation error");
2849 info
->callbacks
->reloc_dangerous
2850 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2854 msg
= _("%X%P: internal error: unknown error\n");
2858 /* Do not report error message for the dangerous relocation again. */
2859 if (msg
&& r
!= bfd_reloc_dangerous
)
2860 info
->callbacks
->einfo (msg
);
2862 /* Free the unused `msg_buf`. */
2865 /* We already reported the error via a callback, so don't try to report
2866 it again by returning false. That leads to spurious errors. */
2871 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2873 riscv_free_pcrel_relocs (&pcrel_relocs
);
2877 /* Finish up dynamic symbol handling. We set the contents of various
2878 dynamic sections here. */
2881 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2882 struct bfd_link_info
*info
,
2883 struct elf_link_hash_entry
*h
,
2884 Elf_Internal_Sym
*sym
)
2886 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2887 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2889 if (h
->plt
.offset
!= (bfd_vma
) -1)
2891 /* We've decided to create a PLT entry for this symbol. */
2893 bfd_vma i
, header_address
, plt_idx
, got_offset
, got_address
;
2894 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2895 Elf_Internal_Rela rela
;
2896 asection
*plt
, *gotplt
, *relplt
;
2898 /* When building a static executable, use .iplt, .igot.plt and
2899 .rela.iplt sections for STT_GNU_IFUNC symbols. */
2900 if (htab
->elf
.splt
!= NULL
)
2902 plt
= htab
->elf
.splt
;
2903 gotplt
= htab
->elf
.sgotplt
;
2904 relplt
= htab
->elf
.srelplt
;
2908 plt
= htab
->elf
.iplt
;
2909 gotplt
= htab
->elf
.igotplt
;
2910 relplt
= htab
->elf
.irelplt
;
2913 /* This symbol has an entry in the procedure linkage table. Set
2915 if ((h
->dynindx
== -1
2916 && !((h
->forced_local
|| bfd_link_executable (info
))
2918 && h
->type
== STT_GNU_IFUNC
))
2924 /* Calculate the address of the PLT header. */
2925 header_address
= sec_addr (plt
);
2927 /* Calculate the index of the entry and the offset of .got.plt entry.
2928 For static executables, we don't reserve anything. */
2929 if (plt
== htab
->elf
.splt
)
2931 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2932 got_offset
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2936 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2937 got_offset
= plt_idx
* GOT_ENTRY_SIZE
;
2940 /* Calculate the address of the .got.plt entry. */
2941 got_address
= sec_addr (gotplt
) + got_offset
;
2943 /* Find out where the .plt entry should go. */
2944 loc
= plt
->contents
+ h
->plt
.offset
;
2946 /* Fill in the PLT entry itself. */
2947 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2948 header_address
+ h
->plt
.offset
,
2952 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2953 bfd_putl32 (plt_entry
[i
], loc
+ 4*i
);
2955 /* Fill in the initial value of the .got.plt entry. */
2956 loc
= gotplt
->contents
+ (got_address
- sec_addr (gotplt
));
2957 bfd_put_NN (output_bfd
, sec_addr (plt
), loc
);
2959 rela
.r_offset
= got_address
;
2961 if (h
->dynindx
== -1
2962 || ((bfd_link_executable (info
)
2963 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2965 && h
->type
== STT_GNU_IFUNC
))
2967 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2968 h
->root
.root
.string
,
2969 h
->root
.u
.def
.section
->owner
);
2971 /* If an STT_GNU_IFUNC symbol is locally defined, generate
2972 R_RISCV_IRELATIVE instead of R_RISCV_JUMP_SLOT. */
2973 asection
*sec
= h
->root
.u
.def
.section
;
2974 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2975 rela
.r_addend
= h
->root
.u
.def
.value
2976 + sec
->output_section
->vma
2977 + sec
->output_offset
;
2981 /* Fill in the entry in the .rela.plt section. */
2982 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2986 loc
= relplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2987 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2989 if (!h
->def_regular
)
2991 /* Mark the symbol as undefined, rather than as defined in
2992 the .plt section. Leave the value alone. */
2993 sym
->st_shndx
= SHN_UNDEF
;
2994 /* If the symbol is weak, we do need to clear the value.
2995 Otherwise, the PLT entry would provide a definition for
2996 the symbol even if the symbol wasn't defined anywhere,
2997 and so the symbol would never be NULL. */
2998 if (!h
->ref_regular_nonweak
)
3003 if (h
->got
.offset
!= (bfd_vma
) -1
3004 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
3005 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
3009 Elf_Internal_Rela rela
;
3010 bool use_elf_append_rela
= true;
3012 /* This symbol has an entry in the GOT. Set it up. */
3014 sgot
= htab
->elf
.sgot
;
3015 srela
= htab
->elf
.srelgot
;
3016 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
3018 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
3020 /* Handle the ifunc symbol in GOT entry. */
3022 && h
->type
== STT_GNU_IFUNC
)
3024 if (h
->plt
.offset
== (bfd_vma
) -1)
3026 /* STT_GNU_IFUNC is referenced without PLT. */
3028 if (htab
->elf
.splt
== NULL
)
3030 /* Use .rela.iplt section to store .got relocations
3031 in static executable. */
3032 srela
= htab
->elf
.irelplt
;
3034 /* Do not use riscv_elf_append_rela to add dynamic
3036 use_elf_append_rela
= false;
3039 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3041 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
3042 h
->root
.root
.string
,
3043 h
->root
.u
.def
.section
->owner
);
3045 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
3046 rela
.r_addend
= (h
->root
.u
.def
.value
3047 + h
->root
.u
.def
.section
->output_section
->vma
3048 + h
->root
.u
.def
.section
->output_offset
);
3052 /* Generate R_RISCV_NN. */
3053 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3054 BFD_ASSERT (h
->dynindx
!= -1);
3055 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3059 else if (bfd_link_pic (info
))
3061 /* Generate R_RISCV_NN. */
3062 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3063 BFD_ASSERT (h
->dynindx
!= -1);
3064 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3071 if (!h
->pointer_equality_needed
)
3074 /* For non-shared object, we can't use .got.plt, which
3075 contains the real function address if we need pointer
3076 equality. We load the GOT entry with the PLT entry. */
3077 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3078 bfd_put_NN (output_bfd
, (plt
->output_section
->vma
3079 + plt
->output_offset
3081 htab
->elf
.sgot
->contents
3082 + (h
->got
.offset
& ~(bfd_vma
) 1));
3086 else if (bfd_link_pic (info
)
3087 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3089 /* If this is a local symbol reference, we just want to emit
3090 a RELATIVE reloc. This can happen if it is a -Bsymbolic link,
3091 or a pie link, or the symbol was forced to be local because
3092 of a version file. The entry in the global offset table will
3093 already have been initialized in the relocate_section function. */
3094 BFD_ASSERT ((h
->got
.offset
& 1) != 0);
3095 asection
*sec
= h
->root
.u
.def
.section
;
3096 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
3097 rela
.r_addend
= (h
->root
.u
.def
.value
3098 + sec
->output_section
->vma
3099 + sec
->output_offset
);
3103 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3104 BFD_ASSERT (h
->dynindx
!= -1);
3105 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3109 bfd_put_NN (output_bfd
, 0,
3110 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3112 if (use_elf_append_rela
)
3113 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
3116 /* Use riscv_elf_append_rela to add the dynamic relocs into
3117 .rela.iplt may cause the overwrite problems. Since we insert
3118 the relocs for PLT didn't handle the reloc_index of .rela.iplt,
3119 but the riscv_elf_append_rela adds the relocs to the place
3120 that are calculated from the reloc_index (in seqential).
3122 One solution is that add these dynamic relocs (GOT IFUNC)
3123 from the last of .rela.iplt section. */
3124 bfd_vma iplt_idx
= htab
->last_iplt_index
--;
3125 bfd_byte
*loc
= srela
->contents
3126 + iplt_idx
* sizeof (ElfNN_External_Rela
);
3127 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
3133 Elf_Internal_Rela rela
;
3136 /* This symbols needs a copy reloc. Set it up. */
3137 BFD_ASSERT (h
->dynindx
!= -1);
3139 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3140 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
3142 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
3143 s
= htab
->elf
.sreldynrelro
;
3145 s
= htab
->elf
.srelbss
;
3146 riscv_elf_append_rela (output_bfd
, s
, &rela
);
3149 /* Mark some specially defined symbols as absolute. */
3150 if (h
== htab
->elf
.hdynamic
3151 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
3152 sym
->st_shndx
= SHN_ABS
;
3157 /* Finish up local dynamic symbol handling. We set the contents of
3158 various dynamic sections here. */
3161 riscv_elf_finish_local_dynamic_symbol (void **slot
, void *inf
)
3163 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) *slot
;
3164 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3166 return riscv_elf_finish_dynamic_symbol (info
->output_bfd
, info
, h
, NULL
);
3169 /* Finish up the dynamic sections. */
3172 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3173 bfd
*dynobj
, asection
*sdyn
)
3175 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3176 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
3177 size_t dynsize
= bed
->s
->sizeof_dyn
;
3178 bfd_byte
*dyncon
, *dynconend
;
3180 dynconend
= sdyn
->contents
+ sdyn
->size
;
3181 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
3183 Elf_Internal_Dyn dyn
;
3186 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
3191 s
= htab
->elf
.sgotplt
;
3192 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3195 s
= htab
->elf
.srelplt
;
3196 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3199 s
= htab
->elf
.srelplt
;
3200 dyn
.d_un
.d_val
= s
->size
;
3206 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3212 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
3213 struct bfd_link_info
*info
)
3217 struct riscv_elf_link_hash_table
*htab
;
3219 htab
= riscv_elf_hash_table (info
);
3220 BFD_ASSERT (htab
!= NULL
);
3221 dynobj
= htab
->elf
.dynobj
;
3223 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3225 if (elf_hash_table (info
)->dynamic_sections_created
)
3230 splt
= htab
->elf
.splt
;
3231 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3233 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
3238 /* Fill in the head and tail entries in the procedure linkage table. */
3242 uint32_t plt_header
[PLT_HEADER_INSNS
];
3243 ret
= riscv_make_plt_header (output_bfd
,
3244 sec_addr (htab
->elf
.sgotplt
),
3245 sec_addr (splt
), plt_header
);
3249 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
3250 bfd_putl32 (plt_header
[i
], splt
->contents
+ 4*i
);
3252 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
3257 if (htab
->elf
.sgotplt
)
3259 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
3261 if (bfd_is_abs_section (output_section
))
3263 (*_bfd_error_handler
)
3264 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
3268 if (htab
->elf
.sgotplt
->size
> 0)
3270 /* Write the first two entries in .got.plt, needed for the dynamic
3272 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
3273 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
3274 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
3277 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3282 asection
*output_section
= htab
->elf
.sgot
->output_section
;
3284 if (htab
->elf
.sgot
->size
> 0)
3286 /* Set the first entry in the global offset table to the address of
3287 the dynamic section. */
3288 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
3289 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
3292 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3295 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
3296 htab_traverse (htab
->loc_hash_table
,
3297 riscv_elf_finish_local_dynamic_symbol
,
3303 /* Return address for Ith PLT stub in section PLT, for relocation REL
3304 or (bfd_vma) -1 if it should not be included. */
3307 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
3308 const arelent
*rel ATTRIBUTE_UNUSED
)
3310 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
3313 static enum elf_reloc_type_class
3314 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3315 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3316 const Elf_Internal_Rela
*rela
)
3318 switch (ELFNN_R_TYPE (rela
->r_info
))
3320 case R_RISCV_RELATIVE
:
3321 return reloc_class_relative
;
3322 case R_RISCV_JUMP_SLOT
:
3323 return reloc_class_plt
;
3325 return reloc_class_copy
;
3327 return reloc_class_normal
;
3331 /* Given the ELF header flags in FLAGS, it returns a string that describes the
3335 riscv_float_abi_string (flagword flags
)
3337 switch (flags
& EF_RISCV_FLOAT_ABI
)
3339 case EF_RISCV_FLOAT_ABI_SOFT
:
3340 return "soft-float";
3342 case EF_RISCV_FLOAT_ABI_SINGLE
:
3343 return "single-float";
3345 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3346 return "double-float";
3348 case EF_RISCV_FLOAT_ABI_QUAD
:
3349 return "quad-float";
3356 /* The information of architecture elf attributes. */
3357 static riscv_subset_list_t in_subsets
;
3358 static riscv_subset_list_t out_subsets
;
3359 static riscv_subset_list_t merged_subsets
;
3361 /* Predicator for standard extension. */
3364 riscv_std_ext_p (const char *name
)
3366 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
3369 /* Update the output subset's version to match the input when the input
3370 subset's version is newer. */
3373 riscv_update_subset_version (struct riscv_subset_t
*in
,
3374 struct riscv_subset_t
*out
)
3376 if (in
== NULL
|| out
== NULL
)
3379 /* Update the output ISA versions to the newest ones, but otherwise don't
3380 provide any errors or warnings about mis-matched ISA versions as it's
3381 generally too tricky to check for these at link time. */
3382 if ((in
->major_version
> out
->major_version
)
3383 || (in
->major_version
== out
->major_version
3384 && in
->minor_version
> out
->minor_version
)
3385 || (out
->major_version
== RISCV_UNKNOWN_VERSION
))
3387 out
->major_version
= in
->major_version
;
3388 out
->minor_version
= in
->minor_version
;
3392 /* Return true if subset is 'i' or 'e'. */
3395 riscv_i_or_e_p (bfd
*ibfd
,
3397 struct riscv_subset_t
*subset
)
3399 if ((strcasecmp (subset
->name
, "e") != 0)
3400 && (strcasecmp (subset
->name
, "i") != 0))
3403 (_("error: %pB: corrupted ISA string '%s'. "
3404 "First letter should be 'i' or 'e' but got '%s'"),
3405 ibfd
, arch
, subset
->name
);
3411 /* Merge standard extensions.
3414 Return FALSE if failed to merge.
3418 `in_arch`: Raw ISA string for input object.
3419 `out_arch`: Raw ISA string for output object.
3420 `pin`: Subset list for input object.
3421 `pout`: Subset list for output object. */
3424 riscv_merge_std_ext (bfd
*ibfd
,
3425 const char *in_arch
,
3426 const char *out_arch
,
3427 struct riscv_subset_t
**pin
,
3428 struct riscv_subset_t
**pout
)
3430 const char *standard_exts
= "mafdqlcbjtpvnh";
3432 struct riscv_subset_t
*in
= *pin
;
3433 struct riscv_subset_t
*out
= *pout
;
3435 /* First letter should be 'i' or 'e'. */
3436 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
3439 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
3442 if (strcasecmp (in
->name
, out
->name
) != 0)
3444 /* TODO: We might allow merge 'i' with 'e'. */
3446 (_("error: %pB: mis-matched ISA string to merge '%s' and '%s'"),
3447 ibfd
, in
->name
, out
->name
);
3451 riscv_update_subset_version(in
, out
);
3452 riscv_add_subset (&merged_subsets
,
3453 out
->name
, out
->major_version
, out
->minor_version
);
3458 /* Handle standard extension first. */
3459 for (p
= standard_exts
; *p
; ++p
)
3461 struct riscv_subset_t
*ext_in
, *ext_out
, *ext_merged
;
3462 char find_ext
[2] = {*p
, '\0'};
3463 bool find_in
, find_out
;
3465 find_in
= riscv_lookup_subset (&in_subsets
, find_ext
, &ext_in
);
3466 find_out
= riscv_lookup_subset (&out_subsets
, find_ext
, &ext_out
);
3468 if (!find_in
&& !find_out
)
3471 if (find_in
&& find_out
)
3472 riscv_update_subset_version(ext_in
, ext_out
);
3474 ext_merged
= find_out
? ext_out
: ext_in
;
3475 riscv_add_subset (&merged_subsets
, ext_merged
->name
,
3476 ext_merged
->major_version
, ext_merged
->minor_version
);
3479 /* Skip all standard extensions. */
3480 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
3481 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
3489 /* Merge multi letter extensions. PIN is a pointer to the head of the input
3490 object subset list. Likewise for POUT and the output object. Return TRUE
3491 on success and FALSE when a conflict is found. */
3494 riscv_merge_multi_letter_ext (riscv_subset_t
**pin
,
3495 riscv_subset_t
**pout
)
3497 riscv_subset_t
*in
= *pin
;
3498 riscv_subset_t
*out
= *pout
;
3499 riscv_subset_t
*tail
;
3505 cmp
= riscv_compare_subsets (in
->name
, out
->name
);
3509 /* `in' comes before `out', append `in' and increment. */
3510 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
3516 /* `out' comes before `in', append `out' and increment. */
3517 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3518 out
->minor_version
);
3523 /* Both present, check version and increment both. */
3524 riscv_update_subset_version (in
, out
);
3526 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3527 out
->minor_version
);
3535 /* If we're here, either `in' or `out' is running longer than
3536 the other. So, we need to append the corresponding tail. */
3537 tail
= in
? in
: out
;
3540 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
3541 tail
->minor_version
);
3549 /* Merge Tag_RISCV_arch attribute. */
3552 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
3554 riscv_subset_t
*in
, *out
;
3555 char *merged_arch_str
;
3557 unsigned xlen_in
, xlen_out
;
3558 merged_subsets
.head
= NULL
;
3559 merged_subsets
.tail
= NULL
;
3561 riscv_parse_subset_t riscv_rps_ld_in
=
3562 {&in_subsets
, _bfd_error_handler
, &xlen_in
, NULL
, false};
3563 riscv_parse_subset_t riscv_rps_ld_out
=
3564 {&out_subsets
, _bfd_error_handler
, &xlen_out
, NULL
, false};
3566 if (in_arch
== NULL
&& out_arch
== NULL
)
3568 if (in_arch
== NULL
&& out_arch
!= NULL
)
3570 if (in_arch
!= NULL
&& out_arch
== NULL
)
3573 /* Parse subset from ISA string. */
3574 if (!riscv_parse_subset (&riscv_rps_ld_in
, in_arch
))
3576 if (!riscv_parse_subset (&riscv_rps_ld_out
, out_arch
))
3579 /* Checking XLEN. */
3580 if (xlen_out
!= xlen_in
)
3583 (_("error: %pB: ISA string of input (%s) doesn't match "
3584 "output (%s)"), ibfd
, in_arch
, out_arch
);
3588 /* Merge subset list. */
3589 in
= in_subsets
.head
;
3590 out
= out_subsets
.head
;
3592 /* Merge standard extension. */
3593 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
3596 /* Merge all non-single letter extensions with single call. */
3597 if (!riscv_merge_multi_letter_ext (&in
, &out
))
3600 if (xlen_in
!= xlen_out
)
3603 (_("error: %pB: XLEN of input (%u) doesn't match "
3604 "output (%u)"), ibfd
, xlen_in
, xlen_out
);
3608 if (xlen_in
!= ARCH_SIZE
)
3611 (_("error: %pB: unsupported XLEN (%u), you might be "
3612 "using wrong emulation"), ibfd
, xlen_in
);
3616 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
3618 /* Release the subset lists. */
3619 riscv_release_subset_list (&in_subsets
);
3620 riscv_release_subset_list (&out_subsets
);
3621 riscv_release_subset_list (&merged_subsets
);
3623 return merged_arch_str
;
3626 /* Merge object attributes from IBFD into output_bfd of INFO.
3627 Raise an error if there are conflicting attributes. */
3630 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3632 bfd
*obfd
= info
->output_bfd
;
3633 obj_attribute
*in_attr
;
3634 obj_attribute
*out_attr
;
3636 bool priv_attrs_merged
= false;
3637 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3640 /* Skip linker created files. */
3641 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3644 /* Skip any input that doesn't have an attribute section.
3645 This enables to link object files without attribute section with
3647 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3650 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3652 /* This is the first object. Copy the attributes. */
3653 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3655 out_attr
= elf_known_obj_attributes_proc (obfd
);
3657 /* Use the Tag_null value to indicate the attributes have been
3664 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3665 out_attr
= elf_known_obj_attributes_proc (obfd
);
3667 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3671 case Tag_RISCV_arch
:
3672 if (!out_attr
[Tag_RISCV_arch
].s
)
3673 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3674 else if (in_attr
[Tag_RISCV_arch
].s
3675 && out_attr
[Tag_RISCV_arch
].s
)
3677 /* Check compatible. */
3679 riscv_merge_arch_attr_info (ibfd
,
3680 in_attr
[Tag_RISCV_arch
].s
,
3681 out_attr
[Tag_RISCV_arch
].s
);
3682 if (merged_arch
== NULL
)
3685 out_attr
[Tag_RISCV_arch
].s
= "";
3688 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3692 case Tag_RISCV_priv_spec
:
3693 case Tag_RISCV_priv_spec_minor
:
3694 case Tag_RISCV_priv_spec_revision
:
3695 /* If we have handled the privileged elf attributes, then skip it. */
3696 if (!priv_attrs_merged
)
3698 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
3699 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
3700 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
3701 enum riscv_spec_class in_priv_spec
= PRIV_SPEC_CLASS_NONE
;
3702 enum riscv_spec_class out_priv_spec
= PRIV_SPEC_CLASS_NONE
;
3704 /* Get the privileged spec class from elf attributes. */
3705 riscv_get_priv_spec_class_from_numbers (in_attr
[Tag_a
].i
,
3709 riscv_get_priv_spec_class_from_numbers (out_attr
[Tag_a
].i
,
3714 /* Allow to link the object without the privileged specs. */
3715 if (out_priv_spec
== PRIV_SPEC_CLASS_NONE
)
3717 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3718 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3719 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3721 else if (in_priv_spec
!= PRIV_SPEC_CLASS_NONE
3722 && in_priv_spec
!= out_priv_spec
)
3725 (_("warning: %pB use privileged spec version %u.%u.%u but "
3726 "the output use version %u.%u.%u"),
3735 /* The privileged spec v1.9.1 can not be linked with others
3736 since the conflicts, so we plan to drop it in a year or
3738 if (in_priv_spec
== PRIV_SPEC_CLASS_1P9P1
3739 || out_priv_spec
== PRIV_SPEC_CLASS_1P9P1
)
3742 (_("warning: privileged spec version 1.9.1 can not be "
3743 "linked with other spec versions"));
3746 /* Update the output privileged spec to the newest one. */
3747 if (in_priv_spec
> out_priv_spec
)
3749 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3750 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3751 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3754 priv_attrs_merged
= true;
3758 case Tag_RISCV_unaligned_access
:
3759 out_attr
[i
].i
|= in_attr
[i
].i
;
3762 case Tag_RISCV_stack_align
:
3763 if (out_attr
[i
].i
== 0)
3764 out_attr
[i
].i
= in_attr
[i
].i
;
3765 else if (in_attr
[i
].i
!= 0
3766 && out_attr
[i
].i
!= 0
3767 && out_attr
[i
].i
!= in_attr
[i
].i
)
3770 (_("error: %pB use %u-byte stack aligned but the output "
3771 "use %u-byte stack aligned"),
3772 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3778 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3781 /* If out_attr was copied from in_attr then it won't have a type yet. */
3782 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3783 out_attr
[i
].type
= in_attr
[i
].type
;
3786 /* Merge Tag_compatibility attributes and any common GNU ones. */
3787 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3790 /* Check for any attributes not known on RISC-V. */
3791 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3796 /* Merge backend specific data from an object file to the output
3797 object file when linking. */
3800 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3802 bfd
*obfd
= info
->output_bfd
;
3803 flagword new_flags
, old_flags
;
3805 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3808 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3810 (*_bfd_error_handler
)
3811 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3812 " target emulation `%s' does not match `%s'"),
3813 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3817 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3820 if (!riscv_merge_attributes (ibfd
, info
))
3823 /* Check to see if the input BFD actually contains any sections. If not,
3824 its flags may not have been initialized either, but it cannot actually
3825 cause any incompatibility. Do not short-circuit dynamic objects; their
3826 section list may be emptied by elf_link_add_object_symbols.
3828 Also check to see if there are no code sections in the input. In this
3829 case, there is no need to check for code specific flags. */
3830 if (!(ibfd
->flags
& DYNAMIC
))
3832 bool null_input_bfd
= true;
3833 bool only_data_sections
= true;
3836 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3838 null_input_bfd
= false;
3840 if ((bfd_section_flags (sec
)
3841 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3842 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3844 only_data_sections
= false;
3849 if (null_input_bfd
|| only_data_sections
)
3853 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3854 old_flags
= elf_elfheader (obfd
)->e_flags
;
3856 if (!elf_flags_init (obfd
))
3858 elf_flags_init (obfd
) = true;
3859 elf_elfheader (obfd
)->e_flags
= new_flags
;
3863 /* Disallow linking different float ABIs. */
3864 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3866 (*_bfd_error_handler
)
3867 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3868 riscv_float_abi_string (new_flags
),
3869 riscv_float_abi_string (old_flags
));
3873 /* Disallow linking RVE and non-RVE. */
3874 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3876 (*_bfd_error_handler
)
3877 (_("%pB: can't link RVE with other target"), ibfd
);
3881 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3882 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3884 /* Allow linking TSO and non-TSO, and keep the TSO flag. */
3885 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_TSO
;
3890 bfd_set_error (bfd_error_bad_value
);
3894 /* A second format for recording PC-relative hi relocations. This stores the
3895 information required to relax them to GP-relative addresses. */
3897 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3898 struct riscv_pcgp_hi_reloc
3905 bool undefined_weak
;
3906 riscv_pcgp_hi_reloc
*next
;
3909 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3910 struct riscv_pcgp_lo_reloc
3913 riscv_pcgp_lo_reloc
*next
;
3918 riscv_pcgp_hi_reloc
*hi
;
3919 riscv_pcgp_lo_reloc
*lo
;
3920 } riscv_pcgp_relocs
;
3922 /* Initialize the pcgp reloc info in P. */
3925 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
3932 /* Free the pcgp reloc info in P. */
3935 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
3936 bfd
*abfd ATTRIBUTE_UNUSED
,
3937 asection
*sec ATTRIBUTE_UNUSED
)
3939 riscv_pcgp_hi_reloc
*c
;
3940 riscv_pcgp_lo_reloc
*l
;
3942 for (c
= p
->hi
; c
!= NULL
; )
3944 riscv_pcgp_hi_reloc
*next
= c
->next
;
3949 for (l
= p
->lo
; l
!= NULL
; )
3951 riscv_pcgp_lo_reloc
*next
= l
->next
;
3957 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
3958 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
3959 relax the corresponding lo part reloc. */
3962 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
3963 bfd_vma hi_addend
, bfd_vma hi_addr
,
3964 unsigned hi_sym
, asection
*sym_sec
,
3965 bool undefined_weak
)
3967 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof (*new));
3970 new->hi_sec_off
= hi_sec_off
;
3971 new->hi_addend
= hi_addend
;
3972 new->hi_addr
= hi_addr
;
3973 new->hi_sym
= hi_sym
;
3974 new->sym_sec
= sym_sec
;
3975 new->undefined_weak
= undefined_weak
;
3981 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3982 This is used by a lo part reloc to find the corresponding hi part reloc. */
3984 static riscv_pcgp_hi_reloc
*
3985 riscv_find_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
3987 riscv_pcgp_hi_reloc
*c
;
3989 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
3990 if (c
->hi_sec_off
== hi_sec_off
)
3995 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
3996 This is used to record relocs that can't be relaxed. */
3999 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4001 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof (*new));
4004 new->hi_sec_off
= hi_sec_off
;
4010 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4011 This is used by a hi part reloc to find the corresponding lo part reloc. */
4014 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4016 riscv_pcgp_lo_reloc
*c
;
4018 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
4019 if (c
->hi_sec_off
== hi_sec_off
)
4025 riscv_update_pcgp_relocs (riscv_pcgp_relocs
*p
, asection
*deleted_sec
,
4026 bfd_vma deleted_addr
, size_t deleted_count
)
4028 /* Bytes have already been deleted and toaddr should match the old section
4029 size for our checks, so adjust it here. */
4030 bfd_vma toaddr
= deleted_sec
->size
+ deleted_count
;
4031 riscv_pcgp_lo_reloc
*l
;
4032 riscv_pcgp_hi_reloc
*h
;
4034 /* Update section offsets of corresponding pcrel_hi relocs for the pcrel_lo
4035 entries where they occur after the deleted bytes. */
4036 for (l
= p
->lo
; l
!= NULL
; l
= l
->next
)
4037 if (l
->hi_sec_off
> deleted_addr
4038 && l
->hi_sec_off
< toaddr
)
4039 l
->hi_sec_off
-= deleted_count
;
4041 /* Update both section offsets, and symbol values of pcrel_hi relocs where
4042 these values occur after the deleted bytes. */
4043 for (h
= p
->hi
; h
!= NULL
; h
= h
->next
)
4045 if (h
->hi_sec_off
> deleted_addr
4046 && h
->hi_sec_off
< toaddr
)
4047 h
->hi_sec_off
-= deleted_count
;
4048 if (h
->sym_sec
== deleted_sec
4049 && h
->hi_addr
> deleted_addr
4050 && h
->hi_addr
< toaddr
)
4051 h
->hi_addr
-= deleted_count
;
4055 /* Delete some bytes, adjust relcocations and symbol table from a section. */
4058 _riscv_relax_delete_bytes (bfd
*abfd
,
4062 struct bfd_link_info
*link_info
,
4063 riscv_pcgp_relocs
*p
,
4064 bfd_vma delete_total
,
4067 unsigned int i
, symcount
;
4068 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
4069 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4070 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
4071 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
4072 bfd_byte
*contents
= data
->this_hdr
.contents
;
4073 size_t bytes_to_move
= toaddr
- addr
- count
;
4075 /* Actually delete the bytes. */
4077 memmove (contents
+ addr
, contents
+ addr
+ count
+ delete_total
, bytes_to_move
);
4079 /* Still adjust relocations and symbols in non-linear times. */
4080 toaddr
= sec
->size
+ count
;
4082 /* Adjust the location of all of the relocs. Note that we need not
4083 adjust the addends, since all PC-relative references must be against
4084 symbols, which we will adjust below. */
4085 for (i
= 0; i
< sec
->reloc_count
; i
++)
4086 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
4087 data
->relocs
[i
].r_offset
-= count
;
4089 /* Adjust the hi_sec_off, and the hi_addr of any entries in the pcgp relocs
4090 table for which these values occur after the deleted bytes. */
4092 riscv_update_pcgp_relocs (p
, sec
, addr
, count
);
4094 /* Adjust the local symbols defined in this section. */
4095 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
4097 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
4098 if (sym
->st_shndx
== sec_shndx
)
4100 /* If the symbol is in the range of memory we just moved, we
4101 have to adjust its value. */
4102 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
4103 sym
->st_value
-= count
;
4105 /* If the symbol *spans* the bytes we just deleted (i.e. its
4106 *end* is in the moved bytes but its *start* isn't), then we
4107 must adjust its size.
4109 This test needs to use the original value of st_value, otherwise
4110 we might accidentally decrease size when deleting bytes right
4111 before the symbol. But since deleted relocs can't span across
4112 symbols, we can't have both a st_value and a st_size decrease,
4113 so it is simpler to just use an else. */
4114 else if (sym
->st_value
<= addr
4115 && sym
->st_value
+ sym
->st_size
> addr
4116 && sym
->st_value
+ sym
->st_size
<= toaddr
)
4117 sym
->st_size
-= count
;
4121 /* Now adjust the global symbols defined in this section. */
4122 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
4123 - symtab_hdr
->sh_info
);
4125 for (i
= 0; i
< symcount
; i
++)
4127 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
4129 /* The '--wrap SYMBOL' option is causing a pain when the object file,
4130 containing the definition of __wrap_SYMBOL, includes a direct
4131 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
4132 the same symbol (which is __wrap_SYMBOL), but still exist as two
4133 different symbols in 'sym_hashes', we don't want to adjust
4134 the global symbol __wrap_SYMBOL twice.
4136 The same problem occurs with symbols that are versioned_hidden, as
4137 foo becomes an alias for foo@BAR, and hence they need the same
4139 if (link_info
->wrap_hash
!= NULL
4140 || sym_hash
->versioned
!= unversioned
)
4142 struct elf_link_hash_entry
**cur_sym_hashes
;
4144 /* Loop only over the symbols which have already been checked. */
4145 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
4148 /* If the current symbol is identical to 'sym_hash', that means
4149 the symbol was already adjusted (or at least checked). */
4150 if (*cur_sym_hashes
== sym_hash
)
4153 /* Don't adjust the symbol again. */
4154 if (cur_sym_hashes
< &sym_hashes
[i
])
4158 if ((sym_hash
->root
.type
== bfd_link_hash_defined
4159 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
4160 && sym_hash
->root
.u
.def
.section
== sec
)
4162 /* As above, adjust the value if needed. */
4163 if (sym_hash
->root
.u
.def
.value
> addr
4164 && sym_hash
->root
.u
.def
.value
<= toaddr
)
4165 sym_hash
->root
.u
.def
.value
-= count
;
4167 /* As above, adjust the size if needed. */
4168 else if (sym_hash
->root
.u
.def
.value
<= addr
4169 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
4170 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
4171 sym_hash
->size
-= count
;
4178 typedef bool (*relax_delete_t
) (bfd
*, asection
*,
4180 struct bfd_link_info
*,
4181 riscv_pcgp_relocs
*,
4182 Elf_Internal_Rela
*);
4184 static relax_delete_t riscv_relax_delete_bytes
;
4186 /* Do not delete some bytes from a section while relaxing.
4187 Just mark the deleted bytes as R_RISCV_DELETE. */
4190 _riscv_relax_delete_piecewise (bfd
*abfd ATTRIBUTE_UNUSED
,
4191 asection
*sec ATTRIBUTE_UNUSED
,
4194 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
4195 riscv_pcgp_relocs
*p ATTRIBUTE_UNUSED
,
4196 Elf_Internal_Rela
*rel
)
4200 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
4201 rel
->r_offset
= addr
;
4202 rel
->r_addend
= count
;
4206 /* Delete some bytes from a section while relaxing. */
4209 _riscv_relax_delete_immediate (bfd
*abfd
,
4213 struct bfd_link_info
*link_info
,
4214 riscv_pcgp_relocs
*p
,
4215 Elf_Internal_Rela
*rel
)
4218 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4219 return _riscv_relax_delete_bytes (abfd
, sec
, addr
, count
,
4220 link_info
, p
, 0, sec
->size
);
4223 /* Delete the bytes for R_RISCV_DELETE relocs. */
4226 riscv_relax_resolve_delete_relocs (bfd
*abfd
,
4228 struct bfd_link_info
*link_info
,
4229 Elf_Internal_Rela
*relocs
)
4231 bfd_vma delete_total
= 0;
4234 for (i
= 0; i
< sec
->reloc_count
; i
++)
4236 Elf_Internal_Rela
*rel
= relocs
+ i
;
4237 if (ELFNN_R_TYPE (rel
->r_info
) != R_RISCV_DELETE
)
4240 /* Find the next R_RISCV_DELETE reloc if possible. */
4241 Elf_Internal_Rela
*rel_next
= NULL
;
4242 unsigned int start
= rel
- relocs
;
4243 for (i
= start
; i
< sec
->reloc_count
; i
++)
4245 /* Since we only replace existing relocs and don't add new relocs, the
4246 relocs are in sequential order. We can skip the relocs prior to this
4247 one, making this search linear time. */
4248 rel_next
= relocs
+ i
;
4249 if (ELFNN_R_TYPE ((rel_next
)->r_info
) == R_RISCV_DELETE
4250 && (rel_next
)->r_offset
> rel
->r_offset
)
4252 BFD_ASSERT (rel_next
- rel
> 0);
4259 bfd_vma toaddr
= rel_next
== NULL
? sec
->size
: rel_next
->r_offset
;
4260 if (!_riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
4261 link_info
, NULL
, delete_total
, toaddr
))
4264 delete_total
+= rel
->r_addend
;
4265 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4267 /* Skip ahead to the next delete reloc. */
4268 i
= rel_next
!= NULL
? (unsigned int) (rel_next
- relocs
- 1)
4275 typedef bool (*relax_func_t
) (bfd
*, asection
*, asection
*,
4276 struct bfd_link_info
*,
4277 Elf_Internal_Rela
*,
4278 bfd_vma
, bfd_vma
, bfd_vma
, bool *,
4279 riscv_pcgp_relocs
*,
4280 bool undefined_weak
);
4282 /* Relax AUIPC + JALR into JAL. */
4285 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
4286 struct bfd_link_info
*link_info
,
4287 Elf_Internal_Rela
*rel
,
4289 bfd_vma max_alignment
,
4290 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4292 riscv_pcgp_relocs
*pcgp_relocs
,
4293 bool undefined_weak ATTRIBUTE_UNUSED
)
4295 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4296 bfd_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
4297 bool near_zero
= (symval
+ RISCV_IMM_REACH
/ 2) < RISCV_IMM_REACH
;
4298 bfd_vma auipc
, jalr
;
4299 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4301 /* If the call crosses section boundaries, an alignment directive could
4302 cause the PC-relative offset to later increase, so we need to add in the
4303 max alignment of any section inclusive from the call to the target.
4304 Otherwise, we only need to use the alignment of the current section. */
4305 if (VALID_JTYPE_IMM (foff
))
4307 if (sym_sec
->output_section
== sec
->output_section
4308 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4309 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4310 foff
+= ((bfd_signed_vma
) foff
< 0 ? -max_alignment
: max_alignment
);
4313 /* See if this function call can be shortened. */
4314 if (!VALID_JTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
4317 /* Shorten the function call. */
4318 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
4320 auipc
= bfd_getl32 (contents
+ rel
->r_offset
);
4321 jalr
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
4322 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
4323 rvc
= rvc
&& VALID_CJTYPE_IMM (foff
);
4325 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
4326 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
4330 /* Relax to C.J[AL] rd, addr. */
4331 r_type
= R_RISCV_RVC_JUMP
;
4332 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
4335 else if (VALID_JTYPE_IMM (foff
))
4337 /* Relax to JAL rd, addr. */
4338 r_type
= R_RISCV_JAL
;
4339 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
4343 /* Near zero, relax to JALR rd, x0, addr. */
4344 r_type
= R_RISCV_LO12_I
;
4345 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
4348 /* Replace the R_RISCV_CALL reloc. */
4349 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
4350 /* Replace the AUIPC. */
4351 riscv_put_insn (8 * len
, auipc
, contents
+ rel
->r_offset
);
4353 /* Delete unnecessary JALR and reuse the R_RISCV_RELAX reloc. */
4355 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
4356 link_info
, pcgp_relocs
, rel
+ 1);
4359 /* Traverse all output sections and return the max alignment. */
4362 _bfd_riscv_get_max_alignment (asection
*sec
)
4364 unsigned int max_alignment_power
= 0;
4367 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
4369 if (o
->alignment_power
> max_alignment_power
)
4370 max_alignment_power
= o
->alignment_power
;
4373 return (bfd_vma
) 1 << max_alignment_power
;
4376 /* Relax non-PIC global variable references to GP-relative references. */
4379 _bfd_riscv_relax_lui (bfd
*abfd
,
4382 struct bfd_link_info
*link_info
,
4383 Elf_Internal_Rela
*rel
,
4385 bfd_vma max_alignment
,
4386 bfd_vma reserve_size
,
4388 riscv_pcgp_relocs
*pcgp_relocs
,
4389 bool undefined_weak
)
4391 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4392 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4393 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4395 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4399 /* If gp and the symbol are in the same output section, which is not the
4400 abs section, then consider only that output section's alignment. */
4401 struct bfd_link_hash_entry
*h
=
4402 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, false, false,
4404 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4405 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4406 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4409 /* Is the reference in range of x0 or gp?
4410 Valid gp range conservatively because of alignment issue. */
4412 || (VALID_ITYPE_IMM (symval
)
4414 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4416 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4418 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
4419 switch (ELFNN_R_TYPE (rel
->r_info
))
4421 case R_RISCV_LO12_I
:
4424 /* Change the RS1 to zero. */
4425 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4426 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4427 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4430 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4433 case R_RISCV_LO12_S
:
4436 /* Change the RS1 to zero. */
4437 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4438 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4439 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4442 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4446 /* Delete unnecessary LUI and reuse the reloc. */
4448 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
4449 link_info
, pcgp_relocs
, rel
);
4456 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
4457 account for this assuming page alignment at worst. In the presence of
4458 RELRO segment the linker aligns it by one page size, therefore sections
4459 after the segment can be moved more than one page. */
4462 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
4463 && VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
4464 && VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
4465 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
4466 : ELF_MAXPAGESIZE
)))
4468 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
4469 bfd_vma lui
= bfd_getl32 (contents
+ rel
->r_offset
);
4470 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
4471 if (rd
== 0 || rd
== X_SP
)
4474 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
4475 bfd_putl32 (lui
, contents
+ rel
->r_offset
);
4477 /* Replace the R_RISCV_HI20 reloc. */
4478 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
4480 /* Delete extra bytes and reuse the R_RISCV_RELAX reloc. */
4482 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
4483 link_info
, pcgp_relocs
, rel
+ 1);
4489 /* Relax non-PIC TLS references to TP-relative references. */
4492 _bfd_riscv_relax_tls_le (bfd
*abfd
,
4494 asection
*sym_sec ATTRIBUTE_UNUSED
,
4495 struct bfd_link_info
*link_info
,
4496 Elf_Internal_Rela
*rel
,
4498 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4499 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4501 riscv_pcgp_relocs
*pcgp_relocs
,
4502 bool undefined_weak ATTRIBUTE_UNUSED
)
4504 /* See if this symbol is in range of tp. */
4505 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
4508 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4509 switch (ELFNN_R_TYPE (rel
->r_info
))
4511 case R_RISCV_TPREL_LO12_I
:
4512 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
4515 case R_RISCV_TPREL_LO12_S
:
4516 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
4519 case R_RISCV_TPREL_HI20
:
4520 case R_RISCV_TPREL_ADD
:
4521 /* Delete unnecessary instruction and reuse the reloc. */
4523 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
,
4531 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs.
4532 Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
4535 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
4537 struct bfd_link_info
*link_info
,
4538 Elf_Internal_Rela
*rel
,
4540 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4541 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4542 bool *again ATTRIBUTE_UNUSED
,
4543 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4544 bool undefined_weak ATTRIBUTE_UNUSED
)
4546 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4547 bfd_vma alignment
= 1, pos
;
4548 while (alignment
<= rel
->r_addend
)
4551 symval
-= rel
->r_addend
;
4552 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
4553 bfd_vma nop_bytes
= aligned_addr
- symval
;
4555 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
4556 sec
->sec_flg0
= true;
4558 /* Make sure there are enough NOPs to actually achieve the alignment. */
4559 if (rel
->r_addend
< nop_bytes
)
4562 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
4563 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
4564 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
4565 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
4566 bfd_set_error (bfd_error_bad_value
);
4570 /* Delete the reloc. */
4571 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4573 /* If the number of NOPs is already correct, there's nothing to do. */
4574 if (nop_bytes
== rel
->r_addend
)
4577 /* Write as many RISC-V NOPs as we need. */
4578 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
4579 bfd_putl32 (RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
4581 /* Write a final RVC NOP if need be. */
4582 if (nop_bytes
% 4 != 0)
4583 bfd_putl16 (RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
4585 /* Delete excess bytes. */
4586 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
4587 rel
->r_addend
- nop_bytes
, link_info
,
4591 /* Relax PC-relative references to GP-relative references. */
4594 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
4597 struct bfd_link_info
*link_info
,
4598 Elf_Internal_Rela
*rel
,
4600 bfd_vma max_alignment
,
4601 bfd_vma reserve_size
,
4603 riscv_pcgp_relocs
*pcgp_relocs
,
4604 bool undefined_weak
)
4606 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4607 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4609 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4611 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
4612 actual target address. */
4613 riscv_pcgp_hi_reloc hi_reloc
;
4614 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
4615 switch (ELFNN_R_TYPE (rel
->r_info
))
4617 case R_RISCV_PCREL_LO12_I
:
4618 case R_RISCV_PCREL_LO12_S
:
4620 /* If the %lo has an addend, it isn't for the label pointing at the
4621 hi part instruction, but rather for the symbol pointed at by the
4622 hi part instruction. So we must subtract it here for the lookup.
4623 It is still used below in the final symbol address. */
4624 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
4625 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
4629 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
4634 symval
= hi_reloc
.hi_addr
;
4635 sym_sec
= hi_reloc
.sym_sec
;
4637 /* We can not know whether the undefined weak symbol is referenced
4638 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
4639 we have to record the 'undefined_weak' flag when handling the
4640 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
4641 undefined_weak
= hi_reloc
.undefined_weak
;
4645 case R_RISCV_PCREL_HI20
:
4646 /* Mergeable symbols and code might later move out of range. */
4647 if (! undefined_weak
4648 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
4651 /* If the cooresponding lo relocation has already been seen then it's not
4652 safe to relax this relocation. */
4653 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
4664 /* If gp and the symbol are in the same output section, which is not the
4665 abs section, then consider only that output section's alignment. */
4666 struct bfd_link_hash_entry
*h
=
4667 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, false, false,
4669 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4670 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4671 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4674 /* Is the reference in range of x0 or gp?
4675 Valid gp range conservatively because of alignment issue. */
4677 || (VALID_ITYPE_IMM (symval
)
4679 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4681 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4683 unsigned sym
= hi_reloc
.hi_sym
;
4684 switch (ELFNN_R_TYPE (rel
->r_info
))
4686 case R_RISCV_PCREL_LO12_I
:
4689 /* Change the RS1 to zero, and then modify the relocation
4690 type to R_RISCV_LO12_I. */
4691 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4692 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4693 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4694 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
4695 rel
->r_addend
= hi_reloc
.hi_addend
;
4699 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4700 rel
->r_addend
+= hi_reloc
.hi_addend
;
4704 case R_RISCV_PCREL_LO12_S
:
4707 /* Change the RS1 to zero, and then modify the relocation
4708 type to R_RISCV_LO12_S. */
4709 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4710 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4711 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4712 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
4713 rel
->r_addend
= hi_reloc
.hi_addend
;
4717 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4718 rel
->r_addend
+= hi_reloc
.hi_addend
;
4722 case R_RISCV_PCREL_HI20
:
4723 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
4727 ELFNN_R_SYM(rel
->r_info
),
4730 /* Delete unnecessary AUIPC and reuse the reloc. */
4732 riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
,
4744 /* Called by after_allocation to set the information of data segment
4748 bfd_elfNN_riscv_set_data_segment_info (struct bfd_link_info
*info
,
4749 int *data_segment_phase
)
4751 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4752 htab
->data_segment_phase
= data_segment_phase
;
4757 Pass 0: Shortens code sequences for LUI/CALL/TPREL/PCREL relocs.
4758 Pass 1: Deletes the bytes that PCREL relaxation in pass 0 made obsolete.
4759 Pass 2: Which cannot be disabled, handles code alignment directives. */
4762 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
4763 struct bfd_link_info
*info
,
4766 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
4767 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4768 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
4769 Elf_Internal_Rela
*relocs
;
4772 bfd_vma max_alignment
, reserve_size
= 0;
4773 riscv_pcgp_relocs pcgp_relocs
;
4777 if (bfd_link_relocatable (info
)
4779 || (sec
->flags
& SEC_RELOC
) == 0
4780 || sec
->reloc_count
== 0
4781 || (info
->disable_target_specific_optimizations
4782 && info
->relax_pass
== 0)
4783 /* The exp_seg_relro_adjust is enum phase_enum (0x4),
4784 and defined in ld/ldexp.h. */
4785 || *(htab
->data_segment_phase
) == 4)
4788 riscv_init_pcgp_relocs (&pcgp_relocs
);
4790 /* Read this BFD's relocs if we haven't done so already. */
4792 relocs
= data
->relocs
;
4793 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4794 info
->keep_memory
)))
4799 max_alignment
= htab
->max_alignment
;
4800 if (max_alignment
== (bfd_vma
) -1)
4802 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4803 htab
->max_alignment
= max_alignment
;
4807 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4809 /* Examine and consider relaxing each reloc. */
4810 for (i
= 0; i
< sec
->reloc_count
; i
++)
4813 Elf_Internal_Rela
*rel
= relocs
+ i
;
4814 relax_func_t relax_func
;
4815 int type
= ELFNN_R_TYPE (rel
->r_info
);
4818 bool undefined_weak
= false;
4821 riscv_relax_delete_bytes
= NULL
;
4822 if (info
->relax_pass
== 0)
4824 if (type
== R_RISCV_CALL
4825 || type
== R_RISCV_CALL_PLT
)
4826 relax_func
= _bfd_riscv_relax_call
;
4827 else if (type
== R_RISCV_HI20
4828 || type
== R_RISCV_LO12_I
4829 || type
== R_RISCV_LO12_S
)
4830 relax_func
= _bfd_riscv_relax_lui
;
4831 else if (type
== R_RISCV_TPREL_HI20
4832 || type
== R_RISCV_TPREL_ADD
4833 || type
== R_RISCV_TPREL_LO12_I
4834 || type
== R_RISCV_TPREL_LO12_S
)
4835 relax_func
= _bfd_riscv_relax_tls_le
;
4836 else if (!bfd_link_pic (info
)
4837 && (type
== R_RISCV_PCREL_HI20
4838 || type
== R_RISCV_PCREL_LO12_I
4839 || type
== R_RISCV_PCREL_LO12_S
))
4840 relax_func
= _bfd_riscv_relax_pc
;
4843 riscv_relax_delete_bytes
= _riscv_relax_delete_piecewise
;
4845 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4846 if (i
== sec
->reloc_count
- 1
4847 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4848 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4851 /* Skip over the R_RISCV_RELAX. */
4854 else if (info
->relax_pass
== 1 && type
== R_RISCV_ALIGN
)
4856 relax_func
= _bfd_riscv_relax_align
;
4857 riscv_relax_delete_bytes
= _riscv_relax_delete_immediate
;
4862 data
->relocs
= relocs
;
4864 /* Read this BFD's contents if we haven't done so already. */
4865 if (!data
->this_hdr
.contents
4866 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4869 /* Read this BFD's symbols if we haven't done so already. */
4870 if (symtab_hdr
->sh_info
!= 0
4871 && !symtab_hdr
->contents
4872 && !(symtab_hdr
->contents
=
4873 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4874 symtab_hdr
->sh_info
,
4875 0, NULL
, NULL
, NULL
)))
4878 /* Get the value of the symbol referred to by the reloc. */
4879 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4881 /* A local symbol. */
4882 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4883 + ELFNN_R_SYM (rel
->r_info
));
4884 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4885 ? 0 : isym
->st_size
- rel
->r_addend
;
4887 /* Relocate against local STT_GNU_IFUNC symbol. we have created
4888 a fake global symbol entry for this, so deal with the local ifunc
4890 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4893 if (isym
->st_shndx
== SHN_UNDEF
)
4894 sym_sec
= sec
, symval
= rel
->r_offset
;
4897 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4898 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4900 /* The purpose of this code is unknown. It breaks linker scripts
4901 for embedded development that place sections at address zero.
4902 This code is believed to be unnecessary. Disabling it but not
4903 yet removing it, in case something breaks. */
4904 if (sec_addr (sym_sec
) == 0)
4907 symval
= isym
->st_value
;
4909 symtype
= ELF_ST_TYPE (isym
->st_info
);
4914 struct elf_link_hash_entry
*h
;
4916 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4917 h
= elf_sym_hashes (abfd
)[indx
];
4919 while (h
->root
.type
== bfd_link_hash_indirect
4920 || h
->root
.type
== bfd_link_hash_warning
)
4921 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4923 /* Disable the relaxation for ifunc. */
4924 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
4927 if (h
->root
.type
== bfd_link_hash_undefweak
4928 && (relax_func
== _bfd_riscv_relax_lui
4929 || relax_func
== _bfd_riscv_relax_pc
))
4931 /* For the lui and auipc relaxations, since the symbol
4932 value of an undefined weak symbol is always be zero,
4933 we can optimize the patterns into a single LI/MV/ADDI
4936 Note that, creating shared libraries and pie output may
4937 break the rule above. Fortunately, since we do not relax
4938 pc relocs when creating shared libraries and pie output,
4939 and the absolute address access for R_RISCV_HI20 isn't
4940 allowed when "-fPIC" is set, the problem of creating shared
4941 libraries can not happen currently. Once we support the
4942 auipc relaxations when creating shared libraries, then we will
4943 need the more rigorous checking for this optimization. */
4944 undefined_weak
= true;
4947 /* This line has to match the check in riscv_elf_relocate_section
4948 in the R_RISCV_CALL[_PLT] case. */
4949 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4951 sym_sec
= htab
->elf
.splt
;
4952 symval
= h
->plt
.offset
;
4954 else if (undefined_weak
)
4957 sym_sec
= bfd_und_section_ptr
;
4959 else if ((h
->root
.type
== bfd_link_hash_defined
4960 || h
->root
.type
== bfd_link_hash_defweak
)
4961 && h
->root
.u
.def
.section
!= NULL
4962 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4964 symval
= h
->root
.u
.def
.value
;
4965 sym_sec
= h
->root
.u
.def
.section
;
4970 if (h
->type
!= STT_FUNC
)
4972 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4976 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4977 && (sym_sec
->flags
& SEC_MERGE
))
4979 /* At this stage in linking, no SEC_MERGE symbol has been
4980 adjusted, so all references to such symbols need to be
4981 passed through _bfd_merged_section_offset. (Later, in
4982 relocate_section, all SEC_MERGE symbols *except* for
4983 section symbols have been adjusted.)
4985 gas may reduce relocations against symbols in SEC_MERGE
4986 sections to a relocation against the section symbol when
4987 the original addend was zero. When the reloc is against
4988 a section symbol we should include the addend in the
4989 offset passed to _bfd_merged_section_offset, since the
4990 location of interest is the original symbol. On the
4991 other hand, an access to "sym+addend" where "sym" is not
4992 a section symbol should not include the addend; Such an
4993 access is presumed to be an offset from "sym"; The
4994 location of interest is just "sym". */
4995 if (symtype
== STT_SECTION
)
4996 symval
+= rel
->r_addend
;
4998 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4999 elf_section_data (sym_sec
)->sec_info
,
5002 if (symtype
!= STT_SECTION
)
5003 symval
+= rel
->r_addend
;
5006 symval
+= rel
->r_addend
;
5008 symval
+= sec_addr (sym_sec
);
5010 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
5011 max_alignment
, reserve_size
, again
,
5012 &pcgp_relocs
, undefined_weak
))
5016 /* Resolve R_RISCV_DELETE relocations. */
5017 if (!riscv_relax_resolve_delete_relocs (abfd
, sec
, info
, relocs
))
5023 if (relocs
!= data
->relocs
)
5025 riscv_free_pcgp_relocs (&pcgp_relocs
, abfd
, sec
);
5031 # define PRSTATUS_SIZE 204
5032 # define PRSTATUS_OFFSET_PR_CURSIG 12
5033 # define PRSTATUS_OFFSET_PR_PID 24
5034 # define PRSTATUS_OFFSET_PR_REG 72
5035 # define ELF_GREGSET_T_SIZE 128
5036 # define PRPSINFO_SIZE 128
5037 # define PRPSINFO_OFFSET_PR_PID 16
5038 # define PRPSINFO_OFFSET_PR_FNAME 32
5039 # define PRPSINFO_OFFSET_PR_PSARGS 48
5040 # define PRPSINFO_PR_FNAME_LENGTH 16
5041 # define PRPSINFO_PR_PSARGS_LENGTH 80
5043 # define PRSTATUS_SIZE 376
5044 # define PRSTATUS_OFFSET_PR_CURSIG 12
5045 # define PRSTATUS_OFFSET_PR_PID 32
5046 # define PRSTATUS_OFFSET_PR_REG 112
5047 # define ELF_GREGSET_T_SIZE 256
5048 # define PRPSINFO_SIZE 136
5049 # define PRPSINFO_OFFSET_PR_PID 24
5050 # define PRPSINFO_OFFSET_PR_FNAME 40
5051 # define PRPSINFO_OFFSET_PR_PSARGS 56
5052 # define PRPSINFO_PR_FNAME_LENGTH 16
5053 # define PRPSINFO_PR_PSARGS_LENGTH 80
5056 /* Write PRSTATUS and PRPSINFO note into core file. This will be called
5057 before the generic code in elf.c. By checking the compiler defines we
5058 only perform any action here if the generic code would otherwise not be
5059 able to help us. The intention is that bare metal core dumps (where the
5060 prstatus_t and/or prpsinfo_t might not be available) will use this code,
5061 while non bare metal tools will use the generic elf code. */
5064 riscv_write_core_note (bfd
*abfd ATTRIBUTE_UNUSED
,
5065 char *buf ATTRIBUTE_UNUSED
,
5066 int *bufsiz ATTRIBUTE_UNUSED
,
5067 int note_type ATTRIBUTE_UNUSED
, ...)
5074 #if !defined (HAVE_PRPSINFO_T)
5077 char data
[PRPSINFO_SIZE
] ATTRIBUTE_NONSTRING
;
5080 va_start (ap
, note_type
);
5081 memset (data
, 0, sizeof (data
));
5082 strncpy (data
+ PRPSINFO_OFFSET_PR_FNAME
, va_arg (ap
, const char *),
5083 PRPSINFO_PR_FNAME_LENGTH
);
5084 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
5086 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
5087 -Wstringop-truncation:
5088 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
5090 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
5092 strncpy (data
+ PRPSINFO_OFFSET_PR_PSARGS
, va_arg (ap
, const char *),
5093 PRPSINFO_PR_PSARGS_LENGTH
);
5094 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
5098 return elfcore_write_note (abfd
, buf
, bufsiz
,
5099 "CORE", note_type
, data
, sizeof (data
));
5101 #endif /* !HAVE_PRPSINFO_T */
5103 #if !defined (HAVE_PRSTATUS_T)
5106 char data
[PRSTATUS_SIZE
];
5112 va_start (ap
, note_type
);
5113 memset (data
, 0, sizeof(data
));
5114 pid
= va_arg (ap
, long);
5115 bfd_put_32 (abfd
, pid
, data
+ PRSTATUS_OFFSET_PR_PID
);
5116 cursig
= va_arg (ap
, int);
5117 bfd_put_16 (abfd
, cursig
, data
+ PRSTATUS_OFFSET_PR_CURSIG
);
5118 greg
= va_arg (ap
, const void *);
5119 memcpy (data
+ PRSTATUS_OFFSET_PR_REG
, greg
,
5120 PRSTATUS_SIZE
- PRSTATUS_OFFSET_PR_REG
- ARCH_SIZE
/ 8);
5122 return elfcore_write_note (abfd
, buf
, bufsiz
,
5123 "CORE", note_type
, data
, sizeof (data
));
5125 #endif /* !HAVE_PRSTATUS_T */
5129 /* Support for core dump NOTE sections. */
5132 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
5134 switch (note
->descsz
)
5139 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
5141 elf_tdata (abfd
)->core
->signal
5142 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
5145 elf_tdata (abfd
)->core
->lwpid
5146 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
5150 /* Make a ".reg/999" section. */
5151 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
5152 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
5156 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
5158 switch (note
->descsz
)
5163 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
5165 elf_tdata (abfd
)->core
->pid
5166 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
5169 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
5170 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
,
5171 PRPSINFO_PR_FNAME_LENGTH
);
5174 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
5175 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
,
5176 PRPSINFO_PR_PSARGS_LENGTH
);
5180 /* Note that for some reason, a spurious space is tacked
5181 onto the end of the args in some (at least one anyway)
5182 implementations, so strip it off if it exists. */
5185 char *command
= elf_tdata (abfd
)->core
->command
;
5186 int n
= strlen (command
);
5188 if (0 < n
&& command
[n
- 1] == ' ')
5189 command
[n
- 1] = '\0';
5195 /* Set the right mach type. */
5198 riscv_elf_object_p (bfd
*abfd
)
5200 /* There are only two mach types in RISCV currently. */
5201 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0
5202 || strcmp (abfd
->xvec
->name
, "elf32-bigriscv") == 0)
5203 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
5205 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
5210 /* Determine whether an object attribute tag takes an integer, a
5214 riscv_elf_obj_attrs_arg_type (int tag
)
5216 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
5219 /* Do not choose mapping symbols as a function name. */
5221 static bfd_size_type
5222 riscv_maybe_function_sym (const asymbol
*sym
,
5226 if (sym
->flags
& BSF_LOCAL
5227 && riscv_elf_is_mapping_symbols (sym
->name
))
5230 return _bfd_elf_maybe_function_sym (sym
, sec
, code_off
);
5233 /* Treat the following cases as target special symbols, they are
5237 riscv_elf_is_target_special_symbol (bfd
*abfd
, asymbol
*sym
)
5239 /* PR27584, local and empty symbols. Since they are usually
5240 generated for pcrel relocations. */
5241 return (!strcmp (sym
->name
, "")
5242 || _bfd_elf_is_local_label_name (abfd
, sym
->name
)
5243 /* PR27916, mapping symbols. */
5244 || riscv_elf_is_mapping_symbols (sym
->name
));
5248 riscv_elf_additional_program_headers (bfd
*abfd
,
5249 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5253 /* See if we need a PT_RISCV_ATTRIBUTES segment. */
5254 if (bfd_get_section_by_name (abfd
, RISCV_ATTRIBUTES_SECTION_NAME
))
5261 riscv_elf_modify_segment_map (bfd
*abfd
,
5262 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5265 struct elf_segment_map
*m
, **pm
;
5268 /* If there is a .riscv.attributes section, we need a PT_RISCV_ATTRIBUTES
5270 s
= bfd_get_section_by_name (abfd
, RISCV_ATTRIBUTES_SECTION_NAME
);
5273 for (m
= elf_seg_map (abfd
); m
!= NULL
; m
= m
->next
)
5274 if (m
->p_type
== PT_RISCV_ATTRIBUTES
)
5276 /* If there is already a PT_RISCV_ATTRIBUTES header, avoid adding
5281 m
= bfd_zalloc (abfd
, amt
);
5285 m
->p_type
= PT_RISCV_ATTRIBUTES
;
5289 /* We want to put it after the PHDR and INTERP segments. */
5290 pm
= &elf_seg_map (abfd
);
5292 && ((*pm
)->p_type
== PT_PHDR
5293 || (*pm
)->p_type
== PT_INTERP
))
5304 /* Merge non-visibility st_other attributes. */
5307 riscv_elf_merge_symbol_attribute (struct elf_link_hash_entry
*h
,
5308 unsigned int st_other
,
5309 bool definition ATTRIBUTE_UNUSED
,
5310 bool dynamic ATTRIBUTE_UNUSED
)
5312 unsigned int isym_sto
= st_other
& ~ELF_ST_VISIBILITY (-1);
5313 unsigned int h_sto
= h
->other
& ~ELF_ST_VISIBILITY (-1);
5315 if (isym_sto
== h_sto
)
5318 if (isym_sto
& ~STO_RISCV_VARIANT_CC
)
5319 _bfd_error_handler (_("unknown attribute for symbol `%s': 0x%02x"),
5320 h
->root
.root
.string
, isym_sto
);
5322 if (isym_sto
& STO_RISCV_VARIANT_CC
)
5323 h
->other
|= STO_RISCV_VARIANT_CC
;
5326 #define TARGET_LITTLE_SYM riscv_elfNN_vec
5327 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
5328 #define TARGET_BIG_SYM riscv_elfNN_be_vec
5329 #define TARGET_BIG_NAME "elfNN-bigriscv"
5331 #define elf_backend_reloc_type_class riscv_reloc_type_class
5333 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
5334 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
5335 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
5336 #define bfd_elfNN_bfd_merge_private_bfd_data \
5337 _bfd_riscv_elf_merge_private_bfd_data
5338 #define bfd_elfNN_bfd_is_target_special_symbol riscv_elf_is_target_special_symbol
5340 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
5341 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
5342 #define elf_backend_check_relocs riscv_elf_check_relocs
5343 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
5344 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
5345 #define elf_backend_relocate_section riscv_elf_relocate_section
5346 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
5347 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
5348 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
5349 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
5350 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
5351 #define elf_backend_object_p riscv_elf_object_p
5352 #define elf_backend_write_core_note riscv_write_core_note
5353 #define elf_backend_maybe_function_sym riscv_maybe_function_sym
5354 #define elf_info_to_howto_rel NULL
5355 #define elf_info_to_howto riscv_info_to_howto_rela
5356 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
5357 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
5358 #define elf_backend_additional_program_headers \
5359 riscv_elf_additional_program_headers
5360 #define elf_backend_modify_segment_map riscv_elf_modify_segment_map
5361 #define elf_backend_merge_symbol_attribute riscv_elf_merge_symbol_attribute
5363 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5365 #define elf_backend_can_gc_sections 1
5366 #define elf_backend_can_refcount 1
5367 #define elf_backend_want_got_plt 1
5368 #define elf_backend_plt_readonly 1
5369 #define elf_backend_plt_alignment 4
5370 #define elf_backend_want_plt_sym 1
5371 #define elf_backend_got_header_size (ARCH_SIZE / 8)
5372 #define elf_backend_want_dynrelro 1
5373 #define elf_backend_rela_normal 1
5374 #define elf_backend_default_execstack 0
5376 #undef elf_backend_obj_attrs_vendor
5377 #define elf_backend_obj_attrs_vendor "riscv"
5378 #undef elf_backend_obj_attrs_arg_type
5379 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
5380 #undef elf_backend_obj_attrs_section_type
5381 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
5382 #undef elf_backend_obj_attrs_section
5383 #define elf_backend_obj_attrs_section RISCV_ATTRIBUTES_SECTION_NAME
5385 #include "elfNN-target.h"