1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright 2011-2016 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 long 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 = 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 ((h->root.u.def.section->flags & SEC_READONLY) != 0)
970 s = htab->elf.sdynrelro;
971 srel = htab->elf.sreldynrelro;
975 s = htab->elf.sdynbss;
976 srel = htab->elf.srelbss;
978 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
980 srel->size += sizeof (ElfNN_External_Rela);
984 if (eh->tls_type & ~GOT_NORMAL)
985 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdyntdata);
987 return _bfd_elf_adjust_dynamic_copy (info, h, s);
990 /* Allocate space in .plt, .got and associated reloc sections for
994 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
996 struct bfd_link_info *info;
997 struct riscv_elf_link_hash_table *htab;
998 struct riscv_elf_link_hash_entry *eh;
999 struct riscv_elf_dyn_relocs *p;
1001 if (h->root.type == bfd_link_hash_indirect)
1004 info = (struct bfd_link_info *) inf;
1005 htab = riscv_elf_hash_table (info);
1006 BFD_ASSERT (htab != NULL);
1008 if (htab->elf.dynamic_sections_created
1009 && h->plt.refcount > 0)
1011 /* Make sure this symbol is output as a dynamic symbol.
1012 Undefined weak syms won't yet be marked as dynamic. */
1013 if (h->dynindx == -1
1014 && !h->forced_local)
1016 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1020 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1022 asection *s = htab->elf.splt;
1025 s->size = PLT_HEADER_SIZE;
1027 h->plt.offset = s->size;
1029 /* Make room for this entry. */
1030 s->size += PLT_ENTRY_SIZE;
1032 /* We also need to make an entry in the .got.plt section. */
1033 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1035 /* We also need to make an entry in the .rela.plt section. */
1036 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
1038 /* If this symbol is not defined in a regular file, and we are
1039 not generating a shared library, then set the symbol to this
1040 location in the .plt. This is required to make function
1041 pointers compare as equal between the normal executable and
1042 the shared library. */
1043 if (! bfd_link_pic (info)
1046 h->root.u.def.section = s;
1047 h->root.u.def.value = h->plt.offset;
1052 h->plt.offset = (bfd_vma) -1;
1058 h->plt.offset = (bfd_vma) -1;
1062 if (h->got.refcount > 0)
1066 int tls_type = riscv_elf_hash_entry (h)->tls_type;
1068 /* Make sure this symbol is output as a dynamic symbol.
1069 Undefined weak syms won't yet be marked as dynamic. */
1070 if (h->dynindx == -1
1071 && !h->forced_local)
1073 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1078 h->got.offset = s->size;
1079 dyn = htab->elf.dynamic_sections_created;
1080 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
1082 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1083 if (tls_type & GOT_TLS_GD)
1085 s->size += 2 * RISCV_ELF_WORD_BYTES;
1086 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1089 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1090 if (tls_type & GOT_TLS_IE)
1092 s->size += RISCV_ELF_WORD_BYTES;
1093 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1098 s->size += RISCV_ELF_WORD_BYTES;
1099 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1100 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1104 h->got.offset = (bfd_vma) -1;
1106 eh = (struct riscv_elf_link_hash_entry *) h;
1107 if (eh->dyn_relocs == NULL)
1110 /* In the shared -Bsymbolic case, discard space allocated for
1111 dynamic pc-relative relocs against symbols which turn out to be
1112 defined in regular objects. For the normal shared case, discard
1113 space for pc-relative relocs that have become local due to symbol
1114 visibility changes. */
1116 if (bfd_link_pic (info))
1118 if (SYMBOL_CALLS_LOCAL (info, h))
1120 struct riscv_elf_dyn_relocs **pp;
1122 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1124 p->count -= p->pc_count;
1133 /* Also discard relocs on undefined weak syms with non-default
1135 if (eh->dyn_relocs != NULL
1136 && h->root.type == bfd_link_hash_undefweak)
1138 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1139 eh->dyn_relocs = NULL;
1141 /* Make sure undefined weak symbols are output as a dynamic
1143 else if (h->dynindx == -1
1144 && !h->forced_local)
1146 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1153 /* For the non-shared case, discard space for relocs against
1154 symbols which turn out to need copy relocs or are not
1160 || (htab->elf.dynamic_sections_created
1161 && (h->root.type == bfd_link_hash_undefweak
1162 || h->root.type == bfd_link_hash_undefined))))
1164 /* Make sure this symbol is output as a dynamic symbol.
1165 Undefined weak syms won't yet be marked as dynamic. */
1166 if (h->dynindx == -1
1167 && !h->forced_local)
1169 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1173 /* If that succeeded, we know we'll be keeping all the
1175 if (h->dynindx != -1)
1179 eh->dyn_relocs = NULL;
1184 /* Finally, allocate space. */
1185 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1187 asection *sreloc = elf_section_data (p->sec)->sreloc;
1188 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1194 /* Find any dynamic relocs that apply to read-only sections. */
1197 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1199 struct riscv_elf_link_hash_entry *eh;
1200 struct riscv_elf_dyn_relocs *p;
1202 eh = (struct riscv_elf_link_hash_entry *) h;
1203 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1205 asection *s = p->sec->output_section;
1207 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1209 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL;
1217 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1219 struct riscv_elf_link_hash_table *htab;
1224 htab = riscv_elf_hash_table (info);
1225 BFD_ASSERT (htab != NULL);
1226 dynobj = htab->elf.dynobj;
1227 BFD_ASSERT (dynobj != NULL);
1229 if (elf_hash_table (info)->dynamic_sections_created)
1231 /* Set the contents of the .interp section to the interpreter. */
1232 if (bfd_link_executable (info) && !info->nointerp)
1234 s = bfd_get_linker_section (dynobj, ".interp");
1235 BFD_ASSERT (s != NULL);
1236 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1237 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1241 /* Set up .got offsets for local syms, and space for local dynamic
1243 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1245 bfd_signed_vma *local_got;
1246 bfd_signed_vma *end_local_got;
1247 char *local_tls_type;
1248 bfd_size_type locsymcount;
1249 Elf_Internal_Shdr *symtab_hdr;
1252 if (! is_riscv_elf (ibfd))
1255 for (s = ibfd->sections; s != NULL; s = s->next)
1257 struct riscv_elf_dyn_relocs *p;
1259 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1261 if (!bfd_is_abs_section (p->sec)
1262 && bfd_is_abs_section (p->sec->output_section))
1264 /* Input section has been discarded, either because
1265 it is a copy of a linkonce section or due to
1266 linker script /DISCARD/, so we'll be discarding
1269 else if (p->count != 0)
1271 srel = elf_section_data (p->sec)->sreloc;
1272 srel->size += p->count * sizeof (ElfNN_External_Rela);
1273 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1274 info->flags |= DF_TEXTREL;
1279 local_got = elf_local_got_refcounts (ibfd);
1283 symtab_hdr = &elf_symtab_hdr (ibfd);
1284 locsymcount = symtab_hdr->sh_info;
1285 end_local_got = local_got + locsymcount;
1286 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1288 srel = htab->elf.srelgot;
1289 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1293 *local_got = s->size;
1294 s->size += RISCV_ELF_WORD_BYTES;
1295 if (*local_tls_type & GOT_TLS_GD)
1296 s->size += RISCV_ELF_WORD_BYTES;
1297 if (bfd_link_pic (info)
1298 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1299 srel->size += sizeof (ElfNN_External_Rela);
1302 *local_got = (bfd_vma) -1;
1306 /* Allocate global sym .plt and .got entries, and space for global
1307 sym dynamic relocs. */
1308 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1310 if (htab->elf.sgotplt)
1312 struct elf_link_hash_entry *got;
1313 got = elf_link_hash_lookup (elf_hash_table (info),
1314 "_GLOBAL_OFFSET_TABLE_",
1315 FALSE, FALSE, FALSE);
1317 /* Don't allocate .got.plt section if there are no GOT nor PLT
1318 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1320 || !got->ref_regular_nonweak)
1321 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1322 && (htab->elf.splt == NULL
1323 || htab->elf.splt->size == 0)
1324 && (htab->elf.sgot == NULL
1325 || (htab->elf.sgot->size
1326 == get_elf_backend_data (output_bfd)->got_header_size)))
1327 htab->elf.sgotplt->size = 0;
1330 /* The check_relocs and adjust_dynamic_symbol entry points have
1331 determined the sizes of the various dynamic sections. Allocate
1333 for (s = dynobj->sections; s != NULL; s = s->next)
1335 if ((s->flags & SEC_LINKER_CREATED) == 0)
1338 if (s == htab->elf.splt
1339 || s == htab->elf.sgot
1340 || s == htab->elf.sgotplt
1341 || s == htab->elf.sdynbss
1342 || s == htab->elf.sdynrelro)
1344 /* Strip this section if we don't need it; see the
1347 else if (strncmp (s->name, ".rela", 5) == 0)
1351 /* We use the reloc_count field as a counter if we need
1352 to copy relocs into the output file. */
1358 /* It's not one of our sections. */
1364 /* If we don't need this section, strip it from the
1365 output file. This is mostly to handle .rela.bss and
1366 .rela.plt. We must create both sections in
1367 create_dynamic_sections, because they must be created
1368 before the linker maps input sections to output
1369 sections. The linker does that before
1370 adjust_dynamic_symbol is called, and it is that
1371 function which decides whether anything needs to go
1372 into these sections. */
1373 s->flags |= SEC_EXCLUDE;
1377 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1380 /* Allocate memory for the section contents. Zero the memory
1381 for the benefit of .rela.plt, which has 4 unused entries
1382 at the beginning, and we don't want garbage. */
1383 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1384 if (s->contents == NULL)
1388 if (elf_hash_table (info)->dynamic_sections_created)
1390 /* Add some entries to the .dynamic section. We fill in the
1391 values later, in riscv_elf_finish_dynamic_sections, but we
1392 must add the entries now so that we get the correct size for
1393 the .dynamic section. The DT_DEBUG entry is filled in by the
1394 dynamic linker and used by the debugger. */
1395 #define add_dynamic_entry(TAG, VAL) \
1396 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1398 if (bfd_link_executable (info))
1400 if (!add_dynamic_entry (DT_DEBUG, 0))
1404 if (htab->elf.srelplt->size != 0)
1406 if (!add_dynamic_entry (DT_PLTGOT, 0)
1407 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1408 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1409 || !add_dynamic_entry (DT_JMPREL, 0))
1413 if (!add_dynamic_entry (DT_RELA, 0)
1414 || !add_dynamic_entry (DT_RELASZ, 0)
1415 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1418 /* If any dynamic relocs apply to a read-only section,
1419 then we need a DT_TEXTREL entry. */
1420 if ((info->flags & DF_TEXTREL) == 0)
1421 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
1423 if (info->flags & DF_TEXTREL)
1425 if (!add_dynamic_entry (DT_TEXTREL, 0))
1429 #undef add_dynamic_entry
1435 #define DTP_OFFSET 0x800
1437 /* Return the relocation value for a TLS dtp-relative reloc. */
1440 dtpoff (struct bfd_link_info *info, bfd_vma address)
1442 /* If tls_sec is NULL, we should have signalled an error already. */
1443 if (elf_hash_table (info)->tls_sec == NULL)
1445 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1448 /* Return the relocation value for a static TLS tp-relative relocation. */
1451 tpoff (struct bfd_link_info *info, bfd_vma address)
1453 /* If tls_sec is NULL, we should have signalled an error already. */
1454 if (elf_hash_table (info)->tls_sec == NULL)
1456 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1459 /* Return the global pointer's value, or 0 if it is not in use. */
1462 riscv_global_pointer_value (struct bfd_link_info *info)
1464 struct bfd_link_hash_entry *h;
1466 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1467 if (h == NULL || h->type != bfd_link_hash_defined)
1470 return h->u.def.value + sec_addr (h->u.def.section);
1473 /* Emplace a static relocation. */
1475 static bfd_reloc_status_type
1476 perform_relocation (const reloc_howto_type *howto,
1477 const Elf_Internal_Rela *rel,
1479 asection *input_section,
1483 if (howto->pc_relative)
1484 value -= sec_addr (input_section) + rel->r_offset;
1485 value += rel->r_addend;
1487 switch (ELFNN_R_TYPE (rel->r_info))
1490 case R_RISCV_TPREL_HI20:
1491 case R_RISCV_PCREL_HI20:
1492 case R_RISCV_GOT_HI20:
1493 case R_RISCV_TLS_GOT_HI20:
1494 case R_RISCV_TLS_GD_HI20:
1495 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1496 return bfd_reloc_overflow;
1497 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1500 case R_RISCV_LO12_I:
1501 case R_RISCV_GPREL_I:
1502 case R_RISCV_TPREL_LO12_I:
1503 case R_RISCV_TPREL_I:
1504 case R_RISCV_PCREL_LO12_I:
1505 value = ENCODE_ITYPE_IMM (value);
1508 case R_RISCV_LO12_S:
1509 case R_RISCV_GPREL_S:
1510 case R_RISCV_TPREL_LO12_S:
1511 case R_RISCV_TPREL_S:
1512 case R_RISCV_PCREL_LO12_S:
1513 value = ENCODE_STYPE_IMM (value);
1517 case R_RISCV_CALL_PLT:
1518 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1519 return bfd_reloc_overflow;
1520 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1521 | (ENCODE_ITYPE_IMM (value) << 32);
1525 if (!VALID_UJTYPE_IMM (value))
1526 return bfd_reloc_overflow;
1527 value = ENCODE_UJTYPE_IMM (value);
1530 case R_RISCV_BRANCH:
1531 if (!VALID_SBTYPE_IMM (value))
1532 return bfd_reloc_overflow;
1533 value = ENCODE_SBTYPE_IMM (value);
1536 case R_RISCV_RVC_BRANCH:
1537 if (!VALID_RVC_B_IMM (value))
1538 return bfd_reloc_overflow;
1539 value = ENCODE_RVC_B_IMM (value);
1542 case R_RISCV_RVC_JUMP:
1543 if (!VALID_RVC_J_IMM (value))
1544 return bfd_reloc_overflow;
1545 value = ENCODE_RVC_J_IMM (value);
1548 case R_RISCV_RVC_LUI:
1549 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1550 return bfd_reloc_overflow;
1551 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1569 case R_RISCV_TLS_DTPREL32:
1570 case R_RISCV_TLS_DTPREL64:
1574 return bfd_reloc_notsupported;
1577 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1578 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1579 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1581 return bfd_reloc_ok;
1584 /* Remember all PC-relative high-part relocs we've encountered to help us
1585 later resolve the corresponding low-part relocs. */
1591 } riscv_pcrel_hi_reloc;
1593 typedef struct riscv_pcrel_lo_reloc
1595 asection * input_section;
1596 struct bfd_link_info * info;
1597 reloc_howto_type * howto;
1598 const Elf_Internal_Rela * reloc;
1601 bfd_byte * contents;
1602 struct riscv_pcrel_lo_reloc * next;
1603 } riscv_pcrel_lo_reloc;
1608 riscv_pcrel_lo_reloc *lo_relocs;
1609 } riscv_pcrel_relocs;
1612 riscv_pcrel_reloc_hash (const void *entry)
1614 const riscv_pcrel_hi_reloc *e = entry;
1615 return (hashval_t)(e->address >> 2);
1619 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1621 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1622 return e1->address == e2->address;
1626 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1629 p->lo_relocs = NULL;
1630 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1631 riscv_pcrel_reloc_eq, free);
1632 return p->hi_relocs != NULL;
1636 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1638 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1642 riscv_pcrel_lo_reloc *next = cur->next;
1647 htab_delete (p->hi_relocs);
1651 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr, bfd_vma value)
1653 riscv_pcrel_hi_reloc entry = {addr, value - addr};
1654 riscv_pcrel_hi_reloc **slot =
1655 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1657 BFD_ASSERT (*slot == NULL);
1658 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1666 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1667 asection *input_section,
1668 struct bfd_link_info *info,
1669 reloc_howto_type *howto,
1670 const Elf_Internal_Rela *reloc,
1675 riscv_pcrel_lo_reloc *entry;
1676 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1679 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1680 name, contents, p->lo_relocs};
1681 p->lo_relocs = entry;
1686 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1688 riscv_pcrel_lo_reloc *r;
1690 for (r = p->lo_relocs; r != NULL; r = r->next)
1692 bfd *input_bfd = r->input_section->owner;
1694 riscv_pcrel_hi_reloc search = {r->addr, 0};
1695 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1698 ((*r->info->callbacks->reloc_overflow)
1699 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0,
1700 input_bfd, r->input_section, r->reloc->r_offset));
1704 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1705 input_bfd, r->contents);
1711 /* Relocate a RISC-V ELF section.
1713 The RELOCATE_SECTION function is called by the new ELF backend linker
1714 to handle the relocations for a section.
1716 The relocs are always passed as Rela structures.
1718 This function is responsible for adjusting the section contents as
1719 necessary, and (if generating a relocatable output file) adjusting
1720 the reloc addend as necessary.
1722 This function does not have to worry about setting the reloc
1723 address or the reloc symbol index.
1725 LOCAL_SYMS is a pointer to the swapped in local symbols.
1727 LOCAL_SECTIONS is an array giving the section in the input file
1728 corresponding to the st_shndx field of each local symbol.
1730 The global hash table entry for the global symbols can be found
1731 via elf_sym_hashes (input_bfd).
1733 When generating relocatable output, this function must handle
1734 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1735 going to be the section symbol corresponding to the output
1736 section, which means that the addend must be adjusted
1740 riscv_elf_relocate_section (bfd *output_bfd,
1741 struct bfd_link_info *info,
1743 asection *input_section,
1745 Elf_Internal_Rela *relocs,
1746 Elf_Internal_Sym *local_syms,
1747 asection **local_sections)
1749 Elf_Internal_Rela *rel;
1750 Elf_Internal_Rela *relend;
1751 riscv_pcrel_relocs pcrel_relocs;
1752 bfd_boolean ret = FALSE;
1753 asection *sreloc = elf_section_data (input_section)->sreloc;
1754 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1755 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1756 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1757 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1759 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1762 relend = relocs + input_section->reloc_count;
1763 for (rel = relocs; rel < relend; rel++)
1765 unsigned long r_symndx;
1766 struct elf_link_hash_entry *h;
1767 Elf_Internal_Sym *sym;
1770 bfd_reloc_status_type r = bfd_reloc_ok;
1772 bfd_vma off, ie_off;
1773 bfd_boolean unresolved_reloc, is_ie = FALSE;
1774 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1775 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1776 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type);
1777 const char *msg = NULL;
1779 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1782 /* This is a final link. */
1783 r_symndx = ELFNN_R_SYM (rel->r_info);
1787 unresolved_reloc = FALSE;
1788 if (r_symndx < symtab_hdr->sh_info)
1790 sym = local_syms + r_symndx;
1791 sec = local_sections[r_symndx];
1792 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1796 bfd_boolean warned, ignored;
1798 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1799 r_symndx, symtab_hdr, sym_hashes,
1801 unresolved_reloc, warned, ignored);
1804 /* To avoid generating warning messages about truncated
1805 relocations, set the relocation's address to be the same as
1806 the start of this section. */
1807 if (input_section->output_section != NULL)
1808 relocation = input_section->output_section->vma;
1814 if (sec != NULL && discarded_section (sec))
1815 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1816 rel, 1, relend, howto, 0, contents);
1818 if (bfd_link_relocatable (info))
1822 name = h->root.root.string;
1825 name = (bfd_elf_string_from_elf_section
1826 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1827 if (name == NULL || *name == '\0')
1828 name = bfd_section_name (input_bfd, sec);
1835 case R_RISCV_TPREL_ADD:
1837 case R_RISCV_JUMP_SLOT:
1838 case R_RISCV_RELATIVE:
1839 /* These require nothing of us at all. */
1843 case R_RISCV_BRANCH:
1844 case R_RISCV_RVC_BRANCH:
1845 case R_RISCV_RVC_LUI:
1846 case R_RISCV_LO12_I:
1847 case R_RISCV_LO12_S:
1852 /* These require no special handling beyond perform_relocation. */
1855 case R_RISCV_GOT_HI20:
1858 bfd_boolean dyn, pic;
1860 off = h->got.offset;
1861 BFD_ASSERT (off != (bfd_vma) -1);
1862 dyn = elf_hash_table (info)->dynamic_sections_created;
1863 pic = bfd_link_pic (info);
1865 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1866 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1868 /* This is actually a static link, or it is a
1869 -Bsymbolic link and the symbol is defined
1870 locally, or the symbol was forced to be local
1871 because of a version file. We must initialize
1872 this entry in the global offset table. Since the
1873 offset must always be a multiple of the word size,
1874 we use the least significant bit to record whether
1875 we have initialized it already.
1877 When doing a dynamic link, we create a .rela.got
1878 relocation entry to initialize the value. This
1879 is done in the finish_dynamic_symbol routine. */
1884 bfd_put_NN (output_bfd, relocation,
1885 htab->elf.sgot->contents + off);
1890 unresolved_reloc = FALSE;
1894 BFD_ASSERT (local_got_offsets != NULL
1895 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1897 off = local_got_offsets[r_symndx];
1899 /* The offset must always be a multiple of the word size.
1900 So, we can use the least significant bit to record
1901 whether we have already processed this entry. */
1906 if (bfd_link_pic (info))
1909 Elf_Internal_Rela outrel;
1911 /* We need to generate a R_RISCV_RELATIVE reloc
1912 for the dynamic linker. */
1913 s = htab->elf.srelgot;
1914 BFD_ASSERT (s != NULL);
1916 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1918 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1919 outrel.r_addend = relocation;
1921 riscv_elf_append_rela (output_bfd, s, &outrel);
1924 bfd_put_NN (output_bfd, relocation,
1925 htab->elf.sgot->contents + off);
1926 local_got_offsets[r_symndx] |= 1;
1929 relocation = sec_addr (htab->elf.sgot) + off;
1930 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
1931 r = bfd_reloc_overflow;
1939 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1940 contents + rel->r_offset);
1941 relocation = old_value + relocation;
1951 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1952 contents + rel->r_offset);
1953 relocation = old_value - relocation;
1957 case R_RISCV_CALL_PLT:
1960 case R_RISCV_RVC_JUMP:
1961 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1963 /* Refer to the PLT entry. */
1964 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1965 unresolved_reloc = FALSE;
1969 case R_RISCV_TPREL_HI20:
1970 relocation = tpoff (info, relocation);
1973 case R_RISCV_TPREL_LO12_I:
1974 case R_RISCV_TPREL_LO12_S:
1975 relocation = tpoff (info, relocation);
1978 case R_RISCV_TPREL_I:
1979 case R_RISCV_TPREL_S:
1980 relocation = tpoff (info, relocation);
1981 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
1983 /* We can use tp as the base register. */
1984 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1985 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1986 insn |= X_TP << OP_SH_RS1;
1987 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1990 r = bfd_reloc_overflow;
1993 case R_RISCV_GPREL_I:
1994 case R_RISCV_GPREL_S:
1996 bfd_vma gp = riscv_global_pointer_value (info);
1997 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
1998 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
2000 /* We can use x0 or gp as the base register. */
2001 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2002 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2005 rel->r_addend -= gp;
2006 insn |= X_GP << OP_SH_RS1;
2008 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2011 r = bfd_reloc_overflow;
2015 case R_RISCV_PCREL_HI20:
2016 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2017 relocation + rel->r_addend))
2018 r = bfd_reloc_overflow;
2021 case R_RISCV_PCREL_LO12_I:
2022 case R_RISCV_PCREL_LO12_S:
2023 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2024 howto, rel, relocation, name,
2027 r = bfd_reloc_overflow;
2030 case R_RISCV_TLS_DTPREL32:
2031 case R_RISCV_TLS_DTPREL64:
2032 relocation = dtpoff (info, relocation);
2037 if ((input_section->flags & SEC_ALLOC) == 0)
2040 if ((bfd_link_pic (info)
2042 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2043 || h->root.type != bfd_link_hash_undefweak)
2044 && (! howto->pc_relative
2045 || !SYMBOL_CALLS_LOCAL (info, h)))
2046 || (!bfd_link_pic (info)
2052 || h->root.type == bfd_link_hash_undefweak
2053 || h->root.type == bfd_link_hash_undefined)))
2055 Elf_Internal_Rela outrel;
2056 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2058 /* When generating a shared object, these relocations
2059 are copied into the output file to be resolved at run
2063 _bfd_elf_section_offset (output_bfd, info, input_section,
2065 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2066 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2067 outrel.r_offset += sec_addr (input_section);
2069 if (skip_dynamic_relocation)
2070 memset (&outrel, 0, sizeof outrel);
2071 else if (h != NULL && h->dynindx != -1
2072 && !(bfd_link_pic (info)
2073 && SYMBOLIC_BIND (info, h)
2076 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2077 outrel.r_addend = rel->r_addend;
2081 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2082 outrel.r_addend = relocation + rel->r_addend;
2085 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2086 if (skip_static_relocation)
2091 case R_RISCV_TLS_GOT_HI20:
2095 case R_RISCV_TLS_GD_HI20:
2098 off = h->got.offset;
2103 off = local_got_offsets[r_symndx];
2104 local_got_offsets[r_symndx] |= 1;
2107 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2108 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2109 /* If this symbol is referenced by both GD and IE TLS, the IE
2110 reference's GOT slot follows the GD reference's slots. */
2112 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2113 ie_off = 2 * GOT_ENTRY_SIZE;
2119 Elf_Internal_Rela outrel;
2121 bfd_boolean need_relocs = FALSE;
2123 if (htab->elf.srelgot == NULL)
2128 bfd_boolean dyn, pic;
2129 dyn = htab->elf.dynamic_sections_created;
2130 pic = bfd_link_pic (info);
2132 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2133 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2137 /* The GOT entries have not been initialized yet. Do it
2138 now, and emit any relocations. */
2139 if ((bfd_link_pic (info) || indx != 0)
2141 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2142 || h->root.type != bfd_link_hash_undefweak))
2145 if (tls_type & GOT_TLS_GD)
2149 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2150 outrel.r_addend = 0;
2151 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2152 bfd_put_NN (output_bfd, 0,
2153 htab->elf.sgot->contents + off);
2154 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2157 BFD_ASSERT (! unresolved_reloc);
2158 bfd_put_NN (output_bfd,
2159 dtpoff (info, relocation),
2160 (htab->elf.sgot->contents + off +
2161 RISCV_ELF_WORD_BYTES));
2165 bfd_put_NN (output_bfd, 0,
2166 (htab->elf.sgot->contents + off +
2167 RISCV_ELF_WORD_BYTES));
2168 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2169 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2170 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2175 /* If we are not emitting relocations for a
2176 general dynamic reference, then we must be in a
2177 static link or an executable link with the
2178 symbol binding locally. Mark it as belonging
2179 to module 1, the executable. */
2180 bfd_put_NN (output_bfd, 1,
2181 htab->elf.sgot->contents + off);
2182 bfd_put_NN (output_bfd,
2183 dtpoff (info, relocation),
2184 (htab->elf.sgot->contents + off +
2185 RISCV_ELF_WORD_BYTES));
2189 if (tls_type & GOT_TLS_IE)
2193 bfd_put_NN (output_bfd, 0,
2194 htab->elf.sgot->contents + off + ie_off);
2195 outrel.r_offset = sec_addr (htab->elf.sgot)
2197 outrel.r_addend = 0;
2199 outrel.r_addend = tpoff (info, relocation);
2200 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2201 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2205 bfd_put_NN (output_bfd, tpoff (info, relocation),
2206 htab->elf.sgot->contents + off + ie_off);
2211 BFD_ASSERT (off < (bfd_vma) -2);
2212 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2213 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
2214 r = bfd_reloc_overflow;
2215 unresolved_reloc = FALSE;
2219 r = bfd_reloc_notsupported;
2222 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2223 because such sections are not SEC_ALLOC and thus ld.so will
2224 not process them. */
2225 if (unresolved_reloc
2226 && !((input_section->flags & SEC_DEBUGGING) != 0
2228 && _bfd_elf_section_offset (output_bfd, info, input_section,
2229 rel->r_offset) != (bfd_vma) -1)
2231 (*_bfd_error_handler)
2232 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2235 (long) rel->r_offset,
2237 h->root.root.string);
2241 if (r == bfd_reloc_ok)
2242 r = perform_relocation (howto, rel, relocation, input_section,
2243 input_bfd, contents);
2250 case bfd_reloc_overflow:
2251 info->callbacks->reloc_overflow
2252 (info, (h ? &h->root : NULL), name, howto->name,
2253 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2256 case bfd_reloc_undefined:
2257 info->callbacks->undefined_symbol
2258 (info, name, input_bfd, input_section, rel->r_offset,
2262 case bfd_reloc_outofrange:
2263 msg = _("internal error: out of range error");
2266 case bfd_reloc_notsupported:
2267 msg = _("internal error: unsupported relocation error");
2270 case bfd_reloc_dangerous:
2271 msg = _("internal error: dangerous relocation");
2275 msg = _("internal error: unknown error");
2280 info->callbacks->warning
2281 (info, msg, name, input_bfd, input_section, rel->r_offset);
2285 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2287 riscv_free_pcrel_relocs (&pcrel_relocs);
2291 /* Finish up dynamic symbol handling. We set the contents of various
2292 dynamic sections here. */
2295 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2296 struct bfd_link_info *info,
2297 struct elf_link_hash_entry *h,
2298 Elf_Internal_Sym *sym)
2300 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2301 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2303 if (h->plt.offset != (bfd_vma) -1)
2305 /* We've decided to create a PLT entry for this symbol. */
2307 bfd_vma i, header_address, plt_idx, got_address;
2308 uint32_t plt_entry[PLT_ENTRY_INSNS];
2309 Elf_Internal_Rela rela;
2311 BFD_ASSERT (h->dynindx != -1);
2313 /* Calculate the address of the PLT header. */
2314 header_address = sec_addr (htab->elf.splt);
2316 /* Calculate the index of the entry. */
2317 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2319 /* Calculate the address of the .got.plt entry. */
2320 got_address = riscv_elf_got_plt_val (plt_idx, info);
2322 /* Find out where the .plt entry should go. */
2323 loc = htab->elf.splt->contents + h->plt.offset;
2325 /* Fill in the PLT entry itself. */
2326 riscv_make_plt_entry (got_address, header_address + h->plt.offset,
2328 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2329 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2331 /* Fill in the initial value of the .got.plt entry. */
2332 loc = htab->elf.sgotplt->contents
2333 + (got_address - sec_addr (htab->elf.sgotplt));
2334 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2336 /* Fill in the entry in the .rela.plt section. */
2337 rela.r_offset = got_address;
2339 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2341 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2342 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2344 if (!h->def_regular)
2346 /* Mark the symbol as undefined, rather than as defined in
2347 the .plt section. Leave the value alone. */
2348 sym->st_shndx = SHN_UNDEF;
2349 /* If the symbol is weak, we do need to clear the value.
2350 Otherwise, the PLT entry would provide a definition for
2351 the symbol even if the symbol wasn't defined anywhere,
2352 and so the symbol would never be NULL. */
2353 if (!h->ref_regular_nonweak)
2358 if (h->got.offset != (bfd_vma) -1
2359 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
2363 Elf_Internal_Rela rela;
2365 /* This symbol has an entry in the GOT. Set it up. */
2367 sgot = htab->elf.sgot;
2368 srela = htab->elf.srelgot;
2369 BFD_ASSERT (sgot != NULL && srela != NULL);
2371 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2373 /* If this is a -Bsymbolic link, and the symbol is defined
2374 locally, we just want to emit a RELATIVE reloc. Likewise if
2375 the symbol was forced to be local because of a version file.
2376 The entry in the global offset table will already have been
2377 initialized in the relocate_section function. */
2378 if (bfd_link_pic (info)
2379 && (info->symbolic || h->dynindx == -1)
2382 asection *sec = h->root.u.def.section;
2383 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2384 rela.r_addend = (h->root.u.def.value
2385 + sec->output_section->vma
2386 + sec->output_offset);
2390 BFD_ASSERT (h->dynindx != -1);
2391 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2395 bfd_put_NN (output_bfd, 0,
2396 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2397 riscv_elf_append_rela (output_bfd, srela, &rela);
2402 Elf_Internal_Rela rela;
2405 /* This symbols needs a copy reloc. Set it up. */
2406 BFD_ASSERT (h->dynindx != -1);
2408 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2409 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2411 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
2412 s = htab->elf.sreldynrelro;
2414 s = htab->elf.srelbss;
2415 riscv_elf_append_rela (output_bfd, s, &rela);
2418 /* Mark some specially defined symbols as absolute. */
2419 if (h == htab->elf.hdynamic
2420 || (h == htab->elf.hgot || h == htab->elf.hplt))
2421 sym->st_shndx = SHN_ABS;
2426 /* Finish up the dynamic sections. */
2429 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2430 bfd *dynobj, asection *sdyn)
2432 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2433 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2434 size_t dynsize = bed->s->sizeof_dyn;
2435 bfd_byte *dyncon, *dynconend;
2437 dynconend = sdyn->contents + sdyn->size;
2438 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2440 Elf_Internal_Dyn dyn;
2443 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2448 s = htab->elf.sgotplt;
2449 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2452 s = htab->elf.srelplt;
2453 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2456 s = htab->elf.srelplt;
2457 dyn.d_un.d_val = s->size;
2463 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2469 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2470 struct bfd_link_info *info)
2474 struct riscv_elf_link_hash_table *htab;
2476 htab = riscv_elf_hash_table (info);
2477 BFD_ASSERT (htab != NULL);
2478 dynobj = htab->elf.dynobj;
2480 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2482 if (elf_hash_table (info)->dynamic_sections_created)
2487 splt = htab->elf.splt;
2488 BFD_ASSERT (splt != NULL && sdyn != NULL);
2490 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2495 /* Fill in the head and tail entries in the procedure linkage table. */
2499 uint32_t plt_header[PLT_HEADER_INSNS];
2500 riscv_make_plt_header (sec_addr (htab->elf.sgotplt),
2501 sec_addr (splt), plt_header);
2503 for (i = 0; i < PLT_HEADER_INSNS; i++)
2504 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2507 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2511 if (htab->elf.sgotplt)
2513 asection *output_section = htab->elf.sgotplt->output_section;
2515 if (bfd_is_abs_section (output_section))
2517 (*_bfd_error_handler)
2518 (_("discarded output section: `%A'"), htab->elf.sgotplt);
2522 if (htab->elf.sgotplt->size > 0)
2524 /* Write the first two entries in .got.plt, needed for the dynamic
2526 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2527 bfd_put_NN (output_bfd, (bfd_vma) 0,
2528 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2531 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2536 asection *output_section = htab->elf.sgot->output_section;
2538 if (htab->elf.sgot->size > 0)
2540 /* Set the first entry in the global offset table to the address of
2541 the dynamic section. */
2542 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2543 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2546 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2552 /* Return address for Ith PLT stub in section PLT, for relocation REL
2553 or (bfd_vma) -1 if it should not be included. */
2556 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2557 const arelent *rel ATTRIBUTE_UNUSED)
2559 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2562 static enum elf_reloc_type_class
2563 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2564 const asection *rel_sec ATTRIBUTE_UNUSED,
2565 const Elf_Internal_Rela *rela)
2567 switch (ELFNN_R_TYPE (rela->r_info))
2569 case R_RISCV_RELATIVE:
2570 return reloc_class_relative;
2571 case R_RISCV_JUMP_SLOT:
2572 return reloc_class_plt;
2574 return reloc_class_copy;
2576 return reloc_class_normal;
2580 /* Merge backend specific data from an object file to the output
2581 object file when linking. */
2584 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2586 bfd *obfd = info->output_bfd;
2587 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2588 flagword old_flags = elf_elfheader (obfd)->e_flags;
2590 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2593 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2595 (*_bfd_error_handler)
2596 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2597 " target emulation `%s' does not match `%s'"),
2598 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
2602 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2605 if (! elf_flags_init (obfd))
2607 elf_flags_init (obfd) = TRUE;
2608 elf_elfheader (obfd)->e_flags = new_flags;
2612 /* Disallow linking different float ABIs. */
2613 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
2615 (*_bfd_error_handler)
2616 (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
2620 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2621 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2626 bfd_set_error (bfd_error_bad_value);
2630 /* Delete some bytes from a section while relaxing. */
2633 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count)
2635 unsigned int i, symcount;
2636 bfd_vma toaddr = sec->size;
2637 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2638 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2639 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2640 struct bfd_elf_section_data *data = elf_section_data (sec);
2641 bfd_byte *contents = data->this_hdr.contents;
2643 /* Actually delete the bytes. */
2645 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2647 /* Adjust the location of all of the relocs. Note that we need not
2648 adjust the addends, since all PC-relative references must be against
2649 symbols, which we will adjust below. */
2650 for (i = 0; i < sec->reloc_count; i++)
2651 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2652 data->relocs[i].r_offset -= count;
2654 /* Adjust the local symbols defined in this section. */
2655 for (i = 0; i < symtab_hdr->sh_info; i++)
2657 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2658 if (sym->st_shndx == sec_shndx)
2660 /* If the symbol is in the range of memory we just moved, we
2661 have to adjust its value. */
2662 if (sym->st_value > addr && sym->st_value <= toaddr)
2663 sym->st_value -= count;
2665 /* If the symbol *spans* the bytes we just deleted (i.e. its
2666 *end* is in the moved bytes but its *start* isn't), then we
2667 must adjust its size. */
2668 if (sym->st_value <= addr
2669 && sym->st_value + sym->st_size > addr
2670 && sym->st_value + sym->st_size <= toaddr)
2671 sym->st_size -= count;
2675 /* Now adjust the global symbols defined in this section. */
2676 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2677 - symtab_hdr->sh_info);
2679 for (i = 0; i < symcount; i++)
2681 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2683 if ((sym_hash->root.type == bfd_link_hash_defined
2684 || sym_hash->root.type == bfd_link_hash_defweak)
2685 && sym_hash->root.u.def.section == sec)
2687 /* As above, adjust the value if needed. */
2688 if (sym_hash->root.u.def.value > addr
2689 && sym_hash->root.u.def.value <= toaddr)
2690 sym_hash->root.u.def.value -= count;
2692 /* As above, adjust the size if needed. */
2693 if (sym_hash->root.u.def.value <= addr
2694 && sym_hash->root.u.def.value + sym_hash->size > addr
2695 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2696 sym_hash->size -= count;
2703 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
2704 struct bfd_link_info *,
2705 Elf_Internal_Rela *,
2706 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *);
2708 /* Relax AUIPC + JALR into JAL. */
2711 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2712 struct bfd_link_info *link_info,
2713 Elf_Internal_Rela *rel,
2715 bfd_vma max_alignment,
2716 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2719 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2720 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2721 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2722 bfd_vma auipc, jalr;
2723 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2725 /* If the call crosses section boundaries, an alignment directive could
2726 cause the PC-relative offset to later increase. */
2727 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2728 foff += (foff < 0 ? -max_alignment : max_alignment);
2730 /* See if this function call can be shortened. */
2731 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2734 /* Shorten the function call. */
2735 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2737 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2738 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2739 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2740 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2742 if (rvc && (rd == 0 || rd == X_RA))
2744 /* Relax to C.J[AL] rd, addr. */
2745 r_type = R_RISCV_RVC_JUMP;
2746 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2749 else if (VALID_UJTYPE_IMM (foff))
2751 /* Relax to JAL rd, addr. */
2752 r_type = R_RISCV_JAL;
2753 auipc = MATCH_JAL | (rd << OP_SH_RD);
2755 else /* near_zero */
2757 /* Relax to JALR rd, x0, addr. */
2758 r_type = R_RISCV_LO12_I;
2759 auipc = MATCH_JALR | (rd << OP_SH_RD);
2762 /* Replace the R_RISCV_CALL reloc. */
2763 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
2764 /* Replace the AUIPC. */
2765 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
2767 /* Delete unnecessary JALR. */
2769 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len);
2772 /* Traverse all output sections and return the max alignment. */
2775 _bfd_riscv_get_max_alignment (asection *sec)
2777 unsigned int max_alignment_power = 0;
2780 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
2782 if (o->alignment_power > max_alignment_power)
2783 max_alignment_power = o->alignment_power;
2786 return (bfd_vma) 1 << max_alignment_power;
2789 /* Relax non-PIC global variable references. */
2792 _bfd_riscv_relax_lui (bfd *abfd,
2795 struct bfd_link_info *link_info,
2796 Elf_Internal_Rela *rel,
2798 bfd_vma max_alignment,
2799 bfd_vma reserve_size,
2802 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2803 bfd_vma gp = riscv_global_pointer_value (link_info);
2804 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2806 /* Mergeable symbols and code might later move out of range. */
2807 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
2810 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2812 /* Is the reference in range of x0 or gp?
2813 Valid gp range conservatively because of alignment issue. */
2814 if (VALID_ITYPE_IMM (symval)
2816 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
2818 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
2820 unsigned sym = ELFNN_R_SYM (rel->r_info);
2821 switch (ELFNN_R_TYPE (rel->r_info))
2823 case R_RISCV_LO12_I:
2824 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2827 case R_RISCV_LO12_S:
2828 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2832 /* We can delete the unnecessary LUI and reloc. */
2833 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2835 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2842 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2843 account for this assuming page alignment at worst. */
2845 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2846 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2847 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2849 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */
2850 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2851 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2854 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2855 bfd_put_32 (abfd, lui, contents + rel->r_offset);
2857 /* Replace the R_RISCV_HI20 reloc. */
2858 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2861 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2867 /* Relax non-PIC TLS references. */
2870 _bfd_riscv_relax_tls_le (bfd *abfd,
2872 asection *sym_sec ATTRIBUTE_UNUSED,
2873 struct bfd_link_info *link_info,
2874 Elf_Internal_Rela *rel,
2876 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2877 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2880 /* See if this symbol is in range of tp. */
2881 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2884 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2885 switch (ELFNN_R_TYPE (rel->r_info))
2887 case R_RISCV_TPREL_LO12_I:
2888 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
2891 case R_RISCV_TPREL_LO12_S:
2892 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
2895 case R_RISCV_TPREL_HI20:
2896 case R_RISCV_TPREL_ADD:
2897 /* We can delete the unnecessary instruction and reloc. */
2898 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2900 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2907 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
2910 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
2911 asection *sym_sec ATTRIBUTE_UNUSED,
2912 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2913 Elf_Internal_Rela *rel,
2915 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2916 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2917 bfd_boolean *again ATTRIBUTE_UNUSED)
2919 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2920 bfd_vma alignment = 1, pos;
2921 while (alignment <= rel->r_addend)
2924 symval -= rel->r_addend;
2925 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
2926 bfd_vma nop_bytes = aligned_addr - symval;
2928 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
2929 sec->sec_flg0 = TRUE;
2931 /* Make sure there are enough NOPs to actually achieve the alignment. */
2932 if (rel->r_addend < nop_bytes)
2935 /* Delete the reloc. */
2936 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2938 /* If the number of NOPs is already correct, there's nothing to do. */
2939 if (nop_bytes == rel->r_addend)
2942 /* Write as many RISC-V NOPs as we need. */
2943 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
2944 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
2946 /* Write a final RVC NOP if need be. */
2947 if (nop_bytes % 4 != 0)
2948 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
2950 /* Delete the excess bytes. */
2951 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
2952 rel->r_addend - nop_bytes);
2955 /* Relax a section. Pass 0 shortens code sequences unless disabled.
2956 Pass 1, which cannot be disabled, handles code alignment directives. */
2959 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
2960 struct bfd_link_info *info,
2963 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
2964 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2965 struct bfd_elf_section_data *data = elf_section_data (sec);
2966 Elf_Internal_Rela *relocs;
2967 bfd_boolean ret = FALSE;
2969 bfd_vma max_alignment, reserve_size = 0;
2973 if (bfd_link_relocatable (info)
2975 || (sec->flags & SEC_RELOC) == 0
2976 || sec->reloc_count == 0
2977 || (info->disable_target_specific_optimizations
2978 && info->relax_pass == 0))
2981 /* Read this BFD's relocs if we haven't done so already. */
2983 relocs = data->relocs;
2984 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2985 info->keep_memory)))
2988 max_alignment = _bfd_riscv_get_max_alignment (sec);
2990 /* Examine and consider relaxing each reloc. */
2991 for (i = 0; i < sec->reloc_count; i++)
2994 Elf_Internal_Rela *rel = relocs + i;
2995 relax_func_t relax_func;
2996 int type = ELFNN_R_TYPE (rel->r_info);
2999 if (info->relax_pass == 0)
3001 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3002 relax_func = _bfd_riscv_relax_call;
3003 else if (type == R_RISCV_HI20
3004 || type == R_RISCV_LO12_I
3005 || type == R_RISCV_LO12_S)
3006 relax_func = _bfd_riscv_relax_lui;
3007 else if (type == R_RISCV_TPREL_HI20
3008 || type == R_RISCV_TPREL_ADD
3009 || type == R_RISCV_TPREL_LO12_I
3010 || type == R_RISCV_TPREL_LO12_S)
3011 relax_func = _bfd_riscv_relax_tls_le;
3015 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3016 if (i == sec->reloc_count - 1
3017 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3018 || rel->r_offset != (rel + 1)->r_offset)
3021 /* Skip over the R_RISCV_RELAX. */
3024 else if (type == R_RISCV_ALIGN)
3025 relax_func = _bfd_riscv_relax_align;
3029 data->relocs = relocs;
3031 /* Read this BFD's contents if we haven't done so already. */
3032 if (!data->this_hdr.contents
3033 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3036 /* Read this BFD's symbols if we haven't done so already. */
3037 if (symtab_hdr->sh_info != 0
3038 && !symtab_hdr->contents
3039 && !(symtab_hdr->contents =
3040 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3041 symtab_hdr->sh_info,
3042 0, NULL, NULL, NULL)))
3045 /* Get the value of the symbol referred to by the reloc. */
3046 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3048 /* A local symbol. */
3049 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3050 + ELFNN_R_SYM (rel->r_info));
3051 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3052 ? 0 : isym->st_size - rel->r_addend;
3054 if (isym->st_shndx == SHN_UNDEF)
3055 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3058 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3059 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3060 if (sec_addr (sym_sec) == 0)
3062 symval = sec_addr (sym_sec) + isym->st_value;
3068 struct elf_link_hash_entry *h;
3070 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3071 h = elf_sym_hashes (abfd)[indx];
3073 while (h->root.type == bfd_link_hash_indirect
3074 || h->root.type == bfd_link_hash_warning)
3075 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3077 if (h->plt.offset != MINUS_ONE)
3078 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3079 else if (h->root.u.def.section->output_section == NULL
3080 || (h->root.type != bfd_link_hash_defined
3081 && h->root.type != bfd_link_hash_defweak))
3084 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3086 if (h->type != STT_FUNC)
3088 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3089 sym_sec = h->root.u.def.section;
3092 symval += rel->r_addend;
3094 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3095 max_alignment, reserve_size, again))
3102 if (relocs != data->relocs)
3109 # define PRSTATUS_SIZE 0 /* FIXME */
3110 # define PRSTATUS_OFFSET_PR_CURSIG 12
3111 # define PRSTATUS_OFFSET_PR_PID 24
3112 # define PRSTATUS_OFFSET_PR_REG 72
3113 # define ELF_GREGSET_T_SIZE 128
3114 # define PRPSINFO_SIZE 128
3115 # define PRPSINFO_OFFSET_PR_PID 16
3116 # define PRPSINFO_OFFSET_PR_FNAME 32
3117 # define PRPSINFO_OFFSET_PR_PSARGS 48
3119 # define PRSTATUS_SIZE 376
3120 # define PRSTATUS_OFFSET_PR_CURSIG 12
3121 # define PRSTATUS_OFFSET_PR_PID 32
3122 # define PRSTATUS_OFFSET_PR_REG 112
3123 # define ELF_GREGSET_T_SIZE 256
3124 # define PRPSINFO_SIZE 136
3125 # define PRPSINFO_OFFSET_PR_PID 24
3126 # define PRPSINFO_OFFSET_PR_FNAME 40
3127 # define PRPSINFO_OFFSET_PR_PSARGS 56
3130 /* Support for core dump NOTE sections. */
3133 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3135 switch (note->descsz)
3140 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3142 elf_tdata (abfd)->core->signal
3143 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3146 elf_tdata (abfd)->core->lwpid
3147 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3151 /* Make a ".reg/999" section. */
3152 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3153 note->descpos + PRSTATUS_OFFSET_PR_REG);
3157 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3159 switch (note->descsz)
3164 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3166 elf_tdata (abfd)->core->pid
3167 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3170 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3171 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3174 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3175 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3179 /* Note that for some reason, a spurious space is tacked
3180 onto the end of the args in some (at least one anyway)
3181 implementations, so strip it off if it exists. */
3184 char *command = elf_tdata (abfd)->core->command;
3185 int n = strlen (command);
3187 if (0 < n && command[n - 1] == ' ')
3188 command[n - 1] = '\0';
3195 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3196 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3198 #define elf_backend_reloc_type_class riscv_reloc_type_class
3200 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3201 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3202 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3203 #define bfd_elfNN_bfd_merge_private_bfd_data \
3204 _bfd_riscv_elf_merge_private_bfd_data
3206 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3207 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3208 #define elf_backend_check_relocs riscv_elf_check_relocs
3209 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3210 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3211 #define elf_backend_relocate_section riscv_elf_relocate_section
3212 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3213 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3214 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3215 #define elf_backend_gc_sweep_hook riscv_elf_gc_sweep_hook
3216 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3217 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3218 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3219 #define elf_info_to_howto_rel NULL
3220 #define elf_info_to_howto riscv_info_to_howto_rela
3221 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3223 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3225 #define elf_backend_can_gc_sections 1
3226 #define elf_backend_can_refcount 1
3227 #define elf_backend_want_got_plt 1
3228 #define elf_backend_plt_readonly 1
3229 #define elf_backend_plt_alignment 4
3230 #define elf_backend_want_plt_sym 1
3231 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3232 #define elf_backend_want_dynrelro 1
3233 #define elf_backend_rela_normal 1
3234 #define elf_backend_default_execstack 0
3236 #include "elfNN-target.h"