1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2021 Free Software Foundation, Inc.
4 Contributed by Andrew Waterman (andrew@sifive.com).
5 Based on TILE-Gx and MIPS targets.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not,
21 see <http://www.gnu.org/licenses/>. */
23 /* This file handles RISC-V ELF targets. */
31 #include "elfxx-riscv.h"
32 #include "elf/riscv.h"
33 #include "opcode/riscv.h"
35 #include "cpu-riscv.h"
42 /* Internal relocations used exclusively by the relaxation pass. */
43 #define R_RISCV_DELETE (R_RISCV_max + 1)
47 #define MINUS_ONE ((bfd_vma)0 - 1)
49 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
51 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
53 /* The name of the dynamic interpreter. This is put in the .interp
56 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
57 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
59 #define ELF_ARCH bfd_arch_riscv
60 #define ELF_TARGET_ID RISCV_ELF_DATA
61 #define ELF_MACHINE_CODE EM_RISCV
62 #define ELF_MAXPAGESIZE 0x1000
63 #define ELF_COMMONPAGESIZE 0x1000
65 /* RISC-V ELF linker hash entry. */
67 struct riscv_elf_link_hash_entry
69 struct elf_link_hash_entry elf
;
79 #define riscv_elf_hash_entry(ent) \
80 ((struct riscv_elf_link_hash_entry *) (ent))
82 struct _bfd_riscv_elf_obj_tdata
84 struct elf_obj_tdata root
;
86 /* tls_type for each local got entry. */
87 char *local_got_tls_type
;
90 #define _bfd_riscv_elf_tdata(abfd) \
91 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
93 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
94 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
96 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
97 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
98 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
100 #define is_riscv_elf(bfd) \
101 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
102 && elf_tdata (bfd) != NULL \
103 && elf_object_id (bfd) == RISCV_ELF_DATA)
106 elfNN_riscv_mkobject (bfd
*abfd
)
108 return bfd_elf_allocate_object (abfd
,
109 sizeof (struct _bfd_riscv_elf_obj_tdata
),
113 #include "elf/common.h"
114 #include "elf/internal.h"
116 struct riscv_elf_link_hash_table
118 struct elf_link_hash_table elf
;
120 /* Short-cuts to get to dynamic linker sections. */
123 /* The max alignment of output sections. */
124 bfd_vma max_alignment
;
126 /* Used by local STT_GNU_IFUNC symbols. */
127 htab_t loc_hash_table
;
128 void * loc_hash_memory
;
130 /* The index of the last unused .rel.iplt slot. */
131 bfd_vma last_iplt_index
;
133 /* Re-run the relaxations from relax pass 0 if TRUE. */
137 /* Instruction access functions. */
138 #define riscv_get_insn(bits, ptr) \
139 ((bits) == 16 ? bfd_getl16 (ptr) \
140 : (bits) == 32 ? bfd_getl32 (ptr) \
141 : (bits) == 64 ? bfd_getl64 (ptr) \
142 : (abort (), (bfd_vma) - 1))
143 #define riscv_put_insn(bits, val, ptr) \
144 ((bits) == 16 ? bfd_putl16 (val, ptr) \
145 : (bits) == 32 ? bfd_putl32 (val, ptr) \
146 : (bits) == 64 ? bfd_putl64 (val, ptr) \
147 : (abort (), (void) 0))
149 /* Get the RISC-V ELF linker hash table from a link_info structure. */
150 #define riscv_elf_hash_table(p) \
151 ((is_elf_hash_table ((p)->hash) \
152 && elf_hash_table_id (elf_hash_table (p)) == RISCV_ELF_DATA) \
153 ? (struct riscv_elf_link_hash_table *) (p)->hash : NULL)
156 riscv_info_to_howto_rela (bfd
*abfd
,
158 Elf_Internal_Rela
*dst
)
160 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
161 return cache_ptr
->howto
!= NULL
;
165 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
167 const struct elf_backend_data
*bed
;
170 bed
= get_elf_backend_data (abfd
);
171 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
172 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
175 /* Return true if a relocation is modifying an instruction. */
178 riscv_is_insn_reloc (const reloc_howto_type
*howto
)
180 /* Heuristic: A multibyte destination with a nontrivial mask
182 return (howto
->bitsize
> 8
183 && howto
->dst_mask
!= 0
184 && ~(howto
->dst_mask
| (howto
->bitsize
< sizeof(bfd_vma
) * CHAR_BIT
185 ? (MINUS_ONE
<< howto
->bitsize
) : (bfd_vma
)0)) != 0);
189 #define PLT_HEADER_INSNS 8
190 #define PLT_ENTRY_INSNS 4
191 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
192 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
193 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
194 /* Reserve two entries of GOTPLT for ld.so, one is used for PLT resolver,
195 the other is used for link map. Other targets also reserve one more
196 entry used for runtime profile? */
197 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
199 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
202 # define MATCH_LREG MATCH_LW
204 # define MATCH_LREG MATCH_LD
207 /* Generate a PLT header. */
210 riscv_make_plt_header (bfd
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
213 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
214 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
216 /* RVE has no t3 register, so this won't work, and is not supported. */
217 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
219 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
224 /* auipc t2, %hi(.got.plt)
225 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
226 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
227 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
228 addi t0, t2, %lo(.got.plt) # &.got.plt
229 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
230 l[w|d] t0, PTRSIZE(t0) # link map
233 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
234 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
235 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
236 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, (uint32_t) -(PLT_HEADER_SIZE
+ 12));
237 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
238 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
239 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
240 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
245 /* Generate a PLT entry. */
248 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
251 /* RVE has no t3 register, so this won't work, and is not supported. */
252 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
254 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
259 /* auipc t3, %hi(.got.plt entry)
260 l[w|d] t3, %lo(.got.plt entry)(t3)
264 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
265 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
266 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
267 entry
[3] = RISCV_NOP
;
272 /* Create an entry in an RISC-V ELF linker hash table. */
274 static struct bfd_hash_entry
*
275 link_hash_newfunc (struct bfd_hash_entry
*entry
,
276 struct bfd_hash_table
*table
, const char *string
)
278 /* Allocate the structure if it has not already been allocated by a
283 bfd_hash_allocate (table
,
284 sizeof (struct riscv_elf_link_hash_entry
));
289 /* Call the allocation method of the superclass. */
290 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
293 struct riscv_elf_link_hash_entry
*eh
;
295 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
296 eh
->tls_type
= GOT_UNKNOWN
;
302 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
303 for local symbol so that we can handle local STT_GNU_IFUNC symbols
304 as global symbol. We reuse indx and dynstr_index for local symbol
305 hash since they aren't used by global symbols in this backend. */
308 riscv_elf_local_htab_hash (const void *ptr
)
310 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) ptr
;
311 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
314 /* Compare local hash entries. */
317 riscv_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
319 struct elf_link_hash_entry
*h1
= (struct elf_link_hash_entry
*) ptr1
;
320 struct elf_link_hash_entry
*h2
= (struct elf_link_hash_entry
*) ptr2
;
322 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
325 /* Find and/or create a hash entry for local symbol. */
327 static struct elf_link_hash_entry
*
328 riscv_elf_get_local_sym_hash (struct riscv_elf_link_hash_table
*htab
,
329 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
332 struct riscv_elf_link_hash_entry eh
, *ret
;
333 asection
*sec
= abfd
->sections
;
334 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
335 ELFNN_R_SYM (rel
->r_info
));
338 eh
.elf
.indx
= sec
->id
;
339 eh
.elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
340 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &eh
, h
,
341 create
? INSERT
: NO_INSERT
);
348 ret
= (struct riscv_elf_link_hash_entry
*) *slot
;
352 ret
= (struct riscv_elf_link_hash_entry
*)
353 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
354 sizeof (struct riscv_elf_link_hash_entry
));
357 memset (ret
, 0, sizeof (*ret
));
358 ret
->elf
.indx
= sec
->id
;
359 ret
->elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
360 ret
->elf
.dynindx
= -1;
366 /* Destroy a RISC-V elf linker hash table. */
369 riscv_elf_link_hash_table_free (bfd
*obfd
)
371 struct riscv_elf_link_hash_table
*ret
372 = (struct riscv_elf_link_hash_table
*) obfd
->link
.hash
;
374 if (ret
->loc_hash_table
)
375 htab_delete (ret
->loc_hash_table
);
376 if (ret
->loc_hash_memory
)
377 objalloc_free ((struct objalloc
*) ret
->loc_hash_memory
);
379 _bfd_elf_link_hash_table_free (obfd
);
382 /* Create a RISC-V ELF linker hash table. */
384 static struct bfd_link_hash_table
*
385 riscv_elf_link_hash_table_create (bfd
*abfd
)
387 struct riscv_elf_link_hash_table
*ret
;
388 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
390 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
394 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
395 sizeof (struct riscv_elf_link_hash_entry
),
402 ret
->max_alignment
= (bfd_vma
) -1;
403 ret
->restart_relax
= false;
405 /* Create hash table for local ifunc. */
406 ret
->loc_hash_table
= htab_try_create (1024,
407 riscv_elf_local_htab_hash
,
408 riscv_elf_local_htab_eq
,
410 ret
->loc_hash_memory
= objalloc_create ();
411 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
413 riscv_elf_link_hash_table_free (abfd
);
416 ret
->elf
.root
.hash_table_free
= riscv_elf_link_hash_table_free
;
418 return &ret
->elf
.root
;
421 /* Create the .got section. */
424 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
428 struct elf_link_hash_entry
*h
;
429 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
430 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
432 /* This function may be called more than once. */
433 if (htab
->sgot
!= NULL
)
436 flags
= bed
->dynamic_sec_flags
;
438 s
= bfd_make_section_anyway_with_flags (abfd
,
439 (bed
->rela_plts_and_copies_p
440 ? ".rela.got" : ".rel.got"),
441 (bed
->dynamic_sec_flags
444 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
448 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
450 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
454 /* The first bit of the global offset table is the header. */
455 s
->size
+= bed
->got_header_size
;
457 if (bed
->want_got_plt
)
459 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
461 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
465 /* Reserve room for the header. */
466 s
->size
+= GOTPLT_HEADER_SIZE
;
469 if (bed
->want_got_sym
)
471 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
472 section. We don't do this in the linker script because we don't want
473 to define the symbol if we are not creating a global offset
475 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
476 "_GLOBAL_OFFSET_TABLE_");
477 elf_hash_table (info
)->hgot
= h
;
485 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
486 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
490 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
491 struct bfd_link_info
*info
)
493 struct riscv_elf_link_hash_table
*htab
;
495 htab
= riscv_elf_hash_table (info
);
496 BFD_ASSERT (htab
!= NULL
);
498 if (!riscv_elf_create_got_section (dynobj
, info
))
501 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
504 if (!bfd_link_pic (info
))
506 /* Technically, this section doesn't have contents. It is used as the
507 target of TLS copy relocs, to copy TLS data from shared libraries into
508 the executable. However, if we don't mark it as loadable, then it
509 matches the IS_TBSS test in ldlang.c, and there is no run-time address
510 space allocated for it even though it has SEC_ALLOC. That test is
511 correct for .tbss, but not correct for this section. There is also
512 a second problem that having a section with no contents can only work
513 if it comes after all sections with contents in the same segment,
514 but the linker script does not guarantee that. This is just mixed in
515 with other .tdata.* sections. We can fix both problems by lying and
516 saying that there are contents. This section is expected to be small
517 so this should not cause a significant extra program startup cost. */
519 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
520 (SEC_ALLOC
| SEC_THREAD_LOCAL
521 | SEC_LOAD
| SEC_DATA
523 | SEC_LINKER_CREATED
));
526 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
527 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
533 /* Copy the extra info we tack onto an elf_link_hash_entry. */
536 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
537 struct elf_link_hash_entry
*dir
,
538 struct elf_link_hash_entry
*ind
)
540 struct riscv_elf_link_hash_entry
*edir
, *eind
;
542 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
543 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
545 if (ind
->root
.type
== bfd_link_hash_indirect
546 && dir
->got
.refcount
<= 0)
548 edir
->tls_type
= eind
->tls_type
;
549 eind
->tls_type
= GOT_UNKNOWN
;
551 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
555 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
556 unsigned long symndx
, char tls_type
)
558 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
560 *new_tls_type
|= tls_type
;
561 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
563 (*_bfd_error_handler
)
564 (_("%pB: `%s' accessed both as normal and thread local symbol"),
565 abfd
, h
? h
->root
.root
.string
: "<local>");
572 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
573 struct elf_link_hash_entry
*h
, long symndx
)
575 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
576 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
578 if (htab
->elf
.sgot
== NULL
)
580 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
586 h
->got
.refcount
+= 1;
590 /* This is a global offset table entry for a local symbol. */
591 if (elf_local_got_refcounts (abfd
) == NULL
)
593 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
594 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
596 _bfd_riscv_elf_local_got_tls_type (abfd
)
597 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
599 elf_local_got_refcounts (abfd
) [symndx
] += 1;
605 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
607 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
609 /* We propably can improve the information to tell users that they
610 should be recompile the code with -fPIC or -fPIE, just like what
612 (*_bfd_error_handler
)
613 (_("%pB: relocation %s against `%s' can not be used when making a shared "
614 "object; recompile with -fPIC"),
615 abfd
, r
? r
->name
: _("<unknown>"),
616 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
617 bfd_set_error (bfd_error_bad_value
);
621 /* Look through the relocs for a section during the first phase, and
622 allocate space in the global offset table or procedure linkage
626 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
627 asection
*sec
, const Elf_Internal_Rela
*relocs
)
629 struct riscv_elf_link_hash_table
*htab
;
630 Elf_Internal_Shdr
*symtab_hdr
;
631 struct elf_link_hash_entry
**sym_hashes
;
632 const Elf_Internal_Rela
*rel
;
633 asection
*sreloc
= NULL
;
635 if (bfd_link_relocatable (info
))
638 htab
= riscv_elf_hash_table (info
);
639 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
640 sym_hashes
= elf_sym_hashes (abfd
);
642 if (htab
->elf
.dynobj
== NULL
)
643 htab
->elf
.dynobj
= abfd
;
645 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
648 unsigned int r_symndx
;
649 struct elf_link_hash_entry
*h
;
651 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
652 r_type
= ELFNN_R_TYPE (rel
->r_info
);
654 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
656 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
661 if (r_symndx
< symtab_hdr
->sh_info
)
663 /* A local symbol. */
664 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
669 /* Check relocation against local STT_GNU_IFUNC symbol. */
670 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
672 h
= riscv_elf_get_local_sym_hash (htab
, abfd
, rel
, true);
676 /* Fake STT_GNU_IFUNC global symbol. */
677 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
679 h
->type
= STT_GNU_IFUNC
;
683 h
->root
.type
= bfd_link_hash_defined
;
690 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
691 while (h
->root
.type
== bfd_link_hash_indirect
692 || h
->root
.type
== bfd_link_hash_warning
)
693 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
703 case R_RISCV_CALL_PLT
:
705 case R_RISCV_GOT_HI20
:
706 case R_RISCV_PCREL_HI20
:
707 /* Create the ifunc sections, iplt and ipltgot, for static
709 if (h
->type
== STT_GNU_IFUNC
710 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
718 /* It is referenced by a non-shared object. */
724 case R_RISCV_TLS_GD_HI20
:
725 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
726 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
730 case R_RISCV_TLS_GOT_HI20
:
731 if (bfd_link_pic (info
))
732 info
->flags
|= DF_STATIC_TLS
;
733 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
734 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
738 case R_RISCV_GOT_HI20
:
739 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
740 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
745 case R_RISCV_CALL_PLT
:
746 /* These symbol requires a procedure linkage table entry.
747 We actually build the entry in adjust_dynamic_symbol,
748 because these might be a case of linking PIC code without
749 linking in any dynamic objects, in which case we don't
750 need to generate a procedure linkage table after all. */
752 /* If it is a local symbol, then we resolve it directly
753 without creating a PLT entry. */
758 h
->plt
.refcount
+= 1;
761 case R_RISCV_PCREL_HI20
:
763 && h
->type
== STT_GNU_IFUNC
)
766 h
->pointer_equality_needed
= 1;
768 /* We don't use the PCREL_HI20 in the data section,
769 so we always need the plt when it refers to
771 h
->plt
.refcount
+= 1;
777 case R_RISCV_RVC_BRANCH
:
778 case R_RISCV_RVC_JUMP
:
779 /* In shared libraries and pie, these relocs are known
781 if (bfd_link_pic (info
))
785 case R_RISCV_TPREL_HI20
:
786 if (!bfd_link_executable (info
))
787 return bad_static_reloc (abfd
, r_type
, h
);
789 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
793 if (bfd_link_pic (info
))
794 return bad_static_reloc (abfd
, r_type
, h
);
798 case R_RISCV_JUMP_SLOT
:
799 case R_RISCV_RELATIVE
:
807 && (!bfd_link_pic (info
)
808 || h
->type
== STT_GNU_IFUNC
))
810 /* This reloc might not bind locally. */
812 h
->pointer_equality_needed
= 1;
815 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
817 /* We may need a .plt entry if the symbol is a function
818 defined in a shared lib or is a function referenced
819 from the code or read-only section. */
820 h
->plt
.refcount
+= 1;
824 /* If we are creating a shared library, and this is a reloc
825 against a global symbol, or a non PC relative reloc
826 against a local symbol, then we need to copy the reloc
827 into the shared library. However, if we are linking with
828 -Bsymbolic, we do not need to copy a reloc against a
829 global symbol which is defined in an object we are
830 including in the link (i.e., DEF_REGULAR is set). At
831 this point we have not seen all the input files, so it is
832 possible that DEF_REGULAR is not set now but will be set
833 later (it is never cleared). In case of a weak definition,
834 DEF_REGULAR may be cleared later by a strong definition in
835 a shared library. We account for that possibility below by
836 storing information in the relocs_copied field of the hash
837 table entry. A similar situation occurs when creating
838 shared libraries and symbol visibility changes render the
841 If on the other hand, we are creating an executable, we
842 may need to keep relocations for symbols satisfied by a
843 dynamic library if we manage to avoid copy relocs for the
846 Generate dynamic pointer relocation against STT_GNU_IFUNC
847 symbol in the non-code section (R_RISCV_32/R_RISCV_64). */
848 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
850 if ((bfd_link_pic (info
)
851 && (sec
->flags
& SEC_ALLOC
) != 0
852 && ((r
!= NULL
&& !r
->pc_relative
)
855 || h
->root
.type
== bfd_link_hash_defweak
856 || !h
->def_regular
))))
857 || (!bfd_link_pic (info
)
858 && (sec
->flags
& SEC_ALLOC
) != 0
860 && (h
->root
.type
== bfd_link_hash_defweak
862 || (!bfd_link_pic (info
)
864 && h
->type
== STT_GNU_IFUNC
865 && (sec
->flags
& SEC_CODE
) == 0))
867 struct elf_dyn_relocs
*p
;
868 struct elf_dyn_relocs
**head
;
870 /* When creating a shared object, we must copy these
871 relocs into the output file. We create a reloc
872 section in dynobj and make room for the reloc. */
875 sreloc
= _bfd_elf_make_dynamic_reloc_section
876 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
877 abfd
, /*rela?*/ true);
883 /* If this is a global symbol, we count the number of
884 relocations we need for this symbol. */
886 head
= &h
->dyn_relocs
;
889 /* Track dynamic relocs needed for local syms too.
890 We really need local syms available to do this
895 Elf_Internal_Sym
*isym
;
897 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
902 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
906 vpp
= &elf_section_data (s
)->local_dynrel
;
907 head
= (struct elf_dyn_relocs
**) vpp
;
911 if (p
== NULL
|| p
->sec
!= sec
)
913 size_t amt
= sizeof *p
;
914 p
= ((struct elf_dyn_relocs
*)
915 bfd_alloc (htab
->elf
.dynobj
, amt
));
926 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
931 case R_RISCV_GNU_VTINHERIT
:
932 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
936 case R_RISCV_GNU_VTENTRY
:
937 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
950 riscv_elf_gc_mark_hook (asection
*sec
,
951 struct bfd_link_info
*info
,
952 Elf_Internal_Rela
*rel
,
953 struct elf_link_hash_entry
*h
,
954 Elf_Internal_Sym
*sym
)
957 switch (ELFNN_R_TYPE (rel
->r_info
))
959 case R_RISCV_GNU_VTINHERIT
:
960 case R_RISCV_GNU_VTENTRY
:
964 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
967 /* Adjust a symbol defined by a dynamic object and referenced by a
968 regular object. The current definition is in some section of the
969 dynamic object, but we're not including those sections. We have to
970 change the definition to something the rest of the link can
974 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
975 struct elf_link_hash_entry
*h
)
977 struct riscv_elf_link_hash_table
*htab
;
978 struct riscv_elf_link_hash_entry
* eh
;
982 htab
= riscv_elf_hash_table (info
);
983 BFD_ASSERT (htab
!= NULL
);
985 dynobj
= htab
->elf
.dynobj
;
987 /* Make sure we know what is going on here. */
988 BFD_ASSERT (dynobj
!= NULL
990 || h
->type
== STT_GNU_IFUNC
994 && !h
->def_regular
)));
996 /* If this is a function, put it in the procedure linkage table. We
997 will fill in the contents of the procedure linkage table later
998 (although we could actually do it here). */
999 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
1001 if (h
->plt
.refcount
<= 0
1002 || (h
->type
!= STT_GNU_IFUNC
1003 && (SYMBOL_CALLS_LOCAL (info
, h
)
1004 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1005 && h
->root
.type
== bfd_link_hash_undefweak
))))
1007 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
1008 input file, but the symbol was never referred to by a dynamic
1009 object, or if all references were garbage collected. In such
1010 a case, we don't actually need to build a PLT entry. */
1011 h
->plt
.offset
= (bfd_vma
) -1;
1018 h
->plt
.offset
= (bfd_vma
) -1;
1020 /* If this is a weak symbol, and there is a real definition, the
1021 processor independent code will have arranged for us to see the
1022 real definition first, and we can just use the same value. */
1023 if (h
->is_weakalias
)
1025 struct elf_link_hash_entry
*def
= weakdef (h
);
1026 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1027 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1028 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1032 /* This is a reference to a symbol defined by a dynamic object which
1033 is not a function. */
1035 /* If we are creating a shared library, we must presume that the
1036 only references to the symbol are via the global offset table.
1037 For such cases we need not do anything here; the relocations will
1038 be handled correctly by relocate_section. */
1039 if (bfd_link_pic (info
))
1042 /* If there are no references to this symbol that do not use the
1043 GOT, we don't need to generate a copy reloc. */
1044 if (!h
->non_got_ref
)
1047 /* If -z nocopyreloc was given, we won't generate them either. */
1048 if (info
->nocopyreloc
)
1054 /* If we don't find any dynamic relocs in read-only sections, then
1055 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1056 if (!_bfd_elf_readonly_dynrelocs (h
))
1062 /* We must allocate the symbol in our .dynbss section, which will
1063 become part of the .bss section of the executable. There will be
1064 an entry for this symbol in the .dynsym section. The dynamic
1065 object will contain position independent code, so all references
1066 from the dynamic object to this symbol will go through the global
1067 offset table. The dynamic linker will use the .dynsym entry to
1068 determine the address it must put in the global offset table, so
1069 both the dynamic object and the regular object will refer to the
1070 same memory location for the variable. */
1072 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
1073 to copy the initial value out of the dynamic object and into the
1074 runtime process image. We need to remember the offset into the
1075 .rel.bss section we are going to use. */
1076 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1077 if (eh
->tls_type
& ~GOT_NORMAL
)
1079 s
= htab
->sdyntdata
;
1080 srel
= htab
->elf
.srelbss
;
1082 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1084 s
= htab
->elf
.sdynrelro
;
1085 srel
= htab
->elf
.sreldynrelro
;
1089 s
= htab
->elf
.sdynbss
;
1090 srel
= htab
->elf
.srelbss
;
1092 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1094 srel
->size
+= sizeof (ElfNN_External_Rela
);
1098 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1101 /* Allocate space in .plt, .got and associated reloc sections for
1105 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1107 struct bfd_link_info
*info
;
1108 struct riscv_elf_link_hash_table
*htab
;
1109 struct elf_dyn_relocs
*p
;
1111 if (h
->root
.type
== bfd_link_hash_indirect
)
1114 info
= (struct bfd_link_info
*) inf
;
1115 htab
= riscv_elf_hash_table (info
);
1116 BFD_ASSERT (htab
!= NULL
);
1118 /* When we are generating pde, make sure gp symbol is output as a
1119 dynamic symbol. Then ld.so can set the gp register earlier, before
1120 resolving the ifunc. */
1121 if (!bfd_link_pic (info
)
1122 && htab
->elf
.dynamic_sections_created
1123 && strcmp (h
->root
.root
.string
, RISCV_GP_SYMBOL
) == 0
1124 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1127 /* Since STT_GNU_IFUNC symbols must go through PLT, we handle them
1128 in the allocate_ifunc_dynrelocs and allocate_local_ifunc_dynrelocs,
1129 if they are defined and referenced in a non-shared object. */
1130 if (h
->type
== STT_GNU_IFUNC
1133 else if (htab
->elf
.dynamic_sections_created
1134 && h
->plt
.refcount
> 0)
1136 /* Make sure this symbol is output as a dynamic symbol.
1137 Undefined weak syms won't yet be marked as dynamic. */
1138 if (h
->dynindx
== -1
1139 && !h
->forced_local
)
1141 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1145 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1147 asection
*s
= htab
->elf
.splt
;
1150 s
->size
= PLT_HEADER_SIZE
;
1152 h
->plt
.offset
= s
->size
;
1154 /* Make room for this entry. */
1155 s
->size
+= PLT_ENTRY_SIZE
;
1157 /* We also need to make an entry in the .got.plt section. */
1158 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
1160 /* We also need to make an entry in the .rela.plt section. */
1161 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
1163 /* If this symbol is not defined in a regular file, and we are
1164 not generating a shared library, then set the symbol to this
1165 location in the .plt. This is required to make function
1166 pointers compare as equal between the normal executable and
1167 the shared library. */
1168 if (! bfd_link_pic (info
)
1171 h
->root
.u
.def
.section
= s
;
1172 h
->root
.u
.def
.value
= h
->plt
.offset
;
1177 h
->plt
.offset
= (bfd_vma
) -1;
1183 h
->plt
.offset
= (bfd_vma
) -1;
1187 if (h
->got
.refcount
> 0)
1191 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
1193 /* Make sure this symbol is output as a dynamic symbol.
1194 Undefined weak syms won't yet be marked as dynamic. */
1195 if (h
->dynindx
== -1
1196 && !h
->forced_local
)
1198 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1203 h
->got
.offset
= s
->size
;
1204 dyn
= htab
->elf
.dynamic_sections_created
;
1205 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
1207 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1208 if (tls_type
& GOT_TLS_GD
)
1210 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
1211 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1214 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1215 if (tls_type
& GOT_TLS_IE
)
1217 s
->size
+= RISCV_ELF_WORD_BYTES
;
1218 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1223 s
->size
+= RISCV_ELF_WORD_BYTES
;
1224 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1225 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1226 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1230 h
->got
.offset
= (bfd_vma
) -1;
1232 if (h
->dyn_relocs
== NULL
)
1235 /* In the shared -Bsymbolic case, discard space allocated for
1236 dynamic pc-relative relocs against symbols which turn out to be
1237 defined in regular objects. For the normal shared case, discard
1238 space for pc-relative relocs that have become local due to symbol
1239 visibility changes. */
1241 if (bfd_link_pic (info
))
1243 if (SYMBOL_CALLS_LOCAL (info
, h
))
1245 struct elf_dyn_relocs
**pp
;
1247 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1249 p
->count
-= p
->pc_count
;
1258 /* Also discard relocs on undefined weak syms with non-default
1260 if (h
->dyn_relocs
!= NULL
1261 && h
->root
.type
== bfd_link_hash_undefweak
)
1263 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1264 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1265 h
->dyn_relocs
= NULL
;
1267 /* Make sure undefined weak symbols are output as a dynamic
1269 else if (h
->dynindx
== -1
1270 && !h
->forced_local
)
1272 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1279 /* For the non-shared case, discard space for relocs against
1280 symbols which turn out to need copy relocs or are not
1286 || (htab
->elf
.dynamic_sections_created
1287 && (h
->root
.type
== bfd_link_hash_undefweak
1288 || h
->root
.type
== bfd_link_hash_undefined
))))
1290 /* Make sure this symbol is output as a dynamic symbol.
1291 Undefined weak syms won't yet be marked as dynamic. */
1292 if (h
->dynindx
== -1
1293 && !h
->forced_local
)
1295 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1299 /* If that succeeded, we know we'll be keeping all the
1301 if (h
->dynindx
!= -1)
1305 h
->dyn_relocs
= NULL
;
1310 /* Finally, allocate space. */
1311 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1313 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1314 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1320 /* Allocate space in .plt, .got and associated reloc sections for
1321 ifunc dynamic relocs. */
1324 allocate_ifunc_dynrelocs (struct elf_link_hash_entry
*h
,
1327 struct bfd_link_info
*info
;
1329 if (h
->root
.type
== bfd_link_hash_indirect
)
1332 if (h
->root
.type
== bfd_link_hash_warning
)
1333 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1335 info
= (struct bfd_link_info
*) inf
;
1337 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1338 here if it is defined and referenced in a non-shared object. */
1339 if (h
->type
== STT_GNU_IFUNC
1341 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
1350 /* Allocate space in .plt, .got and associated reloc sections for
1351 local ifunc dynamic relocs. */
1354 allocate_local_ifunc_dynrelocs (void **slot
, void *inf
)
1356 struct elf_link_hash_entry
*h
1357 = (struct elf_link_hash_entry
*) *slot
;
1359 if (h
->type
!= STT_GNU_IFUNC
1363 || h
->root
.type
!= bfd_link_hash_defined
)
1366 return allocate_ifunc_dynrelocs (h
, inf
);
1370 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1372 struct riscv_elf_link_hash_table
*htab
;
1377 htab
= riscv_elf_hash_table (info
);
1378 BFD_ASSERT (htab
!= NULL
);
1379 dynobj
= htab
->elf
.dynobj
;
1380 BFD_ASSERT (dynobj
!= NULL
);
1382 if (elf_hash_table (info
)->dynamic_sections_created
)
1384 /* Set the contents of the .interp section to the interpreter. */
1385 if (bfd_link_executable (info
) && !info
->nointerp
)
1387 s
= bfd_get_linker_section (dynobj
, ".interp");
1388 BFD_ASSERT (s
!= NULL
);
1389 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1390 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1394 /* Set up .got offsets for local syms, and space for local dynamic
1396 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1398 bfd_signed_vma
*local_got
;
1399 bfd_signed_vma
*end_local_got
;
1400 char *local_tls_type
;
1401 bfd_size_type locsymcount
;
1402 Elf_Internal_Shdr
*symtab_hdr
;
1405 if (! is_riscv_elf (ibfd
))
1408 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1410 struct elf_dyn_relocs
*p
;
1412 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1414 if (!bfd_is_abs_section (p
->sec
)
1415 && bfd_is_abs_section (p
->sec
->output_section
))
1417 /* Input section has been discarded, either because
1418 it is a copy of a linkonce section or due to
1419 linker script /DISCARD/, so we'll be discarding
1422 else if (p
->count
!= 0)
1424 srel
= elf_section_data (p
->sec
)->sreloc
;
1425 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1426 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1427 info
->flags
|= DF_TEXTREL
;
1432 local_got
= elf_local_got_refcounts (ibfd
);
1436 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1437 locsymcount
= symtab_hdr
->sh_info
;
1438 end_local_got
= local_got
+ locsymcount
;
1439 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1441 srel
= htab
->elf
.srelgot
;
1442 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1446 *local_got
= s
->size
;
1447 s
->size
+= RISCV_ELF_WORD_BYTES
;
1448 if (*local_tls_type
& GOT_TLS_GD
)
1449 s
->size
+= RISCV_ELF_WORD_BYTES
;
1450 if (bfd_link_pic (info
)
1451 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1452 srel
->size
+= sizeof (ElfNN_External_Rela
);
1455 *local_got
= (bfd_vma
) -1;
1459 /* Allocate .plt and .got entries and space dynamic relocs for
1461 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1463 /* Allocate .plt and .got entries and space dynamic relocs for
1464 global ifunc symbols. */
1465 elf_link_hash_traverse (&htab
->elf
, allocate_ifunc_dynrelocs
, info
);
1467 /* Allocate .plt and .got entries and space dynamic relocs for
1468 local ifunc symbols. */
1469 htab_traverse (htab
->loc_hash_table
, allocate_local_ifunc_dynrelocs
, info
);
1471 /* Used to resolve the dynamic relocs overwite problems when
1472 generating static executable. */
1473 if (htab
->elf
.irelplt
)
1474 htab
->last_iplt_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1476 if (htab
->elf
.sgotplt
)
1478 struct elf_link_hash_entry
*got
;
1479 got
= elf_link_hash_lookup (elf_hash_table (info
),
1480 "_GLOBAL_OFFSET_TABLE_",
1481 false, false, false);
1483 /* Don't allocate .got.plt section if there are no GOT nor PLT
1484 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1486 || !got
->ref_regular_nonweak
)
1487 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1488 && (htab
->elf
.splt
== NULL
1489 || htab
->elf
.splt
->size
== 0)
1490 && (htab
->elf
.sgot
== NULL
1491 || (htab
->elf
.sgot
->size
1492 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1493 htab
->elf
.sgotplt
->size
= 0;
1496 /* The check_relocs and adjust_dynamic_symbol entry points have
1497 determined the sizes of the various dynamic sections. Allocate
1499 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1501 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1504 if (s
== htab
->elf
.splt
1505 || s
== htab
->elf
.sgot
1506 || s
== htab
->elf
.sgotplt
1507 || s
== htab
->elf
.iplt
1508 || s
== htab
->elf
.igotplt
1509 || s
== htab
->elf
.sdynbss
1510 || s
== htab
->elf
.sdynrelro
1511 || s
== htab
->sdyntdata
)
1513 /* Strip this section if we don't need it; see the
1516 else if (startswith (s
->name
, ".rela"))
1520 /* We use the reloc_count field as a counter if we need
1521 to copy relocs into the output file. */
1527 /* It's not one of our sections. */
1533 /* If we don't need this section, strip it from the
1534 output file. This is mostly to handle .rela.bss and
1535 .rela.plt. We must create both sections in
1536 create_dynamic_sections, because they must be created
1537 before the linker maps input sections to output
1538 sections. The linker does that before
1539 adjust_dynamic_symbol is called, and it is that
1540 function which decides whether anything needs to go
1541 into these sections. */
1542 s
->flags
|= SEC_EXCLUDE
;
1546 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1549 /* Allocate memory for the section contents. Zero the memory
1550 for the benefit of .rela.plt, which has 4 unused entries
1551 at the beginning, and we don't want garbage. */
1552 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1553 if (s
->contents
== NULL
)
1557 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, true);
1561 #define DTP_OFFSET 0x800
1563 /* Return the relocation value for a TLS dtp-relative reloc. */
1566 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1568 /* If tls_sec is NULL, we should have signalled an error already. */
1569 if (elf_hash_table (info
)->tls_sec
== NULL
)
1571 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1574 /* Return the relocation value for a static TLS tp-relative relocation. */
1577 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1579 /* If tls_sec is NULL, we should have signalled an error already. */
1580 if (elf_hash_table (info
)->tls_sec
== NULL
)
1582 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1585 /* Return the global pointer's value, or 0 if it is not in use. */
1588 riscv_global_pointer_value (struct bfd_link_info
*info
)
1590 struct bfd_link_hash_entry
*h
;
1592 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, false, false, true);
1593 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1596 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1599 /* Emplace a static relocation. */
1601 static bfd_reloc_status_type
1602 perform_relocation (const reloc_howto_type
*howto
,
1603 const Elf_Internal_Rela
*rel
,
1605 asection
*input_section
,
1609 if (howto
->pc_relative
)
1610 value
-= sec_addr (input_section
) + rel
->r_offset
;
1611 value
+= rel
->r_addend
;
1613 switch (ELFNN_R_TYPE (rel
->r_info
))
1616 case R_RISCV_TPREL_HI20
:
1617 case R_RISCV_PCREL_HI20
:
1618 case R_RISCV_GOT_HI20
:
1619 case R_RISCV_TLS_GOT_HI20
:
1620 case R_RISCV_TLS_GD_HI20
:
1621 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1622 return bfd_reloc_overflow
;
1623 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1626 case R_RISCV_LO12_I
:
1627 case R_RISCV_GPREL_I
:
1628 case R_RISCV_TPREL_LO12_I
:
1629 case R_RISCV_TPREL_I
:
1630 case R_RISCV_PCREL_LO12_I
:
1631 value
= ENCODE_ITYPE_IMM (value
);
1634 case R_RISCV_LO12_S
:
1635 case R_RISCV_GPREL_S
:
1636 case R_RISCV_TPREL_LO12_S
:
1637 case R_RISCV_TPREL_S
:
1638 case R_RISCV_PCREL_LO12_S
:
1639 value
= ENCODE_STYPE_IMM (value
);
1643 case R_RISCV_CALL_PLT
:
1644 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1645 return bfd_reloc_overflow
;
1646 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1647 | (ENCODE_ITYPE_IMM (value
) << 32);
1651 if (!VALID_JTYPE_IMM (value
))
1652 return bfd_reloc_overflow
;
1653 value
= ENCODE_JTYPE_IMM (value
);
1656 case R_RISCV_BRANCH
:
1657 if (!VALID_BTYPE_IMM (value
))
1658 return bfd_reloc_overflow
;
1659 value
= ENCODE_BTYPE_IMM (value
);
1662 case R_RISCV_RVC_BRANCH
:
1663 if (!VALID_CBTYPE_IMM (value
))
1664 return bfd_reloc_overflow
;
1665 value
= ENCODE_CBTYPE_IMM (value
);
1668 case R_RISCV_RVC_JUMP
:
1669 if (!VALID_CJTYPE_IMM (value
))
1670 return bfd_reloc_overflow
;
1671 value
= ENCODE_CJTYPE_IMM (value
);
1674 case R_RISCV_RVC_LUI
:
1675 if (RISCV_CONST_HIGH_PART (value
) == 0)
1677 /* Linker relaxation can convert an address equal to or greater than
1678 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1679 valid immediate. We can fix this by converting it to a C.LI. */
1680 bfd_vma insn
= riscv_get_insn (howto
->bitsize
,
1681 contents
+ rel
->r_offset
);
1682 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1683 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1684 value
= ENCODE_CITYPE_IMM (0);
1686 else if (!VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1687 return bfd_reloc_overflow
;
1689 value
= ENCODE_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1707 case R_RISCV_32_PCREL
:
1708 case R_RISCV_TLS_DTPREL32
:
1709 case R_RISCV_TLS_DTPREL64
:
1712 case R_RISCV_DELETE
:
1713 return bfd_reloc_ok
;
1716 return bfd_reloc_notsupported
;
1720 if (riscv_is_insn_reloc (howto
))
1721 word
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1723 word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1724 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1725 if (riscv_is_insn_reloc (howto
))
1726 riscv_put_insn (howto
->bitsize
, word
, contents
+ rel
->r_offset
);
1728 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1730 return bfd_reloc_ok
;
1733 /* Remember all PC-relative high-part relocs we've encountered to help us
1734 later resolve the corresponding low-part relocs. */
1740 } riscv_pcrel_hi_reloc
;
1742 typedef struct riscv_pcrel_lo_reloc
1744 asection
*input_section
;
1745 struct bfd_link_info
*info
;
1746 reloc_howto_type
*howto
;
1747 const Elf_Internal_Rela
*reloc
;
1751 struct riscv_pcrel_lo_reloc
*next
;
1752 } riscv_pcrel_lo_reloc
;
1757 riscv_pcrel_lo_reloc
*lo_relocs
;
1758 } riscv_pcrel_relocs
;
1761 riscv_pcrel_reloc_hash (const void *entry
)
1763 const riscv_pcrel_hi_reloc
*e
= entry
;
1764 return (hashval_t
)(e
->address
>> 2);
1768 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1770 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1771 return e1
->address
== e2
->address
;
1775 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1777 p
->lo_relocs
= NULL
;
1778 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1779 riscv_pcrel_reloc_eq
, free
);
1780 return p
->hi_relocs
!= NULL
;
1784 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1786 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1790 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1795 htab_delete (p
->hi_relocs
);
1799 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1800 struct bfd_link_info
*info
,
1804 const reloc_howto_type
*howto
,
1805 bfd
*input_bfd ATTRIBUTE_UNUSED
)
1807 /* We may need to reference low addreses in PC-relative modes even when the
1808 PC is far away from these addresses. For example, undefweak references
1809 need to produce the address 0 when linked. As 0 is far from the arbitrary
1810 addresses that we can link PC-relative programs at, the linker can't
1811 actually relocate references to those symbols. In order to allow these
1812 programs to work we simply convert the PC-relative auipc sequences to
1813 0-relative lui sequences. */
1814 if (bfd_link_pic (info
))
1817 /* If it's possible to reference the symbol using auipc we do so, as that's
1818 more in the spirit of the PC-relative relocations we're processing. */
1819 bfd_vma offset
= addr
- pc
;
1820 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1823 /* If it's impossible to reference this with a LUI-based offset then don't
1824 bother to convert it at all so users still see the PC-relative relocation
1825 in the truncation message. */
1826 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1829 rel
->r_info
= ELFNN_R_INFO (addr
, R_RISCV_HI20
);
1831 bfd_vma insn
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1832 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1833 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1838 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1839 bfd_vma value
, bool absolute
)
1841 bfd_vma offset
= absolute
? value
: value
- addr
;
1842 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1843 riscv_pcrel_hi_reloc
**slot
=
1844 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1846 BFD_ASSERT (*slot
== NULL
);
1847 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1855 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1856 asection
*input_section
,
1857 struct bfd_link_info
*info
,
1858 reloc_howto_type
*howto
,
1859 const Elf_Internal_Rela
*reloc
,
1864 riscv_pcrel_lo_reloc
*entry
;
1865 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1868 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1869 name
, contents
, p
->lo_relocs
};
1870 p
->lo_relocs
= entry
;
1875 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1877 riscv_pcrel_lo_reloc
*r
;
1879 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1881 bfd
*input_bfd
= r
->input_section
->owner
;
1883 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1884 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1886 /* Check the overflow when adding reloc addend. */
1887 || (RISCV_CONST_HIGH_PART (entry
->value
)
1888 != RISCV_CONST_HIGH_PART (entry
->value
+ r
->reloc
->r_addend
)))
1892 string
= _("%pcrel_lo missing matching %pcrel_hi");
1893 else if (asprintf (&string
,
1894 _("%%pcrel_lo overflow with an addend, the "
1895 "value of %%pcrel_hi is 0x%" PRIx64
" without "
1896 "any addend, but may be 0x%" PRIx64
" after "
1897 "adding the %%pcrel_lo addend"),
1898 (int64_t) RISCV_CONST_HIGH_PART (entry
->value
),
1899 (int64_t) RISCV_CONST_HIGH_PART
1900 (entry
->value
+ r
->reloc
->r_addend
)) == -1)
1901 string
= _("%pcrel_lo overflow with an addend");
1903 (*r
->info
->callbacks
->reloc_dangerous
)
1904 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1908 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1909 input_bfd
, r
->contents
);
1915 /* Relocate a RISC-V ELF section.
1917 The RELOCATE_SECTION function is called by the new ELF backend linker
1918 to handle the relocations for a section.
1920 The relocs are always passed as Rela structures.
1922 This function is responsible for adjusting the section contents as
1923 necessary, and (if generating a relocatable output file) adjusting
1924 the reloc addend as necessary.
1926 This function does not have to worry about setting the reloc
1927 address or the reloc symbol index.
1929 LOCAL_SYMS is a pointer to the swapped in local symbols.
1931 LOCAL_SECTIONS is an array giving the section in the input file
1932 corresponding to the st_shndx field of each local symbol.
1934 The global hash table entry for the global symbols can be found
1935 via elf_sym_hashes (input_bfd).
1937 When generating relocatable output, this function must handle
1938 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1939 going to be the section symbol corresponding to the output
1940 section, which means that the addend must be adjusted
1944 riscv_elf_relocate_section (bfd
*output_bfd
,
1945 struct bfd_link_info
*info
,
1947 asection
*input_section
,
1949 Elf_Internal_Rela
*relocs
,
1950 Elf_Internal_Sym
*local_syms
,
1951 asection
**local_sections
)
1953 Elf_Internal_Rela
*rel
;
1954 Elf_Internal_Rela
*relend
;
1955 riscv_pcrel_relocs pcrel_relocs
;
1957 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1958 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1959 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1960 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1963 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1966 relend
= relocs
+ input_section
->reloc_count
;
1967 for (rel
= relocs
; rel
< relend
; rel
++)
1969 unsigned long r_symndx
;
1970 struct elf_link_hash_entry
*h
;
1971 Elf_Internal_Sym
*sym
;
1974 bfd_reloc_status_type r
= bfd_reloc_ok
;
1975 const char *name
= NULL
;
1976 bfd_vma off
, ie_off
;
1977 bool unresolved_reloc
, is_ie
= false;
1978 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1979 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1980 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1981 const char *msg
= NULL
;
1982 char *msg_buf
= NULL
;
1983 bool resolved_to_zero
;
1986 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1989 /* This is a final link. */
1990 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1994 unresolved_reloc
= false;
1995 if (r_symndx
< symtab_hdr
->sh_info
)
1997 sym
= local_syms
+ r_symndx
;
1998 sec
= local_sections
[r_symndx
];
1999 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2001 /* Relocate against local STT_GNU_IFUNC symbol. */
2002 if (!bfd_link_relocatable (info
)
2003 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
2005 h
= riscv_elf_get_local_sym_hash (htab
, input_bfd
, rel
, false);
2009 /* Set STT_GNU_IFUNC symbol value. */
2010 h
->root
.u
.def
.value
= sym
->st_value
;
2011 h
->root
.u
.def
.section
= sec
;
2016 bool warned
, ignored
;
2018 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2019 r_symndx
, symtab_hdr
, sym_hashes
,
2021 unresolved_reloc
, warned
, ignored
);
2024 /* To avoid generating warning messages about truncated
2025 relocations, set the relocation's address to be the same as
2026 the start of this section. */
2027 if (input_section
->output_section
!= NULL
)
2028 relocation
= input_section
->output_section
->vma
;
2034 if (sec
!= NULL
&& discarded_section (sec
))
2035 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2036 rel
, 1, relend
, howto
, 0, contents
);
2038 if (bfd_link_relocatable (info
))
2041 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2042 it here if it is defined in a non-shared object. */
2044 && h
->type
== STT_GNU_IFUNC
2047 asection
*plt
, *base_got
;
2049 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2051 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2052 STT_GNU_IFUNC symbol as STT_FUNC. */
2053 if (elf_section_type (input_section
) == SHT_NOTE
)
2056 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2057 sections because such sections are not SEC_ALLOC and
2058 thus ld.so will not process them. */
2059 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
2064 else if (h
->plt
.offset
== (bfd_vma
) -1
2065 /* The following relocation may not need the .plt entries
2066 when all references to a STT_GNU_IFUNC symbols are done
2067 via GOT or static function pointers. */
2068 && r_type
!= R_RISCV_32
2069 && r_type
!= R_RISCV_64
2070 && r_type
!= R_RISCV_HI20
2071 && r_type
!= R_RISCV_GOT_HI20
2072 && r_type
!= R_RISCV_LO12_I
2073 && r_type
!= R_RISCV_LO12_S
)
2074 goto bad_ifunc_reloc
;
2076 /* STT_GNU_IFUNC symbol must go through PLT. */
2077 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2078 relocation
= plt
->output_section
->vma
2079 + plt
->output_offset
2086 if (rel
->r_addend
!= 0)
2088 if (h
->root
.root
.string
)
2089 name
= h
->root
.root
.string
;
2091 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2094 /* xgettext:c-format */
2095 (_("%pB: relocation %s against STT_GNU_IFUNC "
2096 "symbol `%s' has non-zero addend: %" PRId64
),
2097 input_bfd
, howto
->name
, name
, (int64_t) rel
->r_addend
);
2098 bfd_set_error (bfd_error_bad_value
);
2102 /* Generate dynamic relocation only when there is a non-GOT
2103 reference in a shared object or there is no PLT. */
2104 if ((bfd_link_pic (info
) && h
->non_got_ref
)
2105 || h
->plt
.offset
== (bfd_vma
) -1)
2107 Elf_Internal_Rela outrel
;
2110 /* Need a dynamic relocation to get the real function
2112 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2116 if (outrel
.r_offset
== (bfd_vma
) -1
2117 || outrel
.r_offset
== (bfd_vma
) -2)
2120 outrel
.r_offset
+= input_section
->output_section
->vma
2121 + input_section
->output_offset
;
2123 if (h
->dynindx
== -1
2125 || bfd_link_executable (info
))
2127 info
->callbacks
->minfo
2128 (_("Local IFUNC function `%s' in %pB\n"),
2129 h
->root
.root
.string
,
2130 h
->root
.u
.def
.section
->owner
);
2132 /* This symbol is resolved locally. */
2133 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2134 outrel
.r_addend
= h
->root
.u
.def
.value
2135 + h
->root
.u
.def
.section
->output_section
->vma
2136 + h
->root
.u
.def
.section
->output_offset
;
2140 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2141 outrel
.r_addend
= 0;
2144 /* Dynamic relocations are stored in
2145 1. .rela.ifunc section in PIC object.
2146 2. .rela.got section in dynamic executable.
2147 3. .rela.iplt section in static executable. */
2148 if (bfd_link_pic (info
))
2149 sreloc
= htab
->elf
.irelifunc
;
2150 else if (htab
->elf
.splt
!= NULL
)
2151 sreloc
= htab
->elf
.srelgot
;
2153 sreloc
= htab
->elf
.irelplt
;
2155 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2157 /* If this reloc is against an external symbol, we
2158 do not want to fiddle with the addend. Otherwise,
2159 we need to include the symbol value so that it
2160 becomes an addend for the dynamic reloc. For an
2161 internal symbol, we have updated addend. */
2166 case R_RISCV_GOT_HI20
:
2167 base_got
= htab
->elf
.sgot
;
2168 off
= h
->got
.offset
;
2170 if (base_got
== NULL
)
2173 if (off
== (bfd_vma
) -1)
2177 /* We can't use h->got.offset here to save state, or
2178 even just remember the offset, as finish_dynamic_symbol
2179 would use that as offset into .got. */
2181 if (htab
->elf
.splt
!= NULL
)
2183 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
)
2185 off
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2186 base_got
= htab
->elf
.sgotplt
;
2190 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2191 off
= plt_idx
* GOT_ENTRY_SIZE
;
2192 base_got
= htab
->elf
.igotplt
;
2195 if (h
->dynindx
== -1
2199 /* This references the local definition. We must
2200 initialize this entry in the global offset table.
2201 Since the offset must always be a multiple of 8,
2202 we use the least significant bit to record
2203 whether we have initialized it already.
2205 When doing a dynamic link, we create a .rela.got
2206 relocation entry to initialize the value. This
2207 is done in the finish_dynamic_symbol routine. */
2212 bfd_put_NN (output_bfd
, relocation
,
2213 base_got
->contents
+ off
);
2214 /* Note that this is harmless for the case,
2215 as -1 | 1 still is -1. */
2221 relocation
= base_got
->output_section
->vma
2222 + base_got
->output_offset
+ off
;
2224 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2225 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2227 r
= bfd_reloc_notsupported
;
2228 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2230 r
= bfd_reloc_overflow
;
2234 case R_RISCV_CALL_PLT
:
2236 case R_RISCV_LO12_I
:
2237 case R_RISCV_LO12_S
:
2240 case R_RISCV_PCREL_HI20
:
2241 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2242 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2244 r
= bfd_reloc_notsupported
;
2245 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2247 r
= bfd_reloc_overflow
;
2252 if (h
->root
.root
.string
)
2253 name
= h
->root
.root
.string
;
2255 /* The entry of local ifunc is fake in global hash table,
2256 we should find the name by the original local symbol. */
2257 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2260 /* xgettext:c-format */
2261 (_("%pB: relocation %s against STT_GNU_IFUNC "
2262 "symbol `%s' isn't supported"), input_bfd
,
2264 bfd_set_error (bfd_error_bad_value
);
2271 name
= h
->root
.root
.string
;
2274 name
= (bfd_elf_string_from_elf_section
2275 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2276 if (name
== NULL
|| *name
== '\0')
2277 name
= bfd_section_name (sec
);
2280 resolved_to_zero
= (h
!= NULL
2281 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
2287 case R_RISCV_TPREL_ADD
:
2289 case R_RISCV_JUMP_SLOT
:
2290 case R_RISCV_RELATIVE
:
2291 /* These require nothing of us at all. */
2295 case R_RISCV_BRANCH
:
2296 case R_RISCV_RVC_BRANCH
:
2297 case R_RISCV_RVC_LUI
:
2298 case R_RISCV_LO12_I
:
2299 case R_RISCV_LO12_S
:
2304 case R_RISCV_32_PCREL
:
2305 case R_RISCV_DELETE
:
2306 /* These require no special handling beyond perform_relocation. */
2309 case R_RISCV_GOT_HI20
:
2314 off
= h
->got
.offset
;
2315 BFD_ASSERT (off
!= (bfd_vma
) -1);
2316 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2317 pic
= bfd_link_pic (info
);
2319 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2320 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
2322 /* This is actually a static link, or it is a
2323 -Bsymbolic link and the symbol is defined
2324 locally, or the symbol was forced to be local
2325 because of a version file. We must initialize
2326 this entry in the global offset table. Since the
2327 offset must always be a multiple of the word size,
2328 we use the least significant bit to record whether
2329 we have initialized it already.
2331 When doing a dynamic link, we create a .rela.got
2332 relocation entry to initialize the value. This
2333 is done in the finish_dynamic_symbol routine. */
2338 bfd_put_NN (output_bfd
, relocation
,
2339 htab
->elf
.sgot
->contents
+ off
);
2344 unresolved_reloc
= false;
2348 BFD_ASSERT (local_got_offsets
!= NULL
2349 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2351 off
= local_got_offsets
[r_symndx
];
2353 /* The offset must always be a multiple of the word size.
2354 So, we can use the least significant bit to record
2355 whether we have already processed this entry. */
2360 if (bfd_link_pic (info
))
2363 Elf_Internal_Rela outrel
;
2365 /* We need to generate a R_RISCV_RELATIVE reloc
2366 for the dynamic linker. */
2367 s
= htab
->elf
.srelgot
;
2368 BFD_ASSERT (s
!= NULL
);
2370 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2372 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2373 outrel
.r_addend
= relocation
;
2375 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
2378 bfd_put_NN (output_bfd
, relocation
,
2379 htab
->elf
.sgot
->contents
+ off
);
2380 local_got_offsets
[r_symndx
] |= 1;
2383 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
2384 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2391 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2392 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2394 r
= bfd_reloc_notsupported
;
2395 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2396 relocation
, absolute
))
2397 r
= bfd_reloc_overflow
;
2405 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2406 contents
+ rel
->r_offset
);
2407 relocation
= old_value
+ relocation
;
2417 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2418 contents
+ rel
->r_offset
);
2419 relocation
= old_value
- relocation
;
2424 case R_RISCV_CALL_PLT
:
2425 /* Handle a call to an undefined weak function. This won't be
2426 relaxed, so we have to handle it here. */
2427 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
2428 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
2430 /* We can use x0 as the base register. */
2431 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
2432 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2433 bfd_putl32 (insn
, contents
+ rel
->r_offset
+ 4);
2434 /* Set the relocation value so that we get 0 after the pc
2435 relative adjustment. */
2436 relocation
= sec_addr (input_section
) + rel
->r_offset
;
2441 case R_RISCV_RVC_JUMP
:
2442 /* This line has to match the check in _bfd_riscv_relax_section. */
2443 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
2445 /* Refer to the PLT entry. */
2446 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
2447 unresolved_reloc
= false;
2451 case R_RISCV_TPREL_HI20
:
2452 relocation
= tpoff (info
, relocation
);
2455 case R_RISCV_TPREL_LO12_I
:
2456 case R_RISCV_TPREL_LO12_S
:
2457 relocation
= tpoff (info
, relocation
);
2460 case R_RISCV_TPREL_I
:
2461 case R_RISCV_TPREL_S
:
2462 relocation
= tpoff (info
, relocation
);
2463 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
2465 /* We can use tp as the base register. */
2466 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2467 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2468 insn
|= X_TP
<< OP_SH_RS1
;
2469 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2472 r
= bfd_reloc_overflow
;
2475 case R_RISCV_GPREL_I
:
2476 case R_RISCV_GPREL_S
:
2478 bfd_vma gp
= riscv_global_pointer_value (info
);
2479 bool x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2480 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2482 /* We can use x0 or gp as the base register. */
2483 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2484 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2487 rel
->r_addend
-= gp
;
2488 insn
|= X_GP
<< OP_SH_RS1
;
2490 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2493 r
= bfd_reloc_overflow
;
2497 case R_RISCV_PCREL_HI20
:
2498 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2505 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2506 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2508 r
= bfd_reloc_notsupported
;
2509 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2510 relocation
+ rel
->r_addend
,
2512 r
= bfd_reloc_overflow
;
2515 case R_RISCV_PCREL_LO12_I
:
2516 case R_RISCV_PCREL_LO12_S
:
2517 /* We don't allow section symbols plus addends as the auipc address,
2518 because then riscv_relax_delete_bytes would have to search through
2519 all relocs to update these addends. This is also ambiguous, as
2520 we do allow offsets to be added to the target address, which are
2521 not to be used to find the auipc address. */
2522 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2523 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2526 msg
= _("%pcrel_lo section symbol with an addend");
2527 r
= bfd_reloc_dangerous
;
2531 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2532 howto
, rel
, relocation
, name
,
2535 r
= bfd_reloc_overflow
;
2538 case R_RISCV_TLS_DTPREL32
:
2539 case R_RISCV_TLS_DTPREL64
:
2540 relocation
= dtpoff (info
, relocation
);
2545 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2548 if ((bfd_link_pic (info
)
2550 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2551 && !resolved_to_zero
)
2552 || h
->root
.type
!= bfd_link_hash_undefweak
)
2553 && (!howto
->pc_relative
2554 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2555 || (!bfd_link_pic (info
)
2561 || h
->root
.type
== bfd_link_hash_undefweak
2562 || h
->root
.type
== bfd_link_hash_undefined
)))
2564 Elf_Internal_Rela outrel
;
2566 bool skip_static_relocation
, skip_dynamic_relocation
;
2568 /* When generating a shared object, these relocations
2569 are copied into the output file to be resolved at run
2573 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2575 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2576 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2577 outrel
.r_offset
+= sec_addr (input_section
);
2579 if (skip_dynamic_relocation
)
2580 memset (&outrel
, 0, sizeof outrel
);
2581 else if (h
!= NULL
&& h
->dynindx
!= -1
2582 && !(bfd_link_pic (info
)
2583 && SYMBOLIC_BIND (info
, h
)
2586 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2587 outrel
.r_addend
= rel
->r_addend
;
2591 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2592 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2595 sreloc
= elf_section_data (input_section
)->sreloc
;
2596 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2597 if (skip_static_relocation
)
2602 case R_RISCV_TLS_GOT_HI20
:
2606 case R_RISCV_TLS_GD_HI20
:
2609 off
= h
->got
.offset
;
2614 off
= local_got_offsets
[r_symndx
];
2615 local_got_offsets
[r_symndx
] |= 1;
2618 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2619 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2620 /* If this symbol is referenced by both GD and IE TLS, the IE
2621 reference's GOT slot follows the GD reference's slots. */
2623 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2624 ie_off
= 2 * GOT_ENTRY_SIZE
;
2630 Elf_Internal_Rela outrel
;
2632 bool need_relocs
= false;
2634 if (htab
->elf
.srelgot
== NULL
)
2640 dyn
= htab
->elf
.dynamic_sections_created
;
2641 pic
= bfd_link_pic (info
);
2643 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2644 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2648 /* The GOT entries have not been initialized yet. Do it
2649 now, and emit any relocations. */
2650 if ((bfd_link_pic (info
) || indx
!= 0)
2652 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2653 || h
->root
.type
!= bfd_link_hash_undefweak
))
2656 if (tls_type
& GOT_TLS_GD
)
2660 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2661 outrel
.r_addend
= 0;
2662 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2663 bfd_put_NN (output_bfd
, 0,
2664 htab
->elf
.sgot
->contents
+ off
);
2665 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2668 BFD_ASSERT (! unresolved_reloc
);
2669 bfd_put_NN (output_bfd
,
2670 dtpoff (info
, relocation
),
2671 (htab
->elf
.sgot
->contents
2672 + off
+ RISCV_ELF_WORD_BYTES
));
2676 bfd_put_NN (output_bfd
, 0,
2677 (htab
->elf
.sgot
->contents
2678 + off
+ RISCV_ELF_WORD_BYTES
));
2679 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2680 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2681 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2686 /* If we are not emitting relocations for a
2687 general dynamic reference, then we must be in a
2688 static link or an executable link with the
2689 symbol binding locally. Mark it as belonging
2690 to module 1, the executable. */
2691 bfd_put_NN (output_bfd
, 1,
2692 htab
->elf
.sgot
->contents
+ off
);
2693 bfd_put_NN (output_bfd
,
2694 dtpoff (info
, relocation
),
2695 (htab
->elf
.sgot
->contents
2696 + off
+ RISCV_ELF_WORD_BYTES
));
2700 if (tls_type
& GOT_TLS_IE
)
2704 bfd_put_NN (output_bfd
, 0,
2705 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2706 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2708 outrel
.r_addend
= 0;
2710 outrel
.r_addend
= tpoff (info
, relocation
);
2711 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2712 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2716 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2717 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2722 BFD_ASSERT (off
< (bfd_vma
) -2);
2723 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2724 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2726 r
= bfd_reloc_overflow
;
2727 unresolved_reloc
= false;
2731 r
= bfd_reloc_notsupported
;
2734 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2735 because such sections are not SEC_ALLOC and thus ld.so will
2736 not process them. */
2737 if (unresolved_reloc
2738 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2740 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2741 rel
->r_offset
) != (bfd_vma
) -1)
2746 case R_RISCV_RVC_JUMP
:
2747 if (asprintf (&msg_buf
,
2748 _("%%X%%P: relocation %s against `%s' can "
2749 "not be used when making a shared object; "
2750 "recompile with -fPIC\n"),
2752 h
->root
.root
.string
) == -1)
2757 if (asprintf (&msg_buf
,
2758 _("%%X%%P: unresolvable %s relocation against "
2761 h
->root
.root
.string
) == -1)
2767 r
= bfd_reloc_notsupported
;
2771 if (r
== bfd_reloc_ok
)
2772 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2773 input_bfd
, contents
);
2775 /* We should have already detected the error and set message before.
2776 If the error message isn't set since the linker runs out of memory
2777 or we don't set it before, then we should set the default message
2778 with the "internal error" string here. */
2784 case bfd_reloc_overflow
:
2785 info
->callbacks
->reloc_overflow
2786 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2787 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2790 case bfd_reloc_undefined
:
2791 info
->callbacks
->undefined_symbol
2792 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2796 case bfd_reloc_outofrange
:
2798 msg
= _("%X%P: internal error: out of range error\n");
2801 case bfd_reloc_notsupported
:
2803 msg
= _("%X%P: internal error: unsupported relocation error\n");
2806 case bfd_reloc_dangerous
:
2807 /* The error message should already be set. */
2809 msg
= _("dangerous relocation error");
2810 info
->callbacks
->reloc_dangerous
2811 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2815 msg
= _("%X%P: internal error: unknown error\n");
2819 /* Do not report error message for the dangerous relocation again. */
2820 if (msg
&& r
!= bfd_reloc_dangerous
)
2821 info
->callbacks
->einfo (msg
);
2823 /* Free the unused `msg_buf`. */
2826 /* We already reported the error via a callback, so don't try to report
2827 it again by returning false. That leads to spurious errors. */
2832 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2834 riscv_free_pcrel_relocs (&pcrel_relocs
);
2838 /* Finish up dynamic symbol handling. We set the contents of various
2839 dynamic sections here. */
2842 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2843 struct bfd_link_info
*info
,
2844 struct elf_link_hash_entry
*h
,
2845 Elf_Internal_Sym
*sym
)
2847 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2848 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2850 if (h
->plt
.offset
!= (bfd_vma
) -1)
2852 /* We've decided to create a PLT entry for this symbol. */
2854 bfd_vma i
, header_address
, plt_idx
, got_offset
, got_address
;
2855 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2856 Elf_Internal_Rela rela
;
2857 asection
*plt
, *gotplt
, *relplt
;
2859 /* When building a static executable, use .iplt, .igot.plt and
2860 .rela.iplt sections for STT_GNU_IFUNC symbols. */
2861 if (htab
->elf
.splt
!= NULL
)
2863 plt
= htab
->elf
.splt
;
2864 gotplt
= htab
->elf
.sgotplt
;
2865 relplt
= htab
->elf
.srelplt
;
2869 plt
= htab
->elf
.iplt
;
2870 gotplt
= htab
->elf
.igotplt
;
2871 relplt
= htab
->elf
.irelplt
;
2874 /* This symbol has an entry in the procedure linkage table. Set
2876 if ((h
->dynindx
== -1
2877 && !((h
->forced_local
|| bfd_link_executable (info
))
2879 && h
->type
== STT_GNU_IFUNC
))
2885 /* Calculate the address of the PLT header. */
2886 header_address
= sec_addr (plt
);
2888 /* Calculate the index of the entry and the offset of .got.plt entry.
2889 For static executables, we don't reserve anything. */
2890 if (plt
== htab
->elf
.splt
)
2892 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2893 got_offset
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2897 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2898 got_offset
= plt_idx
* GOT_ENTRY_SIZE
;
2901 /* Calculate the address of the .got.plt entry. */
2902 got_address
= sec_addr (gotplt
) + got_offset
;
2904 /* Find out where the .plt entry should go. */
2905 loc
= plt
->contents
+ h
->plt
.offset
;
2907 /* Fill in the PLT entry itself. */
2908 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2909 header_address
+ h
->plt
.offset
,
2913 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2914 bfd_putl32 (plt_entry
[i
], loc
+ 4*i
);
2916 /* Fill in the initial value of the .got.plt entry. */
2917 loc
= gotplt
->contents
+ (got_address
- sec_addr (gotplt
));
2918 bfd_put_NN (output_bfd
, sec_addr (plt
), loc
);
2920 rela
.r_offset
= got_address
;
2922 if (h
->dynindx
== -1
2923 || ((bfd_link_executable (info
)
2924 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2926 && h
->type
== STT_GNU_IFUNC
))
2928 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2929 h
->root
.root
.string
,
2930 h
->root
.u
.def
.section
->owner
);
2932 /* If an STT_GNU_IFUNC symbol is locally defined, generate
2933 R_RISCV_IRELATIVE instead of R_RISCV_JUMP_SLOT. */
2934 asection
*sec
= h
->root
.u
.def
.section
;
2935 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2936 rela
.r_addend
= h
->root
.u
.def
.value
2937 + sec
->output_section
->vma
2938 + sec
->output_offset
;
2942 /* Fill in the entry in the .rela.plt section. */
2943 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2947 loc
= relplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2948 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2950 if (!h
->def_regular
)
2952 /* Mark the symbol as undefined, rather than as defined in
2953 the .plt section. Leave the value alone. */
2954 sym
->st_shndx
= SHN_UNDEF
;
2955 /* If the symbol is weak, we do need to clear the value.
2956 Otherwise, the PLT entry would provide a definition for
2957 the symbol even if the symbol wasn't defined anywhere,
2958 and so the symbol would never be NULL. */
2959 if (!h
->ref_regular_nonweak
)
2964 if (h
->got
.offset
!= (bfd_vma
) -1
2965 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2966 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2970 Elf_Internal_Rela rela
;
2971 bool use_elf_append_rela
= true;
2973 /* This symbol has an entry in the GOT. Set it up. */
2975 sgot
= htab
->elf
.sgot
;
2976 srela
= htab
->elf
.srelgot
;
2977 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2979 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2981 /* Handle the ifunc symbol in GOT entry. */
2983 && h
->type
== STT_GNU_IFUNC
)
2985 if (h
->plt
.offset
== (bfd_vma
) -1)
2987 /* STT_GNU_IFUNC is referenced without PLT. */
2989 if (htab
->elf
.splt
== NULL
)
2991 /* Use .rela.iplt section to store .got relocations
2992 in static executable. */
2993 srela
= htab
->elf
.irelplt
;
2995 /* Do not use riscv_elf_append_rela to add dynamic
2997 use_elf_append_rela
= false;
3000 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
3002 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
3003 h
->root
.root
.string
,
3004 h
->root
.u
.def
.section
->owner
);
3006 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
3007 rela
.r_addend
= (h
->root
.u
.def
.value
3008 + h
->root
.u
.def
.section
->output_section
->vma
3009 + h
->root
.u
.def
.section
->output_offset
);
3013 /* Generate R_RISCV_NN. */
3014 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3015 BFD_ASSERT (h
->dynindx
!= -1);
3016 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3020 else if (bfd_link_pic (info
))
3022 /* Generate R_RISCV_NN. */
3023 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3024 BFD_ASSERT (h
->dynindx
!= -1);
3025 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3032 if (!h
->pointer_equality_needed
)
3035 /* For non-shared object, we can't use .got.plt, which
3036 contains the real function address if we need pointer
3037 equality. We load the GOT entry with the PLT entry. */
3038 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3039 bfd_put_NN (output_bfd
, (plt
->output_section
->vma
3040 + plt
->output_offset
3042 htab
->elf
.sgot
->contents
3043 + (h
->got
.offset
& ~(bfd_vma
) 1));
3047 else if (bfd_link_pic (info
)
3048 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3050 /* If this is a local symbol reference, we just want to emit
3051 a RELATIVE reloc. This can happen if it is a -Bsymbolic link,
3052 or a pie link, or the symbol was forced to be local because
3053 of a version file. The entry in the global offset table will
3054 already have been initialized in the relocate_section function. */
3055 BFD_ASSERT ((h
->got
.offset
& 1) != 0);
3056 asection
*sec
= h
->root
.u
.def
.section
;
3057 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
3058 rela
.r_addend
= (h
->root
.u
.def
.value
3059 + sec
->output_section
->vma
3060 + sec
->output_offset
);
3064 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3065 BFD_ASSERT (h
->dynindx
!= -1);
3066 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3070 bfd_put_NN (output_bfd
, 0,
3071 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3073 if (use_elf_append_rela
)
3074 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
3077 /* Use riscv_elf_append_rela to add the dynamic relocs into
3078 .rela.iplt may cause the overwrite problems. Since we insert
3079 the relocs for PLT didn't handle the reloc_index of .rela.iplt,
3080 but the riscv_elf_append_rela adds the relocs to the place
3081 that are calculated from the reloc_index (in seqential).
3083 One solution is that add these dynamic relocs (GOT IFUNC)
3084 from the last of .rela.iplt section. */
3085 bfd_vma iplt_idx
= htab
->last_iplt_index
--;
3086 bfd_byte
*loc
= srela
->contents
3087 + iplt_idx
* sizeof (ElfNN_External_Rela
);
3088 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
3094 Elf_Internal_Rela rela
;
3097 /* This symbols needs a copy reloc. Set it up. */
3098 BFD_ASSERT (h
->dynindx
!= -1);
3100 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3101 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
3103 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
3104 s
= htab
->elf
.sreldynrelro
;
3106 s
= htab
->elf
.srelbss
;
3107 riscv_elf_append_rela (output_bfd
, s
, &rela
);
3110 /* Mark some specially defined symbols as absolute. */
3111 if (h
== htab
->elf
.hdynamic
3112 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
3113 sym
->st_shndx
= SHN_ABS
;
3118 /* Finish up local dynamic symbol handling. We set the contents of
3119 various dynamic sections here. */
3122 riscv_elf_finish_local_dynamic_symbol (void **slot
, void *inf
)
3124 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) *slot
;
3125 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3127 return riscv_elf_finish_dynamic_symbol (info
->output_bfd
, info
, h
, NULL
);
3130 /* Finish up the dynamic sections. */
3133 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3134 bfd
*dynobj
, asection
*sdyn
)
3136 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3137 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
3138 size_t dynsize
= bed
->s
->sizeof_dyn
;
3139 bfd_byte
*dyncon
, *dynconend
;
3141 dynconend
= sdyn
->contents
+ sdyn
->size
;
3142 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
3144 Elf_Internal_Dyn dyn
;
3147 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
3152 s
= htab
->elf
.sgotplt
;
3153 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3156 s
= htab
->elf
.srelplt
;
3157 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3160 s
= htab
->elf
.srelplt
;
3161 dyn
.d_un
.d_val
= s
->size
;
3167 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3173 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
3174 struct bfd_link_info
*info
)
3178 struct riscv_elf_link_hash_table
*htab
;
3180 htab
= riscv_elf_hash_table (info
);
3181 BFD_ASSERT (htab
!= NULL
);
3182 dynobj
= htab
->elf
.dynobj
;
3184 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3186 if (elf_hash_table (info
)->dynamic_sections_created
)
3191 splt
= htab
->elf
.splt
;
3192 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3194 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
3199 /* Fill in the head and tail entries in the procedure linkage table. */
3203 uint32_t plt_header
[PLT_HEADER_INSNS
];
3204 ret
= riscv_make_plt_header (output_bfd
,
3205 sec_addr (htab
->elf
.sgotplt
),
3206 sec_addr (splt
), plt_header
);
3210 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
3211 bfd_putl32 (plt_header
[i
], splt
->contents
+ 4*i
);
3213 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
3218 if (htab
->elf
.sgotplt
)
3220 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
3222 if (bfd_is_abs_section (output_section
))
3224 (*_bfd_error_handler
)
3225 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
3229 if (htab
->elf
.sgotplt
->size
> 0)
3231 /* Write the first two entries in .got.plt, needed for the dynamic
3233 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
3234 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
3235 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
3238 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3243 asection
*output_section
= htab
->elf
.sgot
->output_section
;
3245 if (htab
->elf
.sgot
->size
> 0)
3247 /* Set the first entry in the global offset table to the address of
3248 the dynamic section. */
3249 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
3250 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
3253 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3256 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
3257 htab_traverse (htab
->loc_hash_table
,
3258 riscv_elf_finish_local_dynamic_symbol
,
3264 /* Return address for Ith PLT stub in section PLT, for relocation REL
3265 or (bfd_vma) -1 if it should not be included. */
3268 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
3269 const arelent
*rel ATTRIBUTE_UNUSED
)
3271 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
3274 static enum elf_reloc_type_class
3275 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3276 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3277 const Elf_Internal_Rela
*rela
)
3279 switch (ELFNN_R_TYPE (rela
->r_info
))
3281 case R_RISCV_RELATIVE
:
3282 return reloc_class_relative
;
3283 case R_RISCV_JUMP_SLOT
:
3284 return reloc_class_plt
;
3286 return reloc_class_copy
;
3288 return reloc_class_normal
;
3292 /* Given the ELF header flags in FLAGS, it returns a string that describes the
3296 riscv_float_abi_string (flagword flags
)
3298 switch (flags
& EF_RISCV_FLOAT_ABI
)
3300 case EF_RISCV_FLOAT_ABI_SOFT
:
3301 return "soft-float";
3303 case EF_RISCV_FLOAT_ABI_SINGLE
:
3304 return "single-float";
3306 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3307 return "double-float";
3309 case EF_RISCV_FLOAT_ABI_QUAD
:
3310 return "quad-float";
3317 /* The information of architecture elf attributes. */
3318 static riscv_subset_list_t in_subsets
;
3319 static riscv_subset_list_t out_subsets
;
3320 static riscv_subset_list_t merged_subsets
;
3322 /* Predicator for standard extension. */
3325 riscv_std_ext_p (const char *name
)
3327 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
3330 /* Check if the versions are compatible. */
3333 riscv_version_mismatch (bfd
*ibfd
,
3334 struct riscv_subset_t
*in
,
3335 struct riscv_subset_t
*out
)
3337 if (in
== NULL
|| out
== NULL
)
3340 /* Since there are no version conflicts for now, we just report
3341 warning when the versions are mis-matched. */
3342 if (in
->major_version
!= out
->major_version
3343 || in
->minor_version
!= out
->minor_version
)
3345 if ((in
->major_version
== RISCV_UNKNOWN_VERSION
3346 && in
->minor_version
== RISCV_UNKNOWN_VERSION
)
3347 || (out
->major_version
== RISCV_UNKNOWN_VERSION
3348 && out
->minor_version
== RISCV_UNKNOWN_VERSION
))
3350 /* Do not report the warning when the version of input
3351 or output is RISCV_UNKNOWN_VERSION, since the extension
3352 is added implicitly. */
3356 (_("warning: %pB: mis-matched ISA version %d.%d for '%s' "
3357 "extension, the output version is %d.%d"),
3363 out
->minor_version
);
3365 /* Update the output ISA versions to the newest ones. */
3366 if ((in
->major_version
> out
->major_version
)
3367 || (in
->major_version
== out
->major_version
3368 && in
->minor_version
> out
->minor_version
))
3370 out
->major_version
= in
->major_version
;
3371 out
->minor_version
= in
->minor_version
;
3378 /* Return true if subset is 'i' or 'e'. */
3381 riscv_i_or_e_p (bfd
*ibfd
,
3383 struct riscv_subset_t
*subset
)
3385 if ((strcasecmp (subset
->name
, "e") != 0)
3386 && (strcasecmp (subset
->name
, "i") != 0))
3389 (_("error: %pB: corrupted ISA string '%s'. "
3390 "First letter should be 'i' or 'e' but got '%s'"),
3391 ibfd
, arch
, subset
->name
);
3397 /* Merge standard extensions.
3400 Return FALSE if failed to merge.
3404 `in_arch`: Raw ISA string for input object.
3405 `out_arch`: Raw ISA string for output object.
3406 `pin`: Subset list for input object.
3407 `pout`: Subset list for output object. */
3410 riscv_merge_std_ext (bfd
*ibfd
,
3411 const char *in_arch
,
3412 const char *out_arch
,
3413 struct riscv_subset_t
**pin
,
3414 struct riscv_subset_t
**pout
)
3416 const char *standard_exts
= riscv_supported_std_ext ();
3418 struct riscv_subset_t
*in
= *pin
;
3419 struct riscv_subset_t
*out
= *pout
;
3421 /* First letter should be 'i' or 'e'. */
3422 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
3425 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
3428 if (strcasecmp (in
->name
, out
->name
) != 0)
3430 /* TODO: We might allow merge 'i' with 'e'. */
3432 (_("error: %pB: mis-matched ISA string to merge '%s' and '%s'"),
3433 ibfd
, in
->name
, out
->name
);
3436 else if (!riscv_version_mismatch (ibfd
, in
, out
))
3439 riscv_add_subset (&merged_subsets
,
3440 out
->name
, out
->major_version
, out
->minor_version
);
3445 /* Handle standard extension first. */
3446 for (p
= standard_exts
; *p
; ++p
)
3448 struct riscv_subset_t
*ext_in
, *ext_out
, *ext_merged
;
3449 char find_ext
[2] = {*p
, '\0'};
3450 bool find_in
, find_out
;
3452 find_in
= riscv_lookup_subset (&in_subsets
, find_ext
, &ext_in
);
3453 find_out
= riscv_lookup_subset (&out_subsets
, find_ext
, &ext_out
);
3455 if (!find_in
&& !find_out
)
3460 && !riscv_version_mismatch (ibfd
, ext_in
, ext_out
))
3463 ext_merged
= find_out
? ext_out
: ext_in
;
3464 riscv_add_subset (&merged_subsets
, ext_merged
->name
,
3465 ext_merged
->major_version
, ext_merged
->minor_version
);
3468 /* Skip all standard extensions. */
3469 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
3470 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
3478 /* Merge multi letter extensions. PIN is a pointer to the head of the input
3479 object subset list. Likewise for POUT and the output object. Return TRUE
3480 on success and FALSE when a conflict is found. */
3483 riscv_merge_multi_letter_ext (bfd
*ibfd
,
3484 riscv_subset_t
**pin
,
3485 riscv_subset_t
**pout
)
3487 riscv_subset_t
*in
= *pin
;
3488 riscv_subset_t
*out
= *pout
;
3489 riscv_subset_t
*tail
;
3495 cmp
= riscv_compare_subsets (in
->name
, out
->name
);
3499 /* `in' comes before `out', append `in' and increment. */
3500 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
3506 /* `out' comes before `in', append `out' and increment. */
3507 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3508 out
->minor_version
);
3513 /* Both present, check version and increment both. */
3514 if (!riscv_version_mismatch (ibfd
, in
, out
))
3517 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3518 out
->minor_version
);
3526 /* If we're here, either `in' or `out' is running longer than
3527 the other. So, we need to append the corresponding tail. */
3528 tail
= in
? in
: out
;
3531 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
3532 tail
->minor_version
);
3540 /* Merge Tag_RISCV_arch attribute. */
3543 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
3545 riscv_subset_t
*in
, *out
;
3546 char *merged_arch_str
;
3548 unsigned xlen_in
, xlen_out
;
3549 merged_subsets
.head
= NULL
;
3550 merged_subsets
.tail
= NULL
;
3552 riscv_parse_subset_t rpe_in
;
3553 riscv_parse_subset_t rpe_out
;
3555 /* Only assembler needs to check the default version of ISA, so just set
3556 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */
3557 rpe_in
.subset_list
= &in_subsets
;
3558 rpe_in
.error_handler
= _bfd_error_handler
;
3559 rpe_in
.xlen
= &xlen_in
;
3560 rpe_in
.get_default_version
= NULL
;
3561 rpe_in
.check_unknown_prefixed_ext
= false;
3563 rpe_out
.subset_list
= &out_subsets
;
3564 rpe_out
.error_handler
= _bfd_error_handler
;
3565 rpe_out
.xlen
= &xlen_out
;
3566 rpe_out
.get_default_version
= NULL
;
3567 rpe_out
.check_unknown_prefixed_ext
= false;
3569 if (in_arch
== NULL
&& out_arch
== NULL
)
3572 if (in_arch
== NULL
&& out_arch
!= NULL
)
3575 if (in_arch
!= NULL
&& out_arch
== NULL
)
3578 /* Parse subset from ISA string. */
3579 if (!riscv_parse_subset (&rpe_in
, in_arch
))
3582 if (!riscv_parse_subset (&rpe_out
, out_arch
))
3585 /* Checking XLEN. */
3586 if (xlen_out
!= xlen_in
)
3589 (_("error: %pB: ISA string of input (%s) doesn't match "
3590 "output (%s)"), ibfd
, in_arch
, out_arch
);
3594 /* Merge subset list. */
3595 in
= in_subsets
.head
;
3596 out
= out_subsets
.head
;
3598 /* Merge standard extension. */
3599 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
3602 /* Merge all non-single letter extensions with single call. */
3603 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
3606 if (xlen_in
!= xlen_out
)
3609 (_("error: %pB: XLEN of input (%u) doesn't match "
3610 "output (%u)"), ibfd
, xlen_in
, xlen_out
);
3614 if (xlen_in
!= ARCH_SIZE
)
3617 (_("error: %pB: unsupported XLEN (%u), you might be "
3618 "using wrong emulation"), ibfd
, xlen_in
);
3622 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
3624 /* Release the subset lists. */
3625 riscv_release_subset_list (&in_subsets
);
3626 riscv_release_subset_list (&out_subsets
);
3627 riscv_release_subset_list (&merged_subsets
);
3629 return merged_arch_str
;
3632 /* Merge object attributes from IBFD into output_bfd of INFO.
3633 Raise an error if there are conflicting attributes. */
3636 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3638 bfd
*obfd
= info
->output_bfd
;
3639 obj_attribute
*in_attr
;
3640 obj_attribute
*out_attr
;
3642 bool priv_attrs_merged
= false;
3643 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3646 /* Skip linker created files. */
3647 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3650 /* Skip any input that doesn't have an attribute section.
3651 This enables to link object files without attribute section with
3653 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3656 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3658 /* This is the first object. Copy the attributes. */
3659 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3661 out_attr
= elf_known_obj_attributes_proc (obfd
);
3663 /* Use the Tag_null value to indicate the attributes have been
3670 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3671 out_attr
= elf_known_obj_attributes_proc (obfd
);
3673 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3677 case Tag_RISCV_arch
:
3678 if (!out_attr
[Tag_RISCV_arch
].s
)
3679 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3680 else if (in_attr
[Tag_RISCV_arch
].s
3681 && out_attr
[Tag_RISCV_arch
].s
)
3683 /* Check compatible. */
3685 riscv_merge_arch_attr_info (ibfd
,
3686 in_attr
[Tag_RISCV_arch
].s
,
3687 out_attr
[Tag_RISCV_arch
].s
);
3688 if (merged_arch
== NULL
)
3691 out_attr
[Tag_RISCV_arch
].s
= "";
3694 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3698 case Tag_RISCV_priv_spec
:
3699 case Tag_RISCV_priv_spec_minor
:
3700 case Tag_RISCV_priv_spec_revision
:
3701 /* If we have handled the privileged elf attributes, then skip it. */
3702 if (!priv_attrs_merged
)
3704 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
3705 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
3706 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
3707 enum riscv_spec_class in_priv_spec
= PRIV_SPEC_CLASS_NONE
;
3708 enum riscv_spec_class out_priv_spec
= PRIV_SPEC_CLASS_NONE
;
3710 /* Get the privileged spec class from elf attributes. */
3711 riscv_get_priv_spec_class_from_numbers (in_attr
[Tag_a
].i
,
3715 riscv_get_priv_spec_class_from_numbers (out_attr
[Tag_a
].i
,
3720 /* Allow to link the object without the privileged specs. */
3721 if (out_priv_spec
== PRIV_SPEC_CLASS_NONE
)
3723 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3724 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3725 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3727 else if (in_priv_spec
!= PRIV_SPEC_CLASS_NONE
3728 && in_priv_spec
!= out_priv_spec
)
3731 (_("warning: %pB use privileged spec version %u.%u.%u but "
3732 "the output use version %u.%u.%u"),
3741 /* The privileged spec v1.9.1 can not be linked with others
3742 since the conflicts, so we plan to drop it in a year or
3744 if (in_priv_spec
== PRIV_SPEC_CLASS_1P9P1
3745 || out_priv_spec
== PRIV_SPEC_CLASS_1P9P1
)
3748 (_("warning: privileged spec version 1.9.1 can not be "
3749 "linked with other spec versions"));
3752 /* Update the output privileged spec to the newest one. */
3753 if (in_priv_spec
> out_priv_spec
)
3755 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3756 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3757 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3760 priv_attrs_merged
= true;
3764 case Tag_RISCV_unaligned_access
:
3765 out_attr
[i
].i
|= in_attr
[i
].i
;
3768 case Tag_RISCV_stack_align
:
3769 if (out_attr
[i
].i
== 0)
3770 out_attr
[i
].i
= in_attr
[i
].i
;
3771 else if (in_attr
[i
].i
!= 0
3772 && out_attr
[i
].i
!= 0
3773 && out_attr
[i
].i
!= in_attr
[i
].i
)
3776 (_("error: %pB use %u-byte stack aligned but the output "
3777 "use %u-byte stack aligned"),
3778 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3784 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3787 /* If out_attr was copied from in_attr then it won't have a type yet. */
3788 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3789 out_attr
[i
].type
= in_attr
[i
].type
;
3792 /* Merge Tag_compatibility attributes and any common GNU ones. */
3793 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3796 /* Check for any attributes not known on RISC-V. */
3797 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3802 /* Merge backend specific data from an object file to the output
3803 object file when linking. */
3806 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3808 bfd
*obfd
= info
->output_bfd
;
3809 flagword new_flags
, old_flags
;
3811 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3814 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3816 (*_bfd_error_handler
)
3817 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3818 " target emulation `%s' does not match `%s'"),
3819 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3823 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3826 if (!riscv_merge_attributes (ibfd
, info
))
3829 /* Check to see if the input BFD actually contains any sections. If not,
3830 its flags may not have been initialized either, but it cannot actually
3831 cause any incompatibility. Do not short-circuit dynamic objects; their
3832 section list may be emptied by elf_link_add_object_symbols.
3834 Also check to see if there are no code sections in the input. In this
3835 case, there is no need to check for code specific flags. */
3836 if (!(ibfd
->flags
& DYNAMIC
))
3838 bool null_input_bfd
= true;
3839 bool only_data_sections
= true;
3842 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3844 null_input_bfd
= false;
3846 if ((bfd_section_flags (sec
)
3847 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3848 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3850 only_data_sections
= false;
3855 if (null_input_bfd
|| only_data_sections
)
3859 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3860 old_flags
= elf_elfheader (obfd
)->e_flags
;
3862 if (!elf_flags_init (obfd
))
3864 elf_flags_init (obfd
) = true;
3865 elf_elfheader (obfd
)->e_flags
= new_flags
;
3869 /* Disallow linking different float ABIs. */
3870 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3872 (*_bfd_error_handler
)
3873 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3874 riscv_float_abi_string (new_flags
),
3875 riscv_float_abi_string (old_flags
));
3879 /* Disallow linking RVE and non-RVE. */
3880 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3882 (*_bfd_error_handler
)
3883 (_("%pB: can't link RVE with other target"), ibfd
);
3887 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3888 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3893 bfd_set_error (bfd_error_bad_value
);
3897 /* Delete some bytes from a section while relaxing. */
3900 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3901 struct bfd_link_info
*link_info
)
3903 unsigned int i
, symcount
;
3904 bfd_vma toaddr
= sec
->size
;
3905 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3906 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3907 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3908 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3909 bfd_byte
*contents
= data
->this_hdr
.contents
;
3911 /* Actually delete the bytes. */
3913 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3915 /* Adjust the location of all of the relocs. Note that we need not
3916 adjust the addends, since all PC-relative references must be against
3917 symbols, which we will adjust below. */
3918 for (i
= 0; i
< sec
->reloc_count
; i
++)
3919 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3920 data
->relocs
[i
].r_offset
-= count
;
3922 /* Adjust the local symbols defined in this section. */
3923 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3925 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3926 if (sym
->st_shndx
== sec_shndx
)
3928 /* If the symbol is in the range of memory we just moved, we
3929 have to adjust its value. */
3930 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3931 sym
->st_value
-= count
;
3933 /* If the symbol *spans* the bytes we just deleted (i.e. its
3934 *end* is in the moved bytes but its *start* isn't), then we
3935 must adjust its size.
3937 This test needs to use the original value of st_value, otherwise
3938 we might accidentally decrease size when deleting bytes right
3939 before the symbol. But since deleted relocs can't span across
3940 symbols, we can't have both a st_value and a st_size decrease,
3941 so it is simpler to just use an else. */
3942 else if (sym
->st_value
<= addr
3943 && sym
->st_value
+ sym
->st_size
> addr
3944 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3945 sym
->st_size
-= count
;
3949 /* Now adjust the global symbols defined in this section. */
3950 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3951 - symtab_hdr
->sh_info
);
3953 for (i
= 0; i
< symcount
; i
++)
3955 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3957 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3958 containing the definition of __wrap_SYMBOL, includes a direct
3959 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3960 the same symbol (which is __wrap_SYMBOL), but still exist as two
3961 different symbols in 'sym_hashes', we don't want to adjust
3962 the global symbol __wrap_SYMBOL twice.
3964 The same problem occurs with symbols that are versioned_hidden, as
3965 foo becomes an alias for foo@BAR, and hence they need the same
3967 if (link_info
->wrap_hash
!= NULL
3968 || sym_hash
->versioned
== versioned_hidden
)
3970 struct elf_link_hash_entry
**cur_sym_hashes
;
3972 /* Loop only over the symbols which have already been checked. */
3973 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3976 /* If the current symbol is identical to 'sym_hash', that means
3977 the symbol was already adjusted (or at least checked). */
3978 if (*cur_sym_hashes
== sym_hash
)
3981 /* Don't adjust the symbol again. */
3982 if (cur_sym_hashes
< &sym_hashes
[i
])
3986 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3987 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3988 && sym_hash
->root
.u
.def
.section
== sec
)
3990 /* As above, adjust the value if needed. */
3991 if (sym_hash
->root
.u
.def
.value
> addr
3992 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3993 sym_hash
->root
.u
.def
.value
-= count
;
3995 /* As above, adjust the size if needed. */
3996 else if (sym_hash
->root
.u
.def
.value
<= addr
3997 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3998 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3999 sym_hash
->size
-= count
;
4006 /* A second format for recording PC-relative hi relocations. This stores the
4007 information required to relax them to GP-relative addresses. */
4009 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
4010 struct riscv_pcgp_hi_reloc
4017 bool undefined_weak
;
4018 riscv_pcgp_hi_reloc
*next
;
4021 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
4022 struct riscv_pcgp_lo_reloc
4025 riscv_pcgp_lo_reloc
*next
;
4030 riscv_pcgp_hi_reloc
*hi
;
4031 riscv_pcgp_lo_reloc
*lo
;
4032 } riscv_pcgp_relocs
;
4034 /* Initialize the pcgp reloc info in P. */
4037 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
4044 /* Free the pcgp reloc info in P. */
4047 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
4048 bfd
*abfd ATTRIBUTE_UNUSED
,
4049 asection
*sec ATTRIBUTE_UNUSED
)
4051 riscv_pcgp_hi_reloc
*c
;
4052 riscv_pcgp_lo_reloc
*l
;
4054 for (c
= p
->hi
; c
!= NULL
; )
4056 riscv_pcgp_hi_reloc
*next
= c
->next
;
4061 for (l
= p
->lo
; l
!= NULL
; )
4063 riscv_pcgp_lo_reloc
*next
= l
->next
;
4069 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
4070 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
4071 relax the corresponding lo part reloc. */
4074 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
4075 bfd_vma hi_addend
, bfd_vma hi_addr
,
4076 unsigned hi_sym
, asection
*sym_sec
,
4077 bool undefined_weak
)
4079 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof (*new));
4082 new->hi_sec_off
= hi_sec_off
;
4083 new->hi_addend
= hi_addend
;
4084 new->hi_addr
= hi_addr
;
4085 new->hi_sym
= hi_sym
;
4086 new->sym_sec
= sym_sec
;
4087 new->undefined_weak
= undefined_weak
;
4093 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4094 This is used by a lo part reloc to find the corresponding hi part reloc. */
4096 static riscv_pcgp_hi_reloc
*
4097 riscv_find_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4099 riscv_pcgp_hi_reloc
*c
;
4101 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
4102 if (c
->hi_sec_off
== hi_sec_off
)
4107 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
4108 This is used to record relocs that can't be relaxed. */
4111 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4113 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof (*new));
4116 new->hi_sec_off
= hi_sec_off
;
4122 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4123 This is used by a hi part reloc to find the corresponding lo part reloc. */
4126 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4128 riscv_pcgp_lo_reloc
*c
;
4130 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
4131 if (c
->hi_sec_off
== hi_sec_off
)
4136 typedef bool (*relax_func_t
) (bfd
*, asection
*, asection
*,
4137 struct bfd_link_info
*,
4138 Elf_Internal_Rela
*,
4139 bfd_vma
, bfd_vma
, bfd_vma
, bool *,
4140 riscv_pcgp_relocs
*,
4141 bool undefined_weak
);
4143 /* Relax AUIPC + JALR into JAL. */
4146 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
4147 struct bfd_link_info
*link_info
,
4148 Elf_Internal_Rela
*rel
,
4150 bfd_vma max_alignment
,
4151 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4153 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4154 bool undefined_weak ATTRIBUTE_UNUSED
)
4156 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4157 bfd_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
4158 bool near_zero
= (symval
+ RISCV_IMM_REACH
/ 2) < RISCV_IMM_REACH
;
4159 bfd_vma auipc
, jalr
;
4160 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4162 /* If the call crosses section boundaries, an alignment directive could
4163 cause the PC-relative offset to later increase, so we need to add in the
4164 max alignment of any section inclusive from the call to the target.
4165 Otherwise, we only need to use the alignment of the current section. */
4166 if (VALID_JTYPE_IMM (foff
))
4168 if (sym_sec
->output_section
== sec
->output_section
4169 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4170 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4171 foff
+= ((bfd_signed_vma
) foff
< 0 ? -max_alignment
: max_alignment
);
4174 /* See if this function call can be shortened. */
4175 if (!VALID_JTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
4178 /* Shorten the function call. */
4179 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
4181 auipc
= bfd_getl32 (contents
+ rel
->r_offset
);
4182 jalr
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
4183 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
4184 rvc
= rvc
&& VALID_CJTYPE_IMM (foff
);
4186 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
4187 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
4191 /* Relax to C.J[AL] rd, addr. */
4192 r_type
= R_RISCV_RVC_JUMP
;
4193 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
4196 else if (VALID_JTYPE_IMM (foff
))
4198 /* Relax to JAL rd, addr. */
4199 r_type
= R_RISCV_JAL
;
4200 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
4204 /* Near zero, relax to JALR rd, x0, addr. */
4205 r_type
= R_RISCV_LO12_I
;
4206 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
4209 /* Replace the R_RISCV_CALL reloc. */
4210 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
4211 /* Replace the AUIPC. */
4212 riscv_put_insn (8 * len
, auipc
, contents
+ rel
->r_offset
);
4214 /* Delete unnecessary JALR. */
4216 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
4220 /* Traverse all output sections and return the max alignment. */
4223 _bfd_riscv_get_max_alignment (asection
*sec
)
4225 unsigned int max_alignment_power
= 0;
4228 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
4230 if (o
->alignment_power
> max_alignment_power
)
4231 max_alignment_power
= o
->alignment_power
;
4234 return (bfd_vma
) 1 << max_alignment_power
;
4237 /* Relax non-PIC global variable references to GP-relative references. */
4240 _bfd_riscv_relax_lui (bfd
*abfd
,
4243 struct bfd_link_info
*link_info
,
4244 Elf_Internal_Rela
*rel
,
4246 bfd_vma max_alignment
,
4247 bfd_vma reserve_size
,
4249 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4250 bool undefined_weak
)
4252 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4253 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4254 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4256 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4260 /* If gp and the symbol are in the same output section, which is not the
4261 abs section, then consider only that output section's alignment. */
4262 struct bfd_link_hash_entry
*h
=
4263 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, false, false,
4265 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4266 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4267 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4270 /* Is the reference in range of x0 or gp?
4271 Valid gp range conservatively because of alignment issue. */
4273 || (VALID_ITYPE_IMM (symval
)
4275 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4277 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4279 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
4280 switch (ELFNN_R_TYPE (rel
->r_info
))
4282 case R_RISCV_LO12_I
:
4285 /* Change the RS1 to zero. */
4286 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4287 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4288 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4291 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4294 case R_RISCV_LO12_S
:
4297 /* Change the RS1 to zero. */
4298 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4299 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4300 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4303 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4307 /* We can delete the unnecessary LUI and reloc. */
4308 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4310 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
4318 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
4319 account for this assuming page alignment at worst. In the presence of
4320 RELRO segment the linker aligns it by one page size, therefore sections
4321 after the segment can be moved more than one page. */
4324 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
4325 && VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
4326 && VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
4327 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
4328 : ELF_MAXPAGESIZE
)))
4330 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
4331 bfd_vma lui
= bfd_getl32 (contents
+ rel
->r_offset
);
4332 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
4333 if (rd
== 0 || rd
== X_SP
)
4336 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
4337 bfd_putl32 (lui
, contents
+ rel
->r_offset
);
4339 /* Replace the R_RISCV_HI20 reloc. */
4340 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
4343 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
4350 /* Relax non-PIC TLS references to TP-relative references. */
4353 _bfd_riscv_relax_tls_le (bfd
*abfd
,
4355 asection
*sym_sec ATTRIBUTE_UNUSED
,
4356 struct bfd_link_info
*link_info
,
4357 Elf_Internal_Rela
*rel
,
4359 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4360 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4362 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
4363 bool undefined_weak ATTRIBUTE_UNUSED
)
4365 /* See if this symbol is in range of tp. */
4366 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
4369 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4370 switch (ELFNN_R_TYPE (rel
->r_info
))
4372 case R_RISCV_TPREL_LO12_I
:
4373 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
4376 case R_RISCV_TPREL_LO12_S
:
4377 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
4380 case R_RISCV_TPREL_HI20
:
4381 case R_RISCV_TPREL_ADD
:
4382 /* We can delete the unnecessary instruction and reloc. */
4383 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4385 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
4392 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs.
4393 Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
4396 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
4398 struct bfd_link_info
*link_info
,
4399 Elf_Internal_Rela
*rel
,
4401 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4402 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4403 bool *again ATTRIBUTE_UNUSED
,
4404 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
4405 bool undefined_weak ATTRIBUTE_UNUSED
)
4407 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4408 bfd_vma alignment
= 1, pos
;
4409 while (alignment
<= rel
->r_addend
)
4412 symval
-= rel
->r_addend
;
4413 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
4414 bfd_vma nop_bytes
= aligned_addr
- symval
;
4416 /* Make sure there are enough NOPs to actually achieve the alignment. */
4417 if (rel
->r_addend
< nop_bytes
)
4420 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
4421 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
4422 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
4423 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
4424 bfd_set_error (bfd_error_bad_value
);
4428 /* Delete the reloc. */
4429 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4431 /* If the number of NOPs is already correct, there's nothing to do. */
4432 if (nop_bytes
== rel
->r_addend
)
4435 /* Write as many RISC-V NOPs as we need. */
4436 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
4437 bfd_putl32 (RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
4439 /* Write a final RVC NOP if need be. */
4440 if (nop_bytes
% 4 != 0)
4441 bfd_putl16 (RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
4443 /* Delete the excess bytes. */
4444 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
4445 rel
->r_addend
- nop_bytes
, link_info
);
4448 /* Relax PC-relative references to GP-relative references. */
4451 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
4454 struct bfd_link_info
*link_info
,
4455 Elf_Internal_Rela
*rel
,
4457 bfd_vma max_alignment
,
4458 bfd_vma reserve_size
,
4459 bool *again ATTRIBUTE_UNUSED
,
4460 riscv_pcgp_relocs
*pcgp_relocs
,
4461 bool undefined_weak
)
4463 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4464 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4466 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4468 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
4469 actual target address. */
4470 riscv_pcgp_hi_reloc hi_reloc
;
4471 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
4472 switch (ELFNN_R_TYPE (rel
->r_info
))
4474 case R_RISCV_PCREL_LO12_I
:
4475 case R_RISCV_PCREL_LO12_S
:
4477 /* If the %lo has an addend, it isn't for the label pointing at the
4478 hi part instruction, but rather for the symbol pointed at by the
4479 hi part instruction. So we must subtract it here for the lookup.
4480 It is still used below in the final symbol address. */
4481 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
4482 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
4486 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
4491 symval
= hi_reloc
.hi_addr
;
4492 sym_sec
= hi_reloc
.sym_sec
;
4494 /* We can not know whether the undefined weak symbol is referenced
4495 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
4496 we have to record the 'undefined_weak' flag when handling the
4497 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
4498 undefined_weak
= hi_reloc
.undefined_weak
;
4502 case R_RISCV_PCREL_HI20
:
4503 /* Mergeable symbols and code might later move out of range. */
4504 if (! undefined_weak
4505 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
4508 /* If the cooresponding lo relocation has already been seen then it's not
4509 safe to relax this relocation. */
4510 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
4521 /* If gp and the symbol are in the same output section, which is not the
4522 abs section, then consider only that output section's alignment. */
4523 struct bfd_link_hash_entry
*h
=
4524 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, false, false,
4526 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4527 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4528 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4531 /* Is the reference in range of x0 or gp?
4532 Valid gp range conservatively because of alignment issue. */
4534 || (VALID_ITYPE_IMM (symval
)
4536 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4538 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4540 unsigned sym
= hi_reloc
.hi_sym
;
4541 switch (ELFNN_R_TYPE (rel
->r_info
))
4543 case R_RISCV_PCREL_LO12_I
:
4546 /* Change the RS1 to zero, and then modify the relocation
4547 type to R_RISCV_LO12_I. */
4548 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4549 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4550 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4551 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
4552 rel
->r_addend
= hi_reloc
.hi_addend
;
4556 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4557 rel
->r_addend
+= hi_reloc
.hi_addend
;
4561 case R_RISCV_PCREL_LO12_S
:
4564 /* Change the RS1 to zero, and then modify the relocation
4565 type to R_RISCV_LO12_S. */
4566 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4567 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4568 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4569 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
4570 rel
->r_addend
= hi_reloc
.hi_addend
;
4574 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4575 rel
->r_addend
+= hi_reloc
.hi_addend
;
4579 case R_RISCV_PCREL_HI20
:
4580 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
4584 ELFNN_R_SYM(rel
->r_info
),
4587 /* We can delete the unnecessary AUIPC and reloc. */
4588 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
4600 /* Delete the bytes for R_RISCV_DELETE. */
4603 _bfd_riscv_relax_delete (bfd
*abfd
,
4605 asection
*sym_sec ATTRIBUTE_UNUSED
,
4606 struct bfd_link_info
*link_info
,
4607 Elf_Internal_Rela
*rel
,
4608 bfd_vma symval ATTRIBUTE_UNUSED
,
4609 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4610 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4612 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4613 bool undefined_weak ATTRIBUTE_UNUSED
)
4615 if (!riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
4618 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4623 /* Called by after_allocation to check if we need to run the whole
4624 relaxations again. */
4627 bfd_elfNN_riscv_restart_relax_sections (struct bfd_link_info
*info
)
4629 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4630 bool restart
= htab
->restart_relax
;
4631 /* Reset the flag. */
4632 htab
->restart_relax
= false;
4638 Pass 0: Shortens code sequences for LUI/CALL/TPREL relocs.
4639 Pass 1: Shortens code sequences for PCREL relocs.
4640 Pass 2: Deletes the bytes that pass 1 made obsolete.
4641 Pass 3: Which cannot be disabled, handles code alignment directives.
4643 The `again` is used to determine whether the relax pass itself needs to
4644 run again. And the `restart_relax` is used to determine if we need to
4645 run the whole relax passes again from 0 to 2. Once we have deleted the
4646 code between relax pass 0 to 2, the restart_relax will be set to TRUE,
4647 and we should run the whole relaxations again to give them more chances
4648 to shorten the code.
4650 Since we can't relax anything else once we start to handle the alignments,
4651 we will only enter into the relax pass 3 when the restart_relax is FALSE. */
4654 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
4655 struct bfd_link_info
*info
,
4658 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
4659 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4660 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
4661 Elf_Internal_Rela
*relocs
;
4664 bfd_vma max_alignment
, reserve_size
= 0;
4665 riscv_pcgp_relocs pcgp_relocs
;
4669 if (bfd_link_relocatable (info
)
4670 || (sec
->flags
& SEC_RELOC
) == 0
4671 || sec
->reloc_count
== 0
4672 || (info
->disable_target_specific_optimizations
4673 && info
->relax_pass
< 2)
4674 || (htab
->restart_relax
4675 && info
->relax_pass
== 3))
4678 riscv_init_pcgp_relocs (&pcgp_relocs
);
4680 /* Read this BFD's relocs if we haven't done so already. */
4682 relocs
= data
->relocs
;
4683 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4684 info
->keep_memory
)))
4689 max_alignment
= htab
->max_alignment
;
4690 if (max_alignment
== (bfd_vma
) -1)
4692 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4693 htab
->max_alignment
= max_alignment
;
4697 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4699 /* Examine and consider relaxing each reloc. */
4700 for (i
= 0; i
< sec
->reloc_count
; i
++)
4703 Elf_Internal_Rela
*rel
= relocs
+ i
;
4704 relax_func_t relax_func
;
4705 int type
= ELFNN_R_TYPE (rel
->r_info
);
4708 bool undefined_weak
= false;
4711 if (info
->relax_pass
== 0)
4713 if (type
== R_RISCV_CALL
4714 || type
== R_RISCV_CALL_PLT
)
4715 relax_func
= _bfd_riscv_relax_call
;
4716 else if (type
== R_RISCV_HI20
4717 || type
== R_RISCV_LO12_I
4718 || type
== R_RISCV_LO12_S
)
4719 relax_func
= _bfd_riscv_relax_lui
;
4720 else if (type
== R_RISCV_TPREL_HI20
4721 || type
== R_RISCV_TPREL_ADD
4722 || type
== R_RISCV_TPREL_LO12_I
4723 || type
== R_RISCV_TPREL_LO12_S
)
4724 relax_func
= _bfd_riscv_relax_tls_le
;
4728 else if (info
->relax_pass
== 1
4729 && !bfd_link_pic (info
)
4730 && (type
== R_RISCV_PCREL_HI20
4731 || type
== R_RISCV_PCREL_LO12_I
4732 || type
== R_RISCV_PCREL_LO12_S
))
4733 relax_func
= _bfd_riscv_relax_pc
;
4734 else if (info
->relax_pass
== 2 && type
== R_RISCV_DELETE
)
4735 relax_func
= _bfd_riscv_relax_delete
;
4736 else if (info
->relax_pass
== 3 && type
== R_RISCV_ALIGN
)
4737 relax_func
= _bfd_riscv_relax_align
;
4741 if (info
->relax_pass
< 2)
4743 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4744 if (i
== sec
->reloc_count
- 1
4745 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4746 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4749 /* Skip over the R_RISCV_RELAX. */
4753 data
->relocs
= relocs
;
4755 /* Read this BFD's contents if we haven't done so already. */
4756 if (!data
->this_hdr
.contents
4757 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4760 /* Read this BFD's symbols if we haven't done so already. */
4761 if (symtab_hdr
->sh_info
!= 0
4762 && !symtab_hdr
->contents
4763 && !(symtab_hdr
->contents
=
4764 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4765 symtab_hdr
->sh_info
,
4766 0, NULL
, NULL
, NULL
)))
4769 /* Get the value of the symbol referred to by the reloc. */
4770 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4772 /* A local symbol. */
4773 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4774 + ELFNN_R_SYM (rel
->r_info
));
4775 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4776 ? 0 : isym
->st_size
- rel
->r_addend
;
4778 /* Relocate against local STT_GNU_IFUNC symbol. we have created
4779 a fake global symbol entry for this, so deal with the local ifunc
4781 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4784 if (isym
->st_shndx
== SHN_UNDEF
)
4785 sym_sec
= sec
, symval
= rel
->r_offset
;
4788 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4789 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4791 /* The purpose of this code is unknown. It breaks linker scripts
4792 for embedded development that place sections at address zero.
4793 This code is believed to be unnecessary. Disabling it but not
4794 yet removing it, in case something breaks. */
4795 if (sec_addr (sym_sec
) == 0)
4798 symval
= isym
->st_value
;
4800 symtype
= ELF_ST_TYPE (isym
->st_info
);
4805 struct elf_link_hash_entry
*h
;
4807 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4808 h
= elf_sym_hashes (abfd
)[indx
];
4810 while (h
->root
.type
== bfd_link_hash_indirect
4811 || h
->root
.type
== bfd_link_hash_warning
)
4812 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4814 /* Disable the relaxation for ifunc. */
4815 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
4818 if (h
->root
.type
== bfd_link_hash_undefweak
4819 && (relax_func
== _bfd_riscv_relax_lui
4820 || relax_func
== _bfd_riscv_relax_pc
))
4822 /* For the lui and auipc relaxations, since the symbol
4823 value of an undefined weak symbol is always be zero,
4824 we can optimize the patterns into a single LI/MV/ADDI
4827 Note that, creating shared libraries and pie output may
4828 break the rule above. Fortunately, since we do not relax
4829 pc relocs when creating shared libraries and pie output,
4830 and the absolute address access for R_RISCV_HI20 isn't
4831 allowed when "-fPIC" is set, the problem of creating shared
4832 libraries can not happen currently. Once we support the
4833 auipc relaxations when creating shared libraries, then we will
4834 need the more rigorous checking for this optimization. */
4835 undefined_weak
= true;
4838 /* This line has to match the check in riscv_elf_relocate_section
4839 in the R_RISCV_CALL[_PLT] case. */
4840 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4842 sym_sec
= htab
->elf
.splt
;
4843 symval
= h
->plt
.offset
;
4845 else if (undefined_weak
)
4848 sym_sec
= bfd_und_section_ptr
;
4850 else if ((h
->root
.type
== bfd_link_hash_defined
4851 || h
->root
.type
== bfd_link_hash_defweak
)
4852 && h
->root
.u
.def
.section
!= NULL
4853 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4855 symval
= h
->root
.u
.def
.value
;
4856 sym_sec
= h
->root
.u
.def
.section
;
4861 if (h
->type
!= STT_FUNC
)
4863 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4867 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4868 && (sym_sec
->flags
& SEC_MERGE
))
4870 /* At this stage in linking, no SEC_MERGE symbol has been
4871 adjusted, so all references to such symbols need to be
4872 passed through _bfd_merged_section_offset. (Later, in
4873 relocate_section, all SEC_MERGE symbols *except* for
4874 section symbols have been adjusted.)
4876 gas may reduce relocations against symbols in SEC_MERGE
4877 sections to a relocation against the section symbol when
4878 the original addend was zero. When the reloc is against
4879 a section symbol we should include the addend in the
4880 offset passed to _bfd_merged_section_offset, since the
4881 location of interest is the original symbol. On the
4882 other hand, an access to "sym+addend" where "sym" is not
4883 a section symbol should not include the addend; Such an
4884 access is presumed to be an offset from "sym"; The
4885 location of interest is just "sym". */
4886 if (symtype
== STT_SECTION
)
4887 symval
+= rel
->r_addend
;
4889 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4890 elf_section_data (sym_sec
)->sec_info
,
4893 if (symtype
!= STT_SECTION
)
4894 symval
+= rel
->r_addend
;
4897 symval
+= rel
->r_addend
;
4899 symval
+= sec_addr (sym_sec
);
4901 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4902 max_alignment
, reserve_size
, again
,
4903 &pcgp_relocs
, undefined_weak
))
4910 if (relocs
!= data
->relocs
)
4912 riscv_free_pcgp_relocs (&pcgp_relocs
, abfd
, sec
);
4915 htab
->restart_relax
= true;
4921 # define PRSTATUS_SIZE 204
4922 # define PRSTATUS_OFFSET_PR_CURSIG 12
4923 # define PRSTATUS_OFFSET_PR_PID 24
4924 # define PRSTATUS_OFFSET_PR_REG 72
4925 # define ELF_GREGSET_T_SIZE 128
4926 # define PRPSINFO_SIZE 128
4927 # define PRPSINFO_OFFSET_PR_PID 16
4928 # define PRPSINFO_OFFSET_PR_FNAME 32
4929 # define PRPSINFO_OFFSET_PR_PSARGS 48
4930 # define PRPSINFO_PR_FNAME_LENGTH 16
4931 # define PRPSINFO_PR_PSARGS_LENGTH 80
4933 # define PRSTATUS_SIZE 376
4934 # define PRSTATUS_OFFSET_PR_CURSIG 12
4935 # define PRSTATUS_OFFSET_PR_PID 32
4936 # define PRSTATUS_OFFSET_PR_REG 112
4937 # define ELF_GREGSET_T_SIZE 256
4938 # define PRPSINFO_SIZE 136
4939 # define PRPSINFO_OFFSET_PR_PID 24
4940 # define PRPSINFO_OFFSET_PR_FNAME 40
4941 # define PRPSINFO_OFFSET_PR_PSARGS 56
4942 # define PRPSINFO_PR_FNAME_LENGTH 16
4943 # define PRPSINFO_PR_PSARGS_LENGTH 80
4946 /* Write PRSTATUS and PRPSINFO note into core file. This will be called
4947 before the generic code in elf.c. By checking the compiler defines we
4948 only perform any action here if the generic code would otherwise not be
4949 able to help us. The intention is that bare metal core dumps (where the
4950 prstatus_t and/or prpsinfo_t might not be available) will use this code,
4951 while non bare metal tools will use the generic elf code. */
4954 riscv_write_core_note (bfd
*abfd ATTRIBUTE_UNUSED
,
4955 char *buf ATTRIBUTE_UNUSED
,
4956 int *bufsiz ATTRIBUTE_UNUSED
,
4957 int note_type ATTRIBUTE_UNUSED
, ...)
4964 #if !defined (HAVE_PRPSINFO_T)
4967 char data
[PRPSINFO_SIZE
] ATTRIBUTE_NONSTRING
;
4970 va_start (ap
, note_type
);
4971 memset (data
, 0, sizeof (data
));
4972 strncpy (data
+ PRPSINFO_OFFSET_PR_FNAME
, va_arg (ap
, const char *),
4973 PRPSINFO_PR_FNAME_LENGTH
);
4974 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
4976 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
4977 -Wstringop-truncation:
4978 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
4980 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
4982 strncpy (data
+ PRPSINFO_OFFSET_PR_PSARGS
, va_arg (ap
, const char *),
4983 PRPSINFO_PR_PSARGS_LENGTH
);
4984 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
4988 return elfcore_write_note (abfd
, buf
, bufsiz
,
4989 "CORE", note_type
, data
, sizeof (data
));
4991 #endif /* !HAVE_PRPSINFO_T */
4993 #if !defined (HAVE_PRSTATUS_T)
4996 char data
[PRSTATUS_SIZE
];
5002 va_start (ap
, note_type
);
5003 memset (data
, 0, sizeof(data
));
5004 pid
= va_arg (ap
, long);
5005 bfd_put_32 (abfd
, pid
, data
+ PRSTATUS_OFFSET_PR_PID
);
5006 cursig
= va_arg (ap
, int);
5007 bfd_put_16 (abfd
, cursig
, data
+ PRSTATUS_OFFSET_PR_CURSIG
);
5008 greg
= va_arg (ap
, const void *);
5009 memcpy (data
+ PRSTATUS_OFFSET_PR_REG
, greg
,
5010 PRSTATUS_SIZE
- PRSTATUS_OFFSET_PR_REG
- ARCH_SIZE
/ 8);
5012 return elfcore_write_note (abfd
, buf
, bufsiz
,
5013 "CORE", note_type
, data
, sizeof (data
));
5015 #endif /* !HAVE_PRSTATUS_T */
5019 /* Support for core dump NOTE sections. */
5022 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
5024 switch (note
->descsz
)
5029 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
5031 elf_tdata (abfd
)->core
->signal
5032 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
5035 elf_tdata (abfd
)->core
->lwpid
5036 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
5040 /* Make a ".reg/999" section. */
5041 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
5042 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
5046 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
5048 switch (note
->descsz
)
5053 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
5055 elf_tdata (abfd
)->core
->pid
5056 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
5059 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
5060 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
,
5061 PRPSINFO_PR_FNAME_LENGTH
);
5064 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
5065 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
,
5066 PRPSINFO_PR_PSARGS_LENGTH
);
5070 /* Note that for some reason, a spurious space is tacked
5071 onto the end of the args in some (at least one anyway)
5072 implementations, so strip it off if it exists. */
5075 char *command
= elf_tdata (abfd
)->core
->command
;
5076 int n
= strlen (command
);
5078 if (0 < n
&& command
[n
- 1] == ' ')
5079 command
[n
- 1] = '\0';
5085 /* Set the right mach type. */
5088 riscv_elf_object_p (bfd
*abfd
)
5090 /* There are only two mach types in RISCV currently. */
5091 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0
5092 || strcmp (abfd
->xvec
->name
, "elf32-bigriscv") == 0)
5093 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
5095 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
5100 /* Determine whether an object attribute tag takes an integer, a
5104 riscv_elf_obj_attrs_arg_type (int tag
)
5106 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
5109 /* PR27584, Omit local and empty symbols since they usually generated
5110 for pcrel relocations. */
5113 riscv_elf_is_target_special_symbol (bfd
*abfd
, asymbol
*sym
)
5115 return (!strcmp (sym
->name
, "")
5116 || _bfd_elf_is_local_label_name (abfd
, sym
->name
));
5119 #define TARGET_LITTLE_SYM riscv_elfNN_vec
5120 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
5121 #define TARGET_BIG_SYM riscv_elfNN_be_vec
5122 #define TARGET_BIG_NAME "elfNN-bigriscv"
5124 #define elf_backend_reloc_type_class riscv_reloc_type_class
5126 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
5127 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
5128 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
5129 #define bfd_elfNN_bfd_merge_private_bfd_data \
5130 _bfd_riscv_elf_merge_private_bfd_data
5131 #define bfd_elfNN_bfd_is_target_special_symbol riscv_elf_is_target_special_symbol
5133 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
5134 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
5135 #define elf_backend_check_relocs riscv_elf_check_relocs
5136 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
5137 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
5138 #define elf_backend_relocate_section riscv_elf_relocate_section
5139 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
5140 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
5141 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
5142 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
5143 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
5144 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
5145 #define elf_backend_object_p riscv_elf_object_p
5146 #define elf_backend_write_core_note riscv_write_core_note
5147 #define elf_info_to_howto_rel NULL
5148 #define elf_info_to_howto riscv_info_to_howto_rela
5149 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
5150 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
5152 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5154 #define elf_backend_can_gc_sections 1
5155 #define elf_backend_can_refcount 1
5156 #define elf_backend_want_got_plt 1
5157 #define elf_backend_plt_readonly 1
5158 #define elf_backend_plt_alignment 4
5159 #define elf_backend_want_plt_sym 1
5160 #define elf_backend_got_header_size (ARCH_SIZE / 8)
5161 #define elf_backend_want_dynrelro 1
5162 #define elf_backend_rela_normal 1
5163 #define elf_backend_default_execstack 0
5165 #undef elf_backend_obj_attrs_vendor
5166 #define elf_backend_obj_attrs_vendor "riscv"
5167 #undef elf_backend_obj_attrs_arg_type
5168 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
5169 #undef elf_backend_obj_attrs_section_type
5170 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
5171 #undef elf_backend_obj_attrs_section
5172 #define elf_backend_obj_attrs_section ".riscv.attributes"
5174 #include "elfNN-target.h"