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"
44 /* Internal relocations used exclusively by the relaxation pass. */
45 #define R_RISCV_DELETE (R_RISCV_max + 1)
49 #define MINUS_ONE ((bfd_vma)0 - 1)
51 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
53 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
55 /* The name of the dynamic interpreter. This is put in the .interp
58 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
59 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
61 #define ELF_ARCH bfd_arch_riscv
62 #define ELF_TARGET_ID RISCV_ELF_DATA
63 #define ELF_MACHINE_CODE EM_RISCV
64 #define ELF_MAXPAGESIZE 0x1000
65 #define ELF_COMMONPAGESIZE 0x1000
67 /* RISC-V ELF linker hash entry. */
69 struct riscv_elf_link_hash_entry
71 struct elf_link_hash_entry elf
;
81 #define riscv_elf_hash_entry(ent) \
82 ((struct riscv_elf_link_hash_entry *) (ent))
84 struct _bfd_riscv_elf_obj_tdata
86 struct elf_obj_tdata root
;
88 /* tls_type for each local got entry. */
89 char *local_got_tls_type
;
92 #define _bfd_riscv_elf_tdata(abfd) \
93 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
95 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
96 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
98 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
99 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
100 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
102 #define is_riscv_elf(bfd) \
103 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
104 && elf_tdata (bfd) != NULL \
105 && elf_object_id (bfd) == RISCV_ELF_DATA)
108 elfNN_riscv_mkobject (bfd
*abfd
)
110 return bfd_elf_allocate_object (abfd
,
111 sizeof (struct _bfd_riscv_elf_obj_tdata
),
115 #include "elf/common.h"
116 #include "elf/internal.h"
118 struct riscv_elf_link_hash_table
120 struct elf_link_hash_table elf
;
122 /* Short-cuts to get to dynamic linker sections. */
125 /* The max alignment of output sections. */
126 bfd_vma max_alignment
;
128 /* Used by local STT_GNU_IFUNC symbols. */
129 htab_t loc_hash_table
;
130 void * loc_hash_memory
;
132 /* The index of the last unused .rel.iplt slot. */
133 bfd_vma last_iplt_index
;
136 /* Instruction access functions. */
137 #define riscv_get_insn(bits, ptr) \
138 ((bits) == 16 ? bfd_getl16 (ptr) \
139 : (bits) == 32 ? bfd_getl32 (ptr) \
140 : (bits) == 64 ? bfd_getl64 (ptr) \
141 : (abort (), (bfd_vma) - 1))
142 #define riscv_put_insn(bits, val, ptr) \
143 ((bits) == 16 ? bfd_putl16 (val, ptr) \
144 : (bits) == 32 ? bfd_putl32 (val, ptr) \
145 : (bits) == 64 ? bfd_putl64 (val, ptr) \
146 : (abort (), (void) 0))
148 /* Get the RISC-V ELF linker hash table from a link_info structure. */
149 #define riscv_elf_hash_table(p) \
150 ((is_elf_hash_table ((p)->hash) \
151 && elf_hash_table_id (elf_hash_table (p)) == RISCV_ELF_DATA) \
152 ? (struct riscv_elf_link_hash_table *) (p)->hash : NULL)
155 riscv_info_to_howto_rela (bfd
*abfd
,
157 Elf_Internal_Rela
*dst
)
159 cache_ptr
->howto
= riscv_elf_rtype_to_howto (abfd
, ELFNN_R_TYPE (dst
->r_info
));
160 return cache_ptr
->howto
!= NULL
;
164 riscv_elf_append_rela (bfd
*abfd
, asection
*s
, Elf_Internal_Rela
*rel
)
166 const struct elf_backend_data
*bed
;
169 bed
= get_elf_backend_data (abfd
);
170 loc
= s
->contents
+ (s
->reloc_count
++ * bed
->s
->sizeof_rela
);
171 bed
->s
->swap_reloca_out (abfd
, rel
, loc
);
174 /* Return true if a relocation is modifying an instruction. */
177 riscv_is_insn_reloc (const reloc_howto_type
*howto
)
179 /* Heuristic: A multibyte destination with a nontrivial mask
181 return (howto
->bitsize
> 8
182 && howto
->dst_mask
!= 0
183 && ~(howto
->dst_mask
| (howto
->bitsize
< sizeof(bfd_vma
) * CHAR_BIT
184 ? (MINUS_ONE
<< howto
->bitsize
) : (bfd_vma
)0)) != 0);
188 #define PLT_HEADER_INSNS 8
189 #define PLT_ENTRY_INSNS 4
190 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
191 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
192 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
193 /* Reserve two entries of GOTPLT for ld.so, one is used for PLT resolver,
194 the other is used for link map. Other targets also reserve one more
195 entry used for runtime profile? */
196 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
198 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
201 # define MATCH_LREG MATCH_LW
203 # define MATCH_LREG MATCH_LD
206 /* Generate a PLT header. */
209 riscv_make_plt_header (bfd
*output_bfd
, bfd_vma gotplt_addr
, bfd_vma addr
,
212 bfd_vma gotplt_offset_high
= RISCV_PCREL_HIGH_PART (gotplt_addr
, addr
);
213 bfd_vma gotplt_offset_low
= RISCV_PCREL_LOW_PART (gotplt_addr
, addr
);
215 /* RVE has no t3 register, so this won't work, and is not supported. */
216 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
218 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
223 /* auipc t2, %hi(.got.plt)
224 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
225 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
226 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
227 addi t0, t2, %lo(.got.plt) # &.got.plt
228 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
229 l[w|d] t0, PTRSIZE(t0) # link map
232 entry
[0] = RISCV_UTYPE (AUIPC
, X_T2
, gotplt_offset_high
);
233 entry
[1] = RISCV_RTYPE (SUB
, X_T1
, X_T1
, X_T3
);
234 entry
[2] = RISCV_ITYPE (LREG
, X_T3
, X_T2
, gotplt_offset_low
);
235 entry
[3] = RISCV_ITYPE (ADDI
, X_T1
, X_T1
, (uint32_t) -(PLT_HEADER_SIZE
+ 12));
236 entry
[4] = RISCV_ITYPE (ADDI
, X_T0
, X_T2
, gotplt_offset_low
);
237 entry
[5] = RISCV_ITYPE (SRLI
, X_T1
, X_T1
, 4 - RISCV_ELF_LOG_WORD_BYTES
);
238 entry
[6] = RISCV_ITYPE (LREG
, X_T0
, X_T0
, RISCV_ELF_WORD_BYTES
);
239 entry
[7] = RISCV_ITYPE (JALR
, 0, X_T3
, 0);
244 /* Generate a PLT entry. */
247 riscv_make_plt_entry (bfd
*output_bfd
, bfd_vma got
, bfd_vma addr
,
250 /* RVE has no t3 register, so this won't work, and is not supported. */
251 if (elf_elfheader (output_bfd
)->e_flags
& EF_RISCV_RVE
)
253 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
258 /* auipc t3, %hi(.got.plt entry)
259 l[w|d] t3, %lo(.got.plt entry)(t3)
263 entry
[0] = RISCV_UTYPE (AUIPC
, X_T3
, RISCV_PCREL_HIGH_PART (got
, addr
));
264 entry
[1] = RISCV_ITYPE (LREG
, X_T3
, X_T3
, RISCV_PCREL_LOW_PART (got
, addr
));
265 entry
[2] = RISCV_ITYPE (JALR
, X_T1
, X_T3
, 0);
266 entry
[3] = RISCV_NOP
;
271 /* Create an entry in an RISC-V ELF linker hash table. */
273 static struct bfd_hash_entry
*
274 link_hash_newfunc (struct bfd_hash_entry
*entry
,
275 struct bfd_hash_table
*table
, const char *string
)
277 /* Allocate the structure if it has not already been allocated by a
282 bfd_hash_allocate (table
,
283 sizeof (struct riscv_elf_link_hash_entry
));
288 /* Call the allocation method of the superclass. */
289 entry
= _bfd_elf_link_hash_newfunc (entry
, table
, string
);
292 struct riscv_elf_link_hash_entry
*eh
;
294 eh
= (struct riscv_elf_link_hash_entry
*) entry
;
295 eh
->tls_type
= GOT_UNKNOWN
;
301 /* Compute a hash of a local hash entry. We use elf_link_hash_entry
302 for local symbol so that we can handle local STT_GNU_IFUNC symbols
303 as global symbol. We reuse indx and dynstr_index for local symbol
304 hash since they aren't used by global symbols in this backend. */
307 riscv_elf_local_htab_hash (const void *ptr
)
309 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) ptr
;
310 return ELF_LOCAL_SYMBOL_HASH (h
->indx
, h
->dynstr_index
);
313 /* Compare local hash entries. */
316 riscv_elf_local_htab_eq (const void *ptr1
, const void *ptr2
)
318 struct elf_link_hash_entry
*h1
= (struct elf_link_hash_entry
*) ptr1
;
319 struct elf_link_hash_entry
*h2
= (struct elf_link_hash_entry
*) ptr2
;
321 return h1
->indx
== h2
->indx
&& h1
->dynstr_index
== h2
->dynstr_index
;
324 /* Find and/or create a hash entry for local symbol. */
326 static struct elf_link_hash_entry
*
327 riscv_elf_get_local_sym_hash (struct riscv_elf_link_hash_table
*htab
,
328 bfd
*abfd
, const Elf_Internal_Rela
*rel
,
331 struct riscv_elf_link_hash_entry eh
, *ret
;
332 asection
*sec
= abfd
->sections
;
333 hashval_t h
= ELF_LOCAL_SYMBOL_HASH (sec
->id
,
334 ELFNN_R_SYM (rel
->r_info
));
337 eh
.elf
.indx
= sec
->id
;
338 eh
.elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
339 slot
= htab_find_slot_with_hash (htab
->loc_hash_table
, &eh
, h
,
340 create
? INSERT
: NO_INSERT
);
347 ret
= (struct riscv_elf_link_hash_entry
*) *slot
;
351 ret
= (struct riscv_elf_link_hash_entry
*)
352 objalloc_alloc ((struct objalloc
*) htab
->loc_hash_memory
,
353 sizeof (struct riscv_elf_link_hash_entry
));
356 memset (ret
, 0, sizeof (*ret
));
357 ret
->elf
.indx
= sec
->id
;
358 ret
->elf
.dynstr_index
= ELFNN_R_SYM (rel
->r_info
);
359 ret
->elf
.dynindx
= -1;
365 /* Destroy a RISC-V elf linker hash table. */
368 riscv_elf_link_hash_table_free (bfd
*obfd
)
370 struct riscv_elf_link_hash_table
*ret
371 = (struct riscv_elf_link_hash_table
*) obfd
->link
.hash
;
373 if (ret
->loc_hash_table
)
374 htab_delete (ret
->loc_hash_table
);
375 if (ret
->loc_hash_memory
)
376 objalloc_free ((struct objalloc
*) ret
->loc_hash_memory
);
378 _bfd_elf_link_hash_table_free (obfd
);
381 /* Create a RISC-V ELF linker hash table. */
383 static struct bfd_link_hash_table
*
384 riscv_elf_link_hash_table_create (bfd
*abfd
)
386 struct riscv_elf_link_hash_table
*ret
;
387 size_t amt
= sizeof (struct riscv_elf_link_hash_table
);
389 ret
= (struct riscv_elf_link_hash_table
*) bfd_zmalloc (amt
);
393 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
, link_hash_newfunc
,
394 sizeof (struct riscv_elf_link_hash_entry
),
401 ret
->max_alignment
= (bfd_vma
) -1;
403 /* Create hash table for local ifunc. */
404 ret
->loc_hash_table
= htab_try_create (1024,
405 riscv_elf_local_htab_hash
,
406 riscv_elf_local_htab_eq
,
408 ret
->loc_hash_memory
= objalloc_create ();
409 if (!ret
->loc_hash_table
|| !ret
->loc_hash_memory
)
411 riscv_elf_link_hash_table_free (abfd
);
414 ret
->elf
.root
.hash_table_free
= riscv_elf_link_hash_table_free
;
416 return &ret
->elf
.root
;
419 /* Create the .got section. */
422 riscv_elf_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
426 struct elf_link_hash_entry
*h
;
427 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
428 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
430 /* This function may be called more than once. */
431 if (htab
->sgot
!= NULL
)
434 flags
= bed
->dynamic_sec_flags
;
436 s
= bfd_make_section_anyway_with_flags (abfd
,
437 (bed
->rela_plts_and_copies_p
438 ? ".rela.got" : ".rel.got"),
439 (bed
->dynamic_sec_flags
442 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
446 s
= s_got
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
448 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
452 /* The first bit of the global offset table is the header. */
453 s
->size
+= bed
->got_header_size
;
455 if (bed
->want_got_plt
)
457 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
459 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
463 /* Reserve room for the header. */
464 s
->size
+= GOTPLT_HEADER_SIZE
;
467 if (bed
->want_got_sym
)
469 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
470 section. We don't do this in the linker script because we don't want
471 to define the symbol if we are not creating a global offset
473 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s_got
,
474 "_GLOBAL_OFFSET_TABLE_");
475 elf_hash_table (info
)->hgot
= h
;
483 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
484 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
488 riscv_elf_create_dynamic_sections (bfd
*dynobj
,
489 struct bfd_link_info
*info
)
491 struct riscv_elf_link_hash_table
*htab
;
493 htab
= riscv_elf_hash_table (info
);
494 BFD_ASSERT (htab
!= NULL
);
496 if (!riscv_elf_create_got_section (dynobj
, info
))
499 if (!_bfd_elf_create_dynamic_sections (dynobj
, info
))
502 if (!bfd_link_pic (info
))
504 /* Technically, this section doesn't have contents. It is used as the
505 target of TLS copy relocs, to copy TLS data from shared libraries into
506 the executable. However, if we don't mark it as loadable, then it
507 matches the IS_TBSS test in ldlang.c, and there is no run-time address
508 space allocated for it even though it has SEC_ALLOC. That test is
509 correct for .tbss, but not correct for this section. There is also
510 a second problem that having a section with no contents can only work
511 if it comes after all sections with contents in the same segment,
512 but the linker script does not guarantee that. This is just mixed in
513 with other .tdata.* sections. We can fix both problems by lying and
514 saying that there are contents. This section is expected to be small
515 so this should not cause a significant extra program startup cost. */
517 bfd_make_section_anyway_with_flags (dynobj
, ".tdata.dyn",
518 (SEC_ALLOC
| SEC_THREAD_LOCAL
519 | SEC_LOAD
| SEC_DATA
521 | SEC_LINKER_CREATED
));
524 if (!htab
->elf
.splt
|| !htab
->elf
.srelplt
|| !htab
->elf
.sdynbss
525 || (!bfd_link_pic (info
) && (!htab
->elf
.srelbss
|| !htab
->sdyntdata
)))
531 /* Copy the extra info we tack onto an elf_link_hash_entry. */
534 riscv_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
535 struct elf_link_hash_entry
*dir
,
536 struct elf_link_hash_entry
*ind
)
538 struct riscv_elf_link_hash_entry
*edir
, *eind
;
540 edir
= (struct riscv_elf_link_hash_entry
*) dir
;
541 eind
= (struct riscv_elf_link_hash_entry
*) ind
;
543 if (ind
->root
.type
== bfd_link_hash_indirect
544 && dir
->got
.refcount
<= 0)
546 edir
->tls_type
= eind
->tls_type
;
547 eind
->tls_type
= GOT_UNKNOWN
;
549 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
553 riscv_elf_record_tls_type (bfd
*abfd
, struct elf_link_hash_entry
*h
,
554 unsigned long symndx
, char tls_type
)
556 char *new_tls_type
= &_bfd_riscv_elf_tls_type (abfd
, h
, symndx
);
558 *new_tls_type
|= tls_type
;
559 if ((*new_tls_type
& GOT_NORMAL
) && (*new_tls_type
& ~GOT_NORMAL
))
561 (*_bfd_error_handler
)
562 (_("%pB: `%s' accessed both as normal and thread local symbol"),
563 abfd
, h
? h
->root
.root
.string
: "<local>");
570 riscv_elf_record_got_reference (bfd
*abfd
, struct bfd_link_info
*info
,
571 struct elf_link_hash_entry
*h
, long symndx
)
573 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
574 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
576 if (htab
->elf
.sgot
== NULL
)
578 if (!riscv_elf_create_got_section (htab
->elf
.dynobj
, info
))
584 h
->got
.refcount
+= 1;
588 /* This is a global offset table entry for a local symbol. */
589 if (elf_local_got_refcounts (abfd
) == NULL
)
591 bfd_size_type size
= symtab_hdr
->sh_info
* (sizeof (bfd_vma
) + 1);
592 if (!(elf_local_got_refcounts (abfd
) = bfd_zalloc (abfd
, size
)))
594 _bfd_riscv_elf_local_got_tls_type (abfd
)
595 = (char *) (elf_local_got_refcounts (abfd
) + symtab_hdr
->sh_info
);
597 elf_local_got_refcounts (abfd
) [symndx
] += 1;
603 bad_static_reloc (bfd
*abfd
, unsigned r_type
, struct elf_link_hash_entry
*h
)
605 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
607 /* We propably can improve the information to tell users that they
608 should be recompile the code with -fPIC or -fPIE, just like what
610 (*_bfd_error_handler
)
611 (_("%pB: relocation %s against `%s' can not be used when making a shared "
612 "object; recompile with -fPIC"),
613 abfd
, r
? r
->name
: _("<unknown>"),
614 h
!= NULL
? h
->root
.root
.string
: "a local symbol");
615 bfd_set_error (bfd_error_bad_value
);
619 /* Look through the relocs for a section during the first phase, and
620 allocate space in the global offset table or procedure linkage
624 riscv_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
625 asection
*sec
, const Elf_Internal_Rela
*relocs
)
627 struct riscv_elf_link_hash_table
*htab
;
628 Elf_Internal_Shdr
*symtab_hdr
;
629 struct elf_link_hash_entry
**sym_hashes
;
630 const Elf_Internal_Rela
*rel
;
631 asection
*sreloc
= NULL
;
633 if (bfd_link_relocatable (info
))
636 htab
= riscv_elf_hash_table (info
);
637 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
638 sym_hashes
= elf_sym_hashes (abfd
);
640 if (htab
->elf
.dynobj
== NULL
)
641 htab
->elf
.dynobj
= abfd
;
643 for (rel
= relocs
; rel
< relocs
+ sec
->reloc_count
; rel
++)
646 unsigned int r_symndx
;
647 struct elf_link_hash_entry
*h
;
649 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
650 r_type
= ELFNN_R_TYPE (rel
->r_info
);
652 if (r_symndx
>= NUM_SHDR_ENTRIES (symtab_hdr
))
654 (*_bfd_error_handler
) (_("%pB: bad symbol index: %d"),
659 if (r_symndx
< symtab_hdr
->sh_info
)
661 /* A local symbol. */
662 Elf_Internal_Sym
*isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
667 /* Check relocation against local STT_GNU_IFUNC symbol. */
668 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
670 h
= riscv_elf_get_local_sym_hash (htab
, abfd
, rel
, TRUE
);
674 /* Fake STT_GNU_IFUNC global symbol. */
675 h
->root
.root
.string
= bfd_elf_sym_name (abfd
, symtab_hdr
,
677 h
->type
= STT_GNU_IFUNC
;
681 h
->root
.type
= bfd_link_hash_defined
;
688 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
689 while (h
->root
.type
== bfd_link_hash_indirect
690 || h
->root
.type
== bfd_link_hash_warning
)
691 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
701 case R_RISCV_CALL_PLT
:
703 case R_RISCV_GOT_HI20
:
704 case R_RISCV_PCREL_HI20
:
705 /* Create the ifunc sections, iplt and ipltgot, for static
707 if (h
->type
== STT_GNU_IFUNC
708 && !_bfd_elf_create_ifunc_sections (htab
->elf
.dynobj
, info
))
716 /* It is referenced by a non-shared object. */
722 case R_RISCV_TLS_GD_HI20
:
723 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
724 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_GD
))
728 case R_RISCV_TLS_GOT_HI20
:
729 if (bfd_link_pic (info
))
730 info
->flags
|= DF_STATIC_TLS
;
731 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
732 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_IE
))
736 case R_RISCV_GOT_HI20
:
737 if (!riscv_elf_record_got_reference (abfd
, info
, h
, r_symndx
)
738 || !riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_NORMAL
))
743 case R_RISCV_CALL_PLT
:
744 /* These symbol requires a procedure linkage table entry.
745 We actually build the entry in adjust_dynamic_symbol,
746 because these might be a case of linking PIC code without
747 linking in any dynamic objects, in which case we don't
748 need to generate a procedure linkage table after all. */
750 /* If it is a local symbol, then we resolve it directly
751 without creating a PLT entry. */
756 h
->plt
.refcount
+= 1;
759 case R_RISCV_PCREL_HI20
:
761 && h
->type
== STT_GNU_IFUNC
)
764 h
->pointer_equality_needed
= 1;
766 /* We don't use the PCREL_HI20 in the data section,
767 so we always need the plt when it refers to
769 h
->plt
.refcount
+= 1;
775 case R_RISCV_RVC_BRANCH
:
776 case R_RISCV_RVC_JUMP
:
777 /* In shared libraries and pie, these relocs are known
779 if (bfd_link_pic (info
))
783 case R_RISCV_TPREL_HI20
:
784 if (!bfd_link_executable (info
))
785 return bad_static_reloc (abfd
, r_type
, h
);
787 riscv_elf_record_tls_type (abfd
, h
, r_symndx
, GOT_TLS_LE
);
791 if (bfd_link_pic (info
))
792 return bad_static_reloc (abfd
, r_type
, h
);
796 case R_RISCV_JUMP_SLOT
:
797 case R_RISCV_RELATIVE
:
805 && (!bfd_link_pic (info
)
806 || h
->type
== STT_GNU_IFUNC
))
808 /* This reloc might not bind locally. */
810 h
->pointer_equality_needed
= 1;
813 || (sec
->flags
& (SEC_CODE
| SEC_READONLY
)) != 0)
815 /* We may need a .plt entry if the symbol is a function
816 defined in a shared lib or is a function referenced
817 from the code or read-only section. */
818 h
->plt
.refcount
+= 1;
822 /* If we are creating a shared library, and this is a reloc
823 against a global symbol, or a non PC relative reloc
824 against a local symbol, then we need to copy the reloc
825 into the shared library. However, if we are linking with
826 -Bsymbolic, we do not need to copy a reloc against a
827 global symbol which is defined in an object we are
828 including in the link (i.e., DEF_REGULAR is set). At
829 this point we have not seen all the input files, so it is
830 possible that DEF_REGULAR is not set now but will be set
831 later (it is never cleared). In case of a weak definition,
832 DEF_REGULAR may be cleared later by a strong definition in
833 a shared library. We account for that possibility below by
834 storing information in the relocs_copied field of the hash
835 table entry. A similar situation occurs when creating
836 shared libraries and symbol visibility changes render the
839 If on the other hand, we are creating an executable, we
840 may need to keep relocations for symbols satisfied by a
841 dynamic library if we manage to avoid copy relocs for the
844 Generate dynamic pointer relocation against STT_GNU_IFUNC
845 symbol in the non-code section (R_RISCV_32/R_RISCV_64). */
846 reloc_howto_type
* r
= riscv_elf_rtype_to_howto (abfd
, r_type
);
848 if ((bfd_link_pic (info
)
849 && (sec
->flags
& SEC_ALLOC
) != 0
850 && ((r
!= NULL
&& !r
->pc_relative
)
853 || h
->root
.type
== bfd_link_hash_defweak
854 || !h
->def_regular
))))
855 || (!bfd_link_pic (info
)
856 && (sec
->flags
& SEC_ALLOC
) != 0
858 && (h
->root
.type
== bfd_link_hash_defweak
860 || (!bfd_link_pic (info
)
862 && h
->type
== STT_GNU_IFUNC
863 && (sec
->flags
& SEC_CODE
) == 0))
865 struct elf_dyn_relocs
*p
;
866 struct elf_dyn_relocs
**head
;
868 /* When creating a shared object, we must copy these
869 relocs into the output file. We create a reloc
870 section in dynobj and make room for the reloc. */
873 sreloc
= _bfd_elf_make_dynamic_reloc_section
874 (sec
, htab
->elf
.dynobj
, RISCV_ELF_LOG_WORD_BYTES
,
875 abfd
, /*rela?*/ TRUE
);
881 /* If this is a global symbol, we count the number of
882 relocations we need for this symbol. */
884 head
= &h
->dyn_relocs
;
887 /* Track dynamic relocs needed for local syms too.
888 We really need local syms available to do this
893 Elf_Internal_Sym
*isym
;
895 isym
= bfd_sym_from_r_symndx (&htab
->elf
.sym_cache
,
900 s
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
904 vpp
= &elf_section_data (s
)->local_dynrel
;
905 head
= (struct elf_dyn_relocs
**) vpp
;
909 if (p
== NULL
|| p
->sec
!= sec
)
911 size_t amt
= sizeof *p
;
912 p
= ((struct elf_dyn_relocs
*)
913 bfd_alloc (htab
->elf
.dynobj
, amt
));
924 p
->pc_count
+= r
== NULL
? 0 : r
->pc_relative
;
929 case R_RISCV_GNU_VTINHERIT
:
930 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
934 case R_RISCV_GNU_VTENTRY
:
935 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
948 riscv_elf_gc_mark_hook (asection
*sec
,
949 struct bfd_link_info
*info
,
950 Elf_Internal_Rela
*rel
,
951 struct elf_link_hash_entry
*h
,
952 Elf_Internal_Sym
*sym
)
955 switch (ELFNN_R_TYPE (rel
->r_info
))
957 case R_RISCV_GNU_VTINHERIT
:
958 case R_RISCV_GNU_VTENTRY
:
962 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
965 /* Adjust a symbol defined by a dynamic object and referenced by a
966 regular object. The current definition is in some section of the
967 dynamic object, but we're not including those sections. We have to
968 change the definition to something the rest of the link can
972 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
973 struct elf_link_hash_entry
*h
)
975 struct riscv_elf_link_hash_table
*htab
;
976 struct riscv_elf_link_hash_entry
* eh
;
980 htab
= riscv_elf_hash_table (info
);
981 BFD_ASSERT (htab
!= NULL
);
983 dynobj
= htab
->elf
.dynobj
;
985 /* Make sure we know what is going on here. */
986 BFD_ASSERT (dynobj
!= NULL
988 || h
->type
== STT_GNU_IFUNC
992 && !h
->def_regular
)));
994 /* If this is a function, put it in the procedure linkage table. We
995 will fill in the contents of the procedure linkage table later
996 (although we could actually do it here). */
997 if (h
->type
== STT_FUNC
|| h
->type
== STT_GNU_IFUNC
|| h
->needs_plt
)
999 if (h
->plt
.refcount
<= 0
1000 || (h
->type
!= STT_GNU_IFUNC
1001 && (SYMBOL_CALLS_LOCAL (info
, h
)
1002 || (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1003 && h
->root
.type
== bfd_link_hash_undefweak
))))
1005 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
1006 input file, but the symbol was never referred to by a dynamic
1007 object, or if all references were garbage collected. In such
1008 a case, we don't actually need to build a PLT entry. */
1009 h
->plt
.offset
= (bfd_vma
) -1;
1016 h
->plt
.offset
= (bfd_vma
) -1;
1018 /* If this is a weak symbol, and there is a real definition, the
1019 processor independent code will have arranged for us to see the
1020 real definition first, and we can just use the same value. */
1021 if (h
->is_weakalias
)
1023 struct elf_link_hash_entry
*def
= weakdef (h
);
1024 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
1025 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
1026 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
1030 /* This is a reference to a symbol defined by a dynamic object which
1031 is not a function. */
1033 /* If we are creating a shared library, we must presume that the
1034 only references to the symbol are via the global offset table.
1035 For such cases we need not do anything here; the relocations will
1036 be handled correctly by relocate_section. */
1037 if (bfd_link_pic (info
))
1040 /* If there are no references to this symbol that do not use the
1041 GOT, we don't need to generate a copy reloc. */
1042 if (!h
->non_got_ref
)
1045 /* If -z nocopyreloc was given, we won't generate them either. */
1046 if (info
->nocopyreloc
)
1052 /* If we don't find any dynamic relocs in read-only sections, then
1053 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1054 if (!_bfd_elf_readonly_dynrelocs (h
))
1060 /* We must allocate the symbol in our .dynbss section, which will
1061 become part of the .bss section of the executable. There will be
1062 an entry for this symbol in the .dynsym section. The dynamic
1063 object will contain position independent code, so all references
1064 from the dynamic object to this symbol will go through the global
1065 offset table. The dynamic linker will use the .dynsym entry to
1066 determine the address it must put in the global offset table, so
1067 both the dynamic object and the regular object will refer to the
1068 same memory location for the variable. */
1070 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
1071 to copy the initial value out of the dynamic object and into the
1072 runtime process image. We need to remember the offset into the
1073 .rel.bss section we are going to use. */
1074 eh
= (struct riscv_elf_link_hash_entry
*) h
;
1075 if (eh
->tls_type
& ~GOT_NORMAL
)
1077 s
= htab
->sdyntdata
;
1078 srel
= htab
->elf
.srelbss
;
1080 else if ((h
->root
.u
.def
.section
->flags
& SEC_READONLY
) != 0)
1082 s
= htab
->elf
.sdynrelro
;
1083 srel
= htab
->elf
.sreldynrelro
;
1087 s
= htab
->elf
.sdynbss
;
1088 srel
= htab
->elf
.srelbss
;
1090 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
1092 srel
->size
+= sizeof (ElfNN_External_Rela
);
1096 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
1099 /* Allocate space in .plt, .got and associated reloc sections for
1103 allocate_dynrelocs (struct elf_link_hash_entry
*h
, void *inf
)
1105 struct bfd_link_info
*info
;
1106 struct riscv_elf_link_hash_table
*htab
;
1107 struct elf_dyn_relocs
*p
;
1109 if (h
->root
.type
== bfd_link_hash_indirect
)
1112 info
= (struct bfd_link_info
*) inf
;
1113 htab
= riscv_elf_hash_table (info
);
1114 BFD_ASSERT (htab
!= NULL
);
1116 /* When we are generating pde, make sure gp symbol is output as a
1117 dynamic symbol. Then ld.so can set the gp register earlier, before
1118 resolving the ifunc. */
1119 if (!bfd_link_pic (info
)
1120 && htab
->elf
.dynamic_sections_created
1121 && strcmp (h
->root
.root
.string
, RISCV_GP_SYMBOL
) == 0
1122 && !bfd_elf_link_record_dynamic_symbol (info
, h
))
1125 /* Since STT_GNU_IFUNC symbols must go through PLT, we handle them
1126 in the allocate_ifunc_dynrelocs and allocate_local_ifunc_dynrelocs,
1127 if they are defined and referenced in a non-shared object. */
1128 if (h
->type
== STT_GNU_IFUNC
1131 else if (htab
->elf
.dynamic_sections_created
1132 && h
->plt
.refcount
> 0)
1134 /* Make sure this symbol is output as a dynamic symbol.
1135 Undefined weak syms won't yet be marked as dynamic. */
1136 if (h
->dynindx
== -1
1137 && !h
->forced_local
)
1139 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1143 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info
), h
))
1145 asection
*s
= htab
->elf
.splt
;
1148 s
->size
= PLT_HEADER_SIZE
;
1150 h
->plt
.offset
= s
->size
;
1152 /* Make room for this entry. */
1153 s
->size
+= PLT_ENTRY_SIZE
;
1155 /* We also need to make an entry in the .got.plt section. */
1156 htab
->elf
.sgotplt
->size
+= GOT_ENTRY_SIZE
;
1158 /* We also need to make an entry in the .rela.plt section. */
1159 htab
->elf
.srelplt
->size
+= sizeof (ElfNN_External_Rela
);
1161 /* If this symbol is not defined in a regular file, and we are
1162 not generating a shared library, then set the symbol to this
1163 location in the .plt. This is required to make function
1164 pointers compare as equal between the normal executable and
1165 the shared library. */
1166 if (! bfd_link_pic (info
)
1169 h
->root
.u
.def
.section
= s
;
1170 h
->root
.u
.def
.value
= h
->plt
.offset
;
1175 h
->plt
.offset
= (bfd_vma
) -1;
1181 h
->plt
.offset
= (bfd_vma
) -1;
1185 if (h
->got
.refcount
> 0)
1189 int tls_type
= riscv_elf_hash_entry (h
)->tls_type
;
1191 /* Make sure this symbol is output as a dynamic symbol.
1192 Undefined weak syms won't yet be marked as dynamic. */
1193 if (h
->dynindx
== -1
1194 && !h
->forced_local
)
1196 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1201 h
->got
.offset
= s
->size
;
1202 dyn
= htab
->elf
.dynamic_sections_created
;
1203 if (tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
1205 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1206 if (tls_type
& GOT_TLS_GD
)
1208 s
->size
+= 2 * RISCV_ELF_WORD_BYTES
;
1209 htab
->elf
.srelgot
->size
+= 2 * sizeof (ElfNN_External_Rela
);
1212 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1213 if (tls_type
& GOT_TLS_IE
)
1215 s
->size
+= RISCV_ELF_WORD_BYTES
;
1216 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1221 s
->size
+= RISCV_ELF_WORD_BYTES
;
1222 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, bfd_link_pic (info
), h
)
1223 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1224 htab
->elf
.srelgot
->size
+= sizeof (ElfNN_External_Rela
);
1228 h
->got
.offset
= (bfd_vma
) -1;
1230 if (h
->dyn_relocs
== NULL
)
1233 /* In the shared -Bsymbolic case, discard space allocated for
1234 dynamic pc-relative relocs against symbols which turn out to be
1235 defined in regular objects. For the normal shared case, discard
1236 space for pc-relative relocs that have become local due to symbol
1237 visibility changes. */
1239 if (bfd_link_pic (info
))
1241 if (SYMBOL_CALLS_LOCAL (info
, h
))
1243 struct elf_dyn_relocs
**pp
;
1245 for (pp
= &h
->dyn_relocs
; (p
= *pp
) != NULL
; )
1247 p
->count
-= p
->pc_count
;
1256 /* Also discard relocs on undefined weak syms with non-default
1258 if (h
->dyn_relocs
!= NULL
1259 && h
->root
.type
== bfd_link_hash_undefweak
)
1261 if (ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
1262 || UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
1263 h
->dyn_relocs
= NULL
;
1265 /* Make sure undefined weak symbols are output as a dynamic
1267 else if (h
->dynindx
== -1
1268 && !h
->forced_local
)
1270 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1277 /* For the non-shared case, discard space for relocs against
1278 symbols which turn out to need copy relocs or are not
1284 || (htab
->elf
.dynamic_sections_created
1285 && (h
->root
.type
== bfd_link_hash_undefweak
1286 || h
->root
.type
== bfd_link_hash_undefined
))))
1288 /* Make sure this symbol is output as a dynamic symbol.
1289 Undefined weak syms won't yet be marked as dynamic. */
1290 if (h
->dynindx
== -1
1291 && !h
->forced_local
)
1293 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
1297 /* If that succeeded, we know we'll be keeping all the
1299 if (h
->dynindx
!= -1)
1303 h
->dyn_relocs
= NULL
;
1308 /* Finally, allocate space. */
1309 for (p
= h
->dyn_relocs
; p
!= NULL
; p
= p
->next
)
1311 asection
*sreloc
= elf_section_data (p
->sec
)->sreloc
;
1312 sreloc
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1318 /* Allocate space in .plt, .got and associated reloc sections for
1319 ifunc dynamic relocs. */
1322 allocate_ifunc_dynrelocs (struct elf_link_hash_entry
*h
,
1325 struct bfd_link_info
*info
;
1327 if (h
->root
.type
== bfd_link_hash_indirect
)
1330 if (h
->root
.type
== bfd_link_hash_warning
)
1331 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1333 info
= (struct bfd_link_info
*) inf
;
1335 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
1336 here if it is defined and referenced in a non-shared object. */
1337 if (h
->type
== STT_GNU_IFUNC
1339 return _bfd_elf_allocate_ifunc_dyn_relocs (info
, h
,
1348 /* Allocate space in .plt, .got and associated reloc sections for
1349 local ifunc dynamic relocs. */
1352 allocate_local_ifunc_dynrelocs (void **slot
, void *inf
)
1354 struct elf_link_hash_entry
*h
1355 = (struct elf_link_hash_entry
*) *slot
;
1357 if (h
->type
!= STT_GNU_IFUNC
1361 || h
->root
.type
!= bfd_link_hash_defined
)
1364 return allocate_ifunc_dynrelocs (h
, inf
);
1368 riscv_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
1370 struct riscv_elf_link_hash_table
*htab
;
1375 htab
= riscv_elf_hash_table (info
);
1376 BFD_ASSERT (htab
!= NULL
);
1377 dynobj
= htab
->elf
.dynobj
;
1378 BFD_ASSERT (dynobj
!= NULL
);
1380 if (elf_hash_table (info
)->dynamic_sections_created
)
1382 /* Set the contents of the .interp section to the interpreter. */
1383 if (bfd_link_executable (info
) && !info
->nointerp
)
1385 s
= bfd_get_linker_section (dynobj
, ".interp");
1386 BFD_ASSERT (s
!= NULL
);
1387 s
->size
= strlen (ELFNN_DYNAMIC_INTERPRETER
) + 1;
1388 s
->contents
= (unsigned char *) ELFNN_DYNAMIC_INTERPRETER
;
1392 /* Set up .got offsets for local syms, and space for local dynamic
1394 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
1396 bfd_signed_vma
*local_got
;
1397 bfd_signed_vma
*end_local_got
;
1398 char *local_tls_type
;
1399 bfd_size_type locsymcount
;
1400 Elf_Internal_Shdr
*symtab_hdr
;
1403 if (! is_riscv_elf (ibfd
))
1406 for (s
= ibfd
->sections
; s
!= NULL
; s
= s
->next
)
1408 struct elf_dyn_relocs
*p
;
1410 for (p
= elf_section_data (s
)->local_dynrel
; p
!= NULL
; p
= p
->next
)
1412 if (!bfd_is_abs_section (p
->sec
)
1413 && bfd_is_abs_section (p
->sec
->output_section
))
1415 /* Input section has been discarded, either because
1416 it is a copy of a linkonce section or due to
1417 linker script /DISCARD/, so we'll be discarding
1420 else if (p
->count
!= 0)
1422 srel
= elf_section_data (p
->sec
)->sreloc
;
1423 srel
->size
+= p
->count
* sizeof (ElfNN_External_Rela
);
1424 if ((p
->sec
->output_section
->flags
& SEC_READONLY
) != 0)
1425 info
->flags
|= DF_TEXTREL
;
1430 local_got
= elf_local_got_refcounts (ibfd
);
1434 symtab_hdr
= &elf_symtab_hdr (ibfd
);
1435 locsymcount
= symtab_hdr
->sh_info
;
1436 end_local_got
= local_got
+ locsymcount
;
1437 local_tls_type
= _bfd_riscv_elf_local_got_tls_type (ibfd
);
1439 srel
= htab
->elf
.srelgot
;
1440 for (; local_got
< end_local_got
; ++local_got
, ++local_tls_type
)
1444 *local_got
= s
->size
;
1445 s
->size
+= RISCV_ELF_WORD_BYTES
;
1446 if (*local_tls_type
& GOT_TLS_GD
)
1447 s
->size
+= RISCV_ELF_WORD_BYTES
;
1448 if (bfd_link_pic (info
)
1449 || (*local_tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
)))
1450 srel
->size
+= sizeof (ElfNN_External_Rela
);
1453 *local_got
= (bfd_vma
) -1;
1457 /* Allocate .plt and .got entries and space dynamic relocs for
1459 elf_link_hash_traverse (&htab
->elf
, allocate_dynrelocs
, info
);
1461 /* Allocate .plt and .got entries and space dynamic relocs for
1462 global ifunc symbols. */
1463 elf_link_hash_traverse (&htab
->elf
, allocate_ifunc_dynrelocs
, info
);
1465 /* Allocate .plt and .got entries and space dynamic relocs for
1466 local ifunc symbols. */
1467 htab_traverse (htab
->loc_hash_table
, allocate_local_ifunc_dynrelocs
, info
);
1469 /* Used to resolve the dynamic relocs overwite problems when
1470 generating static executable. */
1471 if (htab
->elf
.irelplt
)
1472 htab
->last_iplt_index
= htab
->elf
.irelplt
->reloc_count
- 1;
1474 if (htab
->elf
.sgotplt
)
1476 struct elf_link_hash_entry
*got
;
1477 got
= elf_link_hash_lookup (elf_hash_table (info
),
1478 "_GLOBAL_OFFSET_TABLE_",
1479 FALSE
, FALSE
, FALSE
);
1481 /* Don't allocate .got.plt section if there are no GOT nor PLT
1482 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1484 || !got
->ref_regular_nonweak
)
1485 && (htab
->elf
.sgotplt
->size
== GOTPLT_HEADER_SIZE
)
1486 && (htab
->elf
.splt
== NULL
1487 || htab
->elf
.splt
->size
== 0)
1488 && (htab
->elf
.sgot
== NULL
1489 || (htab
->elf
.sgot
->size
1490 == get_elf_backend_data (output_bfd
)->got_header_size
)))
1491 htab
->elf
.sgotplt
->size
= 0;
1494 /* The check_relocs and adjust_dynamic_symbol entry points have
1495 determined the sizes of the various dynamic sections. Allocate
1497 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
1499 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
1502 if (s
== htab
->elf
.splt
1503 || s
== htab
->elf
.sgot
1504 || s
== htab
->elf
.sgotplt
1505 || s
== htab
->elf
.iplt
1506 || s
== htab
->elf
.igotplt
1507 || s
== htab
->elf
.sdynbss
1508 || s
== htab
->elf
.sdynrelro
1509 || s
== htab
->sdyntdata
)
1511 /* Strip this section if we don't need it; see the
1514 else if (strncmp (s
->name
, ".rela", 5) == 0)
1518 /* We use the reloc_count field as a counter if we need
1519 to copy relocs into the output file. */
1525 /* It's not one of our sections. */
1531 /* If we don't need this section, strip it from the
1532 output file. This is mostly to handle .rela.bss and
1533 .rela.plt. We must create both sections in
1534 create_dynamic_sections, because they must be created
1535 before the linker maps input sections to output
1536 sections. The linker does that before
1537 adjust_dynamic_symbol is called, and it is that
1538 function which decides whether anything needs to go
1539 into these sections. */
1540 s
->flags
|= SEC_EXCLUDE
;
1544 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
1547 /* Allocate memory for the section contents. Zero the memory
1548 for the benefit of .rela.plt, which has 4 unused entries
1549 at the beginning, and we don't want garbage. */
1550 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
1551 if (s
->contents
== NULL
)
1555 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, TRUE
);
1559 #define DTP_OFFSET 0x800
1561 /* Return the relocation value for a TLS dtp-relative reloc. */
1564 dtpoff (struct bfd_link_info
*info
, bfd_vma address
)
1566 /* If tls_sec is NULL, we should have signalled an error already. */
1567 if (elf_hash_table (info
)->tls_sec
== NULL
)
1569 return address
- elf_hash_table (info
)->tls_sec
->vma
- DTP_OFFSET
;
1572 /* Return the relocation value for a static TLS tp-relative relocation. */
1575 tpoff (struct bfd_link_info
*info
, bfd_vma address
)
1577 /* If tls_sec is NULL, we should have signalled an error already. */
1578 if (elf_hash_table (info
)->tls_sec
== NULL
)
1580 return address
- elf_hash_table (info
)->tls_sec
->vma
- TP_OFFSET
;
1583 /* Return the global pointer's value, or 0 if it is not in use. */
1586 riscv_global_pointer_value (struct bfd_link_info
*info
)
1588 struct bfd_link_hash_entry
*h
;
1590 h
= bfd_link_hash_lookup (info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
, TRUE
);
1591 if (h
== NULL
|| h
->type
!= bfd_link_hash_defined
)
1594 return h
->u
.def
.value
+ sec_addr (h
->u
.def
.section
);
1597 /* Emplace a static relocation. */
1599 static bfd_reloc_status_type
1600 perform_relocation (const reloc_howto_type
*howto
,
1601 const Elf_Internal_Rela
*rel
,
1603 asection
*input_section
,
1607 if (howto
->pc_relative
)
1608 value
-= sec_addr (input_section
) + rel
->r_offset
;
1609 value
+= rel
->r_addend
;
1611 switch (ELFNN_R_TYPE (rel
->r_info
))
1614 case R_RISCV_TPREL_HI20
:
1615 case R_RISCV_PCREL_HI20
:
1616 case R_RISCV_GOT_HI20
:
1617 case R_RISCV_TLS_GOT_HI20
:
1618 case R_RISCV_TLS_GD_HI20
:
1619 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1620 return bfd_reloc_overflow
;
1621 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
));
1624 case R_RISCV_LO12_I
:
1625 case R_RISCV_GPREL_I
:
1626 case R_RISCV_TPREL_LO12_I
:
1627 case R_RISCV_TPREL_I
:
1628 case R_RISCV_PCREL_LO12_I
:
1629 value
= ENCODE_ITYPE_IMM (value
);
1632 case R_RISCV_LO12_S
:
1633 case R_RISCV_GPREL_S
:
1634 case R_RISCV_TPREL_LO12_S
:
1635 case R_RISCV_TPREL_S
:
1636 case R_RISCV_PCREL_LO12_S
:
1637 value
= ENCODE_STYPE_IMM (value
);
1641 case R_RISCV_CALL_PLT
:
1642 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
)))
1643 return bfd_reloc_overflow
;
1644 value
= ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value
))
1645 | (ENCODE_ITYPE_IMM (value
) << 32);
1649 if (!VALID_JTYPE_IMM (value
))
1650 return bfd_reloc_overflow
;
1651 value
= ENCODE_JTYPE_IMM (value
);
1654 case R_RISCV_BRANCH
:
1655 if (!VALID_BTYPE_IMM (value
))
1656 return bfd_reloc_overflow
;
1657 value
= ENCODE_BTYPE_IMM (value
);
1660 case R_RISCV_RVC_BRANCH
:
1661 if (!VALID_CBTYPE_IMM (value
))
1662 return bfd_reloc_overflow
;
1663 value
= ENCODE_CBTYPE_IMM (value
);
1666 case R_RISCV_RVC_JUMP
:
1667 if (!VALID_CJTYPE_IMM (value
))
1668 return bfd_reloc_overflow
;
1669 value
= ENCODE_CJTYPE_IMM (value
);
1672 case R_RISCV_RVC_LUI
:
1673 if (RISCV_CONST_HIGH_PART (value
) == 0)
1675 /* Linker relaxation can convert an address equal to or greater than
1676 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1677 valid immediate. We can fix this by converting it to a C.LI. */
1678 bfd_vma insn
= riscv_get_insn (howto
->bitsize
,
1679 contents
+ rel
->r_offset
);
1680 insn
= (insn
& ~MATCH_C_LUI
) | MATCH_C_LI
;
1681 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1682 value
= ENCODE_CITYPE_IMM (0);
1684 else if (!VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (value
)))
1685 return bfd_reloc_overflow
;
1687 value
= ENCODE_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (value
));
1705 case R_RISCV_32_PCREL
:
1706 case R_RISCV_TLS_DTPREL32
:
1707 case R_RISCV_TLS_DTPREL64
:
1710 case R_RISCV_DELETE
:
1711 return bfd_reloc_ok
;
1714 return bfd_reloc_notsupported
;
1718 if (riscv_is_insn_reloc (howto
))
1719 word
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1721 word
= bfd_get (howto
->bitsize
, input_bfd
, contents
+ rel
->r_offset
);
1722 word
= (word
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
1723 if (riscv_is_insn_reloc (howto
))
1724 riscv_put_insn (howto
->bitsize
, word
, contents
+ rel
->r_offset
);
1726 bfd_put (howto
->bitsize
, input_bfd
, word
, contents
+ rel
->r_offset
);
1728 return bfd_reloc_ok
;
1731 /* Remember all PC-relative high-part relocs we've encountered to help us
1732 later resolve the corresponding low-part relocs. */
1738 } riscv_pcrel_hi_reloc
;
1740 typedef struct riscv_pcrel_lo_reloc
1742 asection
*input_section
;
1743 struct bfd_link_info
*info
;
1744 reloc_howto_type
*howto
;
1745 const Elf_Internal_Rela
*reloc
;
1749 struct riscv_pcrel_lo_reloc
*next
;
1750 } riscv_pcrel_lo_reloc
;
1755 riscv_pcrel_lo_reloc
*lo_relocs
;
1756 } riscv_pcrel_relocs
;
1759 riscv_pcrel_reloc_hash (const void *entry
)
1761 const riscv_pcrel_hi_reloc
*e
= entry
;
1762 return (hashval_t
)(e
->address
>> 2);
1766 riscv_pcrel_reloc_eq (const void *entry1
, const void *entry2
)
1768 const riscv_pcrel_hi_reloc
*e1
= entry1
, *e2
= entry2
;
1769 return e1
->address
== e2
->address
;
1773 riscv_init_pcrel_relocs (riscv_pcrel_relocs
*p
)
1775 p
->lo_relocs
= NULL
;
1776 p
->hi_relocs
= htab_create (1024, riscv_pcrel_reloc_hash
,
1777 riscv_pcrel_reloc_eq
, free
);
1778 return p
->hi_relocs
!= NULL
;
1782 riscv_free_pcrel_relocs (riscv_pcrel_relocs
*p
)
1784 riscv_pcrel_lo_reloc
*cur
= p
->lo_relocs
;
1788 riscv_pcrel_lo_reloc
*next
= cur
->next
;
1793 htab_delete (p
->hi_relocs
);
1797 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela
*rel
,
1798 struct bfd_link_info
*info
,
1802 const reloc_howto_type
*howto
,
1803 bfd
*input_bfd ATTRIBUTE_UNUSED
)
1805 /* We may need to reference low addreses in PC-relative modes even when the
1806 PC is far away from these addresses. For example, undefweak references
1807 need to produce the address 0 when linked. As 0 is far from the arbitrary
1808 addresses that we can link PC-relative programs at, the linker can't
1809 actually relocate references to those symbols. In order to allow these
1810 programs to work we simply convert the PC-relative auipc sequences to
1811 0-relative lui sequences. */
1812 if (bfd_link_pic (info
))
1815 /* If it's possible to reference the symbol using auipc we do so, as that's
1816 more in the spirit of the PC-relative relocations we're processing. */
1817 bfd_vma offset
= addr
- pc
;
1818 if (ARCH_SIZE
== 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset
)))
1821 /* If it's impossible to reference this with a LUI-based offset then don't
1822 bother to convert it at all so users still see the PC-relative relocation
1823 in the truncation message. */
1824 if (ARCH_SIZE
> 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr
)))
1827 rel
->r_info
= ELFNN_R_INFO (addr
, R_RISCV_HI20
);
1829 bfd_vma insn
= riscv_get_insn (howto
->bitsize
, contents
+ rel
->r_offset
);
1830 insn
= (insn
& ~MASK_AUIPC
) | MATCH_LUI
;
1831 riscv_put_insn (howto
->bitsize
, insn
, contents
+ rel
->r_offset
);
1836 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs
*p
, bfd_vma addr
,
1837 bfd_vma value
, bfd_boolean absolute
)
1839 bfd_vma offset
= absolute
? value
: value
- addr
;
1840 riscv_pcrel_hi_reloc entry
= {addr
, offset
};
1841 riscv_pcrel_hi_reloc
**slot
=
1842 (riscv_pcrel_hi_reloc
**) htab_find_slot (p
->hi_relocs
, &entry
, INSERT
);
1844 BFD_ASSERT (*slot
== NULL
);
1845 *slot
= (riscv_pcrel_hi_reloc
*) bfd_malloc (sizeof (riscv_pcrel_hi_reloc
));
1853 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs
*p
,
1854 asection
*input_section
,
1855 struct bfd_link_info
*info
,
1856 reloc_howto_type
*howto
,
1857 const Elf_Internal_Rela
*reloc
,
1862 riscv_pcrel_lo_reloc
*entry
;
1863 entry
= (riscv_pcrel_lo_reloc
*) bfd_malloc (sizeof (riscv_pcrel_lo_reloc
));
1866 *entry
= (riscv_pcrel_lo_reloc
) {input_section
, info
, howto
, reloc
, addr
,
1867 name
, contents
, p
->lo_relocs
};
1868 p
->lo_relocs
= entry
;
1873 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs
*p
)
1875 riscv_pcrel_lo_reloc
*r
;
1877 for (r
= p
->lo_relocs
; r
!= NULL
; r
= r
->next
)
1879 bfd
*input_bfd
= r
->input_section
->owner
;
1881 riscv_pcrel_hi_reloc search
= {r
->addr
, 0};
1882 riscv_pcrel_hi_reloc
*entry
= htab_find (p
->hi_relocs
, &search
);
1884 /* Check for overflow into bit 11 when adding reloc addend. */
1885 || (!(entry
->value
& 0x800)
1886 && ((entry
->value
+ r
->reloc
->r_addend
) & 0x800)))
1888 char *string
= (entry
== NULL
1889 ? "%pcrel_lo missing matching %pcrel_hi"
1890 : "%pcrel_lo overflow with an addend");
1891 (*r
->info
->callbacks
->reloc_dangerous
)
1892 (r
->info
, string
, input_bfd
, r
->input_section
, r
->reloc
->r_offset
);
1896 perform_relocation (r
->howto
, r
->reloc
, entry
->value
, r
->input_section
,
1897 input_bfd
, r
->contents
);
1903 /* Relocate a RISC-V ELF section.
1905 The RELOCATE_SECTION function is called by the new ELF backend linker
1906 to handle the relocations for a section.
1908 The relocs are always passed as Rela structures.
1910 This function is responsible for adjusting the section contents as
1911 necessary, and (if generating a relocatable output file) adjusting
1912 the reloc addend as necessary.
1914 This function does not have to worry about setting the reloc
1915 address or the reloc symbol index.
1917 LOCAL_SYMS is a pointer to the swapped in local symbols.
1919 LOCAL_SECTIONS is an array giving the section in the input file
1920 corresponding to the st_shndx field of each local symbol.
1922 The global hash table entry for the global symbols can be found
1923 via elf_sym_hashes (input_bfd).
1925 When generating relocatable output, this function must handle
1926 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1927 going to be the section symbol corresponding to the output
1928 section, which means that the addend must be adjusted
1932 riscv_elf_relocate_section (bfd
*output_bfd
,
1933 struct bfd_link_info
*info
,
1935 asection
*input_section
,
1937 Elf_Internal_Rela
*relocs
,
1938 Elf_Internal_Sym
*local_syms
,
1939 asection
**local_sections
)
1941 Elf_Internal_Rela
*rel
;
1942 Elf_Internal_Rela
*relend
;
1943 riscv_pcrel_relocs pcrel_relocs
;
1944 bfd_boolean ret
= FALSE
;
1945 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
1946 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (input_bfd
);
1947 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (input_bfd
);
1948 bfd_vma
*local_got_offsets
= elf_local_got_offsets (input_bfd
);
1949 bfd_boolean absolute
;
1951 if (!riscv_init_pcrel_relocs (&pcrel_relocs
))
1954 relend
= relocs
+ input_section
->reloc_count
;
1955 for (rel
= relocs
; rel
< relend
; rel
++)
1957 unsigned long r_symndx
;
1958 struct elf_link_hash_entry
*h
;
1959 Elf_Internal_Sym
*sym
;
1962 bfd_reloc_status_type r
= bfd_reloc_ok
;
1963 const char *name
= NULL
;
1964 bfd_vma off
, ie_off
;
1965 bfd_boolean unresolved_reloc
, is_ie
= FALSE
;
1966 bfd_vma pc
= sec_addr (input_section
) + rel
->r_offset
;
1967 int r_type
= ELFNN_R_TYPE (rel
->r_info
), tls_type
;
1968 reloc_howto_type
*howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
1969 const char *msg
= NULL
;
1970 char *msg_buf
= NULL
;
1971 bfd_boolean resolved_to_zero
;
1974 || r_type
== R_RISCV_GNU_VTINHERIT
|| r_type
== R_RISCV_GNU_VTENTRY
)
1977 /* This is a final link. */
1978 r_symndx
= ELFNN_R_SYM (rel
->r_info
);
1982 unresolved_reloc
= FALSE
;
1983 if (r_symndx
< symtab_hdr
->sh_info
)
1985 sym
= local_syms
+ r_symndx
;
1986 sec
= local_sections
[r_symndx
];
1987 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1989 /* Relocate against local STT_GNU_IFUNC symbol. */
1990 if (!bfd_link_relocatable (info
)
1991 && ELF_ST_TYPE (sym
->st_info
) == STT_GNU_IFUNC
)
1993 h
= riscv_elf_get_local_sym_hash (htab
, input_bfd
, rel
, FALSE
);
1997 /* Set STT_GNU_IFUNC symbol value. */
1998 h
->root
.u
.def
.value
= sym
->st_value
;
1999 h
->root
.u
.def
.section
= sec
;
2004 bfd_boolean warned
, ignored
;
2006 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2007 r_symndx
, symtab_hdr
, sym_hashes
,
2009 unresolved_reloc
, warned
, ignored
);
2012 /* To avoid generating warning messages about truncated
2013 relocations, set the relocation's address to be the same as
2014 the start of this section. */
2015 if (input_section
->output_section
!= NULL
)
2016 relocation
= input_section
->output_section
->vma
;
2022 if (sec
!= NULL
&& discarded_section (sec
))
2023 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2024 rel
, 1, relend
, howto
, 0, contents
);
2026 if (bfd_link_relocatable (info
))
2029 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
2030 it here if it is defined in a non-shared object. */
2032 && h
->type
== STT_GNU_IFUNC
2035 asection
*plt
, *base_got
;
2037 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2039 /* If this is a SHT_NOTE section without SHF_ALLOC, treat
2040 STT_GNU_IFUNC symbol as STT_FUNC. */
2041 if (elf_section_type (input_section
) == SHT_NOTE
)
2044 /* Dynamic relocs are not propagated for SEC_DEBUGGING
2045 sections because such sections are not SEC_ALLOC and
2046 thus ld.so will not process them. */
2047 if ((input_section
->flags
& SEC_DEBUGGING
) != 0)
2052 else if (h
->plt
.offset
== (bfd_vma
) -1
2053 /* The following relocation may not need the .plt entries
2054 when all references to a STT_GNU_IFUNC symbols are done
2055 via GOT or static function pointers. */
2056 && r_type
!= R_RISCV_32
2057 && r_type
!= R_RISCV_64
2058 && r_type
!= R_RISCV_HI20
2059 && r_type
!= R_RISCV_GOT_HI20
2060 && r_type
!= R_RISCV_LO12_I
2061 && r_type
!= R_RISCV_LO12_S
)
2062 goto bad_ifunc_reloc
;
2064 /* STT_GNU_IFUNC symbol must go through PLT. */
2065 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
2066 relocation
= plt
->output_section
->vma
2067 + plt
->output_offset
2074 if (rel
->r_addend
!= 0)
2076 if (h
->root
.root
.string
)
2077 name
= h
->root
.root
.string
;
2079 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2082 /* xgettext:c-format */
2083 (_("%pB: relocation %s against STT_GNU_IFUNC "
2084 "symbol `%s' has non-zero addend: %" PRId64
),
2085 input_bfd
, howto
->name
, name
, (int64_t) rel
->r_addend
);
2086 bfd_set_error (bfd_error_bad_value
);
2090 /* Generate dynamic relocation only when there is a non-GOT
2091 reference in a shared object or there is no PLT. */
2092 if ((bfd_link_pic (info
) && h
->non_got_ref
)
2093 || h
->plt
.offset
== (bfd_vma
) -1)
2095 Elf_Internal_Rela outrel
;
2098 /* Need a dynamic relocation to get the real function
2100 outrel
.r_offset
= _bfd_elf_section_offset (output_bfd
,
2104 if (outrel
.r_offset
== (bfd_vma
) -1
2105 || outrel
.r_offset
== (bfd_vma
) -2)
2108 outrel
.r_offset
+= input_section
->output_section
->vma
2109 + input_section
->output_offset
;
2111 if (h
->dynindx
== -1
2113 || bfd_link_executable (info
))
2115 info
->callbacks
->minfo
2116 (_("Local IFUNC function `%s' in %pB\n"),
2117 h
->root
.root
.string
,
2118 h
->root
.u
.def
.section
->owner
);
2120 /* This symbol is resolved locally. */
2121 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2122 outrel
.r_addend
= h
->root
.u
.def
.value
2123 + h
->root
.u
.def
.section
->output_section
->vma
2124 + h
->root
.u
.def
.section
->output_offset
;
2128 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2129 outrel
.r_addend
= 0;
2132 /* Dynamic relocations are stored in
2133 1. .rela.ifunc section in PIC object.
2134 2. .rela.got section in dynamic executable.
2135 3. .rela.iplt section in static executable. */
2136 if (bfd_link_pic (info
))
2137 sreloc
= htab
->elf
.irelifunc
;
2138 else if (htab
->elf
.splt
!= NULL
)
2139 sreloc
= htab
->elf
.srelgot
;
2141 sreloc
= htab
->elf
.irelplt
;
2143 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2145 /* If this reloc is against an external symbol, we
2146 do not want to fiddle with the addend. Otherwise,
2147 we need to include the symbol value so that it
2148 becomes an addend for the dynamic reloc. For an
2149 internal symbol, we have updated addend. */
2154 case R_RISCV_GOT_HI20
:
2155 base_got
= htab
->elf
.sgot
;
2156 off
= h
->got
.offset
;
2158 if (base_got
== NULL
)
2161 if (off
== (bfd_vma
) -1)
2165 /* We can't use h->got.offset here to save state, or
2166 even just remember the offset, as finish_dynamic_symbol
2167 would use that as offset into .got. */
2169 if (htab
->elf
.splt
!= NULL
)
2171 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
)
2173 off
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2174 base_got
= htab
->elf
.sgotplt
;
2178 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2179 off
= plt_idx
* GOT_ENTRY_SIZE
;
2180 base_got
= htab
->elf
.igotplt
;
2183 if (h
->dynindx
== -1
2187 /* This references the local definition. We must
2188 initialize this entry in the global offset table.
2189 Since the offset must always be a multiple of 8,
2190 we use the least significant bit to record
2191 whether we have initialized it already.
2193 When doing a dynamic link, we create a .rela.got
2194 relocation entry to initialize the value. This
2195 is done in the finish_dynamic_symbol routine. */
2200 bfd_put_NN (output_bfd
, relocation
,
2201 base_got
->contents
+ off
);
2202 /* Note that this is harmless for the case,
2203 as -1 | 1 still is -1. */
2209 relocation
= base_got
->output_section
->vma
2210 + base_got
->output_offset
+ off
;
2212 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2213 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2215 r
= bfd_reloc_notsupported
;
2216 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2218 r
= bfd_reloc_overflow
;
2222 case R_RISCV_CALL_PLT
:
2224 case R_RISCV_LO12_I
:
2225 case R_RISCV_LO12_S
:
2228 case R_RISCV_PCREL_HI20
:
2229 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2230 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2232 r
= bfd_reloc_notsupported
;
2233 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2235 r
= bfd_reloc_overflow
;
2240 if (h
->root
.root
.string
)
2241 name
= h
->root
.root
.string
;
2243 /* The entry of local ifunc is fake in global hash table,
2244 we should find the name by the original local symbol. */
2245 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, NULL
);
2248 /* xgettext:c-format */
2249 (_("%pB: relocation %s against STT_GNU_IFUNC "
2250 "symbol `%s' isn't supported"), input_bfd
,
2252 bfd_set_error (bfd_error_bad_value
);
2259 name
= h
->root
.root
.string
;
2262 name
= (bfd_elf_string_from_elf_section
2263 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
2264 if (name
== NULL
|| *name
== '\0')
2265 name
= bfd_section_name (sec
);
2268 resolved_to_zero
= (h
!= NULL
2269 && UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
));
2275 case R_RISCV_TPREL_ADD
:
2277 case R_RISCV_JUMP_SLOT
:
2278 case R_RISCV_RELATIVE
:
2279 /* These require nothing of us at all. */
2283 case R_RISCV_BRANCH
:
2284 case R_RISCV_RVC_BRANCH
:
2285 case R_RISCV_RVC_LUI
:
2286 case R_RISCV_LO12_I
:
2287 case R_RISCV_LO12_S
:
2292 case R_RISCV_32_PCREL
:
2293 case R_RISCV_DELETE
:
2294 /* These require no special handling beyond perform_relocation. */
2297 case R_RISCV_GOT_HI20
:
2300 bfd_boolean dyn
, pic
;
2302 off
= h
->got
.offset
;
2303 BFD_ASSERT (off
!= (bfd_vma
) -1);
2304 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
2305 pic
= bfd_link_pic (info
);
2307 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2308 || (pic
&& SYMBOL_REFERENCES_LOCAL (info
, h
)))
2310 /* This is actually a static link, or it is a
2311 -Bsymbolic link and the symbol is defined
2312 locally, or the symbol was forced to be local
2313 because of a version file. We must initialize
2314 this entry in the global offset table. Since the
2315 offset must always be a multiple of the word size,
2316 we use the least significant bit to record whether
2317 we have initialized it already.
2319 When doing a dynamic link, we create a .rela.got
2320 relocation entry to initialize the value. This
2321 is done in the finish_dynamic_symbol routine. */
2326 bfd_put_NN (output_bfd
, relocation
,
2327 htab
->elf
.sgot
->contents
+ off
);
2332 unresolved_reloc
= FALSE
;
2336 BFD_ASSERT (local_got_offsets
!= NULL
2337 && local_got_offsets
[r_symndx
] != (bfd_vma
) -1);
2339 off
= local_got_offsets
[r_symndx
];
2341 /* The offset must always be a multiple of the word size.
2342 So, we can use the least significant bit to record
2343 whether we have already processed this entry. */
2348 if (bfd_link_pic (info
))
2351 Elf_Internal_Rela outrel
;
2353 /* We need to generate a R_RISCV_RELATIVE reloc
2354 for the dynamic linker. */
2355 s
= htab
->elf
.srelgot
;
2356 BFD_ASSERT (s
!= NULL
);
2358 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2360 ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2361 outrel
.r_addend
= relocation
;
2363 riscv_elf_append_rela (output_bfd
, s
, &outrel
);
2366 bfd_put_NN (output_bfd
, relocation
,
2367 htab
->elf
.sgot
->contents
+ off
);
2368 local_got_offsets
[r_symndx
] |= 1;
2371 relocation
= sec_addr (htab
->elf
.sgot
) + off
;
2372 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2379 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2380 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2382 r
= bfd_reloc_notsupported
;
2383 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2384 relocation
, absolute
))
2385 r
= bfd_reloc_overflow
;
2393 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2394 contents
+ rel
->r_offset
);
2395 relocation
= old_value
+ relocation
;
2405 bfd_vma old_value
= bfd_get (howto
->bitsize
, input_bfd
,
2406 contents
+ rel
->r_offset
);
2407 relocation
= old_value
- relocation
;
2412 case R_RISCV_CALL_PLT
:
2413 /* Handle a call to an undefined weak function. This won't be
2414 relaxed, so we have to handle it here. */
2415 if (h
!= NULL
&& h
->root
.type
== bfd_link_hash_undefweak
2416 && (!bfd_link_pic (info
) || h
->plt
.offset
== MINUS_ONE
))
2418 /* We can use x0 as the base register. */
2419 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
2420 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2421 bfd_putl32 (insn
, contents
+ rel
->r_offset
+ 4);
2422 /* Set the relocation value so that we get 0 after the pc
2423 relative adjustment. */
2424 relocation
= sec_addr (input_section
) + rel
->r_offset
;
2429 case R_RISCV_RVC_JUMP
:
2430 /* This line has to match the check in _bfd_riscv_relax_section. */
2431 if (bfd_link_pic (info
) && h
!= NULL
&& h
->plt
.offset
!= MINUS_ONE
)
2433 /* Refer to the PLT entry. */
2434 relocation
= sec_addr (htab
->elf
.splt
) + h
->plt
.offset
;
2435 unresolved_reloc
= FALSE
;
2439 case R_RISCV_TPREL_HI20
:
2440 relocation
= tpoff (info
, relocation
);
2443 case R_RISCV_TPREL_LO12_I
:
2444 case R_RISCV_TPREL_LO12_S
:
2445 relocation
= tpoff (info
, relocation
);
2448 case R_RISCV_TPREL_I
:
2449 case R_RISCV_TPREL_S
:
2450 relocation
= tpoff (info
, relocation
);
2451 if (VALID_ITYPE_IMM (relocation
+ rel
->r_addend
))
2453 /* We can use tp as the base register. */
2454 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2455 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2456 insn
|= X_TP
<< OP_SH_RS1
;
2457 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2460 r
= bfd_reloc_overflow
;
2463 case R_RISCV_GPREL_I
:
2464 case R_RISCV_GPREL_S
:
2466 bfd_vma gp
= riscv_global_pointer_value (info
);
2467 bfd_boolean x0_base
= VALID_ITYPE_IMM (relocation
+ rel
->r_addend
);
2468 if (x0_base
|| VALID_ITYPE_IMM (relocation
+ rel
->r_addend
- gp
))
2470 /* We can use x0 or gp as the base register. */
2471 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
2472 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
2475 rel
->r_addend
-= gp
;
2476 insn
|= X_GP
<< OP_SH_RS1
;
2478 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
2481 r
= bfd_reloc_overflow
;
2485 case R_RISCV_PCREL_HI20
:
2486 absolute
= riscv_zero_pcrel_hi_reloc (rel
,
2493 r_type
= ELFNN_R_TYPE (rel
->r_info
);
2494 howto
= riscv_elf_rtype_to_howto (input_bfd
, r_type
);
2496 r
= bfd_reloc_notsupported
;
2497 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2498 relocation
+ rel
->r_addend
,
2500 r
= bfd_reloc_overflow
;
2503 case R_RISCV_PCREL_LO12_I
:
2504 case R_RISCV_PCREL_LO12_S
:
2505 /* We don't allow section symbols plus addends as the auipc address,
2506 because then riscv_relax_delete_bytes would have to search through
2507 all relocs to update these addends. This is also ambiguous, as
2508 we do allow offsets to be added to the target address, which are
2509 not to be used to find the auipc address. */
2510 if (((sym
!= NULL
&& (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
))
2511 || (h
!= NULL
&& h
->type
== STT_SECTION
))
2514 msg
= _("%pcrel_lo section symbol with an addend");
2515 r
= bfd_reloc_dangerous
;
2519 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs
, input_section
, info
,
2520 howto
, rel
, relocation
, name
,
2523 r
= bfd_reloc_overflow
;
2526 case R_RISCV_TLS_DTPREL32
:
2527 case R_RISCV_TLS_DTPREL64
:
2528 relocation
= dtpoff (info
, relocation
);
2533 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2536 if ((bfd_link_pic (info
)
2538 || (ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2539 && !resolved_to_zero
)
2540 || h
->root
.type
!= bfd_link_hash_undefweak
)
2541 && (!howto
->pc_relative
2542 || !SYMBOL_CALLS_LOCAL (info
, h
)))
2543 || (!bfd_link_pic (info
)
2549 || h
->root
.type
== bfd_link_hash_undefweak
2550 || h
->root
.type
== bfd_link_hash_undefined
)))
2552 Elf_Internal_Rela outrel
;
2554 bfd_boolean skip_static_relocation
, skip_dynamic_relocation
;
2556 /* When generating a shared object, these relocations
2557 are copied into the output file to be resolved at run
2561 _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2563 skip_static_relocation
= outrel
.r_offset
!= (bfd_vma
) -2;
2564 skip_dynamic_relocation
= outrel
.r_offset
>= (bfd_vma
) -2;
2565 outrel
.r_offset
+= sec_addr (input_section
);
2567 if (skip_dynamic_relocation
)
2568 memset (&outrel
, 0, sizeof outrel
);
2569 else if (h
!= NULL
&& h
->dynindx
!= -1
2570 && !(bfd_link_pic (info
)
2571 && SYMBOLIC_BIND (info
, h
)
2574 outrel
.r_info
= ELFNN_R_INFO (h
->dynindx
, r_type
);
2575 outrel
.r_addend
= rel
->r_addend
;
2579 outrel
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
2580 outrel
.r_addend
= relocation
+ rel
->r_addend
;
2583 sreloc
= elf_section_data (input_section
)->sreloc
;
2584 riscv_elf_append_rela (output_bfd
, sreloc
, &outrel
);
2585 if (skip_static_relocation
)
2590 case R_RISCV_TLS_GOT_HI20
:
2594 case R_RISCV_TLS_GD_HI20
:
2597 off
= h
->got
.offset
;
2602 off
= local_got_offsets
[r_symndx
];
2603 local_got_offsets
[r_symndx
] |= 1;
2606 tls_type
= _bfd_riscv_elf_tls_type (input_bfd
, h
, r_symndx
);
2607 BFD_ASSERT (tls_type
& (GOT_TLS_IE
| GOT_TLS_GD
));
2608 /* If this symbol is referenced by both GD and IE TLS, the IE
2609 reference's GOT slot follows the GD reference's slots. */
2611 if ((tls_type
& GOT_TLS_GD
) && (tls_type
& GOT_TLS_IE
))
2612 ie_off
= 2 * GOT_ENTRY_SIZE
;
2618 Elf_Internal_Rela outrel
;
2620 bfd_boolean need_relocs
= FALSE
;
2622 if (htab
->elf
.srelgot
== NULL
)
2627 bfd_boolean dyn
, pic
;
2628 dyn
= htab
->elf
.dynamic_sections_created
;
2629 pic
= bfd_link_pic (info
);
2631 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, pic
, h
)
2632 && (!pic
|| !SYMBOL_REFERENCES_LOCAL (info
, h
)))
2636 /* The GOT entries have not been initialized yet. Do it
2637 now, and emit any relocations. */
2638 if ((bfd_link_pic (info
) || indx
!= 0)
2640 || ELF_ST_VISIBILITY (h
->other
) == STV_DEFAULT
2641 || h
->root
.type
!= bfd_link_hash_undefweak
))
2644 if (tls_type
& GOT_TLS_GD
)
2648 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
) + off
;
2649 outrel
.r_addend
= 0;
2650 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPMODNN
);
2651 bfd_put_NN (output_bfd
, 0,
2652 htab
->elf
.sgot
->contents
+ off
);
2653 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2656 BFD_ASSERT (! unresolved_reloc
);
2657 bfd_put_NN (output_bfd
,
2658 dtpoff (info
, relocation
),
2659 (htab
->elf
.sgot
->contents
2660 + off
+ RISCV_ELF_WORD_BYTES
));
2664 bfd_put_NN (output_bfd
, 0,
2665 (htab
->elf
.sgot
->contents
2666 + off
+ RISCV_ELF_WORD_BYTES
));
2667 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_DTPRELNN
);
2668 outrel
.r_offset
+= RISCV_ELF_WORD_BYTES
;
2669 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2674 /* If we are not emitting relocations for a
2675 general dynamic reference, then we must be in a
2676 static link or an executable link with the
2677 symbol binding locally. Mark it as belonging
2678 to module 1, the executable. */
2679 bfd_put_NN (output_bfd
, 1,
2680 htab
->elf
.sgot
->contents
+ off
);
2681 bfd_put_NN (output_bfd
,
2682 dtpoff (info
, relocation
),
2683 (htab
->elf
.sgot
->contents
2684 + off
+ RISCV_ELF_WORD_BYTES
));
2688 if (tls_type
& GOT_TLS_IE
)
2692 bfd_put_NN (output_bfd
, 0,
2693 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2694 outrel
.r_offset
= sec_addr (htab
->elf
.sgot
)
2696 outrel
.r_addend
= 0;
2698 outrel
.r_addend
= tpoff (info
, relocation
);
2699 outrel
.r_info
= ELFNN_R_INFO (indx
, R_RISCV_TLS_TPRELNN
);
2700 riscv_elf_append_rela (output_bfd
, htab
->elf
.srelgot
, &outrel
);
2704 bfd_put_NN (output_bfd
, tpoff (info
, relocation
),
2705 htab
->elf
.sgot
->contents
+ off
+ ie_off
);
2710 BFD_ASSERT (off
< (bfd_vma
) -2);
2711 relocation
= sec_addr (htab
->elf
.sgot
) + off
+ (is_ie
? ie_off
: 0);
2712 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs
, pc
,
2714 r
= bfd_reloc_overflow
;
2715 unresolved_reloc
= FALSE
;
2719 r
= bfd_reloc_notsupported
;
2722 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2723 because such sections are not SEC_ALLOC and thus ld.so will
2724 not process them. */
2725 if (unresolved_reloc
2726 && !((input_section
->flags
& SEC_DEBUGGING
) != 0
2728 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2729 rel
->r_offset
) != (bfd_vma
) -1)
2734 case R_RISCV_RVC_JUMP
:
2735 if (asprintf (&msg_buf
,
2736 _("%%X%%P: relocation %s against `%s' can "
2737 "not be used when making a shared object; "
2738 "recompile with -fPIC\n"),
2740 h
->root
.root
.string
) == -1)
2745 if (asprintf (&msg_buf
,
2746 _("%%X%%P: unresolvable %s relocation against "
2749 h
->root
.root
.string
) == -1)
2755 r
= bfd_reloc_notsupported
;
2759 if (r
== bfd_reloc_ok
)
2760 r
= perform_relocation (howto
, rel
, relocation
, input_section
,
2761 input_bfd
, contents
);
2763 /* We should have already detected the error and set message before.
2764 If the error message isn't set since the linker runs out of memory
2765 or we don't set it before, then we should set the default message
2766 with the "internal error" string here. */
2772 case bfd_reloc_overflow
:
2773 info
->callbacks
->reloc_overflow
2774 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2775 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2778 case bfd_reloc_undefined
:
2779 info
->callbacks
->undefined_symbol
2780 (info
, name
, input_bfd
, input_section
, rel
->r_offset
,
2784 case bfd_reloc_outofrange
:
2786 msg
= _("%X%P: internal error: out of range error\n");
2789 case bfd_reloc_notsupported
:
2791 msg
= _("%X%P: internal error: unsupported relocation error\n");
2794 case bfd_reloc_dangerous
:
2795 /* The error message should already be set. */
2797 msg
= _("dangerous relocation error");
2798 info
->callbacks
->reloc_dangerous
2799 (info
, msg
, input_bfd
, input_section
, rel
->r_offset
);
2803 msg
= _("%X%P: internal error: unknown error\n");
2807 /* Do not report error message for the dangerous relocation again. */
2808 if (msg
&& r
!= bfd_reloc_dangerous
)
2809 info
->callbacks
->einfo (msg
);
2811 /* Free the unused `msg_buf`. */
2814 /* We already reported the error via a callback, so don't try to report
2815 it again by returning false. That leads to spurious errors. */
2820 ret
= riscv_resolve_pcrel_lo_relocs (&pcrel_relocs
);
2822 riscv_free_pcrel_relocs (&pcrel_relocs
);
2826 /* Finish up dynamic symbol handling. We set the contents of various
2827 dynamic sections here. */
2830 riscv_elf_finish_dynamic_symbol (bfd
*output_bfd
,
2831 struct bfd_link_info
*info
,
2832 struct elf_link_hash_entry
*h
,
2833 Elf_Internal_Sym
*sym
)
2835 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
2836 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2838 if (h
->plt
.offset
!= (bfd_vma
) -1)
2840 /* We've decided to create a PLT entry for this symbol. */
2842 bfd_vma i
, header_address
, plt_idx
, got_offset
, got_address
;
2843 uint32_t plt_entry
[PLT_ENTRY_INSNS
];
2844 Elf_Internal_Rela rela
;
2845 asection
*plt
, *gotplt
, *relplt
;
2847 /* When building a static executable, use .iplt, .igot.plt and
2848 .rela.iplt sections for STT_GNU_IFUNC symbols. */
2849 if (htab
->elf
.splt
!= NULL
)
2851 plt
= htab
->elf
.splt
;
2852 gotplt
= htab
->elf
.sgotplt
;
2853 relplt
= htab
->elf
.srelplt
;
2857 plt
= htab
->elf
.iplt
;
2858 gotplt
= htab
->elf
.igotplt
;
2859 relplt
= htab
->elf
.irelplt
;
2862 /* This symbol has an entry in the procedure linkage table. Set
2864 if ((h
->dynindx
== -1
2865 && !((h
->forced_local
|| bfd_link_executable (info
))
2867 && h
->type
== STT_GNU_IFUNC
))
2873 /* Calculate the address of the PLT header. */
2874 header_address
= sec_addr (plt
);
2876 /* Calculate the index of the entry and the offset of .got.plt entry.
2877 For static executables, we don't reserve anything. */
2878 if (plt
== htab
->elf
.splt
)
2880 plt_idx
= (h
->plt
.offset
- PLT_HEADER_SIZE
) / PLT_ENTRY_SIZE
;
2881 got_offset
= GOTPLT_HEADER_SIZE
+ (plt_idx
* GOT_ENTRY_SIZE
);
2885 plt_idx
= h
->plt
.offset
/ PLT_ENTRY_SIZE
;
2886 got_offset
= plt_idx
* GOT_ENTRY_SIZE
;
2889 /* Calculate the address of the .got.plt entry. */
2890 got_address
= sec_addr (gotplt
) + got_offset
;
2892 /* Find out where the .plt entry should go. */
2893 loc
= plt
->contents
+ h
->plt
.offset
;
2895 /* Fill in the PLT entry itself. */
2896 if (! riscv_make_plt_entry (output_bfd
, got_address
,
2897 header_address
+ h
->plt
.offset
,
2901 for (i
= 0; i
< PLT_ENTRY_INSNS
; i
++)
2902 bfd_putl32 (plt_entry
[i
], loc
+ 4*i
);
2904 /* Fill in the initial value of the .got.plt entry. */
2905 loc
= gotplt
->contents
+ (got_address
- sec_addr (gotplt
));
2906 bfd_put_NN (output_bfd
, sec_addr (plt
), loc
);
2908 rela
.r_offset
= got_address
;
2910 if (h
->dynindx
== -1
2911 || ((bfd_link_executable (info
)
2912 || ELF_ST_VISIBILITY (h
->other
) != STV_DEFAULT
)
2914 && h
->type
== STT_GNU_IFUNC
))
2916 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2917 h
->root
.root
.string
,
2918 h
->root
.u
.def
.section
->owner
);
2920 /* If an STT_GNU_IFUNC symbol is locally defined, generate
2921 R_RISCV_IRELATIVE instead of R_RISCV_JUMP_SLOT. */
2922 asection
*sec
= h
->root
.u
.def
.section
;
2923 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2924 rela
.r_addend
= h
->root
.u
.def
.value
2925 + sec
->output_section
->vma
2926 + sec
->output_offset
;
2930 /* Fill in the entry in the .rela.plt section. */
2931 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_JUMP_SLOT
);
2935 loc
= relplt
->contents
+ plt_idx
* sizeof (ElfNN_External_Rela
);
2936 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
2938 if (!h
->def_regular
)
2940 /* Mark the symbol as undefined, rather than as defined in
2941 the .plt section. Leave the value alone. */
2942 sym
->st_shndx
= SHN_UNDEF
;
2943 /* If the symbol is weak, we do need to clear the value.
2944 Otherwise, the PLT entry would provide a definition for
2945 the symbol even if the symbol wasn't defined anywhere,
2946 and so the symbol would never be NULL. */
2947 if (!h
->ref_regular_nonweak
)
2952 if (h
->got
.offset
!= (bfd_vma
) -1
2953 && !(riscv_elf_hash_entry (h
)->tls_type
& (GOT_TLS_GD
| GOT_TLS_IE
))
2954 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info
, h
))
2958 Elf_Internal_Rela rela
;
2959 bfd_boolean use_elf_append_rela
= TRUE
;
2961 /* This symbol has an entry in the GOT. Set it up. */
2963 sgot
= htab
->elf
.sgot
;
2964 srela
= htab
->elf
.srelgot
;
2965 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
2967 rela
.r_offset
= sec_addr (sgot
) + (h
->got
.offset
&~ (bfd_vma
) 1);
2969 /* Handle the ifunc symbol in GOT entry. */
2971 && h
->type
== STT_GNU_IFUNC
)
2973 if (h
->plt
.offset
== (bfd_vma
) -1)
2975 /* STT_GNU_IFUNC is referenced without PLT. */
2977 if (htab
->elf
.splt
== NULL
)
2979 /* Use .rela.iplt section to store .got relocations
2980 in static executable. */
2981 srela
= htab
->elf
.irelplt
;
2983 /* Do not use riscv_elf_append_rela to add dynamic
2985 use_elf_append_rela
= FALSE
;
2988 if (SYMBOL_REFERENCES_LOCAL (info
, h
))
2990 info
->callbacks
->minfo (_("Local IFUNC function `%s' in %pB\n"),
2991 h
->root
.root
.string
,
2992 h
->root
.u
.def
.section
->owner
);
2994 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_IRELATIVE
);
2995 rela
.r_addend
= (h
->root
.u
.def
.value
2996 + h
->root
.u
.def
.section
->output_section
->vma
2997 + h
->root
.u
.def
.section
->output_offset
);
3001 /* Generate R_RISCV_NN. */
3002 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3003 BFD_ASSERT (h
->dynindx
!= -1);
3004 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3008 else if (bfd_link_pic (info
))
3010 /* Generate R_RISCV_NN. */
3011 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3012 BFD_ASSERT (h
->dynindx
!= -1);
3013 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3020 if (!h
->pointer_equality_needed
)
3023 /* For non-shared object, we can't use .got.plt, which
3024 contains the real function address if we need pointer
3025 equality. We load the GOT entry with the PLT entry. */
3026 plt
= htab
->elf
.splt
? htab
->elf
.splt
: htab
->elf
.iplt
;
3027 bfd_put_NN (output_bfd
, (plt
->output_section
->vma
3028 + plt
->output_offset
3030 htab
->elf
.sgot
->contents
3031 + (h
->got
.offset
& ~(bfd_vma
) 1));
3035 else if (bfd_link_pic (info
)
3036 && SYMBOL_REFERENCES_LOCAL (info
, h
))
3038 /* If this is a local symbol reference, we just want to emit
3039 a RELATIVE reloc. This can happen if it is a -Bsymbolic link,
3040 or a pie link, or the symbol was forced to be local because
3041 of a version file. The entry in the global offset table will
3042 already have been initialized in the relocate_section function. */
3043 BFD_ASSERT ((h
->got
.offset
& 1) != 0);
3044 asection
*sec
= h
->root
.u
.def
.section
;
3045 rela
.r_info
= ELFNN_R_INFO (0, R_RISCV_RELATIVE
);
3046 rela
.r_addend
= (h
->root
.u
.def
.value
3047 + sec
->output_section
->vma
3048 + sec
->output_offset
);
3052 BFD_ASSERT ((h
->got
.offset
& 1) == 0);
3053 BFD_ASSERT (h
->dynindx
!= -1);
3054 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_NN
);
3058 bfd_put_NN (output_bfd
, 0,
3059 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
3061 if (use_elf_append_rela
)
3062 riscv_elf_append_rela (output_bfd
, srela
, &rela
);
3065 /* Use riscv_elf_append_rela to add the dynamic relocs into
3066 .rela.iplt may cause the overwrite problems. Since we insert
3067 the relocs for PLT didn't handle the reloc_index of .rela.iplt,
3068 but the riscv_elf_append_rela adds the relocs to the place
3069 that are calculated from the reloc_index (in seqential).
3071 One solution is that add these dynamic relocs (GOT IFUNC)
3072 from the last of .rela.iplt section. */
3073 bfd_vma iplt_idx
= htab
->last_iplt_index
--;
3074 bfd_byte
*loc
= srela
->contents
3075 + iplt_idx
* sizeof (ElfNN_External_Rela
);
3076 bed
->s
->swap_reloca_out (output_bfd
, &rela
, loc
);
3082 Elf_Internal_Rela rela
;
3085 /* This symbols needs a copy reloc. Set it up. */
3086 BFD_ASSERT (h
->dynindx
!= -1);
3088 rela
.r_offset
= sec_addr (h
->root
.u
.def
.section
) + h
->root
.u
.def
.value
;
3089 rela
.r_info
= ELFNN_R_INFO (h
->dynindx
, R_RISCV_COPY
);
3091 if (h
->root
.u
.def
.section
== htab
->elf
.sdynrelro
)
3092 s
= htab
->elf
.sreldynrelro
;
3094 s
= htab
->elf
.srelbss
;
3095 riscv_elf_append_rela (output_bfd
, s
, &rela
);
3098 /* Mark some specially defined symbols as absolute. */
3099 if (h
== htab
->elf
.hdynamic
3100 || (h
== htab
->elf
.hgot
|| h
== htab
->elf
.hplt
))
3101 sym
->st_shndx
= SHN_ABS
;
3106 /* Finish up local dynamic symbol handling. We set the contents of
3107 various dynamic sections here. */
3110 riscv_elf_finish_local_dynamic_symbol (void **slot
, void *inf
)
3112 struct elf_link_hash_entry
*h
= (struct elf_link_hash_entry
*) *slot
;
3113 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
3115 return riscv_elf_finish_dynamic_symbol (info
->output_bfd
, info
, h
, NULL
);
3118 /* Finish up the dynamic sections. */
3121 riscv_finish_dyn (bfd
*output_bfd
, struct bfd_link_info
*info
,
3122 bfd
*dynobj
, asection
*sdyn
)
3124 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
3125 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
3126 size_t dynsize
= bed
->s
->sizeof_dyn
;
3127 bfd_byte
*dyncon
, *dynconend
;
3129 dynconend
= sdyn
->contents
+ sdyn
->size
;
3130 for (dyncon
= sdyn
->contents
; dyncon
< dynconend
; dyncon
+= dynsize
)
3132 Elf_Internal_Dyn dyn
;
3135 bed
->s
->swap_dyn_in (dynobj
, dyncon
, &dyn
);
3140 s
= htab
->elf
.sgotplt
;
3141 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3144 s
= htab
->elf
.srelplt
;
3145 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
3148 s
= htab
->elf
.srelplt
;
3149 dyn
.d_un
.d_val
= s
->size
;
3155 bed
->s
->swap_dyn_out (output_bfd
, &dyn
, dyncon
);
3161 riscv_elf_finish_dynamic_sections (bfd
*output_bfd
,
3162 struct bfd_link_info
*info
)
3166 struct riscv_elf_link_hash_table
*htab
;
3168 htab
= riscv_elf_hash_table (info
);
3169 BFD_ASSERT (htab
!= NULL
);
3170 dynobj
= htab
->elf
.dynobj
;
3172 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3174 if (elf_hash_table (info
)->dynamic_sections_created
)
3179 splt
= htab
->elf
.splt
;
3180 BFD_ASSERT (splt
!= NULL
&& sdyn
!= NULL
);
3182 ret
= riscv_finish_dyn (output_bfd
, info
, dynobj
, sdyn
);
3187 /* Fill in the head and tail entries in the procedure linkage table. */
3191 uint32_t plt_header
[PLT_HEADER_INSNS
];
3192 ret
= riscv_make_plt_header (output_bfd
,
3193 sec_addr (htab
->elf
.sgotplt
),
3194 sec_addr (splt
), plt_header
);
3198 for (i
= 0; i
< PLT_HEADER_INSNS
; i
++)
3199 bfd_putl32 (plt_header
[i
], splt
->contents
+ 4*i
);
3201 elf_section_data (splt
->output_section
)->this_hdr
.sh_entsize
3206 if (htab
->elf
.sgotplt
)
3208 asection
*output_section
= htab
->elf
.sgotplt
->output_section
;
3210 if (bfd_is_abs_section (output_section
))
3212 (*_bfd_error_handler
)
3213 (_("discarded output section: `%pA'"), htab
->elf
.sgotplt
);
3217 if (htab
->elf
.sgotplt
->size
> 0)
3219 /* Write the first two entries in .got.plt, needed for the dynamic
3221 bfd_put_NN (output_bfd
, (bfd_vma
) -1, htab
->elf
.sgotplt
->contents
);
3222 bfd_put_NN (output_bfd
, (bfd_vma
) 0,
3223 htab
->elf
.sgotplt
->contents
+ GOT_ENTRY_SIZE
);
3226 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3231 asection
*output_section
= htab
->elf
.sgot
->output_section
;
3233 if (htab
->elf
.sgot
->size
> 0)
3235 /* Set the first entry in the global offset table to the address of
3236 the dynamic section. */
3237 bfd_vma val
= sdyn
? sec_addr (sdyn
) : 0;
3238 bfd_put_NN (output_bfd
, val
, htab
->elf
.sgot
->contents
);
3241 elf_section_data (output_section
)->this_hdr
.sh_entsize
= GOT_ENTRY_SIZE
;
3244 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */
3245 htab_traverse (htab
->loc_hash_table
,
3246 riscv_elf_finish_local_dynamic_symbol
,
3252 /* Return address for Ith PLT stub in section PLT, for relocation REL
3253 or (bfd_vma) -1 if it should not be included. */
3256 riscv_elf_plt_sym_val (bfd_vma i
, const asection
*plt
,
3257 const arelent
*rel ATTRIBUTE_UNUSED
)
3259 return plt
->vma
+ PLT_HEADER_SIZE
+ i
* PLT_ENTRY_SIZE
;
3262 static enum elf_reloc_type_class
3263 riscv_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3264 const asection
*rel_sec ATTRIBUTE_UNUSED
,
3265 const Elf_Internal_Rela
*rela
)
3267 switch (ELFNN_R_TYPE (rela
->r_info
))
3269 case R_RISCV_RELATIVE
:
3270 return reloc_class_relative
;
3271 case R_RISCV_JUMP_SLOT
:
3272 return reloc_class_plt
;
3274 return reloc_class_copy
;
3276 return reloc_class_normal
;
3280 /* Given the ELF header flags in FLAGS, it returns a string that describes the
3284 riscv_float_abi_string (flagword flags
)
3286 switch (flags
& EF_RISCV_FLOAT_ABI
)
3288 case EF_RISCV_FLOAT_ABI_SOFT
:
3289 return "soft-float";
3291 case EF_RISCV_FLOAT_ABI_SINGLE
:
3292 return "single-float";
3294 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3295 return "double-float";
3297 case EF_RISCV_FLOAT_ABI_QUAD
:
3298 return "quad-float";
3305 /* The information of architecture elf attributes. */
3306 static riscv_subset_list_t in_subsets
;
3307 static riscv_subset_list_t out_subsets
;
3308 static riscv_subset_list_t merged_subsets
;
3310 /* Predicator for standard extension. */
3313 riscv_std_ext_p (const char *name
)
3315 return (strlen (name
) == 1) && (name
[0] != 'x') && (name
[0] != 's');
3318 /* Check if the versions are compatible. */
3321 riscv_version_mismatch (bfd
*ibfd
,
3322 struct riscv_subset_t
*in
,
3323 struct riscv_subset_t
*out
)
3325 if (in
== NULL
|| out
== NULL
)
3328 /* Since there are no version conflicts for now, we just report
3329 warning when the versions are mis-matched. */
3330 if (in
->major_version
!= out
->major_version
3331 || in
->minor_version
!= out
->minor_version
)
3334 (_("warning: %pB: mis-matched ISA version %d.%d for '%s' "
3335 "extension, the output version is %d.%d"),
3341 out
->minor_version
);
3343 /* Update the output ISA versions to the newest ones. */
3344 if ((in
->major_version
> out
->major_version
)
3345 || (in
->major_version
== out
->major_version
3346 && in
->minor_version
> out
->minor_version
))
3348 out
->major_version
= in
->major_version
;
3349 out
->minor_version
= in
->minor_version
;
3356 /* Return true if subset is 'i' or 'e'. */
3359 riscv_i_or_e_p (bfd
*ibfd
,
3361 struct riscv_subset_t
*subset
)
3363 if ((strcasecmp (subset
->name
, "e") != 0)
3364 && (strcasecmp (subset
->name
, "i") != 0))
3367 (_("error: %pB: corrupted ISA string '%s'. "
3368 "First letter should be 'i' or 'e' but got '%s'"),
3369 ibfd
, arch
, subset
->name
);
3375 /* Merge standard extensions.
3378 Return FALSE if failed to merge.
3382 `in_arch`: Raw ISA string for input object.
3383 `out_arch`: Raw ISA string for output object.
3384 `pin`: Subset list for input object.
3385 `pout`: Subset list for output object. */
3388 riscv_merge_std_ext (bfd
*ibfd
,
3389 const char *in_arch
,
3390 const char *out_arch
,
3391 struct riscv_subset_t
**pin
,
3392 struct riscv_subset_t
**pout
)
3394 const char *standard_exts
= riscv_supported_std_ext ();
3396 struct riscv_subset_t
*in
= *pin
;
3397 struct riscv_subset_t
*out
= *pout
;
3399 /* First letter should be 'i' or 'e'. */
3400 if (!riscv_i_or_e_p (ibfd
, in_arch
, in
))
3403 if (!riscv_i_or_e_p (ibfd
, out_arch
, out
))
3406 if (strcasecmp (in
->name
, out
->name
) != 0)
3408 /* TODO: We might allow merge 'i' with 'e'. */
3410 (_("error: %pB: mis-matched ISA string to merge '%s' and '%s'"),
3411 ibfd
, in
->name
, out
->name
);
3414 else if (!riscv_version_mismatch (ibfd
, in
, out
))
3417 riscv_add_subset (&merged_subsets
,
3418 out
->name
, out
->major_version
, out
->minor_version
);
3423 /* Handle standard extension first. */
3424 for (p
= standard_exts
; *p
; ++p
)
3426 struct riscv_subset_t
*ext_in
, *ext_out
, *ext_merged
;
3427 char find_ext
[2] = {*p
, '\0'};
3428 bfd_boolean find_in
, find_out
;
3430 find_in
= riscv_lookup_subset (&in_subsets
, find_ext
, &ext_in
);
3431 find_out
= riscv_lookup_subset (&out_subsets
, find_ext
, &ext_out
);
3433 if (!find_in
&& !find_out
)
3438 && !riscv_version_mismatch (ibfd
, ext_in
, ext_out
))
3441 ext_merged
= find_out
? ext_out
: ext_in
;
3442 riscv_add_subset (&merged_subsets
, ext_merged
->name
,
3443 ext_merged
->major_version
, ext_merged
->minor_version
);
3446 /* Skip all standard extensions. */
3447 while ((in
!= NULL
) && riscv_std_ext_p (in
->name
)) in
= in
->next
;
3448 while ((out
!= NULL
) && riscv_std_ext_p (out
->name
)) out
= out
->next
;
3456 /* Merge multi letter extensions. PIN is a pointer to the head of the input
3457 object subset list. Likewise for POUT and the output object. Return TRUE
3458 on success and FALSE when a conflict is found. */
3461 riscv_merge_multi_letter_ext (bfd
*ibfd
,
3462 riscv_subset_t
**pin
,
3463 riscv_subset_t
**pout
)
3465 riscv_subset_t
*in
= *pin
;
3466 riscv_subset_t
*out
= *pout
;
3467 riscv_subset_t
*tail
;
3473 cmp
= riscv_compare_subsets (in
->name
, out
->name
);
3477 /* `in' comes before `out', append `in' and increment. */
3478 riscv_add_subset (&merged_subsets
, in
->name
, in
->major_version
,
3484 /* `out' comes before `in', append `out' and increment. */
3485 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3486 out
->minor_version
);
3491 /* Both present, check version and increment both. */
3492 if (!riscv_version_mismatch (ibfd
, in
, out
))
3495 riscv_add_subset (&merged_subsets
, out
->name
, out
->major_version
,
3496 out
->minor_version
);
3504 /* If we're here, either `in' or `out' is running longer than
3505 the other. So, we need to append the corresponding tail. */
3506 tail
= in
? in
: out
;
3509 riscv_add_subset (&merged_subsets
, tail
->name
, tail
->major_version
,
3510 tail
->minor_version
);
3518 /* Merge Tag_RISCV_arch attribute. */
3521 riscv_merge_arch_attr_info (bfd
*ibfd
, char *in_arch
, char *out_arch
)
3523 riscv_subset_t
*in
, *out
;
3524 char *merged_arch_str
;
3526 unsigned xlen_in
, xlen_out
;
3527 merged_subsets
.head
= NULL
;
3528 merged_subsets
.tail
= NULL
;
3530 riscv_parse_subset_t rpe_in
;
3531 riscv_parse_subset_t rpe_out
;
3533 /* Only assembler needs to check the default version of ISA, so just set
3534 the rpe_in.get_default_version and rpe_out.get_default_version to NULL. */
3535 rpe_in
.subset_list
= &in_subsets
;
3536 rpe_in
.error_handler
= _bfd_error_handler
;
3537 rpe_in
.xlen
= &xlen_in
;
3538 rpe_in
.get_default_version
= NULL
;
3540 rpe_out
.subset_list
= &out_subsets
;
3541 rpe_out
.error_handler
= _bfd_error_handler
;
3542 rpe_out
.xlen
= &xlen_out
;
3543 rpe_out
.get_default_version
= NULL
;
3545 if (in_arch
== NULL
&& out_arch
== NULL
)
3548 if (in_arch
== NULL
&& out_arch
!= NULL
)
3551 if (in_arch
!= NULL
&& out_arch
== NULL
)
3554 /* Parse subset from ISA string. */
3555 if (!riscv_parse_subset (&rpe_in
, in_arch
))
3558 if (!riscv_parse_subset (&rpe_out
, out_arch
))
3561 /* Checking XLEN. */
3562 if (xlen_out
!= xlen_in
)
3565 (_("error: %pB: ISA string of input (%s) doesn't match "
3566 "output (%s)"), ibfd
, in_arch
, out_arch
);
3570 /* Merge subset list. */
3571 in
= in_subsets
.head
;
3572 out
= out_subsets
.head
;
3574 /* Merge standard extension. */
3575 if (!riscv_merge_std_ext (ibfd
, in_arch
, out_arch
, &in
, &out
))
3578 /* Merge all non-single letter extensions with single call. */
3579 if (!riscv_merge_multi_letter_ext (ibfd
, &in
, &out
))
3582 if (xlen_in
!= xlen_out
)
3585 (_("error: %pB: XLEN of input (%u) doesn't match "
3586 "output (%u)"), ibfd
, xlen_in
, xlen_out
);
3590 if (xlen_in
!= ARCH_SIZE
)
3593 (_("error: %pB: unsupported XLEN (%u), you might be "
3594 "using wrong emulation"), ibfd
, xlen_in
);
3598 merged_arch_str
= riscv_arch_str (ARCH_SIZE
, &merged_subsets
);
3600 /* Release the subset lists. */
3601 riscv_release_subset_list (&in_subsets
);
3602 riscv_release_subset_list (&out_subsets
);
3603 riscv_release_subset_list (&merged_subsets
);
3605 return merged_arch_str
;
3608 /* Merge object attributes from IBFD into output_bfd of INFO.
3609 Raise an error if there are conflicting attributes. */
3612 riscv_merge_attributes (bfd
*ibfd
, struct bfd_link_info
*info
)
3614 bfd
*obfd
= info
->output_bfd
;
3615 obj_attribute
*in_attr
;
3616 obj_attribute
*out_attr
;
3617 bfd_boolean result
= TRUE
;
3618 bfd_boolean priv_attrs_merged
= FALSE
;
3619 const char *sec_name
= get_elf_backend_data (ibfd
)->obj_attrs_section
;
3622 /* Skip linker created files. */
3623 if (ibfd
->flags
& BFD_LINKER_CREATED
)
3626 /* Skip any input that doesn't have an attribute section.
3627 This enables to link object files without attribute section with
3629 if (bfd_get_section_by_name (ibfd
, sec_name
) == NULL
)
3632 if (!elf_known_obj_attributes_proc (obfd
)[0].i
)
3634 /* This is the first object. Copy the attributes. */
3635 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
3637 out_attr
= elf_known_obj_attributes_proc (obfd
);
3639 /* Use the Tag_null value to indicate the attributes have been
3646 in_attr
= elf_known_obj_attributes_proc (ibfd
);
3647 out_attr
= elf_known_obj_attributes_proc (obfd
);
3649 for (i
= LEAST_KNOWN_OBJ_ATTRIBUTE
; i
< NUM_KNOWN_OBJ_ATTRIBUTES
; i
++)
3653 case Tag_RISCV_arch
:
3654 if (!out_attr
[Tag_RISCV_arch
].s
)
3655 out_attr
[Tag_RISCV_arch
].s
= in_attr
[Tag_RISCV_arch
].s
;
3656 else if (in_attr
[Tag_RISCV_arch
].s
3657 && out_attr
[Tag_RISCV_arch
].s
)
3659 /* Check compatible. */
3661 riscv_merge_arch_attr_info (ibfd
,
3662 in_attr
[Tag_RISCV_arch
].s
,
3663 out_attr
[Tag_RISCV_arch
].s
);
3664 if (merged_arch
== NULL
)
3667 out_attr
[Tag_RISCV_arch
].s
= "";
3670 out_attr
[Tag_RISCV_arch
].s
= merged_arch
;
3674 case Tag_RISCV_priv_spec
:
3675 case Tag_RISCV_priv_spec_minor
:
3676 case Tag_RISCV_priv_spec_revision
:
3677 /* If we have handled the privileged elf attributes, then skip it. */
3678 if (!priv_attrs_merged
)
3680 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
3681 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
3682 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
3683 enum riscv_spec_class in_priv_spec
= PRIV_SPEC_CLASS_NONE
;
3684 enum riscv_spec_class out_priv_spec
= PRIV_SPEC_CLASS_NONE
;
3686 /* Get the privileged spec class from elf attributes. */
3687 riscv_get_priv_spec_class_from_numbers (in_attr
[Tag_a
].i
,
3691 riscv_get_priv_spec_class_from_numbers (out_attr
[Tag_a
].i
,
3696 /* Allow to link the object without the privileged specs. */
3697 if (out_priv_spec
== PRIV_SPEC_CLASS_NONE
)
3699 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3700 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3701 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3703 else if (in_priv_spec
!= PRIV_SPEC_CLASS_NONE
3704 && in_priv_spec
!= out_priv_spec
)
3707 (_("warning: %pB use privileged spec version %u.%u.%u but "
3708 "the output use version %u.%u.%u"),
3717 /* The privileged spec v1.9.1 can not be linked with others
3718 since the conflicts, so we plan to drop it in a year or
3720 if (in_priv_spec
== PRIV_SPEC_CLASS_1P9P1
3721 || out_priv_spec
== PRIV_SPEC_CLASS_1P9P1
)
3724 (_("warning: privileged spec version 1.9.1 can not be "
3725 "linked with other spec versions"));
3728 /* Update the output privileged spec to the newest one. */
3729 if (in_priv_spec
> out_priv_spec
)
3731 out_attr
[Tag_a
].i
= in_attr
[Tag_a
].i
;
3732 out_attr
[Tag_b
].i
= in_attr
[Tag_b
].i
;
3733 out_attr
[Tag_c
].i
= in_attr
[Tag_c
].i
;
3736 priv_attrs_merged
= TRUE
;
3740 case Tag_RISCV_unaligned_access
:
3741 out_attr
[i
].i
|= in_attr
[i
].i
;
3744 case Tag_RISCV_stack_align
:
3745 if (out_attr
[i
].i
== 0)
3746 out_attr
[i
].i
= in_attr
[i
].i
;
3747 else if (in_attr
[i
].i
!= 0
3748 && out_attr
[i
].i
!= 0
3749 && out_attr
[i
].i
!= in_attr
[i
].i
)
3752 (_("error: %pB use %u-byte stack aligned but the output "
3753 "use %u-byte stack aligned"),
3754 ibfd
, in_attr
[i
].i
, out_attr
[i
].i
);
3760 result
&= _bfd_elf_merge_unknown_attribute_low (ibfd
, obfd
, i
);
3763 /* If out_attr was copied from in_attr then it won't have a type yet. */
3764 if (in_attr
[i
].type
&& !out_attr
[i
].type
)
3765 out_attr
[i
].type
= in_attr
[i
].type
;
3768 /* Merge Tag_compatibility attributes and any common GNU ones. */
3769 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3772 /* Check for any attributes not known on RISC-V. */
3773 result
&= _bfd_elf_merge_unknown_attribute_list (ibfd
, obfd
);
3778 /* Merge backend specific data from an object file to the output
3779 object file when linking. */
3782 _bfd_riscv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
3784 bfd
*obfd
= info
->output_bfd
;
3785 flagword new_flags
, old_flags
;
3787 if (!is_riscv_elf (ibfd
) || !is_riscv_elf (obfd
))
3790 if (strcmp (bfd_get_target (ibfd
), bfd_get_target (obfd
)) != 0)
3792 (*_bfd_error_handler
)
3793 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3794 " target emulation `%s' does not match `%s'"),
3795 ibfd
, bfd_get_target (ibfd
), bfd_get_target (obfd
));
3799 if (!_bfd_elf_merge_object_attributes (ibfd
, info
))
3802 if (!riscv_merge_attributes (ibfd
, info
))
3805 /* Check to see if the input BFD actually contains any sections. If not,
3806 its flags may not have been initialized either, but it cannot actually
3807 cause any incompatibility. Do not short-circuit dynamic objects; their
3808 section list may be emptied by elf_link_add_object_symbols.
3810 Also check to see if there are no code sections in the input. In this
3811 case, there is no need to check for code specific flags. */
3812 if (!(ibfd
->flags
& DYNAMIC
))
3814 bfd_boolean null_input_bfd
= TRUE
;
3815 bfd_boolean only_data_sections
= TRUE
;
3818 for (sec
= ibfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
3820 null_input_bfd
= FALSE
;
3822 if ((bfd_section_flags (sec
)
3823 & (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3824 == (SEC_LOAD
| SEC_CODE
| SEC_HAS_CONTENTS
))
3826 only_data_sections
= FALSE
;
3831 if (null_input_bfd
|| only_data_sections
)
3835 new_flags
= elf_elfheader (ibfd
)->e_flags
;
3836 old_flags
= elf_elfheader (obfd
)->e_flags
;
3838 if (!elf_flags_init (obfd
))
3840 elf_flags_init (obfd
) = TRUE
;
3841 elf_elfheader (obfd
)->e_flags
= new_flags
;
3845 /* Disallow linking different float ABIs. */
3846 if ((old_flags
^ new_flags
) & EF_RISCV_FLOAT_ABI
)
3848 (*_bfd_error_handler
)
3849 (_("%pB: can't link %s modules with %s modules"), ibfd
,
3850 riscv_float_abi_string (new_flags
),
3851 riscv_float_abi_string (old_flags
));
3855 /* Disallow linking RVE and non-RVE. */
3856 if ((old_flags
^ new_flags
) & EF_RISCV_RVE
)
3858 (*_bfd_error_handler
)
3859 (_("%pB: can't link RVE with other target"), ibfd
);
3863 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3864 elf_elfheader (obfd
)->e_flags
|= new_flags
& EF_RISCV_RVC
;
3869 bfd_set_error (bfd_error_bad_value
);
3873 /* Delete some bytes from a section while relaxing. */
3876 riscv_relax_delete_bytes (bfd
*abfd
, asection
*sec
, bfd_vma addr
, size_t count
,
3877 struct bfd_link_info
*link_info
)
3879 unsigned int i
, symcount
;
3880 bfd_vma toaddr
= sec
->size
;
3881 struct elf_link_hash_entry
**sym_hashes
= elf_sym_hashes (abfd
);
3882 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3883 unsigned int sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
3884 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
3885 bfd_byte
*contents
= data
->this_hdr
.contents
;
3887 /* Actually delete the bytes. */
3889 memmove (contents
+ addr
, contents
+ addr
+ count
, toaddr
- addr
- count
);
3891 /* Adjust the location of all of the relocs. Note that we need not
3892 adjust the addends, since all PC-relative references must be against
3893 symbols, which we will adjust below. */
3894 for (i
= 0; i
< sec
->reloc_count
; i
++)
3895 if (data
->relocs
[i
].r_offset
> addr
&& data
->relocs
[i
].r_offset
< toaddr
)
3896 data
->relocs
[i
].r_offset
-= count
;
3898 /* Adjust the local symbols defined in this section. */
3899 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
3901 Elf_Internal_Sym
*sym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ i
;
3902 if (sym
->st_shndx
== sec_shndx
)
3904 /* If the symbol is in the range of memory we just moved, we
3905 have to adjust its value. */
3906 if (sym
->st_value
> addr
&& sym
->st_value
<= toaddr
)
3907 sym
->st_value
-= count
;
3909 /* If the symbol *spans* the bytes we just deleted (i.e. its
3910 *end* is in the moved bytes but its *start* isn't), then we
3911 must adjust its size.
3913 This test needs to use the original value of st_value, otherwise
3914 we might accidentally decrease size when deleting bytes right
3915 before the symbol. But since deleted relocs can't span across
3916 symbols, we can't have both a st_value and a st_size decrease,
3917 so it is simpler to just use an else. */
3918 else if (sym
->st_value
<= addr
3919 && sym
->st_value
+ sym
->st_size
> addr
3920 && sym
->st_value
+ sym
->st_size
<= toaddr
)
3921 sym
->st_size
-= count
;
3925 /* Now adjust the global symbols defined in this section. */
3926 symcount
= ((symtab_hdr
->sh_size
/ sizeof (ElfNN_External_Sym
))
3927 - symtab_hdr
->sh_info
);
3929 for (i
= 0; i
< symcount
; i
++)
3931 struct elf_link_hash_entry
*sym_hash
= sym_hashes
[i
];
3933 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3934 containing the definition of __wrap_SYMBOL, includes a direct
3935 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3936 the same symbol (which is __wrap_SYMBOL), but still exist as two
3937 different symbols in 'sym_hashes', we don't want to adjust
3938 the global symbol __wrap_SYMBOL twice.
3940 The same problem occurs with symbols that are versioned_hidden, as
3941 foo becomes an alias for foo@BAR, and hence they need the same
3943 if (link_info
->wrap_hash
!= NULL
3944 || sym_hash
->versioned
== versioned_hidden
)
3946 struct elf_link_hash_entry
**cur_sym_hashes
;
3948 /* Loop only over the symbols which have already been checked. */
3949 for (cur_sym_hashes
= sym_hashes
; cur_sym_hashes
< &sym_hashes
[i
];
3952 /* If the current symbol is identical to 'sym_hash', that means
3953 the symbol was already adjusted (or at least checked). */
3954 if (*cur_sym_hashes
== sym_hash
)
3957 /* Don't adjust the symbol again. */
3958 if (cur_sym_hashes
< &sym_hashes
[i
])
3962 if ((sym_hash
->root
.type
== bfd_link_hash_defined
3963 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
3964 && sym_hash
->root
.u
.def
.section
== sec
)
3966 /* As above, adjust the value if needed. */
3967 if (sym_hash
->root
.u
.def
.value
> addr
3968 && sym_hash
->root
.u
.def
.value
<= toaddr
)
3969 sym_hash
->root
.u
.def
.value
-= count
;
3971 /* As above, adjust the size if needed. */
3972 else if (sym_hash
->root
.u
.def
.value
<= addr
3973 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
3974 && sym_hash
->root
.u
.def
.value
+ sym_hash
->size
<= toaddr
)
3975 sym_hash
->size
-= count
;
3982 /* A second format for recording PC-relative hi relocations. This stores the
3983 information required to relax them to GP-relative addresses. */
3985 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc
;
3986 struct riscv_pcgp_hi_reloc
3993 bfd_boolean undefined_weak
;
3994 riscv_pcgp_hi_reloc
*next
;
3997 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc
;
3998 struct riscv_pcgp_lo_reloc
4001 riscv_pcgp_lo_reloc
*next
;
4006 riscv_pcgp_hi_reloc
*hi
;
4007 riscv_pcgp_lo_reloc
*lo
;
4008 } riscv_pcgp_relocs
;
4010 /* Initialize the pcgp reloc info in P. */
4013 riscv_init_pcgp_relocs (riscv_pcgp_relocs
*p
)
4020 /* Free the pcgp reloc info in P. */
4023 riscv_free_pcgp_relocs (riscv_pcgp_relocs
*p
,
4024 bfd
*abfd ATTRIBUTE_UNUSED
,
4025 asection
*sec ATTRIBUTE_UNUSED
)
4027 riscv_pcgp_hi_reloc
*c
;
4028 riscv_pcgp_lo_reloc
*l
;
4030 for (c
= p
->hi
; c
!= NULL
; )
4032 riscv_pcgp_hi_reloc
*next
= c
->next
;
4037 for (l
= p
->lo
; l
!= NULL
; )
4039 riscv_pcgp_lo_reloc
*next
= l
->next
;
4045 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
4046 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
4047 relax the corresponding lo part reloc. */
4050 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
,
4051 bfd_vma hi_addend
, bfd_vma hi_addr
,
4052 unsigned hi_sym
, asection
*sym_sec
,
4053 bfd_boolean undefined_weak
)
4055 riscv_pcgp_hi_reloc
*new = bfd_malloc (sizeof (*new));
4058 new->hi_sec_off
= hi_sec_off
;
4059 new->hi_addend
= hi_addend
;
4060 new->hi_addr
= hi_addr
;
4061 new->hi_sym
= hi_sym
;
4062 new->sym_sec
= sym_sec
;
4063 new->undefined_weak
= undefined_weak
;
4069 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4070 This is used by a lo part reloc to find the corresponding hi part reloc. */
4072 static riscv_pcgp_hi_reloc
*
4073 riscv_find_pcgp_hi_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4075 riscv_pcgp_hi_reloc
*c
;
4077 for (c
= p
->hi
; c
!= NULL
; c
= c
->next
)
4078 if (c
->hi_sec_off
== hi_sec_off
)
4083 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
4084 This is used to record relocs that can't be relaxed. */
4087 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4089 riscv_pcgp_lo_reloc
*new = bfd_malloc (sizeof (*new));
4092 new->hi_sec_off
= hi_sec_off
;
4098 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
4099 This is used by a hi part reloc to find the corresponding lo part reloc. */
4102 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs
*p
, bfd_vma hi_sec_off
)
4104 riscv_pcgp_lo_reloc
*c
;
4106 for (c
= p
->lo
; c
!= NULL
; c
= c
->next
)
4107 if (c
->hi_sec_off
== hi_sec_off
)
4112 typedef bfd_boolean (*relax_func_t
) (bfd
*, asection
*, asection
*,
4113 struct bfd_link_info
*,
4114 Elf_Internal_Rela
*,
4115 bfd_vma
, bfd_vma
, bfd_vma
, bfd_boolean
*,
4116 riscv_pcgp_relocs
*,
4117 bfd_boolean undefined_weak
);
4119 /* Relax AUIPC + JALR into JAL. */
4122 _bfd_riscv_relax_call (bfd
*abfd
, asection
*sec
, asection
*sym_sec
,
4123 struct bfd_link_info
*link_info
,
4124 Elf_Internal_Rela
*rel
,
4126 bfd_vma max_alignment
,
4127 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4129 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4130 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4132 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4133 bfd_vma foff
= symval
- (sec_addr (sec
) + rel
->r_offset
);
4134 bfd_boolean near_zero
= (symval
+ RISCV_IMM_REACH
/ 2) < RISCV_IMM_REACH
;
4135 bfd_vma auipc
, jalr
;
4136 int rd
, r_type
, len
= 4, rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4138 /* If the call crosses section boundaries, an alignment directive could
4139 cause the PC-relative offset to later increase, so we need to add in the
4140 max alignment of any section inclusive from the call to the target.
4141 Otherwise, we only need to use the alignment of the current section. */
4142 if (VALID_JTYPE_IMM (foff
))
4144 if (sym_sec
->output_section
== sec
->output_section
4145 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4146 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4147 foff
+= ((bfd_signed_vma
) foff
< 0 ? -max_alignment
: max_alignment
);
4150 /* See if this function call can be shortened. */
4151 if (!VALID_JTYPE_IMM (foff
) && !(!bfd_link_pic (link_info
) && near_zero
))
4154 /* Shorten the function call. */
4155 BFD_ASSERT (rel
->r_offset
+ 8 <= sec
->size
);
4157 auipc
= bfd_getl32 (contents
+ rel
->r_offset
);
4158 jalr
= bfd_getl32 (contents
+ rel
->r_offset
+ 4);
4159 rd
= (jalr
>> OP_SH_RD
) & OP_MASK_RD
;
4160 rvc
= rvc
&& VALID_CJTYPE_IMM (foff
);
4162 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
4163 rvc
= rvc
&& (rd
== 0 || (rd
== X_RA
&& ARCH_SIZE
== 32));
4167 /* Relax to C.J[AL] rd, addr. */
4168 r_type
= R_RISCV_RVC_JUMP
;
4169 auipc
= rd
== 0 ? MATCH_C_J
: MATCH_C_JAL
;
4172 else if (VALID_JTYPE_IMM (foff
))
4174 /* Relax to JAL rd, addr. */
4175 r_type
= R_RISCV_JAL
;
4176 auipc
= MATCH_JAL
| (rd
<< OP_SH_RD
);
4180 /* Near zero, relax to JALR rd, x0, addr. */
4181 r_type
= R_RISCV_LO12_I
;
4182 auipc
= MATCH_JALR
| (rd
<< OP_SH_RD
);
4185 /* Replace the R_RISCV_CALL reloc. */
4186 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), r_type
);
4187 /* Replace the AUIPC. */
4188 riscv_put_insn (8 * len
, auipc
, contents
+ rel
->r_offset
);
4190 /* Delete unnecessary JALR. */
4192 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ len
, 8 - len
,
4196 /* Traverse all output sections and return the max alignment. */
4199 _bfd_riscv_get_max_alignment (asection
*sec
)
4201 unsigned int max_alignment_power
= 0;
4204 for (o
= sec
->output_section
->owner
->sections
; o
!= NULL
; o
= o
->next
)
4206 if (o
->alignment_power
> max_alignment_power
)
4207 max_alignment_power
= o
->alignment_power
;
4210 return (bfd_vma
) 1 << max_alignment_power
;
4213 /* Relax non-PIC global variable references to GP-relative references. */
4216 _bfd_riscv_relax_lui (bfd
*abfd
,
4219 struct bfd_link_info
*link_info
,
4220 Elf_Internal_Rela
*rel
,
4222 bfd_vma max_alignment
,
4223 bfd_vma reserve_size
,
4225 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4226 bfd_boolean undefined_weak
)
4228 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4229 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4230 int use_rvc
= elf_elfheader (abfd
)->e_flags
& EF_RISCV_RVC
;
4232 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4236 /* If gp and the symbol are in the same output section, which is not the
4237 abs section, then consider only that output section's alignment. */
4238 struct bfd_link_hash_entry
*h
=
4239 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
4241 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4242 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4243 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4246 /* Is the reference in range of x0 or gp?
4247 Valid gp range conservatively because of alignment issue. */
4249 || (VALID_ITYPE_IMM (symval
)
4251 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4253 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4255 unsigned sym
= ELFNN_R_SYM (rel
->r_info
);
4256 switch (ELFNN_R_TYPE (rel
->r_info
))
4258 case R_RISCV_LO12_I
:
4261 /* Change the RS1 to zero. */
4262 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4263 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4264 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4267 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4270 case R_RISCV_LO12_S
:
4273 /* Change the RS1 to zero. */
4274 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4275 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4276 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4279 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4283 /* We can delete the unnecessary LUI and reloc. */
4284 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4286 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4,
4294 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
4295 account for this assuming page alignment at worst. In the presence of
4296 RELRO segment the linker aligns it by one page size, therefore sections
4297 after the segment can be moved more than one page. */
4300 && ELFNN_R_TYPE (rel
->r_info
) == R_RISCV_HI20
4301 && VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (symval
))
4302 && VALID_CITYPE_LUI_IMM (RISCV_CONST_HIGH_PART (symval
)
4303 + (link_info
->relro
? 2 * ELF_MAXPAGESIZE
4304 : ELF_MAXPAGESIZE
)))
4306 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
4307 bfd_vma lui
= bfd_getl32 (contents
+ rel
->r_offset
);
4308 unsigned rd
= ((unsigned)lui
>> OP_SH_RD
) & OP_MASK_RD
;
4309 if (rd
== 0 || rd
== X_SP
)
4312 lui
= (lui
& (OP_MASK_RD
<< OP_SH_RD
)) | MATCH_C_LUI
;
4313 bfd_putl32 (lui
, contents
+ rel
->r_offset
);
4315 /* Replace the R_RISCV_HI20 reloc. */
4316 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_RVC_LUI
);
4319 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ 2, 2,
4326 /* Relax non-PIC TLS references to TP-relative references. */
4329 _bfd_riscv_relax_tls_le (bfd
*abfd
,
4331 asection
*sym_sec ATTRIBUTE_UNUSED
,
4332 struct bfd_link_info
*link_info
,
4333 Elf_Internal_Rela
*rel
,
4335 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4336 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4338 riscv_pcgp_relocs
*prcel_relocs ATTRIBUTE_UNUSED
,
4339 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4341 /* See if this symbol is in range of tp. */
4342 if (RISCV_CONST_HIGH_PART (tpoff (link_info
, symval
)) != 0)
4345 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4346 switch (ELFNN_R_TYPE (rel
->r_info
))
4348 case R_RISCV_TPREL_LO12_I
:
4349 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_I
);
4352 case R_RISCV_TPREL_LO12_S
:
4353 rel
->r_info
= ELFNN_R_INFO (ELFNN_R_SYM (rel
->r_info
), R_RISCV_TPREL_S
);
4356 case R_RISCV_TPREL_HI20
:
4357 case R_RISCV_TPREL_ADD
:
4358 /* We can delete the unnecessary instruction and reloc. */
4359 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4361 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, 4, link_info
);
4368 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
4371 _bfd_riscv_relax_align (bfd
*abfd
, asection
*sec
,
4373 struct bfd_link_info
*link_info
,
4374 Elf_Internal_Rela
*rel
,
4376 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4377 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4378 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4379 riscv_pcgp_relocs
*pcrel_relocs ATTRIBUTE_UNUSED
,
4380 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4382 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4383 bfd_vma alignment
= 1, pos
;
4384 while (alignment
<= rel
->r_addend
)
4387 symval
-= rel
->r_addend
;
4388 bfd_vma aligned_addr
= ((symval
- 1) & ~(alignment
- 1)) + alignment
;
4389 bfd_vma nop_bytes
= aligned_addr
- symval
;
4391 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
4392 sec
->sec_flg0
= TRUE
;
4394 /* Make sure there are enough NOPs to actually achieve the alignment. */
4395 if (rel
->r_addend
< nop_bytes
)
4398 (_("%pB(%pA+%#" PRIx64
"): %" PRId64
" bytes required for alignment "
4399 "to %" PRId64
"-byte boundary, but only %" PRId64
" present"),
4400 abfd
, sym_sec
, (uint64_t) rel
->r_offset
,
4401 (int64_t) nop_bytes
, (int64_t) alignment
, (int64_t) rel
->r_addend
);
4402 bfd_set_error (bfd_error_bad_value
);
4406 /* Delete the reloc. */
4407 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4409 /* If the number of NOPs is already correct, there's nothing to do. */
4410 if (nop_bytes
== rel
->r_addend
)
4413 /* Write as many RISC-V NOPs as we need. */
4414 for (pos
= 0; pos
< (nop_bytes
& -4); pos
+= 4)
4415 bfd_putl32 (RISCV_NOP
, contents
+ rel
->r_offset
+ pos
);
4417 /* Write a final RVC NOP if need be. */
4418 if (nop_bytes
% 4 != 0)
4419 bfd_putl16 (RVC_NOP
, contents
+ rel
->r_offset
+ pos
);
4421 /* Delete the excess bytes. */
4422 return riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
+ nop_bytes
,
4423 rel
->r_addend
- nop_bytes
, link_info
);
4426 /* Relax PC-relative references to GP-relative references. */
4429 _bfd_riscv_relax_pc (bfd
*abfd ATTRIBUTE_UNUSED
,
4432 struct bfd_link_info
*link_info
,
4433 Elf_Internal_Rela
*rel
,
4435 bfd_vma max_alignment
,
4436 bfd_vma reserve_size
,
4437 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4438 riscv_pcgp_relocs
*pcgp_relocs
,
4439 bfd_boolean undefined_weak
)
4441 bfd_byte
*contents
= elf_section_data (sec
)->this_hdr
.contents
;
4442 bfd_vma gp
= riscv_global_pointer_value (link_info
);
4444 BFD_ASSERT (rel
->r_offset
+ 4 <= sec
->size
);
4446 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
4447 actual target address. */
4448 riscv_pcgp_hi_reloc hi_reloc
;
4449 memset (&hi_reloc
, 0, sizeof (hi_reloc
));
4450 switch (ELFNN_R_TYPE (rel
->r_info
))
4452 case R_RISCV_PCREL_LO12_I
:
4453 case R_RISCV_PCREL_LO12_S
:
4455 /* If the %lo has an addend, it isn't for the label pointing at the
4456 hi part instruction, but rather for the symbol pointed at by the
4457 hi part instruction. So we must subtract it here for the lookup.
4458 It is still used below in the final symbol address. */
4459 bfd_vma hi_sec_off
= symval
- sec_addr (sym_sec
) - rel
->r_addend
;
4460 riscv_pcgp_hi_reloc
*hi
= riscv_find_pcgp_hi_reloc (pcgp_relocs
,
4464 riscv_record_pcgp_lo_reloc (pcgp_relocs
, hi_sec_off
);
4469 symval
= hi_reloc
.hi_addr
;
4470 sym_sec
= hi_reloc
.sym_sec
;
4472 /* We can not know whether the undefined weak symbol is referenced
4473 according to the information of R_RISCV_PCREL_LO12_I/S. Therefore,
4474 we have to record the 'undefined_weak' flag when handling the
4475 corresponding R_RISCV_HI20 reloc in riscv_record_pcgp_hi_reloc. */
4476 undefined_weak
= hi_reloc
.undefined_weak
;
4480 case R_RISCV_PCREL_HI20
:
4481 /* Mergeable symbols and code might later move out of range. */
4482 if (! undefined_weak
4483 && sym_sec
->flags
& (SEC_MERGE
| SEC_CODE
))
4486 /* If the cooresponding lo relocation has already been seen then it's not
4487 safe to relax this relocation. */
4488 if (riscv_find_pcgp_lo_reloc (pcgp_relocs
, rel
->r_offset
))
4499 /* If gp and the symbol are in the same output section, which is not the
4500 abs section, then consider only that output section's alignment. */
4501 struct bfd_link_hash_entry
*h
=
4502 bfd_link_hash_lookup (link_info
->hash
, RISCV_GP_SYMBOL
, FALSE
, FALSE
,
4504 if (h
->u
.def
.section
->output_section
== sym_sec
->output_section
4505 && sym_sec
->output_section
!= bfd_abs_section_ptr
)
4506 max_alignment
= (bfd_vma
) 1 << sym_sec
->output_section
->alignment_power
;
4509 /* Is the reference in range of x0 or gp?
4510 Valid gp range conservatively because of alignment issue. */
4512 || (VALID_ITYPE_IMM (symval
)
4514 && VALID_ITYPE_IMM (symval
- gp
+ max_alignment
+ reserve_size
))
4516 && VALID_ITYPE_IMM (symval
- gp
- max_alignment
- reserve_size
))))
4518 unsigned sym
= hi_reloc
.hi_sym
;
4519 switch (ELFNN_R_TYPE (rel
->r_info
))
4521 case R_RISCV_PCREL_LO12_I
:
4524 /* Change the RS1 to zero, and then modify the relocation
4525 type to R_RISCV_LO12_I. */
4526 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4527 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4528 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4529 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_I
);
4530 rel
->r_addend
= hi_reloc
.hi_addend
;
4534 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_I
);
4535 rel
->r_addend
+= hi_reloc
.hi_addend
;
4539 case R_RISCV_PCREL_LO12_S
:
4542 /* Change the RS1 to zero, and then modify the relocation
4543 type to R_RISCV_LO12_S. */
4544 bfd_vma insn
= bfd_getl32 (contents
+ rel
->r_offset
);
4545 insn
&= ~(OP_MASK_RS1
<< OP_SH_RS1
);
4546 bfd_putl32 (insn
, contents
+ rel
->r_offset
);
4547 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_LO12_S
);
4548 rel
->r_addend
= hi_reloc
.hi_addend
;
4552 rel
->r_info
= ELFNN_R_INFO (sym
, R_RISCV_GPREL_S
);
4553 rel
->r_addend
+= hi_reloc
.hi_addend
;
4557 case R_RISCV_PCREL_HI20
:
4558 riscv_record_pcgp_hi_reloc (pcgp_relocs
,
4562 ELFNN_R_SYM(rel
->r_info
),
4565 /* We can delete the unnecessary AUIPC and reloc. */
4566 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_DELETE
);
4578 /* Delete the bytes for R_RISCV_DELETE. */
4581 _bfd_riscv_relax_delete (bfd
*abfd
,
4583 asection
*sym_sec ATTRIBUTE_UNUSED
,
4584 struct bfd_link_info
*link_info
,
4585 Elf_Internal_Rela
*rel
,
4586 bfd_vma symval ATTRIBUTE_UNUSED
,
4587 bfd_vma max_alignment ATTRIBUTE_UNUSED
,
4588 bfd_vma reserve_size ATTRIBUTE_UNUSED
,
4589 bfd_boolean
*again ATTRIBUTE_UNUSED
,
4590 riscv_pcgp_relocs
*pcgp_relocs ATTRIBUTE_UNUSED
,
4591 bfd_boolean undefined_weak ATTRIBUTE_UNUSED
)
4593 if (!riscv_relax_delete_bytes (abfd
, sec
, rel
->r_offset
, rel
->r_addend
,
4596 rel
->r_info
= ELFNN_R_INFO (0, R_RISCV_NONE
);
4602 Pass 0: Shortens code sequences for LUI/CALL/TPREL relocs.
4603 Pass 1: Shortens code sequences for PCREL relocs.
4604 Pass 2: Deletes the bytes that pass 1 made obselete.
4605 Pass 3: Which cannot be disabled, handles code alignment directives. */
4608 _bfd_riscv_relax_section (bfd
*abfd
, asection
*sec
,
4609 struct bfd_link_info
*info
,
4612 Elf_Internal_Shdr
*symtab_hdr
= &elf_symtab_hdr (abfd
);
4613 struct riscv_elf_link_hash_table
*htab
= riscv_elf_hash_table (info
);
4614 struct bfd_elf_section_data
*data
= elf_section_data (sec
);
4615 Elf_Internal_Rela
*relocs
;
4616 bfd_boolean ret
= FALSE
;
4618 bfd_vma max_alignment
, reserve_size
= 0;
4619 riscv_pcgp_relocs pcgp_relocs
;
4623 if (bfd_link_relocatable (info
)
4625 || (sec
->flags
& SEC_RELOC
) == 0
4626 || sec
->reloc_count
== 0
4627 || (info
->disable_target_specific_optimizations
4628 && info
->relax_pass
< 2))
4631 riscv_init_pcgp_relocs (&pcgp_relocs
);
4633 /* Read this BFD's relocs if we haven't done so already. */
4635 relocs
= data
->relocs
;
4636 else if (!(relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
4637 info
->keep_memory
)))
4642 max_alignment
= htab
->max_alignment
;
4643 if (max_alignment
== (bfd_vma
) -1)
4645 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4646 htab
->max_alignment
= max_alignment
;
4650 max_alignment
= _bfd_riscv_get_max_alignment (sec
);
4652 /* Examine and consider relaxing each reloc. */
4653 for (i
= 0; i
< sec
->reloc_count
; i
++)
4656 Elf_Internal_Rela
*rel
= relocs
+ i
;
4657 relax_func_t relax_func
;
4658 int type
= ELFNN_R_TYPE (rel
->r_info
);
4661 bfd_boolean undefined_weak
= FALSE
;
4664 if (info
->relax_pass
== 0)
4666 if (type
== R_RISCV_CALL
4667 || type
== R_RISCV_CALL_PLT
)
4668 relax_func
= _bfd_riscv_relax_call
;
4669 else if (type
== R_RISCV_HI20
4670 || type
== R_RISCV_LO12_I
4671 || type
== R_RISCV_LO12_S
)
4672 relax_func
= _bfd_riscv_relax_lui
;
4673 else if (type
== R_RISCV_TPREL_HI20
4674 || type
== R_RISCV_TPREL_ADD
4675 || type
== R_RISCV_TPREL_LO12_I
4676 || type
== R_RISCV_TPREL_LO12_S
)
4677 relax_func
= _bfd_riscv_relax_tls_le
;
4681 else if (info
->relax_pass
== 1
4682 && !bfd_link_pic (info
)
4683 && (type
== R_RISCV_PCREL_HI20
4684 || type
== R_RISCV_PCREL_LO12_I
4685 || type
== R_RISCV_PCREL_LO12_S
))
4686 relax_func
= _bfd_riscv_relax_pc
;
4687 else if (info
->relax_pass
== 2 && type
== R_RISCV_DELETE
)
4688 relax_func
= _bfd_riscv_relax_delete
;
4689 else if (info
->relax_pass
== 3 && type
== R_RISCV_ALIGN
)
4690 relax_func
= _bfd_riscv_relax_align
;
4694 if (info
->relax_pass
< 2)
4696 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
4697 if (i
== sec
->reloc_count
- 1
4698 || ELFNN_R_TYPE ((rel
+ 1)->r_info
) != R_RISCV_RELAX
4699 || rel
->r_offset
!= (rel
+ 1)->r_offset
)
4702 /* Skip over the R_RISCV_RELAX. */
4706 data
->relocs
= relocs
;
4708 /* Read this BFD's contents if we haven't done so already. */
4709 if (!data
->this_hdr
.contents
4710 && !bfd_malloc_and_get_section (abfd
, sec
, &data
->this_hdr
.contents
))
4713 /* Read this BFD's symbols if we haven't done so already. */
4714 if (symtab_hdr
->sh_info
!= 0
4715 && !symtab_hdr
->contents
4716 && !(symtab_hdr
->contents
=
4717 (unsigned char *) bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
4718 symtab_hdr
->sh_info
,
4719 0, NULL
, NULL
, NULL
)))
4722 /* Get the value of the symbol referred to by the reloc. */
4723 if (ELFNN_R_SYM (rel
->r_info
) < symtab_hdr
->sh_info
)
4725 /* A local symbol. */
4726 Elf_Internal_Sym
*isym
= ((Elf_Internal_Sym
*) symtab_hdr
->contents
4727 + ELFNN_R_SYM (rel
->r_info
));
4728 reserve_size
= (isym
->st_size
- rel
->r_addend
) > isym
->st_size
4729 ? 0 : isym
->st_size
- rel
->r_addend
;
4731 /* Relocate against local STT_GNU_IFUNC symbol. we have created
4732 a fake global symbol entry for this, so deal with the local ifunc
4734 if (ELF_ST_TYPE (isym
->st_info
) == STT_GNU_IFUNC
)
4737 if (isym
->st_shndx
== SHN_UNDEF
)
4738 sym_sec
= sec
, symval
= rel
->r_offset
;
4741 BFD_ASSERT (isym
->st_shndx
< elf_numsections (abfd
));
4742 sym_sec
= elf_elfsections (abfd
)[isym
->st_shndx
]->bfd_section
;
4744 /* The purpose of this code is unknown. It breaks linker scripts
4745 for embedded development that place sections at address zero.
4746 This code is believed to be unnecessary. Disabling it but not
4747 yet removing it, in case something breaks. */
4748 if (sec_addr (sym_sec
) == 0)
4751 symval
= isym
->st_value
;
4753 symtype
= ELF_ST_TYPE (isym
->st_info
);
4758 struct elf_link_hash_entry
*h
;
4760 indx
= ELFNN_R_SYM (rel
->r_info
) - symtab_hdr
->sh_info
;
4761 h
= elf_sym_hashes (abfd
)[indx
];
4763 while (h
->root
.type
== bfd_link_hash_indirect
4764 || h
->root
.type
== bfd_link_hash_warning
)
4765 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4767 /* Disable the relaxation for ifunc. */
4768 if (h
!= NULL
&& h
->type
== STT_GNU_IFUNC
)
4771 if (h
->root
.type
== bfd_link_hash_undefweak
4772 && (relax_func
== _bfd_riscv_relax_lui
4773 || relax_func
== _bfd_riscv_relax_pc
))
4775 /* For the lui and auipc relaxations, since the symbol
4776 value of an undefined weak symbol is always be zero,
4777 we can optimize the patterns into a single LI/MV/ADDI
4780 Note that, creating shared libraries and pie output may
4781 break the rule above. Fortunately, since we do not relax
4782 pc relocs when creating shared libraries and pie output,
4783 and the absolute address access for R_RISCV_HI20 isn't
4784 allowed when "-fPIC" is set, the problem of creating shared
4785 libraries can not happen currently. Once we support the
4786 auipc relaxations when creating shared libraries, then we will
4787 need the more rigorous checking for this optimization. */
4788 undefined_weak
= TRUE
;
4791 /* This line has to match the check in riscv_elf_relocate_section
4792 in the R_RISCV_CALL[_PLT] case. */
4793 if (bfd_link_pic (info
) && h
->plt
.offset
!= MINUS_ONE
)
4795 sym_sec
= htab
->elf
.splt
;
4796 symval
= h
->plt
.offset
;
4798 else if (undefined_weak
)
4801 sym_sec
= bfd_und_section_ptr
;
4803 else if ((h
->root
.type
== bfd_link_hash_defined
4804 || h
->root
.type
== bfd_link_hash_defweak
)
4805 && h
->root
.u
.def
.section
!= NULL
4806 && h
->root
.u
.def
.section
->output_section
!= NULL
)
4808 symval
= h
->root
.u
.def
.value
;
4809 sym_sec
= h
->root
.u
.def
.section
;
4814 if (h
->type
!= STT_FUNC
)
4816 (h
->size
- rel
->r_addend
) > h
->size
? 0 : h
->size
- rel
->r_addend
;
4820 if (sym_sec
->sec_info_type
== SEC_INFO_TYPE_MERGE
4821 && (sym_sec
->flags
& SEC_MERGE
))
4823 /* At this stage in linking, no SEC_MERGE symbol has been
4824 adjusted, so all references to such symbols need to be
4825 passed through _bfd_merged_section_offset. (Later, in
4826 relocate_section, all SEC_MERGE symbols *except* for
4827 section symbols have been adjusted.)
4829 gas may reduce relocations against symbols in SEC_MERGE
4830 sections to a relocation against the section symbol when
4831 the original addend was zero. When the reloc is against
4832 a section symbol we should include the addend in the
4833 offset passed to _bfd_merged_section_offset, since the
4834 location of interest is the original symbol. On the
4835 other hand, an access to "sym+addend" where "sym" is not
4836 a section symbol should not include the addend; Such an
4837 access is presumed to be an offset from "sym"; The
4838 location of interest is just "sym". */
4839 if (symtype
== STT_SECTION
)
4840 symval
+= rel
->r_addend
;
4842 symval
= _bfd_merged_section_offset (abfd
, &sym_sec
,
4843 elf_section_data (sym_sec
)->sec_info
,
4846 if (symtype
!= STT_SECTION
)
4847 symval
+= rel
->r_addend
;
4850 symval
+= rel
->r_addend
;
4852 symval
+= sec_addr (sym_sec
);
4854 if (!relax_func (abfd
, sec
, sym_sec
, info
, rel
, symval
,
4855 max_alignment
, reserve_size
, again
,
4856 &pcgp_relocs
, undefined_weak
))
4863 if (relocs
!= data
->relocs
)
4865 riscv_free_pcgp_relocs (&pcgp_relocs
, abfd
, sec
);
4871 # define PRSTATUS_SIZE 204
4872 # define PRSTATUS_OFFSET_PR_CURSIG 12
4873 # define PRSTATUS_OFFSET_PR_PID 24
4874 # define PRSTATUS_OFFSET_PR_REG 72
4875 # define ELF_GREGSET_T_SIZE 128
4876 # define PRPSINFO_SIZE 128
4877 # define PRPSINFO_OFFSET_PR_PID 16
4878 # define PRPSINFO_OFFSET_PR_FNAME 32
4879 # define PRPSINFO_OFFSET_PR_PSARGS 48
4880 # define PRPSINFO_PR_FNAME_LENGTH 16
4881 # define PRPSINFO_PR_PSARGS_LENGTH 80
4883 # define PRSTATUS_SIZE 376
4884 # define PRSTATUS_OFFSET_PR_CURSIG 12
4885 # define PRSTATUS_OFFSET_PR_PID 32
4886 # define PRSTATUS_OFFSET_PR_REG 112
4887 # define ELF_GREGSET_T_SIZE 256
4888 # define PRPSINFO_SIZE 136
4889 # define PRPSINFO_OFFSET_PR_PID 24
4890 # define PRPSINFO_OFFSET_PR_FNAME 40
4891 # define PRPSINFO_OFFSET_PR_PSARGS 56
4892 # define PRPSINFO_PR_FNAME_LENGTH 16
4893 # define PRPSINFO_PR_PSARGS_LENGTH 80
4896 /* Write PRSTATUS and PRPSINFO note into core file. This will be called
4897 before the generic code in elf.c. By checking the compiler defines we
4898 only perform any action here if the generic code would otherwise not be
4899 able to help us. The intention is that bare metal core dumps (where the
4900 prstatus_t and/or prpsinfo_t might not be available) will use this code,
4901 while non bare metal tools will use the generic elf code. */
4904 riscv_write_core_note (bfd
*abfd ATTRIBUTE_UNUSED
,
4905 char *buf ATTRIBUTE_UNUSED
,
4906 int *bufsiz ATTRIBUTE_UNUSED
,
4907 int note_type ATTRIBUTE_UNUSED
, ...)
4914 #if !defined (HAVE_PRPSINFO_T)
4917 char data
[PRPSINFO_SIZE
] ATTRIBUTE_NONSTRING
;
4920 va_start (ap
, note_type
);
4921 memset (data
, 0, sizeof (data
));
4922 strncpy (data
+ PRPSINFO_OFFSET_PR_FNAME
, va_arg (ap
, const char *),
4923 PRPSINFO_PR_FNAME_LENGTH
);
4924 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
4926 /* GCC 8.0 and 8.1 warn about 80 equals destination size with
4927 -Wstringop-truncation:
4928 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85643
4930 DIAGNOSTIC_IGNORE_STRINGOP_TRUNCATION
;
4932 strncpy (data
+ PRPSINFO_OFFSET_PR_PSARGS
, va_arg (ap
, const char *),
4933 PRPSINFO_PR_PSARGS_LENGTH
);
4934 #if GCC_VERSION == 8000 || GCC_VERSION == 8001
4938 return elfcore_write_note (abfd
, buf
, bufsiz
,
4939 "CORE", note_type
, data
, sizeof (data
));
4941 #endif /* !HAVE_PRPSINFO_T */
4943 #if !defined (HAVE_PRSTATUS_T)
4946 char data
[PRSTATUS_SIZE
];
4952 va_start (ap
, note_type
);
4953 memset (data
, 0, sizeof(data
));
4954 pid
= va_arg (ap
, long);
4955 bfd_put_32 (abfd
, pid
, data
+ PRSTATUS_OFFSET_PR_PID
);
4956 cursig
= va_arg (ap
, int);
4957 bfd_put_16 (abfd
, cursig
, data
+ PRSTATUS_OFFSET_PR_CURSIG
);
4958 greg
= va_arg (ap
, const void *);
4959 memcpy (data
+ PRSTATUS_OFFSET_PR_REG
, greg
,
4960 PRSTATUS_SIZE
- PRSTATUS_OFFSET_PR_REG
- ARCH_SIZE
/ 8);
4962 return elfcore_write_note (abfd
, buf
, bufsiz
,
4963 "CORE", note_type
, data
, sizeof (data
));
4965 #endif /* !HAVE_PRSTATUS_T */
4969 /* Support for core dump NOTE sections. */
4972 riscv_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4974 switch (note
->descsz
)
4979 case PRSTATUS_SIZE
: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4981 elf_tdata (abfd
)->core
->signal
4982 = bfd_get_16 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_CURSIG
);
4985 elf_tdata (abfd
)->core
->lwpid
4986 = bfd_get_32 (abfd
, note
->descdata
+ PRSTATUS_OFFSET_PR_PID
);
4990 /* Make a ".reg/999" section. */
4991 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", ELF_GREGSET_T_SIZE
,
4992 note
->descpos
+ PRSTATUS_OFFSET_PR_REG
);
4996 riscv_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4998 switch (note
->descsz
)
5003 case PRPSINFO_SIZE
: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
5005 elf_tdata (abfd
)->core
->pid
5006 = bfd_get_32 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PID
);
5009 elf_tdata (abfd
)->core
->program
= _bfd_elfcore_strndup
5010 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_FNAME
,
5011 PRPSINFO_PR_FNAME_LENGTH
);
5014 elf_tdata (abfd
)->core
->command
= _bfd_elfcore_strndup
5015 (abfd
, note
->descdata
+ PRPSINFO_OFFSET_PR_PSARGS
,
5016 PRPSINFO_PR_PSARGS_LENGTH
);
5020 /* Note that for some reason, a spurious space is tacked
5021 onto the end of the args in some (at least one anyway)
5022 implementations, so strip it off if it exists. */
5025 char *command
= elf_tdata (abfd
)->core
->command
;
5026 int n
= strlen (command
);
5028 if (0 < n
&& command
[n
- 1] == ' ')
5029 command
[n
- 1] = '\0';
5035 /* Set the right mach type. */
5038 riscv_elf_object_p (bfd
*abfd
)
5040 /* There are only two mach types in RISCV currently. */
5041 if (strcmp (abfd
->xvec
->name
, "elf32-littleriscv") == 0
5042 || strcmp (abfd
->xvec
->name
, "elf32-bigriscv") == 0)
5043 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv32
);
5045 bfd_default_set_arch_mach (abfd
, bfd_arch_riscv
, bfd_mach_riscv64
);
5050 /* Determine whether an object attribute tag takes an integer, a
5054 riscv_elf_obj_attrs_arg_type (int tag
)
5056 return (tag
& 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL
: ATTR_TYPE_FLAG_INT_VAL
;
5059 #define TARGET_LITTLE_SYM riscv_elfNN_vec
5060 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
5061 #define TARGET_BIG_SYM riscv_elfNN_be_vec
5062 #define TARGET_BIG_NAME "elfNN-bigriscv"
5064 #define elf_backend_reloc_type_class riscv_reloc_type_class
5066 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
5067 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
5068 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
5069 #define bfd_elfNN_bfd_merge_private_bfd_data \
5070 _bfd_riscv_elf_merge_private_bfd_data
5072 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
5073 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
5074 #define elf_backend_check_relocs riscv_elf_check_relocs
5075 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
5076 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
5077 #define elf_backend_relocate_section riscv_elf_relocate_section
5078 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
5079 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
5080 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
5081 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
5082 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
5083 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
5084 #define elf_backend_object_p riscv_elf_object_p
5085 #define elf_backend_write_core_note riscv_write_core_note
5086 #define elf_info_to_howto_rel NULL
5087 #define elf_info_to_howto riscv_info_to_howto_rela
5088 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
5089 #define bfd_elfNN_mkobject elfNN_riscv_mkobject
5091 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
5093 #define elf_backend_can_gc_sections 1
5094 #define elf_backend_can_refcount 1
5095 #define elf_backend_want_got_plt 1
5096 #define elf_backend_plt_readonly 1
5097 #define elf_backend_plt_alignment 4
5098 #define elf_backend_want_plt_sym 1
5099 #define elf_backend_got_header_size (ARCH_SIZE / 8)
5100 #define elf_backend_want_dynrelro 1
5101 #define elf_backend_rela_normal 1
5102 #define elf_backend_default_execstack 0
5104 #undef elf_backend_obj_attrs_vendor
5105 #define elf_backend_obj_attrs_vendor "riscv"
5106 #undef elf_backend_obj_attrs_arg_type
5107 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
5108 #undef elf_backend_obj_attrs_section_type
5109 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
5110 #undef elf_backend_obj_attrs_section
5111 #define elf_backend_obj_attrs_section ".riscv.attributes"
5113 #include "elfNN-target.h"