1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2017 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"
37 #define MINUS_ONE ((bfd_vma)0 - 1)
39 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
41 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
43 /* The name of the dynamic interpreter. This is put in the .interp
46 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
47 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
49 #define ELF_ARCH bfd_arch_riscv
50 #define ELF_TARGET_ID RISCV_ELF_DATA
51 #define ELF_MACHINE_CODE EM_RISCV
52 #define ELF_MAXPAGESIZE 0x1000
53 #define ELF_COMMONPAGESIZE 0x1000
55 /* The RISC-V linker needs to keep track of the number of relocs that it
56 decides to copy as dynamic relocs in check_relocs for each symbol.
57 This is so that it can later discard them if they are found to be
58 unnecessary. We store the information in a field extending the
59 regular ELF linker hash table. */
61 struct riscv_elf_dyn_relocs
63 struct riscv_elf_dyn_relocs *next;
65 /* The input section of the reloc. */
68 /* Total number of relocs copied for the input section. */
71 /* Number of pc-relative relocs copied for the input section. */
72 bfd_size_type pc_count;
75 /* RISC-V ELF linker hash entry. */
77 struct riscv_elf_link_hash_entry
79 struct elf_link_hash_entry elf;
81 /* Track dynamic relocs copied for this symbol. */
82 struct riscv_elf_dyn_relocs *dyn_relocs;
92 #define riscv_elf_hash_entry(ent) \
93 ((struct riscv_elf_link_hash_entry *)(ent))
95 struct _bfd_riscv_elf_obj_tdata
97 struct elf_obj_tdata root;
99 /* tls_type for each local got entry. */
100 char *local_got_tls_type;
103 #define _bfd_riscv_elf_tdata(abfd) \
104 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
106 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
107 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
109 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
110 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
111 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
113 #define is_riscv_elf(bfd) \
114 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
115 && elf_tdata (bfd) != NULL \
116 && elf_object_id (bfd) == RISCV_ELF_DATA)
118 #include "elf/common.h"
119 #include "elf/internal.h"
121 struct riscv_elf_link_hash_table
123 struct elf_link_hash_table elf;
125 /* Short-cuts to get to dynamic linker sections. */
128 /* Small local sym to section mapping cache. */
129 struct sym_cache sym_cache;
133 /* Get the RISC-V ELF linker hash table from a link_info structure. */
134 #define riscv_elf_hash_table(p) \
135 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
136 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
139 riscv_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
141 Elf_Internal_Rela *dst)
143 cache_ptr->howto = riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst->r_info));
147 riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
149 const struct elf_backend_data *bed;
152 bed = get_elf_backend_data (abfd);
153 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
154 bed->s->swap_reloca_out (abfd, rel, loc);
159 #define PLT_HEADER_INSNS 8
160 #define PLT_ENTRY_INSNS 4
161 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
162 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
164 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
166 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
168 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
171 riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info)
173 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt)
174 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE);
178 # define MATCH_LREG MATCH_LW
180 # define MATCH_LREG MATCH_LD
183 /* Generate a PLT header. */
186 riscv_make_plt_header (bfd_vma gotplt_addr, bfd_vma addr, uint32_t *entry)
188 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr);
189 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr);
191 /* auipc t2, %hi(.got.plt)
192 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
193 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
194 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
195 addi t0, t2, %lo(.got.plt) # &.got.plt
196 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
197 l[w|d] t0, PTRSIZE(t0) # link map
200 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high);
201 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3);
202 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low);
203 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, -(PLT_HEADER_SIZE + 12));
204 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low);
205 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES);
206 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES);
207 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0);
210 /* Generate a PLT entry. */
213 riscv_make_plt_entry (bfd_vma got, bfd_vma addr, uint32_t *entry)
215 /* auipc t3, %hi(.got.plt entry)
216 l[w|d] t3, %lo(.got.plt entry)(t3)
220 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr));
221 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr));
222 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0);
223 entry[3] = RISCV_NOP;
226 /* Create an entry in an RISC-V ELF linker hash table. */
228 static struct bfd_hash_entry *
229 link_hash_newfunc (struct bfd_hash_entry *entry,
230 struct bfd_hash_table *table, const char *string)
232 /* Allocate the structure if it has not already been allocated by a
237 bfd_hash_allocate (table,
238 sizeof (struct riscv_elf_link_hash_entry));
243 /* Call the allocation method of the superclass. */
244 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
247 struct riscv_elf_link_hash_entry *eh;
249 eh = (struct riscv_elf_link_hash_entry *) entry;
250 eh->dyn_relocs = NULL;
251 eh->tls_type = GOT_UNKNOWN;
257 /* Create a RISC-V ELF linker hash table. */
259 static struct bfd_link_hash_table *
260 riscv_elf_link_hash_table_create (bfd *abfd)
262 struct riscv_elf_link_hash_table *ret;
263 bfd_size_type amt = sizeof (struct riscv_elf_link_hash_table);
265 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt);
269 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
270 sizeof (struct riscv_elf_link_hash_entry),
277 return &ret->elf.root;
280 /* Create the .got section. */
283 riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
287 struct elf_link_hash_entry *h;
288 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
289 struct elf_link_hash_table *htab = elf_hash_table (info);
291 /* This function may be called more than once. */
292 if (htab->sgot != NULL)
295 flags = bed->dynamic_sec_flags;
297 s = bfd_make_section_anyway_with_flags (abfd,
298 (bed->rela_plts_and_copies_p
299 ? ".rela.got" : ".rel.got"),
300 (bed->dynamic_sec_flags
303 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
307 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
309 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
313 /* The first bit of the global offset table is the header. */
314 s->size += bed->got_header_size;
316 if (bed->want_got_plt)
318 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
320 || !bfd_set_section_alignment (abfd, s,
321 bed->s->log_file_align))
325 /* Reserve room for the header. */
326 s->size += GOTPLT_HEADER_SIZE;
329 if (bed->want_got_sym)
331 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
332 section. We don't do this in the linker script because we don't want
333 to define the symbol if we are not creating a global offset
335 h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
336 "_GLOBAL_OFFSET_TABLE_");
337 elf_hash_table (info)->hgot = h;
345 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
346 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
350 riscv_elf_create_dynamic_sections (bfd *dynobj,
351 struct bfd_link_info *info)
353 struct riscv_elf_link_hash_table *htab;
355 htab = riscv_elf_hash_table (info);
356 BFD_ASSERT (htab != NULL);
358 if (!riscv_elf_create_got_section (dynobj, info))
361 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
364 if (!bfd_link_pic (info))
367 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",
368 SEC_ALLOC | SEC_THREAD_LOCAL);
371 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss
372 || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata)))
378 /* Copy the extra info we tack onto an elf_link_hash_entry. */
381 riscv_elf_copy_indirect_symbol (struct bfd_link_info *info,
382 struct elf_link_hash_entry *dir,
383 struct elf_link_hash_entry *ind)
385 struct riscv_elf_link_hash_entry *edir, *eind;
387 edir = (struct riscv_elf_link_hash_entry *) dir;
388 eind = (struct riscv_elf_link_hash_entry *) ind;
390 if (eind->dyn_relocs != NULL)
392 if (edir->dyn_relocs != NULL)
394 struct riscv_elf_dyn_relocs **pp;
395 struct riscv_elf_dyn_relocs *p;
397 /* Add reloc counts against the indirect sym to the direct sym
398 list. Merge any entries against the same section. */
399 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
401 struct riscv_elf_dyn_relocs *q;
403 for (q = edir->dyn_relocs; q != NULL; q = q->next)
404 if (q->sec == p->sec)
406 q->pc_count += p->pc_count;
407 q->count += p->count;
414 *pp = edir->dyn_relocs;
417 edir->dyn_relocs = eind->dyn_relocs;
418 eind->dyn_relocs = NULL;
421 if (ind->root.type == bfd_link_hash_indirect
422 && dir->got.refcount <= 0)
424 edir->tls_type = eind->tls_type;
425 eind->tls_type = GOT_UNKNOWN;
427 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
431 riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h,
432 unsigned long symndx, char tls_type)
434 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx);
436 *new_tls_type |= tls_type;
437 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))
439 (*_bfd_error_handler)
440 (_("%B: `%s' accessed both as normal and thread local symbol"),
441 abfd, h ? h->root.root.string : "<local>");
448 riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info,
449 struct elf_link_hash_entry *h, long symndx)
451 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
452 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
454 if (htab->elf.sgot == NULL)
456 if (!riscv_elf_create_got_section (htab->elf.dynobj, info))
462 h->got.refcount += 1;
466 /* This is a global offset table entry for a local symbol. */
467 if (elf_local_got_refcounts (abfd) == NULL)
469 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1);
470 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size)))
472 _bfd_riscv_elf_local_got_tls_type (abfd)
473 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info);
475 elf_local_got_refcounts (abfd) [symndx] += 1;
481 bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h)
483 (*_bfd_error_handler)
484 (_("%B: relocation %s against `%s' can not be used when making a shared "
485 "object; recompile with -fPIC"),
486 abfd, riscv_elf_rtype_to_howto (r_type)->name,
487 h != NULL ? h->root.root.string : "a local symbol");
488 bfd_set_error (bfd_error_bad_value);
491 /* Look through the relocs for a section during the first phase, and
492 allocate space in the global offset table or procedure linkage
496 riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
497 asection *sec, const Elf_Internal_Rela *relocs)
499 struct riscv_elf_link_hash_table *htab;
500 Elf_Internal_Shdr *symtab_hdr;
501 struct elf_link_hash_entry **sym_hashes;
502 const Elf_Internal_Rela *rel;
503 asection *sreloc = NULL;
505 if (bfd_link_relocatable (info))
508 htab = riscv_elf_hash_table (info);
509 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
510 sym_hashes = elf_sym_hashes (abfd);
512 if (htab->elf.dynobj == NULL)
513 htab->elf.dynobj = abfd;
515 for (rel = relocs; rel < relocs + sec->reloc_count; rel++)
518 unsigned int r_symndx;
519 struct elf_link_hash_entry *h;
521 r_symndx = ELFNN_R_SYM (rel->r_info);
522 r_type = ELFNN_R_TYPE (rel->r_info);
524 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
526 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
531 if (r_symndx < symtab_hdr->sh_info)
535 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
536 while (h->root.type == bfd_link_hash_indirect
537 || h->root.type == bfd_link_hash_warning)
538 h = (struct elf_link_hash_entry *) h->root.u.i.link;
540 /* PR15323, ref flags aren't set for references in the same
542 h->root.non_ir_ref_regular = 1;
547 case R_RISCV_TLS_GD_HI20:
548 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
549 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD))
553 case R_RISCV_TLS_GOT_HI20:
554 if (bfd_link_pic (info))
555 info->flags |= DF_STATIC_TLS;
556 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
557 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE))
561 case R_RISCV_GOT_HI20:
562 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
563 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL))
567 case R_RISCV_CALL_PLT:
568 /* This symbol requires a procedure linkage table entry. We
569 actually build the entry in adjust_dynamic_symbol,
570 because this might be a case of linking PIC code without
571 linking in any dynamic objects, in which case we don't
572 need to generate a procedure linkage table after all. */
577 h->plt.refcount += 1;
584 case R_RISCV_RVC_BRANCH:
585 case R_RISCV_RVC_JUMP:
586 case R_RISCV_PCREL_HI20:
587 /* In shared libraries, these relocs are known to bind locally. */
588 if (bfd_link_pic (info))
592 case R_RISCV_TPREL_HI20:
593 if (!bfd_link_executable (info))
594 return bad_static_reloc (abfd, r_type, h);
596 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE);
600 if (bfd_link_pic (info))
601 return bad_static_reloc (abfd, r_type, h);
605 case R_RISCV_JUMP_SLOT:
606 case R_RISCV_RELATIVE:
612 /* This reloc might not bind locally. */
616 if (h != NULL && !bfd_link_pic (info))
618 /* We may need a .plt entry if the function this reloc
619 refers to is in a shared lib. */
620 h->plt.refcount += 1;
623 /* If we are creating a shared library, and this is a reloc
624 against a global symbol, or a non PC relative reloc
625 against a local symbol, then we need to copy the reloc
626 into the shared library. However, if we are linking with
627 -Bsymbolic, we do not need to copy a reloc against a
628 global symbol which is defined in an object we are
629 including in the link (i.e., DEF_REGULAR is set). At
630 this point we have not seen all the input files, so it is
631 possible that DEF_REGULAR is not set now but will be set
632 later (it is never cleared). In case of a weak definition,
633 DEF_REGULAR may be cleared later by a strong definition in
634 a shared library. We account for that possibility below by
635 storing information in the relocs_copied field of the hash
636 table entry. A similar situation occurs when creating
637 shared libraries and symbol visibility changes render the
640 If on the other hand, we are creating an executable, we
641 may need to keep relocations for symbols satisfied by a
642 dynamic library if we manage to avoid copy relocs for the
644 if ((bfd_link_pic (info)
645 && (sec->flags & SEC_ALLOC) != 0
646 && (! riscv_elf_rtype_to_howto (r_type)->pc_relative
649 || h->root.type == bfd_link_hash_defweak
650 || !h->def_regular))))
651 || (!bfd_link_pic (info)
652 && (sec->flags & SEC_ALLOC) != 0
654 && (h->root.type == bfd_link_hash_defweak
655 || !h->def_regular)))
657 struct riscv_elf_dyn_relocs *p;
658 struct riscv_elf_dyn_relocs **head;
660 /* When creating a shared object, we must copy these
661 relocs into the output file. We create a reloc
662 section in dynobj and make room for the reloc. */
665 sreloc = _bfd_elf_make_dynamic_reloc_section
666 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES,
667 abfd, /*rela?*/ TRUE);
673 /* If this is a global symbol, we count the number of
674 relocations we need for this symbol. */
676 head = &((struct riscv_elf_link_hash_entry *) h)->dyn_relocs;
679 /* Track dynamic relocs needed for local syms too.
680 We really need local syms available to do this
685 Elf_Internal_Sym *isym;
687 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
692 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
696 vpp = &elf_section_data (s)->local_dynrel;
697 head = (struct riscv_elf_dyn_relocs **) vpp;
701 if (p == NULL || p->sec != sec)
703 bfd_size_type amt = sizeof *p;
704 p = ((struct riscv_elf_dyn_relocs *)
705 bfd_alloc (htab->elf.dynobj, amt));
716 p->pc_count += riscv_elf_rtype_to_howto (r_type)->pc_relative;
721 case R_RISCV_GNU_VTINHERIT:
722 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
726 case R_RISCV_GNU_VTENTRY:
727 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
740 riscv_elf_gc_mark_hook (asection *sec,
741 struct bfd_link_info *info,
742 Elf_Internal_Rela *rel,
743 struct elf_link_hash_entry *h,
744 Elf_Internal_Sym *sym)
747 switch (ELFNN_R_TYPE (rel->r_info))
749 case R_RISCV_GNU_VTINHERIT:
750 case R_RISCV_GNU_VTENTRY:
754 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
757 /* Update the got entry reference counts for the section being removed. */
760 riscv_elf_gc_sweep_hook (bfd *abfd,
761 struct bfd_link_info *info,
763 const Elf_Internal_Rela *relocs)
765 const Elf_Internal_Rela *rel, *relend;
766 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
767 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
768 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
770 if (bfd_link_relocatable (info))
773 elf_section_data (sec)->local_dynrel = NULL;
775 for (rel = relocs, relend = relocs + sec->reloc_count; rel < relend; rel++)
777 unsigned long r_symndx;
778 struct elf_link_hash_entry *h = NULL;
780 r_symndx = ELFNN_R_SYM (rel->r_info);
781 if (r_symndx >= symtab_hdr->sh_info)
783 struct riscv_elf_link_hash_entry *eh;
784 struct riscv_elf_dyn_relocs **pp;
785 struct riscv_elf_dyn_relocs *p;
787 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
788 while (h->root.type == bfd_link_hash_indirect
789 || h->root.type == bfd_link_hash_warning)
790 h = (struct elf_link_hash_entry *) h->root.u.i.link;
791 eh = (struct riscv_elf_link_hash_entry *) h;
792 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
795 /* Everything must go for SEC. */
801 switch (ELFNN_R_TYPE (rel->r_info))
803 case R_RISCV_GOT_HI20:
804 case R_RISCV_TLS_GOT_HI20:
805 case R_RISCV_TLS_GD_HI20:
808 if (h->got.refcount > 0)
813 if (local_got_refcounts &&
814 local_got_refcounts[r_symndx] > 0)
815 local_got_refcounts[r_symndx]--;
820 case R_RISCV_PCREL_HI20:
822 case R_RISCV_JUMP_SLOT:
823 case R_RISCV_RELATIVE:
829 case R_RISCV_RVC_BRANCH:
830 case R_RISCV_RVC_JUMP:
831 if (bfd_link_pic (info))
835 case R_RISCV_CALL_PLT:
838 if (h->plt.refcount > 0)
851 /* Adjust a symbol defined by a dynamic object and referenced by a
852 regular object. The current definition is in some section of the
853 dynamic object, but we're not including those sections. We have to
854 change the definition to something the rest of the link can
858 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
859 struct elf_link_hash_entry *h)
861 struct riscv_elf_link_hash_table *htab;
862 struct riscv_elf_link_hash_entry * eh;
863 struct riscv_elf_dyn_relocs *p;
867 htab = riscv_elf_hash_table (info);
868 BFD_ASSERT (htab != NULL);
870 dynobj = htab->elf.dynobj;
872 /* Make sure we know what is going on here. */
873 BFD_ASSERT (dynobj != NULL
875 || h->type == STT_GNU_IFUNC
876 || h->u.weakdef != NULL
879 && !h->def_regular)));
881 /* If this is a function, put it in the procedure linkage table. We
882 will fill in the contents of the procedure linkage table later
883 (although we could actually do it here). */
884 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
886 if (h->plt.refcount <= 0
887 || SYMBOL_CALLS_LOCAL (info, h)
888 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
889 && h->root.type == bfd_link_hash_undefweak))
891 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
892 input file, but the symbol was never referred to by a dynamic
893 object, or if all references were garbage collected. In such
894 a case, we don't actually need to build a PLT entry. */
895 h->plt.offset = (bfd_vma) -1;
902 h->plt.offset = (bfd_vma) -1;
904 /* If this is a weak symbol, and there is a real definition, the
905 processor independent code will have arranged for us to see the
906 real definition first, and we can just use the same value. */
907 if (h->u.weakdef != NULL)
909 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
910 || h->u.weakdef->root.type == bfd_link_hash_defweak);
911 h->root.u.def.section = h->u.weakdef->root.u.def.section;
912 h->root.u.def.value = h->u.weakdef->root.u.def.value;
916 /* This is a reference to a symbol defined by a dynamic object which
917 is not a function. */
919 /* If we are creating a shared library, we must presume that the
920 only references to the symbol are via the global offset table.
921 For such cases we need not do anything here; the relocations will
922 be handled correctly by relocate_section. */
923 if (bfd_link_pic (info))
926 /* If there are no references to this symbol that do not use the
927 GOT, we don't need to generate a copy reloc. */
931 /* If -z nocopyreloc was given, we won't generate them either. */
932 if (info->nocopyreloc)
938 eh = (struct riscv_elf_link_hash_entry *) h;
939 for (p = eh->dyn_relocs; p != NULL; p = p->next)
941 s = p->sec->output_section;
942 if (s != NULL && (s->flags & SEC_READONLY) != 0)
946 /* If we didn't find any dynamic relocs in read-only sections, then
947 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
954 /* We must allocate the symbol in our .dynbss section, which will
955 become part of the .bss section of the executable. There will be
956 an entry for this symbol in the .dynsym section. The dynamic
957 object will contain position independent code, so all references
958 from the dynamic object to this symbol will go through the global
959 offset table. The dynamic linker will use the .dynsym entry to
960 determine the address it must put in the global offset table, so
961 both the dynamic object and the regular object will refer to the
962 same memory location for the variable. */
964 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
965 to copy the initial value out of the dynamic object and into the
966 runtime process image. We need to remember the offset into the
967 .rel.bss section we are going to use. */
968 if (eh->tls_type & ~GOT_NORMAL)
971 srel = htab->elf.srelbss;
973 else if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
975 s = htab->elf.sdynrelro;
976 srel = htab->elf.sreldynrelro;
980 s = htab->elf.sdynbss;
981 srel = htab->elf.srelbss;
983 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
985 srel->size += sizeof (ElfNN_External_Rela);
989 return _bfd_elf_adjust_dynamic_copy (info, h, s);
992 /* Allocate space in .plt, .got and associated reloc sections for
996 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
998 struct bfd_link_info *info;
999 struct riscv_elf_link_hash_table *htab;
1000 struct riscv_elf_link_hash_entry *eh;
1001 struct riscv_elf_dyn_relocs *p;
1003 if (h->root.type == bfd_link_hash_indirect)
1006 info = (struct bfd_link_info *) inf;
1007 htab = riscv_elf_hash_table (info);
1008 BFD_ASSERT (htab != NULL);
1010 if (htab->elf.dynamic_sections_created
1011 && h->plt.refcount > 0)
1013 /* Make sure this symbol is output as a dynamic symbol.
1014 Undefined weak syms won't yet be marked as dynamic. */
1015 if (h->dynindx == -1
1016 && !h->forced_local)
1018 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1022 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1024 asection *s = htab->elf.splt;
1027 s->size = PLT_HEADER_SIZE;
1029 h->plt.offset = s->size;
1031 /* Make room for this entry. */
1032 s->size += PLT_ENTRY_SIZE;
1034 /* We also need to make an entry in the .got.plt section. */
1035 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1037 /* We also need to make an entry in the .rela.plt section. */
1038 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
1040 /* If this symbol is not defined in a regular file, and we are
1041 not generating a shared library, then set the symbol to this
1042 location in the .plt. This is required to make function
1043 pointers compare as equal between the normal executable and
1044 the shared library. */
1045 if (! bfd_link_pic (info)
1048 h->root.u.def.section = s;
1049 h->root.u.def.value = h->plt.offset;
1054 h->plt.offset = (bfd_vma) -1;
1060 h->plt.offset = (bfd_vma) -1;
1064 if (h->got.refcount > 0)
1068 int tls_type = riscv_elf_hash_entry (h)->tls_type;
1070 /* Make sure this symbol is output as a dynamic symbol.
1071 Undefined weak syms won't yet be marked as dynamic. */
1072 if (h->dynindx == -1
1073 && !h->forced_local)
1075 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1080 h->got.offset = s->size;
1081 dyn = htab->elf.dynamic_sections_created;
1082 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
1084 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1085 if (tls_type & GOT_TLS_GD)
1087 s->size += 2 * RISCV_ELF_WORD_BYTES;
1088 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1091 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1092 if (tls_type & GOT_TLS_IE)
1094 s->size += RISCV_ELF_WORD_BYTES;
1095 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1100 s->size += RISCV_ELF_WORD_BYTES;
1101 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1102 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1106 h->got.offset = (bfd_vma) -1;
1108 eh = (struct riscv_elf_link_hash_entry *) h;
1109 if (eh->dyn_relocs == NULL)
1112 /* In the shared -Bsymbolic case, discard space allocated for
1113 dynamic pc-relative relocs against symbols which turn out to be
1114 defined in regular objects. For the normal shared case, discard
1115 space for pc-relative relocs that have become local due to symbol
1116 visibility changes. */
1118 if (bfd_link_pic (info))
1120 if (SYMBOL_CALLS_LOCAL (info, h))
1122 struct riscv_elf_dyn_relocs **pp;
1124 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1126 p->count -= p->pc_count;
1135 /* Also discard relocs on undefined weak syms with non-default
1137 if (eh->dyn_relocs != NULL
1138 && h->root.type == bfd_link_hash_undefweak)
1140 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1141 eh->dyn_relocs = NULL;
1143 /* Make sure undefined weak symbols are output as a dynamic
1145 else if (h->dynindx == -1
1146 && !h->forced_local)
1148 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1155 /* For the non-shared case, discard space for relocs against
1156 symbols which turn out to need copy relocs or are not
1162 || (htab->elf.dynamic_sections_created
1163 && (h->root.type == bfd_link_hash_undefweak
1164 || h->root.type == bfd_link_hash_undefined))))
1166 /* Make sure this symbol is output as a dynamic symbol.
1167 Undefined weak syms won't yet be marked as dynamic. */
1168 if (h->dynindx == -1
1169 && !h->forced_local)
1171 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1175 /* If that succeeded, we know we'll be keeping all the
1177 if (h->dynindx != -1)
1181 eh->dyn_relocs = NULL;
1186 /* Finally, allocate space. */
1187 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1189 asection *sreloc = elf_section_data (p->sec)->sreloc;
1190 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1196 /* Find any dynamic relocs that apply to read-only sections. */
1199 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1201 struct riscv_elf_link_hash_entry *eh;
1202 struct riscv_elf_dyn_relocs *p;
1204 eh = (struct riscv_elf_link_hash_entry *) h;
1205 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1207 asection *s = p->sec->output_section;
1209 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1211 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL;
1219 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1221 struct riscv_elf_link_hash_table *htab;
1226 htab = riscv_elf_hash_table (info);
1227 BFD_ASSERT (htab != NULL);
1228 dynobj = htab->elf.dynobj;
1229 BFD_ASSERT (dynobj != NULL);
1231 if (elf_hash_table (info)->dynamic_sections_created)
1233 /* Set the contents of the .interp section to the interpreter. */
1234 if (bfd_link_executable (info) && !info->nointerp)
1236 s = bfd_get_linker_section (dynobj, ".interp");
1237 BFD_ASSERT (s != NULL);
1238 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1239 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1243 /* Set up .got offsets for local syms, and space for local dynamic
1245 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1247 bfd_signed_vma *local_got;
1248 bfd_signed_vma *end_local_got;
1249 char *local_tls_type;
1250 bfd_size_type locsymcount;
1251 Elf_Internal_Shdr *symtab_hdr;
1254 if (! is_riscv_elf (ibfd))
1257 for (s = ibfd->sections; s != NULL; s = s->next)
1259 struct riscv_elf_dyn_relocs *p;
1261 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1263 if (!bfd_is_abs_section (p->sec)
1264 && bfd_is_abs_section (p->sec->output_section))
1266 /* Input section has been discarded, either because
1267 it is a copy of a linkonce section or due to
1268 linker script /DISCARD/, so we'll be discarding
1271 else if (p->count != 0)
1273 srel = elf_section_data (p->sec)->sreloc;
1274 srel->size += p->count * sizeof (ElfNN_External_Rela);
1275 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1276 info->flags |= DF_TEXTREL;
1281 local_got = elf_local_got_refcounts (ibfd);
1285 symtab_hdr = &elf_symtab_hdr (ibfd);
1286 locsymcount = symtab_hdr->sh_info;
1287 end_local_got = local_got + locsymcount;
1288 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1290 srel = htab->elf.srelgot;
1291 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1295 *local_got = s->size;
1296 s->size += RISCV_ELF_WORD_BYTES;
1297 if (*local_tls_type & GOT_TLS_GD)
1298 s->size += RISCV_ELF_WORD_BYTES;
1299 if (bfd_link_pic (info)
1300 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1301 srel->size += sizeof (ElfNN_External_Rela);
1304 *local_got = (bfd_vma) -1;
1308 /* Allocate global sym .plt and .got entries, and space for global
1309 sym dynamic relocs. */
1310 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1312 if (htab->elf.sgotplt)
1314 struct elf_link_hash_entry *got;
1315 got = elf_link_hash_lookup (elf_hash_table (info),
1316 "_GLOBAL_OFFSET_TABLE_",
1317 FALSE, FALSE, FALSE);
1319 /* Don't allocate .got.plt section if there are no GOT nor PLT
1320 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1322 || !got->ref_regular_nonweak)
1323 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1324 && (htab->elf.splt == NULL
1325 || htab->elf.splt->size == 0)
1326 && (htab->elf.sgot == NULL
1327 || (htab->elf.sgot->size
1328 == get_elf_backend_data (output_bfd)->got_header_size)))
1329 htab->elf.sgotplt->size = 0;
1332 /* The check_relocs and adjust_dynamic_symbol entry points have
1333 determined the sizes of the various dynamic sections. Allocate
1335 for (s = dynobj->sections; s != NULL; s = s->next)
1337 if ((s->flags & SEC_LINKER_CREATED) == 0)
1340 if (s == htab->elf.splt
1341 || s == htab->elf.sgot
1342 || s == htab->elf.sgotplt
1343 || s == htab->elf.sdynbss
1344 || s == htab->elf.sdynrelro)
1346 /* Strip this section if we don't need it; see the
1349 else if (strncmp (s->name, ".rela", 5) == 0)
1353 /* We use the reloc_count field as a counter if we need
1354 to copy relocs into the output file. */
1360 /* It's not one of our sections. */
1366 /* If we don't need this section, strip it from the
1367 output file. This is mostly to handle .rela.bss and
1368 .rela.plt. We must create both sections in
1369 create_dynamic_sections, because they must be created
1370 before the linker maps input sections to output
1371 sections. The linker does that before
1372 adjust_dynamic_symbol is called, and it is that
1373 function which decides whether anything needs to go
1374 into these sections. */
1375 s->flags |= SEC_EXCLUDE;
1379 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1382 /* Allocate memory for the section contents. Zero the memory
1383 for the benefit of .rela.plt, which has 4 unused entries
1384 at the beginning, and we don't want garbage. */
1385 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1386 if (s->contents == NULL)
1390 if (elf_hash_table (info)->dynamic_sections_created)
1392 /* Add some entries to the .dynamic section. We fill in the
1393 values later, in riscv_elf_finish_dynamic_sections, but we
1394 must add the entries now so that we get the correct size for
1395 the .dynamic section. The DT_DEBUG entry is filled in by the
1396 dynamic linker and used by the debugger. */
1397 #define add_dynamic_entry(TAG, VAL) \
1398 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1400 if (bfd_link_executable (info))
1402 if (!add_dynamic_entry (DT_DEBUG, 0))
1406 if (htab->elf.srelplt->size != 0)
1408 if (!add_dynamic_entry (DT_PLTGOT, 0)
1409 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1410 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1411 || !add_dynamic_entry (DT_JMPREL, 0))
1415 if (!add_dynamic_entry (DT_RELA, 0)
1416 || !add_dynamic_entry (DT_RELASZ, 0)
1417 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1420 /* If any dynamic relocs apply to a read-only section,
1421 then we need a DT_TEXTREL entry. */
1422 if ((info->flags & DF_TEXTREL) == 0)
1423 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
1425 if (info->flags & DF_TEXTREL)
1427 if (!add_dynamic_entry (DT_TEXTREL, 0))
1431 #undef add_dynamic_entry
1437 #define DTP_OFFSET 0x800
1439 /* Return the relocation value for a TLS dtp-relative reloc. */
1442 dtpoff (struct bfd_link_info *info, bfd_vma address)
1444 /* If tls_sec is NULL, we should have signalled an error already. */
1445 if (elf_hash_table (info)->tls_sec == NULL)
1447 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1450 /* Return the relocation value for a static TLS tp-relative relocation. */
1453 tpoff (struct bfd_link_info *info, bfd_vma address)
1455 /* If tls_sec is NULL, we should have signalled an error already. */
1456 if (elf_hash_table (info)->tls_sec == NULL)
1458 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1461 /* Return the global pointer's value, or 0 if it is not in use. */
1464 riscv_global_pointer_value (struct bfd_link_info *info)
1466 struct bfd_link_hash_entry *h;
1468 h = bfd_link_hash_lookup (info->hash, RISCV_GP_SYMBOL, FALSE, FALSE, TRUE);
1469 if (h == NULL || h->type != bfd_link_hash_defined)
1472 return h->u.def.value + sec_addr (h->u.def.section);
1475 /* Emplace a static relocation. */
1477 static bfd_reloc_status_type
1478 perform_relocation (const reloc_howto_type *howto,
1479 const Elf_Internal_Rela *rel,
1481 asection *input_section,
1485 if (howto->pc_relative)
1486 value -= sec_addr (input_section) + rel->r_offset;
1487 value += rel->r_addend;
1489 switch (ELFNN_R_TYPE (rel->r_info))
1492 case R_RISCV_TPREL_HI20:
1493 case R_RISCV_PCREL_HI20:
1494 case R_RISCV_GOT_HI20:
1495 case R_RISCV_TLS_GOT_HI20:
1496 case R_RISCV_TLS_GD_HI20:
1497 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1498 return bfd_reloc_overflow;
1499 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1502 case R_RISCV_LO12_I:
1503 case R_RISCV_GPREL_I:
1504 case R_RISCV_TPREL_LO12_I:
1505 case R_RISCV_TPREL_I:
1506 case R_RISCV_PCREL_LO12_I:
1507 value = ENCODE_ITYPE_IMM (value);
1510 case R_RISCV_LO12_S:
1511 case R_RISCV_GPREL_S:
1512 case R_RISCV_TPREL_LO12_S:
1513 case R_RISCV_TPREL_S:
1514 case R_RISCV_PCREL_LO12_S:
1515 value = ENCODE_STYPE_IMM (value);
1519 case R_RISCV_CALL_PLT:
1520 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1521 return bfd_reloc_overflow;
1522 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1523 | (ENCODE_ITYPE_IMM (value) << 32);
1527 if (!VALID_UJTYPE_IMM (value))
1528 return bfd_reloc_overflow;
1529 value = ENCODE_UJTYPE_IMM (value);
1532 case R_RISCV_BRANCH:
1533 if (!VALID_SBTYPE_IMM (value))
1534 return bfd_reloc_overflow;
1535 value = ENCODE_SBTYPE_IMM (value);
1538 case R_RISCV_RVC_BRANCH:
1539 if (!VALID_RVC_B_IMM (value))
1540 return bfd_reloc_overflow;
1541 value = ENCODE_RVC_B_IMM (value);
1544 case R_RISCV_RVC_JUMP:
1545 if (!VALID_RVC_J_IMM (value))
1546 return bfd_reloc_overflow;
1547 value = ENCODE_RVC_J_IMM (value);
1550 case R_RISCV_RVC_LUI:
1551 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1552 return bfd_reloc_overflow;
1553 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1571 case R_RISCV_32_PCREL:
1572 case R_RISCV_TLS_DTPREL32:
1573 case R_RISCV_TLS_DTPREL64:
1577 return bfd_reloc_notsupported;
1580 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1581 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1582 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1584 return bfd_reloc_ok;
1587 /* Remember all PC-relative high-part relocs we've encountered to help us
1588 later resolve the corresponding low-part relocs. */
1594 } riscv_pcrel_hi_reloc;
1596 typedef struct riscv_pcrel_lo_reloc
1598 asection * input_section;
1599 struct bfd_link_info * info;
1600 reloc_howto_type * howto;
1601 const Elf_Internal_Rela * reloc;
1604 bfd_byte * contents;
1605 struct riscv_pcrel_lo_reloc * next;
1606 } riscv_pcrel_lo_reloc;
1611 riscv_pcrel_lo_reloc *lo_relocs;
1612 } riscv_pcrel_relocs;
1615 riscv_pcrel_reloc_hash (const void *entry)
1617 const riscv_pcrel_hi_reloc *e = entry;
1618 return (hashval_t)(e->address >> 2);
1622 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1624 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1625 return e1->address == e2->address;
1629 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1632 p->lo_relocs = NULL;
1633 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1634 riscv_pcrel_reloc_eq, free);
1635 return p->hi_relocs != NULL;
1639 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1641 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1645 riscv_pcrel_lo_reloc *next = cur->next;
1650 htab_delete (p->hi_relocs);
1654 riscv_zero_pcrel_hi_reloc (Elf_Internal_Rela *rel,
1655 struct bfd_link_info *info,
1659 const reloc_howto_type *howto,
1662 /* We may need to reference low addreses in PC-relative modes even when the
1663 * PC is far away from these addresses. For example, undefweak references
1664 * need to produce the address 0 when linked. As 0 is far from the arbitrary
1665 * addresses that we can link PC-relative programs at, the linker can't
1666 * actually relocate references to those symbols. In order to allow these
1667 * programs to work we simply convert the PC-relative auipc sequences to
1668 * 0-relative lui sequences. */
1669 if (bfd_link_pic (info))
1672 /* If it's possible to reference the symbol using auipc we do so, as that's
1673 * more in the spirit of the PC-relative relocations we're processing. */
1674 bfd_vma offset = addr - pc;
1675 if (ARCH_SIZE == 32 || VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (offset)))
1678 /* If it's impossible to reference this with a LUI-based offset then don't
1679 * bother to convert it at all so users still see the PC-relative relocation
1680 * in the truncation message. */
1681 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (addr)))
1684 rel->r_info = ELFNN_R_INFO(addr, R_RISCV_HI20);
1686 bfd_vma insn = bfd_get(howto->bitsize, input_bfd, contents + rel->r_offset);
1687 insn = (insn & ~MASK_AUIPC) | MATCH_LUI;
1688 bfd_put(howto->bitsize, input_bfd, insn, contents + rel->r_offset);
1693 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr,
1694 bfd_vma value, bfd_boolean absolute)
1696 bfd_vma offset = absolute ? value : value - addr;
1697 riscv_pcrel_hi_reloc entry = {addr, offset};
1698 riscv_pcrel_hi_reloc **slot =
1699 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1701 BFD_ASSERT (*slot == NULL);
1702 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1710 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1711 asection *input_section,
1712 struct bfd_link_info *info,
1713 reloc_howto_type *howto,
1714 const Elf_Internal_Rela *reloc,
1719 riscv_pcrel_lo_reloc *entry;
1720 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1723 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1724 name, contents, p->lo_relocs};
1725 p->lo_relocs = entry;
1730 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1732 riscv_pcrel_lo_reloc *r;
1734 for (r = p->lo_relocs; r != NULL; r = r->next)
1736 bfd *input_bfd = r->input_section->owner;
1738 riscv_pcrel_hi_reloc search = {r->addr, 0};
1739 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1742 ((*r->info->callbacks->reloc_overflow)
1743 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0,
1744 input_bfd, r->input_section, r->reloc->r_offset));
1748 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1749 input_bfd, r->contents);
1755 /* Relocate a RISC-V ELF section.
1757 The RELOCATE_SECTION function is called by the new ELF backend linker
1758 to handle the relocations for a section.
1760 The relocs are always passed as Rela structures.
1762 This function is responsible for adjusting the section contents as
1763 necessary, and (if generating a relocatable output file) adjusting
1764 the reloc addend as necessary.
1766 This function does not have to worry about setting the reloc
1767 address or the reloc symbol index.
1769 LOCAL_SYMS is a pointer to the swapped in local symbols.
1771 LOCAL_SECTIONS is an array giving the section in the input file
1772 corresponding to the st_shndx field of each local symbol.
1774 The global hash table entry for the global symbols can be found
1775 via elf_sym_hashes (input_bfd).
1777 When generating relocatable output, this function must handle
1778 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1779 going to be the section symbol corresponding to the output
1780 section, which means that the addend must be adjusted
1784 riscv_elf_relocate_section (bfd *output_bfd,
1785 struct bfd_link_info *info,
1787 asection *input_section,
1789 Elf_Internal_Rela *relocs,
1790 Elf_Internal_Sym *local_syms,
1791 asection **local_sections)
1793 Elf_Internal_Rela *rel;
1794 Elf_Internal_Rela *relend;
1795 riscv_pcrel_relocs pcrel_relocs;
1796 bfd_boolean ret = FALSE;
1797 asection *sreloc = elf_section_data (input_section)->sreloc;
1798 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1799 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1800 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1801 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1802 bfd_boolean absolute;
1804 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1807 relend = relocs + input_section->reloc_count;
1808 for (rel = relocs; rel < relend; rel++)
1810 unsigned long r_symndx;
1811 struct elf_link_hash_entry *h;
1812 Elf_Internal_Sym *sym;
1815 bfd_reloc_status_type r = bfd_reloc_ok;
1817 bfd_vma off, ie_off;
1818 bfd_boolean unresolved_reloc, is_ie = FALSE;
1819 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1820 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1821 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type);
1822 const char *msg = NULL;
1824 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1827 /* This is a final link. */
1828 r_symndx = ELFNN_R_SYM (rel->r_info);
1832 unresolved_reloc = FALSE;
1833 if (r_symndx < symtab_hdr->sh_info)
1835 sym = local_syms + r_symndx;
1836 sec = local_sections[r_symndx];
1837 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1841 bfd_boolean warned, ignored;
1843 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1844 r_symndx, symtab_hdr, sym_hashes,
1846 unresolved_reloc, warned, ignored);
1849 /* To avoid generating warning messages about truncated
1850 relocations, set the relocation's address to be the same as
1851 the start of this section. */
1852 if (input_section->output_section != NULL)
1853 relocation = input_section->output_section->vma;
1859 if (sec != NULL && discarded_section (sec))
1860 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1861 rel, 1, relend, howto, 0, contents);
1863 if (bfd_link_relocatable (info))
1867 name = h->root.root.string;
1870 name = (bfd_elf_string_from_elf_section
1871 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1872 if (name == NULL || *name == '\0')
1873 name = bfd_section_name (input_bfd, sec);
1880 case R_RISCV_TPREL_ADD:
1882 case R_RISCV_JUMP_SLOT:
1883 case R_RISCV_RELATIVE:
1884 /* These require nothing of us at all. */
1888 case R_RISCV_BRANCH:
1889 case R_RISCV_RVC_BRANCH:
1890 case R_RISCV_RVC_LUI:
1891 case R_RISCV_LO12_I:
1892 case R_RISCV_LO12_S:
1897 case R_RISCV_32_PCREL:
1898 /* These require no special handling beyond perform_relocation. */
1901 case R_RISCV_GOT_HI20:
1904 bfd_boolean dyn, pic;
1906 off = h->got.offset;
1907 BFD_ASSERT (off != (bfd_vma) -1);
1908 dyn = elf_hash_table (info)->dynamic_sections_created;
1909 pic = bfd_link_pic (info);
1911 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1912 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1914 /* This is actually a static link, or it is a
1915 -Bsymbolic link and the symbol is defined
1916 locally, or the symbol was forced to be local
1917 because of a version file. We must initialize
1918 this entry in the global offset table. Since the
1919 offset must always be a multiple of the word size,
1920 we use the least significant bit to record whether
1921 we have initialized it already.
1923 When doing a dynamic link, we create a .rela.got
1924 relocation entry to initialize the value. This
1925 is done in the finish_dynamic_symbol routine. */
1930 bfd_put_NN (output_bfd, relocation,
1931 htab->elf.sgot->contents + off);
1936 unresolved_reloc = FALSE;
1940 BFD_ASSERT (local_got_offsets != NULL
1941 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1943 off = local_got_offsets[r_symndx];
1945 /* The offset must always be a multiple of the word size.
1946 So, we can use the least significant bit to record
1947 whether we have already processed this entry. */
1952 if (bfd_link_pic (info))
1955 Elf_Internal_Rela outrel;
1957 /* We need to generate a R_RISCV_RELATIVE reloc
1958 for the dynamic linker. */
1959 s = htab->elf.srelgot;
1960 BFD_ASSERT (s != NULL);
1962 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1964 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1965 outrel.r_addend = relocation;
1967 riscv_elf_append_rela (output_bfd, s, &outrel);
1970 bfd_put_NN (output_bfd, relocation,
1971 htab->elf.sgot->contents + off);
1972 local_got_offsets[r_symndx] |= 1;
1975 relocation = sec_addr (htab->elf.sgot) + off;
1976 absolute = riscv_zero_pcrel_hi_reloc (rel,
1983 r_type = ELFNN_R_TYPE (rel->r_info);
1984 howto = riscv_elf_rtype_to_howto (r_type);
1985 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
1986 relocation, absolute))
1987 r = bfd_reloc_overflow;
1995 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1996 contents + rel->r_offset);
1997 relocation = old_value + relocation;
2007 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
2008 contents + rel->r_offset);
2009 relocation = old_value - relocation;
2013 case R_RISCV_CALL_PLT:
2016 case R_RISCV_RVC_JUMP:
2017 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
2019 /* Refer to the PLT entry. */
2020 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
2021 unresolved_reloc = FALSE;
2025 case R_RISCV_TPREL_HI20:
2026 relocation = tpoff (info, relocation);
2029 case R_RISCV_TPREL_LO12_I:
2030 case R_RISCV_TPREL_LO12_S:
2031 relocation = tpoff (info, relocation);
2034 case R_RISCV_TPREL_I:
2035 case R_RISCV_TPREL_S:
2036 relocation = tpoff (info, relocation);
2037 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
2039 /* We can use tp as the base register. */
2040 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2041 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2042 insn |= X_TP << OP_SH_RS1;
2043 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2046 r = bfd_reloc_overflow;
2049 case R_RISCV_GPREL_I:
2050 case R_RISCV_GPREL_S:
2052 bfd_vma gp = riscv_global_pointer_value (info);
2053 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
2054 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
2056 /* We can use x0 or gp as the base register. */
2057 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2058 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2061 rel->r_addend -= gp;
2062 insn |= X_GP << OP_SH_RS1;
2064 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2067 r = bfd_reloc_overflow;
2071 case R_RISCV_PCREL_HI20:
2072 absolute = riscv_zero_pcrel_hi_reloc (rel,
2079 r_type = ELFNN_R_TYPE (rel->r_info);
2080 howto = riscv_elf_rtype_to_howto (r_type);
2081 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2082 relocation + rel->r_addend,
2084 r = bfd_reloc_overflow;
2087 case R_RISCV_PCREL_LO12_I:
2088 case R_RISCV_PCREL_LO12_S:
2089 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2090 howto, rel, relocation, name,
2093 r = bfd_reloc_overflow;
2096 case R_RISCV_TLS_DTPREL32:
2097 case R_RISCV_TLS_DTPREL64:
2098 relocation = dtpoff (info, relocation);
2103 if ((input_section->flags & SEC_ALLOC) == 0)
2106 if ((bfd_link_pic (info)
2108 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2109 || h->root.type != bfd_link_hash_undefweak)
2110 && (! howto->pc_relative
2111 || !SYMBOL_CALLS_LOCAL (info, h)))
2112 || (!bfd_link_pic (info)
2118 || h->root.type == bfd_link_hash_undefweak
2119 || h->root.type == bfd_link_hash_undefined)))
2121 Elf_Internal_Rela outrel;
2122 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2124 /* When generating a shared object, these relocations
2125 are copied into the output file to be resolved at run
2129 _bfd_elf_section_offset (output_bfd, info, input_section,
2131 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2132 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2133 outrel.r_offset += sec_addr (input_section);
2135 if (skip_dynamic_relocation)
2136 memset (&outrel, 0, sizeof outrel);
2137 else if (h != NULL && h->dynindx != -1
2138 && !(bfd_link_pic (info)
2139 && SYMBOLIC_BIND (info, h)
2142 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2143 outrel.r_addend = rel->r_addend;
2147 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2148 outrel.r_addend = relocation + rel->r_addend;
2151 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2152 if (skip_static_relocation)
2157 case R_RISCV_TLS_GOT_HI20:
2161 case R_RISCV_TLS_GD_HI20:
2164 off = h->got.offset;
2169 off = local_got_offsets[r_symndx];
2170 local_got_offsets[r_symndx] |= 1;
2173 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2174 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2175 /* If this symbol is referenced by both GD and IE TLS, the IE
2176 reference's GOT slot follows the GD reference's slots. */
2178 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2179 ie_off = 2 * GOT_ENTRY_SIZE;
2185 Elf_Internal_Rela outrel;
2187 bfd_boolean need_relocs = FALSE;
2189 if (htab->elf.srelgot == NULL)
2194 bfd_boolean dyn, pic;
2195 dyn = htab->elf.dynamic_sections_created;
2196 pic = bfd_link_pic (info);
2198 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2199 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2203 /* The GOT entries have not been initialized yet. Do it
2204 now, and emit any relocations. */
2205 if ((bfd_link_pic (info) || indx != 0)
2207 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2208 || h->root.type != bfd_link_hash_undefweak))
2211 if (tls_type & GOT_TLS_GD)
2215 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2216 outrel.r_addend = 0;
2217 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2218 bfd_put_NN (output_bfd, 0,
2219 htab->elf.sgot->contents + off);
2220 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2223 BFD_ASSERT (! unresolved_reloc);
2224 bfd_put_NN (output_bfd,
2225 dtpoff (info, relocation),
2226 (htab->elf.sgot->contents + off +
2227 RISCV_ELF_WORD_BYTES));
2231 bfd_put_NN (output_bfd, 0,
2232 (htab->elf.sgot->contents + off +
2233 RISCV_ELF_WORD_BYTES));
2234 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2235 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2236 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2241 /* If we are not emitting relocations for a
2242 general dynamic reference, then we must be in a
2243 static link or an executable link with the
2244 symbol binding locally. Mark it as belonging
2245 to module 1, the executable. */
2246 bfd_put_NN (output_bfd, 1,
2247 htab->elf.sgot->contents + off);
2248 bfd_put_NN (output_bfd,
2249 dtpoff (info, relocation),
2250 (htab->elf.sgot->contents + off +
2251 RISCV_ELF_WORD_BYTES));
2255 if (tls_type & GOT_TLS_IE)
2259 bfd_put_NN (output_bfd, 0,
2260 htab->elf.sgot->contents + off + ie_off);
2261 outrel.r_offset = sec_addr (htab->elf.sgot)
2263 outrel.r_addend = 0;
2265 outrel.r_addend = tpoff (info, relocation);
2266 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2267 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2271 bfd_put_NN (output_bfd, tpoff (info, relocation),
2272 htab->elf.sgot->contents + off + ie_off);
2277 BFD_ASSERT (off < (bfd_vma) -2);
2278 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2279 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2281 r = bfd_reloc_overflow;
2282 unresolved_reloc = FALSE;
2286 r = bfd_reloc_notsupported;
2289 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2290 because such sections are not SEC_ALLOC and thus ld.so will
2291 not process them. */
2292 if (unresolved_reloc
2293 && !((input_section->flags & SEC_DEBUGGING) != 0
2295 && _bfd_elf_section_offset (output_bfd, info, input_section,
2296 rel->r_offset) != (bfd_vma) -1)
2298 (*_bfd_error_handler)
2299 (_("%B(%A+%#Lx): unresolvable %s relocation against symbol `%s'"),
2304 h->root.root.string);
2308 if (r == bfd_reloc_ok)
2309 r = perform_relocation (howto, rel, relocation, input_section,
2310 input_bfd, contents);
2317 case bfd_reloc_overflow:
2318 info->callbacks->reloc_overflow
2319 (info, (h ? &h->root : NULL), name, howto->name,
2320 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2323 case bfd_reloc_undefined:
2324 info->callbacks->undefined_symbol
2325 (info, name, input_bfd, input_section, rel->r_offset,
2329 case bfd_reloc_outofrange:
2330 msg = _("internal error: out of range error");
2333 case bfd_reloc_notsupported:
2334 msg = _("internal error: unsupported relocation error");
2337 case bfd_reloc_dangerous:
2338 msg = _("internal error: dangerous relocation");
2342 msg = _("internal error: unknown error");
2347 info->callbacks->warning
2348 (info, msg, name, input_bfd, input_section, rel->r_offset);
2352 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2354 riscv_free_pcrel_relocs (&pcrel_relocs);
2358 /* Finish up dynamic symbol handling. We set the contents of various
2359 dynamic sections here. */
2362 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2363 struct bfd_link_info *info,
2364 struct elf_link_hash_entry *h,
2365 Elf_Internal_Sym *sym)
2367 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2368 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2370 if (h->plt.offset != (bfd_vma) -1)
2372 /* We've decided to create a PLT entry for this symbol. */
2374 bfd_vma i, header_address, plt_idx, got_address;
2375 uint32_t plt_entry[PLT_ENTRY_INSNS];
2376 Elf_Internal_Rela rela;
2378 BFD_ASSERT (h->dynindx != -1);
2380 /* Calculate the address of the PLT header. */
2381 header_address = sec_addr (htab->elf.splt);
2383 /* Calculate the index of the entry. */
2384 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2386 /* Calculate the address of the .got.plt entry. */
2387 got_address = riscv_elf_got_plt_val (plt_idx, info);
2389 /* Find out where the .plt entry should go. */
2390 loc = htab->elf.splt->contents + h->plt.offset;
2392 /* Fill in the PLT entry itself. */
2393 riscv_make_plt_entry (got_address, header_address + h->plt.offset,
2395 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2396 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2398 /* Fill in the initial value of the .got.plt entry. */
2399 loc = htab->elf.sgotplt->contents
2400 + (got_address - sec_addr (htab->elf.sgotplt));
2401 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2403 /* Fill in the entry in the .rela.plt section. */
2404 rela.r_offset = got_address;
2406 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2408 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2409 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2411 if (!h->def_regular)
2413 /* Mark the symbol as undefined, rather than as defined in
2414 the .plt section. Leave the value alone. */
2415 sym->st_shndx = SHN_UNDEF;
2416 /* If the symbol is weak, we do need to clear the value.
2417 Otherwise, the PLT entry would provide a definition for
2418 the symbol even if the symbol wasn't defined anywhere,
2419 and so the symbol would never be NULL. */
2420 if (!h->ref_regular_nonweak)
2425 if (h->got.offset != (bfd_vma) -1
2426 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
2430 Elf_Internal_Rela rela;
2432 /* This symbol has an entry in the GOT. Set it up. */
2434 sgot = htab->elf.sgot;
2435 srela = htab->elf.srelgot;
2436 BFD_ASSERT (sgot != NULL && srela != NULL);
2438 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2440 /* If this is a -Bsymbolic link, and the symbol is defined
2441 locally, we just want to emit a RELATIVE reloc. Likewise if
2442 the symbol was forced to be local because of a version file.
2443 The entry in the global offset table will already have been
2444 initialized in the relocate_section function. */
2445 if (bfd_link_pic (info)
2446 && (info->symbolic || h->dynindx == -1)
2449 asection *sec = h->root.u.def.section;
2450 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2451 rela.r_addend = (h->root.u.def.value
2452 + sec->output_section->vma
2453 + sec->output_offset);
2457 BFD_ASSERT (h->dynindx != -1);
2458 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2462 bfd_put_NN (output_bfd, 0,
2463 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2464 riscv_elf_append_rela (output_bfd, srela, &rela);
2469 Elf_Internal_Rela rela;
2472 /* This symbols needs a copy reloc. Set it up. */
2473 BFD_ASSERT (h->dynindx != -1);
2475 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2476 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2478 if (h->root.u.def.section == htab->elf.sdynrelro)
2479 s = htab->elf.sreldynrelro;
2481 s = htab->elf.srelbss;
2482 riscv_elf_append_rela (output_bfd, s, &rela);
2485 /* Mark some specially defined symbols as absolute. */
2486 if (h == htab->elf.hdynamic
2487 || (h == htab->elf.hgot || h == htab->elf.hplt))
2488 sym->st_shndx = SHN_ABS;
2493 /* Finish up the dynamic sections. */
2496 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2497 bfd *dynobj, asection *sdyn)
2499 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2500 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2501 size_t dynsize = bed->s->sizeof_dyn;
2502 bfd_byte *dyncon, *dynconend;
2504 dynconend = sdyn->contents + sdyn->size;
2505 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2507 Elf_Internal_Dyn dyn;
2510 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2515 s = htab->elf.sgotplt;
2516 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2519 s = htab->elf.srelplt;
2520 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2523 s = htab->elf.srelplt;
2524 dyn.d_un.d_val = s->size;
2530 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2536 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2537 struct bfd_link_info *info)
2541 struct riscv_elf_link_hash_table *htab;
2543 htab = riscv_elf_hash_table (info);
2544 BFD_ASSERT (htab != NULL);
2545 dynobj = htab->elf.dynobj;
2547 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2549 if (elf_hash_table (info)->dynamic_sections_created)
2554 splt = htab->elf.splt;
2555 BFD_ASSERT (splt != NULL && sdyn != NULL);
2557 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2562 /* Fill in the head and tail entries in the procedure linkage table. */
2566 uint32_t plt_header[PLT_HEADER_INSNS];
2567 riscv_make_plt_header (sec_addr (htab->elf.sgotplt),
2568 sec_addr (splt), plt_header);
2570 for (i = 0; i < PLT_HEADER_INSNS; i++)
2571 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2573 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2578 if (htab->elf.sgotplt)
2580 asection *output_section = htab->elf.sgotplt->output_section;
2582 if (bfd_is_abs_section (output_section))
2584 (*_bfd_error_handler)
2585 (_("discarded output section: `%A'"), htab->elf.sgotplt);
2589 if (htab->elf.sgotplt->size > 0)
2591 /* Write the first two entries in .got.plt, needed for the dynamic
2593 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2594 bfd_put_NN (output_bfd, (bfd_vma) 0,
2595 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2598 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2603 asection *output_section = htab->elf.sgot->output_section;
2605 if (htab->elf.sgot->size > 0)
2607 /* Set the first entry in the global offset table to the address of
2608 the dynamic section. */
2609 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2610 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2613 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2619 /* Return address for Ith PLT stub in section PLT, for relocation REL
2620 or (bfd_vma) -1 if it should not be included. */
2623 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2624 const arelent *rel ATTRIBUTE_UNUSED)
2626 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2629 static enum elf_reloc_type_class
2630 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2631 const asection *rel_sec ATTRIBUTE_UNUSED,
2632 const Elf_Internal_Rela *rela)
2634 switch (ELFNN_R_TYPE (rela->r_info))
2636 case R_RISCV_RELATIVE:
2637 return reloc_class_relative;
2638 case R_RISCV_JUMP_SLOT:
2639 return reloc_class_plt;
2641 return reloc_class_copy;
2643 return reloc_class_normal;
2647 /* Merge backend specific data from an object file to the output
2648 object file when linking. */
2651 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2653 bfd *obfd = info->output_bfd;
2654 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2655 flagword old_flags = elf_elfheader (obfd)->e_flags;
2657 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2660 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2662 (*_bfd_error_handler)
2663 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2664 " target emulation `%s' does not match `%s'"),
2665 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
2669 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2672 if (! elf_flags_init (obfd))
2674 elf_flags_init (obfd) = TRUE;
2675 elf_elfheader (obfd)->e_flags = new_flags;
2679 /* Disallow linking different float ABIs. */
2680 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
2682 (*_bfd_error_handler)
2683 (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
2687 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2688 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2693 bfd_set_error (bfd_error_bad_value);
2697 /* Delete some bytes from a section while relaxing. */
2700 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count)
2702 unsigned int i, symcount;
2703 bfd_vma toaddr = sec->size;
2704 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2705 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2706 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2707 struct bfd_elf_section_data *data = elf_section_data (sec);
2708 bfd_byte *contents = data->this_hdr.contents;
2710 /* Actually delete the bytes. */
2712 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2714 /* Adjust the location of all of the relocs. Note that we need not
2715 adjust the addends, since all PC-relative references must be against
2716 symbols, which we will adjust below. */
2717 for (i = 0; i < sec->reloc_count; i++)
2718 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2719 data->relocs[i].r_offset -= count;
2721 /* Adjust the local symbols defined in this section. */
2722 for (i = 0; i < symtab_hdr->sh_info; i++)
2724 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2725 if (sym->st_shndx == sec_shndx)
2727 /* If the symbol is in the range of memory we just moved, we
2728 have to adjust its value. */
2729 if (sym->st_value > addr && sym->st_value <= toaddr)
2730 sym->st_value -= count;
2732 /* If the symbol *spans* the bytes we just deleted (i.e. its
2733 *end* is in the moved bytes but its *start* isn't), then we
2734 must adjust its size. */
2735 if (sym->st_value <= addr
2736 && sym->st_value + sym->st_size > addr
2737 && sym->st_value + sym->st_size <= toaddr)
2738 sym->st_size -= count;
2742 /* Now adjust the global symbols defined in this section. */
2743 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2744 - symtab_hdr->sh_info);
2746 for (i = 0; i < symcount; i++)
2748 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2750 if ((sym_hash->root.type == bfd_link_hash_defined
2751 || sym_hash->root.type == bfd_link_hash_defweak)
2752 && sym_hash->root.u.def.section == sec)
2754 /* As above, adjust the value if needed. */
2755 if (sym_hash->root.u.def.value > addr
2756 && sym_hash->root.u.def.value <= toaddr)
2757 sym_hash->root.u.def.value -= count;
2759 /* As above, adjust the size if needed. */
2760 if (sym_hash->root.u.def.value <= addr
2761 && sym_hash->root.u.def.value + sym_hash->size > addr
2762 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2763 sym_hash->size -= count;
2770 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
2771 struct bfd_link_info *,
2772 Elf_Internal_Rela *,
2773 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *);
2775 /* Relax AUIPC + JALR into JAL. */
2778 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2779 struct bfd_link_info *link_info,
2780 Elf_Internal_Rela *rel,
2782 bfd_vma max_alignment,
2783 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2786 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2787 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2788 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2789 bfd_vma auipc, jalr;
2790 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2792 /* If the call crosses section boundaries, an alignment directive could
2793 cause the PC-relative offset to later increase. */
2794 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2795 foff += (foff < 0 ? -max_alignment : max_alignment);
2797 /* See if this function call can be shortened. */
2798 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2801 /* Shorten the function call. */
2802 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2804 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2805 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2806 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2807 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2809 if (rvc && (rd == 0 || rd == X_RA))
2811 /* Relax to C.J[AL] rd, addr. */
2812 r_type = R_RISCV_RVC_JUMP;
2813 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2816 else if (VALID_UJTYPE_IMM (foff))
2818 /* Relax to JAL rd, addr. */
2819 r_type = R_RISCV_JAL;
2820 auipc = MATCH_JAL | (rd << OP_SH_RD);
2822 else /* near_zero */
2824 /* Relax to JALR rd, x0, addr. */
2825 r_type = R_RISCV_LO12_I;
2826 auipc = MATCH_JALR | (rd << OP_SH_RD);
2829 /* Replace the R_RISCV_CALL reloc. */
2830 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
2831 /* Replace the AUIPC. */
2832 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
2834 /* Delete unnecessary JALR. */
2836 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len);
2839 /* Traverse all output sections and return the max alignment. */
2842 _bfd_riscv_get_max_alignment (asection *sec)
2844 unsigned int max_alignment_power = 0;
2847 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
2849 if (o->alignment_power > max_alignment_power)
2850 max_alignment_power = o->alignment_power;
2853 return (bfd_vma) 1 << max_alignment_power;
2856 /* Relax non-PIC global variable references. */
2859 _bfd_riscv_relax_lui (bfd *abfd,
2862 struct bfd_link_info *link_info,
2863 Elf_Internal_Rela *rel,
2865 bfd_vma max_alignment,
2866 bfd_vma reserve_size,
2869 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2870 bfd_vma gp = riscv_global_pointer_value (link_info);
2871 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2873 /* Mergeable symbols and code might later move out of range. */
2874 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
2877 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2881 /* If gp and the symbol are in the same output section, then
2882 consider only that section's alignment. */
2883 struct bfd_link_hash_entry *h =
2884 bfd_link_hash_lookup (link_info->hash, RISCV_GP_SYMBOL, FALSE, FALSE,
2886 if (h->u.def.section->output_section == sym_sec->output_section)
2887 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
2890 /* Is the reference in range of x0 or gp?
2891 Valid gp range conservatively because of alignment issue. */
2892 if (VALID_ITYPE_IMM (symval)
2894 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
2896 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
2898 unsigned sym = ELFNN_R_SYM (rel->r_info);
2899 switch (ELFNN_R_TYPE (rel->r_info))
2901 case R_RISCV_LO12_I:
2902 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2905 case R_RISCV_LO12_S:
2906 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2910 /* We can delete the unnecessary LUI and reloc. */
2911 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2913 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2920 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2921 account for this assuming page alignment at worst. */
2923 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2924 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2925 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2927 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */
2928 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2929 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2932 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2933 bfd_put_32 (abfd, lui, contents + rel->r_offset);
2935 /* Replace the R_RISCV_HI20 reloc. */
2936 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2939 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2945 /* Relax non-PIC TLS references. */
2948 _bfd_riscv_relax_tls_le (bfd *abfd,
2950 asection *sym_sec ATTRIBUTE_UNUSED,
2951 struct bfd_link_info *link_info,
2952 Elf_Internal_Rela *rel,
2954 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2955 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2958 /* See if this symbol is in range of tp. */
2959 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2962 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2963 switch (ELFNN_R_TYPE (rel->r_info))
2965 case R_RISCV_TPREL_LO12_I:
2966 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
2969 case R_RISCV_TPREL_LO12_S:
2970 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
2973 case R_RISCV_TPREL_HI20:
2974 case R_RISCV_TPREL_ADD:
2975 /* We can delete the unnecessary instruction and reloc. */
2976 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2978 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2985 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
2988 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
2990 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2991 Elf_Internal_Rela *rel,
2993 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2994 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2995 bfd_boolean *again ATTRIBUTE_UNUSED)
2997 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2998 bfd_vma alignment = 1, pos;
2999 while (alignment <= rel->r_addend)
3002 symval -= rel->r_addend;
3003 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
3004 bfd_vma nop_bytes = aligned_addr - symval;
3006 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
3007 sec->sec_flg0 = TRUE;
3009 /* Make sure there are enough NOPs to actually achieve the alignment. */
3010 if (rel->r_addend < nop_bytes)
3012 (*_bfd_error_handler)
3013 (_("%B(%A+0x%lx): %d bytes required for alignment"
3014 "to %d-byte boundary, but only %d present"),
3015 abfd, sym_sec, rel->r_offset, nop_bytes, alignment, rel->r_addend);
3016 bfd_set_error (bfd_error_bad_value);
3020 /* Delete the reloc. */
3021 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
3023 /* If the number of NOPs is already correct, there's nothing to do. */
3024 if (nop_bytes == rel->r_addend)
3027 /* Write as many RISC-V NOPs as we need. */
3028 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
3029 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
3031 /* Write a final RVC NOP if need be. */
3032 if (nop_bytes % 4 != 0)
3033 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
3035 /* Delete the excess bytes. */
3036 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
3037 rel->r_addend - nop_bytes);
3040 /* Relax a section. Pass 0 shortens code sequences unless disabled.
3041 Pass 1, which cannot be disabled, handles code alignment directives. */
3044 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
3045 struct bfd_link_info *info,
3048 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
3049 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
3050 struct bfd_elf_section_data *data = elf_section_data (sec);
3051 Elf_Internal_Rela *relocs;
3052 bfd_boolean ret = FALSE;
3054 bfd_vma max_alignment, reserve_size = 0;
3058 if (bfd_link_relocatable (info)
3060 || (sec->flags & SEC_RELOC) == 0
3061 || sec->reloc_count == 0
3062 || (info->disable_target_specific_optimizations
3063 && info->relax_pass == 0))
3066 /* Read this BFD's relocs if we haven't done so already. */
3068 relocs = data->relocs;
3069 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
3070 info->keep_memory)))
3073 max_alignment = _bfd_riscv_get_max_alignment (sec);
3075 /* Examine and consider relaxing each reloc. */
3076 for (i = 0; i < sec->reloc_count; i++)
3079 Elf_Internal_Rela *rel = relocs + i;
3080 relax_func_t relax_func;
3081 int type = ELFNN_R_TYPE (rel->r_info);
3084 if (info->relax_pass == 0)
3086 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3087 relax_func = _bfd_riscv_relax_call;
3088 else if (type == R_RISCV_HI20
3089 || type == R_RISCV_LO12_I
3090 || type == R_RISCV_LO12_S)
3091 relax_func = _bfd_riscv_relax_lui;
3092 else if (type == R_RISCV_TPREL_HI20
3093 || type == R_RISCV_TPREL_ADD
3094 || type == R_RISCV_TPREL_LO12_I
3095 || type == R_RISCV_TPREL_LO12_S)
3096 relax_func = _bfd_riscv_relax_tls_le;
3100 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3101 if (i == sec->reloc_count - 1
3102 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3103 || rel->r_offset != (rel + 1)->r_offset)
3106 /* Skip over the R_RISCV_RELAX. */
3109 else if (type == R_RISCV_ALIGN)
3110 relax_func = _bfd_riscv_relax_align;
3114 data->relocs = relocs;
3116 /* Read this BFD's contents if we haven't done so already. */
3117 if (!data->this_hdr.contents
3118 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3121 /* Read this BFD's symbols if we haven't done so already. */
3122 if (symtab_hdr->sh_info != 0
3123 && !symtab_hdr->contents
3124 && !(symtab_hdr->contents =
3125 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3126 symtab_hdr->sh_info,
3127 0, NULL, NULL, NULL)))
3130 /* Get the value of the symbol referred to by the reloc. */
3131 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3133 /* A local symbol. */
3134 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3135 + ELFNN_R_SYM (rel->r_info));
3136 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3137 ? 0 : isym->st_size - rel->r_addend;
3139 if (isym->st_shndx == SHN_UNDEF)
3140 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3143 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3144 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3145 if (sec_addr (sym_sec) == 0)
3147 symval = sec_addr (sym_sec) + isym->st_value;
3153 struct elf_link_hash_entry *h;
3155 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3156 h = elf_sym_hashes (abfd)[indx];
3158 while (h->root.type == bfd_link_hash_indirect
3159 || h->root.type == bfd_link_hash_warning)
3160 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3162 if (h->plt.offset != MINUS_ONE)
3163 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3164 else if (h->root.u.def.section->output_section == NULL
3165 || (h->root.type != bfd_link_hash_defined
3166 && h->root.type != bfd_link_hash_defweak))
3169 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3171 if (h->type != STT_FUNC)
3173 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3174 sym_sec = h->root.u.def.section;
3177 symval += rel->r_addend;
3179 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3180 max_alignment, reserve_size, again))
3187 if (relocs != data->relocs)
3194 # define PRSTATUS_SIZE 0 /* FIXME */
3195 # define PRSTATUS_OFFSET_PR_CURSIG 12
3196 # define PRSTATUS_OFFSET_PR_PID 24
3197 # define PRSTATUS_OFFSET_PR_REG 72
3198 # define ELF_GREGSET_T_SIZE 128
3199 # define PRPSINFO_SIZE 128
3200 # define PRPSINFO_OFFSET_PR_PID 16
3201 # define PRPSINFO_OFFSET_PR_FNAME 32
3202 # define PRPSINFO_OFFSET_PR_PSARGS 48
3204 # define PRSTATUS_SIZE 376
3205 # define PRSTATUS_OFFSET_PR_CURSIG 12
3206 # define PRSTATUS_OFFSET_PR_PID 32
3207 # define PRSTATUS_OFFSET_PR_REG 112
3208 # define ELF_GREGSET_T_SIZE 256
3209 # define PRPSINFO_SIZE 136
3210 # define PRPSINFO_OFFSET_PR_PID 24
3211 # define PRPSINFO_OFFSET_PR_FNAME 40
3212 # define PRPSINFO_OFFSET_PR_PSARGS 56
3215 /* Support for core dump NOTE sections. */
3218 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3220 switch (note->descsz)
3225 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3227 elf_tdata (abfd)->core->signal
3228 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3231 elf_tdata (abfd)->core->lwpid
3232 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3236 /* Make a ".reg/999" section. */
3237 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3238 note->descpos + PRSTATUS_OFFSET_PR_REG);
3242 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3244 switch (note->descsz)
3249 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3251 elf_tdata (abfd)->core->pid
3252 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3255 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3256 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3259 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3260 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3264 /* Note that for some reason, a spurious space is tacked
3265 onto the end of the args in some (at least one anyway)
3266 implementations, so strip it off if it exists. */
3269 char *command = elf_tdata (abfd)->core->command;
3270 int n = strlen (command);
3272 if (0 < n && command[n - 1] == ' ')
3273 command[n - 1] = '\0';
3279 /* Set the right mach type. */
3281 riscv_elf_object_p (bfd *abfd)
3283 /* There are only two mach types in RISCV currently. */
3284 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0)
3285 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32);
3287 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64);
3293 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3294 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3296 #define elf_backend_reloc_type_class riscv_reloc_type_class
3298 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3299 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3300 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3301 #define bfd_elfNN_bfd_merge_private_bfd_data \
3302 _bfd_riscv_elf_merge_private_bfd_data
3304 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3305 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3306 #define elf_backend_check_relocs riscv_elf_check_relocs
3307 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3308 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3309 #define elf_backend_relocate_section riscv_elf_relocate_section
3310 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3311 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3312 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3313 #define elf_backend_gc_sweep_hook riscv_elf_gc_sweep_hook
3314 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3315 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3316 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3317 #define elf_backend_object_p riscv_elf_object_p
3318 #define elf_info_to_howto_rel NULL
3319 #define elf_info_to_howto riscv_info_to_howto_rela
3320 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3322 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3324 #define elf_backend_can_gc_sections 1
3325 #define elf_backend_can_refcount 1
3326 #define elf_backend_want_got_plt 1
3327 #define elf_backend_plt_readonly 1
3328 #define elf_backend_plt_alignment 4
3329 #define elf_backend_want_plt_sym 1
3330 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3331 #define elf_backend_want_dynrelro 1
3332 #define elf_backend_rela_normal 1
3333 #define elf_backend_default_execstack 0
3335 #include "elfNN-target.h"