1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2018 Free Software Foundation, Inc.
4 Contributed by Andrew Waterman (andrew@sifive.com).
5 Based on TILE-Gx and MIPS targets.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not,
21 see <http://www.gnu.org/licenses/>. */
23 /* This file handles RISC-V ELF targets. */
31 #include "elfxx-riscv.h"
32 #include "elf/riscv.h"
33 #include "opcode/riscv.h"
35 /* Internal relocations used exclusively by the relaxation pass. */
36 #define R_RISCV_DELETE (R_RISCV_max + 1)
40 #define MINUS_ONE ((bfd_vma)0 - 1)
42 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
44 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
46 /* The name of the dynamic interpreter. This is put in the .interp
49 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
50 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
52 #define ELF_ARCH bfd_arch_riscv
53 #define ELF_TARGET_ID RISCV_ELF_DATA
54 #define ELF_MACHINE_CODE EM_RISCV
55 #define ELF_MAXPAGESIZE 0x1000
56 #define ELF_COMMONPAGESIZE 0x1000
58 /* RISC-V ELF linker hash entry. */
60 struct riscv_elf_link_hash_entry
62 struct elf_link_hash_entry elf;
64 /* Track dynamic relocs copied for this symbol. */
65 struct elf_dyn_relocs *dyn_relocs;
75 #define riscv_elf_hash_entry(ent) \
76 ((struct riscv_elf_link_hash_entry *)(ent))
78 struct _bfd_riscv_elf_obj_tdata
80 struct elf_obj_tdata root;
82 /* tls_type for each local got entry. */
83 char *local_got_tls_type;
86 #define _bfd_riscv_elf_tdata(abfd) \
87 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
89 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
90 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
92 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
93 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
94 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
96 #define is_riscv_elf(bfd) \
97 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
98 && elf_tdata (bfd) != NULL \
99 && elf_object_id (bfd) == RISCV_ELF_DATA)
101 #include "elf/common.h"
102 #include "elf/internal.h"
104 struct riscv_elf_link_hash_table
106 struct elf_link_hash_table elf;
108 /* Short-cuts to get to dynamic linker sections. */
111 /* Small local sym to section mapping cache. */
112 struct sym_cache sym_cache;
114 /* The max alignment of output sections. */
115 bfd_vma max_alignment;
119 /* Get the RISC-V ELF linker hash table from a link_info structure. */
120 #define riscv_elf_hash_table(p) \
121 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
122 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
125 riscv_info_to_howto_rela (bfd *abfd,
127 Elf_Internal_Rela *dst)
129 cache_ptr->howto = riscv_elf_rtype_to_howto (abfd, ELFNN_R_TYPE (dst->r_info));
130 return cache_ptr->howto != NULL;
134 riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
136 const struct elf_backend_data *bed;
139 bed = get_elf_backend_data (abfd);
140 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
141 bed->s->swap_reloca_out (abfd, rel, loc);
146 #define PLT_HEADER_INSNS 8
147 #define PLT_ENTRY_INSNS 4
148 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
149 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
151 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
153 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
155 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
158 riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info)
160 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt)
161 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE);
165 # define MATCH_LREG MATCH_LW
167 # define MATCH_LREG MATCH_LD
170 /* Generate a PLT header. */
173 riscv_make_plt_header (bfd *output_bfd, bfd_vma gotplt_addr, bfd_vma addr,
176 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr);
177 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr);
179 /* RVE has no t3 register, so this won't work, and is not supported. */
180 if (elf_elfheader (output_bfd)->e_flags & EF_RISCV_RVE)
182 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
187 /* auipc t2, %hi(.got.plt)
188 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
189 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
190 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
191 addi t0, t2, %lo(.got.plt) # &.got.plt
192 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
193 l[w|d] t0, PTRSIZE(t0) # link map
196 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high);
197 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3);
198 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low);
199 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, -(PLT_HEADER_SIZE + 12));
200 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low);
201 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES);
202 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES);
203 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0);
208 /* Generate a PLT entry. */
211 riscv_make_plt_entry (bfd *output_bfd, bfd_vma got, bfd_vma addr,
214 /* RVE has no t3 register, so this won't work, and is not supported. */
215 if (elf_elfheader (output_bfd)->e_flags & EF_RISCV_RVE)
217 _bfd_error_handler (_("%pB: warning: RVE PLT generation not supported"),
222 /* auipc t3, %hi(.got.plt entry)
223 l[w|d] t3, %lo(.got.plt entry)(t3)
227 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr));
228 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr));
229 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0);
230 entry[3] = RISCV_NOP;
235 /* Create an entry in an RISC-V ELF linker hash table. */
237 static struct bfd_hash_entry *
238 link_hash_newfunc (struct bfd_hash_entry *entry,
239 struct bfd_hash_table *table, const char *string)
241 /* Allocate the structure if it has not already been allocated by a
246 bfd_hash_allocate (table,
247 sizeof (struct riscv_elf_link_hash_entry));
252 /* Call the allocation method of the superclass. */
253 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
256 struct riscv_elf_link_hash_entry *eh;
258 eh = (struct riscv_elf_link_hash_entry *) entry;
259 eh->dyn_relocs = NULL;
260 eh->tls_type = GOT_UNKNOWN;
266 /* Create a RISC-V ELF linker hash table. */
268 static struct bfd_link_hash_table *
269 riscv_elf_link_hash_table_create (bfd *abfd)
271 struct riscv_elf_link_hash_table *ret;
272 bfd_size_type amt = sizeof (struct riscv_elf_link_hash_table);
274 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt);
278 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
279 sizeof (struct riscv_elf_link_hash_entry),
286 ret->max_alignment = (bfd_vma) -1;
287 return &ret->elf.root;
290 /* Create the .got section. */
293 riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
297 struct elf_link_hash_entry *h;
298 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
299 struct elf_link_hash_table *htab = elf_hash_table (info);
301 /* This function may be called more than once. */
302 if (htab->sgot != NULL)
305 flags = bed->dynamic_sec_flags;
307 s = bfd_make_section_anyway_with_flags (abfd,
308 (bed->rela_plts_and_copies_p
309 ? ".rela.got" : ".rel.got"),
310 (bed->dynamic_sec_flags
313 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
317 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
319 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
323 /* The first bit of the global offset table is the header. */
324 s->size += bed->got_header_size;
326 if (bed->want_got_plt)
328 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
330 || !bfd_set_section_alignment (abfd, s,
331 bed->s->log_file_align))
335 /* Reserve room for the header. */
336 s->size += GOTPLT_HEADER_SIZE;
339 if (bed->want_got_sym)
341 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
342 section. We don't do this in the linker script because we don't want
343 to define the symbol if we are not creating a global offset
345 h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
346 "_GLOBAL_OFFSET_TABLE_");
347 elf_hash_table (info)->hgot = h;
355 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
356 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
360 riscv_elf_create_dynamic_sections (bfd *dynobj,
361 struct bfd_link_info *info)
363 struct riscv_elf_link_hash_table *htab;
365 htab = riscv_elf_hash_table (info);
366 BFD_ASSERT (htab != NULL);
368 if (!riscv_elf_create_got_section (dynobj, info))
371 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
374 if (!bfd_link_pic (info))
377 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",
378 (SEC_ALLOC | SEC_THREAD_LOCAL
379 | SEC_LINKER_CREATED));
382 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss
383 || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata)))
389 /* Copy the extra info we tack onto an elf_link_hash_entry. */
392 riscv_elf_copy_indirect_symbol (struct bfd_link_info *info,
393 struct elf_link_hash_entry *dir,
394 struct elf_link_hash_entry *ind)
396 struct riscv_elf_link_hash_entry *edir, *eind;
398 edir = (struct riscv_elf_link_hash_entry *) dir;
399 eind = (struct riscv_elf_link_hash_entry *) ind;
401 if (eind->dyn_relocs != NULL)
403 if (edir->dyn_relocs != NULL)
405 struct elf_dyn_relocs **pp;
406 struct elf_dyn_relocs *p;
408 /* Add reloc counts against the indirect sym to the direct sym
409 list. Merge any entries against the same section. */
410 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
412 struct elf_dyn_relocs *q;
414 for (q = edir->dyn_relocs; q != NULL; q = q->next)
415 if (q->sec == p->sec)
417 q->pc_count += p->pc_count;
418 q->count += p->count;
425 *pp = edir->dyn_relocs;
428 edir->dyn_relocs = eind->dyn_relocs;
429 eind->dyn_relocs = NULL;
432 if (ind->root.type == bfd_link_hash_indirect
433 && dir->got.refcount <= 0)
435 edir->tls_type = eind->tls_type;
436 eind->tls_type = GOT_UNKNOWN;
438 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
442 riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h,
443 unsigned long symndx, char tls_type)
445 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx);
447 *new_tls_type |= tls_type;
448 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))
450 (*_bfd_error_handler)
451 (_("%pB: `%s' accessed both as normal and thread local symbol"),
452 abfd, h ? h->root.root.string : "<local>");
459 riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info,
460 struct elf_link_hash_entry *h, long symndx)
462 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
463 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
465 if (htab->elf.sgot == NULL)
467 if (!riscv_elf_create_got_section (htab->elf.dynobj, info))
473 h->got.refcount += 1;
477 /* This is a global offset table entry for a local symbol. */
478 if (elf_local_got_refcounts (abfd) == NULL)
480 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1);
481 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size)))
483 _bfd_riscv_elf_local_got_tls_type (abfd)
484 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info);
486 elf_local_got_refcounts (abfd) [symndx] += 1;
492 bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h)
494 reloc_howto_type * r = riscv_elf_rtype_to_howto (abfd, r_type);
496 (*_bfd_error_handler)
497 (_("%pB: relocation %s against `%s' can not be used when making a shared "
498 "object; recompile with -fPIC"),
499 abfd, r ? r->name : _("<unknown>"),
500 h != NULL ? h->root.root.string : "a local symbol");
501 bfd_set_error (bfd_error_bad_value);
504 /* Look through the relocs for a section during the first phase, and
505 allocate space in the global offset table or procedure linkage
509 riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
510 asection *sec, const Elf_Internal_Rela *relocs)
512 struct riscv_elf_link_hash_table *htab;
513 Elf_Internal_Shdr *symtab_hdr;
514 struct elf_link_hash_entry **sym_hashes;
515 const Elf_Internal_Rela *rel;
516 asection *sreloc = NULL;
518 if (bfd_link_relocatable (info))
521 htab = riscv_elf_hash_table (info);
522 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
523 sym_hashes = elf_sym_hashes (abfd);
525 if (htab->elf.dynobj == NULL)
526 htab->elf.dynobj = abfd;
528 for (rel = relocs; rel < relocs + sec->reloc_count; rel++)
531 unsigned int r_symndx;
532 struct elf_link_hash_entry *h;
534 r_symndx = ELFNN_R_SYM (rel->r_info);
535 r_type = ELFNN_R_TYPE (rel->r_info);
537 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
539 (*_bfd_error_handler) (_("%pB: bad symbol index: %d"),
544 if (r_symndx < symtab_hdr->sh_info)
548 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
549 while (h->root.type == bfd_link_hash_indirect
550 || h->root.type == bfd_link_hash_warning)
551 h = (struct elf_link_hash_entry *) h->root.u.i.link;
556 case R_RISCV_TLS_GD_HI20:
557 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
558 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD))
562 case R_RISCV_TLS_GOT_HI20:
563 if (bfd_link_pic (info))
564 info->flags |= DF_STATIC_TLS;
565 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
566 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE))
570 case R_RISCV_GOT_HI20:
571 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
572 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL))
576 case R_RISCV_CALL_PLT:
577 /* This symbol requires a procedure linkage table entry. We
578 actually build the entry in adjust_dynamic_symbol,
579 because this might be a case of linking PIC code without
580 linking in any dynamic objects, in which case we don't
581 need to generate a procedure linkage table after all. */
586 h->plt.refcount += 1;
593 case R_RISCV_RVC_BRANCH:
594 case R_RISCV_RVC_JUMP:
595 case R_RISCV_PCREL_HI20:
596 /* In shared libraries, these relocs are known to bind locally. */
597 if (bfd_link_pic (info))
601 case R_RISCV_TPREL_HI20:
602 if (!bfd_link_executable (info))
603 return bad_static_reloc (abfd, r_type, h);
605 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE);
609 if (bfd_link_pic (info))
610 return bad_static_reloc (abfd, r_type, h);
614 case R_RISCV_JUMP_SLOT:
615 case R_RISCV_RELATIVE:
621 /* This reloc might not bind locally. */
625 if (h != NULL && !bfd_link_pic (info))
627 /* We may need a .plt entry if the function this reloc
628 refers to is in a shared lib. */
629 h->plt.refcount += 1;
632 /* If we are creating a shared library, and this is a reloc
633 against a global symbol, or a non PC relative reloc
634 against a local symbol, then we need to copy the reloc
635 into the shared library. However, if we are linking with
636 -Bsymbolic, we do not need to copy a reloc against a
637 global symbol which is defined in an object we are
638 including in the link (i.e., DEF_REGULAR is set). At
639 this point we have not seen all the input files, so it is
640 possible that DEF_REGULAR is not set now but will be set
641 later (it is never cleared). In case of a weak definition,
642 DEF_REGULAR may be cleared later by a strong definition in
643 a shared library. We account for that possibility below by
644 storing information in the relocs_copied field of the hash
645 table entry. A similar situation occurs when creating
646 shared libraries and symbol visibility changes render the
649 If on the other hand, we are creating an executable, we
650 may need to keep relocations for symbols satisfied by a
651 dynamic library if we manage to avoid copy relocs for the
653 reloc_howto_type * r = riscv_elf_rtype_to_howto (abfd, r_type);
655 if ((bfd_link_pic (info)
656 && (sec->flags & SEC_ALLOC) != 0
657 && ((r != NULL && ! r->pc_relative)
660 || h->root.type == bfd_link_hash_defweak
661 || !h->def_regular))))
662 || (!bfd_link_pic (info)
663 && (sec->flags & SEC_ALLOC) != 0
665 && (h->root.type == bfd_link_hash_defweak
666 || !h->def_regular)))
668 struct elf_dyn_relocs *p;
669 struct elf_dyn_relocs **head;
671 /* When creating a shared object, we must copy these
672 relocs into the output file. We create a reloc
673 section in dynobj and make room for the reloc. */
676 sreloc = _bfd_elf_make_dynamic_reloc_section
677 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES,
678 abfd, /*rela?*/ TRUE);
684 /* If this is a global symbol, we count the number of
685 relocations we need for this symbol. */
687 head = &((struct riscv_elf_link_hash_entry *) h)->dyn_relocs;
690 /* Track dynamic relocs needed for local syms too.
691 We really need local syms available to do this
696 Elf_Internal_Sym *isym;
698 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
703 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
707 vpp = &elf_section_data (s)->local_dynrel;
708 head = (struct elf_dyn_relocs **) vpp;
712 if (p == NULL || p->sec != sec)
714 bfd_size_type amt = sizeof *p;
715 p = ((struct elf_dyn_relocs *)
716 bfd_alloc (htab->elf.dynobj, amt));
727 p->pc_count += r == NULL ? 0 : r->pc_relative;
732 case R_RISCV_GNU_VTINHERIT:
733 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
737 case R_RISCV_GNU_VTENTRY:
738 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
751 riscv_elf_gc_mark_hook (asection *sec,
752 struct bfd_link_info *info,
753 Elf_Internal_Rela *rel,
754 struct elf_link_hash_entry *h,
755 Elf_Internal_Sym *sym)
758 switch (ELFNN_R_TYPE (rel->r_info))
760 case R_RISCV_GNU_VTINHERIT:
761 case R_RISCV_GNU_VTENTRY:
765 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
768 /* Find dynamic relocs for H that apply to read-only sections. */
771 readonly_dynrelocs (struct elf_link_hash_entry *h)
773 struct elf_dyn_relocs *p;
775 for (p = riscv_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
777 asection *s = p->sec->output_section;
779 if (s != NULL && (s->flags & SEC_READONLY) != 0)
785 /* Adjust a symbol defined by a dynamic object and referenced by a
786 regular object. The current definition is in some section of the
787 dynamic object, but we're not including those sections. We have to
788 change the definition to something the rest of the link can
792 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
793 struct elf_link_hash_entry *h)
795 struct riscv_elf_link_hash_table *htab;
796 struct riscv_elf_link_hash_entry * eh;
800 htab = riscv_elf_hash_table (info);
801 BFD_ASSERT (htab != NULL);
803 dynobj = htab->elf.dynobj;
805 /* Make sure we know what is going on here. */
806 BFD_ASSERT (dynobj != NULL
808 || h->type == STT_GNU_IFUNC
812 && !h->def_regular)));
814 /* If this is a function, put it in the procedure linkage table. We
815 will fill in the contents of the procedure linkage table later
816 (although we could actually do it here). */
817 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
819 if (h->plt.refcount <= 0
820 || SYMBOL_CALLS_LOCAL (info, h)
821 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
822 && h->root.type == bfd_link_hash_undefweak))
824 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
825 input file, but the symbol was never referred to by a dynamic
826 object, or if all references were garbage collected. In such
827 a case, we don't actually need to build a PLT entry. */
828 h->plt.offset = (bfd_vma) -1;
835 h->plt.offset = (bfd_vma) -1;
837 /* If this is a weak symbol, and there is a real definition, the
838 processor independent code will have arranged for us to see the
839 real definition first, and we can just use the same value. */
842 struct elf_link_hash_entry *def = weakdef (h);
843 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
844 h->root.u.def.section = def->root.u.def.section;
845 h->root.u.def.value = def->root.u.def.value;
849 /* This is a reference to a symbol defined by a dynamic object which
850 is not a function. */
852 /* If we are creating a shared library, we must presume that the
853 only references to the symbol are via the global offset table.
854 For such cases we need not do anything here; the relocations will
855 be handled correctly by relocate_section. */
856 if (bfd_link_pic (info))
859 /* If there are no references to this symbol that do not use the
860 GOT, we don't need to generate a copy reloc. */
864 /* If -z nocopyreloc was given, we won't generate them either. */
865 if (info->nocopyreloc)
871 /* If we don't find any dynamic relocs in read-only sections, then
872 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
873 if (!readonly_dynrelocs (h))
879 /* We must allocate the symbol in our .dynbss section, which will
880 become part of the .bss section of the executable. There will be
881 an entry for this symbol in the .dynsym section. The dynamic
882 object will contain position independent code, so all references
883 from the dynamic object to this symbol will go through the global
884 offset table. The dynamic linker will use the .dynsym entry to
885 determine the address it must put in the global offset table, so
886 both the dynamic object and the regular object will refer to the
887 same memory location for the variable. */
889 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
890 to copy the initial value out of the dynamic object and into the
891 runtime process image. We need to remember the offset into the
892 .rel.bss section we are going to use. */
893 eh = (struct riscv_elf_link_hash_entry *) h;
894 if (eh->tls_type & ~GOT_NORMAL)
897 srel = htab->elf.srelbss;
899 else if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
901 s = htab->elf.sdynrelro;
902 srel = htab->elf.sreldynrelro;
906 s = htab->elf.sdynbss;
907 srel = htab->elf.srelbss;
909 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
911 srel->size += sizeof (ElfNN_External_Rela);
915 return _bfd_elf_adjust_dynamic_copy (info, h, s);
918 /* Allocate space in .plt, .got and associated reloc sections for
922 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
924 struct bfd_link_info *info;
925 struct riscv_elf_link_hash_table *htab;
926 struct riscv_elf_link_hash_entry *eh;
927 struct elf_dyn_relocs *p;
929 if (h->root.type == bfd_link_hash_indirect)
932 info = (struct bfd_link_info *) inf;
933 htab = riscv_elf_hash_table (info);
934 BFD_ASSERT (htab != NULL);
936 if (htab->elf.dynamic_sections_created
937 && h->plt.refcount > 0)
939 /* Make sure this symbol is output as a dynamic symbol.
940 Undefined weak syms won't yet be marked as dynamic. */
944 if (! bfd_elf_link_record_dynamic_symbol (info, h))
948 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
950 asection *s = htab->elf.splt;
953 s->size = PLT_HEADER_SIZE;
955 h->plt.offset = s->size;
957 /* Make room for this entry. */
958 s->size += PLT_ENTRY_SIZE;
960 /* We also need to make an entry in the .got.plt section. */
961 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
963 /* We also need to make an entry in the .rela.plt section. */
964 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
966 /* If this symbol is not defined in a regular file, and we are
967 not generating a shared library, then set the symbol to this
968 location in the .plt. This is required to make function
969 pointers compare as equal between the normal executable and
970 the shared library. */
971 if (! bfd_link_pic (info)
974 h->root.u.def.section = s;
975 h->root.u.def.value = h->plt.offset;
980 h->plt.offset = (bfd_vma) -1;
986 h->plt.offset = (bfd_vma) -1;
990 if (h->got.refcount > 0)
994 int tls_type = riscv_elf_hash_entry (h)->tls_type;
996 /* Make sure this symbol is output as a dynamic symbol.
997 Undefined weak syms won't yet be marked as dynamic. */
1001 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1006 h->got.offset = s->size;
1007 dyn = htab->elf.dynamic_sections_created;
1008 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
1010 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1011 if (tls_type & GOT_TLS_GD)
1013 s->size += 2 * RISCV_ELF_WORD_BYTES;
1014 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1017 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1018 if (tls_type & GOT_TLS_IE)
1020 s->size += RISCV_ELF_WORD_BYTES;
1021 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1026 s->size += RISCV_ELF_WORD_BYTES;
1027 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
1028 && ! UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1029 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1033 h->got.offset = (bfd_vma) -1;
1035 eh = (struct riscv_elf_link_hash_entry *) h;
1036 if (eh->dyn_relocs == NULL)
1039 /* In the shared -Bsymbolic case, discard space allocated for
1040 dynamic pc-relative relocs against symbols which turn out to be
1041 defined in regular objects. For the normal shared case, discard
1042 space for pc-relative relocs that have become local due to symbol
1043 visibility changes. */
1045 if (bfd_link_pic (info))
1047 if (SYMBOL_CALLS_LOCAL (info, h))
1049 struct elf_dyn_relocs **pp;
1051 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1053 p->count -= p->pc_count;
1062 /* Also discard relocs on undefined weak syms with non-default
1064 if (eh->dyn_relocs != NULL
1065 && h->root.type == bfd_link_hash_undefweak)
1067 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1068 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
1069 eh->dyn_relocs = NULL;
1071 /* Make sure undefined weak symbols are output as a dynamic
1073 else if (h->dynindx == -1
1074 && !h->forced_local)
1076 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1083 /* For the non-shared case, discard space for relocs against
1084 symbols which turn out to need copy relocs or are not
1090 || (htab->elf.dynamic_sections_created
1091 && (h->root.type == bfd_link_hash_undefweak
1092 || h->root.type == bfd_link_hash_undefined))))
1094 /* Make sure this symbol is output as a dynamic symbol.
1095 Undefined weak syms won't yet be marked as dynamic. */
1096 if (h->dynindx == -1
1097 && !h->forced_local)
1099 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1103 /* If that succeeded, we know we'll be keeping all the
1105 if (h->dynindx != -1)
1109 eh->dyn_relocs = NULL;
1114 /* Finally, allocate space. */
1115 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1117 asection *sreloc = elf_section_data (p->sec)->sreloc;
1118 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1124 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1125 read-only sections. */
1128 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1132 if (h->root.type == bfd_link_hash_indirect)
1135 sec = readonly_dynrelocs (h);
1138 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1140 info->flags |= DF_TEXTREL;
1141 info->callbacks->minfo
1142 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1143 sec->owner, h->root.root.string, sec);
1145 /* Not an error, just cut short the traversal. */
1152 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1154 struct riscv_elf_link_hash_table *htab;
1159 htab = riscv_elf_hash_table (info);
1160 BFD_ASSERT (htab != NULL);
1161 dynobj = htab->elf.dynobj;
1162 BFD_ASSERT (dynobj != NULL);
1164 if (elf_hash_table (info)->dynamic_sections_created)
1166 /* Set the contents of the .interp section to the interpreter. */
1167 if (bfd_link_executable (info) && !info->nointerp)
1169 s = bfd_get_linker_section (dynobj, ".interp");
1170 BFD_ASSERT (s != NULL);
1171 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1172 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1176 /* Set up .got offsets for local syms, and space for local dynamic
1178 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1180 bfd_signed_vma *local_got;
1181 bfd_signed_vma *end_local_got;
1182 char *local_tls_type;
1183 bfd_size_type locsymcount;
1184 Elf_Internal_Shdr *symtab_hdr;
1187 if (! is_riscv_elf (ibfd))
1190 for (s = ibfd->sections; s != NULL; s = s->next)
1192 struct elf_dyn_relocs *p;
1194 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1196 if (!bfd_is_abs_section (p->sec)
1197 && bfd_is_abs_section (p->sec->output_section))
1199 /* Input section has been discarded, either because
1200 it is a copy of a linkonce section or due to
1201 linker script /DISCARD/, so we'll be discarding
1204 else if (p->count != 0)
1206 srel = elf_section_data (p->sec)->sreloc;
1207 srel->size += p->count * sizeof (ElfNN_External_Rela);
1208 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1209 info->flags |= DF_TEXTREL;
1214 local_got = elf_local_got_refcounts (ibfd);
1218 symtab_hdr = &elf_symtab_hdr (ibfd);
1219 locsymcount = symtab_hdr->sh_info;
1220 end_local_got = local_got + locsymcount;
1221 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1223 srel = htab->elf.srelgot;
1224 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1228 *local_got = s->size;
1229 s->size += RISCV_ELF_WORD_BYTES;
1230 if (*local_tls_type & GOT_TLS_GD)
1231 s->size += RISCV_ELF_WORD_BYTES;
1232 if (bfd_link_pic (info)
1233 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1234 srel->size += sizeof (ElfNN_External_Rela);
1237 *local_got = (bfd_vma) -1;
1241 /* Allocate global sym .plt and .got entries, and space for global
1242 sym dynamic relocs. */
1243 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1245 if (htab->elf.sgotplt)
1247 struct elf_link_hash_entry *got;
1248 got = elf_link_hash_lookup (elf_hash_table (info),
1249 "_GLOBAL_OFFSET_TABLE_",
1250 FALSE, FALSE, FALSE);
1252 /* Don't allocate .got.plt section if there are no GOT nor PLT
1253 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1255 || !got->ref_regular_nonweak)
1256 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1257 && (htab->elf.splt == NULL
1258 || htab->elf.splt->size == 0)
1259 && (htab->elf.sgot == NULL
1260 || (htab->elf.sgot->size
1261 == get_elf_backend_data (output_bfd)->got_header_size)))
1262 htab->elf.sgotplt->size = 0;
1265 /* The check_relocs and adjust_dynamic_symbol entry points have
1266 determined the sizes of the various dynamic sections. Allocate
1268 for (s = dynobj->sections; s != NULL; s = s->next)
1270 if ((s->flags & SEC_LINKER_CREATED) == 0)
1273 if (s == htab->elf.splt
1274 || s == htab->elf.sgot
1275 || s == htab->elf.sgotplt
1276 || s == htab->elf.sdynbss
1277 || s == htab->elf.sdynrelro)
1279 /* Strip this section if we don't need it; see the
1282 else if (strncmp (s->name, ".rela", 5) == 0)
1286 /* We use the reloc_count field as a counter if we need
1287 to copy relocs into the output file. */
1293 /* It's not one of our sections. */
1299 /* If we don't need this section, strip it from the
1300 output file. This is mostly to handle .rela.bss and
1301 .rela.plt. We must create both sections in
1302 create_dynamic_sections, because they must be created
1303 before the linker maps input sections to output
1304 sections. The linker does that before
1305 adjust_dynamic_symbol is called, and it is that
1306 function which decides whether anything needs to go
1307 into these sections. */
1308 s->flags |= SEC_EXCLUDE;
1312 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1315 /* Allocate memory for the section contents. Zero the memory
1316 for the benefit of .rela.plt, which has 4 unused entries
1317 at the beginning, and we don't want garbage. */
1318 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1319 if (s->contents == NULL)
1323 if (elf_hash_table (info)->dynamic_sections_created)
1325 /* Add some entries to the .dynamic section. We fill in the
1326 values later, in riscv_elf_finish_dynamic_sections, but we
1327 must add the entries now so that we get the correct size for
1328 the .dynamic section. The DT_DEBUG entry is filled in by the
1329 dynamic linker and used by the debugger. */
1330 #define add_dynamic_entry(TAG, VAL) \
1331 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1333 if (bfd_link_executable (info))
1335 if (!add_dynamic_entry (DT_DEBUG, 0))
1339 if (htab->elf.srelplt->size != 0)
1341 if (!add_dynamic_entry (DT_PLTGOT, 0)
1342 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1343 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1344 || !add_dynamic_entry (DT_JMPREL, 0))
1348 if (!add_dynamic_entry (DT_RELA, 0)
1349 || !add_dynamic_entry (DT_RELASZ, 0)
1350 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1353 /* If any dynamic relocs apply to a read-only section,
1354 then we need a DT_TEXTREL entry. */
1355 if ((info->flags & DF_TEXTREL) == 0)
1356 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
1358 if (info->flags & DF_TEXTREL)
1360 if (!add_dynamic_entry (DT_TEXTREL, 0))
1364 #undef add_dynamic_entry
1370 #define DTP_OFFSET 0x800
1372 /* Return the relocation value for a TLS dtp-relative reloc. */
1375 dtpoff (struct bfd_link_info *info, bfd_vma address)
1377 /* If tls_sec is NULL, we should have signalled an error already. */
1378 if (elf_hash_table (info)->tls_sec == NULL)
1380 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1383 /* Return the relocation value for a static TLS tp-relative relocation. */
1386 tpoff (struct bfd_link_info *info, bfd_vma address)
1388 /* If tls_sec is NULL, we should have signalled an error already. */
1389 if (elf_hash_table (info)->tls_sec == NULL)
1391 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1394 /* Return the global pointer's value, or 0 if it is not in use. */
1397 riscv_global_pointer_value (struct bfd_link_info *info)
1399 struct bfd_link_hash_entry *h;
1401 h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
1402 if (h == NULL || h->type != bfd_link_hash_defined)
1405 return h->u.def.value + sec_addr (h->u.def.section);
1408 /* Emplace a static relocation. */
1410 static bfd_reloc_status_type
1411 perform_relocation (const reloc_howto_type *howto,
1412 const Elf_Internal_Rela *rel,
1414 asection *input_section,
1418 if (howto->pc_relative)
1419 value -= sec_addr (input_section) + rel->r_offset;
1420 value += rel->r_addend;
1422 switch (ELFNN_R_TYPE (rel->r_info))
1425 case R_RISCV_TPREL_HI20:
1426 case R_RISCV_PCREL_HI20:
1427 case R_RISCV_GOT_HI20:
1428 case R_RISCV_TLS_GOT_HI20:
1429 case R_RISCV_TLS_GD_HI20:
1430 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1431 return bfd_reloc_overflow;
1432 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1435 case R_RISCV_LO12_I:
1436 case R_RISCV_GPREL_I:
1437 case R_RISCV_TPREL_LO12_I:
1438 case R_RISCV_TPREL_I:
1439 case R_RISCV_PCREL_LO12_I:
1440 value = ENCODE_ITYPE_IMM (value);
1443 case R_RISCV_LO12_S:
1444 case R_RISCV_GPREL_S:
1445 case R_RISCV_TPREL_LO12_S:
1446 case R_RISCV_TPREL_S:
1447 case R_RISCV_PCREL_LO12_S:
1448 value = ENCODE_STYPE_IMM (value);
1452 case R_RISCV_CALL_PLT:
1453 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1454 return bfd_reloc_overflow;
1455 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1456 | (ENCODE_ITYPE_IMM (value) << 32);
1460 if (!VALID_UJTYPE_IMM (value))
1461 return bfd_reloc_overflow;
1462 value = ENCODE_UJTYPE_IMM (value);
1465 case R_RISCV_BRANCH:
1466 if (!VALID_SBTYPE_IMM (value))
1467 return bfd_reloc_overflow;
1468 value = ENCODE_SBTYPE_IMM (value);
1471 case R_RISCV_RVC_BRANCH:
1472 if (!VALID_RVC_B_IMM (value))
1473 return bfd_reloc_overflow;
1474 value = ENCODE_RVC_B_IMM (value);
1477 case R_RISCV_RVC_JUMP:
1478 if (!VALID_RVC_J_IMM (value))
1479 return bfd_reloc_overflow;
1480 value = ENCODE_RVC_J_IMM (value);
1483 case R_RISCV_RVC_LUI:
1484 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1485 return bfd_reloc_overflow;
1486 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1504 case R_RISCV_32_PCREL:
1505 case R_RISCV_TLS_DTPREL32:
1506 case R_RISCV_TLS_DTPREL64:
1509 case R_RISCV_DELETE:
1510 return bfd_reloc_ok;
1513 return bfd_reloc_notsupported;
1516 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1517 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1518 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1520 return bfd_reloc_ok;
1523 /* Remember all PC-relative high-part relocs we've encountered to help us
1524 later resolve the corresponding low-part relocs. */
1530 } riscv_pcrel_hi_reloc;
1532 typedef struct riscv_pcrel_lo_reloc
1534 asection * input_section;
1535 struct bfd_link_info * info;
1536 reloc_howto_type * howto;
1537 const Elf_Internal_Rela * reloc;
1540 bfd_byte * contents;
1541 struct riscv_pcrel_lo_reloc * next;
1542 } riscv_pcrel_lo_reloc;
1547 riscv_pcrel_lo_reloc *lo_relocs;
1548 } riscv_pcrel_relocs;
1551 riscv_pcrel_reloc_hash (const void *entry)
1553 const riscv_pcrel_hi_reloc *e = entry;
1554 return (hashval_t)(e->address >> 2);
1558 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1560 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1561 return e1->address == e2->address;
1565 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1568 p->lo_relocs = NULL;
1569 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1570 riscv_pcrel_reloc_eq, free);
1571 return p->hi_relocs != NULL;
1575 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1577 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1581 riscv_pcrel_lo_reloc *next = cur->next;
1586 htab_delete (p->hi_relocs);
1590 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela *rel,
1591 struct bfd_link_info *info,
1595 const reloc_howto_type *howto,
1598 /* We may need to reference low addreses in PC-relative modes even when the
1599 * PC is far away from these addresses. For example, undefweak references
1600 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1601 * addresses that we can link PC-relative programs at, the linker can't
1602 * actually relocate references to those symbols. In order to allow these
1603 * programs to work we simply convert the PC-relative auipc sequences to
1604 * 0-relative lui sequences. */
1605 if (bfd_link_pic (info))
1608 /* If it's possible to reference the symbol using auipc we do so, as that's
1609 * more in the spirit of the PC-relative relocations we're processing. */
1610 bfd_vma offset = addr - pc;
1611 if (ARCH_SIZE == 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset)))
1614 /* If it's impossible to reference this with a LUI-based offset then don't
1615 * bother to convert it at all so users still see the PC-relative relocation
1616 * in the truncation message. */
1617 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr)))
1620 rel->r_info = ELFNN_R_INFO(addr, R_RISCV_HI20);
1622 bfd_vma insn = bfd_get(howto->bitsize, input_bfd, contents + rel->r_offset);
1623 insn = (insn & ~MASK_AUIPC) | MATCH_LUI;
1624 bfd_put(howto->bitsize, input_bfd, insn, contents + rel->r_offset);
1629 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr,
1630 bfd_vma value, bfd_boolean absolute)
1632 bfd_vma offset = absolute ? value : value - addr;
1633 riscv_pcrel_hi_reloc entry = {addr, offset};
1634 riscv_pcrel_hi_reloc **slot =
1635 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1637 BFD_ASSERT (*slot == NULL);
1638 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1646 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1647 asection *input_section,
1648 struct bfd_link_info *info,
1649 reloc_howto_type *howto,
1650 const Elf_Internal_Rela *reloc,
1655 riscv_pcrel_lo_reloc *entry;
1656 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1659 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1660 name, contents, p->lo_relocs};
1661 p->lo_relocs = entry;
1666 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1668 riscv_pcrel_lo_reloc *r;
1670 for (r = p->lo_relocs; r != NULL; r = r->next)
1672 bfd *input_bfd = r->input_section->owner;
1674 riscv_pcrel_hi_reloc search = {r->addr, 0};
1675 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1677 /* Check for overflow into bit 11 when adding reloc addend. */
1678 || (! (entry->value & 0x800)
1679 && ((entry->value + r->reloc->r_addend) & 0x800)))
1681 char *string = (entry == NULL
1682 ? "%pcrel_lo missing matching %pcrel_hi"
1683 : "%pcrel_lo overflow with an addend");
1684 (*r->info->callbacks->reloc_dangerous)
1685 (r->info, string, input_bfd, r->input_section, r->reloc->r_offset);
1689 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1690 input_bfd, r->contents);
1696 /* Relocate a RISC-V ELF section.
1698 The RELOCATE_SECTION function is called by the new ELF backend linker
1699 to handle the relocations for a section.
1701 The relocs are always passed as Rela structures.
1703 This function is responsible for adjusting the section contents as
1704 necessary, and (if generating a relocatable output file) adjusting
1705 the reloc addend as necessary.
1707 This function does not have to worry about setting the reloc
1708 address or the reloc symbol index.
1710 LOCAL_SYMS is a pointer to the swapped in local symbols.
1712 LOCAL_SECTIONS is an array giving the section in the input file
1713 corresponding to the st_shndx field of each local symbol.
1715 The global hash table entry for the global symbols can be found
1716 via elf_sym_hashes (input_bfd).
1718 When generating relocatable output, this function must handle
1719 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1720 going to be the section symbol corresponding to the output
1721 section, which means that the addend must be adjusted
1725 riscv_elf_relocate_section (bfd *output_bfd,
1726 struct bfd_link_info *info,
1728 asection *input_section,
1730 Elf_Internal_Rela *relocs,
1731 Elf_Internal_Sym *local_syms,
1732 asection **local_sections)
1734 Elf_Internal_Rela *rel;
1735 Elf_Internal_Rela *relend;
1736 riscv_pcrel_relocs pcrel_relocs;
1737 bfd_boolean ret = FALSE;
1738 asection *sreloc = elf_section_data (input_section)->sreloc;
1739 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1740 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1741 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1742 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1743 bfd_boolean absolute;
1745 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1748 relend = relocs + input_section->reloc_count;
1749 for (rel = relocs; rel < relend; rel++)
1751 unsigned long r_symndx;
1752 struct elf_link_hash_entry *h;
1753 Elf_Internal_Sym *sym;
1756 bfd_reloc_status_type r = bfd_reloc_ok;
1758 bfd_vma off, ie_off;
1759 bfd_boolean unresolved_reloc, is_ie = FALSE;
1760 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1761 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1762 reloc_howto_type *howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
1763 const char *msg = NULL;
1764 bfd_boolean resolved_to_zero;
1767 || r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1770 /* This is a final link. */
1771 r_symndx = ELFNN_R_SYM (rel->r_info);
1775 unresolved_reloc = FALSE;
1776 if (r_symndx < symtab_hdr->sh_info)
1778 sym = local_syms + r_symndx;
1779 sec = local_sections[r_symndx];
1780 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1784 bfd_boolean warned, ignored;
1786 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1787 r_symndx, symtab_hdr, sym_hashes,
1789 unresolved_reloc, warned, ignored);
1792 /* To avoid generating warning messages about truncated
1793 relocations, set the relocation's address to be the same as
1794 the start of this section. */
1795 if (input_section->output_section != NULL)
1796 relocation = input_section->output_section->vma;
1802 if (sec != NULL && discarded_section (sec))
1803 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1804 rel, 1, relend, howto, 0, contents);
1806 if (bfd_link_relocatable (info))
1810 name = h->root.root.string;
1813 name = (bfd_elf_string_from_elf_section
1814 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1815 if (name == NULL || *name == '\0')
1816 name = bfd_section_name (input_bfd, sec);
1819 resolved_to_zero = (h != NULL
1820 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
1826 case R_RISCV_TPREL_ADD:
1828 case R_RISCV_JUMP_SLOT:
1829 case R_RISCV_RELATIVE:
1830 /* These require nothing of us at all. */
1834 case R_RISCV_BRANCH:
1835 case R_RISCV_RVC_BRANCH:
1836 case R_RISCV_RVC_LUI:
1837 case R_RISCV_LO12_I:
1838 case R_RISCV_LO12_S:
1843 case R_RISCV_32_PCREL:
1844 case R_RISCV_DELETE:
1845 /* These require no special handling beyond perform_relocation. */
1848 case R_RISCV_GOT_HI20:
1851 bfd_boolean dyn, pic;
1853 off = h->got.offset;
1854 BFD_ASSERT (off != (bfd_vma) -1);
1855 dyn = elf_hash_table (info)->dynamic_sections_created;
1856 pic = bfd_link_pic (info);
1858 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1859 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1861 /* This is actually a static link, or it is a
1862 -Bsymbolic link and the symbol is defined
1863 locally, or the symbol was forced to be local
1864 because of a version file. We must initialize
1865 this entry in the global offset table. Since the
1866 offset must always be a multiple of the word size,
1867 we use the least significant bit to record whether
1868 we have initialized it already.
1870 When doing a dynamic link, we create a .rela.got
1871 relocation entry to initialize the value. This
1872 is done in the finish_dynamic_symbol routine. */
1877 bfd_put_NN (output_bfd, relocation,
1878 htab->elf.sgot->contents + off);
1883 unresolved_reloc = FALSE;
1887 BFD_ASSERT (local_got_offsets != NULL
1888 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1890 off = local_got_offsets[r_symndx];
1892 /* The offset must always be a multiple of the word size.
1893 So, we can use the least significant bit to record
1894 whether we have already processed this entry. */
1899 if (bfd_link_pic (info))
1902 Elf_Internal_Rela outrel;
1904 /* We need to generate a R_RISCV_RELATIVE reloc
1905 for the dynamic linker. */
1906 s = htab->elf.srelgot;
1907 BFD_ASSERT (s != NULL);
1909 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1911 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1912 outrel.r_addend = relocation;
1914 riscv_elf_append_rela (output_bfd, s, &outrel);
1917 bfd_put_NN (output_bfd, relocation,
1918 htab->elf.sgot->contents + off);
1919 local_got_offsets[r_symndx] |= 1;
1922 relocation = sec_addr (htab->elf.sgot) + off;
1923 absolute = riscv_zero_pcrel_hi_reloc (rel,
1930 r_type = ELFNN_R_TYPE (rel->r_info);
1931 howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
1933 r = bfd_reloc_notsupported;
1934 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
1935 relocation, absolute))
1936 r = bfd_reloc_overflow;
1944 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1945 contents + rel->r_offset);
1946 relocation = old_value + relocation;
1956 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1957 contents + rel->r_offset);
1958 relocation = old_value - relocation;
1963 /* Handle a call to an undefined weak function. This won't be
1964 relaxed, so we have to handle it here. */
1965 if (h != NULL && h->root.type == bfd_link_hash_undefweak
1966 && h->plt.offset == MINUS_ONE)
1968 /* We can use x0 as the base register. */
1969 bfd_vma insn = bfd_get_32 (input_bfd,
1970 contents + rel->r_offset + 4);
1971 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1972 bfd_put_32 (input_bfd, insn, contents + rel->r_offset + 4);
1973 /* Set the relocation value so that we get 0 after the pc
1974 relative adjustment. */
1975 relocation = sec_addr (input_section) + rel->r_offset;
1979 case R_RISCV_CALL_PLT:
1981 case R_RISCV_RVC_JUMP:
1982 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1984 /* Refer to the PLT entry. */
1985 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1986 unresolved_reloc = FALSE;
1990 case R_RISCV_TPREL_HI20:
1991 relocation = tpoff (info, relocation);
1994 case R_RISCV_TPREL_LO12_I:
1995 case R_RISCV_TPREL_LO12_S:
1996 relocation = tpoff (info, relocation);
1999 case R_RISCV_TPREL_I:
2000 case R_RISCV_TPREL_S:
2001 relocation = tpoff (info, relocation);
2002 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
2004 /* We can use tp as the base register. */
2005 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2006 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2007 insn |= X_TP << OP_SH_RS1;
2008 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2011 r = bfd_reloc_overflow;
2014 case R_RISCV_GPREL_I:
2015 case R_RISCV_GPREL_S:
2017 bfd_vma gp = riscv_global_pointer_value (info);
2018 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
2019 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
2021 /* We can use x0 or gp as the base register. */
2022 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2023 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2026 rel->r_addend -= gp;
2027 insn |= X_GP << OP_SH_RS1;
2029 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2032 r = bfd_reloc_overflow;
2036 case R_RISCV_PCREL_HI20:
2037 absolute = riscv_zero_pcrel_hi_reloc (rel,
2044 r_type = ELFNN_R_TYPE (rel->r_info);
2045 howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
2047 r = bfd_reloc_notsupported;
2048 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2049 relocation + rel->r_addend,
2051 r = bfd_reloc_overflow;
2054 case R_RISCV_PCREL_LO12_I:
2055 case R_RISCV_PCREL_LO12_S:
2056 /* We don't allow section symbols plus addends as the auipc address,
2057 because then riscv_relax_delete_bytes would have to search through
2058 all relocs to update these addends. This is also ambiguous, as
2059 we do allow offsets to be added to the target address, which are
2060 not to be used to find the auipc address. */
2061 if ((ELF_ST_TYPE (sym->st_info) == STT_SECTION) && rel->r_addend)
2063 r = bfd_reloc_dangerous;
2067 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2068 howto, rel, relocation, name,
2071 r = bfd_reloc_overflow;
2074 case R_RISCV_TLS_DTPREL32:
2075 case R_RISCV_TLS_DTPREL64:
2076 relocation = dtpoff (info, relocation);
2081 if ((input_section->flags & SEC_ALLOC) == 0)
2084 if ((bfd_link_pic (info)
2086 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2087 && !resolved_to_zero)
2088 || h->root.type != bfd_link_hash_undefweak)
2089 && (! howto->pc_relative
2090 || !SYMBOL_CALLS_LOCAL (info, h)))
2091 || (!bfd_link_pic (info)
2097 || h->root.type == bfd_link_hash_undefweak
2098 || h->root.type == bfd_link_hash_undefined)))
2100 Elf_Internal_Rela outrel;
2101 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2103 /* When generating a shared object, these relocations
2104 are copied into the output file to be resolved at run
2108 _bfd_elf_section_offset (output_bfd, info, input_section,
2110 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2111 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2112 outrel.r_offset += sec_addr (input_section);
2114 if (skip_dynamic_relocation)
2115 memset (&outrel, 0, sizeof outrel);
2116 else if (h != NULL && h->dynindx != -1
2117 && !(bfd_link_pic (info)
2118 && SYMBOLIC_BIND (info, h)
2121 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2122 outrel.r_addend = rel->r_addend;
2126 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2127 outrel.r_addend = relocation + rel->r_addend;
2130 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2131 if (skip_static_relocation)
2136 case R_RISCV_TLS_GOT_HI20:
2140 case R_RISCV_TLS_GD_HI20:
2143 off = h->got.offset;
2148 off = local_got_offsets[r_symndx];
2149 local_got_offsets[r_symndx] |= 1;
2152 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2153 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2154 /* If this symbol is referenced by both GD and IE TLS, the IE
2155 reference's GOT slot follows the GD reference's slots. */
2157 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2158 ie_off = 2 * GOT_ENTRY_SIZE;
2164 Elf_Internal_Rela outrel;
2166 bfd_boolean need_relocs = FALSE;
2168 if (htab->elf.srelgot == NULL)
2173 bfd_boolean dyn, pic;
2174 dyn = htab->elf.dynamic_sections_created;
2175 pic = bfd_link_pic (info);
2177 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2178 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2182 /* The GOT entries have not been initialized yet. Do it
2183 now, and emit any relocations. */
2184 if ((bfd_link_pic (info) || indx != 0)
2186 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2187 || h->root.type != bfd_link_hash_undefweak))
2190 if (tls_type & GOT_TLS_GD)
2194 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2195 outrel.r_addend = 0;
2196 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2197 bfd_put_NN (output_bfd, 0,
2198 htab->elf.sgot->contents + off);
2199 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2202 BFD_ASSERT (! unresolved_reloc);
2203 bfd_put_NN (output_bfd,
2204 dtpoff (info, relocation),
2205 (htab->elf.sgot->contents + off +
2206 RISCV_ELF_WORD_BYTES));
2210 bfd_put_NN (output_bfd, 0,
2211 (htab->elf.sgot->contents + off +
2212 RISCV_ELF_WORD_BYTES));
2213 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2214 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2215 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2220 /* If we are not emitting relocations for a
2221 general dynamic reference, then we must be in a
2222 static link or an executable link with the
2223 symbol binding locally. Mark it as belonging
2224 to module 1, the executable. */
2225 bfd_put_NN (output_bfd, 1,
2226 htab->elf.sgot->contents + off);
2227 bfd_put_NN (output_bfd,
2228 dtpoff (info, relocation),
2229 (htab->elf.sgot->contents + off +
2230 RISCV_ELF_WORD_BYTES));
2234 if (tls_type & GOT_TLS_IE)
2238 bfd_put_NN (output_bfd, 0,
2239 htab->elf.sgot->contents + off + ie_off);
2240 outrel.r_offset = sec_addr (htab->elf.sgot)
2242 outrel.r_addend = 0;
2244 outrel.r_addend = tpoff (info, relocation);
2245 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2246 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2250 bfd_put_NN (output_bfd, tpoff (info, relocation),
2251 htab->elf.sgot->contents + off + ie_off);
2256 BFD_ASSERT (off < (bfd_vma) -2);
2257 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2258 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2260 r = bfd_reloc_overflow;
2261 unresolved_reloc = FALSE;
2265 r = bfd_reloc_notsupported;
2268 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2269 because such sections are not SEC_ALLOC and thus ld.so will
2270 not process them. */
2271 if (unresolved_reloc
2272 && !((input_section->flags & SEC_DEBUGGING) != 0
2274 && _bfd_elf_section_offset (output_bfd, info, input_section,
2275 rel->r_offset) != (bfd_vma) -1)
2277 (*_bfd_error_handler)
2278 (_("%pB(%pA+%#" PRIx64 "): "
2279 "unresolvable %s relocation against symbol `%s'"),
2282 (uint64_t) rel->r_offset,
2284 h->root.root.string);
2288 if (r == bfd_reloc_ok)
2289 r = perform_relocation (howto, rel, relocation, input_section,
2290 input_bfd, contents);
2297 case bfd_reloc_overflow:
2298 info->callbacks->reloc_overflow
2299 (info, (h ? &h->root : NULL), name, howto->name,
2300 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2303 case bfd_reloc_undefined:
2304 info->callbacks->undefined_symbol
2305 (info, name, input_bfd, input_section, rel->r_offset,
2309 case bfd_reloc_outofrange:
2310 msg = _("%X%P: internal error: out of range error\n");
2313 case bfd_reloc_notsupported:
2314 msg = _("%X%P: internal error: unsupported relocation error\n");
2317 case bfd_reloc_dangerous:
2318 info->callbacks->reloc_dangerous
2319 (info, "%pcrel_lo section symbol with an addend", input_bfd,
2320 input_section, rel->r_offset);
2324 msg = _("%X%P: internal error: unknown error\n");
2329 info->callbacks->einfo (msg);
2331 /* We already reported the error via a callback, so don't try to report
2332 it again by returning false. That leads to spurious errors. */
2337 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2339 riscv_free_pcrel_relocs (&pcrel_relocs);
2343 /* Finish up dynamic symbol handling. We set the contents of various
2344 dynamic sections here. */
2347 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2348 struct bfd_link_info *info,
2349 struct elf_link_hash_entry *h,
2350 Elf_Internal_Sym *sym)
2352 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2353 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2355 if (h->plt.offset != (bfd_vma) -1)
2357 /* We've decided to create a PLT entry for this symbol. */
2359 bfd_vma i, header_address, plt_idx, got_address;
2360 uint32_t plt_entry[PLT_ENTRY_INSNS];
2361 Elf_Internal_Rela rela;
2363 BFD_ASSERT (h->dynindx != -1);
2365 /* Calculate the address of the PLT header. */
2366 header_address = sec_addr (htab->elf.splt);
2368 /* Calculate the index of the entry. */
2369 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2371 /* Calculate the address of the .got.plt entry. */
2372 got_address = riscv_elf_got_plt_val (plt_idx, info);
2374 /* Find out where the .plt entry should go. */
2375 loc = htab->elf.splt->contents + h->plt.offset;
2377 /* Fill in the PLT entry itself. */
2378 if (! riscv_make_plt_entry (output_bfd, got_address,
2379 header_address + h->plt.offset,
2383 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2384 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2386 /* Fill in the initial value of the .got.plt entry. */
2387 loc = htab->elf.sgotplt->contents
2388 + (got_address - sec_addr (htab->elf.sgotplt));
2389 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2391 /* Fill in the entry in the .rela.plt section. */
2392 rela.r_offset = got_address;
2394 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2396 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2397 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2399 if (!h->def_regular)
2401 /* Mark the symbol as undefined, rather than as defined in
2402 the .plt section. Leave the value alone. */
2403 sym->st_shndx = SHN_UNDEF;
2404 /* If the symbol is weak, we do need to clear the value.
2405 Otherwise, the PLT entry would provide a definition for
2406 the symbol even if the symbol wasn't defined anywhere,
2407 and so the symbol would never be NULL. */
2408 if (!h->ref_regular_nonweak)
2413 if (h->got.offset != (bfd_vma) -1
2414 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE))
2415 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2419 Elf_Internal_Rela rela;
2421 /* This symbol has an entry in the GOT. Set it up. */
2423 sgot = htab->elf.sgot;
2424 srela = htab->elf.srelgot;
2425 BFD_ASSERT (sgot != NULL && srela != NULL);
2427 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2429 /* If this is a local symbol reference, we just want to emit a RELATIVE
2430 reloc. This can happen if it is a -Bsymbolic link, or a pie link, or
2431 the symbol was forced to be local because of a version file.
2432 The entry in the global offset table will already have been
2433 initialized in the relocate_section function. */
2434 if (bfd_link_pic (info)
2435 && SYMBOL_REFERENCES_LOCAL (info, h))
2437 BFD_ASSERT((h->got.offset & 1) != 0);
2438 asection *sec = h->root.u.def.section;
2439 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2440 rela.r_addend = (h->root.u.def.value
2441 + sec->output_section->vma
2442 + sec->output_offset);
2446 BFD_ASSERT((h->got.offset & 1) == 0);
2447 BFD_ASSERT (h->dynindx != -1);
2448 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2452 bfd_put_NN (output_bfd, 0,
2453 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2454 riscv_elf_append_rela (output_bfd, srela, &rela);
2459 Elf_Internal_Rela rela;
2462 /* This symbols needs a copy reloc. Set it up. */
2463 BFD_ASSERT (h->dynindx != -1);
2465 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2466 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2468 if (h->root.u.def.section == htab->elf.sdynrelro)
2469 s = htab->elf.sreldynrelro;
2471 s = htab->elf.srelbss;
2472 riscv_elf_append_rela (output_bfd, s, &rela);
2475 /* Mark some specially defined symbols as absolute. */
2476 if (h == htab->elf.hdynamic
2477 || (h == htab->elf.hgot || h == htab->elf.hplt))
2478 sym->st_shndx = SHN_ABS;
2483 /* Finish up the dynamic sections. */
2486 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2487 bfd *dynobj, asection *sdyn)
2489 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2490 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2491 size_t dynsize = bed->s->sizeof_dyn;
2492 bfd_byte *dyncon, *dynconend;
2494 dynconend = sdyn->contents + sdyn->size;
2495 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2497 Elf_Internal_Dyn dyn;
2500 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2505 s = htab->elf.sgotplt;
2506 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2509 s = htab->elf.srelplt;
2510 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2513 s = htab->elf.srelplt;
2514 dyn.d_un.d_val = s->size;
2520 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2526 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2527 struct bfd_link_info *info)
2531 struct riscv_elf_link_hash_table *htab;
2533 htab = riscv_elf_hash_table (info);
2534 BFD_ASSERT (htab != NULL);
2535 dynobj = htab->elf.dynobj;
2537 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2539 if (elf_hash_table (info)->dynamic_sections_created)
2544 splt = htab->elf.splt;
2545 BFD_ASSERT (splt != NULL && sdyn != NULL);
2547 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2552 /* Fill in the head and tail entries in the procedure linkage table. */
2556 uint32_t plt_header[PLT_HEADER_INSNS];
2557 ret = riscv_make_plt_header (output_bfd,
2558 sec_addr (htab->elf.sgotplt),
2559 sec_addr (splt), plt_header);
2563 for (i = 0; i < PLT_HEADER_INSNS; i++)
2564 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2566 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2571 if (htab->elf.sgotplt)
2573 asection *output_section = htab->elf.sgotplt->output_section;
2575 if (bfd_is_abs_section (output_section))
2577 (*_bfd_error_handler)
2578 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
2582 if (htab->elf.sgotplt->size > 0)
2584 /* Write the first two entries in .got.plt, needed for the dynamic
2586 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2587 bfd_put_NN (output_bfd, (bfd_vma) 0,
2588 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2591 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2596 asection *output_section = htab->elf.sgot->output_section;
2598 if (htab->elf.sgot->size > 0)
2600 /* Set the first entry in the global offset table to the address of
2601 the dynamic section. */
2602 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2603 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2606 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2612 /* Return address for Ith PLT stub in section PLT, for relocation REL
2613 or (bfd_vma) -1 if it should not be included. */
2616 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2617 const arelent *rel ATTRIBUTE_UNUSED)
2619 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2622 static enum elf_reloc_type_class
2623 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2624 const asection *rel_sec ATTRIBUTE_UNUSED,
2625 const Elf_Internal_Rela *rela)
2627 switch (ELFNN_R_TYPE (rela->r_info))
2629 case R_RISCV_RELATIVE:
2630 return reloc_class_relative;
2631 case R_RISCV_JUMP_SLOT:
2632 return reloc_class_plt;
2634 return reloc_class_copy;
2636 return reloc_class_normal;
2640 /* Merge backend specific data from an object file to the output
2641 object file when linking. */
2644 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2646 bfd *obfd = info->output_bfd;
2647 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2648 flagword old_flags = elf_elfheader (obfd)->e_flags;
2650 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2653 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2655 (*_bfd_error_handler)
2656 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
2657 " target emulation `%s' does not match `%s'"),
2658 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
2662 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2665 if (! elf_flags_init (obfd))
2667 elf_flags_init (obfd) = TRUE;
2668 elf_elfheader (obfd)->e_flags = new_flags;
2672 /* Disallow linking different float ABIs. */
2673 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
2675 (*_bfd_error_handler)
2676 (_("%pB: can't link hard-float modules with soft-float modules"), ibfd);
2680 /* Disallow linking RVE and non-RVE. */
2681 if ((old_flags ^ new_flags) & EF_RISCV_RVE)
2683 (*_bfd_error_handler)
2684 (_("%pB: can't link RVE with other target"), ibfd);
2688 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2689 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2694 bfd_set_error (bfd_error_bad_value);
2698 /* Delete some bytes from a section while relaxing. */
2701 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count,
2702 struct bfd_link_info *link_info)
2704 unsigned int i, symcount;
2705 bfd_vma toaddr = sec->size;
2706 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2707 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2708 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2709 struct bfd_elf_section_data *data = elf_section_data (sec);
2710 bfd_byte *contents = data->this_hdr.contents;
2712 /* Actually delete the bytes. */
2714 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2716 /* Adjust the location of all of the relocs. Note that we need not
2717 adjust the addends, since all PC-relative references must be against
2718 symbols, which we will adjust below. */
2719 for (i = 0; i < sec->reloc_count; i++)
2720 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2721 data->relocs[i].r_offset -= count;
2723 /* Adjust the local symbols defined in this section. */
2724 for (i = 0; i < symtab_hdr->sh_info; i++)
2726 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2727 if (sym->st_shndx == sec_shndx)
2729 /* If the symbol is in the range of memory we just moved, we
2730 have to adjust its value. */
2731 if (sym->st_value > addr && sym->st_value <= toaddr)
2732 sym->st_value -= count;
2734 /* If the symbol *spans* the bytes we just deleted (i.e. its
2735 *end* is in the moved bytes but its *start* isn't), then we
2736 must adjust its size.
2738 This test needs to use the original value of st_value, otherwise
2739 we might accidentally decrease size when deleting bytes right
2740 before the symbol. But since deleted relocs can't span across
2741 symbols, we can't have both a st_value and a st_size decrease,
2742 so it is simpler to just use an else. */
2743 else if (sym->st_value <= addr
2744 && sym->st_value + sym->st_size > addr
2745 && sym->st_value + sym->st_size <= toaddr)
2746 sym->st_size -= count;
2750 /* Now adjust the global symbols defined in this section. */
2751 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2752 - symtab_hdr->sh_info);
2754 for (i = 0; i < symcount; i++)
2756 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2758 /* The '--wrap SYMBOL' option is causing a pain when the object file,
2759 containing the definition of __wrap_SYMBOL, includes a direct
2760 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
2761 the same symbol (which is __wrap_SYMBOL), but still exist as two
2762 different symbols in 'sym_hashes', we don't want to adjust
2763 the global symbol __wrap_SYMBOL twice. */
2764 /* The same problem occurs with symbols that are versioned_hidden, as
2765 foo becomes an alias for foo@BAR, and hence they need the same
2767 if (link_info->wrap_hash != NULL
2768 || sym_hash->versioned == versioned_hidden)
2770 struct elf_link_hash_entry **cur_sym_hashes;
2772 /* Loop only over the symbols which have already been checked. */
2773 for (cur_sym_hashes = sym_hashes; cur_sym_hashes < &sym_hashes[i];
2776 /* If the current symbol is identical to 'sym_hash', that means
2777 the symbol was already adjusted (or at least checked). */
2778 if (*cur_sym_hashes == sym_hash)
2781 /* Don't adjust the symbol again. */
2782 if (cur_sym_hashes < &sym_hashes[i])
2786 if ((sym_hash->root.type == bfd_link_hash_defined
2787 || sym_hash->root.type == bfd_link_hash_defweak)
2788 && sym_hash->root.u.def.section == sec)
2790 /* As above, adjust the value if needed. */
2791 if (sym_hash->root.u.def.value > addr
2792 && sym_hash->root.u.def.value <= toaddr)
2793 sym_hash->root.u.def.value -= count;
2795 /* As above, adjust the size if needed. */
2796 else if (sym_hash->root.u.def.value <= addr
2797 && sym_hash->root.u.def.value + sym_hash->size > addr
2798 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2799 sym_hash->size -= count;
2806 /* A second format for recording PC-relative hi relocations. This stores the
2807 information required to relax them to GP-relative addresses. */
2809 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc;
2810 struct riscv_pcgp_hi_reloc
2817 riscv_pcgp_hi_reloc *next;
2820 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc;
2821 struct riscv_pcgp_lo_reloc
2824 riscv_pcgp_lo_reloc *next;
2829 riscv_pcgp_hi_reloc *hi;
2830 riscv_pcgp_lo_reloc *lo;
2831 } riscv_pcgp_relocs;
2834 riscv_init_pcgp_relocs (riscv_pcgp_relocs *p)
2842 riscv_free_pcgp_relocs (riscv_pcgp_relocs *p,
2843 bfd *abfd ATTRIBUTE_UNUSED,
2844 asection *sec ATTRIBUTE_UNUSED)
2846 riscv_pcgp_hi_reloc *c;
2847 riscv_pcgp_lo_reloc *l;
2849 for (c = p->hi; c != NULL;)
2851 riscv_pcgp_hi_reloc *next = c->next;
2856 for (l = p->lo; l != NULL;)
2858 riscv_pcgp_lo_reloc *next = l->next;
2865 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off,
2866 bfd_vma hi_addend, bfd_vma hi_addr,
2867 unsigned hi_sym, asection *sym_sec)
2869 riscv_pcgp_hi_reloc *new = bfd_malloc (sizeof(*new));
2872 new->hi_sec_off = hi_sec_off;
2873 new->hi_addend = hi_addend;
2874 new->hi_addr = hi_addr;
2875 new->hi_sym = hi_sym;
2876 new->sym_sec = sym_sec;
2882 static riscv_pcgp_hi_reloc *
2883 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
2885 riscv_pcgp_hi_reloc *c;
2887 for (c = p->hi; c != NULL; c = c->next)
2888 if (c->hi_sec_off == hi_sec_off)
2894 riscv_delete_pcgp_hi_reloc(riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
2896 bfd_boolean out = FALSE;
2897 riscv_pcgp_hi_reloc *c;
2899 for (c = p->hi; c != NULL; c = c->next)
2900 if (c->hi_sec_off == hi_sec_off)
2907 riscv_use_pcgp_hi_reloc(riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
2909 bfd_boolean out = FALSE;
2910 riscv_pcgp_hi_reloc *c;
2912 for (c = p->hi; c != NULL; c = c->next)
2913 if (c->hi_sec_off == hi_sec_off)
2920 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
2922 riscv_pcgp_lo_reloc *new = bfd_malloc (sizeof(*new));
2925 new->hi_sec_off = hi_sec_off;
2932 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
2934 riscv_pcgp_lo_reloc *c;
2936 for (c = p->lo; c != NULL; c = c->next)
2937 if (c->hi_sec_off == hi_sec_off)
2943 riscv_delete_pcgp_lo_reloc (riscv_pcgp_relocs *p ATTRIBUTE_UNUSED,
2944 bfd_vma lo_sec_off ATTRIBUTE_UNUSED,
2945 size_t bytes ATTRIBUTE_UNUSED)
2950 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
2951 struct bfd_link_info *,
2952 Elf_Internal_Rela *,
2953 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *,
2954 riscv_pcgp_relocs *);
2956 /* Relax AUIPC + JALR into JAL. */
2959 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2960 struct bfd_link_info *link_info,
2961 Elf_Internal_Rela *rel,
2963 bfd_vma max_alignment,
2964 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2966 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
2968 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2969 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2970 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2971 bfd_vma auipc, jalr;
2972 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2974 /* If the call crosses section boundaries, an alignment directive could
2975 cause the PC-relative offset to later increase. */
2976 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2977 foff += (foff < 0 ? -max_alignment : max_alignment);
2979 /* See if this function call can be shortened. */
2980 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2983 /* Shorten the function call. */
2984 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2986 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2987 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2988 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2989 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2991 if (rvc && (rd == 0 || rd == X_RA))
2993 /* Relax to C.J[AL] rd, addr. */
2994 r_type = R_RISCV_RVC_JUMP;
2995 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2998 else if (VALID_UJTYPE_IMM (foff))
3000 /* Relax to JAL rd, addr. */
3001 r_type = R_RISCV_JAL;
3002 auipc = MATCH_JAL | (rd << OP_SH_RD);
3004 else /* near_zero */
3006 /* Relax to JALR rd, x0, addr. */
3007 r_type = R_RISCV_LO12_I;
3008 auipc = MATCH_JALR | (rd << OP_SH_RD);
3011 /* Replace the R_RISCV_CALL reloc. */
3012 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
3013 /* Replace the AUIPC. */
3014 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
3016 /* Delete unnecessary JALR. */
3018 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len,
3022 /* Traverse all output sections and return the max alignment. */
3025 _bfd_riscv_get_max_alignment (asection *sec)
3027 unsigned int max_alignment_power = 0;
3030 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
3032 if (o->alignment_power > max_alignment_power)
3033 max_alignment_power = o->alignment_power;
3036 return (bfd_vma) 1 << max_alignment_power;
3039 /* Relax non-PIC global variable references. */
3042 _bfd_riscv_relax_lui (bfd *abfd,
3045 struct bfd_link_info *link_info,
3046 Elf_Internal_Rela *rel,
3048 bfd_vma max_alignment,
3049 bfd_vma reserve_size,
3051 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3053 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3054 bfd_vma gp = riscv_global_pointer_value (link_info);
3055 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
3057 /* Mergeable symbols and code might later move out of range. */
3058 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
3061 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3065 /* If gp and the symbol are in the same output section, then
3066 consider only that section's alignment. */
3067 struct bfd_link_hash_entry *h =
3068 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE,
3070 if (h->u.def.section->output_section == sym_sec->output_section)
3071 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
3074 /* Is the reference in range of x0 or gp?
3075 Valid gp range conservatively because of alignment issue. */
3076 if (VALID_ITYPE_IMM (symval)
3078 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
3080 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
3082 unsigned sym = ELFNN_R_SYM (rel->r_info);
3083 switch (ELFNN_R_TYPE (rel->r_info))
3085 case R_RISCV_LO12_I:
3086 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
3089 case R_RISCV_LO12_S:
3090 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
3094 /* We can delete the unnecessary LUI and reloc. */
3095 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3097 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4,
3105 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3106 account for this assuming page alignment at worst. */
3108 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
3109 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
3110 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
3112 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3113 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
3114 unsigned rd = ((unsigned)lui >> OP_SH_RD) & OP_MASK_RD;
3115 if (rd == 0 || rd == X_SP)
3118 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
3119 bfd_put_32 (abfd, lui, contents + rel->r_offset);
3121 /* Replace the R_RISCV_HI20 reloc. */
3122 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
3125 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2,
3132 /* Relax non-PIC TLS references. */
3135 _bfd_riscv_relax_tls_le (bfd *abfd,
3137 asection *sym_sec ATTRIBUTE_UNUSED,
3138 struct bfd_link_info *link_info,
3139 Elf_Internal_Rela *rel,
3141 bfd_vma max_alignment ATTRIBUTE_UNUSED,
3142 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3144 riscv_pcgp_relocs *prcel_relocs ATTRIBUTE_UNUSED)
3146 /* See if this symbol is in range of tp. */
3147 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
3150 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3151 switch (ELFNN_R_TYPE (rel->r_info))
3153 case R_RISCV_TPREL_LO12_I:
3154 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
3157 case R_RISCV_TPREL_LO12_S:
3158 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
3161 case R_RISCV_TPREL_HI20:
3162 case R_RISCV_TPREL_ADD:
3163 /* We can delete the unnecessary instruction and reloc. */
3164 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3166 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4, link_info);
3173 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3176 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
3178 struct bfd_link_info *link_info,
3179 Elf_Internal_Rela *rel,
3181 bfd_vma max_alignment ATTRIBUTE_UNUSED,
3182 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3183 bfd_boolean *again ATTRIBUTE_UNUSED,
3184 riscv_pcgp_relocs *pcrel_relocs ATTRIBUTE_UNUSED)
3186 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3187 bfd_vma alignment = 1, pos;
3188 while (alignment <= rel->r_addend)
3191 symval -= rel->r_addend;
3192 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
3193 bfd_vma nop_bytes = aligned_addr - symval;
3195 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3196 sec->sec_flg0 = TRUE;
3198 /* Make sure there are enough NOPs to actually achieve the alignment. */
3199 if (rel->r_addend < nop_bytes)
3202 (_("%pB(%pA+%#" PRIx64 "): %" PRId64 " bytes required for alignment "
3203 "to %" PRId64 "-byte boundary, but only %" PRId64 " present"),
3204 abfd, sym_sec, (uint64_t) rel->r_offset,
3205 (int64_t) nop_bytes, (int64_t) alignment, (int64_t) rel->r_addend);
3206 bfd_set_error (bfd_error_bad_value);
3210 /* Delete the reloc. */
3211 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3213 /* If the number of NOPs is already correct, there's nothing to do. */
3214 if (nop_bytes == rel->r_addend)
3217 /* Write as many RISC-V NOPs as we need. */
3218 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
3219 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
3221 /* Write a final RVC NOP if need be. */
3222 if (nop_bytes % 4 != 0)
3223 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
3225 /* Delete the excess bytes. */
3226 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
3227 rel->r_addend - nop_bytes, link_info);
3230 /* Relax PC-relative references to GP-relative references. */
3233 _bfd_riscv_relax_pc (bfd *abfd,
3236 struct bfd_link_info *link_info,
3237 Elf_Internal_Rela *rel,
3239 bfd_vma max_alignment,
3240 bfd_vma reserve_size,
3241 bfd_boolean *again ATTRIBUTE_UNUSED,
3242 riscv_pcgp_relocs *pcgp_relocs)
3244 bfd_vma gp = riscv_global_pointer_value (link_info);
3246 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3248 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3249 * actual target address. */
3250 riscv_pcgp_hi_reloc hi_reloc;
3251 memset (&hi_reloc, 0, sizeof (hi_reloc));
3252 switch (ELFNN_R_TYPE (rel->r_info))
3254 case R_RISCV_PCREL_LO12_I:
3255 case R_RISCV_PCREL_LO12_S:
3257 /* If the %lo has an addend, it isn't for the label pointing at the
3258 hi part instruction, but rather for the symbol pointed at by the
3259 hi part instruction. So we must subtract it here for the lookup.
3260 It is still used below in the final symbol address. */
3261 bfd_vma hi_sec_off = symval - sec_addr (sym_sec) - rel->r_addend;
3262 riscv_pcgp_hi_reloc *hi = riscv_find_pcgp_hi_reloc (pcgp_relocs,
3266 riscv_record_pcgp_lo_reloc (pcgp_relocs, hi_sec_off);
3271 symval = hi_reloc.hi_addr;
3272 sym_sec = hi_reloc.sym_sec;
3273 if (!riscv_use_pcgp_hi_reloc(pcgp_relocs, hi->hi_sec_off))
3275 (_("%pB(%pA+%#" PRIx64 "): Unable to clear RISCV_PCREL_HI20 reloc "
3276 "for corresponding RISCV_PCREL_LO12 reloc"),
3277 abfd, sec, (uint64_t) rel->r_offset);
3281 case R_RISCV_PCREL_HI20:
3282 /* Mergeable symbols and code might later move out of range. */
3283 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
3286 /* If the cooresponding lo relocation has already been seen then it's not
3287 * safe to relax this relocation. */
3288 if (riscv_find_pcgp_lo_reloc (pcgp_relocs, rel->r_offset))
3299 /* If gp and the symbol are in the same output section, then
3300 consider only that section's alignment. */
3301 struct bfd_link_hash_entry *h =
3302 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
3303 if (h->u.def.section->output_section == sym_sec->output_section)
3304 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
3307 /* Is the reference in range of x0 or gp?
3308 Valid gp range conservatively because of alignment issue. */
3309 if (VALID_ITYPE_IMM (symval)
3311 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
3313 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
3315 unsigned sym = hi_reloc.hi_sym;
3316 switch (ELFNN_R_TYPE (rel->r_info))
3318 case R_RISCV_PCREL_LO12_I:
3319 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
3320 rel->r_addend += hi_reloc.hi_addend;
3321 return riscv_delete_pcgp_lo_reloc (pcgp_relocs, rel->r_offset, 4);
3323 case R_RISCV_PCREL_LO12_S:
3324 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
3325 rel->r_addend += hi_reloc.hi_addend;
3326 return riscv_delete_pcgp_lo_reloc (pcgp_relocs, rel->r_offset, 4);
3328 case R_RISCV_PCREL_HI20:
3329 riscv_record_pcgp_hi_reloc (pcgp_relocs,
3333 ELFNN_R_SYM(rel->r_info),
3335 /* We can delete the unnecessary AUIPC and reloc. */
3336 rel->r_info = ELFNN_R_INFO (0, R_RISCV_DELETE);
3338 return riscv_delete_pcgp_hi_reloc (pcgp_relocs, rel->r_offset);
3348 /* Relax PC-relative references to GP-relative references. */
3351 _bfd_riscv_relax_delete (bfd *abfd,
3353 asection *sym_sec ATTRIBUTE_UNUSED,
3354 struct bfd_link_info *link_info,
3355 Elf_Internal_Rela *rel,
3356 bfd_vma symval ATTRIBUTE_UNUSED,
3357 bfd_vma max_alignment ATTRIBUTE_UNUSED,
3358 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3359 bfd_boolean *again ATTRIBUTE_UNUSED,
3360 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3362 if (!riscv_relax_delete_bytes(abfd, sec, rel->r_offset, rel->r_addend,
3365 rel->r_info = ELFNN_R_INFO(0, R_RISCV_NONE);
3369 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3370 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3371 disabled, handles code alignment directives. */
3374 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
3375 struct bfd_link_info *info,
3378 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
3379 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
3380 struct bfd_elf_section_data *data = elf_section_data (sec);
3381 Elf_Internal_Rela *relocs;
3382 bfd_boolean ret = FALSE;
3384 bfd_vma max_alignment, reserve_size = 0;
3385 riscv_pcgp_relocs pcgp_relocs;
3389 if (bfd_link_relocatable (info)
3391 || (sec->flags & SEC_RELOC) == 0
3392 || sec->reloc_count == 0
3393 || (info->disable_target_specific_optimizations
3394 && info->relax_pass == 0))
3397 riscv_init_pcgp_relocs (&pcgp_relocs);
3399 /* Read this BFD's relocs if we haven't done so already. */
3401 relocs = data->relocs;
3402 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3403 info->keep_memory)))
3408 max_alignment = htab->max_alignment;
3409 if (max_alignment == (bfd_vma) -1)
3411 max_alignment = _bfd_riscv_get_max_alignment (sec);
3412 htab->max_alignment = max_alignment;
3416 max_alignment = _bfd_riscv_get_max_alignment (sec);
3418 /* Examine and consider relaxing each reloc. */
3419 for (i = 0; i < sec->reloc_count; i++)
3422 Elf_Internal_Rela *rel = relocs + i;
3423 relax_func_t relax_func;
3424 int type = ELFNN_R_TYPE (rel->r_info);
3428 if (info->relax_pass == 0)
3430 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3431 relax_func = _bfd_riscv_relax_call;
3432 else if (type == R_RISCV_HI20
3433 || type == R_RISCV_LO12_I
3434 || type == R_RISCV_LO12_S)
3435 relax_func = _bfd_riscv_relax_lui;
3436 else if (!bfd_link_pic(info)
3437 && (type == R_RISCV_PCREL_HI20
3438 || type == R_RISCV_PCREL_LO12_I
3439 || type == R_RISCV_PCREL_LO12_S))
3440 relax_func = _bfd_riscv_relax_pc;
3441 else if (type == R_RISCV_TPREL_HI20
3442 || type == R_RISCV_TPREL_ADD
3443 || type == R_RISCV_TPREL_LO12_I
3444 || type == R_RISCV_TPREL_LO12_S)
3445 relax_func = _bfd_riscv_relax_tls_le;
3449 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3450 if (i == sec->reloc_count - 1
3451 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3452 || rel->r_offset != (rel + 1)->r_offset)
3455 /* Skip over the R_RISCV_RELAX. */
3458 else if (info->relax_pass == 1 && type == R_RISCV_DELETE)
3459 relax_func = _bfd_riscv_relax_delete;
3460 else if (info->relax_pass == 2 && type == R_RISCV_ALIGN)
3461 relax_func = _bfd_riscv_relax_align;
3465 data->relocs = relocs;
3467 /* Read this BFD's contents if we haven't done so already. */
3468 if (!data->this_hdr.contents
3469 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3472 /* Read this BFD's symbols if we haven't done so already. */
3473 if (symtab_hdr->sh_info != 0
3474 && !symtab_hdr->contents
3475 && !(symtab_hdr->contents =
3476 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3477 symtab_hdr->sh_info,
3478 0, NULL, NULL, NULL)))
3481 /* Get the value of the symbol referred to by the reloc. */
3482 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3484 /* A local symbol. */
3485 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3486 + ELFNN_R_SYM (rel->r_info));
3487 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3488 ? 0 : isym->st_size - rel->r_addend;
3490 if (isym->st_shndx == SHN_UNDEF)
3491 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3494 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3495 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3497 /* The purpose of this code is unknown. It breaks linker scripts
3498 for embedded development that place sections at address zero.
3499 This code is believed to be unnecessary. Disabling it but not
3500 yet removing it, in case something breaks. */
3501 if (sec_addr (sym_sec) == 0)
3504 symval = sec_addr (sym_sec) + isym->st_value;
3510 struct elf_link_hash_entry *h;
3512 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3513 h = elf_sym_hashes (abfd)[indx];
3515 while (h->root.type == bfd_link_hash_indirect
3516 || h->root.type == bfd_link_hash_warning)
3517 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3519 if (h->plt.offset != MINUS_ONE)
3520 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3521 else if (h->root.u.def.section->output_section == NULL
3522 || (h->root.type != bfd_link_hash_defined
3523 && h->root.type != bfd_link_hash_defweak))
3526 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3528 if (h->type != STT_FUNC)
3530 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3531 sym_sec = h->root.u.def.section;
3534 symval += rel->r_addend;
3536 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3537 max_alignment, reserve_size, again,
3545 if (relocs != data->relocs)
3547 riscv_free_pcgp_relocs(&pcgp_relocs, abfd, sec);
3553 # define PRSTATUS_SIZE 0 /* FIXME */
3554 # define PRSTATUS_OFFSET_PR_CURSIG 12
3555 # define PRSTATUS_OFFSET_PR_PID 24
3556 # define PRSTATUS_OFFSET_PR_REG 72
3557 # define ELF_GREGSET_T_SIZE 128
3558 # define PRPSINFO_SIZE 128
3559 # define PRPSINFO_OFFSET_PR_PID 16
3560 # define PRPSINFO_OFFSET_PR_FNAME 32
3561 # define PRPSINFO_OFFSET_PR_PSARGS 48
3563 # define PRSTATUS_SIZE 376
3564 # define PRSTATUS_OFFSET_PR_CURSIG 12
3565 # define PRSTATUS_OFFSET_PR_PID 32
3566 # define PRSTATUS_OFFSET_PR_REG 112
3567 # define ELF_GREGSET_T_SIZE 256
3568 # define PRPSINFO_SIZE 136
3569 # define PRPSINFO_OFFSET_PR_PID 24
3570 # define PRPSINFO_OFFSET_PR_FNAME 40
3571 # define PRPSINFO_OFFSET_PR_PSARGS 56
3574 /* Support for core dump NOTE sections. */
3577 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3579 switch (note->descsz)
3584 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3586 elf_tdata (abfd)->core->signal
3587 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3590 elf_tdata (abfd)->core->lwpid
3591 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3595 /* Make a ".reg/999" section. */
3596 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3597 note->descpos + PRSTATUS_OFFSET_PR_REG);
3601 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3603 switch (note->descsz)
3608 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3610 elf_tdata (abfd)->core->pid
3611 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3614 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3615 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3618 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3619 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3623 /* Note that for some reason, a spurious space is tacked
3624 onto the end of the args in some (at least one anyway)
3625 implementations, so strip it off if it exists. */
3628 char *command = elf_tdata (abfd)->core->command;
3629 int n = strlen (command);
3631 if (0 < n && command[n - 1] == ' ')
3632 command[n - 1] = '\0';
3638 /* Set the right mach type. */
3640 riscv_elf_object_p (bfd *abfd)
3642 /* There are only two mach types in RISCV currently. */
3643 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0)
3644 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32);
3646 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64);
3652 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3653 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3655 #define elf_backend_reloc_type_class riscv_reloc_type_class
3657 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3658 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3659 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3660 #define bfd_elfNN_bfd_merge_private_bfd_data \
3661 _bfd_riscv_elf_merge_private_bfd_data
3663 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3664 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3665 #define elf_backend_check_relocs riscv_elf_check_relocs
3666 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3667 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3668 #define elf_backend_relocate_section riscv_elf_relocate_section
3669 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3670 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3671 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3672 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3673 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3674 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3675 #define elf_backend_object_p riscv_elf_object_p
3676 #define elf_info_to_howto_rel NULL
3677 #define elf_info_to_howto riscv_info_to_howto_rela
3678 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3680 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3682 #define elf_backend_can_gc_sections 1
3683 #define elf_backend_can_refcount 1
3684 #define elf_backend_want_got_plt 1
3685 #define elf_backend_plt_readonly 1
3686 #define elf_backend_plt_alignment 4
3687 #define elf_backend_want_plt_sym 1
3688 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3689 #define elf_backend_want_dynrelro 1
3690 #define elf_backend_rela_normal 1
3691 #define elf_backend_default_execstack 0
3693 #include "elfNN-target.h"