1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2019 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
1278 || s == htab->sdyntdata)
1280 /* Strip this section if we don't need it; see the
1283 else if (strncmp (s->name, ".rela", 5) == 0)
1287 /* We use the reloc_count field as a counter if we need
1288 to copy relocs into the output file. */
1294 /* It's not one of our sections. */
1300 /* If we don't need this section, strip it from the
1301 output file. This is mostly to handle .rela.bss and
1302 .rela.plt. We must create both sections in
1303 create_dynamic_sections, because they must be created
1304 before the linker maps input sections to output
1305 sections. The linker does that before
1306 adjust_dynamic_symbol is called, and it is that
1307 function which decides whether anything needs to go
1308 into these sections. */
1309 s->flags |= SEC_EXCLUDE;
1313 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1316 /* Allocate memory for the section contents. Zero the memory
1317 for the benefit of .rela.plt, which has 4 unused entries
1318 at the beginning, and we don't want garbage. */
1319 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1320 if (s->contents == NULL)
1324 if (elf_hash_table (info)->dynamic_sections_created)
1326 /* Add some entries to the .dynamic section. We fill in the
1327 values later, in riscv_elf_finish_dynamic_sections, but we
1328 must add the entries now so that we get the correct size for
1329 the .dynamic section. The DT_DEBUG entry is filled in by the
1330 dynamic linker and used by the debugger. */
1331 #define add_dynamic_entry(TAG, VAL) \
1332 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1334 if (bfd_link_executable (info))
1336 if (!add_dynamic_entry (DT_DEBUG, 0))
1340 if (htab->elf.srelplt->size != 0)
1342 if (!add_dynamic_entry (DT_PLTGOT, 0)
1343 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1344 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1345 || !add_dynamic_entry (DT_JMPREL, 0))
1349 if (!add_dynamic_entry (DT_RELA, 0)
1350 || !add_dynamic_entry (DT_RELASZ, 0)
1351 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1354 /* If any dynamic relocs apply to a read-only section,
1355 then we need a DT_TEXTREL entry. */
1356 if ((info->flags & DF_TEXTREL) == 0)
1357 elf_link_hash_traverse (&htab->elf, maybe_set_textrel, info);
1359 if (info->flags & DF_TEXTREL)
1361 if (!add_dynamic_entry (DT_TEXTREL, 0))
1365 #undef add_dynamic_entry
1371 #define DTP_OFFSET 0x800
1373 /* Return the relocation value for a TLS dtp-relative reloc. */
1376 dtpoff (struct bfd_link_info *info, bfd_vma address)
1378 /* If tls_sec is NULL, we should have signalled an error already. */
1379 if (elf_hash_table (info)->tls_sec == NULL)
1381 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1384 /* Return the relocation value for a static TLS tp-relative relocation. */
1387 tpoff (struct bfd_link_info *info, bfd_vma address)
1389 /* If tls_sec is NULL, we should have signalled an error already. */
1390 if (elf_hash_table (info)->tls_sec == NULL)
1392 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1395 /* Return the global pointer's value, or 0 if it is not in use. */
1398 riscv_global_pointer_value (struct bfd_link_info *info)
1400 struct bfd_link_hash_entry *h;
1402 h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
1403 if (h == NULL || h->type != bfd_link_hash_defined)
1406 return h->u.def.value + sec_addr (h->u.def.section);
1409 /* Emplace a static relocation. */
1411 static bfd_reloc_status_type
1412 perform_relocation (const reloc_howto_type *howto,
1413 const Elf_Internal_Rela *rel,
1415 asection *input_section,
1419 if (howto->pc_relative)
1420 value -= sec_addr (input_section) + rel->r_offset;
1421 value += rel->r_addend;
1423 switch (ELFNN_R_TYPE (rel->r_info))
1426 case R_RISCV_TPREL_HI20:
1427 case R_RISCV_PCREL_HI20:
1428 case R_RISCV_GOT_HI20:
1429 case R_RISCV_TLS_GOT_HI20:
1430 case R_RISCV_TLS_GD_HI20:
1431 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1432 return bfd_reloc_overflow;
1433 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1436 case R_RISCV_LO12_I:
1437 case R_RISCV_GPREL_I:
1438 case R_RISCV_TPREL_LO12_I:
1439 case R_RISCV_TPREL_I:
1440 case R_RISCV_PCREL_LO12_I:
1441 value = ENCODE_ITYPE_IMM (value);
1444 case R_RISCV_LO12_S:
1445 case R_RISCV_GPREL_S:
1446 case R_RISCV_TPREL_LO12_S:
1447 case R_RISCV_TPREL_S:
1448 case R_RISCV_PCREL_LO12_S:
1449 value = ENCODE_STYPE_IMM (value);
1453 case R_RISCV_CALL_PLT:
1454 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1455 return bfd_reloc_overflow;
1456 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1457 | (ENCODE_ITYPE_IMM (value) << 32);
1461 if (!VALID_UJTYPE_IMM (value))
1462 return bfd_reloc_overflow;
1463 value = ENCODE_UJTYPE_IMM (value);
1466 case R_RISCV_BRANCH:
1467 if (!VALID_SBTYPE_IMM (value))
1468 return bfd_reloc_overflow;
1469 value = ENCODE_SBTYPE_IMM (value);
1472 case R_RISCV_RVC_BRANCH:
1473 if (!VALID_RVC_B_IMM (value))
1474 return bfd_reloc_overflow;
1475 value = ENCODE_RVC_B_IMM (value);
1478 case R_RISCV_RVC_JUMP:
1479 if (!VALID_RVC_J_IMM (value))
1480 return bfd_reloc_overflow;
1481 value = ENCODE_RVC_J_IMM (value);
1484 case R_RISCV_RVC_LUI:
1485 if (RISCV_CONST_HIGH_PART (value) == 0)
1487 /* Linker relaxation can convert an address equal to or greater than
1488 0x800 to slightly below 0x800. C.LUI does not accept zero as a
1489 valid immediate. We can fix this by converting it to a C.LI. */
1490 bfd_vma insn = bfd_get (howto->bitsize, input_bfd,
1491 contents + rel->r_offset);
1492 insn = (insn & ~MATCH_C_LUI) | MATCH_C_LI;
1493 bfd_put (howto->bitsize, input_bfd, insn, contents + rel->r_offset);
1494 value = ENCODE_RVC_IMM (0);
1496 else if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1497 return bfd_reloc_overflow;
1499 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1517 case R_RISCV_32_PCREL:
1518 case R_RISCV_TLS_DTPREL32:
1519 case R_RISCV_TLS_DTPREL64:
1522 case R_RISCV_DELETE:
1523 return bfd_reloc_ok;
1526 return bfd_reloc_notsupported;
1529 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1530 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1531 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1533 return bfd_reloc_ok;
1536 /* Remember all PC-relative high-part relocs we've encountered to help us
1537 later resolve the corresponding low-part relocs. */
1543 } riscv_pcrel_hi_reloc;
1545 typedef struct riscv_pcrel_lo_reloc
1547 asection * input_section;
1548 struct bfd_link_info * info;
1549 reloc_howto_type * howto;
1550 const Elf_Internal_Rela * reloc;
1553 bfd_byte * contents;
1554 struct riscv_pcrel_lo_reloc * next;
1555 } riscv_pcrel_lo_reloc;
1560 riscv_pcrel_lo_reloc *lo_relocs;
1561 } riscv_pcrel_relocs;
1564 riscv_pcrel_reloc_hash (const void *entry)
1566 const riscv_pcrel_hi_reloc *e = entry;
1567 return (hashval_t)(e->address >> 2);
1571 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1573 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1574 return e1->address == e2->address;
1578 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1581 p->lo_relocs = NULL;
1582 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1583 riscv_pcrel_reloc_eq, free);
1584 return p->hi_relocs != NULL;
1588 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1590 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1594 riscv_pcrel_lo_reloc *next = cur->next;
1599 htab_delete (p->hi_relocs);
1603 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela *rel,
1604 struct bfd_link_info *info,
1608 const reloc_howto_type *howto,
1611 /* We may need to reference low addreses in PC-relative modes even when the
1612 * PC is far away from these addresses. For example, undefweak references
1613 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1614 * addresses that we can link PC-relative programs at, the linker can't
1615 * actually relocate references to those symbols. In order to allow these
1616 * programs to work we simply convert the PC-relative auipc sequences to
1617 * 0-relative lui sequences. */
1618 if (bfd_link_pic (info))
1621 /* If it's possible to reference the symbol using auipc we do so, as that's
1622 * more in the spirit of the PC-relative relocations we're processing. */
1623 bfd_vma offset = addr - pc;
1624 if (ARCH_SIZE == 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset)))
1627 /* If it's impossible to reference this with a LUI-based offset then don't
1628 * bother to convert it at all so users still see the PC-relative relocation
1629 * in the truncation message. */
1630 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr)))
1633 rel->r_info = ELFNN_R_INFO(addr, R_RISCV_HI20);
1635 bfd_vma insn = bfd_get(howto->bitsize, input_bfd, contents + rel->r_offset);
1636 insn = (insn & ~MASK_AUIPC) | MATCH_LUI;
1637 bfd_put(howto->bitsize, input_bfd, insn, contents + rel->r_offset);
1642 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr,
1643 bfd_vma value, bfd_boolean absolute)
1645 bfd_vma offset = absolute ? value : value - addr;
1646 riscv_pcrel_hi_reloc entry = {addr, offset};
1647 riscv_pcrel_hi_reloc **slot =
1648 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1650 BFD_ASSERT (*slot == NULL);
1651 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1659 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1660 asection *input_section,
1661 struct bfd_link_info *info,
1662 reloc_howto_type *howto,
1663 const Elf_Internal_Rela *reloc,
1668 riscv_pcrel_lo_reloc *entry;
1669 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1672 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1673 name, contents, p->lo_relocs};
1674 p->lo_relocs = entry;
1679 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1681 riscv_pcrel_lo_reloc *r;
1683 for (r = p->lo_relocs; r != NULL; r = r->next)
1685 bfd *input_bfd = r->input_section->owner;
1687 riscv_pcrel_hi_reloc search = {r->addr, 0};
1688 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1690 /* Check for overflow into bit 11 when adding reloc addend. */
1691 || (! (entry->value & 0x800)
1692 && ((entry->value + r->reloc->r_addend) & 0x800)))
1694 char *string = (entry == NULL
1695 ? "%pcrel_lo missing matching %pcrel_hi"
1696 : "%pcrel_lo overflow with an addend");
1697 (*r->info->callbacks->reloc_dangerous)
1698 (r->info, string, input_bfd, r->input_section, r->reloc->r_offset);
1702 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1703 input_bfd, r->contents);
1709 /* Relocate a RISC-V ELF section.
1711 The RELOCATE_SECTION function is called by the new ELF backend linker
1712 to handle the relocations for a section.
1714 The relocs are always passed as Rela structures.
1716 This function is responsible for adjusting the section contents as
1717 necessary, and (if generating a relocatable output file) adjusting
1718 the reloc addend as necessary.
1720 This function does not have to worry about setting the reloc
1721 address or the reloc symbol index.
1723 LOCAL_SYMS is a pointer to the swapped in local symbols.
1725 LOCAL_SECTIONS is an array giving the section in the input file
1726 corresponding to the st_shndx field of each local symbol.
1728 The global hash table entry for the global symbols can be found
1729 via elf_sym_hashes (input_bfd).
1731 When generating relocatable output, this function must handle
1732 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1733 going to be the section symbol corresponding to the output
1734 section, which means that the addend must be adjusted
1738 riscv_elf_relocate_section (bfd *output_bfd,
1739 struct bfd_link_info *info,
1741 asection *input_section,
1743 Elf_Internal_Rela *relocs,
1744 Elf_Internal_Sym *local_syms,
1745 asection **local_sections)
1747 Elf_Internal_Rela *rel;
1748 Elf_Internal_Rela *relend;
1749 riscv_pcrel_relocs pcrel_relocs;
1750 bfd_boolean ret = FALSE;
1751 asection *sreloc = elf_section_data (input_section)->sreloc;
1752 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1753 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1754 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1755 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1756 bfd_boolean absolute;
1758 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1761 relend = relocs + input_section->reloc_count;
1762 for (rel = relocs; rel < relend; rel++)
1764 unsigned long r_symndx;
1765 struct elf_link_hash_entry *h;
1766 Elf_Internal_Sym *sym;
1769 bfd_reloc_status_type r = bfd_reloc_ok;
1771 bfd_vma off, ie_off;
1772 bfd_boolean unresolved_reloc, is_ie = FALSE;
1773 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1774 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1775 reloc_howto_type *howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
1776 const char *msg = NULL;
1777 bfd_boolean resolved_to_zero;
1780 || r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1783 /* This is a final link. */
1784 r_symndx = ELFNN_R_SYM (rel->r_info);
1788 unresolved_reloc = FALSE;
1789 if (r_symndx < symtab_hdr->sh_info)
1791 sym = local_syms + r_symndx;
1792 sec = local_sections[r_symndx];
1793 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1797 bfd_boolean warned, ignored;
1799 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1800 r_symndx, symtab_hdr, sym_hashes,
1802 unresolved_reloc, warned, ignored);
1805 /* To avoid generating warning messages about truncated
1806 relocations, set the relocation's address to be the same as
1807 the start of this section. */
1808 if (input_section->output_section != NULL)
1809 relocation = input_section->output_section->vma;
1815 if (sec != NULL && discarded_section (sec))
1816 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1817 rel, 1, relend, howto, 0, contents);
1819 if (bfd_link_relocatable (info))
1823 name = h->root.root.string;
1826 name = (bfd_elf_string_from_elf_section
1827 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1828 if (name == NULL || *name == '\0')
1829 name = bfd_section_name (input_bfd, sec);
1832 resolved_to_zero = (h != NULL
1833 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
1839 case R_RISCV_TPREL_ADD:
1841 case R_RISCV_JUMP_SLOT:
1842 case R_RISCV_RELATIVE:
1843 /* These require nothing of us at all. */
1847 case R_RISCV_BRANCH:
1848 case R_RISCV_RVC_BRANCH:
1849 case R_RISCV_RVC_LUI:
1850 case R_RISCV_LO12_I:
1851 case R_RISCV_LO12_S:
1856 case R_RISCV_32_PCREL:
1857 case R_RISCV_DELETE:
1858 /* These require no special handling beyond perform_relocation. */
1861 case R_RISCV_GOT_HI20:
1864 bfd_boolean dyn, pic;
1866 off = h->got.offset;
1867 BFD_ASSERT (off != (bfd_vma) -1);
1868 dyn = elf_hash_table (info)->dynamic_sections_created;
1869 pic = bfd_link_pic (info);
1871 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1872 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1874 /* This is actually a static link, or it is a
1875 -Bsymbolic link and the symbol is defined
1876 locally, or the symbol was forced to be local
1877 because of a version file. We must initialize
1878 this entry in the global offset table. Since the
1879 offset must always be a multiple of the word size,
1880 we use the least significant bit to record whether
1881 we have initialized it already.
1883 When doing a dynamic link, we create a .rela.got
1884 relocation entry to initialize the value. This
1885 is done in the finish_dynamic_symbol routine. */
1890 bfd_put_NN (output_bfd, relocation,
1891 htab->elf.sgot->contents + off);
1896 unresolved_reloc = FALSE;
1900 BFD_ASSERT (local_got_offsets != NULL
1901 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1903 off = local_got_offsets[r_symndx];
1905 /* The offset must always be a multiple of the word size.
1906 So, we can use the least significant bit to record
1907 whether we have already processed this entry. */
1912 if (bfd_link_pic (info))
1915 Elf_Internal_Rela outrel;
1917 /* We need to generate a R_RISCV_RELATIVE reloc
1918 for the dynamic linker. */
1919 s = htab->elf.srelgot;
1920 BFD_ASSERT (s != NULL);
1922 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1924 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1925 outrel.r_addend = relocation;
1927 riscv_elf_append_rela (output_bfd, s, &outrel);
1930 bfd_put_NN (output_bfd, relocation,
1931 htab->elf.sgot->contents + off);
1932 local_got_offsets[r_symndx] |= 1;
1935 relocation = sec_addr (htab->elf.sgot) + off;
1936 absolute = riscv_zero_pcrel_hi_reloc (rel,
1943 r_type = ELFNN_R_TYPE (rel->r_info);
1944 howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
1946 r = bfd_reloc_notsupported;
1947 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
1948 relocation, absolute))
1949 r = bfd_reloc_overflow;
1957 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1958 contents + rel->r_offset);
1959 relocation = old_value + relocation;
1969 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1970 contents + rel->r_offset);
1971 relocation = old_value - relocation;
1976 /* Handle a call to an undefined weak function. This won't be
1977 relaxed, so we have to handle it here. */
1978 if (h != NULL && h->root.type == bfd_link_hash_undefweak
1979 && h->plt.offset == MINUS_ONE)
1981 /* We can use x0 as the base register. */
1982 bfd_vma insn = bfd_get_32 (input_bfd,
1983 contents + rel->r_offset + 4);
1984 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1985 bfd_put_32 (input_bfd, insn, contents + rel->r_offset + 4);
1986 /* Set the relocation value so that we get 0 after the pc
1987 relative adjustment. */
1988 relocation = sec_addr (input_section) + rel->r_offset;
1992 case R_RISCV_CALL_PLT:
1994 case R_RISCV_RVC_JUMP:
1995 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1997 /* Refer to the PLT entry. */
1998 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1999 unresolved_reloc = FALSE;
2003 case R_RISCV_TPREL_HI20:
2004 relocation = tpoff (info, relocation);
2007 case R_RISCV_TPREL_LO12_I:
2008 case R_RISCV_TPREL_LO12_S:
2009 relocation = tpoff (info, relocation);
2012 case R_RISCV_TPREL_I:
2013 case R_RISCV_TPREL_S:
2014 relocation = tpoff (info, relocation);
2015 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
2017 /* We can use tp as the base register. */
2018 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2019 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2020 insn |= X_TP << OP_SH_RS1;
2021 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2024 r = bfd_reloc_overflow;
2027 case R_RISCV_GPREL_I:
2028 case R_RISCV_GPREL_S:
2030 bfd_vma gp = riscv_global_pointer_value (info);
2031 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
2032 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
2034 /* We can use x0 or gp as the base register. */
2035 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2036 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2039 rel->r_addend -= gp;
2040 insn |= X_GP << OP_SH_RS1;
2042 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2045 r = bfd_reloc_overflow;
2049 case R_RISCV_PCREL_HI20:
2050 absolute = riscv_zero_pcrel_hi_reloc (rel,
2057 r_type = ELFNN_R_TYPE (rel->r_info);
2058 howto = riscv_elf_rtype_to_howto (input_bfd, r_type);
2060 r = bfd_reloc_notsupported;
2061 else if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2062 relocation + rel->r_addend,
2064 r = bfd_reloc_overflow;
2067 case R_RISCV_PCREL_LO12_I:
2068 case R_RISCV_PCREL_LO12_S:
2069 /* We don't allow section symbols plus addends as the auipc address,
2070 because then riscv_relax_delete_bytes would have to search through
2071 all relocs to update these addends. This is also ambiguous, as
2072 we do allow offsets to be added to the target address, which are
2073 not to be used to find the auipc address. */
2074 if (((sym != NULL && (ELF_ST_TYPE (sym->st_info) == STT_SECTION))
2075 || (h != NULL && h->type == STT_SECTION))
2078 r = bfd_reloc_dangerous;
2082 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2083 howto, rel, relocation, name,
2086 r = bfd_reloc_overflow;
2089 case R_RISCV_TLS_DTPREL32:
2090 case R_RISCV_TLS_DTPREL64:
2091 relocation = dtpoff (info, relocation);
2096 if ((input_section->flags & SEC_ALLOC) == 0)
2099 if ((bfd_link_pic (info)
2101 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2102 && !resolved_to_zero)
2103 || h->root.type != bfd_link_hash_undefweak)
2104 && (! howto->pc_relative
2105 || !SYMBOL_CALLS_LOCAL (info, h)))
2106 || (!bfd_link_pic (info)
2112 || h->root.type == bfd_link_hash_undefweak
2113 || h->root.type == bfd_link_hash_undefined)))
2115 Elf_Internal_Rela outrel;
2116 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2118 /* When generating a shared object, these relocations
2119 are copied into the output file to be resolved at run
2123 _bfd_elf_section_offset (output_bfd, info, input_section,
2125 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2126 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2127 outrel.r_offset += sec_addr (input_section);
2129 if (skip_dynamic_relocation)
2130 memset (&outrel, 0, sizeof outrel);
2131 else if (h != NULL && h->dynindx != -1
2132 && !(bfd_link_pic (info)
2133 && SYMBOLIC_BIND (info, h)
2136 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2137 outrel.r_addend = rel->r_addend;
2141 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2142 outrel.r_addend = relocation + rel->r_addend;
2145 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2146 if (skip_static_relocation)
2151 case R_RISCV_TLS_GOT_HI20:
2155 case R_RISCV_TLS_GD_HI20:
2158 off = h->got.offset;
2163 off = local_got_offsets[r_symndx];
2164 local_got_offsets[r_symndx] |= 1;
2167 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2168 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2169 /* If this symbol is referenced by both GD and IE TLS, the IE
2170 reference's GOT slot follows the GD reference's slots. */
2172 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2173 ie_off = 2 * GOT_ENTRY_SIZE;
2179 Elf_Internal_Rela outrel;
2181 bfd_boolean need_relocs = FALSE;
2183 if (htab->elf.srelgot == NULL)
2188 bfd_boolean dyn, pic;
2189 dyn = htab->elf.dynamic_sections_created;
2190 pic = bfd_link_pic (info);
2192 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2193 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2197 /* The GOT entries have not been initialized yet. Do it
2198 now, and emit any relocations. */
2199 if ((bfd_link_pic (info) || indx != 0)
2201 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2202 || h->root.type != bfd_link_hash_undefweak))
2205 if (tls_type & GOT_TLS_GD)
2209 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2210 outrel.r_addend = 0;
2211 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2212 bfd_put_NN (output_bfd, 0,
2213 htab->elf.sgot->contents + off);
2214 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2217 BFD_ASSERT (! unresolved_reloc);
2218 bfd_put_NN (output_bfd,
2219 dtpoff (info, relocation),
2220 (htab->elf.sgot->contents + off +
2221 RISCV_ELF_WORD_BYTES));
2225 bfd_put_NN (output_bfd, 0,
2226 (htab->elf.sgot->contents + off +
2227 RISCV_ELF_WORD_BYTES));
2228 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2229 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2230 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2235 /* If we are not emitting relocations for a
2236 general dynamic reference, then we must be in a
2237 static link or an executable link with the
2238 symbol binding locally. Mark it as belonging
2239 to module 1, the executable. */
2240 bfd_put_NN (output_bfd, 1,
2241 htab->elf.sgot->contents + off);
2242 bfd_put_NN (output_bfd,
2243 dtpoff (info, relocation),
2244 (htab->elf.sgot->contents + off +
2245 RISCV_ELF_WORD_BYTES));
2249 if (tls_type & GOT_TLS_IE)
2253 bfd_put_NN (output_bfd, 0,
2254 htab->elf.sgot->contents + off + ie_off);
2255 outrel.r_offset = sec_addr (htab->elf.sgot)
2257 outrel.r_addend = 0;
2259 outrel.r_addend = tpoff (info, relocation);
2260 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2261 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2265 bfd_put_NN (output_bfd, tpoff (info, relocation),
2266 htab->elf.sgot->contents + off + ie_off);
2271 BFD_ASSERT (off < (bfd_vma) -2);
2272 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2273 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2275 r = bfd_reloc_overflow;
2276 unresolved_reloc = FALSE;
2280 r = bfd_reloc_notsupported;
2283 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2284 because such sections are not SEC_ALLOC and thus ld.so will
2285 not process them. */
2286 if (unresolved_reloc
2287 && !((input_section->flags & SEC_DEBUGGING) != 0
2289 && _bfd_elf_section_offset (output_bfd, info, input_section,
2290 rel->r_offset) != (bfd_vma) -1)
2292 (*_bfd_error_handler)
2293 (_("%pB(%pA+%#" PRIx64 "): "
2294 "unresolvable %s relocation against symbol `%s'"),
2297 (uint64_t) rel->r_offset,
2299 h->root.root.string);
2301 bfd_set_error (bfd_error_bad_value);
2306 if (r == bfd_reloc_ok)
2307 r = perform_relocation (howto, rel, relocation, input_section,
2308 input_bfd, contents);
2315 case bfd_reloc_overflow:
2316 info->callbacks->reloc_overflow
2317 (info, (h ? &h->root : NULL), name, howto->name,
2318 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2321 case bfd_reloc_undefined:
2322 info->callbacks->undefined_symbol
2323 (info, name, input_bfd, input_section, rel->r_offset,
2327 case bfd_reloc_outofrange:
2328 msg = _("%X%P: internal error: out of range error\n");
2331 case bfd_reloc_notsupported:
2332 msg = _("%X%P: internal error: unsupported relocation error\n");
2335 case bfd_reloc_dangerous:
2336 info->callbacks->reloc_dangerous
2337 (info, "%pcrel_lo section symbol with an addend", input_bfd,
2338 input_section, rel->r_offset);
2342 msg = _("%X%P: internal error: unknown error\n");
2347 info->callbacks->einfo (msg);
2349 /* We already reported the error via a callback, so don't try to report
2350 it again by returning false. That leads to spurious errors. */
2355 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2357 riscv_free_pcrel_relocs (&pcrel_relocs);
2361 /* Finish up dynamic symbol handling. We set the contents of various
2362 dynamic sections here. */
2365 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2366 struct bfd_link_info *info,
2367 struct elf_link_hash_entry *h,
2368 Elf_Internal_Sym *sym)
2370 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2371 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2373 if (h->plt.offset != (bfd_vma) -1)
2375 /* We've decided to create a PLT entry for this symbol. */
2377 bfd_vma i, header_address, plt_idx, got_address;
2378 uint32_t plt_entry[PLT_ENTRY_INSNS];
2379 Elf_Internal_Rela rela;
2381 BFD_ASSERT (h->dynindx != -1);
2383 /* Calculate the address of the PLT header. */
2384 header_address = sec_addr (htab->elf.splt);
2386 /* Calculate the index of the entry. */
2387 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2389 /* Calculate the address of the .got.plt entry. */
2390 got_address = riscv_elf_got_plt_val (plt_idx, info);
2392 /* Find out where the .plt entry should go. */
2393 loc = htab->elf.splt->contents + h->plt.offset;
2395 /* Fill in the PLT entry itself. */
2396 if (! riscv_make_plt_entry (output_bfd, got_address,
2397 header_address + h->plt.offset,
2401 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2402 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2404 /* Fill in the initial value of the .got.plt entry. */
2405 loc = htab->elf.sgotplt->contents
2406 + (got_address - sec_addr (htab->elf.sgotplt));
2407 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2409 /* Fill in the entry in the .rela.plt section. */
2410 rela.r_offset = got_address;
2412 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2414 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2415 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2417 if (!h->def_regular)
2419 /* Mark the symbol as undefined, rather than as defined in
2420 the .plt section. Leave the value alone. */
2421 sym->st_shndx = SHN_UNDEF;
2422 /* If the symbol is weak, we do need to clear the value.
2423 Otherwise, the PLT entry would provide a definition for
2424 the symbol even if the symbol wasn't defined anywhere,
2425 and so the symbol would never be NULL. */
2426 if (!h->ref_regular_nonweak)
2431 if (h->got.offset != (bfd_vma) -1
2432 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE))
2433 && !UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
2437 Elf_Internal_Rela rela;
2439 /* This symbol has an entry in the GOT. Set it up. */
2441 sgot = htab->elf.sgot;
2442 srela = htab->elf.srelgot;
2443 BFD_ASSERT (sgot != NULL && srela != NULL);
2445 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2447 /* If this is a local symbol reference, we just want to emit a RELATIVE
2448 reloc. This can happen if it is a -Bsymbolic link, or a pie link, or
2449 the symbol was forced to be local because of a version file.
2450 The entry in the global offset table will already have been
2451 initialized in the relocate_section function. */
2452 if (bfd_link_pic (info)
2453 && SYMBOL_REFERENCES_LOCAL (info, h))
2455 BFD_ASSERT((h->got.offset & 1) != 0);
2456 asection *sec = h->root.u.def.section;
2457 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2458 rela.r_addend = (h->root.u.def.value
2459 + sec->output_section->vma
2460 + sec->output_offset);
2464 BFD_ASSERT((h->got.offset & 1) == 0);
2465 BFD_ASSERT (h->dynindx != -1);
2466 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2470 bfd_put_NN (output_bfd, 0,
2471 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2472 riscv_elf_append_rela (output_bfd, srela, &rela);
2477 Elf_Internal_Rela rela;
2480 /* This symbols needs a copy reloc. Set it up. */
2481 BFD_ASSERT (h->dynindx != -1);
2483 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2484 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2486 if (h->root.u.def.section == htab->elf.sdynrelro)
2487 s = htab->elf.sreldynrelro;
2489 s = htab->elf.srelbss;
2490 riscv_elf_append_rela (output_bfd, s, &rela);
2493 /* Mark some specially defined symbols as absolute. */
2494 if (h == htab->elf.hdynamic
2495 || (h == htab->elf.hgot || h == htab->elf.hplt))
2496 sym->st_shndx = SHN_ABS;
2501 /* Finish up the dynamic sections. */
2504 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2505 bfd *dynobj, asection *sdyn)
2507 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2508 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2509 size_t dynsize = bed->s->sizeof_dyn;
2510 bfd_byte *dyncon, *dynconend;
2512 dynconend = sdyn->contents + sdyn->size;
2513 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2515 Elf_Internal_Dyn dyn;
2518 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2523 s = htab->elf.sgotplt;
2524 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2527 s = htab->elf.srelplt;
2528 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2531 s = htab->elf.srelplt;
2532 dyn.d_un.d_val = s->size;
2538 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2544 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2545 struct bfd_link_info *info)
2549 struct riscv_elf_link_hash_table *htab;
2551 htab = riscv_elf_hash_table (info);
2552 BFD_ASSERT (htab != NULL);
2553 dynobj = htab->elf.dynobj;
2555 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2557 if (elf_hash_table (info)->dynamic_sections_created)
2562 splt = htab->elf.splt;
2563 BFD_ASSERT (splt != NULL && sdyn != NULL);
2565 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2570 /* Fill in the head and tail entries in the procedure linkage table. */
2574 uint32_t plt_header[PLT_HEADER_INSNS];
2575 ret = riscv_make_plt_header (output_bfd,
2576 sec_addr (htab->elf.sgotplt),
2577 sec_addr (splt), plt_header);
2581 for (i = 0; i < PLT_HEADER_INSNS; i++)
2582 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2584 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2589 if (htab->elf.sgotplt)
2591 asection *output_section = htab->elf.sgotplt->output_section;
2593 if (bfd_is_abs_section (output_section))
2595 (*_bfd_error_handler)
2596 (_("discarded output section: `%pA'"), htab->elf.sgotplt);
2600 if (htab->elf.sgotplt->size > 0)
2602 /* Write the first two entries in .got.plt, needed for the dynamic
2604 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2605 bfd_put_NN (output_bfd, (bfd_vma) 0,
2606 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2609 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2614 asection *output_section = htab->elf.sgot->output_section;
2616 if (htab->elf.sgot->size > 0)
2618 /* Set the first entry in the global offset table to the address of
2619 the dynamic section. */
2620 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2621 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2624 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2630 /* Return address for Ith PLT stub in section PLT, for relocation REL
2631 or (bfd_vma) -1 if it should not be included. */
2634 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2635 const arelent *rel ATTRIBUTE_UNUSED)
2637 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2640 static enum elf_reloc_type_class
2641 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2642 const asection *rel_sec ATTRIBUTE_UNUSED,
2643 const Elf_Internal_Rela *rela)
2645 switch (ELFNN_R_TYPE (rela->r_info))
2647 case R_RISCV_RELATIVE:
2648 return reloc_class_relative;
2649 case R_RISCV_JUMP_SLOT:
2650 return reloc_class_plt;
2652 return reloc_class_copy;
2654 return reloc_class_normal;
2658 /* Given the ELF header flags in FLAGS, it returns a string that describes the
2662 riscv_float_abi_string (flagword flags)
2664 switch (flags & EF_RISCV_FLOAT_ABI)
2666 case EF_RISCV_FLOAT_ABI_SOFT:
2667 return "soft-float";
2669 case EF_RISCV_FLOAT_ABI_SINGLE:
2670 return "single-float";
2672 case EF_RISCV_FLOAT_ABI_DOUBLE:
2673 return "double-float";
2675 case EF_RISCV_FLOAT_ABI_QUAD:
2676 return "quad-float";
2683 /* The information of architecture attribute. */
2684 static riscv_subset_list_t in_subsets;
2685 static riscv_subset_list_t out_subsets;
2686 static riscv_subset_list_t merged_subsets;
2688 /* Predicator for standard extension. */
2691 riscv_std_ext_p (const char *name)
2693 return (strlen (name) == 1) && (name[0] != 'x') && (name[0] != 's');
2696 /* Predicator for non-standard extension. */
2699 riscv_non_std_ext_p (const char *name)
2701 return (strlen (name) >= 2) && (name[0] == 'x');
2704 /* Predicator for standard supervisor extension. */
2707 riscv_std_sv_ext_p (const char *name)
2709 return (strlen (name) >= 2) && (name[0] == 's') && (name[1] != 'x');
2712 /* Predicator for non-standard supervisor extension. */
2715 riscv_non_std_sv_ext_p (const char *name)
2717 return (strlen (name) >= 3) && (name[0] == 's') && (name[1] == 'x');
2720 /* Error handler when version mis-match. */
2723 riscv_version_mismatch (bfd *ibfd,
2724 struct riscv_subset_t *in,
2725 struct riscv_subset_t *out)
2728 (_("error: %pB: Mis-matched ISA version for '%s' extension. "
2731 in->major_version, in->minor_version,
2732 out->major_version, out->minor_version);
2735 /* Return true if subset is 'i' or 'e'. */
2738 riscv_i_or_e_p (bfd *ibfd,
2740 struct riscv_subset_t *subset)
2742 if ((strcasecmp (subset->name, "e") != 0)
2743 && (strcasecmp (subset->name, "i") != 0))
2746 (_("error: %pB: corrupted ISA string '%s'. "
2747 "First letter should be 'i' or 'e' but got '%s'."),
2748 ibfd, arch, subset->name);
2754 /* Merge standard extensions.
2757 Return FALSE if failed to merge.
2761 `in_arch`: Raw arch string for input object.
2762 `out_arch`: Raw arch string for output object.
2763 `pin`: subset list for input object, and it'll skip all merged subset after
2765 `pout`: Like `pin`, but for output object. */
2768 riscv_merge_std_ext (bfd *ibfd,
2769 const char *in_arch,
2770 const char *out_arch,
2771 struct riscv_subset_t **pin,
2772 struct riscv_subset_t **pout)
2774 const char *standard_exts = riscv_supported_std_ext ();
2776 struct riscv_subset_t *in = *pin;
2777 struct riscv_subset_t *out = *pout;
2779 /* First letter should be 'i' or 'e'. */
2780 if (!riscv_i_or_e_p (ibfd, in_arch, in))
2783 if (!riscv_i_or_e_p (ibfd, out_arch, out))
2786 if (in->name[0] != out->name[0])
2788 /* TODO: We might allow merge 'i' with 'e'. */
2790 (_("error: %pB: Mis-matched ISA string to merge '%s' and '%s'."),
2791 ibfd, in->name, out->name);
2794 else if ((in->major_version != out->major_version) ||
2795 (in->minor_version != out->minor_version))
2797 /* TODO: Allow different merge policy. */
2798 riscv_version_mismatch (ibfd, in, out);
2802 riscv_add_subset (&merged_subsets,
2803 in->name, in->major_version, in->minor_version);
2808 /* Handle standard extension first. */
2809 for (p = standard_exts; *p; ++p)
2811 char find_ext[2] = {*p, '\0'};
2812 struct riscv_subset_t *find_in =
2813 riscv_lookup_subset (&in_subsets, find_ext);
2814 struct riscv_subset_t *find_out =
2815 riscv_lookup_subset (&out_subsets, find_ext);
2817 if (find_in == NULL && find_out == NULL)
2820 /* Check version is same or not. */
2821 /* TODO: Allow different merge policy. */
2822 if ((find_in != NULL && find_out != NULL)
2823 && ((find_in->major_version != find_out->major_version)
2824 || (find_in->minor_version != find_out->minor_version)))
2826 riscv_version_mismatch (ibfd, in, out);
2830 struct riscv_subset_t *merged = find_in ? find_in : find_out;
2831 riscv_add_subset (&merged_subsets, merged->name,
2832 merged->major_version, merged->minor_version);
2835 /* Skip all standard extensions. */
2836 while ((in != NULL) && riscv_std_ext_p (in->name)) in = in->next;
2837 while ((out != NULL) && riscv_std_ext_p (out->name)) out = out->next;
2845 /* Merge non-standard and supervisor extensions.
2847 Return FALSE if failed to merge.
2851 `in_arch`: Raw arch string for input object.
2852 `out_arch`: Raw arch string for output object.
2853 `pin`: subset list for input object, and it'll skip all merged subset after
2855 `pout`: Like `pin`, but for output object. */
2858 riscv_merge_non_std_and_sv_ext (bfd *ibfd,
2859 riscv_subset_t **pin,
2860 riscv_subset_t **pout,
2861 bfd_boolean (*predicate_func) (const char *))
2863 riscv_subset_t *in = *pin;
2864 riscv_subset_t *out = *pout;
2866 for (in = *pin; in != NULL && predicate_func (in->name); in = in->next)
2867 riscv_add_subset (&merged_subsets, in->name, in->major_version,
2870 for (out = *pout; out != NULL && predicate_func (out->name); out = out->next)
2872 riscv_subset_t *find_ext =
2873 riscv_lookup_subset (&merged_subsets, out->name);
2874 if (find_ext != NULL)
2876 /* Check version is same or not. */
2877 /* TODO: Allow different merge policy. */
2878 if ((find_ext->major_version != out->major_version)
2879 || (find_ext->minor_version != out->minor_version))
2881 riscv_version_mismatch (ibfd, find_ext, out);
2886 riscv_add_subset (&merged_subsets, out->name,
2887 out->major_version, out->minor_version);
2895 /* Merge Tag_RISCV_arch attribute. */
2898 riscv_merge_arch_attr_info (bfd *ibfd, char *in_arch, char *out_arch)
2900 riscv_subset_t *in, *out;
2901 char *merged_arch_str;
2903 unsigned xlen_in, xlen_out;
2904 merged_subsets.head = NULL;
2905 merged_subsets.tail = NULL;
2907 riscv_parse_subset_t rpe_in;
2908 riscv_parse_subset_t rpe_out;
2910 rpe_in.subset_list = &in_subsets;
2911 rpe_in.error_handler = _bfd_error_handler;
2912 rpe_in.xlen = &xlen_in;
2914 rpe_out.subset_list = &out_subsets;
2915 rpe_out.error_handler = _bfd_error_handler;
2916 rpe_out.xlen = &xlen_out;
2918 if (in_arch == NULL && out_arch == NULL)
2921 if (in_arch == NULL && out_arch != NULL)
2924 if (in_arch != NULL && out_arch == NULL)
2927 /* Parse subset from arch string. */
2928 if (!riscv_parse_subset (&rpe_in, in_arch))
2931 if (!riscv_parse_subset (&rpe_out, out_arch))
2934 /* Checking XLEN. */
2935 if (xlen_out != xlen_in)
2938 (_("error: %pB: ISA string of input (%s) doesn't match "
2939 "output (%s)."), ibfd, in_arch, out_arch);
2943 /* Merge subset list. */
2944 in = in_subsets.head;
2945 out = out_subsets.head;
2947 /* Merge standard extension. */
2948 if (!riscv_merge_std_ext (ibfd, in_arch, out_arch, &in, &out))
2950 /* Merge non-standard extension. */
2951 if (!riscv_merge_non_std_and_sv_ext (ibfd, &in, &out, riscv_non_std_ext_p))
2953 /* Merge standard supervisor extension. */
2954 if (!riscv_merge_non_std_and_sv_ext (ibfd, &in, &out, riscv_std_sv_ext_p))
2956 /* Merge non-standard supervisor extension. */
2957 if (!riscv_merge_non_std_and_sv_ext (ibfd, &in, &out, riscv_non_std_sv_ext_p))
2960 if (xlen_in != xlen_out)
2963 (_("error: %pB: XLEN of input (%u) doesn't match "
2964 "output (%u)."), ibfd, xlen_in, xlen_out);
2968 if (xlen_in != ARCH_SIZE)
2971 (_("error: %pB: Unsupported XLEN (%u), you might be "
2972 "using wrong emulation."), ibfd, xlen_in);
2976 merged_arch_str = riscv_arch_str (ARCH_SIZE, &merged_subsets);
2978 /* Release the subset lists. */
2979 riscv_release_subset_list (&in_subsets);
2980 riscv_release_subset_list (&out_subsets);
2981 riscv_release_subset_list (&merged_subsets);
2983 return merged_arch_str;
2986 /* Merge object attributes from IBFD into output_bfd of INFO.
2987 Raise an error if there are conflicting attributes. */
2990 riscv_merge_attributes (bfd *ibfd, struct bfd_link_info *info)
2992 bfd *obfd = info->output_bfd;
2993 obj_attribute *in_attr;
2994 obj_attribute *out_attr;
2995 bfd_boolean result = TRUE;
2996 const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
2999 /* Skip linker created files. */
3000 if (ibfd->flags & BFD_LINKER_CREATED)
3003 /* Skip any input that doesn't have an attribute section.
3004 This enables to link object files without attribute section with
3006 if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
3009 if (!elf_known_obj_attributes_proc (obfd)[0].i)
3011 /* This is the first object. Copy the attributes. */
3012 _bfd_elf_copy_obj_attributes (ibfd, obfd);
3014 out_attr = elf_known_obj_attributes_proc (obfd);
3016 /* Use the Tag_null value to indicate the attributes have been
3023 in_attr = elf_known_obj_attributes_proc (ibfd);
3024 out_attr = elf_known_obj_attributes_proc (obfd);
3026 for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
3030 case Tag_RISCV_arch:
3031 if (!out_attr[Tag_RISCV_arch].s)
3032 out_attr[Tag_RISCV_arch].s = in_attr[Tag_RISCV_arch].s;
3033 else if (in_attr[Tag_RISCV_arch].s
3034 && out_attr[Tag_RISCV_arch].s)
3036 /* Check arch compatible. */
3038 riscv_merge_arch_attr_info (ibfd,
3039 in_attr[Tag_RISCV_arch].s,
3040 out_attr[Tag_RISCV_arch].s);
3041 if (merged_arch == NULL)
3044 out_attr[Tag_RISCV_arch].s = "";
3047 out_attr[Tag_RISCV_arch].s = merged_arch;
3050 case Tag_RISCV_priv_spec:
3051 case Tag_RISCV_priv_spec_minor:
3052 case Tag_RISCV_priv_spec_revision:
3053 if (out_attr[i].i != in_attr[i].i)
3056 (_("error: %pB: conflicting priv spec version "
3057 "(major/minor/revision)."), ibfd);
3061 case Tag_RISCV_unaligned_access:
3062 out_attr[i].i |= in_attr[i].i;
3064 case Tag_RISCV_stack_align:
3065 if (out_attr[i].i == 0)
3066 out_attr[i].i = in_attr[i].i;
3067 else if (in_attr[i].i != 0
3068 && out_attr[i].i != 0
3069 && out_attr[i].i != in_attr[i].i)
3072 (_("error: %pB use %u-byte stack aligned but the output "
3073 "use %u-byte stack aligned."),
3074 ibfd, in_attr[i].i, out_attr[i].i);
3079 result &= _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
3082 /* If out_attr was copied from in_attr then it won't have a type yet. */
3083 if (in_attr[i].type && !out_attr[i].type)
3084 out_attr[i].type = in_attr[i].type;
3087 /* Merge Tag_compatibility attributes and any common GNU ones. */
3088 if (!_bfd_elf_merge_object_attributes (ibfd, info))
3091 /* Check for any attributes not known on RISC-V. */
3092 result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
3097 /* Merge backend specific data from an object file to the output
3098 object file when linking. */
3101 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
3103 bfd *obfd = info->output_bfd;
3104 flagword new_flags, old_flags;
3106 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
3109 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
3111 (*_bfd_error_handler)
3112 (_("%pB: ABI is incompatible with that of the selected emulation:\n"
3113 " target emulation `%s' does not match `%s'"),
3114 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
3118 if (!_bfd_elf_merge_object_attributes (ibfd, info))
3121 if (!riscv_merge_attributes (ibfd, info))
3124 new_flags = elf_elfheader (ibfd)->e_flags;
3125 old_flags = elf_elfheader (obfd)->e_flags;
3127 if (! elf_flags_init (obfd))
3129 elf_flags_init (obfd) = TRUE;
3130 elf_elfheader (obfd)->e_flags = new_flags;
3134 /* Check to see if the input BFD actually contains any sections. If not,
3135 its flags may not have been initialized either, but it cannot actually
3136 cause any incompatibility. Do not short-circuit dynamic objects; their
3137 section list may be emptied by elf_link_add_object_symbols.
3139 Also check to see if there are no code sections in the input. In this
3140 case, there is no need to check for code specific flags. */
3141 if (!(ibfd->flags & DYNAMIC))
3143 bfd_boolean null_input_bfd = TRUE;
3144 bfd_boolean only_data_sections = TRUE;
3147 for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3149 if ((bfd_get_section_flags (ibfd, sec)
3150 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3151 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3152 only_data_sections = FALSE;
3154 null_input_bfd = FALSE;
3158 if (null_input_bfd || only_data_sections)
3162 /* Disallow linking different float ABIs. */
3163 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
3165 (*_bfd_error_handler)
3166 (_("%pB: can't link %s modules with %s modules"), ibfd,
3167 riscv_float_abi_string (new_flags),
3168 riscv_float_abi_string (old_flags));
3172 /* Disallow linking RVE and non-RVE. */
3173 if ((old_flags ^ new_flags) & EF_RISCV_RVE)
3175 (*_bfd_error_handler)
3176 (_("%pB: can't link RVE with other target"), ibfd);
3180 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
3181 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
3186 bfd_set_error (bfd_error_bad_value);
3190 /* Delete some bytes from a section while relaxing. */
3193 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count,
3194 struct bfd_link_info *link_info)
3196 unsigned int i, symcount;
3197 bfd_vma toaddr = sec->size;
3198 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
3199 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3200 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
3201 struct bfd_elf_section_data *data = elf_section_data (sec);
3202 bfd_byte *contents = data->this_hdr.contents;
3204 /* Actually delete the bytes. */
3206 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
3208 /* Adjust the location of all of the relocs. Note that we need not
3209 adjust the addends, since all PC-relative references must be against
3210 symbols, which we will adjust below. */
3211 for (i = 0; i < sec->reloc_count; i++)
3212 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
3213 data->relocs[i].r_offset -= count;
3215 /* Adjust the local symbols defined in this section. */
3216 for (i = 0; i < symtab_hdr->sh_info; i++)
3218 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
3219 if (sym->st_shndx == sec_shndx)
3221 /* If the symbol is in the range of memory we just moved, we
3222 have to adjust its value. */
3223 if (sym->st_value > addr && sym->st_value <= toaddr)
3224 sym->st_value -= count;
3226 /* If the symbol *spans* the bytes we just deleted (i.e. its
3227 *end* is in the moved bytes but its *start* isn't), then we
3228 must adjust its size.
3230 This test needs to use the original value of st_value, otherwise
3231 we might accidentally decrease size when deleting bytes right
3232 before the symbol. But since deleted relocs can't span across
3233 symbols, we can't have both a st_value and a st_size decrease,
3234 so it is simpler to just use an else. */
3235 else if (sym->st_value <= addr
3236 && sym->st_value + sym->st_size > addr
3237 && sym->st_value + sym->st_size <= toaddr)
3238 sym->st_size -= count;
3242 /* Now adjust the global symbols defined in this section. */
3243 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
3244 - symtab_hdr->sh_info);
3246 for (i = 0; i < symcount; i++)
3248 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
3250 /* The '--wrap SYMBOL' option is causing a pain when the object file,
3251 containing the definition of __wrap_SYMBOL, includes a direct
3252 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
3253 the same symbol (which is __wrap_SYMBOL), but still exist as two
3254 different symbols in 'sym_hashes', we don't want to adjust
3255 the global symbol __wrap_SYMBOL twice. */
3256 /* The same problem occurs with symbols that are versioned_hidden, as
3257 foo becomes an alias for foo@BAR, and hence they need the same
3259 if (link_info->wrap_hash != NULL
3260 || sym_hash->versioned == versioned_hidden)
3262 struct elf_link_hash_entry **cur_sym_hashes;
3264 /* Loop only over the symbols which have already been checked. */
3265 for (cur_sym_hashes = sym_hashes; cur_sym_hashes < &sym_hashes[i];
3268 /* If the current symbol is identical to 'sym_hash', that means
3269 the symbol was already adjusted (or at least checked). */
3270 if (*cur_sym_hashes == sym_hash)
3273 /* Don't adjust the symbol again. */
3274 if (cur_sym_hashes < &sym_hashes[i])
3278 if ((sym_hash->root.type == bfd_link_hash_defined
3279 || sym_hash->root.type == bfd_link_hash_defweak)
3280 && sym_hash->root.u.def.section == sec)
3282 /* As above, adjust the value if needed. */
3283 if (sym_hash->root.u.def.value > addr
3284 && sym_hash->root.u.def.value <= toaddr)
3285 sym_hash->root.u.def.value -= count;
3287 /* As above, adjust the size if needed. */
3288 else if (sym_hash->root.u.def.value <= addr
3289 && sym_hash->root.u.def.value + sym_hash->size > addr
3290 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
3291 sym_hash->size -= count;
3298 /* A second format for recording PC-relative hi relocations. This stores the
3299 information required to relax them to GP-relative addresses. */
3301 typedef struct riscv_pcgp_hi_reloc riscv_pcgp_hi_reloc;
3302 struct riscv_pcgp_hi_reloc
3309 riscv_pcgp_hi_reloc *next;
3312 typedef struct riscv_pcgp_lo_reloc riscv_pcgp_lo_reloc;
3313 struct riscv_pcgp_lo_reloc
3316 riscv_pcgp_lo_reloc *next;
3321 riscv_pcgp_hi_reloc *hi;
3322 riscv_pcgp_lo_reloc *lo;
3323 } riscv_pcgp_relocs;
3325 /* Initialize the pcgp reloc info in P. */
3328 riscv_init_pcgp_relocs (riscv_pcgp_relocs *p)
3335 /* Free the pcgp reloc info in P. */
3338 riscv_free_pcgp_relocs (riscv_pcgp_relocs *p,
3339 bfd *abfd ATTRIBUTE_UNUSED,
3340 asection *sec ATTRIBUTE_UNUSED)
3342 riscv_pcgp_hi_reloc *c;
3343 riscv_pcgp_lo_reloc *l;
3345 for (c = p->hi; c != NULL;)
3347 riscv_pcgp_hi_reloc *next = c->next;
3352 for (l = p->lo; l != NULL;)
3354 riscv_pcgp_lo_reloc *next = l->next;
3360 /* Record pcgp hi part reloc info in P, using HI_SEC_OFF as the lookup index.
3361 The HI_ADDEND, HI_ADDR, HI_SYM, and SYM_SEC args contain info required to
3362 relax the corresponding lo part reloc. */
3365 riscv_record_pcgp_hi_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off,
3366 bfd_vma hi_addend, bfd_vma hi_addr,
3367 unsigned hi_sym, asection *sym_sec)
3369 riscv_pcgp_hi_reloc *new = bfd_malloc (sizeof(*new));
3372 new->hi_sec_off = hi_sec_off;
3373 new->hi_addend = hi_addend;
3374 new->hi_addr = hi_addr;
3375 new->hi_sym = hi_sym;
3376 new->sym_sec = sym_sec;
3382 /* Look up hi part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3383 This is used by a lo part reloc to find the corresponding hi part reloc. */
3385 static riscv_pcgp_hi_reloc *
3386 riscv_find_pcgp_hi_reloc(riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
3388 riscv_pcgp_hi_reloc *c;
3390 for (c = p->hi; c != NULL; c = c->next)
3391 if (c->hi_sec_off == hi_sec_off)
3396 /* Record pcgp lo part reloc info in P, using HI_SEC_OFF as the lookup info.
3397 This is used to record relocs that can't be relaxed. */
3400 riscv_record_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
3402 riscv_pcgp_lo_reloc *new = bfd_malloc (sizeof(*new));
3405 new->hi_sec_off = hi_sec_off;
3411 /* Look up lo part pcgp reloc info in P, using HI_SEC_OFF as the lookup index.
3412 This is used by a hi part reloc to find the corresponding lo part reloc. */
3415 riscv_find_pcgp_lo_reloc (riscv_pcgp_relocs *p, bfd_vma hi_sec_off)
3417 riscv_pcgp_lo_reloc *c;
3419 for (c = p->lo; c != NULL; c = c->next)
3420 if (c->hi_sec_off == hi_sec_off)
3425 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
3426 struct bfd_link_info *,
3427 Elf_Internal_Rela *,
3428 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *,
3429 riscv_pcgp_relocs *);
3431 /* Relax AUIPC + JALR into JAL. */
3434 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
3435 struct bfd_link_info *link_info,
3436 Elf_Internal_Rela *rel,
3438 bfd_vma max_alignment,
3439 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3441 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3443 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3444 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
3445 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
3446 bfd_vma auipc, jalr;
3447 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
3449 /* If the call crosses section boundaries, an alignment directive could
3450 cause the PC-relative offset to later increase. */
3451 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
3452 foff += (foff < 0 ? -max_alignment : max_alignment);
3454 /* See if this function call can be shortened. */
3455 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
3458 /* Shorten the function call. */
3459 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
3461 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
3462 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
3463 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
3464 rvc = rvc && VALID_RVC_J_IMM (foff);
3466 /* C.J exists on RV32 and RV64, but C.JAL is RV32-only. */
3467 rvc = rvc && (rd == 0 || (rd == X_RA && ARCH_SIZE == 32));
3471 /* Relax to C.J[AL] rd, addr. */
3472 r_type = R_RISCV_RVC_JUMP;
3473 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
3476 else if (VALID_UJTYPE_IMM (foff))
3478 /* Relax to JAL rd, addr. */
3479 r_type = R_RISCV_JAL;
3480 auipc = MATCH_JAL | (rd << OP_SH_RD);
3482 else /* near_zero */
3484 /* Relax to JALR rd, x0, addr. */
3485 r_type = R_RISCV_LO12_I;
3486 auipc = MATCH_JALR | (rd << OP_SH_RD);
3489 /* Replace the R_RISCV_CALL reloc. */
3490 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
3491 /* Replace the AUIPC. */
3492 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
3494 /* Delete unnecessary JALR. */
3496 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len,
3500 /* Traverse all output sections and return the max alignment. */
3503 _bfd_riscv_get_max_alignment (asection *sec)
3505 unsigned int max_alignment_power = 0;
3508 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
3510 if (o->alignment_power > max_alignment_power)
3511 max_alignment_power = o->alignment_power;
3514 return (bfd_vma) 1 << max_alignment_power;
3517 /* Relax non-PIC global variable references. */
3520 _bfd_riscv_relax_lui (bfd *abfd,
3523 struct bfd_link_info *link_info,
3524 Elf_Internal_Rela *rel,
3526 bfd_vma max_alignment,
3527 bfd_vma reserve_size,
3529 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3531 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3532 bfd_vma gp = riscv_global_pointer_value (link_info);
3533 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
3535 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3539 /* If gp and the symbol are in the same output section, which is not the
3540 abs section, then consider only that output section's alignment. */
3541 struct bfd_link_hash_entry *h =
3542 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE,
3544 if (h->u.def.section->output_section == sym_sec->output_section
3545 && sym_sec->output_section != bfd_abs_section_ptr)
3546 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
3549 /* Is the reference in range of x0 or gp?
3550 Valid gp range conservatively because of alignment issue. */
3551 if (VALID_ITYPE_IMM (symval)
3553 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
3555 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
3557 unsigned sym = ELFNN_R_SYM (rel->r_info);
3558 switch (ELFNN_R_TYPE (rel->r_info))
3560 case R_RISCV_LO12_I:
3561 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
3564 case R_RISCV_LO12_S:
3565 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
3569 /* We can delete the unnecessary LUI and reloc. */
3570 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3572 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4,
3580 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
3581 account for this assuming page alignment at worst. In the presence of
3582 RELRO segment the linker aligns it by one page size, therefore sections
3583 after the segment can be moved more than one page. */
3586 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
3587 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
3588 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval)
3589 + (link_info->relro ? 2 * ELF_MAXPAGESIZE
3590 : ELF_MAXPAGESIZE)))
3592 /* Replace LUI with C.LUI if legal (i.e., rd != x0 and rd != x2/sp). */
3593 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
3594 unsigned rd = ((unsigned)lui >> OP_SH_RD) & OP_MASK_RD;
3595 if (rd == 0 || rd == X_SP)
3598 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
3599 bfd_put_32 (abfd, lui, contents + rel->r_offset);
3601 /* Replace the R_RISCV_HI20 reloc. */
3602 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
3605 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2,
3612 /* Relax non-PIC TLS references. */
3615 _bfd_riscv_relax_tls_le (bfd *abfd,
3617 asection *sym_sec ATTRIBUTE_UNUSED,
3618 struct bfd_link_info *link_info,
3619 Elf_Internal_Rela *rel,
3621 bfd_vma max_alignment ATTRIBUTE_UNUSED,
3622 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3624 riscv_pcgp_relocs *prcel_relocs ATTRIBUTE_UNUSED)
3626 /* See if this symbol is in range of tp. */
3627 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
3630 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3631 switch (ELFNN_R_TYPE (rel->r_info))
3633 case R_RISCV_TPREL_LO12_I:
3634 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
3637 case R_RISCV_TPREL_LO12_S:
3638 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
3641 case R_RISCV_TPREL_HI20:
3642 case R_RISCV_TPREL_ADD:
3643 /* We can delete the unnecessary instruction and reloc. */
3644 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3646 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4, link_info);
3653 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
3656 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
3658 struct bfd_link_info *link_info,
3659 Elf_Internal_Rela *rel,
3661 bfd_vma max_alignment ATTRIBUTE_UNUSED,
3662 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3663 bfd_boolean *again ATTRIBUTE_UNUSED,
3664 riscv_pcgp_relocs *pcrel_relocs ATTRIBUTE_UNUSED)
3666 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
3667 bfd_vma alignment = 1, pos;
3668 while (alignment <= rel->r_addend)
3671 symval -= rel->r_addend;
3672 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
3673 bfd_vma nop_bytes = aligned_addr - symval;
3675 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3676 sec->sec_flg0 = TRUE;
3678 /* Make sure there are enough NOPs to actually achieve the alignment. */
3679 if (rel->r_addend < nop_bytes)
3682 (_("%pB(%pA+%#" PRIx64 "): %" PRId64 " bytes required for alignment "
3683 "to %" PRId64 "-byte boundary, but only %" PRId64 " present"),
3684 abfd, sym_sec, (uint64_t) rel->r_offset,
3685 (int64_t) nop_bytes, (int64_t) alignment, (int64_t) rel->r_addend);
3686 bfd_set_error (bfd_error_bad_value);
3690 /* Delete the reloc. */
3691 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3693 /* If the number of NOPs is already correct, there's nothing to do. */
3694 if (nop_bytes == rel->r_addend)
3697 /* Write as many RISC-V NOPs as we need. */
3698 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
3699 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
3701 /* Write a final RVC NOP if need be. */
3702 if (nop_bytes % 4 != 0)
3703 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
3705 /* Delete the excess bytes. */
3706 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
3707 rel->r_addend - nop_bytes, link_info);
3710 /* Relax PC-relative references to GP-relative references. */
3713 _bfd_riscv_relax_pc (bfd *abfd ATTRIBUTE_UNUSED,
3716 struct bfd_link_info *link_info,
3717 Elf_Internal_Rela *rel,
3719 bfd_vma max_alignment,
3720 bfd_vma reserve_size,
3721 bfd_boolean *again ATTRIBUTE_UNUSED,
3722 riscv_pcgp_relocs *pcgp_relocs)
3724 bfd_vma gp = riscv_global_pointer_value (link_info);
3726 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
3728 /* Chain the _LO relocs to their cooresponding _HI reloc to compute the
3729 * actual target address. */
3730 riscv_pcgp_hi_reloc hi_reloc;
3731 memset (&hi_reloc, 0, sizeof (hi_reloc));
3732 switch (ELFNN_R_TYPE (rel->r_info))
3734 case R_RISCV_PCREL_LO12_I:
3735 case R_RISCV_PCREL_LO12_S:
3737 /* If the %lo has an addend, it isn't for the label pointing at the
3738 hi part instruction, but rather for the symbol pointed at by the
3739 hi part instruction. So we must subtract it here for the lookup.
3740 It is still used below in the final symbol address. */
3741 bfd_vma hi_sec_off = symval - sec_addr (sym_sec) - rel->r_addend;
3742 riscv_pcgp_hi_reloc *hi = riscv_find_pcgp_hi_reloc (pcgp_relocs,
3746 riscv_record_pcgp_lo_reloc (pcgp_relocs, hi_sec_off);
3751 symval = hi_reloc.hi_addr;
3752 sym_sec = hi_reloc.sym_sec;
3756 case R_RISCV_PCREL_HI20:
3757 /* Mergeable symbols and code might later move out of range. */
3758 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
3761 /* If the cooresponding lo relocation has already been seen then it's not
3762 * safe to relax this relocation. */
3763 if (riscv_find_pcgp_lo_reloc (pcgp_relocs, rel->r_offset))
3774 /* If gp and the symbol are in the same output section, which is not the
3775 abs section, then consider only that output section's alignment. */
3776 struct bfd_link_hash_entry *h =
3777 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE,
3779 if (h->u.def.section->output_section == sym_sec->output_section
3780 && sym_sec->output_section != bfd_abs_section_ptr)
3781 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
3784 /* Is the reference in range of x0 or gp?
3785 Valid gp range conservatively because of alignment issue. */
3786 if (VALID_ITYPE_IMM (symval)
3788 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
3790 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
3792 unsigned sym = hi_reloc.hi_sym;
3793 switch (ELFNN_R_TYPE (rel->r_info))
3795 case R_RISCV_PCREL_LO12_I:
3796 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
3797 rel->r_addend += hi_reloc.hi_addend;
3800 case R_RISCV_PCREL_LO12_S:
3801 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
3802 rel->r_addend += hi_reloc.hi_addend;
3805 case R_RISCV_PCREL_HI20:
3806 riscv_record_pcgp_hi_reloc (pcgp_relocs,
3810 ELFNN_R_SYM(rel->r_info),
3812 /* We can delete the unnecessary AUIPC and reloc. */
3813 rel->r_info = ELFNN_R_INFO (0, R_RISCV_DELETE);
3825 /* Relax PC-relative references to GP-relative references. */
3828 _bfd_riscv_relax_delete (bfd *abfd,
3830 asection *sym_sec ATTRIBUTE_UNUSED,
3831 struct bfd_link_info *link_info,
3832 Elf_Internal_Rela *rel,
3833 bfd_vma symval ATTRIBUTE_UNUSED,
3834 bfd_vma max_alignment ATTRIBUTE_UNUSED,
3835 bfd_vma reserve_size ATTRIBUTE_UNUSED,
3836 bfd_boolean *again ATTRIBUTE_UNUSED,
3837 riscv_pcgp_relocs *pcgp_relocs ATTRIBUTE_UNUSED)
3839 if (!riscv_relax_delete_bytes(abfd, sec, rel->r_offset, rel->r_addend,
3842 rel->r_info = ELFNN_R_INFO(0, R_RISCV_NONE);
3846 /* Relax a section. Pass 0 shortens code sequences unless disabled. Pass 1
3847 deletes the bytes that pass 0 made obselete. Pass 2, which cannot be
3848 disabled, handles code alignment directives. */
3851 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
3852 struct bfd_link_info *info,
3855 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
3856 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
3857 struct bfd_elf_section_data *data = elf_section_data (sec);
3858 Elf_Internal_Rela *relocs;
3859 bfd_boolean ret = FALSE;
3861 bfd_vma max_alignment, reserve_size = 0;
3862 riscv_pcgp_relocs pcgp_relocs;
3866 if (bfd_link_relocatable (info)
3868 || (sec->flags & SEC_RELOC) == 0
3869 || sec->reloc_count == 0
3870 || (info->disable_target_specific_optimizations
3871 && info->relax_pass == 0))
3874 riscv_init_pcgp_relocs (&pcgp_relocs);
3876 /* Read this BFD's relocs if we haven't done so already. */
3878 relocs = data->relocs;
3879 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3880 info->keep_memory)))
3885 max_alignment = htab->max_alignment;
3886 if (max_alignment == (bfd_vma) -1)
3888 max_alignment = _bfd_riscv_get_max_alignment (sec);
3889 htab->max_alignment = max_alignment;
3893 max_alignment = _bfd_riscv_get_max_alignment (sec);
3895 /* Examine and consider relaxing each reloc. */
3896 for (i = 0; i < sec->reloc_count; i++)
3899 Elf_Internal_Rela *rel = relocs + i;
3900 relax_func_t relax_func;
3901 int type = ELFNN_R_TYPE (rel->r_info);
3906 if (info->relax_pass == 0)
3908 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3909 relax_func = _bfd_riscv_relax_call;
3910 else if (type == R_RISCV_HI20
3911 || type == R_RISCV_LO12_I
3912 || type == R_RISCV_LO12_S)
3913 relax_func = _bfd_riscv_relax_lui;
3914 else if (!bfd_link_pic(info)
3915 && (type == R_RISCV_PCREL_HI20
3916 || type == R_RISCV_PCREL_LO12_I
3917 || type == R_RISCV_PCREL_LO12_S))
3918 relax_func = _bfd_riscv_relax_pc;
3919 else if (type == R_RISCV_TPREL_HI20
3920 || type == R_RISCV_TPREL_ADD
3921 || type == R_RISCV_TPREL_LO12_I
3922 || type == R_RISCV_TPREL_LO12_S)
3923 relax_func = _bfd_riscv_relax_tls_le;
3927 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3928 if (i == sec->reloc_count - 1
3929 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3930 || rel->r_offset != (rel + 1)->r_offset)
3933 /* Skip over the R_RISCV_RELAX. */
3936 else if (info->relax_pass == 1 && type == R_RISCV_DELETE)
3937 relax_func = _bfd_riscv_relax_delete;
3938 else if (info->relax_pass == 2 && type == R_RISCV_ALIGN)
3939 relax_func = _bfd_riscv_relax_align;
3943 data->relocs = relocs;
3945 /* Read this BFD's contents if we haven't done so already. */
3946 if (!data->this_hdr.contents
3947 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3950 /* Read this BFD's symbols if we haven't done so already. */
3951 if (symtab_hdr->sh_info != 0
3952 && !symtab_hdr->contents
3953 && !(symtab_hdr->contents =
3954 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3955 symtab_hdr->sh_info,
3956 0, NULL, NULL, NULL)))
3959 /* Get the value of the symbol referred to by the reloc. */
3960 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3962 /* A local symbol. */
3963 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3964 + ELFNN_R_SYM (rel->r_info));
3965 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3966 ? 0 : isym->st_size - rel->r_addend;
3968 if (isym->st_shndx == SHN_UNDEF)
3969 sym_sec = sec, symval = rel->r_offset;
3972 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3973 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3975 /* The purpose of this code is unknown. It breaks linker scripts
3976 for embedded development that place sections at address zero.
3977 This code is believed to be unnecessary. Disabling it but not
3978 yet removing it, in case something breaks. */
3979 if (sec_addr (sym_sec) == 0)
3982 symval = isym->st_value;
3984 symtype = ELF_ST_TYPE (isym->st_info);
3989 struct elf_link_hash_entry *h;
3991 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3992 h = elf_sym_hashes (abfd)[indx];
3994 while (h->root.type == bfd_link_hash_indirect
3995 || h->root.type == bfd_link_hash_warning)
3996 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3998 if (h->plt.offset != MINUS_ONE)
4000 sym_sec = htab->elf.splt;
4001 symval = h->plt.offset;
4003 else if (h->root.u.def.section->output_section == NULL
4004 || (h->root.type != bfd_link_hash_defined
4005 && h->root.type != bfd_link_hash_defweak))
4009 symval = h->root.u.def.value;
4010 sym_sec = h->root.u.def.section;
4013 if (h->type != STT_FUNC)
4015 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
4019 if (sym_sec->sec_info_type == SEC_INFO_TYPE_MERGE
4020 && (sym_sec->flags & SEC_MERGE))
4022 /* At this stage in linking, no SEC_MERGE symbol has been
4023 adjusted, so all references to such symbols need to be
4024 passed through _bfd_merged_section_offset. (Later, in
4025 relocate_section, all SEC_MERGE symbols *except* for
4026 section symbols have been adjusted.)
4028 gas may reduce relocations against symbols in SEC_MERGE
4029 sections to a relocation against the section symbol when
4030 the original addend was zero. When the reloc is against
4031 a section symbol we should include the addend in the
4032 offset passed to _bfd_merged_section_offset, since the
4033 location of interest is the original symbol. On the
4034 other hand, an access to "sym+addend" where "sym" is not
4035 a section symbol should not include the addend; Such an
4036 access is presumed to be an offset from "sym"; The
4037 location of interest is just "sym". */
4038 if (symtype == STT_SECTION)
4039 symval += rel->r_addend;
4041 symval = _bfd_merged_section_offset (abfd, &sym_sec,
4042 elf_section_data (sym_sec)->sec_info,
4045 if (symtype != STT_SECTION)
4046 symval += rel->r_addend;
4049 symval += rel->r_addend;
4051 symval += sec_addr (sym_sec);
4053 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
4054 max_alignment, reserve_size, again,
4062 if (relocs != data->relocs)
4064 riscv_free_pcgp_relocs(&pcgp_relocs, abfd, sec);
4070 # define PRSTATUS_SIZE 204
4071 # define PRSTATUS_OFFSET_PR_CURSIG 12
4072 # define PRSTATUS_OFFSET_PR_PID 24
4073 # define PRSTATUS_OFFSET_PR_REG 72
4074 # define ELF_GREGSET_T_SIZE 128
4075 # define PRPSINFO_SIZE 128
4076 # define PRPSINFO_OFFSET_PR_PID 16
4077 # define PRPSINFO_OFFSET_PR_FNAME 32
4078 # define PRPSINFO_OFFSET_PR_PSARGS 48
4080 # define PRSTATUS_SIZE 376
4081 # define PRSTATUS_OFFSET_PR_CURSIG 12
4082 # define PRSTATUS_OFFSET_PR_PID 32
4083 # define PRSTATUS_OFFSET_PR_REG 112
4084 # define ELF_GREGSET_T_SIZE 256
4085 # define PRPSINFO_SIZE 136
4086 # define PRPSINFO_OFFSET_PR_PID 24
4087 # define PRPSINFO_OFFSET_PR_FNAME 40
4088 # define PRPSINFO_OFFSET_PR_PSARGS 56
4091 /* Support for core dump NOTE sections. */
4094 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4096 switch (note->descsz)
4101 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
4103 elf_tdata (abfd)->core->signal
4104 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
4107 elf_tdata (abfd)->core->lwpid
4108 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
4112 /* Make a ".reg/999" section. */
4113 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
4114 note->descpos + PRSTATUS_OFFSET_PR_REG);
4118 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4120 switch (note->descsz)
4125 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
4127 elf_tdata (abfd)->core->pid
4128 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
4131 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
4132 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
4135 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
4136 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
4140 /* Note that for some reason, a spurious space is tacked
4141 onto the end of the args in some (at least one anyway)
4142 implementations, so strip it off if it exists. */
4145 char *command = elf_tdata (abfd)->core->command;
4146 int n = strlen (command);
4148 if (0 < n && command[n - 1] == ' ')
4149 command[n - 1] = '\0';
4155 /* Set the right mach type. */
4157 riscv_elf_object_p (bfd *abfd)
4159 /* There are only two mach types in RISCV currently. */
4160 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0)
4161 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32);
4163 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64);
4168 /* Determine whether an object attribute tag takes an integer, a
4172 riscv_elf_obj_attrs_arg_type (int tag)
4174 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
4177 #define TARGET_LITTLE_SYM riscv_elfNN_vec
4178 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
4180 #define elf_backend_reloc_type_class riscv_reloc_type_class
4182 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
4183 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
4184 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
4185 #define bfd_elfNN_bfd_merge_private_bfd_data \
4186 _bfd_riscv_elf_merge_private_bfd_data
4188 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
4189 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
4190 #define elf_backend_check_relocs riscv_elf_check_relocs
4191 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
4192 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
4193 #define elf_backend_relocate_section riscv_elf_relocate_section
4194 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
4195 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
4196 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
4197 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
4198 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
4199 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
4200 #define elf_backend_object_p riscv_elf_object_p
4201 #define elf_info_to_howto_rel NULL
4202 #define elf_info_to_howto riscv_info_to_howto_rela
4203 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
4205 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
4207 #define elf_backend_can_gc_sections 1
4208 #define elf_backend_can_refcount 1
4209 #define elf_backend_want_got_plt 1
4210 #define elf_backend_plt_readonly 1
4211 #define elf_backend_plt_alignment 4
4212 #define elf_backend_want_plt_sym 1
4213 #define elf_backend_got_header_size (ARCH_SIZE / 8)
4214 #define elf_backend_want_dynrelro 1
4215 #define elf_backend_rela_normal 1
4216 #define elf_backend_default_execstack 0
4218 #undef elf_backend_obj_attrs_vendor
4219 #define elf_backend_obj_attrs_vendor "riscv"
4220 #undef elf_backend_obj_attrs_arg_type
4221 #define elf_backend_obj_attrs_arg_type riscv_elf_obj_attrs_arg_type
4222 #undef elf_backend_obj_attrs_section_type
4223 #define elf_backend_obj_attrs_section_type SHT_RISCV_ATTRIBUTES
4224 #undef elf_backend_obj_attrs_section
4225 #define elf_backend_obj_attrs_section ".riscv.attributes"
4227 #include "elfNN-target.h"