1 /* RISC-V-specific support for NN-bit ELF.
2 Copyright (C) 2011-2017 Free Software Foundation, Inc.
4 Contributed by Andrew Waterman (andrew@sifive.com).
5 Based on TILE-Gx and MIPS targets.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not,
21 see <http://www.gnu.org/licenses/>. */
23 /* This file handles RISC-V ELF targets. */
31 #include "elfxx-riscv.h"
32 #include "elf/riscv.h"
33 #include "opcode/riscv.h"
37 #define MINUS_ONE ((bfd_vma)0 - 1)
39 #define RISCV_ELF_LOG_WORD_BYTES (ARCH_SIZE == 32 ? 2 : 3)
41 #define RISCV_ELF_WORD_BYTES (1 << RISCV_ELF_LOG_WORD_BYTES)
43 /* The name of the dynamic interpreter. This is put in the .interp
46 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1"
47 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1"
49 #define ELF_ARCH bfd_arch_riscv
50 #define ELF_TARGET_ID RISCV_ELF_DATA
51 #define ELF_MACHINE_CODE EM_RISCV
52 #define ELF_MAXPAGESIZE 0x1000
53 #define ELF_COMMONPAGESIZE 0x1000
55 /* The global pointer's symbol name. */
57 #define GP_NAME "__global_pointer$"
59 /* The RISC-V linker needs to keep track of the number of relocs that it
60 decides to copy as dynamic relocs in check_relocs for each symbol.
61 This is so that it can later discard them if they are found to be
62 unnecessary. We store the information in a field extending the
63 regular ELF linker hash table. */
65 struct riscv_elf_dyn_relocs
67 struct riscv_elf_dyn_relocs *next;
69 /* The input section of the reloc. */
72 /* Total number of relocs copied for the input section. */
75 /* Number of pc-relative relocs copied for the input section. */
76 bfd_size_type pc_count;
79 /* RISC-V ELF linker hash entry. */
81 struct riscv_elf_link_hash_entry
83 struct elf_link_hash_entry elf;
85 /* Track dynamic relocs copied for this symbol. */
86 struct riscv_elf_dyn_relocs *dyn_relocs;
96 #define riscv_elf_hash_entry(ent) \
97 ((struct riscv_elf_link_hash_entry *)(ent))
99 struct _bfd_riscv_elf_obj_tdata
101 struct elf_obj_tdata root;
103 /* tls_type for each local got entry. */
104 char *local_got_tls_type;
107 #define _bfd_riscv_elf_tdata(abfd) \
108 ((struct _bfd_riscv_elf_obj_tdata *) (abfd)->tdata.any)
110 #define _bfd_riscv_elf_local_got_tls_type(abfd) \
111 (_bfd_riscv_elf_tdata (abfd)->local_got_tls_type)
113 #define _bfd_riscv_elf_tls_type(abfd, h, symndx) \
114 (*((h) != NULL ? &riscv_elf_hash_entry (h)->tls_type \
115 : &_bfd_riscv_elf_local_got_tls_type (abfd) [symndx]))
117 #define is_riscv_elf(bfd) \
118 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
119 && elf_tdata (bfd) != NULL \
120 && elf_object_id (bfd) == RISCV_ELF_DATA)
122 #include "elf/common.h"
123 #include "elf/internal.h"
125 struct riscv_elf_link_hash_table
127 struct elf_link_hash_table elf;
129 /* Short-cuts to get to dynamic linker sections. */
132 /* Small local sym to section mapping cache. */
133 struct sym_cache sym_cache;
137 /* Get the RISC-V ELF linker hash table from a link_info structure. */
138 #define riscv_elf_hash_table(p) \
139 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
140 == RISCV_ELF_DATA ? ((struct riscv_elf_link_hash_table *) ((p)->hash)) : NULL)
143 riscv_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
145 Elf_Internal_Rela *dst)
147 cache_ptr->howto = riscv_elf_rtype_to_howto (ELFNN_R_TYPE (dst->r_info));
151 riscv_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel)
153 const struct elf_backend_data *bed;
156 bed = get_elf_backend_data (abfd);
157 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela);
158 bed->s->swap_reloca_out (abfd, rel, loc);
163 #define PLT_HEADER_INSNS 8
164 #define PLT_ENTRY_INSNS 4
165 #define PLT_HEADER_SIZE (PLT_HEADER_INSNS * 4)
166 #define PLT_ENTRY_SIZE (PLT_ENTRY_INSNS * 4)
168 #define GOT_ENTRY_SIZE RISCV_ELF_WORD_BYTES
170 #define GOTPLT_HEADER_SIZE (2 * GOT_ENTRY_SIZE)
172 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
175 riscv_elf_got_plt_val (bfd_vma plt_index, struct bfd_link_info *info)
177 return sec_addr (riscv_elf_hash_table (info)->elf.sgotplt)
178 + GOTPLT_HEADER_SIZE + (plt_index * GOT_ENTRY_SIZE);
182 # define MATCH_LREG MATCH_LW
184 # define MATCH_LREG MATCH_LD
187 /* Generate a PLT header. */
190 riscv_make_plt_header (bfd_vma gotplt_addr, bfd_vma addr, uint32_t *entry)
192 bfd_vma gotplt_offset_high = RISCV_PCREL_HIGH_PART (gotplt_addr, addr);
193 bfd_vma gotplt_offset_low = RISCV_PCREL_LOW_PART (gotplt_addr, addr);
195 /* auipc t2, %hi(.got.plt)
196 sub t1, t1, t3 # shifted .got.plt offset + hdr size + 12
197 l[w|d] t3, %lo(.got.plt)(t2) # _dl_runtime_resolve
198 addi t1, t1, -(hdr size + 12) # shifted .got.plt offset
199 addi t0, t2, %lo(.got.plt) # &.got.plt
200 srli t1, t1, log2(16/PTRSIZE) # .got.plt offset
201 l[w|d] t0, PTRSIZE(t0) # link map
204 entry[0] = RISCV_UTYPE (AUIPC, X_T2, gotplt_offset_high);
205 entry[1] = RISCV_RTYPE (SUB, X_T1, X_T1, X_T3);
206 entry[2] = RISCV_ITYPE (LREG, X_T3, X_T2, gotplt_offset_low);
207 entry[3] = RISCV_ITYPE (ADDI, X_T1, X_T1, -(PLT_HEADER_SIZE + 12));
208 entry[4] = RISCV_ITYPE (ADDI, X_T0, X_T2, gotplt_offset_low);
209 entry[5] = RISCV_ITYPE (SRLI, X_T1, X_T1, 4 - RISCV_ELF_LOG_WORD_BYTES);
210 entry[6] = RISCV_ITYPE (LREG, X_T0, X_T0, RISCV_ELF_WORD_BYTES);
211 entry[7] = RISCV_ITYPE (JALR, 0, X_T3, 0);
214 /* Generate a PLT entry. */
217 riscv_make_plt_entry (bfd_vma got, bfd_vma addr, uint32_t *entry)
219 /* auipc t3, %hi(.got.plt entry)
220 l[w|d] t3, %lo(.got.plt entry)(t3)
224 entry[0] = RISCV_UTYPE (AUIPC, X_T3, RISCV_PCREL_HIGH_PART (got, addr));
225 entry[1] = RISCV_ITYPE (LREG, X_T3, X_T3, RISCV_PCREL_LOW_PART (got, addr));
226 entry[2] = RISCV_ITYPE (JALR, X_T1, X_T3, 0);
227 entry[3] = RISCV_NOP;
230 /* Create an entry in an RISC-V ELF linker hash table. */
232 static struct bfd_hash_entry *
233 link_hash_newfunc (struct bfd_hash_entry *entry,
234 struct bfd_hash_table *table, const char *string)
236 /* Allocate the structure if it has not already been allocated by a
241 bfd_hash_allocate (table,
242 sizeof (struct riscv_elf_link_hash_entry));
247 /* Call the allocation method of the superclass. */
248 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
251 struct riscv_elf_link_hash_entry *eh;
253 eh = (struct riscv_elf_link_hash_entry *) entry;
254 eh->dyn_relocs = NULL;
255 eh->tls_type = GOT_UNKNOWN;
261 /* Create a RISC-V ELF linker hash table. */
263 static struct bfd_link_hash_table *
264 riscv_elf_link_hash_table_create (bfd *abfd)
266 struct riscv_elf_link_hash_table *ret;
267 bfd_size_type amt = sizeof (struct riscv_elf_link_hash_table);
269 ret = (struct riscv_elf_link_hash_table *) bfd_zmalloc (amt);
273 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc,
274 sizeof (struct riscv_elf_link_hash_entry),
281 return &ret->elf.root;
284 /* Create the .got section. */
287 riscv_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
291 struct elf_link_hash_entry *h;
292 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
293 struct elf_link_hash_table *htab = elf_hash_table (info);
295 /* This function may be called more than once. */
296 if (htab->sgot != NULL)
299 flags = bed->dynamic_sec_flags;
301 s = bfd_make_section_anyway_with_flags (abfd,
302 (bed->rela_plts_and_copies_p
303 ? ".rela.got" : ".rel.got"),
304 (bed->dynamic_sec_flags
307 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
311 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
313 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
317 /* The first bit of the global offset table is the header. */
318 s->size += bed->got_header_size;
320 if (bed->want_got_plt)
322 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
324 || !bfd_set_section_alignment (abfd, s,
325 bed->s->log_file_align))
329 /* Reserve room for the header. */
330 s->size += GOTPLT_HEADER_SIZE;
333 if (bed->want_got_sym)
335 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
336 section. We don't do this in the linker script because we don't want
337 to define the symbol if we are not creating a global offset
339 h = _bfd_elf_define_linkage_sym (abfd, info, s_got,
340 "_GLOBAL_OFFSET_TABLE_");
341 elf_hash_table (info)->hgot = h;
349 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
350 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
354 riscv_elf_create_dynamic_sections (bfd *dynobj,
355 struct bfd_link_info *info)
357 struct riscv_elf_link_hash_table *htab;
359 htab = riscv_elf_hash_table (info);
360 BFD_ASSERT (htab != NULL);
362 if (!riscv_elf_create_got_section (dynobj, info))
365 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
368 if (!bfd_link_pic (info))
371 bfd_make_section_anyway_with_flags (dynobj, ".tdata.dyn",
372 SEC_ALLOC | SEC_THREAD_LOCAL);
375 if (!htab->elf.splt || !htab->elf.srelplt || !htab->elf.sdynbss
376 || (!bfd_link_pic (info) && (!htab->elf.srelbss || !htab->sdyntdata)))
382 /* Copy the extra info we tack onto an elf_link_hash_entry. */
385 riscv_elf_copy_indirect_symbol (struct bfd_link_info *info,
386 struct elf_link_hash_entry *dir,
387 struct elf_link_hash_entry *ind)
389 struct riscv_elf_link_hash_entry *edir, *eind;
391 edir = (struct riscv_elf_link_hash_entry *) dir;
392 eind = (struct riscv_elf_link_hash_entry *) ind;
394 if (eind->dyn_relocs != NULL)
396 if (edir->dyn_relocs != NULL)
398 struct riscv_elf_dyn_relocs **pp;
399 struct riscv_elf_dyn_relocs *p;
401 /* Add reloc counts against the indirect sym to the direct sym
402 list. Merge any entries against the same section. */
403 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
405 struct riscv_elf_dyn_relocs *q;
407 for (q = edir->dyn_relocs; q != NULL; q = q->next)
408 if (q->sec == p->sec)
410 q->pc_count += p->pc_count;
411 q->count += p->count;
418 *pp = edir->dyn_relocs;
421 edir->dyn_relocs = eind->dyn_relocs;
422 eind->dyn_relocs = NULL;
425 if (ind->root.type == bfd_link_hash_indirect
426 && dir->got.refcount <= 0)
428 edir->tls_type = eind->tls_type;
429 eind->tls_type = GOT_UNKNOWN;
431 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
435 riscv_elf_record_tls_type (bfd *abfd, struct elf_link_hash_entry *h,
436 unsigned long symndx, char tls_type)
438 char *new_tls_type = &_bfd_riscv_elf_tls_type (abfd, h, symndx);
440 *new_tls_type |= tls_type;
441 if ((*new_tls_type & GOT_NORMAL) && (*new_tls_type & ~GOT_NORMAL))
443 (*_bfd_error_handler)
444 (_("%B: `%s' accessed both as normal and thread local symbol"),
445 abfd, h ? h->root.root.string : "<local>");
452 riscv_elf_record_got_reference (bfd *abfd, struct bfd_link_info *info,
453 struct elf_link_hash_entry *h, long symndx)
455 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
456 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
458 if (htab->elf.sgot == NULL)
460 if (!riscv_elf_create_got_section (htab->elf.dynobj, info))
466 h->got.refcount += 1;
470 /* This is a global offset table entry for a local symbol. */
471 if (elf_local_got_refcounts (abfd) == NULL)
473 bfd_size_type size = symtab_hdr->sh_info * (sizeof (bfd_vma) + 1);
474 if (!(elf_local_got_refcounts (abfd) = bfd_zalloc (abfd, size)))
476 _bfd_riscv_elf_local_got_tls_type (abfd)
477 = (char *) (elf_local_got_refcounts (abfd) + symtab_hdr->sh_info);
479 elf_local_got_refcounts (abfd) [symndx] += 1;
485 bad_static_reloc (bfd *abfd, unsigned r_type, struct elf_link_hash_entry *h)
487 (*_bfd_error_handler)
488 (_("%B: relocation %s against `%s' can not be used when making a shared "
489 "object; recompile with -fPIC"),
490 abfd, riscv_elf_rtype_to_howto (r_type)->name,
491 h != NULL ? h->root.root.string : "a local symbol");
492 bfd_set_error (bfd_error_bad_value);
495 /* Look through the relocs for a section during the first phase, and
496 allocate space in the global offset table or procedure linkage
500 riscv_elf_check_relocs (bfd *abfd, struct bfd_link_info *info,
501 asection *sec, const Elf_Internal_Rela *relocs)
503 struct riscv_elf_link_hash_table *htab;
504 Elf_Internal_Shdr *symtab_hdr;
505 struct elf_link_hash_entry **sym_hashes;
506 const Elf_Internal_Rela *rel;
507 asection *sreloc = NULL;
509 if (bfd_link_relocatable (info))
512 htab = riscv_elf_hash_table (info);
513 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
514 sym_hashes = elf_sym_hashes (abfd);
516 if (htab->elf.dynobj == NULL)
517 htab->elf.dynobj = abfd;
519 for (rel = relocs; rel < relocs + sec->reloc_count; rel++)
522 unsigned long r_symndx;
523 struct elf_link_hash_entry *h;
525 r_symndx = ELFNN_R_SYM (rel->r_info);
526 r_type = ELFNN_R_TYPE (rel->r_info);
528 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
530 (*_bfd_error_handler) (_("%B: bad symbol index: %d"),
535 if (r_symndx < symtab_hdr->sh_info)
539 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
540 while (h->root.type == bfd_link_hash_indirect
541 || h->root.type == bfd_link_hash_warning)
542 h = (struct elf_link_hash_entry *) h->root.u.i.link;
544 /* PR15323, ref flags aren't set for references in the same
546 h->root.non_ir_ref = 1;
551 case R_RISCV_TLS_GD_HI20:
552 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
553 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_GD))
557 case R_RISCV_TLS_GOT_HI20:
558 if (bfd_link_pic (info))
559 info->flags |= DF_STATIC_TLS;
560 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
561 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_IE))
565 case R_RISCV_GOT_HI20:
566 if (!riscv_elf_record_got_reference (abfd, info, h, r_symndx)
567 || !riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_NORMAL))
571 case R_RISCV_CALL_PLT:
572 /* This symbol requires a procedure linkage table entry. We
573 actually build the entry in adjust_dynamic_symbol,
574 because this might be a case of linking PIC code without
575 linking in any dynamic objects, in which case we don't
576 need to generate a procedure linkage table after all. */
581 h->plt.refcount += 1;
588 case R_RISCV_RVC_BRANCH:
589 case R_RISCV_RVC_JUMP:
590 case R_RISCV_PCREL_HI20:
591 /* In shared libraries, these relocs are known to bind locally. */
592 if (bfd_link_pic (info))
596 case R_RISCV_TPREL_HI20:
597 if (!bfd_link_executable (info))
598 return bad_static_reloc (abfd, r_type, h);
600 riscv_elf_record_tls_type (abfd, h, r_symndx, GOT_TLS_LE);
604 if (bfd_link_pic (info))
605 return bad_static_reloc (abfd, r_type, h);
609 case R_RISCV_JUMP_SLOT:
610 case R_RISCV_RELATIVE:
616 /* This reloc might not bind locally. */
620 if (h != NULL && !bfd_link_pic (info))
622 /* We may need a .plt entry if the function this reloc
623 refers to is in a shared lib. */
624 h->plt.refcount += 1;
627 /* If we are creating a shared library, and this is a reloc
628 against a global symbol, or a non PC relative reloc
629 against a local symbol, then we need to copy the reloc
630 into the shared library. However, if we are linking with
631 -Bsymbolic, we do not need to copy a reloc against a
632 global symbol which is defined in an object we are
633 including in the link (i.e., DEF_REGULAR is set). At
634 this point we have not seen all the input files, so it is
635 possible that DEF_REGULAR is not set now but will be set
636 later (it is never cleared). In case of a weak definition,
637 DEF_REGULAR may be cleared later by a strong definition in
638 a shared library. We account for that possibility below by
639 storing information in the relocs_copied field of the hash
640 table entry. A similar situation occurs when creating
641 shared libraries and symbol visibility changes render the
644 If on the other hand, we are creating an executable, we
645 may need to keep relocations for symbols satisfied by a
646 dynamic library if we manage to avoid copy relocs for the
648 if ((bfd_link_pic (info)
649 && (sec->flags & SEC_ALLOC) != 0
650 && (! riscv_elf_rtype_to_howto (r_type)->pc_relative
653 || h->root.type == bfd_link_hash_defweak
654 || !h->def_regular))))
655 || (!bfd_link_pic (info)
656 && (sec->flags & SEC_ALLOC) != 0
658 && (h->root.type == bfd_link_hash_defweak
659 || !h->def_regular)))
661 struct riscv_elf_dyn_relocs *p;
662 struct riscv_elf_dyn_relocs **head;
664 /* When creating a shared object, we must copy these
665 relocs into the output file. We create a reloc
666 section in dynobj and make room for the reloc. */
669 sreloc = _bfd_elf_make_dynamic_reloc_section
670 (sec, htab->elf.dynobj, RISCV_ELF_LOG_WORD_BYTES,
671 abfd, /*rela?*/ TRUE);
677 /* If this is a global symbol, we count the number of
678 relocations we need for this symbol. */
680 head = &((struct riscv_elf_link_hash_entry *) h)->dyn_relocs;
683 /* Track dynamic relocs needed for local syms too.
684 We really need local syms available to do this
689 Elf_Internal_Sym *isym;
691 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
696 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
700 vpp = &elf_section_data (s)->local_dynrel;
701 head = (struct riscv_elf_dyn_relocs **) vpp;
705 if (p == NULL || p->sec != sec)
707 bfd_size_type amt = sizeof *p;
708 p = ((struct riscv_elf_dyn_relocs *)
709 bfd_alloc (htab->elf.dynobj, amt));
720 p->pc_count += riscv_elf_rtype_to_howto (r_type)->pc_relative;
725 case R_RISCV_GNU_VTINHERIT:
726 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
730 case R_RISCV_GNU_VTENTRY:
731 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
744 riscv_elf_gc_mark_hook (asection *sec,
745 struct bfd_link_info *info,
746 Elf_Internal_Rela *rel,
747 struct elf_link_hash_entry *h,
748 Elf_Internal_Sym *sym)
751 switch (ELFNN_R_TYPE (rel->r_info))
753 case R_RISCV_GNU_VTINHERIT:
754 case R_RISCV_GNU_VTENTRY:
758 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
761 /* Update the got entry reference counts for the section being removed. */
764 riscv_elf_gc_sweep_hook (bfd *abfd,
765 struct bfd_link_info *info,
767 const Elf_Internal_Rela *relocs)
769 const Elf_Internal_Rela *rel, *relend;
770 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
771 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
772 bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (abfd);
774 if (bfd_link_relocatable (info))
777 elf_section_data (sec)->local_dynrel = NULL;
779 for (rel = relocs, relend = relocs + sec->reloc_count; rel < relend; rel++)
781 unsigned long r_symndx;
782 struct elf_link_hash_entry *h = NULL;
784 r_symndx = ELFNN_R_SYM (rel->r_info);
785 if (r_symndx >= symtab_hdr->sh_info)
787 struct riscv_elf_link_hash_entry *eh;
788 struct riscv_elf_dyn_relocs **pp;
789 struct riscv_elf_dyn_relocs *p;
791 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
792 while (h->root.type == bfd_link_hash_indirect
793 || h->root.type == bfd_link_hash_warning)
794 h = (struct elf_link_hash_entry *) h->root.u.i.link;
795 eh = (struct riscv_elf_link_hash_entry *) h;
796 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
799 /* Everything must go for SEC. */
805 switch (ELFNN_R_TYPE (rel->r_info))
807 case R_RISCV_GOT_HI20:
808 case R_RISCV_TLS_GOT_HI20:
809 case R_RISCV_TLS_GD_HI20:
812 if (h->got.refcount > 0)
817 if (local_got_refcounts &&
818 local_got_refcounts[r_symndx] > 0)
819 local_got_refcounts[r_symndx]--;
824 case R_RISCV_PCREL_HI20:
826 case R_RISCV_JUMP_SLOT:
827 case R_RISCV_RELATIVE:
833 case R_RISCV_RVC_BRANCH:
834 case R_RISCV_RVC_JUMP:
835 if (bfd_link_pic (info))
839 case R_RISCV_CALL_PLT:
842 if (h->plt.refcount > 0)
855 /* Adjust a symbol defined by a dynamic object and referenced by a
856 regular object. The current definition is in some section of the
857 dynamic object, but we're not including those sections. We have to
858 change the definition to something the rest of the link can
862 riscv_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
863 struct elf_link_hash_entry *h)
865 struct riscv_elf_link_hash_table *htab;
866 struct riscv_elf_link_hash_entry * eh;
867 struct riscv_elf_dyn_relocs *p;
871 htab = riscv_elf_hash_table (info);
872 BFD_ASSERT (htab != NULL);
874 dynobj = htab->elf.dynobj;
876 /* Make sure we know what is going on here. */
877 BFD_ASSERT (dynobj != NULL
879 || h->type == STT_GNU_IFUNC
880 || h->u.weakdef != NULL
883 && !h->def_regular)));
885 /* If this is a function, put it in the procedure linkage table. We
886 will fill in the contents of the procedure linkage table later
887 (although we could actually do it here). */
888 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
890 if (h->plt.refcount <= 0
891 || SYMBOL_CALLS_LOCAL (info, h)
892 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
893 && h->root.type == bfd_link_hash_undefweak))
895 /* This case can occur if we saw a R_RISCV_CALL_PLT reloc in an
896 input file, but the symbol was never referred to by a dynamic
897 object, or if all references were garbage collected. In such
898 a case, we don't actually need to build a PLT entry. */
899 h->plt.offset = (bfd_vma) -1;
906 h->plt.offset = (bfd_vma) -1;
908 /* If this is a weak symbol, and there is a real definition, the
909 processor independent code will have arranged for us to see the
910 real definition first, and we can just use the same value. */
911 if (h->u.weakdef != NULL)
913 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
914 || h->u.weakdef->root.type == bfd_link_hash_defweak);
915 h->root.u.def.section = h->u.weakdef->root.u.def.section;
916 h->root.u.def.value = h->u.weakdef->root.u.def.value;
920 /* This is a reference to a symbol defined by a dynamic object which
921 is not a function. */
923 /* If we are creating a shared library, we must presume that the
924 only references to the symbol are via the global offset table.
925 For such cases we need not do anything here; the relocations will
926 be handled correctly by relocate_section. */
927 if (bfd_link_pic (info))
930 /* If there are no references to this symbol that do not use the
931 GOT, we don't need to generate a copy reloc. */
935 /* If -z nocopyreloc was given, we won't generate them either. */
936 if (info->nocopyreloc)
942 eh = (struct riscv_elf_link_hash_entry *) h;
943 for (p = eh->dyn_relocs; p != NULL; p = p->next)
945 s = p->sec->output_section;
946 if (s != NULL && (s->flags & SEC_READONLY) != 0)
950 /* If we didn't find any dynamic relocs in read-only sections, then
951 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
958 /* We must allocate the symbol in our .dynbss section, which will
959 become part of the .bss section of the executable. There will be
960 an entry for this symbol in the .dynsym section. The dynamic
961 object will contain position independent code, so all references
962 from the dynamic object to this symbol will go through the global
963 offset table. The dynamic linker will use the .dynsym entry to
964 determine the address it must put in the global offset table, so
965 both the dynamic object and the regular object will refer to the
966 same memory location for the variable. */
968 /* We must generate a R_RISCV_COPY reloc to tell the dynamic linker
969 to copy the initial value out of the dynamic object and into the
970 runtime process image. We need to remember the offset into the
971 .rel.bss section we are going to use. */
972 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
974 s = htab->elf.sdynrelro;
975 srel = htab->elf.sreldynrelro;
979 s = htab->elf.sdynbss;
980 srel = htab->elf.srelbss;
982 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
984 srel->size += sizeof (ElfNN_External_Rela);
988 if (eh->tls_type & ~GOT_NORMAL)
989 return _bfd_elf_adjust_dynamic_copy (info, h, htab->sdyntdata);
991 return _bfd_elf_adjust_dynamic_copy (info, h, s);
994 /* Allocate space in .plt, .got and associated reloc sections for
998 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1000 struct bfd_link_info *info;
1001 struct riscv_elf_link_hash_table *htab;
1002 struct riscv_elf_link_hash_entry *eh;
1003 struct riscv_elf_dyn_relocs *p;
1005 if (h->root.type == bfd_link_hash_indirect)
1008 info = (struct bfd_link_info *) inf;
1009 htab = riscv_elf_hash_table (info);
1010 BFD_ASSERT (htab != NULL);
1012 if (htab->elf.dynamic_sections_created
1013 && h->plt.refcount > 0)
1015 /* Make sure this symbol is output as a dynamic symbol.
1016 Undefined weak syms won't yet be marked as dynamic. */
1017 if (h->dynindx == -1
1018 && !h->forced_local)
1020 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1024 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1026 asection *s = htab->elf.splt;
1029 s->size = PLT_HEADER_SIZE;
1031 h->plt.offset = s->size;
1033 /* Make room for this entry. */
1034 s->size += PLT_ENTRY_SIZE;
1036 /* We also need to make an entry in the .got.plt section. */
1037 htab->elf.sgotplt->size += GOT_ENTRY_SIZE;
1039 /* We also need to make an entry in the .rela.plt section. */
1040 htab->elf.srelplt->size += sizeof (ElfNN_External_Rela);
1042 /* If this symbol is not defined in a regular file, and we are
1043 not generating a shared library, then set the symbol to this
1044 location in the .plt. This is required to make function
1045 pointers compare as equal between the normal executable and
1046 the shared library. */
1047 if (! bfd_link_pic (info)
1050 h->root.u.def.section = s;
1051 h->root.u.def.value = h->plt.offset;
1056 h->plt.offset = (bfd_vma) -1;
1062 h->plt.offset = (bfd_vma) -1;
1066 if (h->got.refcount > 0)
1070 int tls_type = riscv_elf_hash_entry (h)->tls_type;
1072 /* Make sure this symbol is output as a dynamic symbol.
1073 Undefined weak syms won't yet be marked as dynamic. */
1074 if (h->dynindx == -1
1075 && !h->forced_local)
1077 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1082 h->got.offset = s->size;
1083 dyn = htab->elf.dynamic_sections_created;
1084 if (tls_type & (GOT_TLS_GD | GOT_TLS_IE))
1086 /* TLS_GD needs two dynamic relocs and two GOT slots. */
1087 if (tls_type & GOT_TLS_GD)
1089 s->size += 2 * RISCV_ELF_WORD_BYTES;
1090 htab->elf.srelgot->size += 2 * sizeof (ElfNN_External_Rela);
1093 /* TLS_IE needs one dynamic reloc and one GOT slot. */
1094 if (tls_type & GOT_TLS_IE)
1096 s->size += RISCV_ELF_WORD_BYTES;
1097 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1102 s->size += RISCV_ELF_WORD_BYTES;
1103 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1104 htab->elf.srelgot->size += sizeof (ElfNN_External_Rela);
1108 h->got.offset = (bfd_vma) -1;
1110 eh = (struct riscv_elf_link_hash_entry *) h;
1111 if (eh->dyn_relocs == NULL)
1114 /* In the shared -Bsymbolic case, discard space allocated for
1115 dynamic pc-relative relocs against symbols which turn out to be
1116 defined in regular objects. For the normal shared case, discard
1117 space for pc-relative relocs that have become local due to symbol
1118 visibility changes. */
1120 if (bfd_link_pic (info))
1122 if (SYMBOL_CALLS_LOCAL (info, h))
1124 struct riscv_elf_dyn_relocs **pp;
1126 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
1128 p->count -= p->pc_count;
1137 /* Also discard relocs on undefined weak syms with non-default
1139 if (eh->dyn_relocs != NULL
1140 && h->root.type == bfd_link_hash_undefweak)
1142 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1143 eh->dyn_relocs = NULL;
1145 /* Make sure undefined weak symbols are output as a dynamic
1147 else if (h->dynindx == -1
1148 && !h->forced_local)
1150 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1157 /* For the non-shared case, discard space for relocs against
1158 symbols which turn out to need copy relocs or are not
1164 || (htab->elf.dynamic_sections_created
1165 && (h->root.type == bfd_link_hash_undefweak
1166 || h->root.type == bfd_link_hash_undefined))))
1168 /* Make sure this symbol is output as a dynamic symbol.
1169 Undefined weak syms won't yet be marked as dynamic. */
1170 if (h->dynindx == -1
1171 && !h->forced_local)
1173 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1177 /* If that succeeded, we know we'll be keeping all the
1179 if (h->dynindx != -1)
1183 eh->dyn_relocs = NULL;
1188 /* Finally, allocate space. */
1189 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1191 asection *sreloc = elf_section_data (p->sec)->sreloc;
1192 sreloc->size += p->count * sizeof (ElfNN_External_Rela);
1198 /* Find any dynamic relocs that apply to read-only sections. */
1201 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf)
1203 struct riscv_elf_link_hash_entry *eh;
1204 struct riscv_elf_dyn_relocs *p;
1206 eh = (struct riscv_elf_link_hash_entry *) h;
1207 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1209 asection *s = p->sec->output_section;
1211 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1213 ((struct bfd_link_info *) inf)->flags |= DF_TEXTREL;
1221 riscv_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1223 struct riscv_elf_link_hash_table *htab;
1228 htab = riscv_elf_hash_table (info);
1229 BFD_ASSERT (htab != NULL);
1230 dynobj = htab->elf.dynobj;
1231 BFD_ASSERT (dynobj != NULL);
1233 if (elf_hash_table (info)->dynamic_sections_created)
1235 /* Set the contents of the .interp section to the interpreter. */
1236 if (bfd_link_executable (info) && !info->nointerp)
1238 s = bfd_get_linker_section (dynobj, ".interp");
1239 BFD_ASSERT (s != NULL);
1240 s->size = strlen (ELFNN_DYNAMIC_INTERPRETER) + 1;
1241 s->contents = (unsigned char *) ELFNN_DYNAMIC_INTERPRETER;
1245 /* Set up .got offsets for local syms, and space for local dynamic
1247 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
1249 bfd_signed_vma *local_got;
1250 bfd_signed_vma *end_local_got;
1251 char *local_tls_type;
1252 bfd_size_type locsymcount;
1253 Elf_Internal_Shdr *symtab_hdr;
1256 if (! is_riscv_elf (ibfd))
1259 for (s = ibfd->sections; s != NULL; s = s->next)
1261 struct riscv_elf_dyn_relocs *p;
1263 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
1265 if (!bfd_is_abs_section (p->sec)
1266 && bfd_is_abs_section (p->sec->output_section))
1268 /* Input section has been discarded, either because
1269 it is a copy of a linkonce section or due to
1270 linker script /DISCARD/, so we'll be discarding
1273 else if (p->count != 0)
1275 srel = elf_section_data (p->sec)->sreloc;
1276 srel->size += p->count * sizeof (ElfNN_External_Rela);
1277 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
1278 info->flags |= DF_TEXTREL;
1283 local_got = elf_local_got_refcounts (ibfd);
1287 symtab_hdr = &elf_symtab_hdr (ibfd);
1288 locsymcount = symtab_hdr->sh_info;
1289 end_local_got = local_got + locsymcount;
1290 local_tls_type = _bfd_riscv_elf_local_got_tls_type (ibfd);
1292 srel = htab->elf.srelgot;
1293 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
1297 *local_got = s->size;
1298 s->size += RISCV_ELF_WORD_BYTES;
1299 if (*local_tls_type & GOT_TLS_GD)
1300 s->size += RISCV_ELF_WORD_BYTES;
1301 if (bfd_link_pic (info)
1302 || (*local_tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
1303 srel->size += sizeof (ElfNN_External_Rela);
1306 *local_got = (bfd_vma) -1;
1310 /* Allocate global sym .plt and .got entries, and space for global
1311 sym dynamic relocs. */
1312 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info);
1314 if (htab->elf.sgotplt)
1316 struct elf_link_hash_entry *got;
1317 got = elf_link_hash_lookup (elf_hash_table (info),
1318 "_GLOBAL_OFFSET_TABLE_",
1319 FALSE, FALSE, FALSE);
1321 /* Don't allocate .got.plt section if there are no GOT nor PLT
1322 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */
1324 || !got->ref_regular_nonweak)
1325 && (htab->elf.sgotplt->size == GOTPLT_HEADER_SIZE)
1326 && (htab->elf.splt == NULL
1327 || htab->elf.splt->size == 0)
1328 && (htab->elf.sgot == NULL
1329 || (htab->elf.sgot->size
1330 == get_elf_backend_data (output_bfd)->got_header_size)))
1331 htab->elf.sgotplt->size = 0;
1334 /* The check_relocs and adjust_dynamic_symbol entry points have
1335 determined the sizes of the various dynamic sections. Allocate
1337 for (s = dynobj->sections; s != NULL; s = s->next)
1339 if ((s->flags & SEC_LINKER_CREATED) == 0)
1342 if (s == htab->elf.splt
1343 || s == htab->elf.sgot
1344 || s == htab->elf.sgotplt
1345 || s == htab->elf.sdynbss
1346 || s == htab->elf.sdynrelro)
1348 /* Strip this section if we don't need it; see the
1351 else if (strncmp (s->name, ".rela", 5) == 0)
1355 /* We use the reloc_count field as a counter if we need
1356 to copy relocs into the output file. */
1362 /* It's not one of our sections. */
1368 /* If we don't need this section, strip it from the
1369 output file. This is mostly to handle .rela.bss and
1370 .rela.plt. We must create both sections in
1371 create_dynamic_sections, because they must be created
1372 before the linker maps input sections to output
1373 sections. The linker does that before
1374 adjust_dynamic_symbol is called, and it is that
1375 function which decides whether anything needs to go
1376 into these sections. */
1377 s->flags |= SEC_EXCLUDE;
1381 if ((s->flags & SEC_HAS_CONTENTS) == 0)
1384 /* Allocate memory for the section contents. Zero the memory
1385 for the benefit of .rela.plt, which has 4 unused entries
1386 at the beginning, and we don't want garbage. */
1387 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
1388 if (s->contents == NULL)
1392 if (elf_hash_table (info)->dynamic_sections_created)
1394 /* Add some entries to the .dynamic section. We fill in the
1395 values later, in riscv_elf_finish_dynamic_sections, but we
1396 must add the entries now so that we get the correct size for
1397 the .dynamic section. The DT_DEBUG entry is filled in by the
1398 dynamic linker and used by the debugger. */
1399 #define add_dynamic_entry(TAG, VAL) \
1400 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
1402 if (bfd_link_executable (info))
1404 if (!add_dynamic_entry (DT_DEBUG, 0))
1408 if (htab->elf.srelplt->size != 0)
1410 if (!add_dynamic_entry (DT_PLTGOT, 0)
1411 || !add_dynamic_entry (DT_PLTRELSZ, 0)
1412 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
1413 || !add_dynamic_entry (DT_JMPREL, 0))
1417 if (!add_dynamic_entry (DT_RELA, 0)
1418 || !add_dynamic_entry (DT_RELASZ, 0)
1419 || !add_dynamic_entry (DT_RELAENT, sizeof (ElfNN_External_Rela)))
1422 /* If any dynamic relocs apply to a read-only section,
1423 then we need a DT_TEXTREL entry. */
1424 if ((info->flags & DF_TEXTREL) == 0)
1425 elf_link_hash_traverse (&htab->elf, readonly_dynrelocs, info);
1427 if (info->flags & DF_TEXTREL)
1429 if (!add_dynamic_entry (DT_TEXTREL, 0))
1433 #undef add_dynamic_entry
1439 #define DTP_OFFSET 0x800
1441 /* Return the relocation value for a TLS dtp-relative reloc. */
1444 dtpoff (struct bfd_link_info *info, bfd_vma address)
1446 /* If tls_sec is NULL, we should have signalled an error already. */
1447 if (elf_hash_table (info)->tls_sec == NULL)
1449 return address - elf_hash_table (info)->tls_sec->vma - DTP_OFFSET;
1452 /* Return the relocation value for a static TLS tp-relative relocation. */
1455 tpoff (struct bfd_link_info *info, bfd_vma address)
1457 /* If tls_sec is NULL, we should have signalled an error already. */
1458 if (elf_hash_table (info)->tls_sec == NULL)
1460 return address - elf_hash_table (info)->tls_sec->vma - TP_OFFSET;
1463 /* Return the global pointer's value, or 0 if it is not in use. */
1466 riscv_global_pointer_value (struct bfd_link_info *info)
1468 struct bfd_link_hash_entry *h;
1470 h = bfd_link_hash_lookup (info->hash, GP_NAME, FALSE, FALSE, TRUE);
1471 if (h == NULL || h->type != bfd_link_hash_defined)
1474 return h->u.def.value + sec_addr (h->u.def.section);
1477 /* Emplace a static relocation. */
1479 static bfd_reloc_status_type
1480 perform_relocation (const reloc_howto_type *howto,
1481 const Elf_Internal_Rela *rel,
1483 asection *input_section,
1487 if (howto->pc_relative)
1488 value -= sec_addr (input_section) + rel->r_offset;
1489 value += rel->r_addend;
1491 switch (ELFNN_R_TYPE (rel->r_info))
1494 case R_RISCV_TPREL_HI20:
1495 case R_RISCV_PCREL_HI20:
1496 case R_RISCV_GOT_HI20:
1497 case R_RISCV_TLS_GOT_HI20:
1498 case R_RISCV_TLS_GD_HI20:
1499 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1500 return bfd_reloc_overflow;
1501 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value));
1504 case R_RISCV_LO12_I:
1505 case R_RISCV_GPREL_I:
1506 case R_RISCV_TPREL_LO12_I:
1507 case R_RISCV_TPREL_I:
1508 case R_RISCV_PCREL_LO12_I:
1509 value = ENCODE_ITYPE_IMM (value);
1512 case R_RISCV_LO12_S:
1513 case R_RISCV_GPREL_S:
1514 case R_RISCV_TPREL_LO12_S:
1515 case R_RISCV_TPREL_S:
1516 case R_RISCV_PCREL_LO12_S:
1517 value = ENCODE_STYPE_IMM (value);
1521 case R_RISCV_CALL_PLT:
1522 if (ARCH_SIZE > 32 && !VALID_UTYPE_IMM (RISCV_CONST_HIGH_PART (value)))
1523 return bfd_reloc_overflow;
1524 value = ENCODE_UTYPE_IMM (RISCV_CONST_HIGH_PART (value))
1525 | (ENCODE_ITYPE_IMM (value) << 32);
1529 if (!VALID_UJTYPE_IMM (value))
1530 return bfd_reloc_overflow;
1531 value = ENCODE_UJTYPE_IMM (value);
1534 case R_RISCV_BRANCH:
1535 if (!VALID_SBTYPE_IMM (value))
1536 return bfd_reloc_overflow;
1537 value = ENCODE_SBTYPE_IMM (value);
1540 case R_RISCV_RVC_BRANCH:
1541 if (!VALID_RVC_B_IMM (value))
1542 return bfd_reloc_overflow;
1543 value = ENCODE_RVC_B_IMM (value);
1546 case R_RISCV_RVC_JUMP:
1547 if (!VALID_RVC_J_IMM (value))
1548 return bfd_reloc_overflow;
1549 value = ENCODE_RVC_J_IMM (value);
1552 case R_RISCV_RVC_LUI:
1553 if (!VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value)))
1554 return bfd_reloc_overflow;
1555 value = ENCODE_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (value));
1573 case R_RISCV_TLS_DTPREL32:
1574 case R_RISCV_TLS_DTPREL64:
1578 return bfd_reloc_notsupported;
1581 bfd_vma word = bfd_get (howto->bitsize, input_bfd, contents + rel->r_offset);
1582 word = (word & ~howto->dst_mask) | (value & howto->dst_mask);
1583 bfd_put (howto->bitsize, input_bfd, word, contents + rel->r_offset);
1585 return bfd_reloc_ok;
1588 /* Remember all PC-relative high-part relocs we've encountered to help us
1589 later resolve the corresponding low-part relocs. */
1595 } riscv_pcrel_hi_reloc;
1597 typedef struct riscv_pcrel_lo_reloc
1599 asection * input_section;
1600 struct bfd_link_info * info;
1601 reloc_howto_type * howto;
1602 const Elf_Internal_Rela * reloc;
1605 bfd_byte * contents;
1606 struct riscv_pcrel_lo_reloc * next;
1607 } riscv_pcrel_lo_reloc;
1612 riscv_pcrel_lo_reloc *lo_relocs;
1613 } riscv_pcrel_relocs;
1616 riscv_pcrel_reloc_hash (const void *entry)
1618 const riscv_pcrel_hi_reloc *e = entry;
1619 return (hashval_t)(e->address >> 2);
1623 riscv_pcrel_reloc_eq (const void *entry1, const void *entry2)
1625 const riscv_pcrel_hi_reloc *e1 = entry1, *e2 = entry2;
1626 return e1->address == e2->address;
1630 riscv_init_pcrel_relocs (riscv_pcrel_relocs *p)
1633 p->lo_relocs = NULL;
1634 p->hi_relocs = htab_create (1024, riscv_pcrel_reloc_hash,
1635 riscv_pcrel_reloc_eq, free);
1636 return p->hi_relocs != NULL;
1640 riscv_free_pcrel_relocs (riscv_pcrel_relocs *p)
1642 riscv_pcrel_lo_reloc *cur = p->lo_relocs;
1646 riscv_pcrel_lo_reloc *next = cur->next;
1651 htab_delete (p->hi_relocs);
1655 riscv_record_pcrel_hi_reloc (riscv_pcrel_relocs *p, bfd_vma addr, bfd_vma value)
1657 riscv_pcrel_hi_reloc entry = {addr, value - addr};
1658 riscv_pcrel_hi_reloc **slot =
1659 (riscv_pcrel_hi_reloc **) htab_find_slot (p->hi_relocs, &entry, INSERT);
1661 BFD_ASSERT (*slot == NULL);
1662 *slot = (riscv_pcrel_hi_reloc *) bfd_malloc (sizeof (riscv_pcrel_hi_reloc));
1670 riscv_record_pcrel_lo_reloc (riscv_pcrel_relocs *p,
1671 asection *input_section,
1672 struct bfd_link_info *info,
1673 reloc_howto_type *howto,
1674 const Elf_Internal_Rela *reloc,
1679 riscv_pcrel_lo_reloc *entry;
1680 entry = (riscv_pcrel_lo_reloc *) bfd_malloc (sizeof (riscv_pcrel_lo_reloc));
1683 *entry = (riscv_pcrel_lo_reloc) {input_section, info, howto, reloc, addr,
1684 name, contents, p->lo_relocs};
1685 p->lo_relocs = entry;
1690 riscv_resolve_pcrel_lo_relocs (riscv_pcrel_relocs *p)
1692 riscv_pcrel_lo_reloc *r;
1694 for (r = p->lo_relocs; r != NULL; r = r->next)
1696 bfd *input_bfd = r->input_section->owner;
1698 riscv_pcrel_hi_reloc search = {r->addr, 0};
1699 riscv_pcrel_hi_reloc *entry = htab_find (p->hi_relocs, &search);
1702 ((*r->info->callbacks->reloc_overflow)
1703 (r->info, NULL, r->name, r->howto->name, (bfd_vma) 0,
1704 input_bfd, r->input_section, r->reloc->r_offset));
1708 perform_relocation (r->howto, r->reloc, entry->value, r->input_section,
1709 input_bfd, r->contents);
1715 /* Relocate a RISC-V ELF section.
1717 The RELOCATE_SECTION function is called by the new ELF backend linker
1718 to handle the relocations for a section.
1720 The relocs are always passed as Rela structures.
1722 This function is responsible for adjusting the section contents as
1723 necessary, and (if generating a relocatable output file) adjusting
1724 the reloc addend as necessary.
1726 This function does not have to worry about setting the reloc
1727 address or the reloc symbol index.
1729 LOCAL_SYMS is a pointer to the swapped in local symbols.
1731 LOCAL_SECTIONS is an array giving the section in the input file
1732 corresponding to the st_shndx field of each local symbol.
1734 The global hash table entry for the global symbols can be found
1735 via elf_sym_hashes (input_bfd).
1737 When generating relocatable output, this function must handle
1738 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1739 going to be the section symbol corresponding to the output
1740 section, which means that the addend must be adjusted
1744 riscv_elf_relocate_section (bfd *output_bfd,
1745 struct bfd_link_info *info,
1747 asection *input_section,
1749 Elf_Internal_Rela *relocs,
1750 Elf_Internal_Sym *local_syms,
1751 asection **local_sections)
1753 Elf_Internal_Rela *rel;
1754 Elf_Internal_Rela *relend;
1755 riscv_pcrel_relocs pcrel_relocs;
1756 bfd_boolean ret = FALSE;
1757 asection *sreloc = elf_section_data (input_section)->sreloc;
1758 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
1759 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (input_bfd);
1760 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
1761 bfd_vma *local_got_offsets = elf_local_got_offsets (input_bfd);
1763 if (!riscv_init_pcrel_relocs (&pcrel_relocs))
1766 relend = relocs + input_section->reloc_count;
1767 for (rel = relocs; rel < relend; rel++)
1769 unsigned long r_symndx;
1770 struct elf_link_hash_entry *h;
1771 Elf_Internal_Sym *sym;
1774 bfd_reloc_status_type r = bfd_reloc_ok;
1776 bfd_vma off, ie_off;
1777 bfd_boolean unresolved_reloc, is_ie = FALSE;
1778 bfd_vma pc = sec_addr (input_section) + rel->r_offset;
1779 int r_type = ELFNN_R_TYPE (rel->r_info), tls_type;
1780 reloc_howto_type *howto = riscv_elf_rtype_to_howto (r_type);
1781 const char *msg = NULL;
1783 if (r_type == R_RISCV_GNU_VTINHERIT || r_type == R_RISCV_GNU_VTENTRY)
1786 /* This is a final link. */
1787 r_symndx = ELFNN_R_SYM (rel->r_info);
1791 unresolved_reloc = FALSE;
1792 if (r_symndx < symtab_hdr->sh_info)
1794 sym = local_syms + r_symndx;
1795 sec = local_sections[r_symndx];
1796 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1800 bfd_boolean warned, ignored;
1802 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1803 r_symndx, symtab_hdr, sym_hashes,
1805 unresolved_reloc, warned, ignored);
1808 /* To avoid generating warning messages about truncated
1809 relocations, set the relocation's address to be the same as
1810 the start of this section. */
1811 if (input_section->output_section != NULL)
1812 relocation = input_section->output_section->vma;
1818 if (sec != NULL && discarded_section (sec))
1819 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1820 rel, 1, relend, howto, 0, contents);
1822 if (bfd_link_relocatable (info))
1826 name = h->root.root.string;
1829 name = (bfd_elf_string_from_elf_section
1830 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1831 if (name == NULL || *name == '\0')
1832 name = bfd_section_name (input_bfd, sec);
1839 case R_RISCV_TPREL_ADD:
1841 case R_RISCV_JUMP_SLOT:
1842 case R_RISCV_RELATIVE:
1843 /* These require nothing of us at all. */
1847 case R_RISCV_BRANCH:
1848 case R_RISCV_RVC_BRANCH:
1849 case R_RISCV_RVC_LUI:
1850 case R_RISCV_LO12_I:
1851 case R_RISCV_LO12_S:
1856 /* These require no special handling beyond perform_relocation. */
1859 case R_RISCV_GOT_HI20:
1862 bfd_boolean dyn, pic;
1864 off = h->got.offset;
1865 BFD_ASSERT (off != (bfd_vma) -1);
1866 dyn = elf_hash_table (info)->dynamic_sections_created;
1867 pic = bfd_link_pic (info);
1869 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
1870 || (pic && SYMBOL_REFERENCES_LOCAL (info, h)))
1872 /* This is actually a static link, or it is a
1873 -Bsymbolic link and the symbol is defined
1874 locally, or the symbol was forced to be local
1875 because of a version file. We must initialize
1876 this entry in the global offset table. Since the
1877 offset must always be a multiple of the word size,
1878 we use the least significant bit to record whether
1879 we have initialized it already.
1881 When doing a dynamic link, we create a .rela.got
1882 relocation entry to initialize the value. This
1883 is done in the finish_dynamic_symbol routine. */
1888 bfd_put_NN (output_bfd, relocation,
1889 htab->elf.sgot->contents + off);
1894 unresolved_reloc = FALSE;
1898 BFD_ASSERT (local_got_offsets != NULL
1899 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1901 off = local_got_offsets[r_symndx];
1903 /* The offset must always be a multiple of the word size.
1904 So, we can use the least significant bit to record
1905 whether we have already processed this entry. */
1910 if (bfd_link_pic (info))
1913 Elf_Internal_Rela outrel;
1915 /* We need to generate a R_RISCV_RELATIVE reloc
1916 for the dynamic linker. */
1917 s = htab->elf.srelgot;
1918 BFD_ASSERT (s != NULL);
1920 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
1922 ELFNN_R_INFO (0, R_RISCV_RELATIVE);
1923 outrel.r_addend = relocation;
1925 riscv_elf_append_rela (output_bfd, s, &outrel);
1928 bfd_put_NN (output_bfd, relocation,
1929 htab->elf.sgot->contents + off);
1930 local_got_offsets[r_symndx] |= 1;
1933 relocation = sec_addr (htab->elf.sgot) + off;
1934 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
1935 r = bfd_reloc_overflow;
1943 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1944 contents + rel->r_offset);
1945 relocation = old_value + relocation;
1955 bfd_vma old_value = bfd_get (howto->bitsize, input_bfd,
1956 contents + rel->r_offset);
1957 relocation = old_value - relocation;
1961 case R_RISCV_CALL_PLT:
1964 case R_RISCV_RVC_JUMP:
1965 if (bfd_link_pic (info) && h != NULL && h->plt.offset != MINUS_ONE)
1967 /* Refer to the PLT entry. */
1968 relocation = sec_addr (htab->elf.splt) + h->plt.offset;
1969 unresolved_reloc = FALSE;
1973 case R_RISCV_TPREL_HI20:
1974 relocation = tpoff (info, relocation);
1977 case R_RISCV_TPREL_LO12_I:
1978 case R_RISCV_TPREL_LO12_S:
1979 relocation = tpoff (info, relocation);
1982 case R_RISCV_TPREL_I:
1983 case R_RISCV_TPREL_S:
1984 relocation = tpoff (info, relocation);
1985 if (VALID_ITYPE_IMM (relocation + rel->r_addend))
1987 /* We can use tp as the base register. */
1988 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
1989 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
1990 insn |= X_TP << OP_SH_RS1;
1991 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
1994 r = bfd_reloc_overflow;
1997 case R_RISCV_GPREL_I:
1998 case R_RISCV_GPREL_S:
2000 bfd_vma gp = riscv_global_pointer_value (info);
2001 bfd_boolean x0_base = VALID_ITYPE_IMM (relocation + rel->r_addend);
2002 if (x0_base || VALID_ITYPE_IMM (relocation + rel->r_addend - gp))
2004 /* We can use x0 or gp as the base register. */
2005 bfd_vma insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2006 insn &= ~(OP_MASK_RS1 << OP_SH_RS1);
2009 rel->r_addend -= gp;
2010 insn |= X_GP << OP_SH_RS1;
2012 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2015 r = bfd_reloc_overflow;
2019 case R_RISCV_PCREL_HI20:
2020 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc,
2021 relocation + rel->r_addend))
2022 r = bfd_reloc_overflow;
2025 case R_RISCV_PCREL_LO12_I:
2026 case R_RISCV_PCREL_LO12_S:
2027 if (riscv_record_pcrel_lo_reloc (&pcrel_relocs, input_section, info,
2028 howto, rel, relocation, name,
2031 r = bfd_reloc_overflow;
2034 case R_RISCV_TLS_DTPREL32:
2035 case R_RISCV_TLS_DTPREL64:
2036 relocation = dtpoff (info, relocation);
2041 if ((input_section->flags & SEC_ALLOC) == 0)
2044 if ((bfd_link_pic (info)
2046 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2047 || h->root.type != bfd_link_hash_undefweak)
2048 && (! howto->pc_relative
2049 || !SYMBOL_CALLS_LOCAL (info, h)))
2050 || (!bfd_link_pic (info)
2056 || h->root.type == bfd_link_hash_undefweak
2057 || h->root.type == bfd_link_hash_undefined)))
2059 Elf_Internal_Rela outrel;
2060 bfd_boolean skip_static_relocation, skip_dynamic_relocation;
2062 /* When generating a shared object, these relocations
2063 are copied into the output file to be resolved at run
2067 _bfd_elf_section_offset (output_bfd, info, input_section,
2069 skip_static_relocation = outrel.r_offset != (bfd_vma) -2;
2070 skip_dynamic_relocation = outrel.r_offset >= (bfd_vma) -2;
2071 outrel.r_offset += sec_addr (input_section);
2073 if (skip_dynamic_relocation)
2074 memset (&outrel, 0, sizeof outrel);
2075 else if (h != NULL && h->dynindx != -1
2076 && !(bfd_link_pic (info)
2077 && SYMBOLIC_BIND (info, h)
2080 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
2081 outrel.r_addend = rel->r_addend;
2085 outrel.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2086 outrel.r_addend = relocation + rel->r_addend;
2089 riscv_elf_append_rela (output_bfd, sreloc, &outrel);
2090 if (skip_static_relocation)
2095 case R_RISCV_TLS_GOT_HI20:
2099 case R_RISCV_TLS_GD_HI20:
2102 off = h->got.offset;
2107 off = local_got_offsets[r_symndx];
2108 local_got_offsets[r_symndx] |= 1;
2111 tls_type = _bfd_riscv_elf_tls_type (input_bfd, h, r_symndx);
2112 BFD_ASSERT (tls_type & (GOT_TLS_IE | GOT_TLS_GD));
2113 /* If this symbol is referenced by both GD and IE TLS, the IE
2114 reference's GOT slot follows the GD reference's slots. */
2116 if ((tls_type & GOT_TLS_GD) && (tls_type & GOT_TLS_IE))
2117 ie_off = 2 * GOT_ENTRY_SIZE;
2123 Elf_Internal_Rela outrel;
2125 bfd_boolean need_relocs = FALSE;
2127 if (htab->elf.srelgot == NULL)
2132 bfd_boolean dyn, pic;
2133 dyn = htab->elf.dynamic_sections_created;
2134 pic = bfd_link_pic (info);
2136 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, pic, h)
2137 && (!pic || !SYMBOL_REFERENCES_LOCAL (info, h)))
2141 /* The GOT entries have not been initialized yet. Do it
2142 now, and emit any relocations. */
2143 if ((bfd_link_pic (info) || indx != 0)
2145 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2146 || h->root.type != bfd_link_hash_undefweak))
2149 if (tls_type & GOT_TLS_GD)
2153 outrel.r_offset = sec_addr (htab->elf.sgot) + off;
2154 outrel.r_addend = 0;
2155 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPMODNN);
2156 bfd_put_NN (output_bfd, 0,
2157 htab->elf.sgot->contents + off);
2158 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2161 BFD_ASSERT (! unresolved_reloc);
2162 bfd_put_NN (output_bfd,
2163 dtpoff (info, relocation),
2164 (htab->elf.sgot->contents + off +
2165 RISCV_ELF_WORD_BYTES));
2169 bfd_put_NN (output_bfd, 0,
2170 (htab->elf.sgot->contents + off +
2171 RISCV_ELF_WORD_BYTES));
2172 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_DTPRELNN);
2173 outrel.r_offset += RISCV_ELF_WORD_BYTES;
2174 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2179 /* If we are not emitting relocations for a
2180 general dynamic reference, then we must be in a
2181 static link or an executable link with the
2182 symbol binding locally. Mark it as belonging
2183 to module 1, the executable. */
2184 bfd_put_NN (output_bfd, 1,
2185 htab->elf.sgot->contents + off);
2186 bfd_put_NN (output_bfd,
2187 dtpoff (info, relocation),
2188 (htab->elf.sgot->contents + off +
2189 RISCV_ELF_WORD_BYTES));
2193 if (tls_type & GOT_TLS_IE)
2197 bfd_put_NN (output_bfd, 0,
2198 htab->elf.sgot->contents + off + ie_off);
2199 outrel.r_offset = sec_addr (htab->elf.sgot)
2201 outrel.r_addend = 0;
2203 outrel.r_addend = tpoff (info, relocation);
2204 outrel.r_info = ELFNN_R_INFO (indx, R_RISCV_TLS_TPRELNN);
2205 riscv_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel);
2209 bfd_put_NN (output_bfd, tpoff (info, relocation),
2210 htab->elf.sgot->contents + off + ie_off);
2215 BFD_ASSERT (off < (bfd_vma) -2);
2216 relocation = sec_addr (htab->elf.sgot) + off + (is_ie ? ie_off : 0);
2217 if (!riscv_record_pcrel_hi_reloc (&pcrel_relocs, pc, relocation))
2218 r = bfd_reloc_overflow;
2219 unresolved_reloc = FALSE;
2223 r = bfd_reloc_notsupported;
2226 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
2227 because such sections are not SEC_ALLOC and thus ld.so will
2228 not process them. */
2229 if (unresolved_reloc
2230 && !((input_section->flags & SEC_DEBUGGING) != 0
2232 && _bfd_elf_section_offset (output_bfd, info, input_section,
2233 rel->r_offset) != (bfd_vma) -1)
2235 (*_bfd_error_handler)
2236 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2239 (long) rel->r_offset,
2241 h->root.root.string);
2245 if (r == bfd_reloc_ok)
2246 r = perform_relocation (howto, rel, relocation, input_section,
2247 input_bfd, contents);
2254 case bfd_reloc_overflow:
2255 info->callbacks->reloc_overflow
2256 (info, (h ? &h->root : NULL), name, howto->name,
2257 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2260 case bfd_reloc_undefined:
2261 info->callbacks->undefined_symbol
2262 (info, name, input_bfd, input_section, rel->r_offset,
2266 case bfd_reloc_outofrange:
2267 msg = _("internal error: out of range error");
2270 case bfd_reloc_notsupported:
2271 msg = _("internal error: unsupported relocation error");
2274 case bfd_reloc_dangerous:
2275 msg = _("internal error: dangerous relocation");
2279 msg = _("internal error: unknown error");
2284 info->callbacks->warning
2285 (info, msg, name, input_bfd, input_section, rel->r_offset);
2289 ret = riscv_resolve_pcrel_lo_relocs (&pcrel_relocs);
2291 riscv_free_pcrel_relocs (&pcrel_relocs);
2295 /* Finish up dynamic symbol handling. We set the contents of various
2296 dynamic sections here. */
2299 riscv_elf_finish_dynamic_symbol (bfd *output_bfd,
2300 struct bfd_link_info *info,
2301 struct elf_link_hash_entry *h,
2302 Elf_Internal_Sym *sym)
2304 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2305 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2307 if (h->plt.offset != (bfd_vma) -1)
2309 /* We've decided to create a PLT entry for this symbol. */
2311 bfd_vma i, header_address, plt_idx, got_address;
2312 uint32_t plt_entry[PLT_ENTRY_INSNS];
2313 Elf_Internal_Rela rela;
2315 BFD_ASSERT (h->dynindx != -1);
2317 /* Calculate the address of the PLT header. */
2318 header_address = sec_addr (htab->elf.splt);
2320 /* Calculate the index of the entry. */
2321 plt_idx = (h->plt.offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE;
2323 /* Calculate the address of the .got.plt entry. */
2324 got_address = riscv_elf_got_plt_val (plt_idx, info);
2326 /* Find out where the .plt entry should go. */
2327 loc = htab->elf.splt->contents + h->plt.offset;
2329 /* Fill in the PLT entry itself. */
2330 riscv_make_plt_entry (got_address, header_address + h->plt.offset,
2332 for (i = 0; i < PLT_ENTRY_INSNS; i++)
2333 bfd_put_32 (output_bfd, plt_entry[i], loc + 4*i);
2335 /* Fill in the initial value of the .got.plt entry. */
2336 loc = htab->elf.sgotplt->contents
2337 + (got_address - sec_addr (htab->elf.sgotplt));
2338 bfd_put_NN (output_bfd, sec_addr (htab->elf.splt), loc);
2340 /* Fill in the entry in the .rela.plt section. */
2341 rela.r_offset = got_address;
2343 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_JUMP_SLOT);
2345 loc = htab->elf.srelplt->contents + plt_idx * sizeof (ElfNN_External_Rela);
2346 bed->s->swap_reloca_out (output_bfd, &rela, loc);
2348 if (!h->def_regular)
2350 /* Mark the symbol as undefined, rather than as defined in
2351 the .plt section. Leave the value alone. */
2352 sym->st_shndx = SHN_UNDEF;
2353 /* If the symbol is weak, we do need to clear the value.
2354 Otherwise, the PLT entry would provide a definition for
2355 the symbol even if the symbol wasn't defined anywhere,
2356 and so the symbol would never be NULL. */
2357 if (!h->ref_regular_nonweak)
2362 if (h->got.offset != (bfd_vma) -1
2363 && !(riscv_elf_hash_entry (h)->tls_type & (GOT_TLS_GD | GOT_TLS_IE)))
2367 Elf_Internal_Rela rela;
2369 /* This symbol has an entry in the GOT. Set it up. */
2371 sgot = htab->elf.sgot;
2372 srela = htab->elf.srelgot;
2373 BFD_ASSERT (sgot != NULL && srela != NULL);
2375 rela.r_offset = sec_addr (sgot) + (h->got.offset &~ (bfd_vma) 1);
2377 /* If this is a -Bsymbolic link, and the symbol is defined
2378 locally, we just want to emit a RELATIVE reloc. Likewise if
2379 the symbol was forced to be local because of a version file.
2380 The entry in the global offset table will already have been
2381 initialized in the relocate_section function. */
2382 if (bfd_link_pic (info)
2383 && (info->symbolic || h->dynindx == -1)
2386 asection *sec = h->root.u.def.section;
2387 rela.r_info = ELFNN_R_INFO (0, R_RISCV_RELATIVE);
2388 rela.r_addend = (h->root.u.def.value
2389 + sec->output_section->vma
2390 + sec->output_offset);
2394 BFD_ASSERT (h->dynindx != -1);
2395 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_NN);
2399 bfd_put_NN (output_bfd, 0,
2400 sgot->contents + (h->got.offset & ~(bfd_vma) 1));
2401 riscv_elf_append_rela (output_bfd, srela, &rela);
2406 Elf_Internal_Rela rela;
2409 /* This symbols needs a copy reloc. Set it up. */
2410 BFD_ASSERT (h->dynindx != -1);
2412 rela.r_offset = sec_addr (h->root.u.def.section) + h->root.u.def.value;
2413 rela.r_info = ELFNN_R_INFO (h->dynindx, R_RISCV_COPY);
2415 if (h->root.u.def.section == htab->elf.sdynrelro)
2416 s = htab->elf.sreldynrelro;
2418 s = htab->elf.srelbss;
2419 riscv_elf_append_rela (output_bfd, s, &rela);
2422 /* Mark some specially defined symbols as absolute. */
2423 if (h == htab->elf.hdynamic
2424 || (h == htab->elf.hgot || h == htab->elf.hplt))
2425 sym->st_shndx = SHN_ABS;
2430 /* Finish up the dynamic sections. */
2433 riscv_finish_dyn (bfd *output_bfd, struct bfd_link_info *info,
2434 bfd *dynobj, asection *sdyn)
2436 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2437 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2438 size_t dynsize = bed->s->sizeof_dyn;
2439 bfd_byte *dyncon, *dynconend;
2441 dynconend = sdyn->contents + sdyn->size;
2442 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize)
2444 Elf_Internal_Dyn dyn;
2447 bed->s->swap_dyn_in (dynobj, dyncon, &dyn);
2452 s = htab->elf.sgotplt;
2453 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2456 s = htab->elf.srelplt;
2457 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
2460 s = htab->elf.srelplt;
2461 dyn.d_un.d_val = s->size;
2467 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon);
2473 riscv_elf_finish_dynamic_sections (bfd *output_bfd,
2474 struct bfd_link_info *info)
2478 struct riscv_elf_link_hash_table *htab;
2480 htab = riscv_elf_hash_table (info);
2481 BFD_ASSERT (htab != NULL);
2482 dynobj = htab->elf.dynobj;
2484 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
2486 if (elf_hash_table (info)->dynamic_sections_created)
2491 splt = htab->elf.splt;
2492 BFD_ASSERT (splt != NULL && sdyn != NULL);
2494 ret = riscv_finish_dyn (output_bfd, info, dynobj, sdyn);
2499 /* Fill in the head and tail entries in the procedure linkage table. */
2503 uint32_t plt_header[PLT_HEADER_INSNS];
2504 riscv_make_plt_header (sec_addr (htab->elf.sgotplt),
2505 sec_addr (splt), plt_header);
2507 for (i = 0; i < PLT_HEADER_INSNS; i++)
2508 bfd_put_32 (output_bfd, plt_header[i], splt->contents + 4*i);
2510 elf_section_data (splt->output_section)->this_hdr.sh_entsize
2515 if (htab->elf.sgotplt)
2517 asection *output_section = htab->elf.sgotplt->output_section;
2519 if (bfd_is_abs_section (output_section))
2521 (*_bfd_error_handler)
2522 (_("discarded output section: `%A'"), htab->elf.sgotplt);
2526 if (htab->elf.sgotplt->size > 0)
2528 /* Write the first two entries in .got.plt, needed for the dynamic
2530 bfd_put_NN (output_bfd, (bfd_vma) -1, htab->elf.sgotplt->contents);
2531 bfd_put_NN (output_bfd, (bfd_vma) 0,
2532 htab->elf.sgotplt->contents + GOT_ENTRY_SIZE);
2535 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2540 asection *output_section = htab->elf.sgot->output_section;
2542 if (htab->elf.sgot->size > 0)
2544 /* Set the first entry in the global offset table to the address of
2545 the dynamic section. */
2546 bfd_vma val = sdyn ? sec_addr (sdyn) : 0;
2547 bfd_put_NN (output_bfd, val, htab->elf.sgot->contents);
2550 elf_section_data (output_section)->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
2556 /* Return address for Ith PLT stub in section PLT, for relocation REL
2557 or (bfd_vma) -1 if it should not be included. */
2560 riscv_elf_plt_sym_val (bfd_vma i, const asection *plt,
2561 const arelent *rel ATTRIBUTE_UNUSED)
2563 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE;
2566 static enum elf_reloc_type_class
2567 riscv_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
2568 const asection *rel_sec ATTRIBUTE_UNUSED,
2569 const Elf_Internal_Rela *rela)
2571 switch (ELFNN_R_TYPE (rela->r_info))
2573 case R_RISCV_RELATIVE:
2574 return reloc_class_relative;
2575 case R_RISCV_JUMP_SLOT:
2576 return reloc_class_plt;
2578 return reloc_class_copy;
2580 return reloc_class_normal;
2584 /* Merge backend specific data from an object file to the output
2585 object file when linking. */
2588 _bfd_riscv_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2590 bfd *obfd = info->output_bfd;
2591 flagword new_flags = elf_elfheader (ibfd)->e_flags;
2592 flagword old_flags = elf_elfheader (obfd)->e_flags;
2594 if (!is_riscv_elf (ibfd) || !is_riscv_elf (obfd))
2597 if (strcmp (bfd_get_target (ibfd), bfd_get_target (obfd)) != 0)
2599 (*_bfd_error_handler)
2600 (_("%B: ABI is incompatible with that of the selected emulation:\n"
2601 " target emulation `%s' does not match `%s'"),
2602 ibfd, bfd_get_target (ibfd), bfd_get_target (obfd));
2606 if (!_bfd_elf_merge_object_attributes (ibfd, info))
2609 if (! elf_flags_init (obfd))
2611 elf_flags_init (obfd) = TRUE;
2612 elf_elfheader (obfd)->e_flags = new_flags;
2616 /* Disallow linking different float ABIs. */
2617 if ((old_flags ^ new_flags) & EF_RISCV_FLOAT_ABI)
2619 (*_bfd_error_handler)
2620 (_("%B: can't link hard-float modules with soft-float modules"), ibfd);
2624 /* Allow linking RVC and non-RVC, and keep the RVC flag. */
2625 elf_elfheader (obfd)->e_flags |= new_flags & EF_RISCV_RVC;
2630 bfd_set_error (bfd_error_bad_value);
2634 /* Delete some bytes from a section while relaxing. */
2637 riscv_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, size_t count)
2639 unsigned int i, symcount;
2640 bfd_vma toaddr = sec->size;
2641 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (abfd);
2642 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2643 unsigned int sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2644 struct bfd_elf_section_data *data = elf_section_data (sec);
2645 bfd_byte *contents = data->this_hdr.contents;
2647 /* Actually delete the bytes. */
2649 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2651 /* Adjust the location of all of the relocs. Note that we need not
2652 adjust the addends, since all PC-relative references must be against
2653 symbols, which we will adjust below. */
2654 for (i = 0; i < sec->reloc_count; i++)
2655 if (data->relocs[i].r_offset > addr && data->relocs[i].r_offset < toaddr)
2656 data->relocs[i].r_offset -= count;
2658 /* Adjust the local symbols defined in this section. */
2659 for (i = 0; i < symtab_hdr->sh_info; i++)
2661 Elf_Internal_Sym *sym = (Elf_Internal_Sym *) symtab_hdr->contents + i;
2662 if (sym->st_shndx == sec_shndx)
2664 /* If the symbol is in the range of memory we just moved, we
2665 have to adjust its value. */
2666 if (sym->st_value > addr && sym->st_value <= toaddr)
2667 sym->st_value -= count;
2669 /* If the symbol *spans* the bytes we just deleted (i.e. its
2670 *end* is in the moved bytes but its *start* isn't), then we
2671 must adjust its size. */
2672 if (sym->st_value <= addr
2673 && sym->st_value + sym->st_size > addr
2674 && sym->st_value + sym->st_size <= toaddr)
2675 sym->st_size -= count;
2679 /* Now adjust the global symbols defined in this section. */
2680 symcount = ((symtab_hdr->sh_size / sizeof (ElfNN_External_Sym))
2681 - symtab_hdr->sh_info);
2683 for (i = 0; i < symcount; i++)
2685 struct elf_link_hash_entry *sym_hash = sym_hashes[i];
2687 if ((sym_hash->root.type == bfd_link_hash_defined
2688 || sym_hash->root.type == bfd_link_hash_defweak)
2689 && sym_hash->root.u.def.section == sec)
2691 /* As above, adjust the value if needed. */
2692 if (sym_hash->root.u.def.value > addr
2693 && sym_hash->root.u.def.value <= toaddr)
2694 sym_hash->root.u.def.value -= count;
2696 /* As above, adjust the size if needed. */
2697 if (sym_hash->root.u.def.value <= addr
2698 && sym_hash->root.u.def.value + sym_hash->size > addr
2699 && sym_hash->root.u.def.value + sym_hash->size <= toaddr)
2700 sym_hash->size -= count;
2707 typedef bfd_boolean (*relax_func_t) (bfd *, asection *, asection *,
2708 struct bfd_link_info *,
2709 Elf_Internal_Rela *,
2710 bfd_vma, bfd_vma, bfd_vma, bfd_boolean *);
2712 /* Relax AUIPC + JALR into JAL. */
2715 _bfd_riscv_relax_call (bfd *abfd, asection *sec, asection *sym_sec,
2716 struct bfd_link_info *link_info,
2717 Elf_Internal_Rela *rel,
2719 bfd_vma max_alignment,
2720 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2723 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2724 bfd_signed_vma foff = symval - (sec_addr (sec) + rel->r_offset);
2725 bfd_boolean near_zero = (symval + RISCV_IMM_REACH/2) < RISCV_IMM_REACH;
2726 bfd_vma auipc, jalr;
2727 int rd, r_type, len = 4, rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2729 /* If the call crosses section boundaries, an alignment directive could
2730 cause the PC-relative offset to later increase. */
2731 if (VALID_UJTYPE_IMM (foff) && sym_sec->output_section != sec->output_section)
2732 foff += (foff < 0 ? -max_alignment : max_alignment);
2734 /* See if this function call can be shortened. */
2735 if (!VALID_UJTYPE_IMM (foff) && !(!bfd_link_pic (link_info) && near_zero))
2738 /* Shorten the function call. */
2739 BFD_ASSERT (rel->r_offset + 8 <= sec->size);
2741 auipc = bfd_get_32 (abfd, contents + rel->r_offset);
2742 jalr = bfd_get_32 (abfd, contents + rel->r_offset + 4);
2743 rd = (jalr >> OP_SH_RD) & OP_MASK_RD;
2744 rvc = rvc && VALID_RVC_J_IMM (foff) && ARCH_SIZE == 32;
2746 if (rvc && (rd == 0 || rd == X_RA))
2748 /* Relax to C.J[AL] rd, addr. */
2749 r_type = R_RISCV_RVC_JUMP;
2750 auipc = rd == 0 ? MATCH_C_J : MATCH_C_JAL;
2753 else if (VALID_UJTYPE_IMM (foff))
2755 /* Relax to JAL rd, addr. */
2756 r_type = R_RISCV_JAL;
2757 auipc = MATCH_JAL | (rd << OP_SH_RD);
2759 else /* near_zero */
2761 /* Relax to JALR rd, x0, addr. */
2762 r_type = R_RISCV_LO12_I;
2763 auipc = MATCH_JALR | (rd << OP_SH_RD);
2766 /* Replace the R_RISCV_CALL reloc. */
2767 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), r_type);
2768 /* Replace the AUIPC. */
2769 bfd_put (8 * len, abfd, auipc, contents + rel->r_offset);
2771 /* Delete unnecessary JALR. */
2773 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + len, 8 - len);
2776 /* Traverse all output sections and return the max alignment. */
2779 _bfd_riscv_get_max_alignment (asection *sec)
2781 unsigned int max_alignment_power = 0;
2784 for (o = sec->output_section->owner->sections; o != NULL; o = o->next)
2786 if (o->alignment_power > max_alignment_power)
2787 max_alignment_power = o->alignment_power;
2790 return (bfd_vma) 1 << max_alignment_power;
2793 /* Relax non-PIC global variable references. */
2796 _bfd_riscv_relax_lui (bfd *abfd,
2799 struct bfd_link_info *link_info,
2800 Elf_Internal_Rela *rel,
2802 bfd_vma max_alignment,
2803 bfd_vma reserve_size,
2806 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2807 bfd_vma gp = riscv_global_pointer_value (link_info);
2808 int use_rvc = elf_elfheader (abfd)->e_flags & EF_RISCV_RVC;
2810 /* Mergeable symbols and code might later move out of range. */
2811 if (sym_sec->flags & (SEC_MERGE | SEC_CODE))
2814 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2818 /* If gp and the symbol are in the same output section, then
2819 consider only that section's alignment. */
2820 struct bfd_link_hash_entry *h =
2821 bfd_link_hash_lookup (link_info->hash, GP_NAME, FALSE, FALSE, TRUE);
2822 if (h->u.def.section->output_section == sym_sec->output_section)
2823 max_alignment = (bfd_vma) 1 << sym_sec->output_section->alignment_power;
2826 /* Is the reference in range of x0 or gp?
2827 Valid gp range conservatively because of alignment issue. */
2828 if (VALID_ITYPE_IMM (symval)
2830 && VALID_ITYPE_IMM (symval - gp + max_alignment + reserve_size))
2832 && VALID_ITYPE_IMM (symval - gp - max_alignment - reserve_size)))
2834 unsigned sym = ELFNN_R_SYM (rel->r_info);
2835 switch (ELFNN_R_TYPE (rel->r_info))
2837 case R_RISCV_LO12_I:
2838 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_I);
2841 case R_RISCV_LO12_S:
2842 rel->r_info = ELFNN_R_INFO (sym, R_RISCV_GPREL_S);
2846 /* We can delete the unnecessary LUI and reloc. */
2847 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2849 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2856 /* Can we relax LUI to C.LUI? Alignment might move the section forward;
2857 account for this assuming page alignment at worst. */
2859 && ELFNN_R_TYPE (rel->r_info) == R_RISCV_HI20
2860 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval))
2861 && VALID_RVC_LUI_IMM (RISCV_CONST_HIGH_PART (symval + ELF_MAXPAGESIZE)))
2863 /* Replace LUI with C.LUI if legal (i.e., rd != x2/sp). */
2864 bfd_vma lui = bfd_get_32 (abfd, contents + rel->r_offset);
2865 if (((lui >> OP_SH_RD) & OP_MASK_RD) == X_SP)
2868 lui = (lui & (OP_MASK_RD << OP_SH_RD)) | MATCH_C_LUI;
2869 bfd_put_32 (abfd, lui, contents + rel->r_offset);
2871 /* Replace the R_RISCV_HI20 reloc. */
2872 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_RVC_LUI);
2875 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + 2, 2);
2881 /* Relax non-PIC TLS references. */
2884 _bfd_riscv_relax_tls_le (bfd *abfd,
2886 asection *sym_sec ATTRIBUTE_UNUSED,
2887 struct bfd_link_info *link_info,
2888 Elf_Internal_Rela *rel,
2890 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2891 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2894 /* See if this symbol is in range of tp. */
2895 if (RISCV_CONST_HIGH_PART (tpoff (link_info, symval)) != 0)
2898 BFD_ASSERT (rel->r_offset + 4 <= sec->size);
2899 switch (ELFNN_R_TYPE (rel->r_info))
2901 case R_RISCV_TPREL_LO12_I:
2902 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_I);
2905 case R_RISCV_TPREL_LO12_S:
2906 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), R_RISCV_TPREL_S);
2909 case R_RISCV_TPREL_HI20:
2910 case R_RISCV_TPREL_ADD:
2911 /* We can delete the unnecessary instruction and reloc. */
2912 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2914 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset, 4);
2921 /* Implement R_RISCV_ALIGN by deleting excess alignment NOPs. */
2924 _bfd_riscv_relax_align (bfd *abfd, asection *sec,
2925 asection *sym_sec ATTRIBUTE_UNUSED,
2926 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
2927 Elf_Internal_Rela *rel,
2929 bfd_vma max_alignment ATTRIBUTE_UNUSED,
2930 bfd_vma reserve_size ATTRIBUTE_UNUSED,
2931 bfd_boolean *again ATTRIBUTE_UNUSED)
2933 bfd_byte *contents = elf_section_data (sec)->this_hdr.contents;
2934 bfd_vma alignment = 1, pos;
2935 while (alignment <= rel->r_addend)
2938 symval -= rel->r_addend;
2939 bfd_vma aligned_addr = ((symval - 1) & ~(alignment - 1)) + alignment;
2940 bfd_vma nop_bytes = aligned_addr - symval;
2942 /* Once we've handled an R_RISCV_ALIGN, we can't relax anything else. */
2943 sec->sec_flg0 = TRUE;
2945 /* Make sure there are enough NOPs to actually achieve the alignment. */
2946 if (rel->r_addend < nop_bytes)
2949 /* Delete the reloc. */
2950 rel->r_info = ELFNN_R_INFO (0, R_RISCV_NONE);
2952 /* If the number of NOPs is already correct, there's nothing to do. */
2953 if (nop_bytes == rel->r_addend)
2956 /* Write as many RISC-V NOPs as we need. */
2957 for (pos = 0; pos < (nop_bytes & -4); pos += 4)
2958 bfd_put_32 (abfd, RISCV_NOP, contents + rel->r_offset + pos);
2960 /* Write a final RVC NOP if need be. */
2961 if (nop_bytes % 4 != 0)
2962 bfd_put_16 (abfd, RVC_NOP, contents + rel->r_offset + pos);
2964 /* Delete the excess bytes. */
2965 return riscv_relax_delete_bytes (abfd, sec, rel->r_offset + nop_bytes,
2966 rel->r_addend - nop_bytes);
2969 /* Relax a section. Pass 0 shortens code sequences unless disabled.
2970 Pass 1, which cannot be disabled, handles code alignment directives. */
2973 _bfd_riscv_relax_section (bfd *abfd, asection *sec,
2974 struct bfd_link_info *info,
2977 Elf_Internal_Shdr *symtab_hdr = &elf_symtab_hdr (abfd);
2978 struct riscv_elf_link_hash_table *htab = riscv_elf_hash_table (info);
2979 struct bfd_elf_section_data *data = elf_section_data (sec);
2980 Elf_Internal_Rela *relocs;
2981 bfd_boolean ret = FALSE;
2983 bfd_vma max_alignment, reserve_size = 0;
2987 if (bfd_link_relocatable (info)
2989 || (sec->flags & SEC_RELOC) == 0
2990 || sec->reloc_count == 0
2991 || (info->disable_target_specific_optimizations
2992 && info->relax_pass == 0))
2995 /* Read this BFD's relocs if we haven't done so already. */
2997 relocs = data->relocs;
2998 else if (!(relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2999 info->keep_memory)))
3002 max_alignment = _bfd_riscv_get_max_alignment (sec);
3004 /* Examine and consider relaxing each reloc. */
3005 for (i = 0; i < sec->reloc_count; i++)
3008 Elf_Internal_Rela *rel = relocs + i;
3009 relax_func_t relax_func;
3010 int type = ELFNN_R_TYPE (rel->r_info);
3013 if (info->relax_pass == 0)
3015 if (type == R_RISCV_CALL || type == R_RISCV_CALL_PLT)
3016 relax_func = _bfd_riscv_relax_call;
3017 else if (type == R_RISCV_HI20
3018 || type == R_RISCV_LO12_I
3019 || type == R_RISCV_LO12_S)
3020 relax_func = _bfd_riscv_relax_lui;
3021 else if (type == R_RISCV_TPREL_HI20
3022 || type == R_RISCV_TPREL_ADD
3023 || type == R_RISCV_TPREL_LO12_I
3024 || type == R_RISCV_TPREL_LO12_S)
3025 relax_func = _bfd_riscv_relax_tls_le;
3029 /* Only relax this reloc if it is paired with R_RISCV_RELAX. */
3030 if (i == sec->reloc_count - 1
3031 || ELFNN_R_TYPE ((rel + 1)->r_info) != R_RISCV_RELAX
3032 || rel->r_offset != (rel + 1)->r_offset)
3035 /* Skip over the R_RISCV_RELAX. */
3038 else if (type == R_RISCV_ALIGN)
3039 relax_func = _bfd_riscv_relax_align;
3043 data->relocs = relocs;
3045 /* Read this BFD's contents if we haven't done so already. */
3046 if (!data->this_hdr.contents
3047 && !bfd_malloc_and_get_section (abfd, sec, &data->this_hdr.contents))
3050 /* Read this BFD's symbols if we haven't done so already. */
3051 if (symtab_hdr->sh_info != 0
3052 && !symtab_hdr->contents
3053 && !(symtab_hdr->contents =
3054 (unsigned char *) bfd_elf_get_elf_syms (abfd, symtab_hdr,
3055 symtab_hdr->sh_info,
3056 0, NULL, NULL, NULL)))
3059 /* Get the value of the symbol referred to by the reloc. */
3060 if (ELFNN_R_SYM (rel->r_info) < symtab_hdr->sh_info)
3062 /* A local symbol. */
3063 Elf_Internal_Sym *isym = ((Elf_Internal_Sym *) symtab_hdr->contents
3064 + ELFNN_R_SYM (rel->r_info));
3065 reserve_size = (isym->st_size - rel->r_addend) > isym->st_size
3066 ? 0 : isym->st_size - rel->r_addend;
3068 if (isym->st_shndx == SHN_UNDEF)
3069 sym_sec = sec, symval = sec_addr (sec) + rel->r_offset;
3072 BFD_ASSERT (isym->st_shndx < elf_numsections (abfd));
3073 sym_sec = elf_elfsections (abfd)[isym->st_shndx]->bfd_section;
3074 if (sec_addr (sym_sec) == 0)
3076 symval = sec_addr (sym_sec) + isym->st_value;
3082 struct elf_link_hash_entry *h;
3084 indx = ELFNN_R_SYM (rel->r_info) - symtab_hdr->sh_info;
3085 h = elf_sym_hashes (abfd)[indx];
3087 while (h->root.type == bfd_link_hash_indirect
3088 || h->root.type == bfd_link_hash_warning)
3089 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3091 if (h->plt.offset != MINUS_ONE)
3092 symval = sec_addr (htab->elf.splt) + h->plt.offset;
3093 else if (h->root.u.def.section->output_section == NULL
3094 || (h->root.type != bfd_link_hash_defined
3095 && h->root.type != bfd_link_hash_defweak))
3098 symval = sec_addr (h->root.u.def.section) + h->root.u.def.value;
3100 if (h->type != STT_FUNC)
3102 (h->size - rel->r_addend) > h->size ? 0 : h->size - rel->r_addend;
3103 sym_sec = h->root.u.def.section;
3106 symval += rel->r_addend;
3108 if (!relax_func (abfd, sec, sym_sec, info, rel, symval,
3109 max_alignment, reserve_size, again))
3116 if (relocs != data->relocs)
3123 # define PRSTATUS_SIZE 0 /* FIXME */
3124 # define PRSTATUS_OFFSET_PR_CURSIG 12
3125 # define PRSTATUS_OFFSET_PR_PID 24
3126 # define PRSTATUS_OFFSET_PR_REG 72
3127 # define ELF_GREGSET_T_SIZE 128
3128 # define PRPSINFO_SIZE 128
3129 # define PRPSINFO_OFFSET_PR_PID 16
3130 # define PRPSINFO_OFFSET_PR_FNAME 32
3131 # define PRPSINFO_OFFSET_PR_PSARGS 48
3133 # define PRSTATUS_SIZE 376
3134 # define PRSTATUS_OFFSET_PR_CURSIG 12
3135 # define PRSTATUS_OFFSET_PR_PID 32
3136 # define PRSTATUS_OFFSET_PR_REG 112
3137 # define ELF_GREGSET_T_SIZE 256
3138 # define PRPSINFO_SIZE 136
3139 # define PRPSINFO_OFFSET_PR_PID 24
3140 # define PRPSINFO_OFFSET_PR_FNAME 40
3141 # define PRPSINFO_OFFSET_PR_PSARGS 56
3144 /* Support for core dump NOTE sections. */
3147 riscv_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3149 switch (note->descsz)
3154 case PRSTATUS_SIZE: /* sizeof(struct elf_prstatus) on Linux/RISC-V. */
3156 elf_tdata (abfd)->core->signal
3157 = bfd_get_16 (abfd, note->descdata + PRSTATUS_OFFSET_PR_CURSIG);
3160 elf_tdata (abfd)->core->lwpid
3161 = bfd_get_32 (abfd, note->descdata + PRSTATUS_OFFSET_PR_PID);
3165 /* Make a ".reg/999" section. */
3166 return _bfd_elfcore_make_pseudosection (abfd, ".reg", ELF_GREGSET_T_SIZE,
3167 note->descpos + PRSTATUS_OFFSET_PR_REG);
3171 riscv_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3173 switch (note->descsz)
3178 case PRPSINFO_SIZE: /* sizeof(struct elf_prpsinfo) on Linux/RISC-V. */
3180 elf_tdata (abfd)->core->pid
3181 = bfd_get_32 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PID);
3184 elf_tdata (abfd)->core->program = _bfd_elfcore_strndup
3185 (abfd, note->descdata + PRPSINFO_OFFSET_PR_FNAME, 16);
3188 elf_tdata (abfd)->core->command = _bfd_elfcore_strndup
3189 (abfd, note->descdata + PRPSINFO_OFFSET_PR_PSARGS, 80);
3193 /* Note that for some reason, a spurious space is tacked
3194 onto the end of the args in some (at least one anyway)
3195 implementations, so strip it off if it exists. */
3198 char *command = elf_tdata (abfd)->core->command;
3199 int n = strlen (command);
3201 if (0 < n && command[n - 1] == ' ')
3202 command[n - 1] = '\0';
3208 /* Set the right mach type. */
3210 riscv_elf_object_p (bfd *abfd)
3212 /* There are only two mach types in RISCV currently. */
3213 if (strcmp (abfd->xvec->name, "elf32-littleriscv") == 0)
3214 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv32);
3216 bfd_default_set_arch_mach (abfd, bfd_arch_riscv, bfd_mach_riscv64);
3222 #define TARGET_LITTLE_SYM riscv_elfNN_vec
3223 #define TARGET_LITTLE_NAME "elfNN-littleriscv"
3225 #define elf_backend_reloc_type_class riscv_reloc_type_class
3227 #define bfd_elfNN_bfd_reloc_name_lookup riscv_reloc_name_lookup
3228 #define bfd_elfNN_bfd_link_hash_table_create riscv_elf_link_hash_table_create
3229 #define bfd_elfNN_bfd_reloc_type_lookup riscv_reloc_type_lookup
3230 #define bfd_elfNN_bfd_merge_private_bfd_data \
3231 _bfd_riscv_elf_merge_private_bfd_data
3233 #define elf_backend_copy_indirect_symbol riscv_elf_copy_indirect_symbol
3234 #define elf_backend_create_dynamic_sections riscv_elf_create_dynamic_sections
3235 #define elf_backend_check_relocs riscv_elf_check_relocs
3236 #define elf_backend_adjust_dynamic_symbol riscv_elf_adjust_dynamic_symbol
3237 #define elf_backend_size_dynamic_sections riscv_elf_size_dynamic_sections
3238 #define elf_backend_relocate_section riscv_elf_relocate_section
3239 #define elf_backend_finish_dynamic_symbol riscv_elf_finish_dynamic_symbol
3240 #define elf_backend_finish_dynamic_sections riscv_elf_finish_dynamic_sections
3241 #define elf_backend_gc_mark_hook riscv_elf_gc_mark_hook
3242 #define elf_backend_gc_sweep_hook riscv_elf_gc_sweep_hook
3243 #define elf_backend_plt_sym_val riscv_elf_plt_sym_val
3244 #define elf_backend_grok_prstatus riscv_elf_grok_prstatus
3245 #define elf_backend_grok_psinfo riscv_elf_grok_psinfo
3246 #define elf_backend_object_p riscv_elf_object_p
3247 #define elf_info_to_howto_rel NULL
3248 #define elf_info_to_howto riscv_info_to_howto_rela
3249 #define bfd_elfNN_bfd_relax_section _bfd_riscv_relax_section
3251 #define elf_backend_init_index_section _bfd_elf_init_1_index_section
3253 #define elf_backend_can_gc_sections 1
3254 #define elf_backend_can_refcount 1
3255 #define elf_backend_want_got_plt 1
3256 #define elf_backend_plt_readonly 1
3257 #define elf_backend_plt_alignment 4
3258 #define elf_backend_want_plt_sym 1
3259 #define elf_backend_got_header_size (ARCH_SIZE / 8)
3260 #define elf_backend_want_dynrelro 1
3261 #define elf_backend_rela_normal 1
3262 #define elf_backend_default_execstack 0
3264 #include "elfNN-target.h"