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_ALLOC) != 0 && h->size != 0)
970 htab->elf.srelbss->size += sizeof (ElfNN_External_Rela);
974 if (eh->tls_type & ~GOT_NORMAL)
975 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdyntdata);
977 return _bfd_elf_adjust_dynamic_copy (info, h, htab->elf.sdynbss);
980 /* Allocate space in .plt, .got and associated reloc sections for
984 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
986 struct bfd_link_info *info;
987 struct riscv_elf_link_hash_table *htab;
988 struct riscv_elf_link_hash_entry *eh;
989 struct riscv_elf_dyn_relocs *p;
991 if (h->root.type == bfd_link_hash_indirect)
994 info = (struct bfd_link_info *) inf;
995 htab = riscv_elf_hash_table (info);
996 BFD_ASSERT (htab != NULL);
998 if (htab->elf.dynamic_sections_created
999 && h->plt.refcount > 0)
1001 /* Make sure this symbol is output as a dynamic symbol.
1002 Undefined weak syms won't yet be marked as dynamic. */
1003 if (h->dynindx == -1
1004 && !h->forced_local)
1006 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1010 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1012 asection *s = htab->elf.splt;
1015 s->size = PLT_HEADER_SIZE;
1017 h->plt.offset = s->size;
1019 /* Make room for this entry. */
1020 s->size += PLT_ENTRY_SIZE;
1022 /* We also need to make an entry in the .got.plt section. */
1023 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1025 /* We also need to make an entry in the .rela.plt section. */
1026 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
1028 /* If this symbol is not defined in a regular file, and we are
1029 not generating a shared library, then set the symbol to this
1030 location in the .plt. This is required to make function
1031 pointers compare as equal between the normal executable and
1032 the shared library. */
1033 if (! bfd_link_pic (info)
1036 h->root.u.def.section = s;
1037 h->root.u.def.value = h->plt.offset;
1042 h->plt.offset = (bfd_vma) -1;
1048 h->plt.offset = (bfd_vma) -1;
1052 if (h->got.refcount > 0)
1056 int tls_type = riscv_elf_hash_entry (h)->tls_type;
1058 /* Make sure this symbol is output as a dynamic symbol.
1059 Undefined weak syms won't yet be marked as dynamic. */
1060 if (h->dynindx == -1
1061 && !h->forced_local)
1063 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1068 h->got.offset = s->size;
1069 dyn = htab->elf.dynamic_sections_created;
1070 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
1072 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1073 if (tls_type & GOT_TLS_GD)
1075 s->size += 2 * RISCV_ELF_WORD_BYTES;
1076 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1079 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1080 if (tls_type & GOT_TLS_IE)
1082 s->size += RISCV_ELF_WORD_BYTES;
1083 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1088 s->size += RISCV_ELF_WORD_BYTES;
1089 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1090 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1094 h->got.offset = (bfd_vma) -1;
1096 eh = (struct riscv_elf_link_hash_entry *) h;
1097 if (eh->dyn_relocs == NULL)
1100 /* In the shared -Bsymbolic case, discard space allocated for
1101 dynamic pc-relative relocs against symbols which turn out to be
1102 defined in regular objects. For the normal shared case, discard
1103 space for pc-relative relocs that have become local due to symbol
1104 visibility changes. */
1106 if (bfd_link_pic (info))
1108 if (SYMBOL_CALLS_LOCAL (info, h))
1110 struct riscv_elf_dyn_relocs **pp;
1112 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1114 p->count -= p->pc_count;
1123 /* Also discard relocs on undefined weak syms with non-default
1125 if (eh->dyn_relocs != NULL
1126 && h->root.type == bfd_link_hash_undefweak)
1128 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1129 eh->dyn_relocs = NULL;
1131 /* Make sure undefined weak symbols are output as a dynamic
1133 else if (h->dynindx == -1
1134 && !h->forced_local)
1136 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1143 /* For the non-shared case, discard space for relocs against
1144 symbols which turn out to need copy relocs or are not
1150 || (htab->elf.dynamic_sections_created
1151 && (h->root.type == bfd_link_hash_undefweak
1152 || h->root.type == bfd_link_hash_undefined))))
1154 /* Make sure this symbol is output as a dynamic symbol.
1155 Undefined weak syms won't yet be marked as dynamic. */
1156 if (h->dynindx == -1
1157 && !h->forced_local)
1159 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1163 /* If that succeeded, we know we'll be keeping all the
1165 if (h->dynindx != -1)
1169 eh->dyn_relocs = NULL;
1174 /* Finally, allocate space. */
1175 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1177 asection *sreloc = elf_section_data (p->sec)->sreloc;
1178 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1184 /* Find any dynamic relocs that apply to read-only sections. */
1187 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1189 struct riscv_elf_link_hash_entry *eh;
1190 struct riscv_elf_dyn_relocs *p;
1192 eh = (struct riscv_elf_link_hash_entry *) h;
1193 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1195 asection *s = p->sec->output_section;
1197 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1199 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL;
1207 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1209 struct riscv_elf_link_hash_table *htab;
1214 htab = riscv_elf_hash_table (info);
1215 BFD_ASSERT (htab != NULL);
1216 dynobj = htab->elf.dynobj;
1217 BFD_ASSERT (dynobj != NULL);
1219 if (elf_hash_table (info)->dynamic_sections_created)
1221 /* Set the contents of the .interp section to the interpreter. */
1222 if (bfd_link_executable (info) && !info->nointerp)
1224 s = bfd_get_linker_section (dynobj, ".interp");
1225 BFD_ASSERT (s != NULL);
1226 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1227 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1231 /* Set up .got offsets for local syms, and space for local dynamic
1233 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1235 bfd_signed_vma *local_got;
1236 bfd_signed_vma *end_local_got;
1237 char *local_tls_type;
1238 bfd_size_type locsymcount;
1239 Elf_Internal_Shdr *symtab_hdr;
1242 if (! is_riscv_elf (ibfd))
1245 for (s = ibfd->sections; s != NULL; s = s->next)
1247 struct riscv_elf_dyn_relocs *p;
1249 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1251 if (!bfd_is_abs_section (p->sec)
1252 && bfd_is_abs_section (p->sec->output_section))
1254 /* Input section has been discarded, either because
1255 it is a copy of a linkonce section or due to
1256 linker script /DISCARD/, so we'll be discarding
1259 else if (p->count != 0)
1261 srel = elf_section_data (p->sec)->sreloc;
1262 srel->size += p->count * sizeof (ElfNN_External_Rela);
1263 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1264 info->flags |= DF_TEXTREL;
1269 local_got = elf_local_got_refcounts (ibfd);
1273 symtab_hdr = &elf_symtab_hdr (ibfd);
1274 locsymcount = symtab_hdr->sh_info;
1275 end_local_got = local_got + locsymcount;
1276 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1278 srel = htab->elf.srelgot;
1279 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1283 *local_got = s->size;
1284 s->size += RISCV_ELF_WORD_BYTES;
1285 if (*local_tls_type & GOT_TLS_GD)
1286 s->size += RISCV_ELF_WORD_BYTES;
1287 if (bfd_link_pic (info)
1288 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1289 srel->size += sizeof (ElfNN_External_Rela);
1292 *local_got = (bfd_vma) -1;
1296 /* Allocate global sym .plt and .got entries, and space for global
1297 sym dynamic relocs. */
1298 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1300 if (htab->elf.sgotplt)
1302 struct elf_link_hash_entry *got;
1303 got = elf_link_hash_lookup (elf_hash_table (info),
1304 "_GLOBAL_OFFSET_TABLE_",
1305 FALSE, FALSE, FALSE);
1307 /* Don't allocate .got.plt section if there are no GOT nor PLT
1308 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1310 || !got->ref_regular_nonweak)
1311 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1312 && (htab->elf.splt == NULL
1313 || htab->elf.splt->size == 0)
1314 && (htab->elf.sgot == NULL
1315 || (htab->elf.sgot->size
1316 == get_elf_backend_data (output_bfd)->got_header_size)))
1317 htab->elf.sgotplt->size = 0;
1320 /* The check_relocs and adjust_dynamic_symbol entry points have
1321 determined the sizes of the various dynamic sections. Allocate
1323 for (s = dynobj->sections; s != NULL; s = s->next)
1325 if ((s->flags & SEC_LINKER_CREATED) == 0)
1328 if (s == htab->elf.splt
1329 || s == htab->elf.sgot
1330 || s == htab->elf.sgotplt
1331 || s == htab->elf.sdynbss)
1333 /* Strip this section if we don't need it; see the
1336 else if (strncmp (s->name, ".rela", 5) == 0)
1340 /* We use the reloc_count field as a counter if we need
1341 to copy relocs into the output file. */
1347 /* It's not one of our sections. */
1353 /* If we don't need this section, strip it from the
1354 output file. This is mostly to handle .rela.bss and
1355 .rela.plt. We must create both sections in
1356 create_dynamic_sections, because they must be created
1357 before the linker maps input sections to output
1358 sections. The linker does that before
1359 adjust_dynamic_symbol is called, and it is that
1360 function which decides whether anything needs to go
1361 into these sections. */
1362 s->flags |= SEC_EXCLUDE;
1366 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1369 /* Allocate memory for the section contents. Zero the memory
1370 for the benefit of .rela.plt, which has 4 unused entries
1371 at the beginning, and we don't want garbage. */
1372 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1373 if (s->contents == NULL)
1377 if (elf_hash_table (info)->dynamic_sections_created)
1379 /* Add some entries to the .dynamic section. We fill in the
1380 values later, in riscv_elf_finish_dynamic_sections, but we
1381 must add the entries now so that we get the correct size for
1382 the .dynamic section. The DT_DEBUG entry is filled in by the
1383 dynamic linker and used by the debugger. */
1384 #define add_dynamic_entry(TAG, VAL) \
1385 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1387 if (bfd_link_executable (info))
1389 if (!add_dynamic_entry (DT_DEBUG, 0))
1393 if (htab->elf.srelplt->size != 0)
1395 if (!add_dynamic_entry (DT_PLTGOT, 0)
1396 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1397 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1398 || !add_dynamic_entry (DT_JMPREL, 0))
1402 if (!add_dynamic_entry (DT_RELA, 0)
1403 || !add_dynamic_entry (DT_RELASZ, 0)
1404 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1407 /* If any dynamic relocs apply to a read-only section,
1408 then we need a DT_TEXTREL entry. */
1409 if ((info->flags & DF_TEXTREL) == 0)
1410 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
1412 if (info->flags & DF_TEXTREL)
1414 if (!add_dynamic_entry (DT_TEXTREL, 0))
1418 #undef add_dynamic_entry
1424 #define DTP_OFFSET 0x800
1426 /* Return the relocation value for a TLS dtp-relative reloc. */
1429 dtpoff (struct bfd_link_info *info, bfd_vma address)
1431 /* If tls_sec is NULL, we should have signalled an error already. */
1432 if (elf_hash_table (info)->tls_sec == NULL)
1434 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1437 /* Return the relocation value for a static TLS tp-relative relocation. */
1440 tpoff (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 - TP_OFFSET;
1448 /* Return the global pointer's value, or 0 if it is not in use. */
1451 riscv_global_pointer_value (struct bfd_link_info *info)
1453 struct bfd_link_hash_entry *h;
1455 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1456 if (h == NULL || h->type != bfd_link_hash_defined)
1459 return h->u.def.value + sec_addr (h->u.def.section);
1462 /* Emplace a static relocation. */
1464 static bfd_reloc_status_type
1465 perform_relocation (const reloc_howto_type *howto,
1466 const Elf_Internal_Rela *rel,
1468 asection *input_section,
1472 if (howto->pc_relative)
1473 value -= sec_addr (input_section) + rel->r_offset;
1474 value += rel->r_addend;
1476 switch (ELFNN_R_TYPE (rel->r_info))
1479 case R_RISCV_TPREL_HI20:
1480 case R_RISCV_PCREL_HI20:
1481 case R_RISCV_GOT_HI20:
1482 case R_RISCV_TLS_GOT_HI20:
1483 case R_RISCV_TLS_GD_HI20:
1484 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1485 return bfd_reloc_overflow;
1486 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1489 case R_RISCV_LO12_I:
1490 case R_RISCV_GPREL_I:
1491 case R_RISCV_TPREL_LO12_I:
1492 case R_RISCV_TPREL_I:
1493 case R_RISCV_PCREL_LO12_I:
1494 value = ENCODE_ITYPE_IMM (value);
1497 case R_RISCV_LO12_S:
1498 case R_RISCV_GPREL_S:
1499 case R_RISCV_TPREL_LO12_S:
1500 case R_RISCV_TPREL_S:
1501 case R_RISCV_PCREL_LO12_S:
1502 value = ENCODE_STYPE_IMM (value);
1506 case R_RISCV_CALL_PLT:
1507 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1508 return bfd_reloc_overflow;
1509 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1510 | (ENCODE_ITYPE_IMM (value) << 32);
1514 if (!VALID_UJTYPE_IMM (value))
1515 return bfd_reloc_overflow;
1516 value = ENCODE_UJTYPE_IMM (value);
1519 case R_RISCV_BRANCH:
1520 if (!VALID_SBTYPE_IMM (value))
1521 return bfd_reloc_overflow;
1522 value = ENCODE_SBTYPE_IMM (value);
1525 case R_RISCV_RVC_BRANCH:
1526 if (!VALID_RVC_B_IMM (value))
1527 return bfd_reloc_overflow;
1528 value = ENCODE_RVC_B_IMM (value);
1531 case R_RISCV_RVC_JUMP:
1532 if (!VALID_RVC_J_IMM (value))
1533 return bfd_reloc_overflow;
1534 value = ENCODE_RVC_J_IMM (value);
1537 case R_RISCV_RVC_LUI:
1538 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1539 return bfd_reloc_overflow;
1540 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1558 case R_RISCV_TLS_DTPREL32:
1559 case R_RISCV_TLS_DTPREL64:
1563 return bfd_reloc_notsupported;
1566 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1567 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1568 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1570 return bfd_reloc_ok;
1573 /* Remember all PC-relative high-part relocs we've encountered to help us
1574 later resolve the corresponding low-part relocs. */
1580 } riscv_pcrel_hi_reloc;
1582 typedef struct riscv_pcrel_lo_reloc
1584 asection * input_section;
1585 struct bfd_link_info * info;
1586 reloc_howto_type * howto;
1587 const Elf_Internal_Rela * reloc;
1590 bfd_byte * contents;
1591 struct riscv_pcrel_lo_reloc * next;
1592 } riscv_pcrel_lo_reloc;
1597 riscv_pcrel_lo_reloc *lo_relocs;
1598 } riscv_pcrel_relocs;
1601 riscv_pcrel_reloc_hash (const void *entry)
1603 const riscv_pcrel_hi_reloc *e = entry;
1604 return (hashval_t)(e->address >> 2);
1608 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1610 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1611 return e1->address == e2->address;
1615 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1618 p->lo_relocs = NULL;
1619 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1620 riscv_pcrel_reloc_eq, free);
1621 return p->hi_relocs != NULL;
1625 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1627 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1631 riscv_pcrel_lo_reloc *next = cur->next;
1636 htab_delete (p->hi_relocs);
1640 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr, bfd_vma value)
1642 riscv_pcrel_hi_reloc entry = {addr, value - addr};
1643 riscv_pcrel_hi_reloc **slot =
1644 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1646 BFD_ASSERT (*slot == NULL);
1647 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1655 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1656 asection *input_section,
1657 struct bfd_link_info *info,
1658 reloc_howto_type *howto,
1659 const Elf_Internal_Rela *reloc,
1664 riscv_pcrel_lo_reloc *entry;
1665 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1668 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1669 name, contents, p->lo_relocs};
1670 p->lo_relocs = entry;
1675 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1677 riscv_pcrel_lo_reloc *r;
1679 for (r = p->lo_relocs; r != NULL; r = r->next)
1681 bfd *input_bfd = r->input_section->owner;
1683 riscv_pcrel_hi_reloc search = {r->addr, 0};
1684 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1687 ((*r->info->callbacks->reloc_overflow)
1688 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0,
1689 input_bfd, r->input_section, r->reloc->r_offset));
1693 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1694 input_bfd, r->contents);
1700 /* Relocate a RISC-V ELF section.
1702 The RELOCATE_SECTION function is called by the new ELF backend linker
1703 to handle the relocations for a section.
1705 The relocs are always passed as Rela structures.
1707 This function is responsible for adjusting the section contents as
1708 necessary, and (if generating a relocatable output file) adjusting
1709 the reloc addend as necessary.
1711 This function does not have to worry about setting the reloc
1712 address or the reloc symbol index.
1714 LOCAL_SYMS is a pointer to the swapped in local symbols.
1716 LOCAL_SECTIONS is an array giving the section in the input file
1717 corresponding to the st_shndx field of each local symbol.
1719 The global hash table entry for the global symbols can be found
1720 via elf_sym_hashes (input_bfd).
1722 When generating relocatable output, this function must handle
1723 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1724 going to be the section symbol corresponding to the output
1725 section, which means that the addend must be adjusted
1729 riscv_elf_relocate_section (bfd *output_bfd,
1730 struct bfd_link_info *info,
1732 asection *input_section,
1734 Elf_Internal_Rela *relocs,
1735 Elf_Internal_Sym *local_syms,
1736 asection **local_sections)
1738 Elf_Internal_Rela *rel;
1739 Elf_Internal_Rela *relend;
1740 riscv_pcrel_relocs pcrel_relocs;
1741 bfd_boolean ret = FALSE;
1742 asection *sreloc = elf_section_data (input_section)->sreloc;
1743 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1744 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1745 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1746 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1748 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1751 relend = relocs + input_section->reloc_count;
1752 for (rel = relocs; rel < relend; rel++)
1754 unsigned long r_symndx;
1755 struct elf_link_hash_entry *h;
1756 Elf_Internal_Sym *sym;
1759 bfd_reloc_status_type r = bfd_reloc_ok;
1761 bfd_vma off, ie_off;
1762 bfd_boolean unresolved_reloc, is_ie = FALSE;
1763 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1764 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1765 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type);
1766 const char *msg = NULL;
1768 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1771 /* This is a final link. */
1772 r_symndx = ELFNN_R_SYM (rel->r_info);
1776 unresolved_reloc = FALSE;
1777 if (r_symndx < symtab_hdr->sh_info)
1779 sym = local_syms + r_symndx;
1780 sec = local_sections[r_symndx];
1781 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1785 bfd_boolean warned, ignored;
1787 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1788 r_symndx, symtab_hdr, sym_hashes,
1790 unresolved_reloc, warned, ignored);
1793 /* To avoid generating warning messages about truncated
1794 relocations, set the relocation's address to be the same as
1795 the start of this section. */
1796 if (input_section->output_section != NULL)
1797 relocation = input_section->output_section->vma;
1803 if (sec != NULL && discarded_section (sec))
1804 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1805 rel, 1, relend, howto, 0, contents);
1807 if (bfd_link_relocatable (info))
1811 name = h->root.root.string;
1814 name = (bfd_elf_string_from_elf_section
1815 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1816 if (name == NULL || *name == '\0')
1817 name = bfd_section_name (input_bfd, sec);
1824 case R_RISCV_TPREL_ADD:
1826 case R_RISCV_JUMP_SLOT:
1827 case R_RISCV_RELATIVE:
1828 /* These require nothing of us at all. */
1832 case R_RISCV_BRANCH:
1833 case R_RISCV_RVC_BRANCH:
1834 case R_RISCV_RVC_LUI:
1835 case R_RISCV_LO12_I:
1836 case R_RISCV_LO12_S:
1841 /* These require no special handling beyond perform_relocation. */
1844 case R_RISCV_GOT_HI20:
1847 bfd_boolean dyn, pic;
1849 off = h->got.offset;
1850 BFD_ASSERT (off != (bfd_vma) -1);
1851 dyn = elf_hash_table (info)->dynamic_sections_created;
1852 pic = bfd_link_pic (info);
1854 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1855 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1857 /* This is actually a static link, or it is a
1858 -Bsymbolic link and the symbol is defined
1859 locally, or the symbol was forced to be local
1860 because of a version file. We must initialize
1861 this entry in the global offset table. Since the
1862 offset must always be a multiple of the word size,
1863 we use the least significant bit to record whether
1864 we have initialized it already.
1866 When doing a dynamic link, we create a .rela.got
1867 relocation entry to initialize the value. This
1868 is done in the finish_dynamic_symbol routine. */
1873 bfd_put_NN (output_bfd, relocation,
1874 htab->elf.sgot->contents + off);
1879 unresolved_reloc = FALSE;
1883 BFD_ASSERT (local_got_offsets != NULL
1884 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1886 off = local_got_offsets[r_symndx];
1888 /* The offset must always be a multiple of the word size.
1889 So, we can use the least significant bit to record
1890 whether we have already processed this entry. */
1895 if (bfd_link_pic (info))
1898 Elf_Internal_Rela outrel;
1900 /* We need to generate a R_RISCV_RELATIVE reloc
1901 for the dynamic linker. */
1902 s = htab->elf.srelgot;
1903 BFD_ASSERT (s != NULL);
1905 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1907 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1908 outrel.r_addend = relocation;
1910 riscv_elf_append_rela (output_bfd, s, &outrel);
1913 bfd_put_NN (output_bfd, relocation,
1914 htab->elf.sgot->contents + off);
1915 local_got_offsets[r_symndx] |= 1;
1918 relocation = sec_addr (htab->elf.sgot) + off;
1919 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
1920 r = bfd_reloc_overflow;
1928 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1929 contents + rel->r_offset);
1930 relocation = old_value + relocation;
1940 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1941 contents + rel->r_offset);
1942 relocation = old_value - relocation;
1946 case R_RISCV_CALL_PLT:
1949 case R_RISCV_RVC_JUMP:
1950 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1952 /* Refer to the PLT entry. */
1953 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1954 unresolved_reloc = FALSE;
1958 case R_RISCV_TPREL_HI20:
1959 relocation = tpoff (info, relocation);
1962 case R_RISCV_TPREL_LO12_I:
1963 case R_RISCV_TPREL_LO12_S:
1964 relocation = tpoff (info, relocation);
1967 case R_RISCV_TPREL_I:
1968 case R_RISCV_TPREL_S:
1969 relocation = tpoff (info, relocation);
1970 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
1972 /* We can use tp as the base register. */
1973 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1974 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1975 insn |= X_TP << OP_SH_RS1;
1976 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1979 r = bfd_reloc_overflow;
1982 case R_RISCV_GPREL_I:
1983 case R_RISCV_GPREL_S:
1985 bfd_vma gp = riscv_global_pointer_value (info);
1986 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
1987 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
1989 /* We can use x0 or gp as the base register. */
1990 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1991 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1994 rel->r_addend -= gp;
1995 insn |= X_GP << OP_SH_RS1;
1997 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2000 r = bfd_reloc_overflow;
2004 case R_RISCV_PCREL_HI20:
2005 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2006 relocation + rel->r_addend))
2007 r = bfd_reloc_overflow;
2010 case R_RISCV_PCREL_LO12_I:
2011 case R_RISCV_PCREL_LO12_S:
2012 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2013 howto, rel, relocation, name,
2016 r = bfd_reloc_overflow;
2019 case R_RISCV_TLS_DTPREL32:
2020 case R_RISCV_TLS_DTPREL64:
2021 relocation = dtpoff (info, relocation);
2026 if ((input_section->flags & SEC_ALLOC) == 0)
2029 if ((bfd_link_pic (info)
2031 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2032 || h->root.type != bfd_link_hash_undefweak)
2033 && (! howto->pc_relative
2034 || !SYMBOL_CALLS_LOCAL (info, h)))
2035 || (!bfd_link_pic (info)
2041 || h->root.type == bfd_link_hash_undefweak
2042 || h->root.type == bfd_link_hash_undefined)))
2044 Elf_Internal_Rela outrel;
2045 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2047 /* When generating a shared object, these relocations
2048 are copied into the output file to be resolved at run
2052 _bfd_elf_section_offset (output_bfd, info, input_section,
2054 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2055 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2056 outrel.r_offset += sec_addr (input_section);
2058 if (skip_dynamic_relocation)
2059 memset (&outrel, 0, sizeof outrel);
2060 else if (h != NULL && h->dynindx != -1
2061 && !(bfd_link_pic (info)
2062 && SYMBOLIC_BIND (info, h)
2065 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2066 outrel.r_addend = rel->r_addend;
2070 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2071 outrel.r_addend = relocation + rel->r_addend;
2074 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2075 if (skip_static_relocation)
2080 case R_RISCV_TLS_GOT_HI20:
2084 case R_RISCV_TLS_GD_HI20:
2087 off = h->got.offset;
2092 off = local_got_offsets[r_symndx];
2093 local_got_offsets[r_symndx] |= 1;
2096 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2097 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2098 /* If this symbol is referenced by both GD and IE TLS, the IE
2099 reference's GOT slot follows the GD reference's slots. */
2101 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2102 ie_off = 2 * GOT_ENTRY_SIZE;
2108 Elf_Internal_Rela outrel;
2110 bfd_boolean need_relocs = FALSE;
2112 if (htab->elf.srelgot == NULL)
2117 bfd_boolean dyn, pic;
2118 dyn = htab->elf.dynamic_sections_created;
2119 pic = bfd_link_pic (info);
2121 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2122 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2126 /* The GOT entries have not been initialized yet. Do it
2127 now, and emit any relocations. */
2128 if ((bfd_link_pic (info) || indx != 0)
2130 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2131 || h->root.type != bfd_link_hash_undefweak))
2134 if (tls_type & GOT_TLS_GD)
2138 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2139 outrel.r_addend = 0;
2140 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2141 bfd_put_NN (output_bfd, 0,
2142 htab->elf.sgot->contents + off);
2143 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2146 BFD_ASSERT (! unresolved_reloc);
2147 bfd_put_NN (output_bfd,
2148 dtpoff (info, relocation),
2149 (htab->elf.sgot->contents + off +
2150 RISCV_ELF_WORD_BYTES));
2154 bfd_put_NN (output_bfd, 0,
2155 (htab->elf.sgot->contents + off +
2156 RISCV_ELF_WORD_BYTES));
2157 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2158 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2159 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2164 /* If we are not emitting relocations for a
2165 general dynamic reference, then we must be in a
2166 static link or an executable link with the
2167 symbol binding locally. Mark it as belonging
2168 to module 1, the executable. */
2169 bfd_put_NN (output_bfd, 1,
2170 htab->elf.sgot->contents + off);
2171 bfd_put_NN (output_bfd,
2172 dtpoff (info, relocation),
2173 (htab->elf.sgot->contents + off +
2174 RISCV_ELF_WORD_BYTES));
2178 if (tls_type & GOT_TLS_IE)
2182 bfd_put_NN (output_bfd, 0,
2183 htab->elf.sgot->contents + off + ie_off);
2184 outrel.r_offset = sec_addr (htab->elf.sgot)
2186 outrel.r_addend = 0;
2188 outrel.r_addend = tpoff (info, relocation);
2189 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2190 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2194 bfd_put_NN (output_bfd, tpoff (info, relocation),
2195 htab->elf.sgot->contents + off + ie_off);
2200 BFD_ASSERT (off < (bfd_vma) -2);
2201 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2202 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
2203 r = bfd_reloc_overflow;
2204 unresolved_reloc = FALSE;
2208 r = bfd_reloc_notsupported;
2211 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2212 because such sections are not SEC_ALLOC and thus ld.so will
2213 not process them. */
2214 if (unresolved_reloc
2215 && !((input_section->flags & SEC_DEBUGGING) != 0
2217 && _bfd_elf_section_offset (output_bfd, info, input_section,
2218 rel->r_offset) != (bfd_vma) -1)
2220 (*_bfd_error_handler)
2221 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2224 (long) rel->r_offset,
2226 h->root.root.string);
2230 if (r == bfd_reloc_ok)
2231 r = perform_relocation (howto, rel, relocation, input_section,
2232 input_bfd, contents);
2239 case bfd_reloc_overflow:
2240 info->callbacks->reloc_overflow
2241 (info, (h ? &h->root : NULL), name, howto->name,
2242 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2245 case bfd_reloc_undefined:
2246 info->callbacks->undefined_symbol
2247 (info, name, input_bfd, input_section, rel->r_offset,
2251 case bfd_reloc_outofrange:
2252 msg = _("internal error: out of range error");
2255 case bfd_reloc_notsupported:
2256 msg = _("internal error: unsupported relocation error");
2259 case bfd_reloc_dangerous:
2260 msg = _("internal error: dangerous relocation");
2264 msg = _("internal error: unknown error");
2269 info->callbacks->warning
2270 (info, msg, name, input_bfd, input_section, rel->r_offset);
2274 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2276 riscv_free_pcrel_relocs (&pcrel_relocs);
2280 /* Finish up dynamic symbol handling. We set the contents of various
2281 dynamic sections here. */
2284 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2285 struct bfd_link_info *info,
2286 struct elf_link_hash_entry *h,
2287 Elf_Internal_Sym *sym)
2289 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2290 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2292 if (h->plt.offset != (bfd_vma) -1)
2294 /* We've decided to create a PLT entry for this symbol. */
2296 bfd_vma i, header_address, plt_idx, got_address;
2297 uint32_t plt_entry[PLT_ENTRY_INSNS];
2298 Elf_Internal_Rela rela;
2300 BFD_ASSERT (h->dynindx != -1);
2302 /* Calculate the address of the PLT header. */
2303 header_address = sec_addr (htab->elf.splt);
2305 /* Calculate the index of the entry. */
2306 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2308 /* Calculate the address of the .got.plt entry. */
2309 got_address = riscv_elf_got_plt_val (plt_idx, info);
2311 /* Find out where the .plt entry should go. */
2312 loc = htab->elf.splt->contents + h->plt.offset;
2314 /* Fill in the PLT entry itself. */
2315 riscv_make_plt_entry (got_address, header_address + h->plt.offset,
2317 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2318 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2320 /* Fill in the initial value of the .got.plt entry. */
2321 loc = htab->elf.sgotplt->contents
2322 + (got_address - sec_addr (htab->elf.sgotplt));
2323 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2325 /* Fill in the entry in the .rela.plt section. */
2326 rela.r_offset = got_address;
2328 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2330 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2331 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2333 if (!h->def_regular)
2335 /* Mark the symbol as undefined, rather than as defined in
2336 the .plt section. Leave the value alone. */
2337 sym->st_shndx = SHN_UNDEF;
2338 /* If the symbol is weak, we do need to clear the value.
2339 Otherwise, the PLT entry would provide a definition for
2340 the symbol even if the symbol wasn't defined anywhere,
2341 and so the symbol would never be NULL. */
2342 if (!h->ref_regular_nonweak)
2347 if (h->got.offset != (bfd_vma) -1
2348 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
2352 Elf_Internal_Rela rela;
2354 /* This symbol has an entry in the GOT. Set it up. */
2356 sgot = htab->elf.sgot;
2357 srela = htab->elf.srelgot;
2358 BFD_ASSERT (sgot != NULL && srela != NULL);
2360 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2362 /* If this is a -Bsymbolic link, and the symbol is defined
2363 locally, we just want to emit a RELATIVE reloc. Likewise if
2364 the symbol was forced to be local because of a version file.
2365 The entry in the global offset table will already have been
2366 initialized in the relocate_section function. */
2367 if (bfd_link_pic (info)
2368 && (info->symbolic || h->dynindx == -1)
2371 asection *sec = h->root.u.def.section;
2372 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2373 rela.r_addend = (h->root.u.def.value
2374 + sec->output_section->vma
2375 + sec->output_offset);
2379 BFD_ASSERT (h->dynindx != -1);
2380 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2384 bfd_put_NN (output_bfd, 0,
2385 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2386 riscv_elf_append_rela (output_bfd, srela, &rela);
2391 Elf_Internal_Rela rela;
2393 /* This symbols needs a copy reloc. Set it up. */
2394 BFD_ASSERT (h->dynindx != -1);
2396 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2397 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2399 riscv_elf_append_rela (output_bfd, htab->elf.srelbss, &rela);
2402 /* Mark some specially defined symbols as absolute. */
2403 if (h == htab->elf.hdynamic
2404 || (h == htab->elf.hgot || h == htab->elf.hplt))
2405 sym->st_shndx = SHN_ABS;
2410 /* Finish up the dynamic sections. */
2413 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2414 bfd *dynobj, asection *sdyn)
2416 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2417 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2418 size_t dynsize = bed->s->sizeof_dyn;
2419 bfd_byte *dyncon, *dynconend;
2421 dynconend = sdyn->contents + sdyn->size;
2422 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2424 Elf_Internal_Dyn dyn;
2427 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2432 s = htab->elf.sgotplt;
2433 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2436 s = htab->elf.srelplt;
2437 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2440 s = htab->elf.srelplt;
2441 dyn.d_un.d_val = s->size;
2447 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2453 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2454 struct bfd_link_info *info)
2458 struct riscv_elf_link_hash_table *htab;
2460 htab = riscv_elf_hash_table (info);
2461 BFD_ASSERT (htab != NULL);
2462 dynobj = htab->elf.dynobj;
2464 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2466 if (elf_hash_table (info)->dynamic_sections_created)
2471 splt = htab->elf.splt;
2472 BFD_ASSERT (splt != NULL && sdyn != NULL);
2474 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2479 /* Fill in the head and tail entries in the procedure linkage table. */
2483 uint32_t plt_header[PLT_HEADER_INSNS];
2484 riscv_make_plt_header (sec_addr (htab->elf.sgotplt),
2485 sec_addr (splt), plt_header);
2487 for (i = 0; i < PLT_HEADER_INSNS; i++)
2488 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2491 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2495 if (htab->elf.sgotplt)
2497 asection *output_section = htab->elf.sgotplt->output_section;
2499 if (bfd_is_abs_section (output_section))
2501 (*_bfd_error_handler)
2502 (_("discarded output section: `%A'"), htab->elf.sgotplt);
2506 if (htab->elf.sgotplt->size > 0)
2508 /* Write the first two entries in .got.plt, needed for the dynamic
2510 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2511 bfd_put_NN (output_bfd, (bfd_vma) 0,
2512 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2515 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2520 asection *output_section = htab->elf.sgot->output_section;
2522 if (htab->elf.sgot->size > 0)
2524 /* Set the first entry in the global offset table to the address of
2525 the dynamic section. */
2526 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2527 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2530 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2536 /* Return address for Ith PLT stub in section PLT, for relocation REL
2537 or (bfd_vma) -1 if it should not be included. */
2540 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2541 const arelent *rel ATTRIBUTE_UNUSED)
2543 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2546 static enum elf_reloc_type_class
2547 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2548 const asection *rel_sec ATTRIBUTE_UNUSED,
2549 const Elf_Internal_Rela *rela)
2551 switch (ELFNN_R_TYPE (rela->r_info))
2553 case R_RISCV_RELATIVE:
2554 return reloc_class_relative;
2555 case R_RISCV_JUMP_SLOT:
2556 return reloc_class_plt;
2558 return reloc_class_copy;
2560 return reloc_class_normal;
2564 /* Merge backend specific data from an object file to the output
2565 object file when linking. */
2568 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2570 bfd *obfd = info->output_bfd;
2571 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2572 flagword old_flags = elf_elfheader (obfd)->e_flags;
2574 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2577 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2579 (*_bfd_error_handler)
2580 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2581 " target emulation `%s' does not match `%s'"),
2582 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
2586 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2589 if (! elf_flags_init (obfd))
2591 elf_flags_init (obfd) = TRUE;
2592 elf_elfheader (obfd)->e_flags = new_flags;
2596 /* Disallow linking different float ABIs. */
2597 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
2599 (*_bfd_error_handler)
2600 (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
2604 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2605 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2610 bfd_set_error (bfd_error_bad_value);
2614 /* Delete some bytes from a section while relaxing. */
2617 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count)
2619 unsigned int i, symcount;
2620 bfd_vma toaddr = sec->size;
2621 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2622 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2623 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2624 struct bfd_elf_section_data *data = elf_section_data (sec);
2625 bfd_byte *contents = data->this_hdr.contents;
2627 /* Actually delete the bytes. */
2629 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2631 /* Adjust the location of all of the relocs. Note that we need not
2632 adjust the addends, since all PC-relative references must be against
2633 symbols, which we will adjust below. */
2634 for (i = 0; i < sec->reloc_count; i++)
2635 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2636 data->relocs[i].r_offset -= count;
2638 /* Adjust the local symbols defined in this section. */
2639 for (i = 0; i < symtab_hdr->sh_info; i++)
2641 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2642 if (sym->st_shndx == sec_shndx)
2644 /* If the symbol is in the range of memory we just moved, we
2645 have to adjust its value. */
2646 if (sym->st_value > addr && sym->st_value <= toaddr)
2647 sym->st_value -= count;
2649 /* If the symbol *spans* the bytes we just deleted (i.e. its
2650 *end* is in the moved bytes but its *start* isn't), then we
2651 must adjust its size. */
2652 if (sym->st_value <= addr
2653 && sym->st_value + sym->st_size > addr
2654 && sym->st_value + sym->st_size <= toaddr)
2655 sym->st_size -= count;
2659 /* Now adjust the global symbols defined in this section. */
2660 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2661 - symtab_hdr->sh_info);
2663 for (i = 0; i < symcount; i++)
2665 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2667 if ((sym_hash->root.type == bfd_link_hash_defined
2668 || sym_hash->root.type == bfd_link_hash_defweak)
2669 && sym_hash->root.u.def.section == sec)
2671 /* As above, adjust the value if needed. */
2672 if (sym_hash->root.u.def.value > addr
2673 && sym_hash->root.u.def.value <= toaddr)
2674 sym_hash->root.u.def.value -= count;
2676 /* As above, adjust the size if needed. */
2677 if (sym_hash->root.u.def.value <= addr
2678 && sym_hash->root.u.def.value + sym_hash->size > addr
2679 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2680 sym_hash->size -= count;
2687 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
2688 struct bfd_link_info *,
2689 Elf_Internal_Rela *,
2690 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *);
2692 /* Relax AUIPC + JALR into JAL. */
2695 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2696 struct bfd_link_info *link_info,
2697 Elf_Internal_Rela *rel,
2699 bfd_vma max_alignment,
2700 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2703 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2704 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2705 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2706 bfd_vma auipc, jalr;
2707 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2709 /* If the call crosses section boundaries, an alignment directive could
2710 cause the PC-relative offset to later increase. */
2711 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2712 foff += (foff < 0 ? -max_alignment : max_alignment);
2714 /* See if this function call can be shortened. */
2715 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2718 /* Shorten the function call. */
2719 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2721 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2722 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2723 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2724 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2726 if (rvc && (rd == 0 || rd == X_RA))
2728 /* Relax to C.J[AL] rd, addr. */
2729 r_type = R_RISCV_RVC_JUMP;
2730 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2733 else if (VALID_UJTYPE_IMM (foff))
2735 /* Relax to JAL rd, addr. */
2736 r_type = R_RISCV_JAL;
2737 auipc = MATCH_JAL | (rd << OP_SH_RD);
2739 else /* near_zero */
2741 /* Relax to JALR rd, x0, addr. */
2742 r_type = R_RISCV_LO12_I;
2743 auipc = MATCH_JALR | (rd << OP_SH_RD);
2746 /* Replace the R_RISCV_CALL reloc. */
2747 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
2748 /* Replace the AUIPC. */
2749 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
2751 /* Delete unnecessary JALR. */
2753 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len);
2756 /* Traverse all output sections and return the max alignment. */
2759 _bfd_riscv_get_max_alignment (asection *sec)
2761 unsigned int max_alignment_power = 0;
2764 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
2766 if (o->alignment_power > max_alignment_power)
2767 max_alignment_power = o->alignment_power;
2770 return (bfd_vma) 1 << max_alignment_power;
2773 /* Relax non-PIC global variable references. */
2776 _bfd_riscv_relax_lui (bfd *abfd,
2779 struct bfd_link_info *link_info,
2780 Elf_Internal_Rela *rel,
2782 bfd_vma max_alignment,
2783 bfd_vma reserve_size,
2786 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2787 bfd_vma gp = riscv_global_pointer_value (link_info);
2788 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2790 /* Mergeable symbols and code might later move out of range. */
2791 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
2794 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2796 /* Is the reference in range of x0 or gp?
2797 Valid gp range conservatively because of alignment issue. */
2798 if (VALID_ITYPE_IMM (symval)
2800 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
2802 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
2804 unsigned sym = ELFNN_R_SYM (rel->r_info);
2805 switch (ELFNN_R_TYPE (rel->r_info))
2807 case R_RISCV_LO12_I:
2808 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2811 case R_RISCV_LO12_S:
2812 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2816 /* We can delete the unnecessary LUI and reloc. */
2817 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2819 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2826 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2827 account for this assuming page alignment at worst. */
2829 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2830 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2831 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2833 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */
2834 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2835 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2838 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2839 bfd_put_32 (abfd, lui, contents + rel->r_offset);
2841 /* Replace the R_RISCV_HI20 reloc. */
2842 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2845 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2851 /* Relax non-PIC TLS references. */
2854 _bfd_riscv_relax_tls_le (bfd *abfd,
2856 asection *sym_sec ATTRIBUTE_UNUSED,
2857 struct bfd_link_info *link_info,
2858 Elf_Internal_Rela *rel,
2860 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2861 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2864 /* See if this symbol is in range of tp. */
2865 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2868 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2869 switch (ELFNN_R_TYPE (rel->r_info))
2871 case R_RISCV_TPREL_LO12_I:
2872 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
2875 case R_RISCV_TPREL_LO12_S:
2876 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
2879 case R_RISCV_TPREL_HI20:
2880 case R_RISCV_TPREL_ADD:
2881 /* We can delete the unnecessary instruction and reloc. */
2882 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2884 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2891 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
2894 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
2895 asection *sym_sec ATTRIBUTE_UNUSED,
2896 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2897 Elf_Internal_Rela *rel,
2899 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2900 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2901 bfd_boolean *again ATTRIBUTE_UNUSED)
2903 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2904 bfd_vma alignment = 1, pos;
2905 while (alignment <= rel->r_addend)
2908 symval -= rel->r_addend;
2909 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
2910 bfd_vma nop_bytes = aligned_addr - symval;
2912 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
2913 sec->sec_flg0 = TRUE;
2915 /* Make sure there are enough NOPs to actually achieve the alignment. */
2916 if (rel->r_addend < nop_bytes)
2919 /* Delete the reloc. */
2920 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2922 /* If the number of NOPs is already correct, there's nothing to do. */
2923 if (nop_bytes == rel->r_addend)
2926 /* Write as many RISC-V NOPs as we need. */
2927 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
2928 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
2930 /* Write a final RVC NOP if need be. */
2931 if (nop_bytes % 4 != 0)
2932 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
2934 /* Delete the excess bytes. */
2935 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
2936 rel->r_addend - nop_bytes);
2939 /* Relax a section. Pass 0 shortens code sequences unless disabled.
2940 Pass 1, which cannot be disabled, handles code alignment directives. */
2943 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
2944 struct bfd_link_info *info,
2947 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
2948 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2949 struct bfd_elf_section_data *data = elf_section_data (sec);
2950 Elf_Internal_Rela *relocs;
2951 bfd_boolean ret = FALSE;
2953 bfd_vma max_alignment, reserve_size = 0;
2957 if (bfd_link_relocatable (info)
2959 || (sec->flags & SEC_RELOC) == 0
2960 || sec->reloc_count == 0
2961 || (info->disable_target_specific_optimizations
2962 && info->relax_pass == 0))
2965 /* Read this BFD's relocs if we haven't done so already. */
2967 relocs = data->relocs;
2968 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2969 info->keep_memory)))
2972 max_alignment = _bfd_riscv_get_max_alignment (sec);
2974 /* Examine and consider relaxing each reloc. */
2975 for (i = 0; i < sec->reloc_count; i++)
2978 Elf_Internal_Rela *rel = relocs + i;
2979 relax_func_t relax_func;
2980 int type = ELFNN_R_TYPE (rel->r_info);
2983 if (info->relax_pass == 0)
2985 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
2986 relax_func = _bfd_riscv_relax_call;
2987 else if (type == R_RISCV_HI20
2988 || type == R_RISCV_LO12_I
2989 || type == R_RISCV_LO12_S)
2990 relax_func = _bfd_riscv_relax_lui;
2991 else if (type == R_RISCV_TPREL_HI20
2992 || type == R_RISCV_TPREL_ADD
2993 || type == R_RISCV_TPREL_LO12_I
2994 || type == R_RISCV_TPREL_LO12_S)
2995 relax_func = _bfd_riscv_relax_tls_le;
2999 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3000 if (i == sec->reloc_count - 1
3001 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3002 || rel->r_offset != (rel + 1)->r_offset)
3005 /* Skip over the R_RISCV_RELAX. */
3008 else if (type == R_RISCV_ALIGN)
3009 relax_func = _bfd_riscv_relax_align;
3013 data->relocs = relocs;
3015 /* Read this BFD's contents if we haven't done so already. */
3016 if (!data->this_hdr.contents
3017 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3020 /* Read this BFD's symbols if we haven't done so already. */
3021 if (symtab_hdr->sh_info != 0
3022 && !symtab_hdr->contents
3023 && !(symtab_hdr->contents =
3024 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3025 symtab_hdr->sh_info,
3026 0, NULL, NULL, NULL)))
3029 /* Get the value of the symbol referred to by the reloc. */
3030 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3032 /* A local symbol. */
3033 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3034 + ELFNN_R_SYM (rel->r_info));
3035 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3036 ? 0 : isym->st_size - rel->r_addend;
3038 if (isym->st_shndx == SHN_UNDEF)
3039 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3042 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3043 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3044 if (sec_addr (sym_sec) == 0)
3046 symval = sec_addr (sym_sec) + isym->st_value;
3052 struct elf_link_hash_entry *h;
3054 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3055 h = elf_sym_hashes (abfd)[indx];
3057 while (h->root.type == bfd_link_hash_indirect
3058 || h->root.type == bfd_link_hash_warning)
3059 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3061 if (h->plt.offset != MINUS_ONE)
3062 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3063 else if (h->root.u.def.section->output_section == NULL
3064 || (h->root.type != bfd_link_hash_defined
3065 && h->root.type != bfd_link_hash_defweak))
3068 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3070 if (h->type != STT_FUNC)
3072 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3073 sym_sec = h->root.u.def.section;
3076 symval += rel->r_addend;
3078 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3079 max_alignment, reserve_size, again))
3086 if (relocs != data->relocs)
3093 # define PRSTATUS_SIZE 0 /* FIXME */
3094 # define PRSTATUS_OFFSET_PR_CURSIG 12
3095 # define PRSTATUS_OFFSET_PR_PID 24
3096 # define PRSTATUS_OFFSET_PR_REG 72
3097 # define ELF_GREGSET_T_SIZE 128
3098 # define PRPSINFO_SIZE 128
3099 # define PRPSINFO_OFFSET_PR_PID 16
3100 # define PRPSINFO_OFFSET_PR_FNAME 32
3101 # define PRPSINFO_OFFSET_PR_PSARGS 48
3103 # define PRSTATUS_SIZE 376
3104 # define PRSTATUS_OFFSET_PR_CURSIG 12
3105 # define PRSTATUS_OFFSET_PR_PID 32
3106 # define PRSTATUS_OFFSET_PR_REG 112
3107 # define ELF_GREGSET_T_SIZE 256
3108 # define PRPSINFO_SIZE 136
3109 # define PRPSINFO_OFFSET_PR_PID 24
3110 # define PRPSINFO_OFFSET_PR_FNAME 40
3111 # define PRPSINFO_OFFSET_PR_PSARGS 56
3114 /* Support for core dump NOTE sections. */
3117 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3119 switch (note->descsz)
3124 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3126 elf_tdata (abfd)->core->signal
3127 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3130 elf_tdata (abfd)->core->lwpid
3131 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3135 /* Make a ".reg/999" section. */
3136 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3137 note->descpos + PRSTATUS_OFFSET_PR_REG);
3141 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3143 switch (note->descsz)
3148 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3150 elf_tdata (abfd)->core->pid
3151 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3154 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3155 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3158 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3159 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3163 /* Note that for some reason, a spurious space is tacked
3164 onto the end of the args in some (at least one anyway)
3165 implementations, so strip it off if it exists. */
3168 char *command = elf_tdata (abfd)->core->command;
3169 int n = strlen (command);
3171 if (0 < n && command[n - 1] == ' ')
3172 command[n - 1] = '\0';
3179 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3180 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3182 #define elf_backend_reloc_type_class riscv_reloc_type_class
3184 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3185 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3186 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3187 #define bfd_elfNN_bfd_merge_private_bfd_data \
3188 _bfd_riscv_elf_merge_private_bfd_data
3190 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3191 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3192 #define elf_backend_check_relocs riscv_elf_check_relocs
3193 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3194 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3195 #define elf_backend_relocate_section riscv_elf_relocate_section
3196 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3197 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3198 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3199 #define elf_backend_gc_sweep_hook riscv_elf_gc_sweep_hook
3200 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3201 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3202 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3203 #define elf_info_to_howto_rel NULL
3204 #define elf_info_to_howto riscv_info_to_howto_rela
3205 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3207 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3209 #define elf_backend_can_gc_sections 1
3210 #define elf_backend_can_refcount 1
3211 #define elf_backend_want_got_plt 1
3212 #define elf_backend_plt_readonly 1
3213 #define elf_backend_plt_alignment 4
3214 #define elf_backend_want_plt_sym 1
3215 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3216 #define elf_backend_rela_normal 1
3217 #define elf_backend_default_execstack 0
3219 #include "elfNN-target.h"